Clase: Mongoid::Criteria

Hereda:
Objeto
  • Objeto
Mostrar todo
Incluye:
Enumerable, Inspeccionable, Mongoid::Clients::Options, Mongoid::Clients::Sessions, Contextual, Findable, Includable, Marshalable, Modifiable, Opciones, Queryable, Scopable
Definido en:
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/modifiable.rb,
lib/mongoid/criteria/permission.rb,
lib/mongoid/criteria/translator.rb,
lib/mongoid/criteria/marshalable.rb,
lib/mongoid/criteria/queryable/key.rb,
lib/mongoid/criteria/queryable/smash.rb,
lib/mongoid/criteria/queryable/options.rb,
lib/mongoid/criteria/queryable/opcional.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/extensions/time.rb,
lib/mongoid/criteria/queryable/extensions/arreglo.rb,
lib/mongoid/criteria/queryable/extensions/rango.rb,
lib/mongoid/criteria/queryable/extensions/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/booleano.rb,
lib/mongoid/criteria/queryable/extensions/numeric.rb,
lib/mongoid/criteria/queryable/extensions/date_time.rb,
lib/mongoid/criteria/queryable/extensions/nil_class.rb,
lib/mongoid/criteria/queryable/extensions/big_decimal.rb,
lib/mongoid/criteria/queryable/extensions/time_with_zone.rb

Overview

La clase Criteria es el objeto principal necesario en Mongoid para recuperar objetos de la base de datos. Es un DSL que, en esencia, configura los argumentos selector y options que se pasan a una Mongo::colección en el driver de Ruby. Cada método en el Criteria devuelve self para que puedan encadenarse y crear un criterio legible para ejecutarse en la base de datos.

Definido bajo Namespace

Modules: Localizable, Incluible, Agrupable, Modificables, Opciones, Permisos, Consultable, Limitable Rango, Traductor

Resumen de constantes colapsar

ALLOWED_FROM_HASH_METHODS =

Métodos permitidos para from_hash para evitar la ejecución arbitraria de métodos. Sólo se permiten métodos de construcción de consultas, no métodos de ejecución o modificación.

%i[
  Todo all_in todo y  any_in any_of asc Ascendente
  batch_size entre
  intercalación comment cursor_type
  desc Descendente
  elem_match eq exists extras
  geo_spatial group gt gte
  hint
  in incluye
  limit lt lte
  max_distance max_scan max_time_ms fusionar mod
  ne near near_sphere nin sin tiempo de espera Ninguno none_of ni no no_en
  desplazamiento solo or orden ordenar_por
  Proyecto
  crudo Lea reordenar
  delimitado Omitir rebanada snapshot
  text_search tipo
  sin ámbito unwind
  dónde con el tamaño con tipo sin
].freeze
CHEQUE =

Arreglo estático usado para verificar con el método missing; solo necesitamos instanciarlo una vez.

[]

Resumen de atributos de la instancia colapsar

Atributos incluidos de Modificable

#create_attrs, #create_attrs Atributos adicionales para añadir al Documento al crear uno.

Atributos incluidos de Queryable

#alias, #alias Los alias., #serializadores, #serializadores Los serializadores.

Atributos incluidos de Queryable::opcional

#opciones, #opciones Los parámetros de la query.

Atributos incluidos de Queryable::Aggregable

#agregando, #agregando Indicador de si estamos agregando o no., #pipeline, #pipeline pipeline de agregación.

Atributos incluidos desde Queryable::Mergeable

#strategy, #strategy El nombre de la estrategia actual.

Resumen del método de clase colapsar

Resumen del método de instancia colapsar

Métodos incluidos de Mongoid::Clients::Sessions

incluido

Métodos incluidos de Mongoid::Clients::Options

#colección, #collection_name, #mongo_client, #persistence_context, #persistence_context?, #with

Métodos incluidos de Scopable

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

Métodos incluidos de Modificable

