Clase: Mongoid::Criteria

Hereda:
Objeto
  • Objeto
Mostrar todo
Incluye:
Enumerable, Inspeccionable, Mongoid::Clientes::Opciones, Mongoid::Clientes::Sesiones, Contextual, Localizable, Incluible, Marshalizable, Modificable, Opciones, Consultable, Alcance
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/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/extensions/time.rb,
lib/mongoid/criteria/queryable/extensions/array.rb,
lib/mongoid/criteria/queryable/extensions/range.rb,
lib/mongoid/criteria/queryable/extensions/object.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/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 del selector y las opciones que se pasan a una Mongo::Collection en el controlador Ruby. Cada método de la clase Criteria retorna a sí mismo; se pueden encadenar para crear un criterio legible que se ejecute en la base de datos.

Definido en el espacio de nombres

Modules: Localizable, Incluible, Marshalable, Modificable, Opciones, Permiso, Consultable, Alcance, Traductor

Colapso delresumen constante

COMPROBAR =

Matriz estática utilizada para verificar si falta un método: solo necesitamos instanciarlo una vez.

[]

Colapso delresumen de atributos de instancia

Atributos incluidos de Modificable

#create_attrs, #create_attrs Atributos adicionales para agregar al documento durante la creación.

Atributos incluidos en Queryable

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

Atributos incluidos en Queryable::Optional

#opciones, #opciones Las opciones de consulta.

Atributos incluidos de Queryable::Aggregable

#agregando, #agregando Bandera que indica si estamos agregando o no, #tubería, #tubería La tubería de agregación.

Atributos incluidos en Queryable::Mergeable

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

Colapso delresumen del método de clase

Colapso del resumen del método de instancia

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

incluido

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

#colección, #nombre_de_colección, #cliente_mongo, #contexto_de_persistencia, #contexto_de_persistencia?, #con

Métodos incluidos en Scopable

#aplicar_alcance_predeterminado, #aplicar_alcance, #eliminar_alcance, #con_alcance, #¿con_alcance?, #opciones_de_alcance, #opciones_de_alcance=, #sin_alcance, #¿sin_alcance?, #con_alcance_predeterminado

Métodos incluidos de Modifiable

#construir, #crear, #¡crear!, #crear_con, #encontrar_o_crear_por, #encontrar_o_crear_por!, #encontrar_o_inicializar_por, #primero_o_crear, #primero_o_crear!, #primero_o_inicializar

Métodos incluidos de Marshalable

#marshal_dump, #marshal_load

Métodos incluidos en Includable

#incluye, #inclusiones, #inclusiones=

Métodos incluidos en Findable

#ejecutar_o_elevar, #para_ids, #múltiples_desde_la_base_de_datos

Métodos incluidos en Queryable::Optional

#ascendente, #tamaño_de_lote, #intercalación, #comentario, #tipo_de_cursor, #descendente, reenviables, #pista, #límite, #escaneo_máximo, #tiempo_máximo_ms, #sin_tiempo_de_espera, #ordenar_por, #reordenar, #omitir, #segmento, #instantánea

Métodos incluidos en Queryable::Macroable

#key

Métodos incluidos en Seleccionable

#selector_atómico

Métodos incluidos en Queryable::Aggregable

#agregando?, #agrupar, #proyecto, #desenrollar

Métodos incluidos en Queryable::Mergeable

#operador_y_con, #intersecar, #anular, #¡reiniciar_estrategias!, #unión

Métodos incluidos en 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

Inicializar los nuevos criterios.

Ejemplos:

Inicialice los nuevos criterios.

Criteria.new(Band)

Parámetros:

  • klass (Clase) -

    La clase modelo.



233
234
235
236
237
238
 
# Archivo 'lib/mongoid/criteria.rb', línea 233

def inicializar(klass)
  @klass = klass
  @incorporado = nulo
  @none = nulo
  klass ? Super(klass.campos con alias, klass.campos, klass.relaciones, klass.asociaciones_aliasadas) : Super({}, {}, {}, {})
end

Manejo de métodos dinámicos

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

#method_missing ⇒ Objeto (privado)

