Leer datos de MongoDB Atlas - Funciones

Encuentre un solo documento (findOne())

Puedes encontrar un único documento usando el método collection.findOne().

El siguiente snippet de función encuentra un solo documento de la colección items que tiene un quantity mayor o igual a 25:

const query = { "quantity": { "$gte": 25 } };
const projection = {
 "title": 1,
 "quantity": 1,
}
return itemsCollection.findOne(query, projection)
  .then(result => {
    if(result) {
      console.log(`Successfully found document: ${result}.`);
    } else {
      console.log("No document matches the provided query.");
    }
    return result;
  })
  .catch(err => console.error(`Failed to find document: ${err}`));

Encuentra uno o más documentos (find())

Puedes encontrar varios documentos usando el método collection.find().

El siguiente fragmento de función encuentra todos los documentos en la colección items que tienen al menos una revisión y los devuelve ordenados por name con el campo _id omitido:

const query = { "reviews.0": { "$exists": true } };
const projection = { "_id": 0 };
return itemsCollection.find(query, projection)
  .sort({ name: 1 })
  .toArray()
  .then(items => {
    console.log(`Successfully found ${items.length} documents.`)
    items.forEach(console.log)
    return items
  })
  .catch(err => console.error(`Failed to find documents: ${err}`))

Contar documentos en la colección (count())

Puede contar documentos en una colección usando el método collection.count(). Puedes especificar una query para controlar qué documentos contar. Si no especificas una query, el método contará todos los documentos de la colección.

El siguiente snippet de función cuenta el número de documentos en la colección items que tienen al menos una revisión:

return itemsCollection.count({ "reviews.0": { "$exists": true } })
  .then(numDocs => console.log(`${numDocs} items have a review.`))
  .catch(err => console.error("Failed to count documents: ", err))

Buscar por ID de documento

Puedes query una colección para encontrar un documento con un ID específico. MongoDB almacena automáticamente el ID de cada documento como un valor ObjectId en el campo _id del documento.

{ "_id": <ObjectId> }

{ "_id": BSON.ObjectId("5ad84b81b8b998278f773c1b") }

Buscar por fecha

Puedes query una colección para encontrar documentos que tengan un campo con un valor de fecha específico, o query documentos dentro de un rango de fechas.

{ "<Date Field Name>": <Date | Expression> }

{ "createdAt": new Date("2019-01-23T05:00:00.000Z") }

{
  "createdAt": {
    "$gte": new Date("2019-01-01T00:00:00.000Z"),
    "$lt": new Date("2020-01-01T00:00:00.000Z"),
  }
}

Coincide con un campo de nivel raíz

Puedes query una colección basándote en el valor de un campo de nivel raíz en cada documento. Puedes especificar un valor específico o una expresión anidada que MongoDB evalúa para cada documento.

Para más información, consulta el tutorial Query Documents en el MongoDB Server Manual.

{ "<Field Name>": <Value | Expression> }

{ "name": "Basketball" }

Coincidir varios campos

Puede especificar varias condiciones de query en un único documento de query. Cada campo de nivel raíz de un documento de query se asigna a un campo en la colección. MongoDB solo devuelve los documentos que cumplen todas las condiciones de la query.

Para obtener más información, vea el tutorial query en Documentos Incrustados/Anidados en el Manual de MongoDB Server.

{
  "<Field Name 1>": <Value | Expression>,
  "<Field Name 2>": <Value | Expression>
}

{
  "name": "Basketball",
  "quantity": { "$gt": 0 }
}

Coincidir un campo de documento incrustado

Puedes query una colección basándote en el valor de los campos de documentos incrustados. Para especificar un campo de documento incrustado, utiliza varios expresiones de query anidadas o la notación de puntos estándar del documento.

Para obtener más información, vea el tutorial query en Documentos Incrustados/Anidados en el Manual de MongoDB Server.

{ "<Field Name>": { "<Nested Field Name>": <Value | Expression> } }

{ "<Field Name>.<Nested Field Name>": <Value | Expression> }

{
  "reviews.0.username": "JoeMango"
}

Coincidir con un arreglo de valores

Puedes consultar una colección en función de todos los elementos contenidos en un campo de arreglo.

Si query un campo de arreglo para un arreglo específico de valores, MongoDB devuelve documentos donde el campo de arreglo coincide exactamente con el arreglo de valores especificado. Si deseas que MongoDB devuelva documentos donde el campo de arreglo contenga todos los elementos en el arreglo de valores especificada, usa el operador $all.

Para obtener más información, consulta el Tutorial sobre query a un arreglo en el Manual del servidor de MongoDB.

{ "<Array Field Name>": [<Value>, ...] }

{
  "reviews": [{ username: "JoeMango", comment: "This rocks!" }]
}

{
  "reviews": {
    "$all": [{ username: "JoeMango", comment: "This rocks!" }]
  }
}

Coincidir un elemento de un arreglo

Puedes hacer query a una colección basadas en el valor de uno o más elementos de un campo de arreglo.

Si se consulta un campo de arreglo con una expresión de query que tiene múltiples condiciones, MongoDB devuelve documentos donde cualquier combinación de los elementos del arreglo cumple con la expresión. Si deseas que MongoDB devuelva documentos en los que un único elemento de arreglo cumpla todas las condiciones de la expresión, utiliza el operador $elemMatch.

Para obtener más información, consulta el Tutorial sobre query a un arreglo en el Manual del servidor de MongoDB.

{ "<Array Field Name>": <Value | Expression> }

{
  "reviews": {
    "username": "JoeMango",
    "comment": "This is a great product!"
  }
}

{
  "reviews": {
    "$elemMatch": {
      "username": "JoeMango",
      "comment": "This is a great product!"
    }
  }
}

Compare Values

Puedes usar un operador de comparación para comparar el valor de un campo de documento con otro valor.

{ "<Field Name>": { "<Comparison Operator>": <Comparison Value> } }

Están disponibles los siguientes operadores de comparación:

{
  "quantity": { "$gt": 0, "$lte": 10 }
}

Evaluar una expresión lógica

Se puede usar un operador lógico para evaluar múltiples expresiones para un solo campo.

{
  "<Field Name>": {
    "<Logical Operator>": [<Expression>, ...]
  }
}

Los siguientes operadores lógicos están disponibles:

{
  "$or": [
    { "quantity": { "$gt": 0 } },
    { "reviews": { "$size": { "$lte": 5 } } }
  ]
}

Evaluar una expresión regular

Puede usar el operador del query $regex para devolver documentos con campos que coincidan con una expresión regular. Para evitar ambigüedades con el tipo $regex EJSON, debes utilizar un objeto atlas-BSON.BSONRegExp.

{
  "<Field Name>": {
    "$regex": BSON.BSONRegExp(<RegEx String>, <RegEx Options>)
  }
}

{
  "name": { "$regex": BSON.BSONRegExp(".+ball", "i") }
}