#compilar, #crear, #crear!, #crear_con, #buscar_o_crear_por, #buscar_o_crear_por!, #buscar_o_inicializar_por, #primero_o_crear, #primero_o_crear!, #primero_o_inicializar

Métodos incluidos de Marshalable

#marshal_dump, #marshal_load

Métodos incluidos de Incluible

#eager_load, #includes, #inclusions, #inclusions=, #use_lookup?

Métodos incluidos de Findable

#execute_or_raise, #for_ids, #multiple_from_db

Métodos incluidos de Queryable

#to_mql

Métodos incluidos desde Queryable::opcional

#ascending, #batch_size, #intercalación, #comment, #cursor_type, #descending, forwardables, #hint, #limit, #max_scan, #max_time_ms, #no_timeout, <spanclass=" ><a href="" title="">#order_by, #reorder, #skip, #slice, #snapshot

Métodos incluidos de Queryable::Macroable

#key

Métodos incluidos de Seleccionable

#atomic_selector

Métodos incluidos de Queryable::Aggregable

#aggregating?, #group, #Proyecto, #unwind

Métodos incluidos de Queryable::Mergeable

#and_with_operator, #intersect, #override, #reset_strategies!, #unión

Métodos incluidos de Queryable::Storable

#add_field_expression, #add_logical_operator_expression, #add_one_expression, #add_operator_expression

Métodos incluidos de Contextual

#context, #load_async

Detalles del Constructor

#initialize(klass) ⇒ Criteria

Inicialice los nuevos criterios.

Ejemplos:

Inicializa los nuevos criterios.

Criteria.new(Band)

Parámetros:

  • klass (clase) —

    La clase de modelo.



323
324
325
326
327
328
 
# Archivo 'lib/mongoid/criteria.rb', línea 323

def inicializar(klass)
  @klass = klass
  @embedded = nulo
  @none = nulo
  klass ? super(klass.campos_alias, klass.Campos, klass.relaciones, klass.asociaciones_aliased) : super({}, {}, {}, {})
end

Gestión dinámica de métodos

Esta clase gestiona métodos dinámicos a través del método method_missing

#method_missing ⇒ Object (privado)

Se utiliza para encadenar Criteria alcances juntos en la forma de métodos de clase en el Document para el que se establecen los criterios.

Ejemplos:

Gestionar método no encontrado.

criteria.method_missing(:name)

Parámetros:

  • Nombre (Símbolo) —

    El nombre del método.

  • *args (objeto...) —

    Los argumentos.

Devuelve:

  • (objeto) —

    El resultado de la llamada al método.



619
620
621
622
623
624
625
626
627
628
629
 
# Archivo 'lib/mongoid/criteria.rb', línea 619

ruby2_keywords def method_missing(Nombre, *args, &bloque)
  si klass.respond_to?(Nombre)
    klass.enviar(con: alcance, sí mismo) hacer
      klass.enviar(Nombre, *args, &bloque)
    end
  elsif Verificar.respond_to?(Nombre)
    entradas.enviar(Nombre, *args, &bloque)
  else
    super
  end
end

Detalles de atributo de instancias

#_raw_results ⇒ nil | Hash

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Un asistente interno para obtener/establecer el indicador "raw" en un objeto de criterios dado.

Devuelve:

  • (nil | Hash) —

    Si se establece, es un hash con dos claves: :raw y :typed, que describen si se deben devolver los resultados en bruto y si deben ser convertidos a tipo.



244
245
246
 
# Archivo 'lib/mongoid/criteria.rb', línea 244

def _raw_results
  @_raw_results
end

#asociación ⇒ objeto

Devuelve el valor del atributo association.



100
101
102
 
# Archivo 'lib/mongoid/criteria.rb', línea 100

def asociación
  @asociación
end

#documents ⇒ Array<Document>

Obtén los documentos de los criterios incrustados.

Ejemplos:

Obtén los documentos.

criteria.documents

Devuelve:



183
184
185
 
# Archivo 'lib/mongoid/criteria.rb', línea 183

