Retrieve Data

Abrir tutorial interativo

Visão geral

Você pode executar operações para recuperar dados de seu banco de dados MongoDB. Você pode executar uma operação de localizar para corresponder aos documentos em um conjunto de critérios ligando com o método find() ou findOne().

Você também pode especificar melhor as informações que a operação de localização retorna especificando parâmetros opcionais ou encadeando outros métodos, conforme mostrado nos seguintes guias:

• Classificar resultados

• Ignorar resultados devolvidos

• Limite o número de resultados retornados

• Especifique quais campos retornar

Você também pode utilizar uma operação de aggregation para recuperar dados. Esse tipo de operação permite que você aplique um pipeline ordenado de transformações aos dados correspondentes.

Se você deseja monitorar o banco de dados para dados de entrada que correspondem a um conjunto de critérios, você pode usar a operação de relógio para ser notificado em tempo real quando dados correspondentes são inseridos.

Você pode usar o driver Node.js para conectar e executar operações de leitura para implantações hospedadas nos seguintes ambientes:

• MongoDB Atlas: o serviço totalmente gerenciado para implantações do MongoDB na nuvem

• MongoDB Enterprise: a versão autogerenciada e baseada em assinatura do MongoDB

• MongoDB Community: uma versão com código disponível, de uso gratuito e autogerenciada do MongoDB

Para saber mais sobre como executar operações de leitura na IU do Atlas para implantações hospedadas no MongoDB Atlas, consulte Exibir, Filtrar e Classificar Documentos.

Encontrar documentos

Você pode usar o método find() em um objeto Collection. O método aceita um documento de query que descreve os documentos que você deseja recuperar. Para saber mais sobre como especificar seu documento de query, consulte o guia Especificar uma query.

await myColl.find(); // no query
await myColl.find({}); // empty query

const options = {
  projection: { _id: 0, field1: 1 },
};
const findResult = await myColl.findOne({}, options);

Se você resolver a Promise retornada por find(), receberá uma referência a um Cursor com o qual poderá navegar pelos documentos correspondentes. Se você resolver a Promise retornada por findOne(), receberá o documento correspondente ou null se não houver correspondências.

    const findResult = await orders.find({
      name: "Lemony Snicket",
      date: {
        $gte: new Date(new Date().setHours(00, 00, 00)),
        $lt: new Date(new Date().setHours(23, 59, 59)),
      },
    });

await findResult.forEach(console.dir);

[
  { name: "Lemony Snicket", type: "horseradish pizza", qty: 1, status: "delivered", date: ... },
  { name: "Lemony Snicket", type: "coal-fired oven pizza", qty: 3, status: "canceled", date: ...},
  ...
]

Consulte find() e findOne() para obter exemplos totalmente executáveis.

Agregar dados de documentos

Se quiser executar um pipeline de processamento personalizado para recuperar dados do seu banco de dados, você pode utilizar o método aggregate(). Este método aceita expressões de aggregation para executar em sequência. Essas expressões permitem filtrar, agrupar e organizar os dados de resultado de uma collection.

    const aggregateResult = await orders.aggregate([
      {
        $match: {
          date: {
            $gte: new Date(new Date().getTime() - 1000 * 3600 * 24 * 7),
            $lt: new Date(),
          },
        },
      },
      {
        $group: {
          _id: "$status",
          count: {
            $sum: 1,
          },
        },
      },
    ]);

await aggregateResult.forEach(console.dir);

[
  { _id: 'delivering', count: 5 },
  { _id: 'delivered', count: 37 },
  { _id: 'created', count: 9 }
]

Consulte as páginas do manual do servidor MongoDB sobre agregação para obter mais informações sobre como criar um pipeline de agregação.

Monitorar alterações de dados

Você pode usar o método watch() para monitorar uma collection para alterações em uma collection que correspondam a determinados critérios. Essas alterações incluem documentos inseridos, atualizados, substituídos e excluídos. Você pode passar a esse método um pipeline de comandos de aggregation que é executado sequencialmente nos dados alterados sempre que operações de gravação forem executadas na collection.

    const changeStream = orders.watch([
      { $match: { operationType: "insert" } },
      {
        $project: {
          "fullDocument.name": 1,
          "fullDocument.address": 1,
        },
      },
    ]);
    changeStream.on("change", change => {
      const { name, address } = change.fullDocument;
      console.log(`New order for ${name} at ${address}.`);
    });

Para obter um exemplo executável do método watch() usando o driver NodeJS, consulte o exemplo de uso de change streams .