Classe: Mongoid::Criteria

Herda:
Objeto
  • Objeto
mostrar tudo
Inclui:
Enumerável, Inspecionável , Mongoid::Clients::Options, Mongoid::Clients::Sessions, Contextual, Localizável, Includable, Ordenadopor , Modificável , Opções, Queryable , Escopo
Definido em:
lib/mongoid/criteria.rb,
lib/mongoid/criteria/options.rb,
lib/mongoid/criteria/findable.rb,
lib/mongoid/criteria/scopable.rb,
lib/mongoid/criteria/queryable.rb,
lib/mongoid/criteria/includable.rb,
lib/mongoid/criteria/modavailable.rb,
lib/mongoid/criteria/permission.rb,
lib/mongoid/criteria/translator.rb,
lib/mongoid/criteria/marshable.rb,
lib/mongoid/criteria/queryable/key.rb,
lib/mongoid/criteria/queryable/smash.rb,
lib/mongoid/criteria/queryable/options.rb,
lib/mongoid/criteria/queryable/optional.rb,
lib/mongoid/criteria/queryable/pipeline.rb,
lib/mongoid/criteria/queryable/selector.rb,
lib/mongoid/criteria/queryable/storable.rb,
lib/mongoid/criteria/queryable/macroable.rb,
lib/mongoid/criteria/queryable/mergeable.rb,
lib/mongoid/criteria/queryable/aggregable.rb,
lib/mongoid/criteria/queryable/expandable.rb,
lib/mongoid/criteria/queryable/selectable.rb,
lib/mongoid/criteria/queryable/extensions/set.rb,
lib/mongoid/criteria/queryable/extensions/date.rb,
lib/mongoid/criteria/queryable/extensions/hash.rb,
lib/mongoid/criteria/queryable/extentions/time.rb,
lib/mongoid/criteria/queryable/extentions/array.rb,
lib/mongoid/criteria/queryable/extensions/range.rb,
lib/mongoid/criteria/queryable/extensão/ objeto.rb,
lib/mongoid/criteria/queryable/extensions/regexp.rb,
lib/mongoid/criteria/queryable/extensions/string.rb,
lib/mongoid/criteria/queryable/extensions/symbol.rb,
lib/mongoid/criteria/queryable/extensions/boolean.rb,
lib/mongoid/criteria/queryable/extentions/numeric.rb,
lib/mongoid/criteria/queryable/extentions/date_time.rb,
lib/mongoid/criteria/queryable/extentions/nil_class.rb,
lib/mongoid/criteria/queryable/extentions/big_decimal.rb,
lib/mongoid/criteria/queryable/extensions/time_with_zone.rb

Visão geral

A classe Criteria é o objeto principal necessário no Mongoid para recuperar objetos do banco de banco de dados. É um DSL que essencialmente define o seletor e as opções de argumentos que são passados para uma Mongo::Collection no driver Ruby. Cada método no Criteria retorna a si mesmo para eles podem ser encadeados a fim de criar um critério legível a ser executado no banco de banco de dados.

Definido sob namespace

Módulos: Localizável, Includable, Secundável, Modificável, Opções, Permissão, Queryable, Escopável, Tradutor

Colapsode resumo constante

ALlowed_FROM_HASH_METHODS =

Métodos permitidos para from_hash para evitar a execução arbitrária do método. Somente métodos de construção de query são permitidos, não métodos de execução ou modificação.

%i[
  todos all_in all_of e a any_in any_of asc crescente
  batch_size entre
  agrupamento comment cursor_type
  desc descendentes
  elem_match eq existe Extras
  geo_spatial grupo, grupo gt gte
  dica
  Em inclui
  limit lt lte
  max_istance max_scan max_time_ms mesclar mod
  ne perto near_sphere nin no_timeout none none_of nem não not_in
  offset Apenas ou order order_by
  projeto, projeto
  bruto ler reordenar
  com escopo ignorar fatia snapshot
  text_search type
  sem escopo Unwind
  ONDE with_size with_type sem
].congelar
Verificar =

Array estática usada para verificar com o método ausente - só precisamos instanciar uma vez.

[]

Recolhimento do Resumo do atributo de instância

Atributos incluídos de Modificável

