db.colección.find() (método mongosh)

MongoDB con controladores

Esta página documenta una mongosh . Para ver el método equivalente en un driver de MongoDB, se debe consultar la página correspondiente al lenguaje de programación:

C#Java Sync Node.js PyMongo C C++Go Java RS Kotlin Coroutine Kotlin Sync PHP Mongoid Rust Scala

Definición

db.collection.find(query, projection, options)

Selecciona documentos en una colección o vista y devuelve un cursor a los documentos seleccionados.

Devuelve:	Un cursor para los documentos que cumplen con los criterios de`query`. Cuando el método `find()` "devuelve documentos", en realidad está devolviendo un cursor a los documentos.

Compatibilidad

Este método está disponible en implementaciones alojadas en los siguientes entornos:

MongoDB Atlas: El servicio totalmente gestionado para implementaciones de MongoDB en la nube

Nota

Este comando es compatible con todos los clústeres de MongoDB Atlas. Para obtener información sobre el soporte de Atlas para todos los comandos, consulte Comandos no compatibles.

MongoDB Enterprise: La versión basada en suscripción y autogestionada de MongoDB
MongoDB Community: La versión de MongoDB con código fuente disponible, de uso gratuito y autogestionada.

Sintaxis

El método find() tiene la siguiente forma:

db.collection.find( <query>, <projection>, <options> )

Parámetros

El método find() toma los siguientes parámetros:

Parameter	Tipo	Descripción
Consulta	Documento	Opcional. Especifica el filtro de selección mediante operadores del query. Para devolver todos los documentos de una colección, omite este parámetro o pasa un documento vacío (`{}`).
proyección	Documento	Opcional. Especifica los campos que se deben devolver en los documentos que coinciden con el filtro de query. Para devolver todos los campos en los documentos coincidentes, omite este parámetro. Para obtener más detalles, consulta Proyección.
opciones	Documento	Opcional. Especifica opciones adicionales para la query. Estas opciones modifican el comportamiento de la query y cómo se devuelven los resultados. Para más detalles, consulta Opciones.

Comportamiento

Proyección

Importante

Consistencia del lenguaje

Como parte de hacer que la proyección de find() y findAndModify() sea coherente con la etapa de $project de agregación,

La proyección find() y findAndModify() pueden aceptar expresiones y sintaxis de agregación.
MongoDB aplica restricciones adicionales con respecto a las proyecciones. Consulta restricciones de proyección para obtener más detalles.

El parámetro projection determina qué campos se devuelven en los documentos coincidentes. El parámetro projection acepta un documento con el siguiente formato:

{ <field1>: <value>, <field2>: <value> ... }

Proyección	Descripción
`<field>: <1 or true>`	Especifica la inclusión de un campo. Si especificas un entero distinto de cero para el valor de proyección, la operación trata el valor como `true`.
`<field>: <0 or false>`	Especifica la exclusión de un campo.
`"<field>.$": <1 or true>`	Utiliza el operador de proyección de arreglo `$` para devolver el primer elemento que coincide con la condición de query en el campo de arreglo. Si especificas un entero distinto de cero para el valor de proyección, la operación trata el valor como `true`. No disponible para las vistas.
`<field>: <array projection>`	Utiliza los operadores de proyección de arreglos (`$elemMatch`, `$slice`) para especificar los elementos del arreglo que se deben incluir. No disponible para las vistas.
`<field>: <$meta expression>`	Utilice la expresión del operador `$meta` para especificar la inclusión de `per-document metadata`disponibles. No disponible para las vistas.
`<field>: <aggregation expression>`	Especifica el valor del campo proyectado. Con el uso de expresiones y sintaxis de agregación, incluido el uso de literales y variables de agregación, se pueden proyectar campos nuevos o proyectar campos existentes con valores nuevos. Si se especifica un literal no numérico, no booleano (como una cadena de caracteres, un arreglo o una expresión de operador) para el valor de proyección, el campo se proyecta con el nuevo valor, por ejemplo: `{ field: [ 1, 2, 3, "$someExistingField" ] }` `{ field: "New String Value" }` `{ field: { status: "Active", total: { $sum: "$existingArray" } } }` Para proyectar un valor literal para un campo, utiliza la expresión de agregación `$literal`; por ejemplo: `{ field: { $literal: 5 } }` `{ field: { $literal: true } }` `{ field: { $literal: { fieldWithValue0: 0, fieldWithValue1: 1 } } }`

opciones

