Consulta MongoDB - Web SDK

Inserir um único documento

Você pode inserir um único documento chamando collection.insertOne().

O trecho a seguir insere um único documento que descreve uma planta "lírio do vale" em uma coleção de documentos que descrevem plantas à venda em um grupo de lojas:

const result = await plants.insertOne({
  name: "lily of the valley",
  sunlight: "full",
  color: "white",
  type: "perennial",
  _partition: "Store 47",
});
console.log(result);

A execução deste trecho produz saída semelhante ao seguinte:

{ insertedId: ObjectId("5f879f83fc9013565c23360e") }

Insira vários documentos

Você pode inserir vários documentos ao mesmo tempo usando collection.insertMany().

O trecho a seguir insere três documentos descrevendo plantas em uma coleção de documentos que descrevem plantas para venda em um grupo de lojas:

const result = await plants.insertMany([
  {
    name: "rhubarb",
    sunlight: "full",
    color: "red",
    type: "perennial",
    _partition: "Store 47",
  },
  {
    name: "wisteria lilac",
    sunlight: "partial",
    color: "purple",
    type: "perennial",
    _partition: "Store 42",
  },
  {
    name: "daffodil",
    sunlight: "full",
    color: "yellow",
    type: "perennial",
    _partition: "Store 42",
  },
]);
console.log(result);

A execução deste trecho produz saída semelhante ao seguinte:

{
  insertedIds: [
    ObjectId("5f87a0defc9013565c233611"),
    ObjectId("5f87a0defc9013565c233612"),
    ObjectId("5f87a0defc9013565c233613"),
  ],
}

Encontrar um único documento

Você pode encontrar um único documento usando collection.findOne().

O trecho a seguir encontra o documento que descreve as armadilhas de vênus na coleção de documentos que descrevem plantas à venda em um grupo de lojas:

const venusFlytrap = await plants.findOne({ name: "venus flytrap" });
console.log("venusFlytrap", venusFlytrap);

A execução deste trecho produz saída semelhante ao seguinte:

{
  _id: ObjectId("5f87976b7b800b285345a8b4"),
  name: "venus flytrap",
  sunlight: "full",
  color: "white",
  type: "perennial",
  _partition: "Store 42",
}

Localizar vários documentos

Você pode encontrar vários documentos usando collection.find().

O snippet a seguir encontra todos os documentos em uma coleção de documentos que descrevem plantas à venda em um grupo de lojas que contêm um campo chamado type com um valor de "perennial":

const perennials = await plants.find({ type: "perennial" });
console.log("perennials", perennials);

A execução deste trecho produz saída semelhante ao seguinte:

[
  {
    _id: ObjectId("5f87976b7b800b285345a8b4"),
    name: "venus flytrap",
    sunlight: "full",
    color: "white",
    type: "perennial",
    _partition: "Store 42",
  },
  {
    _id: ObjectId("5f87976b7b800b285345a8b6"),
    name: "thai basil",
    sunlight: "partial",
    color: "green",
    type: "perennial",
    _partition: "Store 42",
  },
]

Contagem de documentos na coleção

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

O seguinte trecho conta o número de documentos em uma coleção de documentos que descrevem plantas para venda em um grupo de lojas:

const numPlants = await plants.count();
console.log(`There are ${numPlants} plants in the collection`);

A execução deste trecho produz saída semelhante ao seguinte:

"There are 5 plants in the collection"

Atualizar um único documento

Você pode atualizar um único documento usando collection.updateOne().

O trecho a seguir atualiza um único documento em uma coleção de documentos que descrevem plantas para venda em um grupo de lojas. Essa operação consulta um documento em que o campo name contém o valor "petunia" e altera o valor do campo sunlight do primeiro documento correspondente para "parcial":

const result = await plants.updateOne(
  { name: "petunia" },
  { $set: { sunlight: "partial" } }
);
console.log(result);

A execução deste trecho produz saída semelhante ao seguinte:

{ matchedCount: 1, modifiedCount: 1 }

Atualizar vários documentos