#create_attrs, #create_attrs Atributos adicionais a serem adicionados ao documento após a criação.

Atributos incluídos no Queryable

#aliases, #aliases Os aliases., #serializers, #serializers Os serializadores.

Atributos incluídos de Queryable::Optional

#options, #options As opções de query.

Atributos incluídos de Queryable::aggregable

#aggregating, #aggregating Sinalizador se estamos ou não agregando., #pipeline, #pipeline O agregação pipeline.

Atributos incluídos de Queryable::Mergeable

#strategy, #strategy O nome da estratégia atual.

Recolhimento do Resumo do método de classe

Recolhimento do Resumo do método de instância

Métodos incluídos do Mongoid::Clients::Sessions

incluído

Métodos incluídos do Mongoid::Clients::Options

#collection, #collection_name, #mongo_client, #persistence_context, #persistence_context?, #com

Métodos incluídos no Scoped

#apply_default_scope, #apply_scope, #remove_scoping, #scoped, #scoped?, #scoping_options, #scoping_options=, #unscoped, #unscoped?, #with_default_scope

Métodos incluídos do Modificável

#build, #create, #create !, #create_with, #find_or_create_by, #find_or_create_by!, #find_or_initialize_by, #first_or_create, #first_or_create!, #first_or_initialize

Métodos incluídos noMarshable

.

Métodos incluídos de Includable

#eager_load, #includes, #incluses, #incluses=, #use_lookup?

Métodos incluídos no Findable

#execute_or_raise, #for_ids, #multiple_from_db

Métodos incluídos do Queryable

#to_mql

Métodos incluídos do Queryable::Optional

#ascending, #batch_size, #collation, #comment, #cursor_type, #descending, forwardables, #hint, #limit, #max_scan, #max_time_ms, #no_timeout, #order_by, #reorder, #skip, #slice, #snapshot

Métodos incluídos do Queryable::macroable

#key

Métodos incluídos em Selectable

#atomic_selector

Métodos incluídos do Queryable::Aggregable

#aggregating?, #group, #project, #unwind

Métodos incluídos do Queryable::Mergeable

#and_with_operator, #intersect, #override, #reset_strategies!, # união

Métodos incluídos do Queryable::Storable

#add_field_expression, #add_logical_operator_expression, #add_one_expression, #add_operator_expression

Métodos incluídos do Contexto

#context, #load_async

Detalhes do construtor

#initialize(klass) ⇒ Criteria

Inicialize os novos critérios.

Exemplos:

Inicie os novos critérios.

Criteria.new(Band)

Parâmetros:

  • classe (Classe) —

    A classe modelo.



323
324
325
326
327
328
 
# Arquivo 'lib/mongoid/criteria.rb', linha 323

def inicializar(classe)
  @klass = classe
  @embedded = nada
  @none = nada
  classe ? super(classe.aliased_fields, classe.Campos, classe.relações, classe.aliased_associations) : super({}, {}, {}, {})
end

Manipulação de métodos dinâmicos

Esta classe lida com métodos dinâmicos através do método method_missing

#method_missing ➤ Object (private)

Usado para encadear escopos Criteria no for dos métodos de classe no Document o qual os critérios são.

Exemplos:

Método de manuseio ausente.

criteria.method_missing(:name)

Parâmetros:

  • name (Símbolo) —

    O nome do método.

  • *args (Objeto...) —

    Os argumentos.

Retorna:

  • (Objeto) —

    O resultado da chamada de método.



619
620
621
622
623
624
625
626
627
628
629
 
# Arquivo 'lib/mongoid/criteria.rb', linha 619

ruby2_keywords def method_missing(name, *Args, &noum: bloco ; verb: bloquear)
  se classe.respond_to?(name)
    classe.enviar(:with_scope, auto) fazer
      classe.enviar(name, *Args, &noum: bloco ; verb: bloquear)
    end
  elsif Verificar.respond_to?(name)
    entradas.enviar(name, *Args, &noum: bloco ; verb: bloquear)
  mais
    super
  end
end

Detalhes do atributo da instância

#_raw_results ⇒ nil | Hash

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Um assistente interno para obter/definir o sinalizador "raw" em um determinado objeto de critérios.

