查询

Band.where(name: "Depeche Mode")
#   => #<Mongoid::Criteria
#   selector: {"name"=>"Depeche Mode"}
#   options:  {}
#   class:    Band
#   embedded: false>
# Equivalent to:
Band.where("name" => "Depeche Mode")

Band.where(founded: {'$gt' => 1980})
# => #<Mongoid::Criteria
#   selector: {"founded"=>{"$gt"=>1980}}
#   options:  {}
#   class:    Band
#   embedded: false>
# Equivalent to:
Band.where('founded' => {'$gt' => 1980})

Band.where(:founded.gt => 1980)
# => #<Mongoid::Criteria
#   selector: {"founded"=>{"$gt"=>1980}}
#   options:  {}
#   class:    Band
#   embedded: false>

Band.where(name: 2020, founded: "2020")
#   => #<Mongoid::Criteria
#   selector: {"name"=>"2020", "founded"=>2020}
#   options:  {}
#   class:    Band
#   embedded: false>

Band.where(founded: Mongoid::RawValue("2020"))
# => #<Mongoid::Criteria
#   selector: {"founded"=>"2020"}
#   options:  {}
#   class:    Band
#   embedded: false>

Band.where(name: 'Astral Projection')
#   => #<Mongoid::Criteria
#   selector: {"n"=>"Astral Projection"}
#   options:  {}
#   class:    Band
#   embedded: false>

Band.where(id: '5ebdeddfe1b83265a376a760')
# => #<Mongoid::Criteria
#   selector: {"_id"=>BSON::ObjectId('5ebdeddfe1b83265a376a760')}
#   options:  {}
#   class:    Band
#   embedded: false>

Band.where(name: 1).where(name: 2).selector
# => {"name"=>"1", "$and"=>[{"name"=>"2"}]}
Band.where(name: 1).or(name: 2).selector
# => {"$or"=>[{"name"=>"1"}, {"name"=>"2"}]}

# or joins the two conditions
Band.where(name: 'Sun').or(label: 'Trust').selector
# => {"$or"=>[{"name"=>"Sun"}, {"label"=>"Trust"}]}
# or applies only to the first condition, the second condition is added
# to the top level as $and
Band.or(name: 'Sun').where(label: 'Trust').selector
# => {"$or"=>[{"name"=>"Sun"}], "label"=>"Trust"}
# Same as previous example - where and and are aliases
Band.or(name: 'Sun').and(label: 'Trust').selector
# => {"$or"=>[{"name"=>"Sun"}], "label"=>"Trust"}
# Same operator can be stacked any number of times
Band.or(name: 'Sun').or(label: 'Trust').selector
# => {"$or"=>[{"name"=>"Sun"}, {"label"=>"Trust"}]}
# The label: Foo condition is added to the top level as $and
Band.where(name: 'Sun').or(label: 'Trust').where(label: 'Foo').selector
# => {"$or"=>[{"name"=>"Sun"}, {"label"=>"Trust"}], "label"=>"Foo"}

Band.where(label: 'Trust in Trance').and(name: 'Astral Projection').selector
# => {"label"=>"Trust in Trance Records", "name"=>"Astral Projection"}
Band.where(name: /Best/).and(name: 'Astral Projection').selector
# => {"name"=>/Best/, "$and"=>[{"name"=>"Astral Projection"}]}

Band.where(name: /Best/).or(name: 'Astral Projection')
# => {"$or"=>[{"name"=>/Best/}, {"name"=>"Astral Projection"}]}
Band.where(name: /Best/).and(name: 'Astral Projection').
  or(Band.where(label: /Records/)).and(label: 'Trust').selector
# => {"$or"=>[{"name"=>/Best/, "$and"=>[{"name"=>"Astral Projection"}]}, {"label"=>/Records/}], "label"=>"Trust"}

Band.where(name: /Best/).or(name: 'Astral Projection').
  or(Band.where(label: /Records/)).selector
# => {"$or"=>[{"name"=>/Best/}, {"name"=>"Astral Projection"}, {"label"=>/Records/}]}