def Documentos
  @documents ||= []
end

#incrustado ⇒ Objeto

Devuelve el valor del atributo incrustado.



100
101
102
 
# Archivo 'lib/mongoid/criteria.rb', línea 100

def integrado
  @embedded
end

#klass ⇒ Object

Devuelve el valor del atributo klass.



100
101
102
 
# Archivo 'lib/mongoid/criteria.rb', línea 100

def klass
  @klass
end

#parent_document ⇒ Objeto

Devuelve el valor del atributo parent_document.



100
101
102
 
# Archivo 'lib/mongoid/criteria.rb', línea 100

def parent_document
  @parent_document
end

Detalles del método de clase

.from_hash(hash) ⇒ Criterios

Obsoleto.

Este método está obsoleto y será eliminado en una versión futura.

Convierta el hash dado en un criterio. Iterará sobre cada clave en el hash que debe corresponder a un método permitido en un objeto de criterio. El hash puede incluir una clave "klass" que especifica la clase del model para los criterios.

Ejemplos:

Convierta el hash en criterios.

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

Parámetros:

  • hash (encriptada) —

    El hash para convertir.

Devuelve:

Aumenta:

  • (ArgumentError) —

    Si un método no está permitido en from_hash.



81
82
83
84
85
86
87
88
89
90
91
92
 
# Archivo 'lib/mongoid/criteria.rb', línea 81

def from_hash(hash)
  criterios = Criterios.Nuevo(hash.borrar(:klass) || hash.borrar('klass'))
  hash.each_pair hacer |Método, args|
    método_símbolo = Método.to_sym
    a menos que ALLOWED_FROM_HASH_METHODS.incluir?(método_símbolo)
      propagar ArgumentError, "Método '#{método}' no se permite en from_hash"
    end

    criterios = criterios.public_send(método_símbolo, args)
  end
  criterios
end

Detalles del método de instancia

#==(another) ⇒ verdadero | falso

Nota:

Forzará la carga de la base de datos cuando se invoque si se pasa un enumerable.

Devuelve verdadero si Enumerable o Criteria proporcionados son iguales a los resultados de este Criteria o a los propios criterios.

Parámetros:

  • Otros (objeto) —

    El otro Enumerable o Criteria para comparar.

Devuelve:

  • (true | false) —

    Si los objetos son iguales.



110
111
112
113
114
 
# Archivo 'lib/mongoid/criteria.rb', línea 110

def ==(Otros)
  return super si Otros.respond_to?(Selector:)

  entradas == Otros
end

#_enumerable_find ⇒ Object

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro. 



24
 
# Archivo 'lib/mongoid/criteria.rb', línea 24

Alias _enumerable_find buscar

#_findable_find ⇒ Objeto

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro. 



31
 
# Archivo 'lib/mongoid/criteria.rb', línea 31

Alias _findable_find buscar

#as_json(options = nil) ⇒ String

Es necesario para obtener correctamente un criterio como json.

Ejemplos:

Obten los criterios en json.

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

Parámetros:

  • opciones (encriptada) (valor por defecto: nil) —

    Opciones para pasar al serializador.

Devuelve:

  • (string) —

    La string JSON.



173
174
175
 
# Archivo 'lib/mongoid/criteria.rb', línea 173

def as_json(opciones = nulo)
  entradas.as_json(opciones)
end

#¿integrado? ⇒ true | false

¿Es el criterio para documentos incrustados?

Ejemplos:

¿Es el criterio para documentos incrustados?

criteria.embedded?

Devuelve:

  • (true | false) —

    Si el criterio está integrado.



202
203
204
 
# Archivo 'lib/mongoid/criteria.rb', línea 202

def ¿Incorporado?
  !!@embedded
end

#empty_and_chainable? ⇒ true | false

¿Son los criterios unos criterios vacíos pero encadenables?

Ejemplos:

¿Es el criterio un criterio nulo?

criteria.empty_and_chainable?

