Módulo: Mongoid::Findable

Ampliado por:
Reenviable
Definido en:
lib/mongoid/findable.rb

Overview

Este módulo define los métodos de búsqueda que se asocian al documento a nivel de clase.

Resumen del método de instancia colapsar

Detalles del método de instancia

#cualquiera? ⇒ verdadero | falso

Devuelve "true" si existen document que cumplan con los criterios.

Ejemplos:

Determine si existen document

Model.any?

Devuelve:

  • (true | false) —

    Si existen documentos.



124
125
126
 
# Archivo 'lib/mongoid/findable.rb', línea 124

def any?
  limit(1).count > 0
end

#count ⇒ Integer

Devuelve un recuento de registros en la base de datos. Si quieres especificar condiciones, utiliza WHERE.

Ejemplos:

Obtiene el recuento de documentos que coinciden.

Person.count
Person.where(title: "Sir").count

Devuelve:

  • (Número entero) —

    El número de documentos coincidentes.



73
74
75
 
# Archivo 'lib/mongoid/findable.rb', línea 73

def count
  con_ámbito_predeterminado.count
end

#empty? ⇒ true | false

Devuelve verdadero si el recuento es cero

Ejemplos:

¿No hay documentos guardados para este modelo?

Person.empty?

Devuelve:

  • (true | false) —

    Si la colección está vacía.



93
94
95
 
# Archivo 'lib/mongoid/findable.rb', línea 93

def ¿vacío?
  count == 0
end

#estimated_count ⇒ Entero

Devuelve un recuento estimado de registros en la base de datos.

Ejemplos:

Obtiene el recuento de documentos que coinciden.

Person.estimated_count

Devuelve:

  • (Número entero) —

    El número de documentos coincidentes.



83
84
85
 
# Archivo 'lib/mongoid/findable.rb', línea 83

def estimated_count
  con_ámbito_predeterminado.estimated_count
end

#¿exists?(id_or_conditions = :none) ⇒ true | false

Devuelve verdadero si hay algún documento en la base de datos según los argumentos proporcionados.

Ejemplos:

¿Existen documentos para las condiciones?

Person.exists?

¿Existen documentos para la _id dada?

Person.exists?(BSON::ObjectId(...))

¿Existen documentos para las condiciones dadas?

Person.exists?(name: "...")

Parámetros:

  • id_or_conditions (Hash | Objeto | falso) (por defecto: :none) —

    un _id para buscar, un hash de condiciones, nil o falso.

Devuelve:

  • (true | false) —

    Si existen documentos para las condiciones. Siempre es falso si se pasa nil o false.



114
115
116
 
# Archivo 'lib/mongoid/findable.rb', línea 114

def ¿existe?(id_or_conditions = none)
  con_ámbito_predeterminado.¿existe?(id_or_conditions)
end

#find(*args, &block) ⇒ 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 un Document o varios documentos por sus valores de _id.

Si se proporciona un solo argumento que no es un arreglo, este argumento se interpreta como el valor _id del documento que se busca. Si existe un documento que coincida en la base de datos, este documento se devuelve; de lo contrario, si la opción de configuración de Mongoid raise_not_found_error es verdadera (que es la opción por defecto), se lanza Errors::DocumentNotFound, y si raise_not_found_error es falsa, find devuelve nil.

Si se dan múltiples argumentos, o si se da un argumento tipo arreglo, se aplana el arreglo y se interpreta cada elemento del arreglo como el valor de _id del documento que se debe buscar. Mongoid luego intenta recuperar todos los documentos con los valores de _id proporcionados. El valor devuelto es un arreglo de Documentos encontrados. Cada documento aparece una vez en el arreglo devuelto, incluso si su _id se proporciona varias veces en el argumento de find. Si la opción de configuración raise_not_found_error Mongoid es verdadera, Errors::DocumentNotFound se generará una excepción si alguno de los _ids especificados no se encuentra en la base de datos. Si la opción de configuración de Mongoid raise_not_found_error es falsa, solo se devuelven aquellos documentos que se encuentran; si no se encuentra ningún documento, el valor de retorno es un arreglo vacío.

Ten en cuenta que MongoDB no permite que el campo _id sea un arreglo.

El argumento se somete a las conversiones habituales de tipo Mongoid según el tipo declarado para el campo _id. Por defecto, el campo _id es un BSON::ObjectId; esto permite que las cadenas se pasen a find y las cadenas se convertirán de forma transparente en instancias de BSON::ObjectId durante la construcción de consultas.