Band.where(label: /Trust/).any_of({name: 'Astral Projection'}, {name: /Best/})
# => {"label"=>/Trust/, "$or"=>[{"name"=>"Astral Projection"}, {"name"=>/Best/}]}

Band.where(label: /Trust/).any_of({name: 'Astral Projection'})
# => {"label"=>/Trust/, "name"=>"Astral Projection"}

Band.where(label: /Trust/).none_of({name: 'Astral Projection'}, {name: /Best/})
# => {"label"=>/Trust/, "$nor"=>[{"name"=>"Astral Projection"}, {"name"=>/Best/}]}

# not negates subsequent where
Band.not.where(name: 'Best').selector
# => {"name"=>{"$ne"=>"Best"}}
# The second where is added as $and
Band.not.where(name: 'Best').where(label: /Records/).selector
# => {"name"=>{"$ne"=>"Best"}, "label"=>/Records/}
# not negates its argument
Band.not(name: 'Best').selector
# => {"name"=>{"$ne"=>"Best"}}

# Simple condition
Band.not(name: /Best/).selector
# => {"name"=>{"$not"=>/Best/}}
# Complex conditions
Band.where(name: /Best/).not(name: 'Astral Projection').selector
# => {"name"=>/Best/, "$and"=>[{"$nor"=>[{"name"=>"Astral Projection"}]}]}
# Symbol operator syntax
Band.not(:name.ne => 'Astral Projection')
# => #<Mongoid::Criteria
#   selector: {"$and"=>[{"$nor"=>[{"name"=>{"$ne"=>"Astral Projection"}}]}]}
#   options:  {}
#   class:    Band
#   embedded: false>

Band.in(name: ['a']).override.in(name: ['b'])
=> #<Mongoid::Criteria
  selector: {"name"=>{"$in"=>["b"]}}
  options:  {}
  class:    Band
  embedded: false>
Band.in(name: ['a', 'b']).intersect.in(name: ['b', 'c'])
=> #<Mongoid::Criteria
  selector: {"name"=>{"$in"=>["b"]}}
  options:  {}
  class:    Band
  embedded: false>
Band.in(name: ['a']).union.in(name: ['b'])
=> #<Mongoid::Criteria
  selector: {"name"=>{"$in"=>["a", "b"]}}
  options:  {}
  class:    Band
  embedded: false>

Band.in(name: ['a']).union.ne(name: 'c').in(name: ['b'])
=> #<Mongoid::Criteria
  selector: {"name"=>{"$in"=>["a"], "$ne"=>"c"}, "$and"=>[{"name"=>{"$in"=>["b"]}}]}
  options:  {}
  class:    Band
  embedded: false>

Band.in(foo: ['a']).union.where(foo: {'$in' => 'b'})
=> #<Mongoid::Criteria
  selector: {"foo"=>{"$in"=>["a"]}, "$and"=>[{"foo"=>{"$in"=>"b"}}]}
  options:  {}
  class:    Band
  embedded: false>

Band.where(foo: {'$in' => ['a']}).union.in(foo: ['b'])
=> #<Mongoid::Criteria
  selector: {"foo"=>{"$in"=>["a", "b"]}}
  options:  {}
  class:    Band
  embedded: false>

Band.in(year: 1950..1960)
=> #<Mongoid::Criteria
  selector: {"year"=>{"$in"=>[1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960]}}
  options:  {}
  class:    Band
  embedded: false>

Band.in(year: 1950)
=> #<Mongoid::Criteria
  selector: {"year"=>{"$in"=>[1950]}}
  options:  {}
  class:    Band
  embedded: false>

class Band
  include Mongoid::Document
  field :name, type: String
  field :tours, type: Array
end
aerosmith = Band.create!(name: 'Aerosmith', tours: [
  {city: 'London', year: 1995},
  {city: 'New York', year: 1999},
])
Band.elem_match(tours: {city: 'London'}).to_a # => [aerosmith]

class Band
  include Mongoid::Document
  field :name, type: String
  embeds_many :tours