Se utiliza para encadenar ámbitos Criteria juntos en el for de métodos de clase en el Document para el cual se aplica el criterio.

Ejemplos:

Gestionar método no encontrado.

criteria.method_missing(:name)

Parámetros:

  • Nombre ( Símbolo) -

    El nombre del método.

  • *argumentos (Objeto...) -

    Los argumentos.

Devuelve:

  • (Objeto) -

    El resultado de la llamada al método.



530
531
532
533
534
535
536
537
538
539
540
 
# Archivo 'lib/mongoid/criteria.rb', línea 530

ruby2_keywords def método_faltante(Nombre, *args, Ybloque)
  Si klass.respond_to?(Nombre)
    klass.Enviar(:con_alcance, yo) hacer
      klass.Enviar(Nombre, *args, Ybloque)
    end
  elsif VER.respond_to?(Nombre)
    return entradas.Enviar(Nombre, *args, Ybloque)
  else
    Super
  end
end

Detalles de los atributos de instancia

#asociación ⇒ objeto

Devuelve el valor de la asociación de atributos.



68
69
70
 
# Archivo 'lib/mongoid/criteria.rb', línea 68

def asociación
  @asociación
end

#incrustado ⇒ Objeto

Devuelve el valor del atributo incrustado.



68
69
70
 
# Archivo 'lib/mongoid/criteria.rb', línea 68

def incrustado
  @incorporado
end

#klass ⇒ Object

Devuelve el valor del atributo klass.



68
69
70
 
# Archivo 'lib/mongoid/criteria.rb', línea 68

def klass
  @klass
end

#documento_principal ⇒ Objeto

Devuelve el valor del atributo parent_document.



68
69
70
 
# Archivo 'lib/mongoid/criteria.rb', línea 68

def documento principal
  @parent_document
end

Detalles del método de clase

.from_hash(hash) ⇒ Criterios

Convierte el hash dado en un criterio. Itera sobre cada clave del hash, que debe corresponder al método de un objeto de criterio. El hash también debe incluir una clave "klass".

Ejemplos:

Convierte el hash en un criterio.

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

Parámetros:

  • hash (Hash) —

    El hash a convertir.

Devuelve:



55
56
57
58
59
60
61
 
# Archivo 'lib/mongoid/criteria.rb', línea 55

def desde_hash(hash)
  criterios = Criterios.Nuevo(hash.borrar(:klass) || hash.borrar('klass'))
  hash.each_pair hacer |Método, args|
    criterios = criterios.__enviar__(Método, args)
  end
  criterios
end

Detalles del método de instancia

#==(otro) ⇒ verdadero | falso

Nota:

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

Devuelve verdadero si el Enumerable o Criteria suministrado es igual a los resultados de este Criteria o al criterio en sí.

Parámetros:

  • otros (Objeto) -

    El otro Enumerable o Criteria con el que comparar.

Devuelve:

  • (verdadero | falso) —

    Si los objetos son iguales.



78
79
80
81
 
# Archivo 'lib/mongoid/criteria.rb', línea 78

def ==(otros)
  return Super Si otros.respond_to?(:selector)
  entradas == otros
end

#_enumerable_find ⇒ Object

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro. 



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

alias :_hallazgo_enumerable :encontrar

#_findable_find ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro. 



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

alias :_findable_find :encontrar

#as_json(options = nil) ⇒ String

Es necesario para obtener correctamente un criterio como json.

Ejemplos:

Obtenga los criterios como json.

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

Parámetros:

  • opciones (Hash) (predeterminado: nulo) —

    Opciones para pasar al serializador.

Devuelve:

  • (Cadena) -

    La cadena JSON.



140
141
142
 
# Archivo 'lib/mongoid/criteria.rb', línea 140

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

#documents ⇒ Array<Document>

Obtenga los documentos de los criterios integrados.

Ejemplos:

Obtenga los documentos.

criteria.documents

Devuelve:

  • (Matriz) —

    Los documentos.



150
151
152
 
# Archivo 'lib/mongoid/criteria.rb', línea 150

def Documentos
  @documents ||= []
end

#documents=(docs) ⇒ Array<Document>