Você pode atualizar um único documento usando collection.updateMany().

O trecho a seguir atualiza vários documentos em uma coleção de documentos que descrevem plantas para venda em um grupo de lojas. Esta operação faz queries em documentos onde o campo _partition contém o valor "Armazenar 42" e altera o valor do campo _partition de cada documento correspondente para "Armazenar 51":

const result = await plants.updateMany(
  { _partition: "Store 42" },
  { $set: { _partition: "Store 51" } }
);
console.log(result);

A execução deste trecho produz saída semelhante ao seguinte:

{ matchedCount: 4, modifiedCount: 4 }

Documentos do Upsert

Se uma operação de atualização não corresponder a nenhum documento na coleção, você poderá inserir automaticamente um único novo documento na coleção que corresponda à query de atualização definindo a opção upsert como true.

O trecho a seguir atualiza um documento em uma coleção de documentos que descrevem plantas para venda em um grupo de lojas ou insere um novo documento se nenhum documento corresponder à query. Esta operação query documentos onde:

• o campo sunlight tem um valor de "completo"

• o campo type tem um valor de "perene"

• o campo color tem um valor de "verde"

• o campo _partition tem um valor de "Armazenar 47"

Como esse trecho define a opção upsert como true, se nenhum documento corresponder à query, o MongoDB cria um novo documento que inclui a query e as atualizações especificadas:

const result = await plants.updateOne(
  {
    sunlight: "full",
    type: "perennial",
    color: "green",
    _partition: "Store 47",
  },
  { $set: { name: "super sweet basil" } },
  { upsert: true }
);
console.log(result);

A execução deste trecho produz saída semelhante ao seguinte:

{
  matchedCount: 0,
  modifiedCount: 0,
  upsertedId: ObjectId("5f1f63055512f2cb67f460a3"),
} 

Excluir um único documento

Você pode excluir um único documento de uma coleção usando collection.deleteOne().

O trecho a seguir exclui um documento em uma coleção de documentos que descrevem plantas para venda em um grupo de lojas. Esta operação consulta um documento onde o campo color tem um valor de "verde" e exclui o primeiro documento que corresponde à consulta:

const result = await plants.deleteOne({ color: "green" });
console.log(result);

A execução deste trecho produz saída semelhante ao seguinte:

{ deletedCount: 1 }

Excluir vários documentos

Você pode excluir vários itens de uma coleção usando collection.deleteMany().

O snippet a seguir exclui todos os documentos para plantas que estão em "Loja 42" em uma coleção de documentos que descrevem plantas para venda em um grupo de lojas:

const result = await plants.deleteMany({
  _partition: "Store 42",
});
console.log(result);

A execução deste trecho produz saída semelhante ao seguinte:

{ deletedCount: 4 }

Fique atento às mudanças em uma coleção

Para observar todas as mudanças em uma coleção, chame collection.watch() sem argumentos:

for await (const change of plants.watch()) {
  let breakAsyncIterator = false; // Later used to exit async iterator
  switch (change.operationType) {
    case "insert": {
      const { documentKey, fullDocument } = change;
      console.log(`new document: ${documentKey}`, fullDocument);
      breakAsyncIterator = true;
      break;
    }
    case "update": {
      const { documentKey, fullDocument } = change;
      console.log(`updated document: ${documentKey}`, fullDocument);
      breakAsyncIterator = true;
      break;
    }
    case "replace": {
      const { documentKey, fullDocument } = change;
      console.log(`replaced document: ${documentKey}`, fullDocument);
      breakAsyncIterator = true;
      break;
    }
    case "delete": {
      const { documentKey } = change;
      console.log(`deleted document: ${documentKey}`);
      breakAsyncIterator = true;
      break;
    }
  }
  if (breakAsyncIterator) break; // Exit async iterator
}

Fique atento às alterações em uma coleção com um filtro

Para observar alterações específicas em uma coleção, chame collection.watch() com uma query que especifique os valores de eventos de alteração a serem observados:

for await (const change of plants.watch({
  filter: {
    operationType: "update",
    "fullDocument.type": "perennial",
  },
})) {
  // The change event will always represent a newly inserted perennial
  const { documentKey, fullDocument } = change;
  console.log(`new document: ${documentKey}`, fullDocument);
  break; // Exit async iterator
}

Agregar documentos em uma coleção

Você pode executar um pipeline de agregação usando collection.aggregate().

O trecho a seguir agrupa todos os documentos na coleção plants por seu valor type e agrega uma contagem do número de cada tipo:

const result = await plants.aggregate([
  {
    $group: {
      _id: "$type",
      total: { $sum: 1 },
    },
  },
  { $sort: { _id: 1 } },
]);
console.log(result);

A execução deste trecho produz saída semelhante ao seguinte:

[
  { _id: "annual", total: 3 },
  { _id: "perennial", total: 2 },
]

Filtrar documentos

Você pode utilizar o estágio $match para filtrar documentos de acordo com a sintaxe da query padrão do MongoDB.

{
  "$match": {
    "<Field Name>": <Query Expression>,
    ...
  }
}

const perennials = await plants.aggregate([
  { $match: { type: { $eq: "perennial" } } },
]);
console.log(perennials);

[
  { "_id": ObjectId("5f87976b7b800b285345a8c4"), "_partition": "Store 42", "color": "white", "name": "venus flytrap", "sunlight": "full", "type": "perennial" },
  { "_id": ObjectId("5f87976b7b800b285345a8c6"), "_partition": "Store 42", "color": "green", "name": "thai basil", "sunlight": "partial", "type": "perennial" },
  { "_id": ObjectId("5f87a0dffc9013565c233612"), "_partition": "Store 42", "color": "purple", "name": "wisteria lilac", "sunlight": "partial", "type": "perennial" },
  { "_id": ObjectId("5f87a0dffc9013565c233613"), "_partition": "Store 42", "color": "yellow", "name": "daffodil", "sunlight": "full", "type": "perennial" },
  { "_id": ObjectId("5f1f63055512f2cb67f460a3"), "_partition": "Store 47", "color": "green", "name": "sweet basil", "sunlight": "full", "type": "perennial" }
]

Documentos do grupo

Você pode usar o estágio $group para agregar dados resumidos de um ou mais documentos. O MongoDB agrupa documentos com base na expressão definida no campo _id da etapa $group . Você pode referenciar um campo de documento específico prefixando o nome do campo com um $.

{
  "$group": {
    "_id": <Group By Expression>,
    "<Field Name>": <Aggregation Expression>,
    ...
  }
}

const result = await plants.aggregate([
  {
    $group: {
      _id: "$type",
      numItems: { $sum: 1 },
    },
  },
  { $sort: { _id: 1 } },
]);
console.log(result);

[
  { _id: "annual", numItems: 1 },
  { _id: "perennial", numItems: 5 },
]

Paginar documentos

Para paginar resultados, você pode utilizar consultas de agregação de intervalo com os operadores $match, $sort e $limit. Para saber mais sobre a paginação de documentos, consulte Usando consultas de intervalo na documentação do MongoDB Server.

// Paginates through list of plants
// in ascending order by plant name (A -> Z)
async function paginateCollectionAscending(
  collection,
  nPerPage,
  startValue
) {
  const pipeline = [{ $sort: { name: 1 } }, { $limit: nPerPage }];
  // If not starting from the beginning of the collection,
  // only match documents greater than the previous greatest value.
  if (startValue !== undefined) {
    pipeline.unshift({
      $match: {
        name: { $gt: startValue },
      },
    });
  }
  const results = await collection.aggregate(pipeline);
  return results;
}
// Number of results to show on each page
const resultsPerPage = 3;
const pageOneResults = await paginateCollectionAscending(
  plants,
  resultsPerPage
);
const pageTwoStartValue = pageOneResults[pageOneResults.length - 1].name;
const pageTwoResults = await paginateCollectionAscending(
  plants,
  resultsPerPage,
  pageTwoStartValue
);
// ... can keep paginating for as many plants as there are in the collection

Campos do documento do projeto