Opción	Descripción
allowDiskUse	Si las pipelines que requieren más de 100 megabytes de memoria para ejecutarse se escriben o no en archivos temporales en el disco. Para obtener más detalles, consulta `cursor.allowDiskUse()`.
permitir resultados parciales	Para las queries sobre una colección fragmentada, permite que el comando (o los comandos getMore posteriores) devuelvan resultados parciales, en lugar de un error, si uno o más fragmentos consultados no están disponibles.
awaitData	Si el cursor es un cursor de seguimiento y espera. Requiere que `tailable` sea `true`.
intercalación	Configuración de intercalación para la operación de actualización.
comment	Agrega un `$comment` a la query que se muestra en los registros del perfilador.
explicar	Añade la salida de explicación según el modo de nivel de verbosidad proporcionado.
hint	Obliga al optimizador del query a usar índices específicos en el query.
limit	Establece un límite de documentos que se devuelven en el conjunto de resultados.
máximo	El límite superior exclusivo para un índice específico.
maxAwaitTimeMS	El tiempo máximo que el servidor esperará nuevos documentos para satisfacer una query de cursor con seguimiento. Requiere que `tailable` y `awaitData` sean `true`.
maxTimeMS	El tiempo máximo (en milisegundos) que el servidor debe permitir que la query se ejecute.
min	El límite inferior inclusivo para un índice específico.
noCursorTimeout	Si el servidor debería cerrar el cursor después de un período de inactividad (10 minutos por defecto).
proyección	Especifica los campos que se devolverán en los documentos que coincidan con el filtro de query. Puedes especificar la proyección de dos maneras para `find()` y `findOne()`: Estableciendo el parámetro `projection` Configurando el parámetro `options` a `projection` Si especificas ambos parámetros, el parámetro `projection` tiene prioridad. Para usar `options.projection`, establece el parámetro `projection` en `null` o `undefined`.
readConcern	Especifica el nivel de consistencia de lectura para la query.
readPreference	Especifica el nivel de preferencia de lectura para la query.
returnKey	Si solo se devuelven las claves de índice para una query.
showRecordId	Si se agrega el campo `$recordId` a los documentos devueltos. El `$recordId` indica la posición del documento en el conjunto de resultados.
Omitir	Cuántos documentos se deben omitir antes de devolver el primer documento del conjunto de resultados.
sort	El orden de los documentos devueltos en el conjunto de resultados. Los campos especificados en la ordenación deben tener un índice.
con seguimiento	Indica si es un cursor con seguimiento. Los cursores con seguimiento permanecen abiertos una vez agotados los resultados iniciales de la query. Los cursores con seguimiento solo están disponibles en las colecciones con tamaño fijo.

Especificación de campo embebido

Para campos en documentos incrustados, puedes especificar el campo mediante:

notación de puntos, por ejemplo "field.nestedfield": <value>
formulario anidado, por ejemplo { field: { nestedfield: <value> } }

`_id` Proyección de campo

El campo _id se incluye por defecto en los documentos devueltos, a menos que especifiques explícitamente _id: 0 en la proyección para suprimir el campo.

Inclusión o exclusión

Una projection no puede contener ambas especificaciones de inclusión y exclusión, con la excepción del campo _id:

En las proyecciones que incluyen explícitamente campos, el campo _id es el único campo que puedes excluir explícitamente.
En las proyecciones que excluyen explícitamente campos, el campo _id es el único campo que puedes incluir explícitamente; sin embargo, el campo _id se incluye por defecto.

Consulte Ejemplos de Proyección.

Clasificación

Cuando una operación ordena y proyecta con los mismos campos, MongoDB ordena según los valores originales de los campos antes de aplicar la proyección. Para obtener más información sobre el orden de las operaciones, consulta find() Orden de las operaciones.

Cursor Handling

La ejecución de db.collection.find() en mongosh itera automáticamente el cursor para mostrar hasta los primeros 20 documentos. Escriba it para continuar con la iteración.

Para acceder a los documentos devueltos con un controlador, utiliza el mecanismo de manejo del cursor apropiado para el lenguaje del controlador.

Tip

Iterar el cursor devuelto
Modificar el comportamiento del cursor
Métodos de cursor disponibles en mongosh

readConcern

Para especificar el nivel de consistencia de lectura para db.collection.find(), utiliza el método cursor.readConcern().

Tipos de corchetes

MongoDB considera algunos tipos de datos como equivalentes para fines de comparación. Por instancia, los tipos numéricos se convierten antes de la comparación. Sin embargo, para la mayoría de los tipos de datos, los operadores de comparación solo realizan comparaciones en documentos donde el tipo BSON del campo de destino coincide con el tipo del operando de query. Considera la siguiente colección:

{ "_id": "apples", "qty": 5 }
{ "_id": "bananas", "qty": 7 }
{ "_id": "oranges", "qty": { "in stock": 8, "ordered": 12 } }
{ "_id": "avocados", "qty": "fourteen" }

La siguiente query utiliza $gt para devolver documentos donde el valor de qty es mayor que 4.

db.collection.find( { qty: { $gt: 4 } } )

La query devuelve los siguientes documentos:

{ "_id": "apples", "qty": 5 }
{ "_id": "bananas", "qty": 7 }

El documento con _id igual a "avocados" no se devuelve porque su valor qty es de tipo string mientras que el operando $gt es de tipo integer.