Establezca los documentos incrustados según los criterios.

Ejemplos:

Establecer los documentos.

Parámetros:

  • docs (Matriz) —

    Los documentos incrustados.

Devuelve:

  • (Matriz) —

    Los documentos incrustados.



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

def documentos=(docs)
  @documents = docs
end

#¿incrustado? ⇒ verdadero | falso

¿Cuáles son los criterios para los documentos incrustados?

Ejemplos:

¿Cuáles son los criterios para los documentos incrustados?

criteria.embedded?

Devuelve:

  • (verdadero | falso) —

    Si el criterio está incrustado.



171
172
173
 
# Archivo 'lib/mongoid/criteria.rb', línea 171

def ¿incorporado?
  !!@incorporado
end

#¿vacío_y_encadenable? ⇒ verdadero | falso

¿Es el criterio un criterio vacío pero encadenable?

Ejemplos:

¿El criterio es un criterio no válido?

criteria.empty_and_chainable?

Devuelve:

  • (verdadero | falso) —

    Si el criterio es ninguno.



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

def empty_and_chainable?
  !!@none
end

#extract_id ⇒ Objeto

Extrae un único ID a partir de los criterios proporcionados. Puede ser una consulta `$and` o una consulta `_id` directa.

Ejemplos:

Extraer el id.

criteria.extract_id

Devuelve:

  • (Objeto) -

    El id.



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

def id_de_extracto
  selector['_id'] || selector[:_identificación] || selector['id'] || selector[:id]
end

#extras(extras) ⇒ Criteria

Agrega un criterio a Criteria que especifica opciones adicionales que se pasarán al controlador Ruby, en el formato exacto del controlador.

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

Ejemplos:

Añade parámetros adicionales a los criterios.

Parámetros:

  • extras (Hash) —

    Las opciones de controlador adicionales.

Devuelve:



195
196
197
198
199
 
# Archivo 'lib/mongoid/criteria.rb', línea 195

def extras(extras)
  crit = clon
  crit.opciones.¡unir!(extras)
  crit
end

#lista_de_campos ⇒ Matriz<String>

Obtenga la lista de campos incluidos.

Ejemplos:

Obtener la lista de campos.

criteria.field_list

Devuelve:

  • (Matriz<String>) —

    Los campos.



207
208
209
210
211
212
213
 
# Archivo 'lib/mongoid/criteria.rb', línea 207

def lista_de_campos
  Si opciones[:campos]
    opciones[:campos].claves.rechazar{ |clave| clave == klass.clave discriminadora }
  else
    []
  end
end

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

Nota:

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

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

Si a este método no se le asigna un bloque, delega en Findable#find y encuentra uno o muchos documentos para los valores _id proporcionados.

Si se le asigna un bloque a este método, delega a Enumerable#find y devuelve el primer documento de los encontrados por el objeto Crieria actual para el cual el bloque devuelve un valor verdadero.

Tenga en cuenta que Mongoid no trata especialmente el argumento “procedimiento predeterminado” de Enumerable: la decisión entre delegar a Findable o Enumerable se toma únicamente en función de si se le pasa un bloque a find.

Ejemplos:

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

critera.find("1234")

Encuentra el primer documento coincidente utilizando 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 de caracteres del Proc proporcionado, pero generalmente falla.

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

Parámetros:

  • *argumentos ([ Objeto | Matriz<Object> ]...) —

    El/los id.

  • &bloquear —

    Bloque opcional para pasar.

Rendimientos:

  • (Objeto) -

    Devuelve cada elemento enumerable al bloque.

Devuelve:

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

    Un documento o documentos coincidentes.

Aumentos:

  • 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.

Ver también:



124
125
126
127
128
129
130
 
# Archivo 'lib/mongoid/criteria.rb', línea 124

def buscar(*args, Ybloque)
  Si ¿bloque_dado?
    _hallazgo_enumerable(*args, Ybloque)
  else
    _findable_find(*args)
  end
end

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

Obsoleto.

