Consultas

Sintaxe de campo

A sintaxe de query mais simples utiliza os hash Ruby básicos. As chaves podem ser símbolos ou strings e correspondem a nomes de campos em documentos MongoDB:

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

Sintaxe MQL

É possível especificar um operador de MQL em qualquer campo usando a sintaxe de hash:

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

Sintaxe do operador de símbolos

Os operadores MQL podem ser especificados como métodos em símbolos para o respectivo nome de campo, como segue:

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

Executar queries em campos definidos

Para consultar um campo, não é necessário adicionar o campo à definição da classe de modelo. No entanto, se um campo for definido na classe de modelo, o Mongoid forçará os valores de query a corresponderem aos tipos de campo definidos ao construir a query:

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

Queries por valores brutos

Se você quiser ignorar o comportamento de coerção de tipo de query do Mongoid e consultar diretamente o valor de tipo bruto no banco de dados, encapsule o valor de query em classe Mongoid::RawValue. Isso pode ser útil ao trabalhar com dados legados.

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

Aliases de campo

As queries levam em conta os nomes de campo de armazenamento e os aliases de campo:

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

Como os campos id e _id são aliases, qualquer um pode ser utilizado para queries:

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

Combinações do operador

A partir do Mongoid 7.1, os operadores lógicos (and, or, nor e not) foram alterados para ter a mesma semântica que os do ActiveRecord. Para obter a semântica de or como ela se comportou no Mongoid 7.0 e versões anteriores, use any_of , descrito abaixo.

Quando as condições são especificadas no mesmo campo várias vezes, todas as condições são adicionadas aos critérios:

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"}]}

any_of, none_of, nor e not comportam-se da mesma forma, com not produzindo diferentes formas de query como descrito abaixo.

Quando andoperadores lógicos, or e nor são usados, eles operam sobre os critérios construídos até aquele ponto e seu argumento. where tem o mesmo significado que and:

# 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"}

and Comportamento

O método and adicionará novas condições simples ao nível superior dos critérios, a menos que os critérios de recebimento já tenham uma condição nos respectivos campos, caso em que as condições serão combinadas com $and.

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"}]}

A partir do Mongoid 7.1, especificar vários critérios no mesmo campo com and combina todos os critérios assim especificados, enquanto em versões anteriores de condições Mongoid em um campo às vezes substituía condições previamente especificadas no mesmo campo, dependendo de qual forma de and foi usada.

or/nor Behavior _----------------------

or e nor produzem $or e $nor operadores MongoDB, respectivamente, usando o receptor e todos os argumentos como operandos. Por exemplo:

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"}

Se a única condição no receptor for outra or/nor, as novas condições são adicionadas à lista existente:

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

Use any_of para adicionar uma disjunção a um objeto Criteria e, ao mesmo tempo, manter todas as condições criadas até o momento.

any_of Comportamento

any_of adiciona uma disjunção construída de seus argumentos às condições existentes nos critérios. Por exemplo:

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

As condições são elevadas ao nível superior, se possível:

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

none_of Comportamento

none_of adiciona uma disjunção negativa ("nor") construída a partir de seus argumentos para as condições existentes nos critérios. Por exemplo:

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

not Comportamento

not método pode ser chamado sem argumentos, caso em que ele negará a próxima condição que é especificada. not também pode ser chamado com uma ou mais condições de hash ou objetos Criteria , que serão todos negados e adicionados aos critérios.

# 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"}}

# String negation - uses $ne
Band.not.where(name: 'Best').selector
# => {"name"=>{"$ne"=>"Best"}}
# Regexp negation - uses $not
Band.not.where(name: /Best/).selector
# => {"name"=>{"$not"=>/Best/}}

Da mesma forma que and, not negará condições individuais para critérios de campo simples. Para condições complexas e quando um campo já tem uma condição definida nele, uma vez que o servidor MongoDB só suporta o operador $not em uma base por campo em vez de globalmente, o Mongoid emula $not usando uma construção {'$and' => [{'$nor' => ...}]} :

# 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>

Se utilizar o not com arrays ou expressões regulares, note as advertências/limitações do $not estacionadas na documentação do servidor MongoDB.

Estratégias de fusão

O Mongoid oferece três estratégias de mesclagem:

• Substituir: a nova instância do operador substitui quaisquer condições existentes no mesmo campo usando o mesmo operador.

• Interseção: se já houver uma condição usando o mesmo operador no mesmo campo, os valores da condição existente serão cruzados com os valores da nova condição e o resultado será armazenado como o valor do operador.

• Unidade: se já houver uma condição usando o mesmo operador no mesmo campo, os valores da nova condição serão adicionados aos valores da condição existente e o resultado será armazenado como o valor do operador.