El documento con _id igual a "oranges" no se devuelve porque su valor qty es de tipo object.

Nota

Para aplicar tipos de datos en una colección, utiliza la validación de esquema.

Sesiones

Para los cursores creados dentro de una sesión, no puedes llamar a getMore fuera de la sesión.

De manera similar, para los cursores creados fuera de una sesión, no puedes llamar a getMore dentro de una sesión.

Tiempo de espera de inactividad de la sesión

Los drivers de MongoDB y mongosh asocian todas las operaciones con una sesión de servidor, con la excepción de las operaciones de escritura no reconocidas. Para las operaciones no asociadas explícitamente a una sesión (es decir, mediante Mongo.startSession()), los drivers de MongoDB y mongosh crean una sesión implícita y la asocian con la operación.

Si una sesión está inactiva durante más de 30 minutos, MongoDB Server marca esa sesión como expirada y puede cerrarla en cualquier momento. Cuando MongoDB Server cierra la sesión, también finaliza cualquier operación en curso y cierra los cursores abiertos asociados con la sesión. Esto incluye cursores configurados con noCursorTimeout() o un maxTimeMS() mayor a 30 minutos.

Para las operaciones que puedan estar inactivas durante más de 30 minutos, asocia la operación con una sesión explícita con Mongo.startSession() y actualiza periódicamente la sesión con el comando refreshSessions. Consulta Tiempo de espera de inactividad de la sesión para obtener más información.

Transacciones

db.collection.find() puede usarse dentro de transacciones distribuidas.

Para los cursores creados fuera de una transacción, no puedes llamar a getMore dentro de la transacción.
Para los cursores creados en una transacción, no puedes llamar a getMore fuera de la transacción.

Importante

En la mayoría de los casos, una transacción distribuida incurre en un costo de rendimiento mayor que las escrituras de documentos individuales, y la disponibilidad de transacciones distribuidas no debería ser un sustituto para un diseño de esquema efectivo. Para muchos casos, el modelo de datos desnormalizado (documento incrustado y matrices) seguirá siendo óptimo para tus datos y casos de uso. Es decir, en muchos casos, modelar tus datos de forma adecuada minimizará la necesidad de transacciones distribuidas.

Para consideraciones adicionales sobre el uso de transacciones (como el límite de tiempo de ejecución y el límite de tamaño del oplog), consulta también las consideraciones de producción.

Desconexión del cliente

Si el cliente que emitió db.collection.find() se desconecta antes de que la operación se complete, MongoDB marca db.collection.find() para su terminación usando killOp.

Configuración de query

Nuevo en la versión 8.0.

Puedes utilizar la configuración de query para establecer sugerencias de índice, fijar filtros de rechazo de operación y otros campos. Los ajustes se aplican a la forma de la query en todo el clúster. El clúster retiene la configuración después del apagado.

El optimizador de query utiliza la configuración del query como entrada adicional durante la planificación del query, lo que afecta al plan seleccionado para ejecutar el query. También puedes usar la configuración del query para bloquear una forma del query.

Para añadir configuraciones de query y explorar ejemplos, consulte setQuerySettings.

Puedes añadir configuraciones de query para los comandos find, distinct, y aggregate.

La configuración de query tiene más funcionalidades y se prefiere sobre los filtros de índice en desuso.

Para remover la configuración del query, utilice removeQuerySettings. Para obtener la configuración del query, utilice una etapa de $querySettings en una canalización de agregación.

Ejemplos

Los ejemplos en esta sección utilizan documentos de la colección bios, donde los documentos generalmente tienen la forma:

{
    "_id" : <value>,
    "name" : { "first" : <string>, "last" : <string> },       // embedded document
    "birth" : <ISODate>,
    "death" : <ISODate>,
    "contribs" : [ <string>, ... ],                           // Array of Strings
    "awards" : [
        { "award" : <string>, year: <number>, by: <string> }  // Array of embedded documents
        ...
    ]
}

Para crear y poblar la colección bios, consulta la colección bios.

Encuentre todos los documentos en una colección

El método find() sin parámetros devuelve todos los documentos de una colección y todos los campos de los documentos. Por ejemplo, la siguiente operación devuelve todos los documentos en la colección bios:

db.bios.find()

Encuentra documentos que coincidan con los criterios de query

Query para la igualdad

La siguiente operación devuelve documentos en la colección bios donde _id es igual a 5:
```
db.bios.find( { _id: 5 } )
```
La siguiente operación devuelve documentos en la colección bios donde el campo last en el documento incrustado name es igual a "Hopper":
```
db.bios.find( { "name.last": "Hopper" } )
```
Nota
Para acceder a campos en un documento incrustado, utiliza notación de puntos ("<embedded document>.<field>").

Query mediante operadores

Para encontrar documentos que cumplan con un conjunto de criterios de selección, llama al método find() con el parámetro <criteria>.

MongoDB proporciona varios operadores del query para especificar los criterios.

