Ler dados do Atlas MongoDB - Funções

Modelo de dados

Os exemplos nesta página usam uma coleção chamada store.items que modela vários itens disponíveis para compra em uma loja virtual. Cada item possui um name, um inventário quantity e uma array 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" }
        }
      }
    }
  }
}

Configuração do trecho

Para usar um trecho de código em uma função, você deve primeiro instanciar um identificador de coleção do 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 ...
}

Encontre um único documento (findOne())

Você pode encontrar um único documento usando o método collection.findOne().

O seguinte trecho de função encontra um único documento da collection items que possui um quantity maior ou 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}`));

Encontre um ou mais documentos (find())

Você pode encontrar vários documentos usando o método collection.find().

O trecho de função abaixo localiza todos os documentos na collection items que têm pelo menos uma revisão e os retorna classificados por name com o 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}`))

Contagem de documentos na coleção (count())

Você pode contar documentos em uma coleção usando o método collection.count(). Você pode especificar uma query para controlar quais documentos contar. Se você não especificar uma query, o método contará todos os documentos da coleção.

O trecho de função a seguir conta o número de documentos na coleção items que têm pelo menos uma revisão:

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))

Encontrar por ID do documento

Você pode executar query de uma coleção para localizar um documento que tenha um ID especificado. O MongoDB armazena automaticamente o ID de cada documento como um valor ObjectId no campo _id do documento.

{ "_id": <ObjectId> }

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

Encontrar por data

Você pode fazer query de uma collection para localizar documentos que tenham um campo com um valor de data específico ou fazer query de documentos dentro de um intervalo de datas.

{ "<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"),
  }
}

Corresponder a um campo de nível raiz

Você pode fazer query de uma collection com base no valor de um campo de nível raiz em cada documento. Você pode especificar um valor específico ou uma expressão aninhada que o MongoDB avalia para cada documento.

Para obter mais informações, consulte o tutorial Query de documentos no manual do MongoDB Server.

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

{ "name": "Basketball" }

Combinar vários campos

Você pode especificar várias condições de query em um único documento de query. Cada campo de nível raiz de um documento de query mapeia um campo na coleção. O MongoDB só retorna documentos que atendam a todas as condições de query.

Para obter mais informações, consulte o tutorial Query on Embedded/Nested Documents (Consultar documentos incorporados/aninhados ) no Manual do MongoDB Server.

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

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

Combinar um campo de documento incorporado

Você pode fazer query de uma collection com base no valor dos campos de documento incorporado . Para especificar um campo de documento incorporado , use várias expressões de query aninhadas ou notação de pontodocumento padrão.

Para obter mais informações, consulte o tutorial Query on Embedded/Nested Documents (Consultar documentos incorporados/aninhados ) no Manual do MongoDB Server.

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

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

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

Corresponder a uma array de valores

Você pode fazer query de uma collection com base em todos os elementos contidos em um campo de array.

Se você fizer query de um campo de array para uma array específica de valores, o MongoDB retornará documentos em que o campo de array corresponde exatamente à array de valores especificada. Se você quiser que o MongoDB retorne documentos onde o campo de array contém todos os elementos na array de valores especificada, use o operador $all .

Para obter mais informações, consulte o tutorial Query de array no manual do MongoDB Server.

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

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

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

Combine um elemento de array

Você pode executar uma query de uma coleção com base no valor de um ou mais elementos em um campo de array.

Se você executar uma query de um campo de array com uma expressão de query que tenha várias condições, o MongoDB retornará documentos em que qualquer combinação de elementos da array satisfaça a expressão. Se você quiser que o MongoDB retorne documentos em que um único elemento do array satisfaça todas as condições da expressão , use o operador $elemMatch .

Para obter mais informações, consulte o tutorial Query de array no manual do MongoDB Server.

{ "<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

Você pode usar um operador de comparação para comparar o valor de um campo de documento com outro valor.

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

Os seguintes operadores de comparação estão disponíveis:

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

Avalie uma expressão lógica

Você pode usar um operador lógico para avaliar múltiplas expressões para um único campo.

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

Os seguintes operadores lógicos estão disponíveis:

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

Avaliar uma expressão regular

Você pode usar o operador de query $regex para retornar documentos com campos que correspondem a uma expressão regular. Para evitar ambiguidade com o tipo $regex de EJSON , você deve usar um objeto BSON.BSONRegExp .

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

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