Busca documentos según el JavaScript y el alcance proporcionados. Usa un `$where`, pero se diferencia de `Criteria#where` en que pasa un objeto de código a la consulta en lugar de una cadena pura. Es seguro contra ataques de inyección de JavaScript.

Ejemplos:

Buscar por javascript.

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

Parámetros:

  • JavaScript (Cadena) -

    El javascript a ejecutar en el $where.

  • ámbito de aplicación (Hash) (predeterminado: {}) —

    El alcance del código.

Devuelve:



466
467
468
469
470
471
472
473
474
 
# Archivo 'lib/mongoid/criteria.rb', línea 466

def para_js(JavaScript, ámbito de aplicación = {})
  Código = Si ámbito de aplicación.¿vacío?
    # CodeWithScope no es compatible con $where a partir de MongoDB 4.4
    BSON::Código.Nuevo(JavaScript)
  else
    BSON::Código con alcance.Nuevo(JavaScript, ámbito de aplicación)
  end
  consulta_js(Código)
end

#freeze ⇒ Criteria

Al congelar un criterio, primero debemos inicializar el contexto; de lo contrario, la configuración del contexto en el intento de iteración generará un error de tiempo de ejecución.

Ejemplos:

Congelar los criterios.

criteria.freeze

Devuelve:



223
224
225
 
# Archivo 'lib/mongoid/criteria.rb', línea 223

def freeze
  context y  inclusiones y  Super
end

#fusionar(otros) ⇒ Criterios

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 varios ámbitos, donde se desea una situación de ámbitos encadenados.

Ejemplos:

Fusionar el criterio con otro criterio.

criteria.merge(other_criteria)

Fusionar los criterios con un hash. El hash debe contener una clase.

key 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) -

    El otro criterio a fusionar.

Devuelve:



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

def unir(otros)
  crit = clon
  crit.¡unir!(otros)
  crit
end

#¡Fusionar!(otro) ⇒ Criterios

Fusionar los demás criterios en este.

Ejemplos:

Fusionar otro criterio con este criterio.

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

Parámetros:

  • otros (Criterios | Hash) —

    Los criterios para fusionarse.

Devuelve:



274
275
276
277
278
279
280
281
282
 
# Archivo 'lib/mongoid/criteria.rb', línea 274

def ¡unir!(otros)
  otros = yo.clase.desde_hash(otros) Si otros.is_a?(Picadillo)
  selector.¡unir!(otros.selector)
  opciones.¡unir!(otros.opciones)
  yo.Documentos = otros.Documentos.dup a no ser que otros.Documentos.¿vacío?
  yo.opciones de alcance = otros.opciones de alcance
  yo.inclusiones = (inclusiones + otros.inclusiones).único
  yo
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:



291
292
293
 
# Archivo 'lib/mongoid/criteria.rb', línea 291

def ninguno
  @none = true y  yo
end

#solo(*args) ⇒ Criterios

Se reemplazó para incluir _type en los campos.

Ejemplos:

Limite los campos devueltos desde la base de datos.

Band.only(:name)

Parámetros:

  • *argumentos ([ Símbolo |<Symbol> Matriz<Símbolo> ]...) —

    El nombre(s) del campo.

Devuelve:



313
314
315
316
317
318
319
320
321
322
323
 
# Archivo 'lib/mongoid/criteria.rb', línea 313

def sólo(*args)
  args = args.aplanar
  return clon Si args.¿vacío?
  Si (args Y Campos::Identificación).¿vacío?
    args.unshift(:_identificación)
  end
  Si klass.¿hereditario?
    args.Push(klass.clave discriminadora.a_sym)
  end
  Super(*args)
end

#leer(valor = nulo) ⇒ Criterios

Establezca la preferencia de lectura para los criterios.

Ejemplos:

Establecer la preferencia de lectura.

criteria.read(mode: :primary_preferred)

Parámetros:

  • valor (Hash) (predeterminado: nulo) —

    La preferencia de modo.

Devuelve:



333
334
335
336
337
 
# Archivo 'lib/mongoid/criteria.rb', línea 333

def Lea(valor = nulo)
  clon.grifo hacer |criterios|
    criterios.opciones.¡unir!(leer: valor)
  end
end