La siguiente operación utiliza el operador $in para devolver documentos en la colección bios donde _id es igual a 5 o ObjectId("507c35dd8fada716c89d0013"):
```
db.bios.find(
   { _id: { $in: [ 5, ObjectId("507c35dd8fada716c89d0013") ] } }
)
```
La siguiente operación utiliza el operador $gt para devolver todos los documentos de la colección bios donde birth es mayor que new Date('1950-01-01'):
```
db.bios.find( { birth: { $gt: new Date('1950-01-01') } } )
```
La siguiente operación utiliza el operador $regex para devolver documentos en la colección bios donde el campo name.last empieza con la letra N (o es "LIKE N%")
```
db.bios.find(
   { "name.last": { $regex: /^N/ } }
)
```

Para obtener una lista de los operadores del query, consulte Predicados de query.

Query de rangos

Combina los operadores de comparación para especificar rangos para un campo. La siguiente operación devuelve documentos de la colección bios donde birth está entre new Date('1940-01-01') y new Date('1960-01-01') (exclusivamente):

db.bios.find( { birth: { $gt: new Date('1940-01-01'), $lt: new Date('1960-01-01') } } )

Para obtener una lista de los operadores del query, consulte Predicados de query.

Query para múltiples condiciones

La siguiente operación devuelve todos los documentos de la colección bios donde el campo birth es greater than new Date('1950-01-01') y el campo death no existe:

db.bios.find( {
   birth: { $gt: new Date('1920-01-01') },
   death: { $exists: false }
} )

Para obtener una lista de los operadores del query, consulte Predicados de query.

Comparar dos campos de un único documento

$expr puede contener expresiones que comparen campos del mismo documento.

Crea una colección monthlyBudget con estos documentos:

db.monthlyBudget.insertMany( [
   { _id : 1, category : "food", budget : 400, spent : 450 },
   { _id : 2, category : "drinks", budget : 100, spent : 150 },
   { _id : 3, category : "clothes", budget : 100, spent : 50 },
   { _id : 4, category : "misc", budget : 500, spent : 300 },
   { _id : 5, category : "travel", budget : 200, spent : 650 }
] )

La siguiente operación utiliza $expr para encontrar documentos donde el monto de spent excede el budget:

db.monthlyBudget.find( { $expr: { $gt: [ "$spent" , "$budget" ] } } )

Salida:

{ _id : 1, category : "food", budget : 400, spent : 450 }
{ _id : 2, category : "drinks", budget : 100, spent : 150 }
{ _id : 5, category : "travel", budget : 200, spent : 650 }

Consulta documentos incrustados

Los siguientes ejemplos de query al campo incrustado name en la colección bios.

Query de coincidencias exactas en documentos incrustados

La siguiente operación devuelve documentos en la colección bios donde el documento incrustado name es exactamente { first: "Yukihiro", last: "Matsumoto" }, incluido el orden:

db.bios.find(
    { name: { first: "Yukihiro", last: "Matsumoto" } }
)

El campo name debe coincidir exactamente con el documento incrustado. La query no coincide con los documentos que tienen los siguientes campos de name:

{
   first: "Yukihiro",
   aka: "Matz",
   last: "Matsumoto"
}
{
   last: "Matsumoto",
   first: "Yukihiro"
}

Campos de query de un documento incrustado

La siguiente operación devuelve documentos en la colección bios donde el documento incrustado name contiene un campo first con el valor "Yukihiro" y un campo last con el valor "Matsumoto". La query utiliza la notación de puntos para acceder a campos en un documento incrustado:

db.bios.find(
   {
     "name.first": "Yukihiro",
     "name.last": "Matsumoto"
   }
)

La query coincide con el documento donde el campo name contiene un documento incrustado con el campo first con el valor "Yukihiro" y un campo last con el valor "Matsumoto". Por ejemplo, la query coincidiría con documentos con name campos que contuvieran alguno de los siguientes valores:

{
  first: "Yukihiro",
  aka: "Matz",
  last: "Matsumoto"
}
{
  last: "Matsumoto",
  first: "Yukihiro"
}

Para obtener más información y ejemplos, consulta también Query sobre documentos incrustados/anidados.

Arreglos de query

Query para un elemento de arreglo

Los siguientes ejemplos consultan el arreglo contribs en la colección bios.

La siguiente operación devuelve documentos en la colección bios donde el campo de arreglo contribs contiene el elemento "UNIX":
```
db.bios.find( { contribs: "UNIX" } )
```
La siguiente operación devuelve documentos en la colección bios donde el campo de arreglo contribs contiene el elemento "ALGOL" o "Lisp":
```
db.bios.find( { contribs: { $in: [ "ALGOL", "Lisp" ]} } )
```
La siguiente operación utiliza el operador del query $all para devolver documentos en la colección bios donde el campo de arreglo contribs contiene ambos elementos "ALGOL" y "Lisp":
```
db.bios.find( { contribs: { $all: [ "ALGOL", "Lisp" ] } } )
```
Para ver más ejemplos, consulta $all. Consulta también $elemMatch.
La siguiente operación utiliza el operador $size para devolver documentos en la colección bios donde el tamaño del arreglo de contribs es 4:
```
db.bios.find( { contribs: { $size: 4 } } )
```