O seguinte trecho demonstra todas as estratégias, utilizando in como o operador de exemplo:

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>

A estratégia é solicitada ligando para override, intersect ou union em uma instância do Criteria. A estratégia solicitada se aplica ao próximo método de condição chamado na query. Se o próximo método de condição chamado não for compatível com estratégias de mesclagem, a estratégia será redefinida, conforme mostrado no exemplo a seguir:

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>

Como ne não oferece suporte a estratégias de mesclagem, a estratégia union foi ignorada e redefinida e, quando in foi invocado pela segunda vez, não havia nenhuma estratégia ativa.

Métodos de operador suportados

Os métodos de operador a seguir oferecem suporte a estratégias de mesclagem:

• all

• in

• nin

O conjunto de métodos pode ser expandido em futuras versões do Mongoid. Para compatibilidade futura, invoque um método estratégico somente quando a próxima chamada de método for um operador que ofereça suporte a estratégias de mesclagem.

Observe que, no momento, as estratégias de mesclagem são aplicadas somente quando as condições são adicionadas por meio dos métodos designados. No exemplo a seguir, a estratégia de mesclagem não é aplicada porque a segunda condição é adicionada por meio de where e não por meio de in:

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

Esse comportamento pode mudar em uma versão futura do Mongoid e não deve ser considerado.

Por outro lado, não importa como a query existente foi criada quando um método de operador de suporte à estratégia de mesclagem é invocado. No exemplo a seguir, a primeira condição foi adicionada por meio where mas o mecanismo de estratégia ainda se aplica:

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

Expansão de valor do operador

Todos os métodos de operador que suportam estratégias de mesclagem usam Array como seu tipo de valor. O Mongoid expande os tipos compatíveis com Array, como um Range, quando são utilizados com estes métodos de operador:

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>

Além disso, o Mongoid historicamente envolveu valores nãoArray em arrays, como demonstra o exemplo a seguir:

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

elem_match

Esse correspondente localiza documentos com campos de array em que um dos valores de array corresponde a todas as condições. Por exemplo:

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]

elem_match também funciona com associações incorporadas:

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]

elem_match não funciona com associações não incorporadas porque o MongoDB não tem participações - as condições seriam adicionadas à coleção que é a origem de uma associação não incorporada em vez da coleção do alvo da associação.c

elem_match também pode ser usado com associações recursivamente incorporadas, como mostra o exemplo a seguir:

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]

only

O método only recupera somente os campos especificados do banco de dados. Essa operação às vezes é chamada de "projeção".

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

Tentar referenciar atributos que não foram carregados resulta em Mongoid::Errors::AttributeNotLoaded.

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

Embora o Mongoid atualmente permita a gravação em atributos que não foram carregados, essas gravações não serão mantidas (MONGOID-4701) e, portanto, devem ser evitadas.

only também pode ser usado com associações incorporadas:

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

band = Band.only(:tours, 'tours.year').last

band = Band.only('tours.year').last

only pode ser especificado com associações referenciadas (has_one, has_many, has_and_belongs_to_many), mas é atualmente ignorado para associações referenciadas - todos os campos de associações referenciadas serão carregados (MONGOID-4704).

Observe que, se um documento tiver has_one ou has_and_belongs_to_many associações, os campos com chaves estrangeiras deverão ser incluídos na lista de atributos carregados com only para que essas associações sejam carregadas. Por exemplo:

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')]>]

without

O oposto de only, without faz com que os campos especificados sejam omitidos:

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

Como o Mongoid requer o campo _id para várias operações, ele (bem como seu alias id ) não pode ser omitido via without:

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>

limit

limit Define o número total de documentos a serem devolvidos por uma query:

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

skip

skip (alias: offset) define o número de resultados da query a ignorar antes de retornar documentos. O valor limit, se especificado, será aplicado após os documentos serem ignorados. Ao realizar a paginação, recomenda-se que skip seja combinado com a ordenação para garantir resultados consistentes.

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

batch_size

Ao executar queries grandes ou ao iterar sobre os resultados das queries com um método enumerador como Criteria#each, o Mongoid usa automaticamente o comando getMore do MongoDB para carregar os resultados em lotes. O batch_size padrão é 1000, mas você pode defini-lo explicitamente:

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

Escopos nomeados

Os escopos nomeados são simplesmente critérios definidos na carga de classe que são referenciados por um nome fornecido. Assim como os critérios normais, eles são preguiçosos e acorrentados.

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.

Escopos nomeados podem levar procs e blocos para aceitar parâmetros ou estender a funcionalidade.

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.