#responder_a?(nombre, incluir_privado = falso) ⇒ verdadero | falso

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

Ejemplos:

¿Los criterios responden al método?

crtiteria.respond_to?(:each)

Parámetros:

  • Nombre ( Símbolo) -

    El nombre del método de clase en Document.

  • incluir_privado (true | false) (predeterminado: falso)

    Si se deben incluir los privados.

Devuelve:

  • (verdadero | falso) —

    Si el criterio responde al método.



361
362
363
 
# Archivo 'lib/mongoid/criteria.rb', línea 361

def respond_to?(Nombre, incluir_privado = false)
  Super || klass.respond_to?(Nombre) || VER.respond_to?(Nombre, incluir_privado)
end

#to_criteria ⇒ Criteria

Obsoleto.

Conveniencia para objetos que desean fusionarse según un criterio.

Ejemplos:

Convertir a un criterio.

criteria.to_criteria

Devuelve:



374
375
376
 
# Archivo 'lib/mongoid/criteria.rb', línea 374

def to_criteria
  yo
end

#to_proc ⇒ Proc

Convertir los criterios en un procedimiento.

Ejemplos:

Convertir los criterios en un procedimiento.

criteria.to_proc

Devuelve:

  • (Procedimiento) —

    Los criterios envueltos.



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

def to_proc
  ->{ yo }
end

# tipo(s)⇒ Criterios

Agrega un criterio a Criteria que especifica un tipo o una matriz de tipos que deben coincidir.

Ejemplos:

Coincide únicamente con modelos específicos.

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

Parámetros:

  • tipos (Matriz<String>) —

    Los tipos con los que comparar.

Devuelve:



399
400
401
 
# Archivo 'lib/mongoid/criteria.rb', línea 399

def tipo(tipos)
  any_in(yo.clave discriminadora.a_sym => Arreglo(tipos))
end

#donde(*args) ⇒ Criterios

Este es el punto de entrada general para la mayoría de las consultas de MongoDB. Crea un campo estándar: selección de valor y selección expandida mediante métodos hash, o una selección $where si se proporciona una cadena.

Ejemplos:

Añadir una selección estándar.

criteria.where(name: "syd")

Agregar una selección de JavaScript.

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

Parámetros:

  • *argumentos ([ Hash | Cadena ]... ) —

    La selección estándar o cadena de javascript.

Devuelve:

Aumentos:

  • (Javascriptno compatible) —

    Si se proporciona una cadena y los criterios están incrustados.



420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
 
# Archivo 'lib/mongoid/criteria.rb', línea 420

def donde(*args)
  # Históricamente, este método requería exactamente un argumento.
  # A partir de https://jira.mongodb.org/browse/MONGOID-4804 también acepta
  # zero arguments.
  # La implementación subyacente donde la superinvocación admite
  # cualquier número de argumentos, pero actualmente no permitimos varios
  # argumentos a través de este método. Esta API se puede reconsiderar en el
  # futuro.
  Si args.longitud > 1
    propagar ArgumentError, "Criterios#donderequiere cero o un argumento (dado #{args.length} )"
  end
  Si args.longitud == 1
    expresión = args.primera
    Si expresión.is_a?(::String) && ¿incorporado?
      propagar Errors::Javascript no compatible.Nuevo(klass, expresión)
    end
  end
  Super
end

#sin(*args) ⇒ Criterios

Se anuló para excluir _id de los campos.

Ejemplos:

Excluir campos devueltos de la base de datos.

Band.without(:name)

Parámetros:

  • *argumentos (Symbol...) —

    El nombre(s) del campo.

Devuelve:



347
348
349
350
 
# Archivo 'lib/mongoid/criteria.rb', línea 347

def sin(*args)
  args -= campos de identificación
  Super(*args)
end

#sin_opciones ⇒ Criterios

Obtenga una versión de este criterio sin las opciones.

Ejemplos:

Obtenga los criterios sin opciones.

criteria.without_options

Devuelve:



446
447
448
449
450
 
# Archivo 'lib/mongoid/criteria.rb', línea 446

def sin_opciones
  crit = clon
  crit.opciones.borrar
  crit
end