Para más información y ejemplos sobre cómo consultar un arreglo, consulta:

Para obtener una lista de operadores del query específicos de arreglos, consulte Operadores de predicados de query de arreglos.

Consulta un arreglo de documentos

Los siguientes ejemplos consultan el arreglo awards en la colección bios.

La siguiente operación devuelve documentos en la colección bios donde el arreglo awards contiene un elemento con el campo award igual a "Turing Award":
```
db.bios.find(
   { "awards.award": "Turing Award" }
)
```
La siguiente operación devuelve documentos en la colección bios donde el arreglo awards contiene al menos un elemento con el campo award igual a "Turing Award" y el campo year mayor que 1980:
```
db.bios.find(
   { awards: { $elemMatch: { award: "Turing Award", year: { $gt: 1980 } } } }
)
```
Utiliza el operador $elemMatch para especificar varios criterios en el elemento de un arreglo.

Para más información y ejemplos sobre cómo consultar un arreglo, consulta:

Para obtener una lista de operadores del query específicos de arreglos, consulte Operadores de predicados de query de arreglos.

Query para expresiones regulares BSON

Para encontrar documentos que contengan expresiones regulares BSON como valores, llame a find() con la opción bsonRegExp configurada en true. La opción bsonRegExp le permite devolver expresiones regulares que no se pueden representar como expresiones regulares de JavaScript.

La siguiente operación devuelve documentos en una colección llamada testbson donde el valor de un campo llamado foo es de tipo BSONRegExp:

db.testbson.find( {}, {}, { bsonRegExp: true } )

[
  {
    _id: ObjectId('65e8ba8a4b3c33a76e6cacca'),
    foo: BSONRegExp('(?-i)AA_', 'i')
  }
]

Proyecciones

El parámetro proyección especifica qué campos se deben devolver. El parámetro contiene especificaciones de inclusión o exclusión, no ambas, a menos que la exclusión sea para el campo _id.

Nota

A menos que el campo _id esté explícitamente excluido en el documento de proyección _id: 0, se devuelve el campo _id.

Especifica los campos a devolver

La siguiente operación encuentra todos los documentos en la colección bios y devuelve solo el campo name, el campo contribs y el campo _id.

db.bios.find( { }, { name: 1, contribs: 1 } )

Nota

A menos que el campo _id esté explícitamente excluido en el documento de proyección _id: 0, se devuelve el campo _id.

Campos explícitamente excluidos

La siguiente operación consulta la colección bios y devuelve todos los campos excepto el campo first en el documento incrustado name y el campo birth:

db.bios.find(
   { contribs: 'OOP' },
   { 'name.first': 0, birth: 0 }
)

Excluir explícitamente el `_id` campo

Nota

A menos que el campo _id esté explícitamente excluido en el documento de proyección _id: 0, se devuelve el campo _id.

La siguiente operación encuentra documentos en la colección bios y devuelve solo el campo name y el campo contribs:

db.bios.find(
   { },
   { name: 1, contribs: 1, _id: 0 }
)

Sobre arreglos y documentos incrustados

La siguiente operación consulta la colección bios y devuelve el campo last en el documento incrustado name y los dos primeros elementos del arreglo contribs:

db.bios.find(
   { },
   { _id: 0, 'name.last': 1, contribs: { $slice: 2 } } )

También puedes especificar campos incrustados utilizando la forma anidada. Por ejemplo:

db.bios.find(
   { },
   { _id: 0, name: { last: 1 }, contribs: { $slice: 2 } }
)

Utiliza la expresión de agregación

La proyección db.collection.find() puede aceptar expresiones y sintaxis de agregación.

Con el uso de expresiones de agregación y sintaxis, puedes proyectar campos nuevos o existentes con valores nuevos. Por ejemplo, la siguiente operación utiliza expresiones de agregación para sobrescribir el valor de los campos name y awards, así como para incluir campos nuevos reportDate, reportBy y reportNumber.

db.bios.find(
   { },
   {
     _id: 0,
     name: {
        $concat: [
           { $ifNull: [ "$name.aka", "$name.first" ] },
           " ",
           "$name.last"
        ]
     },
     birth: 1,
     contribs: 1,
     awards: { $cond: { if: { $isArray: "$awards" }, then: { $size: "$awards" }, else: 0 } },
     reportDate: { $dateToString: {  date: new Date(), format: "%Y-%m-%d" } },
     reportBy: "hellouser123",
     reportNumber: { $literal: 1 }
   }
)

Para establecer el campo reportRun al valor 1, la operación devuelve los siguientes documentos:

{ "birth" : ISODate("1924-12-03T05:00:00Z"), "contribs" : [ "Fortran", "ALGOL", "Backus-Naur Form", "FP" ], "name" : "John Backus", "awards" : 4, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1927-09-04T04:00:00Z"), "contribs" : [ "Lisp", "Artificial Intelligence", "ALGOL" ], "name" : "John McCarthy", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1906-12-09T05:00:00Z"), "contribs" : [ "UNIVAC", "compiler", "FLOW-MATIC", "COBOL" ], "name" : "Grace Hopper", "awards" : 4, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1926-08-27T04:00:00Z"), "contribs" : [ "OOP", "Simula" ], "name" : "Kristen Nygaard", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1931-10-12T04:00:00Z"), "contribs" : [ "OOP", "Simula" ], "name" : "Ole-Johan Dahl", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1956-01-31T05:00:00Z"), "contribs" : [ "Python" ], "name" : "Guido van Rossum", "awards" : 2, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1941-09-09T04:00:00Z"), "contribs" : [ "UNIX", "C" ], "name" : "Dennis Ritchie", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1965-04-14T04:00:00Z"), "contribs" : [ "Ruby" ], "name" : "Matz Matsumoto", "awards" : 1, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1955-05-19T04:00:00Z"), "contribs" : [ "Java" ], "name" : "James Gosling", "awards" : 2, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "contribs" : [ "Scala" ], "name" : "Martin Odersky", "awards" : 0, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }

Tip

Campos del proyecto a devolver del query

Iterar el cursor devuelto

El método find() devuelve un cursor a los resultados.

En mongosh, si el cursor devuelto no se asigna a una variable usando la palabra clave var, el cursor se itera automáticamente para acceder hasta los primeros 20 documentos que coincidan con la consulta. Puede actualizar la variable displayBatchSize para cambiar la cantidad de documentos que se iteran automáticamente.

El siguiente ejemplo establece el tamaño del lote en 3. Las futuras operaciones de db.collection.find() solo devolverán 3 documentos por cada iteración del cursor.

config.set( "displayBatchSize", 3 )

Para iterar manualmente sobre los resultados, asigna el cursor devuelto a una variable con la palabra clave var, como se muestra en las siguientes secciones.

Con Nombre de Variable

El siguiente ejemplo utiliza la variable myCursor para iterar sobre el cursor e imprimir los documentos coincidentes:

var myCursor = db.bios.find( );
myCursor

Con el método `next()`

El siguiente ejemplo utiliza el método cursor next() para acceder a los documentos:

var myCursor = db.bios.find( );
var myDocument = myCursor.hasNext() ? myCursor.next() : null;
if (myDocument) {
    var myName = myDocument.name;
    print (tojson(myName));
}

Para imprimir, también puedes utilizar el método printjson() en lugar de print(tojson()):

if (myDocument) {
   var myName = myDocument.name;
   printjson(myName);
}

Con el método `forEach()`

El siguiente ejemplo utiliza el método forEach() para iterar el cursor y acceder a los documentos:

var myCursor = db.bios.find( );
myCursor.forEach(printjson);

Modificar el comportamiento del cursor

mongosh y los controladores proporcionan varios métodos de cursor que llaman al cursor devuelto por el método find() para modificar su comportamiento.

Ordenar documentos en el conjunto de resultados

El método sort() ordena los documentos en el conjunto de resultados. La siguiente operación devuelve documentos dentro de la colección bios ordenados en orden ascendente por el campo name:

db.bios.find().sort( { name: 1 } )

sort() corresponde a la instrucción ORDER BY en SQL.

Limita la cantidad de documentos a devolver

El método de limit() limita el número de documentos en el conjunto de resultados. La siguiente operación devuelve como máximo 5 documentos en la colección bios:

db.bios.find().limit( 5 )

limit() corresponde a la instrucción LIMIT en SQL.

Establece el punto de inicio del conjunto de resultados

El método skip() controla el punto de inicio del conjunto de resultados. La siguiente operación omite los primeros 5 documentos en la colección bios y devuelve todos los documentos restantes:

db.bios.find().skip( 5 )

Especificar la intercalación

La intercalación permite a los usuarios especificar reglas propias del lenguaje para la comparación de strings, como reglas para el uso de mayúsculas y minúsculas y marcas de acento.

El método collation() especifica la intercalación para la operación de db.collection.find().

db.bios.find( { "name.last": "hopper" } ).collation( { locale: "en_US", strength: 1 } )

Combinar métodos de cursor

Las siguientes instrucciones encadenan los métodos de cursor limit() y sort():

db.bios.find().sort( { name: 1 } ).limit( 5 )
db.bios.find().limit( 5 ).sort( { name: 1 } )

Las dos instrucciones son equivalentes, lo que significa que el orden en el que encadena los métodos limit() y sort() no es significativo. Ambas instrucciones devuelven los primeros cinco documentos, según el orden de clasificación ascendente de "nombre".