end
class Tour
  include Mongoid::Document
  field :city, type: String
  field :year, type: Integer
  embedded_in :band
end
dm = Band.create!(name: 'Depeche Mode')
aerosmith = Band.create!(name: 'Aerosmith')
Tour.create!(band: aerosmith, city: 'London', year: 1995)
Tour.create!(band: aerosmith, city: 'New York', year: 1999)
Band.elem_match(tours: {city: 'London'}).to_a # => [aerosmith]

class Tag
  include Mongoid::Document
  field :name, type: String
  recursively_embeds_many
end
root = Tag.create!(name: 'root')
sub1 = Tag.new(name: 'sub1', child_tags: [Tag.new(name: 'subsub1')])
root.child_tags << sub1
root.child_tags << Tag.new(name: 'sub2')
root.save!
Tag.elem_match(child_tags: {name: 'sub1'}).to_a # => [root]
root.child_tags.elem_match(child_tags: {name: 'subsub1'}).to_a # => [sub1]

class Band
  include Mongoid::Document
  field :name, type: String
  field :label, type: String
  embeds_many :tours
end
class Tour
  include Mongoid::Document
  field :city, type: String
  field :year, type: Integer
  embedded_in :band
end
band = Band.only(:name).first

band.label
#=> raises Mongoid::Errors::AttributeNotLoaded

band = Band.only(:name, 'tours.year').last
# => #<Band _id: 5c59afb1026d7c034dba46ac, name: "Aerosmith">
band.tours.first
# => #<Tour _id: 5c59afdf026d7c034dba46af, city: nil, year: 1995>

class Band
  include Mongoid::Document
  field :name, type: String
  has_and_belongs_to_many :managers
end
class Manager
  include Mongoid::Document
  has_and_belongs_to_many :bands
end
band = Band.create!(name: 'Astral Projection')
band.managers << Manager.new
Band.where(name: 'Astral Projection').only(:name).first.managers
# => []
Band.where(name: 'Astral Projection').only(:name, :manager_ids).first.managers
# => [#<Manager _id: 5c5dc2f0026d7c1730969843, band_ids: [BSON::ObjectId('5c5dc2f0026d7c1730969842')]>]

Band.without(:name)
# =>
# #<Mongoid::Criteria
#   selector: {}
#   options:  {:fields=>{"name"=>0}}
#   class:    Band
#   embedded: false>

Band.without(:name, :id)
# =>
# #<Mongoid::Criteria
#   selector: {}
#   options:  {:fields=>{"name"=>0}}
#   class:    Band
#   embedded: false>
Band.without(:name, :_id)
# =>
# #<Mongoid::Criteria
#   selector: {}
#   options:  {:fields=>{"name"=>0}}
#   class:    Band
#   embedded: false>

Band.limit(5)
# =>
# #<Mongoid::Criteria
#   selector: {}
#   options:  {:limit=>5}
#   class:    Band
#   embedded: false>

Band.skip(10)
# =>
# #<Mongoid::Criteria
#   selector: {}
#   options:  {:skip=>10}
#   class:    Band
#   embedded: false>

Band.batch_size(500)
# =>
# #<Mongoid::Criteria
#   selector: {}
#   options:  {:batch_size=>500}
#   class:    Band
#   embedded: false>

class Band
  include Mongoid::Document
  field :country, type: String
  field :genres, type: Array
  scope :english, ->{ where(country: "England") }
  scope :rock, ->{ where(:genres.in => [ "rock" ]) }
end
Band.english.rock # Get the English rock bands.

class Band
  include Mongoid::Document
  field :name, type: String
  field :country, type: String
  field :active, type: Boolean, default: true
  scope :named, ->(name){ where(name: name) }
  scope :active, ->{
    where(active: true) do
      def deutsch
        tap do |scope|
          scope.selector.store("origin" => "Deutschland")
        end
      end
    end
  }
end
Band.named("Depeche Mode") # Find Depeche Mode.
Band.active.deutsch # Find active German bands.

class Product
  include Mongoid::Document
  def self.fresh
    true
  end
  scope :fresh, ->{ where(fresh: true) }