Devuelve:

  • (true | false) —

    Si el criterio es ninguno.



394
395
396
 
# Archivo 'lib/mongoid/criteria.rb', línea 394

def empty_and_chainable?
  !!@none
end

#extract_id ⇒ Object

Extraer un único ID de los criterios proporcionados. Podría estar en una $and query o en una query directa de _id.

Ejemplos:

Extraer el id.

criteria.extract_id

Devuelve:

  • (objeto) —

    El id.



272
273
274
 
# Archivo 'lib/mongoid/criteria.rb', línea 272

def extract_id
  selector['_id'] || selector[::_id] || selector['id'] || selector[:id]
end

#extras(extras) ⇒ Criteria

Agrega un criterio al Criteria que especifica opciones adicionales para ser pasadas al driver de Ruby, en el formato exacto para el driver.

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

Ejemplos:

Agrega parámetros extra a los criterios.

Parámetros:

  • extras (encriptada) —

    Las opciones extras del driver.

Devuelve:



285
286
287
288
289
 
# Archivo 'lib/mongoid/criteria.rb', línea 285

def extras(extras)
  crit = clonar
  crit.opciones.¡Actualizar!(extras)
  crit
end

#field_list ⇒ arreglo<String>

Obtén la lista de campos incluidos.

Ejemplos:

Obtenga la lista de campos.

criteria.field_list

Devuelve:

  • (arreglo<String>) —

    Los campos.



297
298
299
300
301
302
303
 
# Archivo 'lib/mongoid/criteria.rb', línea 297

def field_list
  si opciones[campo]
    opciones[campo].claves.rechazar { |llave| llave == klass.discriminador_clave }
  else
    []
  end
end

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

Nota:

Cada argumento puede ser un ID individual, un arreglo de IDs o un arreglo anidado. Cada arreglo se aplanará.

Encuentra uno o varios documentos dados los valores de _id proporcionados, o filtra los documentos en el ámbito actual en el espacio de proceso de la aplicación después de cargarlos si es necesario.

Si este método no recibe un bloque, delega a Findable#find y encuentra uno o varios document para los valores de _id proporcionados.

Si este método recibe un bloque, delega en Enumerable#find y devuelve el primer document de los encontrados por el objeto de Criterios actual para el cual el bloque devuelva un valor verdadero.

Nota que el argumento "por defecto proc" de Enumerable no es tratado de manera especial por Mongoid: la decisión entre delegar a Findable vs Enumerable se toma únicamente en función de si find recibe un bloque.

Ejemplos:

Encuentra un documento por su _id, invoca Findable#find.

criteria.find("1234")

Encuentra el primer documento que coincide usando un bloque, invoca Enumerable#find.

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

Encuentra el primer documento que coincida usando un bloque con el Proc por defecto, invoca Enumerable#find.

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

Intenta encontrar un documento cuyo _id sea la cadena proporcionada de Proc, normalmente sin éxito.

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

Parámetros:

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

    El/los id.

  • &bloque —

    Bloque opcional para pasar.

Rendimientos:

  • (objeto) —

    Cede cada elemento enumerable al bloque.

Devuelve:

  • (Document | Array<Document> | nil) —

    Un documento o documentos coincidentes.

Aumenta:

  • Errors::DocumentNotFound Si los parámetros eran valores de _id y no se encuentran todos los documentos y la opción de configuración raise_not_found_error de Mongoid es verdadera.

Véase también:



157
158
159
160
161
162
163
 
# Archivo 'lib/mongoid/criteria.rb', línea 157

def buscar(*args, &bloque)
  si ¿block_given?
    _enumerable_find(*args, &bloque)
  else
    _findable_find(*args)
  end
end

#for_js(javascript, scope = {}) ⇒ Criterios

Obsoleto.

Encuentra documentos mediante el JavaScript proporcionado y el alcance. Utiliza un $where pero es diferente de Criteria#where en que pasará un objeto de código a la consulta en lugar de una string pura. Seguro contra ataques de inyección de Javascript.