Si a este método se le pasa un bloque, delega en Enumerable#find y retorna el primer document de aquellos encontrados por el objeto Criteria actual para los cuales el bloque retorna un valor "truthy". Si se proporcionan tanto un bloque como identificadores, el bloque será ignorado y se devolverán los documentos correspondientes a los identificadores proporcionados. Si se proporciona un bloque y un proc, el método delega en Enumerable#find y utiliza el proc como valor por defecto.

El método find tiene en cuenta el ámbito por defecto definido en la clase del modelo, si existe.

Parámetros:

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

    El o los id a localizar.

Devuelve:

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

    Un documento o documentos coincidentes.

Aumenta:

  • Errores::DocumentoNoEncontrado Si no se encuentran todos los documentos y la opción de configuración de Mongoid raise_not_found_error es verdadera.



197
198
199
200
201
202
203
204
 
# Archivo 'lib/mongoid/findable.rb', línea 197

def buscar(*args, &bloque)
  empty_or_proc = args.¿vacío? || (args.longitud == 1 && args.primero.is_a?(Proc))
  si ¿block_given? && empty_or_proc
    con_ámbito_predeterminado.buscar(*args, &bloque)
  else
    con_ámbito_predeterminado.buscar(*args)
  end
end

#find_by(attrs = {}) {|result| ... } ⇒ documento | nil

Encuentra el primer Document dado las condiciones. Si no se encuentra un documento coincidente y Mongoid.raise_not_found_error es verdadero, arroja Mongoid::Errors::DocumentNotFound y devuelve nulo nil de otra manera.

y Mongoid.raise_not_found_error es verdadero.

Ejemplos:

Buscar el documento por un atributo que no sea su id

Person.find_by(:username => "superuser")

Parámetros:

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

    Los atributos que se van a comprobar.

Rendimientos:

  • (resultado)

Devuelve:

  • (Document | nil) —

    Un documento coincidente.

Aumenta:



220
221
222
223
224
225
226
 
# Archivo 'lib/mongoid/findable.rb', línea 220

def find_by(attrs = {})
  Resultado = dónde(attrs).find_first
  propagar(Errors::DocumentoNoEncontrado.Nuevo(sí mismo, attrs)) si Resultado.nil? && Mongoid.raise_not_found_error

  rendimiento(Resultado) si Resultado && ¿block_given?
  Resultado
end

#find_by!(attrs = {}) {|result| ... } ⇒ Documento

Encuentra el primer Document dadas las condiciones, o lanza Mongoid::Errors::DocumentNotFound

Ejemplos:

Buscar el documento por un atributo que no sea su id

Person.find_by(:username => "superuser")

Parámetros:

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

    Los atributos que se van a comprobar.

Rendimientos:

  • (resultado)

Devuelve:

Aumenta:



239
240
241
242
243
244
245
 
# Archivo 'lib/mongoid/findable.rb', línea 239

def find_by!(attrs = {})
  Resultado = dónde(attrs).find_first
  propagar(Errors::DocumentoNoEncontrado.Nuevo(sí mismo, attrs)) a menos que Resultado

  rendimiento(Resultado) si Resultado && ¿block_given?
  Resultado
end

#first(limite = nil) ⇒ Documento también conocido como: uno

Encuentra el primer Document dadas las condiciones.

Ejemplos:

Encuentre el primer documento.

Person.first

Parámetros:

  • limit (Integer) (valor por defecto: nil) —

    El número de documentos a devolver.

Devuelve:

  • (documento) —

    El primer documento coincidente.



255
256
257
 
# Archivo 'lib/mongoid/findable.rb', línea 255

def primero(limit = nulo)
  con_ámbito_predeterminado.primero(limit)
end

#last(limit = nil) ⇒ Document

Encuentra el último Document dado las condiciones.

Ejemplos:

Encuentra el último documento.

Person.last

Parámetros:

  • limit (Integer) (valor por defecto: nil) —

    El número de documentos a devolver.

Devuelve:

  • (documento) —

    El último documento coincidente.



268
269
270
 
# Archivo 'lib/mongoid/findable.rb', línea 268

def último(limit = nulo)
  con_ámbito_predeterminado.último(limit)
end

#muchos? ⇒ verdadero | falso

Devuelve verdadero si existe más de un document en los criterios.

Ejemplos:

Determinar si existen muchos documentos

Model.many?

Devuelve:

  • (true | false) —

    Si existen muchos documentos.



144
145
146
 
# Archivo 'lib/mongoid/findable.rb', línea 144

def ¿muchos?
  limit(2).count > 1
end

#¿one? ⇒ verdadero | falso

Devuelve true si solo existe un document en los criterios.

Ejemplos:

Determina si solo existe un document

Model.one?

Devuelve:

  • (true | false) —

    Si solo existe un document.



134
135
136
 
# Archivo 'lib/mongoid/findable.rb', línea 134

def ¿uno?
  limit(2).count == 1
end