Você pode utilizar o estágio $project para incluir ou omitir campos específicos de documentos ou calcular novos campos utilizando operadores de agregação. As projeções funcionam de duas formas:

• Inclua campos explicitamente com um valor de 1. Isso tem o efeito colateral de excluir implicitamente todos os campos não especificados.

• Exclua campos de forma implícita com um valor de 0. Isso tem o efeito colateral de incluir implicitamente todos os campos não especificados.

Esses dois métodos de projeção são mutuamente exclusivos: se você incluir campos explicitamente, não poderá excluir campos explicitamente e vice-versa.

{
  "$project": {
    "<Field Name>": <0 | 1 | Expression>,
    ...
  }
}

const result = await plants.aggregate([
  {
    $project: {
      _id: 0,
      name: 1,
      storeNumber: {
        $arrayElemAt: [{ $split: ["$_partition", " "] }, 1],
      },
    },
  },
]);
console.log(result);

[
  { "name": "venus flytrap", "storeNumber": "42" },
  { "name": "thai basil", "storeNumber": "42" },
  { "name": "helianthus", "storeNumber": "42" },
  { "name": "wisteria lilac", "storeNumber": "42" },
  { "name": "daffodil", "storeNumber": "42" },
  { "name": "sweet basil", "storeNumber": "47" }
]

Adicionar campos aos documentos

Você pode usar o estágio $addFields para adicionar novos campos com valores calculados usando operadores de agregação.

{ $addFields: { <newField>: <expression>, ... } }

const result = await plants.aggregate([
  {
    $addFields: {
      storeNumber: {
        $arrayElemAt: [{ $split: ["$_partition", " "] }, 1],
      },
    },
  },
]);
console.log(result);

[
  { "_id": ObjectId("5f87976b7b800b285345a8c4"), "_partition": "Store 42", "color": "white", "name": "venus flytrap", "storeNumber": "42", "sunlight": "full", "type": "perennial" },
  { "_id": ObjectId("5f87976b7b800b285345a8c6"), "_partition": "Store 42", "color": "green", "name": "thai basil", "storeNumber": "42", "sunlight": "partial", "type": "perennial" },
  { "_id": ObjectId("5f87976b7b800b285345a8c7"), "_partition": "Store 42", "color": "yellow", "name": "helianthus", "storeNumber": "42", "sunlight": "full", "type": "annual" },
  { "_id": ObjectId("5f87a0dffc9013565c233612"), "_partition": "Store 42", "color": "purple", "name": "wisteria lilac", "storeNumber": "42", "sunlight": "partial", "type": "perennial" },
  { "_id": ObjectId("5f87a0dffc9013565c233613"), "_partition": "Store 42", "color": "yellow", "name": "daffodil", "storeNumber": "42", "sunlight": "full", "type": "perennial" },
  { "_id": ObjectId("5f1f63055512f2cb67f460a3"), "_partition": "Store 47", "color": "green", "name": "sweet basil", "storeNumber": "47", "sunlight": "full", "type": "perennial" }
]

Unwind Array Values

Você pode usar o estágio $unwind para transformar um único documento contendo uma matriz em vários documentos contendo valores individuais dessa matriz. Quando você desenrola um campo de matriz, o MongoDB copia cada documento uma vez para cada elemento do campo de matriz, mas substitui o valor da matriz pelo elemento da matriz em cada cópia.

{
  $unwind: {
    path: <Array Field Path>,
    includeArrayIndex: <string>,
    preserveNullAndEmptyArrays: <boolean>
  }
}

const result = await plants.aggregate([
  { $group: { _id: "$type", colors: { $addToSet: "$color" } } },
  { $unwind: { path: "$colors" } },
  { $sort: { _id: 1, colors: 1 } },
]);
console.log(result);

[
  { "_id": "annual", "colors": "yellow" },
  { "_id": "perennial", "colors": "green" },
  { "_id": "perennial", "colors": "purple" },
  { "_id": "perennial", "colors": "white" },
  { "_id": "perennial", "colors": "yellow" },
]