Métodos disponibles `mongosh` Cursor

Usar variables en `let` la opción

Puedes especificar las opciones de query para modificar el comportamiento de la query e indicar cómo se devuelven los resultados.

Por ejemplo, para definir variables a las que puedas acceder en otras partes del método find, utiliza la opción let. Para aplicar un filtro de resultados con una variable, debes acceder a la variable dentro del operador $expr.

Cree una colección cakeFlavors:

db.cakeFlavors.insertMany( [
   { _id: 1, flavor: "chocolate" },
   { _id: 2, flavor: "strawberry" },
   { _id: 3, flavor: "cherry" }
] )

El siguiente ejemplo define una variable targetFlavor en let y utiliza la variable para recuperar el sabor del pastel chocolate:

db.cakeFlavors.find(
   { $expr: { $eq: [ "$flavor", "$$targetFlavor" ] } },
   { _id: 0 },
   { let : { targetFlavor: "chocolate" }
} )

Salida:

[ { flavor: 'chocolate' } ]

Recupera documentos para los roles otorgados al usuario actual

A partir de MongoDB 7.0, puedes usar la nueva variable de sistema USER_ROLES para devolver los roles de usuario.

En esta sección aparecen usuarios con varios roles que tienen acceso limitado a documentos en una colección que contiene información presupuestaria.

El escenario muestra un posible uso de USER_ROLES. La colección budget contiene documentos con un campo llamado allowedRoles. Como verás en el siguiente caso, puedes guardar queries que comparen los roles de usuario encontrados en el campo allowedRoles con los roles devueltos por la variable de sistema USER_ROLES.

Nota

Para ver otro ejemplo de USER_ROLES, consulta Recuperación de la información médica para los roles otorgados al usuario actual. Ese ejemplo no almacena los roles de usuario en los campos del documento, tal como se hace en el ejemplo siguiente.

Para el escenario presupuestario de esta sección, realiza los siguientes pasos para crear los roles, usuarios y la colección de budget:

Crea los roles

Ejecuta:

db.createRole( { role: "Marketing", roles: [], privileges: [] } )
db.createRole( { role: "Sales", roles: [], privileges: [] } )
db.createRole( { role: "Development", roles: [], privileges: [] } )
db.createRole( { role: "Operations", roles: [], privileges: [] } )

Crea los usuarios

Crea usuarios llamados John y Jane con los roles requeridos. Reemplaza la base de datos test con el nombre de su base de datos.

db.createUser( {
   user: "John",
   pwd: "jn008",
   roles: [
      { role: "Marketing", db: "test" },
      { role: "Development", db: "test" },
      { role: "Operations", db: "test" },
      { role: "read", db: "test" }
   ]
} )
db.createUser( {
   user: "Jane",
   pwd: "je009",
   roles: [
      { role: "Sales", db: "test" },
      { role: "Operations", db: "test" },
      { role: "read", db: "test" }
   ]
} )

Crear la colección

Ejecuta:

db.budget.insertMany( [
   {
      _id: 0,
      allowedRoles: [ "Marketing" ],
      comment: "For marketing team",
      yearlyBudget: 15000
   },
   {
      _id: 1,
      allowedRoles: [ "Sales" ],
      comment: "For sales team",
      yearlyBudget: 17000,
      salesEventsBudget: 1000
   },
   {
      _id: 2,
      allowedRoles: [ "Operations" ],
      comment: "For operations team",
      yearlyBudget: 19000,
      cloudBudget: 12000
   },
   {
      _id: 3,
      allowedRoles: [ "Development" ],
      comment: "For development team",
      yearlyBudget: 27000
   }
] )

Realiza los siguientes pasos para recuperar los documentos accesibles a John

Inicia sesión como John

Ejecuta:

db.auth( "John", "jn008" )

Recupera los documentos

Para usar una variable del sistema, agrega $$ al inicio del nombre de la variable. Especifica la variable del sistema USER_ROLES como $$USER_ROLES.

Ejecuta:

db.budget.find( {
   $expr: {
      $not: {
         $eq: [ { $setIntersection: [ "$allowedRoles", "$$USER_ROLES.role" ] }, [] ]
      }
   }
} )

El ejemplo anterior devuelve los documentos de la colección budget que coinciden con al menos uno de los roles que tiene el usuario que ejecuta el ejemplo. Para hacer eso, el ejemplo utiliza $setIntersection para devolver documentos donde la intersección entre el campo allowedRoles del documento budget y el conjunto de roles de usuario de $$USER_ROLES no está vacía.

Examina los documentos

John tiene los roles Marketing, Operations y Development, y ve estos documentos:

[
   {
      _id: 0,
      allowedRoles: [ 'Marketing' ],
      comment: 'For marketing team',
      yearlyBudget: 15000
   },
   {
      _id: 2,
      allowedRoles: [ 'Operations' ],
      comment: 'For operations team',
      yearlyBudget: 19000,
      cloudBudget: 12000
   },
   {
      _id: 3,
      allowedRoles: [ 'Development' ],
      comment: 'For development team',
      yearlyBudget: 27000
   }
]

