Leer datos de MongoDB Atlas - Funciones

Modelo de datos

Los ejemplos de esta página utilizan una colección denominada store.items Que modela varios artículos disponibles para la compra en una tienda en línea. Cada artículo tiene un name, un inventario quantity y una matriz de clientes reviews.

{
  "title": "Item",
  "required": ["_id", "name", "quantity", "reviews"],
  "properties": {
    "_id": { "bsonType": "objectId" },
    "name": { "bsonType": "string" },
    "quantity": { "bsonType": "int" },
    "reviews": {
      "bsonType": "array",
      "items": {
        "bsonType": "object",
        "required": ["username", "comment"],
        "properties": {
          "username": { "bsonType": "string" },
          "comment": { "bsonType": "string" }
        }
      }
    }
  }
}

Configuración de fragmentos

Para utilizar un fragmento de código en una función, primero debe crear una instancia de un controlador de colección de MongoDB:

exports = function() {
  const mongodb = context.services.get("mongodb-atlas");
  const itemsCollection = mongodb.db("store").collection("items");
  const purchasesCollection = mongodb.db("store").collection("purchases");
  // ... paste snippet here ...
}

Buscar un solo documentofindOne() ()

Puede encontrar un solo documento utilizando el collection.findOne() método.

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

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}`));

Buscar uno o más documentosfind() ()

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

El siguiente fragmento de función busca todos los documentos en la items colección que tienen al menos una revisión y los devuelve ordenados por name con el _id campo 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 los documentos de una colección con el collection.count() método. Puede especificar una consulta para controlar qué documentos contar. Si no especifica una consulta, el método cuenta todos los documentos de la colección.

El siguiente fragmento de función cuenta la cantidad de documentos en la items colección 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 consultar 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

Puede consultar una colección para encontrar documentos que tengan un campo con un valor de fecha específico, o consultar 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"),
  }
}

Coincidir con un campo de nivel raíz

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

Para obtener más información, consulte el tutorial Consulta de documentos en el Manual del servidor MongoDB.

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

{ "name": "Basketball" }

Coincidir con varios campos

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

Para obtener más información, consulte el tutorial Consulta en documentos anidados o incrustados en el Manual del servidor MongoDB.

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

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

Coincidir con un campo de documento incrustado

Puede consultar una colección basándose en el valor de los campos de documento incrustados. Para especificar un campo de documento incrustado, utilice varias expresiones de consulta anidadas o la notación de puntos estándar.

Para obtener más información, consulte el tutorial Consulta en documentos anidados o incrustados en el Manual del servidor MongoDB.

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

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

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

Coincidir con una matriz de valores

Puede consultar una colección basándose en todos los elementos contenidos en un campo de matriz.

Si consulta un campo de matriz para obtener una matriz de valores específica, MongoDB devuelve documentos donde el campo de matriz coincide exactamente con la matriz de valores especificada. Si desea que MongoDB devuelva documentos donde el campo de matriz contenga todos los elementos de la matriz de valores especificada, utilice el operador $all.

Para obtener más información, consulte el tutorial Consultar una matriz en el Manual del servidor MongoDB.

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

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

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

Coincidir un elemento de un arreglo

Puede consultar una colección basándose en el valor de uno o más elementos en un campo de matriz.

Si consulta un campo de matriz con una expresión de consulta con varias condiciones, MongoDB devuelve documentos donde cualquier combinación de elementos de la matriz cumple la expresión. Si desea que MongoDB devuelva documentos donde un solo elemento de la matriz cumple todas las condiciones de la expresión, utilice el operador $elemMatch.

Para obtener más información, consulte el tutorial Consultar una matriz en el Manual del servidor 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

Puede utilizar un operador de comparación para comparar el valor de un campo de documento con otro valor.

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

Los siguientes operadores de comparación están disponibles:

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

Evaluar una expresión lógica

Puede utilizar 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 utilizar el operador de consulta $regex para devolver documentos con campos que coincidan con una expresión regularPara evitar ambigüedades con el $regex tipo EJSON, debe utilizar un objeto BSON.BSONRegExp.

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

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