Query MongoDB - Node.js SDK

Encontrar um único documento

Para encontrar um único documento, faça uma query que corresponda ao documento para coleção.findOne(). Se você não fizer uma query, findOne() corresponderá ao primeiro documento encontrado na coleção.

O trecho a seguir encontra o documento que descreve as plantas "dioneia" 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);

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

Localizar vários documentos

Para localizar vários documentos, faça uma query que corresponda aos documentos para coleção.find(). Se você não passar uma query, find() corresponderá a todos os documentos da coleção.

O seguinte trecho encontra todos os documentos que descrevem plantas perenes na coleção de documentos que descrevem plantas para venda em um grupo de lojas:

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

[
  { _id: ObjectId("5f87976b7b800b285345a8c4"), name: 'venus flytrap', sunlight: 'full', color: 'white', type: 'perennial', _partition: 'Store 42' },
  { _id: ObjectId("5f87976b7b800b285345a8c6"), name: 'thai basil', sunlight: 'partial', color: 'green', type: 'perennial', _partition: 'Store 42' },
  { _id: ObjectId("5f879f83fc9013565c23360e"), name: 'lily of the valley', sunlight: 'full', color: 'white', type: 'perennial', _partition: 'Store 47' },
  { _id: ObjectId("5f87a0defc9013565c233611"), name: 'rhubarb', sunlight: 'full', color: 'red', type: 'perennial', _partition: 'Store 47' },
  { _id: ObjectId("5f87a0dffc9013565c233612"), name: 'wisteria lilac', sunlight: 'partial', color: 'purple', type: 'perennial', _partition: 'Store 42' },
  { _id: ObjectId("5f87a0dffc9013565c233613"), name: 'daffodil', sunlight: 'full', color: 'yellow', type: 'perennial', _partition: 'Store 42' }
]

Contagem de documentos

Para contar documentos, passe uma query que corresponda aos documentos para collection.count(). Se você não passar uma query, count() contará todos os documentos na collection.

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

"There are 9 plants in the collection"

Inserir um único documento

Para inserir um único documento, passe para 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);

{
  insertedId: "5f879f83fc9013565c23360e",
}

Insira vários documentos

Para inserir vários documentos ao mesmo tempo, passe-os como uma array para 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);

{
  insertedIds: [
    "5f87a0defc9013565c233611",
    "5f87a0dffc9013565c233612",
    "5f87a0dffc9013565c233613",
  ],
}

Atualizar um único documento

Para atualizar um único documento, passe uma query que corresponda ao documento e um documento de atualização para 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);

{ matchedCount: 1, modifiedCount: 1 }

Atualizar vários documentos

Para atualizar vários documentos simultaneamente, faça uma query que corresponda aos documentos e uma descrição de atualização para 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 47" e altera o valor do campo _partition de cada documento correspondente para "Armazenar 51":

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

{ matchedCount: 3, modifiedCount: 3 }

Documentos do Upsert

Para atualizar um documento, defina a opção upsert para true na sua operação de atualização. Se a query da operação não corresponder a nenhum documento na coleção, um upsert inserirá automaticamente um único novo documento na coleção que corresponda ao documento de query fornecido com a atualização aplicada a ele.

O trecho a seguir atualiza um documento em uma coleção de documentos que descrevem plantas para venda em um grupo de lojas com uma operação de upsert. A query não corresponde a nenhum documento existente, portanto, o MongoDB cria automaticamente um novo.

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

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

Excluir um único documento

Para excluir um único documento de uma coleção, faça uma query que corresponda ao documento para collection.deleteOne(). Se você não fizer uma query ou se a query corresponder a vários documentos, a operação excluirá o primeiro documento encontrado.

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

{ deletedCount: 1 }

Excluir vários documentos

Para excluir vários documentos de uma coleção, faça uma query que corresponda aos documentos para coleção.deleteMany(). Se você não fizer uma query, o deleteMany() excluirá todos os documentos na coleção.

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

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

{ deletedCount: 3 }

Fique atento a todas as alterações em uma coleção

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

for await (const change of plants.watch()) {
  switch (change.operationType) {
    case "insert": {
      const { documentKey, fullDocument } = change;
      console.log(`new document: ${documentKey}`, fullDocument);
      break;
    }
    case "update": {
      const { documentKey, fullDocument } = change;
      console.log(`updated document: ${documentKey}`, fullDocument);
      break;
    }
    case "replace": {
      const { documentKey, fullDocument } = change;
      console.log(`replaced document: ${documentKey}`, fullDocument);
      break;
    }
    case "delete": {
      const { documentKey } = change;
      console.log(`deleted document: ${documentKey}`);
      break;
    }
  }
}

Fique atento a mudanças específicas em uma collection

Para observar alterações específicas em uma coleção, faça uma query que corresponda aos campos de eventos de alteração para collection.watch():

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

Execute um Pipeline de Agregação

Para executar um pipeline de agregação, passe uma array de estágios de agregação para collection.aggregate(). As operações de agregação retornam o conjunto de resultados da última etapa do pipeline.

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

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

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

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

{
  "$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);

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

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

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

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

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

{
  $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);