Ejemplos:

Buscar por JavaScript.

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

Parámetros:

  • JavaScript (string) —

    El javascript a ejecutar en el $where.

  • Alcance (encriptada) (por defecto: {}) —

    El alcance del código.

Devuelve:



553
554
555
556
557
558
559
560
561
 
# Archivo 'lib/mongoid/criteria.rb', línea 553

def for_js(JavaScript, Alcance = {})
  Código = si Alcance.¿vacío?
           # CodeWithScope no es compatible con $where en MongoDB 4.4
           BSON::Código.Nuevo(JavaScript)
         else
           BSON::CodeWithScope.Nuevo(JavaScript, Alcance)
         end
  js_query(Código)
end

#freeze ⇒ Criteria

Al congelar un criterio, debemos inicializar el contexto primero; de lo contrario, al intentar establecer el contexto en la iteración, se producirá un error en tiempo de ejecución.

Ejemplos:

Congela los criterios.

criteria.freeze

Devuelve:



313
314
315
 
# Archivo 'lib/mongoid/criteria.rb', línea 313

def freeze
  context y  inclusiones y  super
end

#merge(other) ⇒ Criterios

Se fusiona otro objeto con este Criteria y devuelve un nuevo criterio. El otro objeto puede ser un Criteria o un Hash. Esto se utiliza para combinar múltiples ámbitos juntos, donde se pueda desear una situación de ámbitos encadenados.

Ejemplos:

Combina los criterios con otros criterios.

criteria.merge(other_criteria)

Combina los criterios con un hash. El hash debe contener un 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:

  • Otros (Criterios | Hash) —

    El otro criterio con el que fusionarse.

Devuelve:



351
352
353
354
355
 
# Archivo 'lib/mongoid/criteria.rb', línea 351

def fusionar(Otros)
  crit = clonar
  crit.¡Actualizar!(Otros)
  crit
end

#¡fusionar!(otro) ⇒ Criterio

Fusionar los demás criterios en este.

Ejemplos:

Fusionar otro criterio en este criterio.

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

Parámetros:

  • Otros (Criterios | Hash) —

    Los criterios para fusionar.

Devuelve:



365
366
367
368
369
370
371
372
373
374
375
 
# Archivo 'lib/mongoid/criteria.rb', línea 365

def ¡Actualizar!(Otros)
  Otros = sí mismo.clase.from_hash(Otros) si Otros.is_a?(encriptada)
  selector.¡Actualizar!(Otros.selector)
  opciones.¡Actualizar!(Otros.opciones)
  sí mismo.Documentos = Otros.Documentos.dup a menos que Otros.Documentos.¿vacío?
  sí mismo.scoping_options = Otros.scoping_options
  sí mismo.inclusiones = (inclusiones + Otros.inclusiones).uniq
  sí mismo._raw_results = _raw_results || Otros._raw_results
  @use_lookup ||= Otros.use_lookup?
  sí mismo
end

#none ⇒ Criteria

Devuelve un criterio que siempre contendrá cero resultados y nunca accederá a la base de datos.

Ejemplos:

Devuelve un criterio ninguno.

criteria.none

Devuelve:



384
385
386
 
# Archivo 'lib/mongoid/criteria.rb', línea 384

def Ninguno
  @none = true y  sí mismo
end

#only(*args) ⇒ Criterios

Anulado para incluir _type en los campos.

Ejemplos:

Limita los campos devueltos de la base de datos.

Band.only(:name)

Parámetros:

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

    El(los) nombre(s) del(los) campo(s).

Devuelve:



406
407
408
409
410
411
412
413
 
# Archivo 'lib/mongoid/criteria.rb', línea 406

def solo(*args)
  args = args.nivelar
  return clonar si args.¿vacío?

  args.unshift(::_id) si (args & Campos::IDS).¿vacío?
  args.push(klass.discriminador_clave.to_sym) si klass.¿hereditaria?
  super