Por padrão, o Mongoid permite definir um escopo que sombrearia um método de classe existente, como mostra o exemplo a seguir:

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

Para que o Mongoid gere um erro quando um escopo substituiria um método de classe existente, defina a opção de configuração scope_overwrite_exception como true.

Escopos padrão

Os escopos padrão podem ser úteis quando você se encontra aplicando os mesmos critérios à maioria das queries e deseja especificar esses critérios como padrão. Escopos padrão são procs que retornam objetos de critérios.

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

Especificar um escopo padrão também inicializa os campos de novos modelos para os valores fornecidos no escopo padrão, se os valores forem literais simples:

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>

Observe que, se um valor padrão for fornecido na definição de campo e no escopo padrão, o valor no escopo padrão terá precedência:

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>

Como um escopo padrão inicializa campos em novos modelos conforme descrito acima, definir um escopo padrão com uma chave pontilhada e um valor literal simples, embora possível, não é recomendado:

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"}> ]

O Mongoid 8 permite que chaves pontilhadas sejam usadas no Mongoid e, ao criar um documento, o escopo é adicionado como uma chave pontilhada nos atributos:

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

Por outro lado, ao fazer query, o Mongoid procura um documento incorporado:

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

Uma solução alternativa é definir o escopo padrão como uma query complexa:

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

Você pode dizer ao Mongoid que não aplique o escopo padrão usando unscoped, que pode ser embutido ou ter um bloco.

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

Você também pode dizer ao Mongoid para aplicar explicitamente o escopo padrão novamente mais tarde para garantir que ele esteja sempre lá.

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

Se estiver usando um escopo padrão em um modelo que faz parte de uma associação, será necessário recarregar a associação para que o escopo seja reaplicado. É importante observar que, se você alterar um valor de um documento na associação, isso afetará sua visibilidade dentro da associação com escopo.

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 :name
  field :active
  field :touring
  default_scope ->{ where(active: true) }
end
Band.where(name: 'Infected Mushroom')
# =>
# #<Mongoid::Criteria
#   selector: {"active"=>true, "name"=>"Infected Mushroom"}
#   options:  {}
#   class:    Band
#   embedded: false>
Band.where(name: 'Infected Mushroom').or(touring: true)
# =>
# #<Mongoid::Criteria
#   selector: {"$or"=>[{"active"=>true, "name"=>"Infected Mushroom"}, {"touring"=>true}]}
#   options:  {}
#   class:    Band
#   embedded: false>
Band.or(touring: true)
# =>
# #<Mongoid::Criteria
#   selector: {"$or"=>[{"active"=>true}, {"touring"=>true}]}
#   options:  {}
#   class:    Band
#   embedded: false>

Substituição de escopo padrão de tempo de execução

Você pode usar o método with_scope para alterar o escopo padrão em um bloco no tempo de execução:

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>

Métodos de classe

Métodos de classe em modelos que retornam objetos de critérios também são tratados como escopos, e também podem ser encadeados.

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

Habilitando cache de query

O cache de query pode ser habilitado usando o namespace do driver ou o namespace do Mongoid.

Habilitando o cache de query automaticamente

O MongoDB Ruby Driver fornece middleware para ativar automaticamente o cache de query para solicitações web do Rack e execuções de tarefas do ActiveJob. Consulte a seção Query Cache Rack Middleware na página de configuração para obter instruções.

Observe que o Query Cache Middleware não se aplica ao código executado fora de solicitações da web e/ou trabalhos.

Habilitando cache de query manualmente

Para ativar o cache de query manualmente para um segmento de código, use:

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

O Cache de Query também pode ser ativado e desativado explicitamente, embora seja recomendável usar o formulário de bloqueio descrito acima:

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

Armazenando em cache o resultado de #first

A chamada do método first em uma classe de modelo impõe uma classificação crescente pelo campo _id na query subjacente. Isso pode produzir um comportamento inesperado com o cache de query.

Por exemplo, ao chamar all em uma classe de modelo e depois first, seria de se esperar que a segunda query usasse os resultados em cache da primeira. No entanto, devido à classificação imposta na segunda query, ambos os métodos farão a query do banco de dados e armazenarão separadamente seus resultados em cache.

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

Para usar os resultados em cache, ligue para all.to_a.first na classe de modelo.

Configuração da execução de query assíncrona

As queries assíncronas são desativadas por padrão. Quando as queries assíncronas estiverem desativadas, load_async executará uma query imediatamente na thread atual, bloqueando conforme necessário. Portanto, chamando load_async nos critérios, nesse caso, é praticamente o equivalente de chamar to_a para forçar a execução da query.

Para habilitar a execução de query assíncrona, as seguintes opções de configuração devem ser definidas:

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