Retorna:

  • (nil | Hash) —

    Se definido, é um hash com duas chaves, :raw e :typed, que descrevem se os resultados brutos devem ser retornados e se devem ser digitados.



244
245
246
 
# Arquivo 'lib/mongoid/criteria.rb', linha 244

def _raw_results
  @_raw_results
end

#associação ➤ Objeto

Retorna o valor da associação de atributo.



100
101
102
 
# Arquivo 'lib/mongoid/criteria.rb', linha 100

def associação
  @association
end

#documents ⇒ Array<Document>

Obtenha os documentos a partir dos critérios incorporados.

Exemplos:

Pegue os documentos.

criteria.documents

Retorna:



183
184
185
 
# Arquivo 'lib/mongoid/criteria.rb', linha 183

def documentos
  @documents ||= []
end

#Objeto ➤ incorporado

Retorna o valor do atributo incorporado.



100
101
102
 
# Arquivo 'lib/mongoid/criteria.rb', linha 100

def incorporado
  @embedded
end

#klass ⇒ Object

Retorna o valor do atributo klass.



100
101
102
 
# Arquivo 'lib/mongoid/criteria.rb', linha 100

def classe
  @klass
end

#parent_document ➤ Objeto

Retorna o valor do atributo parent_document.



100
101
102
 
# Arquivo 'lib/mongoid/criteria.rb', linha 100

def parent_document
  @parent_document
end

Detalhes do método de classe

.from_hash(hash) ➤ Critérios

Obsoleto.

Este método é preterido e será removido em uma versão futura.

Converta o hash fornecido em um critério. Irá iterar sobre cada chave no hash que deve corresponder a um método permitido em um objeto de critérios . O hash pode incluir uma chave "klass" que especifica a classe de model para os critérios.

Exemplos:

Converta o hash em um critério.