end

#raise_eager_error(is_eager_load, klass, relation) ⇒ Objeto

Aumenta:



115
116
117
118
119
120
121
 
# Archivo 'lib/mongoid/criteria/includable.rb', línea 115

def raise_eager_error(es_carga_entusiasta, klass, relación)
  si es_carga_entusiasta
    propagar ArgumentError, "La carga anticipada solo admite argumentos que sean nombres de asociaciones en #{klass}"
  end

  propagar Errors::ElementosIncluidosNoVálidos.Nuevo(klass, [ relación ])
end

#raw(raw_results = true, typed: nil) ⇒ Criterios

Produce un clon del objeto de criterios actual con el ajuste "raw" configurado al valor proporcionado. Un conjunto de criterios configurado como “original” devolverá todos los resultados en forma de hashes originales. Si typed es verdadero, los valores en los hashes serán convertidos según los campos con los que correspondan.

Cuando "raw" no está configurado (o si raw_results es falso), el criterio devolverá todos los resultados como instancias de Document ya creadas.

Ejemplos:

Devuelve los resultados de las query como hashes sin procesar:

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

Parámetros:

  • raw_results (true | false) (por defecto: true) —

    Si los nuevos criterios deben colocarse en modo "sin editar" o no.

  • escribió (true | false) (valor por defecto: nil) —

    Si se deben aplicar conversiones de tipo a los resultados sin procesar antes de devolverlos. Por defecto, es verdadero si raw_results es falso, y falso en lo contrario.

Devuelve:

  • (Criterios) —

    el objeto de criterios clonados.

Aumenta:

  • (ArgumentError) 


224
225
226
227
228
229
230
231
232
233
234
 
# Archivo 'lib/mongoid/criteria.rb', línea 224

def crudo(raw_results = true, escribió: nulo)
  # por defecto para typed es true cuando raw_results es false, y false cuando
  # raw_results es verdadero.
  escribió = !raw_results si escribió.nil?

  propagar ArgumentError, 'los resultados instanciados deben convertirse a un tipo determinado' si !escribió && !raw_results

  clonar.tocar hacer |criterios|
    criterios._raw_results = { crudo: raw_results, escribió: escribió }
  end
end

#raw_results? ⇒ verdadero | falso

