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

Colapso delresumen constante

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, #nombre_de_colección, #cliente_mongo, #contexto_de_persistencia, #contexto_de_persistencia?, #con

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

#includes, #inclusiones, #inclusiones=

Métodos incluidos de Findable

#execute_or_raise, #for_ids, #multiple_from_db

Métodos incluidos desde Queryable::opcional

#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

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



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

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

Gestión dinámica de métodos

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

#method_missing ⇒ Object (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 method_missing(Nombre, *args, Ybloque)
  si klass.respond_to?(Nombre)
    klass.enviar(con: alcance, sí mismo) hacer
      klass.enviar(Nombre, *args, Ybloque)
    end
  elsif Verificar.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 del atributo association.



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 integrado
  @embedded
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 parent_document
  @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 (encriptada) —

    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.__send__(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 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.



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 Buscar

#_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 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 (Hash) (predeterminado: nulo) —

    Opciones para pasar al serializador.

Devuelve:

  • (string) —

    La string JSON.



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

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

#documents ⇒ Array<Document>

Obtén los documentos de los criterios incrustados.

Ejemplos:

Obtenga los documentos.

criteria.documents

Devuelve:



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

def Documentos
  @documents ||= []
end

#documents=(docs) ⇒ Array<Document>

Establece los documentos incrustados en los criterios.

Ejemplos:

Configura los documentos.

Parámetros:

  • docs (Array<documento>) —

    Los documentos incrustados.

Devuelve:

  • (Array<documento>) —

    Los documentos incrustados.



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

def documento=(docs)
  @documents = docs
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.



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

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.



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

def empty_and_chainable?
  !!@none
end

#extract_id ⇒ Objeto

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.



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

def extract_id
  selector['_id'] || selector[:_identificación] || 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:

Añade parámetros adicionales a los criterios.

Parámetros:

  • extras (encriptada) —

    Las opciones extras del driver.

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>

Obtén la lista de campos incluidos.

Ejemplos:

Obtener la lista de campos.

criteria.field_list

Devuelve:

  • (arreglo<String>) —

    Los campos.



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

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 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 no se le da un bloque a este método, delega a Findable#find y encuentra uno o varios documentos para los valores de _id proporcionados.

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

Ten en cuenta que el argumento "proc por defecto" de Enumerable no es tratado especialmente por Mongoid - la decisión entre delegar a Findable vs Enumerable se toma únicamente en función de si se pasa un bloque a find.

Ejemplos:

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

critera.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:

  • *argumentos ([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:



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

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

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

Obsoleto.

Encontrar documentos mediante JavaScript y alcance proporcionados. Utiliza un $where, pero se diferencia de Criteria#where en que pasará un objeto de código a la consulta en lugar de una string pura. Protección 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 (Hash) (por defecto: {}) —

    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, Alcance = {})
  Código = si Alcance.¿vacío?
    # CodeWithScope no es compatible con $where en MongoDB 4.4
    BSON::Código.Nuevo(JavaScript)
  else
    BSON::Código con alcance.Nuevo(JavaScript, Alcance)
  end
  js_query(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:

Congela 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:

Combina los criterios con otros criterios.

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 fusionar(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 fusionar.

Devuelve:



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

def ¡unir!(Otros)
  Otros = sí mismo.clase.desde_hash(Otros) si Otros.is_a?(Picadillo)
  selector.¡unir!(Otros.selector)
  opciones.¡unir!(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).único
  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:



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

def Ninguno
  @none = true y  sí mismo
end

#only(*args) ⇒ Criterios

Se reemplazó para incluir _type en los campos.

Ejemplos:

Limita los campos devueltos de 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 solo(*args)
  args = args.nivelar
  return clon si args.¿vacío?
  si (args Y Campos::IDS).¿vacío?
    args.unshift(:_identificación)
  end
  si klass.¿hereditaria?
    args.push(klass.discriminador_clave.to_sym)
  end
  super(*args)
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 (Hash) (predeterminado: nulo) —

    La preferencia de moda.

Devuelve:



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

def Lea(Valor = nulo)
  clon.tocar hacer |criterios|
    criterios.opciones.¡unir!(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?

crtiteria.respond_to?(:each)

Parámetros:

  • Nombre (Símbolo) —

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

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

    Si incluir los elementos privados.

Devuelve:

  • (true | false) —

    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) || Verificar.respond_to?(Nombre, incluir_privado)
end

#to_criteria ⇒ Criteria

Obsoleto.

Conveniencia para los objetos que desean fusionarse en 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
  sí mismo
end

#to_proc ⇒ Proc

Convertir los criterios en un procedimiento.

Ejemplos:

Convertir los criterios en un procedimiento.

criteria.to_proc

Devuelve:

  • (Proc) —

    Los criterios envueltos.



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

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:

Coincide únicamente con modelos específicos.

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

Parámetros:

  • tipos (arreglo<String>) —

    Los tipos con los que hacer coincidir.

Devuelve:



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

def tipo(tipos)
  any_in(sí mismo.discriminador_clave.to_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ñade una selección estándar.

criteria.where(name: "syd")

Agregar una selección de JavaScript.

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

Parámetros:

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

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

Devuelve:

Aumenta:

  • (JavascriptNoCompatible) —

    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 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 la invocación que la invoca soporta
  # cualquier número de argumentos, pero actualmente no permitimos múltiple
  # argumentos a través de este método. Esta API puede ser reconsiderada en el
  # future.
  si args.longitud > 1
    propagar ArgumentError, "Criteria#where requiere cero o un argumento (dado #{args.length})"
  end
  si args.longitud == 1
    expresión = args.primero
    si expresión.is_a?(::String) && ¿Incorporado?
      propagar Errors::Javascript no compatible.Nuevo(klass, expresión)
    end
  end
  super
end

#sin(*args) ⇒ Criterio

Anulado 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 -= id_fields
  super(*args)
end

#sin_opciones ⇒ Criterio

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

Ejemplos:

Obtener los criterios sin opciones.

criteria.without_options

Devuelve:



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

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