Realiza los siguientes pasos para recuperar los documentos accesibles a Jane

Inicia sesión como Jane

Ejecuta:

db.auth( "Jane", "je009" )

Recupera los documentos

Ejecuta:

db.budget.find( {
   $expr: {
      $not: {
         $eq: [ { $setIntersection: [ "$allowedRoles", "$$USER_ROLES.role" ] }, [] ]
      }
   }
} )

Examina los documentos

Jane tiene los roles Sales y Operations y ve estos documentos:

[
   {
      _id: 1,
      allowedRoles: [ 'Sales' ],
      comment: 'For sales team',
      yearlyBudget: 17000,
      salesEventsBudget: 1000
   },
   {
      _id: 2,
      allowedRoles: [ 'Operations' ],
      comment: 'For operations team',
      yearlyBudget: 19000,
      cloudBudget: 12000
   }
]

Nota

En un clúster, una query se puede ejecutar en un fragmento por otro nodo de servidor en nombre del usuario. En esas queries, USER_ROLES todavía se completan con los roles del usuario.

Modificar una query con opciones

Los siguientes ejemplos muestran cómo puedes utilizar el campo options en una query find(). Utiliza el siguiente insertMany() para configurar la colección users:

db.users.insertMany( [
   { username: "david", age: 27 },
   { username: "amanda", age: 25 },
   { username: "rajiv", age: 32 },
   { username: "rajiv", age: 90 }
] )

límite con opciones

La siguiente query limita el número de documentos en el conjunto de resultados con el parámetro de opciones limit:

db.users.find(
   { username : "rajiv"}, // query
   { age : 1 }, // projection
   { limit : 1 } // options
)

allowDiskUse con opciones

La siguiente query utiliza el parámetro options para activar allowDiskUse:

db.users.find(
   { username : "david" },
   { age : 1 },
   { allowDiskUse : true }
)

explicación con opciones

La siguiente consulta utiliza el parámetro options para obtener la salida de explicación executionStats:

var cursor = db.users.find(
   { username: "amanda" },
   { age : 1 },
   { explain : "executionStats" }
)
cursor.next()

Especifica múltiples opciones en una query

La siguiente query utiliza múltiples options en una sola query. Esta query utiliza limit configurado en 2 para devolver solo dos documentos y showRecordId configurado en true para devolver la posición del documento en el conjunto de resultados:

db.users.find(
   {},
   { username: 1, age: 1 },
   {
     limit: 2,
     showRecordId: true
   }
)

Obtén más información

Volver

db.collection.explain

db.collection.findAndModify

Definición

Compatibilidad

Nota

Sintaxis

Parámetros

Comportamiento

Proyección

Importante

Consistencia del lenguaje

opciones

Especificación de campo embebido

_id Proyección de campo

Inclusión o exclusión

Clasificación

Cursor Handling

Tip

readConcern

Tipos de corchetes

Nota

Sesiones

Tiempo de espera de inactividad de la sesión

Transacciones

Importante

Desconexión del cliente

Configuración de query

Ejemplos

Encuentre todos los documentos en una colección

Encuentra documentos que coincidan con los criterios de query

Query para la igualdad

Nota

Query mediante operadores

Query de rangos

Query para múltiples condiciones

Comparar dos campos de un único documento

Consulta documentos incrustados

Query de coincidencias exactas en documentos incrustados

Campos de query de un documento incrustado

Arreglos de query

Query para un elemento de arreglo

Consulta un arreglo de documentos

Query para expresiones regulares BSON

Proyecciones

Nota

Especifica los campos a devolver

Nota

Campos explícitamente excluidos

Excluir explícitamente el _id campo

Nota

Sobre arreglos y documentos incrustados

Utiliza la expresión de agregación

Tip

Iterar el cursor devuelto

Con Nombre de Variable

Con el método next()

Con el método forEach()

Modificar el comportamiento del cursor

Ordenar documentos en el conjunto de resultados

Limita la cantidad de documentos a devolver

Establece el punto de inicio del conjunto de resultados

Especificar la intercalación

Combinar métodos de cursor

Métodos disponibles mongosh Cursor

Usar variables en let la opción

Recupera documentos para los roles otorgados al usuario actual

Nota

Crea los roles

Crea los usuarios

Crear la colección

Inicia sesión como John

Recupera los documentos

Examina los documentos

Inicia sesión como Jane

Recupera los documentos

Examina los documentos

Nota

Modificar una query con opciones

límite con opciones

allowDiskUse con opciones

explicación con opciones

Especifica múltiples opciones en una query

`_id` Proyección de campo

Excluir explícitamente el `_id` campo

Con el método `next()`

Con el método `forEach()`

Métodos disponibles `mongosh` Cursor

Usar variables en `let` la opción