Predicado que la respuesta a la pregunta: ¿está este objeto de criterios actualmente en modo sin procesar? (Consulta #raw para obtener una descripción del modo bruto).

Devuelve:

  • (true | false) —

    si el criterio está en modo sin procesar o no.



250
251
252
 
# Archivo 'lib/mongoid/criteria.rb', línea 250

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

#read(valor = nil) ⇒ Criteria

Establece la preferencia de lectura para el criterio.

Ejemplos:

Define la preferencia de lectura.

criteria.read(mode: :primary_preferred)

Parámetros:

  • Valor (encriptada) (valor por defecto: nil) —

    La preferencia de moda.

Devuelve:



423
424
425
426
427
 
# Archivo 'lib/mongoid/criteria.rb', línea 423

def Lea(Valor = nulo)
  clonar.tocar hacer |criterios|
    criterios.opciones.¡Actualizar!(leer: Valor)
  end
end

#respond_to?(nombre, include_private = false) ⇒ true | false

Devuelve verdadero si los criterios responden al método dado.

Ejemplos:

¿El criterio responde al método?

criteria.respond_to?(:each)

Parámetros:

  • Nombre (Símbolo) —

    El nombre del método de clase en el Document.

  • incluir_privada (true | false) (por defecto: false) —

    Si incluir los elementos privados.

Devuelve:

  • (true | false) —

    Si el criterio responde al método.



451
452
453
 
# Archivo 'lib/mongoid/criteria.rb', línea 451

def respond_to?(Nombre, incluir_privada = false)
  super || klass.respond_to?(Nombre) || Verificar.respond_to?(Nombre, incluir_privada)
end

#to_criteria ⇒ Criteria

Obsoleto.

Conveniencia para los objetos que desean fusionarse en un criterio.

Ejemplos:

Convertir a un criterio.

criteria.to_criteria

Devuelve:



464
465
466
 
# Archivo 'lib/mongoid/criteria.rb', línea 464

def to_criteria
  sí mismo
end

#to_proc ⇒ Proc

Convierte los criterios a un procedimiento.

Ejemplos:

Convierte los criterios a un procedimiento.

criteria.to_proc

Devuelve:

  • (Proc) —

    Los criterios envueltos.



475
476
477
 
# Archivo 'lib/mongoid/criteria.rb', línea 475

def to_proc
  -> { sí mismo }
end

#type(tipos) ⇒ Criterios

Agrega un criterio al Criteria que especifica un tipo o un arreglo de tipos que deben coincidir.

Ejemplos:

Empareja solo modelos específicos.

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

Parámetros:

  • Tipos (arreglo<String>) —

    Los tipos con los que hacer coincidir.

Devuelve:



489
490
491
 
# Archivo 'lib/mongoid/criteria.rb', línea 489

def tipo(Tipos)
  any_in(discriminador_clave.to_sym => Arreglo(Tipos))
end

#¿typecast_results? ⇒ true | false

¿Predicado que da respuesta a la pregunta: los resultados devueltos por este objeto de criterios deben someterse a conversión de tipo? (Consulta #raw para obtener la descripción de esto.) La respuesta no tiene sentido a menos que #raw_results? sea verdadera, ya que si se devuelven objetos de document instanciados, siempre serán convertidos de tipo.

Devuelve:

  • (true | false) —

    si los criterios deben devolver resultados tipificados.



261
262
263
 
# Archivo 'lib/mongoid/criteria.rb', línea 261

def resultados_de_typecast?
  _raw_results && _raw_results[Escribió]
end

#donde(*args) ⇒ Criterios

Este es el punto de entrada general para la mayoría de las consultas de MongoDB. Esto crea un campo estándar: selección de valor y selección ampliada con el uso de métodos hash, o una selección $where si se proporciona una string.

Ejemplos:

Añade una selección estándar.

criteria.where(name: "syd")

Agregar una selección de JavaScript.

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

Parámetros:

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

    La selección estándar o string de JavaScript.

Devuelve:

Aumenta:

  • (JavascriptNoCompatible) —

    Si se proporciona una string y el criterio está integrado.



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

def dónde(*args)
  # Históricamente este método requería exactamente un argumento.
  # Como se indica en https://jira.mongodb.org/browse/MONGOID-4804 también acepta
  # zero arguments.
  # La implementación subyacente donde las invocaciones super admiten
  # cualquier número de argumentos, pero actualmente no permitimos múltiples
  # argumentos a través de este método. Esta API puede ser reconsiderada en el
  # future.
  propagar ArgumentError, "Criteria#where requiere cero o un argumento (dado #{args.length})" si args.longitud > 1

  si args.longitud == 1
    expresión = args.primero
    propagar Errors::Javascript no compatible.Nuevo(klass, expresión) si expresión.is_a?(::String) && ¿Incorporado?
  end
  super
end

#sin(*args) ⇒ Criterio

Sobrescrito para excluir _id de los campos.

Ejemplos:

Excluya los campos devueltos de la base de datos.

Band.without(:name)

Parámetros:

  • *args (Symbol...) —

    El(los) nombre(s) del(los) campo(s).

Devuelve:



437
438
439
440
 
# Archivo 'lib/mongoid/criteria.rb', línea 437

def sin(*args)
  args -= id_fields
  super
end

#sin_opciones ⇒ Criterio

Obtén una versión de este criterio sin las opciones.

Ejemplos:

Obtener los criterios sin opciones.

criteria.without_options

Devuelve:



533
534
535
536
537
 
# Archivo 'lib/mongoid/criteria.rb', línea 533

def sinOpciones
  crit = clonar
  crit.opciones.borrar
  crit
end