Criteria.from_hash({ klass: Band, where: { name: "Depeche Mode" })

Parâmetros:

  • hash (Hash) —

    O hash a ser convertido.

Retorna:

Aumenta:

  • (ArgumentError) —

    Se um método não for permitido em from_hash.



81
82
83
84
85
86
87
88
89
90
91
92
 
# Arquivo 'lib/mongoid/criteria.rb', linha 81

def from_hash(hash)
  critério = critério.Novo(hash.excluir(:klass) || hash.excluir('klass'))
  hash.cada_pair fazer |Método, Args|
    method_sym = Método.to_sym
    a menos que Allowed_FROM_HASH_METHODS.incluir?(method_sym)
      aumentar ArgumentError, "Método'#{método}' não é permitido em from_hash"
    end

    critério = critério.public_send(method_sym, Args)
  end
  critério
end

Detalhes do método de instância

#==(outro) ➤ verdadeiro | false

Observação:

Isso forçará um carregamento de banco de dados de dados quando chamado se um enumerável for passado.

Retorna verdadeiro se o Enumerable ou Criteria fornecido for igual aos resultados deste Criteria ou aos próprios critérios.

Parâmetros:

  • Outro (Objeto) —

    O outro Enumerable ou Criteria para comparar.

Retorna:

  • (verdadeiro | falso) —

    Se os objetos forem iguais.



110
111
112
113
114
 
# Arquivo 'lib/mongoid/criteria.rb', linha 110

def ==(Outro)
  Método super se Outro.respond_to?(:selector)

  entradas == Outro
end

#_enumerable_find ⇒ Object

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro. 



24
 
# Arquivo 'lib/mongoid/criteria.rb', linha 24

Alias _enumerable_find find

#_findable_find ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro. 



31
 
# Arquivo 'lib/mongoid/criteria.rb', linha 31

Alias _findable_find find

#as_json(options = nil) ⇒ String

Necessário para obter corretamente um critério de volta como JSON

Exemplos:

Obtenha os critérios como JSON.

Person.where(:title => "Sir").as_json

Parâmetros:

  • opções (Hash) (padrão para: nil) —

    Opções a serem passadas para o serializador.

Retorna:

  • (string) —

    A string JSON.



173
174
175
 
# Arquivo 'lib/mongoid/criteria.rb', linha 173

def as_json(opções = nada)
  entradas.as_json(opções)
end

#incorporado? ➤ verdadeiro | false

Os critérios são para documentos incorporados?

Exemplos:

Os critérios são para documentos incorporados?

criteria.embedded?

Retorna:

  • (verdadeiro | falso) —

    Se o critério estiver incorporado.



202
203
204
 
# Arquivo 'lib/mongoid/criteria.rb', linha 202

def incorporado?
  !!@embedded
end

#empty_and_chainable? ➤ verdadeiro | false

O critério é um critério vazio, mas acorrentador?

Exemplos:

O critério é nenhum critério?

criteria.empty_and_chainable?

Retorna:

  • (verdadeiro | falso) —

    Se o critério não for nenhum.



394
395
396
 
# Arquivo 'lib/mongoid/criteria.rb', linha 394

def empty_and_chainable?
  !!@none
end

#extract_id ➤ Objeto

Extraia um único ID dos critérios fornecidos. Pode estar em uma query $and ou uma query _id direta.

Exemplos:

Extraia o ID.

criteria.extract_id

Retorna:

  • (Objeto) —

    O ID.



272
273
274
 
# Arquivo 'lib/mongoid/criteria.rb', linha 272

def extract_id
  seletor['_id'] || seletor[:_id] || seletor['ID'] || seletor[:id]
end

#extras(extras) ⇒ Criteria

Adiciona um critério ao Criteria que especifica opções adicionais a serem passadas para o driver Ruby, no formato exato do driver.

criteria.extras(:limit => 20, :skip => 40)

Exemplos:

Adicione parâmetros extras aos critérios.

Parâmetros:

  • Extras (Hash) —

    As opções extras do driver.

Retorna:



285
286
287
288
289
 
# Arquivo 'lib/mongoid/criteria.rb', linha 285

def Extras(Extras)
  crit = clonar
  crit.opções.mesclar!(Extras)
  crit
end

#field_list ➤ Array<String>

Obtenha a lista de campos incluídos.

Exemplos:

Obtenha a lista de campo .

criteria.field_list

Retorna:

  • (Array<String>) —

    Os campos.



297
298
299
300
301
302
303
 
# Arquivo 'lib/mongoid/criteria.rb', linha 297

def field_list
  se opções[:fields]
    opções[:fields].keys.rejeitar { |chave| chave == classe.discriminator_key }
  mais
    []
  end
end

#find(*args) {|Object| ... } ⇒ Document | Array<Document> | nil

Observação:

Cada argumento pode ser um ID individual, uma array de ids ou uma array agrupada. Cada array será achatada.

Localiza um ou vários documentos de acordo com os valores _id fornecidos ou filtra os documentos no escopo atual no espaço do processo do aplicação depois de carregá-los, se necessário.

Se este método não receber um bloco, ele delegará para Findable#find e encontrará um ou muitos documentos para os valores de _id fornecidos.

Se esse método receber um bloco, ele delegará para Enumerable#find e retornará o primeiro document daqueles encontrados pelo objeto Criteria atual para o qual o bloco retornará um valor de verdade.

Observe que o argumento "padrão proc" de Enumerable não é tratado especialmente pelo Mongoid - a decisão entre delegar para Findable versus Enumerable é feita somente com base no fato de find passar a um bloqueio.

Exemplos:

Localiza um documento por seu _id, invoca Findable#find.

criteria.find("1234")

Localiza o primeiro documento correspondente usando um bloco, invoca Enumerable#find.

criteria.find { |item| item.name == "Depeche Mode" }

Encontra o primeiro documento correspondente usando um bloco usando o Proc padrão, invoca Enumerable#find.

criteria.find(-> { "Default Band" }) { |item| item.name == "Milwaukee Mode" }

Tenta encontrar um documento cujo _id seja a stringificação do Proc fornecido, normalmente falha.

enumerator = criteria.find(-> { "Default Band" })

Parâmetros:

  • *args ([ Object | Array<Object> ]...) —

    Os ID(s).

  • &block —

    Bloco opcional a ser aprovado.

Rendimento:

  • (Objeto) —

    Fornece cada elemento enumerável para o bloco.

Retorna:

Aumenta:

  • Erros::DocumentNotFound Se os parâmetros forem valores _id e nem todos os documentos forem encontrados, e a opção de configuração Mongoid raise_not_found_error for truey.

Veja também:



157
158
159
160
161
162
163
 
# Arquivo 'lib/mongoid/criteria.rb', linha 157

def find(*Args, &noum: bloco ; verb: bloquear)
  se block_given?
    _enumerable_find(*Args, &noum: bloco ; verb: bloquear)
  mais
    _findable_find(*Args)
  end
end

#for_js(JavaScript, scope = {}) ➤ Critérios

Obsoleto.

Encontre documentos pelo javascript e escopo fornecidos. Usa um $where, mas é diferente de Criteria#where porque passará um objeto de código para a query em vez de uma string pura. Seguro contra ataques de injeção de Javascript.

Exemplos:

Encontrar por JavaScript.

Band.for_js("this.name = param", param: "Tool")

Parâmetros:

  • JavaScript (string) —

    O JavaScript a ser executado no $where.

  • escopo (Hash) (padrão para: {}) —

    O escopo do código.

Retorna:



553
554
555
556
557
558
559
560
561
 
# Arquivo 'lib/mongoid/criteria.rb', linha 553

def for_js(JavaScript, escopo = {})
  código = se escopo.vazio?
           # CodeWithScope não é suportado para $where a partir do MongoDB 4.4
           BSON::Código.Novo(JavaScript)
         mais
           BSON::CodeWithScope.Novo(JavaScript, escopo)
         end
  js_query(código)
end

#freeze ⇒ Criteria

Ao congelar um critério, precisamos inicializar o contexto primeiro, caso contrário, a configuração do contexto em uma tentativa de iteração gerará um erro de tempo de execução.

Exemplos:

Congele os critérios.

criteria.freeze

Retorna:



313
314
315
 
# Arquivo 'lib/mongoid/criteria.rb', linha 313

def congelar
  Contexto e a inclusões e a super
end

#mesclar(outro) ➤ Critérios

Mescle outro objeto com este Criteria e retorna um novo critério. O outro objeto pode ser Criteria ou Hash. Isso é usado para combinar vários escopos, onde uma situação de escopo encadeado pode ser desejada.

Exemplos:

Mesclar os critérios com outros critérios.

criteria.merge(other_criteria)

Mescle os critérios com um hash. O hash deve conter uma klass

key that specifies the model class for the criteria and the key/value
pairs correspond to method names/args.

criteria.merge({
  klass: Band,
  where: { name: "Depeche Mode" },
  order_by: { name: 1 }
})

Parâmetros:

  • Outro (Critérios | Hash) —

    O outro critério para mesclar.

Retorna:



351
352
353
354
355
 
# Arquivo 'lib/mongoid/criteria.rb', linha 351

def mesclar(Outro)
  crit = clonar
  crit.mesclar!(Outro)
  crit
end

#merge!(outros) ➤ Critérios

Mesclar os outros critérios neste.

Exemplos:

Mesclar outros critérios a esse critério.

criteria.merge(Person.where(name: "bob"))

Parâmetros:

  • Outro (Critérios | Hash) —

    Os critérios para a mesclagem.

Retorna:



365
366
367
368
369
370
371
372
373
374
375
 
# Arquivo 'lib/mongoid/criteria.rb', linha 365

def mesclar!(Outro)
  Outro = auto.classe.from_hash(Outro) se Outro.is_a?(Hash)
  seletor.mesclar!(Outro.seletor)
  opções.mesclar!(Outro.opções)
  auto.documentos = Outro.documentos.dup a menos que Outro.documentos.vazio?
  auto.scope_options = Outro.scope_options
  auto.inclusões = (inclusões + Outro.inclusões).uniq
  auto._raw_results = _raw_results || Outro._raw_results
  @use_lookup ||= Outro.use_lookup?
  auto
end

#none ➤ Critérios

Retorna um critério que sempre conterá zero resultados e nunca atinge o banco de dados de dados.

Exemplos:

Retorna um critério nenhum.

criteria.none

Retorna:



384
385
386
 
# Arquivo 'lib/mongoid/criteria.rb', linha 384

def none
  @none = true e a auto
end

#only(*args) ➤ Critérios

Substituído para incluir _type nos campos.

Exemplos:

Limite os campos retornados do banco de banco de dados.

Band.only(:name)

Parâmetros:

  • *args ([ Símbolo | Array<Símbolo><Symbol> ]...) —

    O(s) nome(s) do campo .

Retorna:



406
407
408
409
410
411
412
413
 
# Arquivo 'lib/mongoid/criteria.rb', linha 406

def Apenas(*Args)
  Args = Args.achatar
  Método clonar se Args.vazio?

  Args.unshift(:_id) se (Args & Campos::IDS).vazio?
  Args.push(classe.discriminator_key.to_sym) se classe.hereditário?
  super
end

#aumente_eager_error(is_eager_load, klass, relação) ⇒ Objeto

Aumenta:



115
116
117
118
119
120
121
 
# Arquivo 'lib/mongoid/criteria/includable.rb', linha 115

def create_eager_error(is_eager_load, classe, relação)
  se is_eager_load
    aumentar ArgumentError, "O carregamento ávido suporta apenas argumentos que são os nomes das associações em #{klass}"
  end

  aumentar Errors::Inválido inclui.Novo(classe, [ relação ])
end

#bruto(raw_results = true, digitado: nil) ➤ Critérios

Produza um clone do objeto de critérios atual com sua configuração "raw" definida para o valor fornecido. Um critério definido como "raw" retornará todos os resultados como hashes brutos. Se typed for verdadeiro, os valores nos hashes serão convertidos de acordo com os campos aos quais correspondem.

Quando "raw" não estiver definido (ou se raw_results for falso), os critérios retornarão todos os resultados como instâncias de Document instanciadas.

Exemplos:

Retornar resultados da query como hashes brutos:

Person.where(city: 'Boston').raw

Parâmetros:

  • bruto_results (verdadeiro | falso) (padrão para: true) —

    Se os novos critérios devem ser colocados no modo " bruto " ou não.

  • digitado (verdadeiro | falso) (padrão para: nil) —

    Se os resultados brutos devem ser digitados antes de serem retornados. O padrão é verdadeiro se prima_resultados for falso e falso caso contrário.

Retorna:

  • (Critérios) —

    o objeto de critérios clonado .

Aumenta:

  • (ArgumentError) 


224
225
226
227
228
229
230
231
232
233
234
 
# Arquivo 'lib/mongoid/criteria.rb', linha 224

def bruto(bruto_results = true, digitado: nada)
  # padrão para digitado é verdadeiro quando bruto_results é falso e falso quando
  # bruto_results é verdadeiro.
  digitado = !bruto_results se digitado.nada?

  aumentar ArgumentError, 'resultados instanciados devem ser typecast' se !digitado && !bruto_results

  clonar.toque fazer |critério|
    critério._raw_results = { bruto: bruto_results, digitado: digitado }
  end
end

#bruto_resultados? ➤ verdadeiro | false

Predicado que responde à pergunta: este objeto de critérios está atualmente no modo bruto? (Consulte #raw para obter uma descrição do modo bruto.)

Retorna:

  • (verdadeiro | falso) —

    se os critérios estão no modo bruto ou não.



250
251
252
 
# Arquivo 'lib/mongoid/criteria.rb', linha 250

def bruto_resultados?
  _raw_results && _raw_results[:raw]
end

#read(value = nil) ➤ Critérios

Defina a preferência de leitura para os critérios.

Exemplos:

Defina a preferência de leitura.

criteria.read(mode: :primary_preferred)

Parâmetros:

  • valor (Hash) (padrão para: nil) —

    A preferência de modo .

Retorna:



423
424
425
426
427
 
# Arquivo 'lib/mongoid/criteria.rb', linha 423

def ler(valor = nada)
  clonar.toque fazer |critério|
    critério.opções.mesclar!(ler: valor)
  end
end

#respond_to?(nome, include_private = false) ➤ true | false

Retorna verdadeiro se os critérios responderem ao método fornecido.

Exemplos:

Os critérios respondem ao método?

criteria.respond_to?(:each)

Parâmetros:

  • name (Símbolo) —

    O nome do método de classe no Document.

  • include_private (verdadeiro | falso) (padrão para: false) —

    Se incluir privados.

Retorna:

  • (verdadeiro | falso) —

    Se os critérios responderem ao método.



451
452
453
 
# Arquivo 'lib/mongoid/criteria.rb', linha 451

def respond_to?(name, include_private = false)
  super || classe.respond_to?(name) || Verificar.respond_to?(name, include_private)
end

#to_criteria ⇒ Criteria

Obsoleto.

Conveniência para objetos que desejam ser mesclados em um critério.

Exemplos:

Converta em um critério.

criteria.to_criteria

Retorna:



464
465
466
 
# Arquivo 'lib/mongoid/criteria.rb', linha 464

def to_criteria
  auto
end

#to_proc ➤ Proc

Converta os critérios em um proc.

Exemplos:

Converta os critérios em um proc.

criteria.to_proc

Retorna:

  • (Proc) —

    Os critérios agrupados.



475
476
477
 
# Arquivo 'lib/mongoid/criteria.rb', linha 475

def to_proc
  -> { auto }
end

#type(tipos) ➤ Critérios

Adiciona um critério ao Criteria que especifica um tipo ou uma Array de tipos que devem ser correspondidos.

Exemplos:

Combine apenas modelos específicos.

criteria.type('Browser')
criteria.type(['Firefox', 'Browser'])

Parâmetros:

  • Tipos (Array<String>) —

    Os tipos a serem comparados.

Retorna:



489
490
491
 
# Arquivo 'lib/mongoid/criteria.rb', linha 489

def type(Tipos)
  any_in(discriminator_key.to_sym => Array(Tipos))
end

#typecast_results? ➤ verdadeiro | false

Predicado que responde à pergunta: os resultados retornados por este objeto de critérios devem ser digitados? (Consulte #raw para obter uma descrição disso.) A resposta não tem sentido a menos que #raw_results? é verdadeiro, pois, se objetos de documento instanciados forem retornados, eles sempre serão digitados.

Retorna:

  • (verdadeiro | falso) —

    se os critérios devem retornar resultados de typecast.



261
262
263
 
# Arquivo 'lib/mongoid/criteria.rb', linha 261

def typecast_results?
  _raw_results && _raw_results[:typed]
end

#onde(*args) ➤ Critérios

Este é o ponto de entrada geral para a maioria das consultas MongoDB. Isso cria um campo padrão: seleção de valor e seleção expandida com o uso de métodos de hash ou uma seleção $where se uma string for fornecida.

Exemplos:

Adicione uma seleção padrão.

criteria.where(name: "syd")

Adicione uma seleção JavaScript .

criteria.where("this.name == 'syd'")

Parâmetros:

  • *args ([ Hash | string ]...) —

    A seleção padrão ou JavaScript string.

Retorna:

Aumenta:

  • (Javascript não suportado) —

    Se for fornecida uma string e os critérios forem incorporados.



510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
 
# Arquivo 'lib/mongoid/criteria.rb', linha 510

def ONDE(*Args)
  # Anteriormente, este método exigia exatamente um argumento.
  # A partir de https://jira.mongodb.org/browse/MONGOID-4804 ele também aceita
  # zero arguments.
  # A implementação subjacente de onde super invoca suportes
  # qualquer número de argumentos, mas atualmente não permitimos vários
  # argumentos através deste método. Essa API pode ser reconfigurada na
  # futuro.
  aumentar ArgumentError, "Critérios#onde requer zero ou um argumento (dado #{args.comprimento})" se Args.Tamanho > 1

  se Args.Tamanho == 1
    expressão = Args.primeiro
    aumentar Errors::Javascript não suportado.Novo(classe, expressão) se expressão.is_a?(::String) && incorporado?
  end
  super
end

#sem(*args) ➤ Critérios

Substituído para excluir _id dos campos.

Exemplos:

Exclua campos retornados do banco de banco de dados.

Band.without(:name)

Parâmetros:

  • *args (Símbolo...) —

    O(s) nome(s) do campo .

Retorna:



437
438
439
440
 
# Arquivo 'lib/mongoid/criteria.rb', linha 437

def sem(*Args)
  Args -= id_fields
  super
end

#sem_opções ➤ Critérios

Obtenha uma versão desses critérios sem as opções.

Exemplos:

Obtenha os critérios sem opções.

criteria.without_options

Retorna:



533
534
535
536
537
 
# Arquivo 'lib/mongoid/criteria.rb', linha 533

def sem_opções
  crit = clonar
  crit.opções.Limpar
  crit
end