end

class Band
  include Mongoid::Document
  field :name, type: String
  field :active, type: Boolean
  default_scope ->{ where(active: true) }
end
Band.each do |band|
  # All bands here are active.
end

class Band
  include Mongoid::Document
  field :name, type: String
  field :active, type: Boolean
  field :num_tours, type: Integer
  default_scope ->{ where(active: true, num_tours: {'$gt' => 1}) }
end
# active is set, num_tours is not set
Band.new # => #<Band _id: 5c3f7452ce4ef378295ca5f5, name: nil, active: true, num_tours: nil>

class Band
  include Mongoid::Document
  field :name, type: String
  field :active, type: Boolean, default: true
  default_scope ->{ where(active: false) }
end
Band.new # => #<Band _id: 5c3f74ddce4ef3791abbb088, name: nil, active: false>

class Band
  include Mongoid::Document
  field :name, type: String
  field :tags, type: Hash
  default_scope ->{ where('tags.foo' => 'bar') }
end
Band.create!
# => Created document: {"_id"=>BSON::ObjectId('632de48f3282a404bee1877b'), "tags.foo"=>"bar"}
Band.create!(tags: { 'foo' => 'bar' })
# => Created document: {"_id"=>BSON::ObjectId('632de4ad3282a404bee1877c'), "tags.foo"=>"bar", "tags"=>{"foo"=>"bar"}}
Band.all.to_a
# => [ #<Band _id: 632de4ad3282a404bee1877c, tags: {"foo"=>"bar"}> ]

Band.new.attribute
# => {"_id"=>BSON::ObjectId('632de97d3282a404bee1877d'), "tags.foo"=>"bar"}

Band.create!
# => Created document: {"_id"=>BSON::ObjectId('632de48f3282a404bee1877b'), "tags.foo"=>"bar"}
Band.where
# => #<Mongoid::Criteria
       selector: {"tags.foo"=>"bar"}
       options:  {}
       class:    Band
       embedded: false>
# This looks for something like: { tags: { "foo" => "bar" } }
Band.count
# => 0

class Band
  include Mongoid::Document
  field :name, type: String
  field :tags, type: Hash
  default_scope ->{ where('tags.foo' => {'$eq' => 'bar'}) }
end
Band.create!(tags: { hello: 'world' })
Band.create!(tags: { foo: 'bar' })
# does not add a "tags.foo" dotted attribute
Band.count
# => 1

Band.unscoped.where(name: "Depeche Mode")
Band.unscoped do
  Band.where(name: "Depeche Mode")
end

Band.unscoped.where(name: "Depeche Mode").scoped

class Label
  include Mongoid::Document
  embeds_many :bands
end
class Band
  include Mongoid::Document
  field :active, default: true
  embedded_in :label
  default_scope ->{ where(active: true) }
end
label.bands.push(band)
label.bands # [ band ]
band.update_attribute(:active, false)
label.bands # [ band ] Must reload.
label.reload.bands # []

class Band
  include Mongoid::Document
  field :country, type: String
  field :genres, type: Array
  scope :english, ->{ where(country: "England") }
end
criteria = Band.with_scope(Band.english) do
  Band.all
end
criteria
# =>
# #<Mongoid::Criteria
#   selector: {"country"=>"England"}
#   options:  {}
#   class:    Band
#   embedded: false>

class Band
  include Mongoid::Document
  field :name, type: String
  field :active, type: Boolean, default: true
  def self.active
    where(active: true)
  end
end
Band.active

Mongo::QueryCache.cache do
  # ...
end

begin
  Mongo::QueryCache.enabled = true
  # ...
ensure
  Mongo::QueryCache.enabled = false
end

Band.all.to_a
#=> Queries the database and caches the results
Band.first
#=> Queries the database again because of the sort

development:
  ...
  options:
    # Execute asynchronous queries using a global thread pool.
    async_query_executor: :global_thread_pool
    # Number of threads in the pool. The default is 4.
    # global_executor_concurrency: 4