En MongoDB el db.collection.find() selecciona documentos en una colección o vista y devuelve un cursor a los documentos seleccionados..
La collection parte es el nombre de la colección o vista a buscar.
Puede usarlo para devolver todos los documentos, solo algunos o solo un documento. También puede especificar qué campos deben devolverse.
Es importante tener en cuenta que en realidad no devuelve los documentos. Simplemente devuelve un cursor a los documentos. Habiendo dicho eso, es más fácil decir que "devuelve documentos" y, por lo general, se lo menciona de esa manera, incluso en este artículo 🙂
Devolver todos los documentos
Aquí hay un ejemplo para demostrarlo.
db.pets.find()Resultado:
{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat", "weight" : 3 }
Aquí, usamos find() método para devolver todos los documentos de las pets recopilación. Sabemos que esto devuelve todos los documentos porque no proporcionamos ningún criterio de filtrado. De hecho, no proporcionamos ningún argumento.
Cuando se llama sin argumentos, find() devuelve todos los documentos de una colección y devuelve todos los campos de los documentos.
Otra forma de hacer lo anterior es así:
db.pets.find({})En este caso pasamos un documento vacío.
Al agregar a este documento vacío, podemos comenzar a filtrar los resultados.
Filtrar los resultados
La sintaxis real de find() va así:
db.collection.find(query, projection)Esto significa que puede pasar una consulta como primer argumento y una proyección como segundo.
Si pasa una consulta, se utiliza para filtrar los resultados. Una consulta es un documento que contiene operadores de consulta. Como vimos en el ejemplo anterior, un documento vacío devuelve todos los documentos.
Reduzcamos los resultados a un subconjunto de documentos de la colección.
db.pets.find({"type":"Dog"})Resultado:
{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
Esto redujo los resultados a solo aquellos documentos que tienen un type campo con un valor de Dog .
En este caso, simplemente pasamos un documento como criterio de filtrado.
También puede utilizar operadores de consulta. Estos le permiten aplicar criterios más específicos a su consulta.
Ejemplo:
db.pets.find({"weight": { $lt: 10 }})Resultado:
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat", "weight" : 3 } Documentos incrustados
Si tiene documentos que contienen documentos incrustados, puede usar los siguientes métodos para consultar datos en los documentos incrustados.
- Notación de puntos (p. ej.,
field.nestedfield: <value>) - Forma anidada (por ejemplo, {
field: { nestedfield: <value> } }). Tenga en cuenta que esta opción solo está disponible desde MongoDB 4.4.
Supongamos que insertamos el siguiente documento.
db.pets.insertOne({
"_id" : 6,
"name" : "Fetch",
"type" : "Dog",
"specs" : {
"height" : 400,
"weight" : 15,
"color" : "brown"
}
}) Podemos usar la notación de puntos para consultar dentro del documento incrustado.
db.pets.find({ "specs.height": 400 })Resultado:
{ "_id" : 6, "name" : "Fetch", "type" : "Dog", "specs" : { "height" : 400, "weight" : 15, "color" : "brown" } } La siguiente consulta devuelve el mismo documento, excepto que esta vez hacemos referencia al documento incrustado utilizando un formulario anidado.
db.pets.find({
"specs" : {
"height" : 400,
"weight" : 15,
"color" : "brown"
}
})Resultado:
{ "_id" : 6, "name" : "Fetch", "type" : "Dog", "specs" : { "height" : 400, "weight" : 15, "color" : "brown" } } Cuando se utiliza el formulario anidado, la consulta debe coincidir exactamente con todo el documento incrustado. Por ejemplo, la siguiente consulta no coincide:
db.pets.find({
"specs" : {
"height" : 400
}
})Dar formato a los resultados
El resultado del ejemplo anterior se devolvió en una línea. Puedes usar el cursor.pretty() método para configurar el cursor para mostrar los resultados en un formato más legible.
Para usar pretty() añádalo a find() método.
Ejemplo:
db.pets.find({ "_id": 6 }).pretty()Resultado:
{
"_id" : 6,
"name" : "Fetch",
"type" : "Dog",
"specs" : {
"height" : 400,
"weight" : 15,
"color" : "brown"
}
} Arreglos
Puede hacer referencia a datos en matrices haciendo referencia al elemento de la matriz por su índice o por su valor.
Supongamos que insertamos el siguiente documento:
db.pets.insertOne({
"_id" : 7,
"name" : "Jake",
"type" : "Dog",
"awards" : [
"Top Dog",
"Best Dog",
"Biggest Dog"
]
}) Si quisiéramos encontrar todos los perros con el premio Top Dog, podríamos escribir la siguiente consulta (que devolverá el perro anterior).
db.pets.find({
"awards": "Top Dog"
}).pretty()Resultado:
{
"_id" : 7,
"name" : "Jake",
"type" : "Dog",
"awards" : [
"Top Dog",
"Best Dog",
"Biggest Dog"
]
} También puede especificar el índice del elemento, así:
db.pets.find({
"awards.0": "Top Dog"
}).pretty()Hacer eso requiere que el valor especificado esté en el índice especificado. Por lo tanto, la siguiente consulta no devuelve el mismo perro.
db.pets.find({
"awards.1": "Top Dog"
}).pretty()Tenga en cuenta que las matrices se basan en cero, por lo que un índice de 0 especifica el primer elemento, 1 especifica el segundo elemento, y así sucesivamente.
Proyecciones
De forma predeterminada, todos los campos del documento se devuelven cuando usa find() . Pero puede usar proyecciones para reducir la cantidad de campos devueltos si es necesario.
Puede recordar que la sintaxis de find() va así:
db.collection.find(query, projection)
Donde query proporciona los criterios de filtrado (que hemos hecho en los ejemplos anteriores) y projection es una proyección opcional que especifica qué campos devolver de cualquier documento coincidente. Por lo tanto, si queremos usar una proyección, simplemente la ponemos después de la consulta.
Cuando usa una proyección, puede especificar los campos para incluir , los campos a excluir , o ambos. Para hacer esto, enumere el nombre del campo y un 1 (para incluirlo) o 0 (para excluirlo).
Por ahora, nuestra colección contiene los siguientes documentos:
{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat", "weight" : 3 }
{ "_id" : 6, "name" : "Fetch", "type" : "Dog", "specs" : { "height" : 400, "weight" : 15, "color" : "brown" } }
{ "_id" : 7, "name" : "Jake", "type" : "Dog", "awards" : [ "Top Dog", "Best Dog", "Biggest Dog" ] } Este es un ejemplo del uso de una proyección para especificar los campos a incluir:
db.pets.find({}, { name: 1, type: 1 })Resultado:
{ "_id" : 1, "name" : "Wag", "type" : "Dog" }
{ "_id" : 2, "name" : "Bark", "type" : "Dog" }
{ "_id" : 3, "name" : "Meow", "type" : "Cat" }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat" }
{ "_id" : 5, "name" : "Bruce", "type" : "Bat" }
{ "_id" : 6, "name" : "Fetch", "type" : "Dog" }
{ "_id" : 7, "name" : "Jake", "type" : "Dog" }
Observe que el _id campo se devuelve aunque no lo incluimos en nuestra proyección. Este campo es una excepción y se incluye de forma predeterminada.
Si no desea el _id campo que se devolverá, debe excluirlo explícitamente.
db.pets.find({}, { _id: 0, name: 1, type: 1 })Resultado:
{ "name" : "Wag", "type" : "Dog" }
{ "name" : "Bark", "type" : "Dog" }
{ "name" : "Meow", "type" : "Cat" }
{ "name" : "Scratch", "type" : "Cat" }
{ "name" : "Bruce", "type" : "Bat" }
{ "name" : "Fetch", "type" : "Dog" }
{ "name" : "Jake", "type" : "Dog" } Aquí hay otro ejemplo, esta vez solo especificamos qué campos excluir.
db.pets.find({}, { _id: 0, weight: 0, specs: 0, awards: 0 })Resultado:
{ "name" : "Wag", "type" : "Dog" }
{ "name" : "Bark", "type" : "Dog" }
{ "name" : "Meow", "type" : "Cat" }
{ "name" : "Scratch", "type" : "Cat" }
{ "name" : "Bruce", "type" : "Bat" }
{ "name" : "Fetch", "type" : "Dog" }
{ "name" : "Jake", "type" : "Dog" } Más Proyecciones
Hay varias otras cosas que puede hacer con las proyecciones. Por ejemplo, a partir de MongDB 4.4 puede usar expresiones agregadas para especificar el valor de un campo proyectado.
Ejemplo:
db.pets.find({}, {
"_id": 0,
"n": "$name",
"t": "$type",
"w": "$weight"
})Resultado:
{ "n" : "Wag", "t" : "Dog", "w" : 20 }
{ "n" : "Bark", "t" : "Dog", "w" : 10 }
{ "n" : "Meow", "t" : "Cat", "w" : 7 }
{ "n" : "Scratch", "t" : "Cat", "w" : 8 }
{ "n" : "Bruce", "t" : "Bat", "w" : 3 }
{ "n" : "Fetch", "t" : "Dog" }
{ "n" : "Jake", "t" : "Dog" }
Aquí, cambiamos el nombre de los nombres de los campos. Hicimos esto especificando un nuevo nombre para cada campo como un literal de cadena, usando $fieldName sintaxis para generar el valor de ese campo. El resultado es un poco como usar alias en SQL.
Más información
Consulte la documentación de MongoDB para obtener más información.
