Consulta MongoDB - SDK web

Inserta un solo documento

Puede insertar un solo documento llamando a collection.insertOne().

El siguiente fragmento inserta un único documento que describe una planta de "lirio de los valles" en una colección de documentos que describen plantas a la venta en un grupo de tiendas:

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

Al ejecutar este fragmento se obtiene un resultado similar al siguiente:

{ insertedId: ObjectId("5f879f83fc9013565c23360e") }

Inserta varios documentos

Puede insertar varios documentos al mismo tiempo utilizando collection.insertMany().

El siguiente fragmento inserta tres documentos que describen plantas en una colección de documentos que describen plantas en venta en un grupo de tiendas:

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

Al ejecutar este fragmento se obtiene un resultado similar al siguiente:

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

Buscar un solo documento

Puede encontrar un solo documento utilizando collection.findOne().

El siguiente fragmento encuentra el documento que describe las plantas atrapamoscas en la colección de documentos que describen plantas en venta en un grupo de tiendas:

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

Al ejecutar este fragmento se obtiene un resultado similar al siguiente:

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

Encuentra varios documentos

Puede encontrar varios documentos utilizando collection.find().

El siguiente fragmento busca todos los documentos en una colección de documentos que describen plantas a la venta en un grupo de tiendas que contienen un campo llamado type con un valor de "perenne":

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

Al ejecutar este fragmento se obtiene un resultado similar al siguiente:

[
  {
    _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",
  },
]

Contar documentos en la colección

Puedes contar los documentos de una colección usando collection.count(). Puedes especificar una consulta opcional para determinar qué documentos contar. Si no especificas una consulta, la acción cuenta todos los documentos de la colección.

El siguiente fragmento cuenta la cantidad de documentos en una colección de documentos que describen plantas en venta en un grupo de tiendas:

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

Al ejecutar este fragmento se obtiene un resultado similar al siguiente:

"There are 5 plants in the collection"

Actualiza un solo documento

Puede actualizar un solo documento utilizando collection.updateOne().

El siguiente fragmento actualiza un documento de una colección que describe plantas a la venta en un grupo de tiendas. Esta operación busca un documento cuyo name campo contiene el valor "petunia" y cambia el valor del campo del primer documento coincidente sunlight a "parcial":

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

Al ejecutar este fragmento se obtiene un resultado similar al siguiente:

{ matchedCount: 1, modifiedCount: 1 }

Actualiza varios documentos

Puede actualizar un solo documento utilizando collection.updateMany().

El siguiente fragmento actualiza varios documentos de una colección que describen plantas en venta en un grupo de tiendas. Esta operación busca documentos cuyo _partition campo contenga el valor "Tienda 42" y cambia el valor del _partition campo de cada documento coincidente a "Tienda 51":

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

Al ejecutar este fragmento se obtiene un resultado similar al siguiente:

{ matchedCount: 4, modifiedCount: 4 }

Insertar documentos

Si una operación de actualización no coincide con ningún documento de la colección, puede insertar automáticamente un solo documento nuevo en la colección que coincida con la consulta de actualización configurando la opción upsert en true.

El siguiente fragmento actualiza un documento de una colección que describe plantas en venta en un grupo de tiendas o inserta un nuevo documento si ningún documento coincide con la consulta. Esta operación busca documentos donde:

• El campo sunlight tiene un valor de "completo"

• El campo type tiene un valor de "perenne"

• El campo color tiene un valor de "verde"

• el campo _partition tiene el valor "Store 47".

Debido a que este fragmento establece la opción upsert en true, si ningún documento coincide con la consulta, MongoDB crea un nuevo documento que incluye tanto la consulta como las actualizaciones 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);

Al ejecutar este fragmento se obtiene un resultado similar al siguiente:

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

Borrar un único documento

Puedes eliminar un solo documento de una colección utilizando collection.deleteOne().

El siguiente fragmento elimina un documento de una colección que describe plantas en venta en un grupo de tiendas. Esta operación busca un documento cuyo color campo tenga el valor "verde" y elimina el primer documento que coincida con la consulta:

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

Al ejecutar este fragmento se obtiene un resultado similar al siguiente:

{ deletedCount: 1 }

Borra varios documentos

Puede borrar varios elementos de una colección usando collection.deleteMany().

El siguiente fragmento elimina todos los documentos de plantas que se encuentran en "Tienda 42" en una colección de documentos que describen plantas en venta en un grupo de tiendas:

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

Al ejecutar este fragmento se obtiene un resultado similar al siguiente:

{ deletedCount: 4 }

Esté atento a los cambios en una colección

Para observar todos los cambios en una colección, llama a collection.watch() sin ningún argumento:

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
}

Esté atento a los cambios en una colección con un filtro

Para observar cambios específicos en una colección, llame a collection.watch() con una consulta que especifique los valores de eventos de cambio a observar:

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
}

Documentos agregados en una colección

Puede ejecutar una canalización de agregación utilizando collection.aggregate().

El siguiente fragmento agrupa todos los documentos de la colección plants por su valor type y agrega un recuento de la cantidad de cada tipo:

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

Al ejecutar este fragmento se obtiene un resultado similar al siguiente:

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

Filtrar Documentos

Puede utilizar la etapa $match para filtrar documentos según la sintaxis de consulta estándar de 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 de grupo

Puede usar la etapa $group para agregar datos de resumen de uno o más documentos. MongoDB agrupa documentos según la expresión definida en el _id campo de la $group etapa. Puede hacer referencia a un campo de documento específico anteponiendo al nombre del $ campo.

{
  "$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, puede usar consultas de agregación de rangos con los $match $sortoperadores,$limit y. Para obtener más información sobre la paginación de documentos, consulte "Uso de consultas de rangos" en la documentación de 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 del documento del proyecto

Puede usar la etapa $project para incluir u omitir campos específicos de los documentos o para calcular nuevos campos mediante operadores de agregación. Las proyecciones funcionan de dos maneras:

• Incluir explícitamente los campos con el valor 1. Esto tiene el efecto secundario de excluir implícitamente todos los campos no especificados.

• Excluye implícitamente los campos con un valor de 0. Esto tiene el efecto secundario de incluir implícitamente todos los campos no especificados.

Estos dos métodos de proyección son mutuamente excluyentes: si incluye campos explícitamente, no puede excluirlos explícitamente, y viceversa.

{
  "$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" }
]

Agregar campos a los documentos

Puede utilizar la etapa $addFields para agregar nuevos campos con valores calculados utilizando operadores de agregación.

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

Puede usar la etapa $unwind para transformar un documento que contiene una matriz en varios documentos que contienen valores individuales de esa matriz. Al desenrollar un campo de matriz, MongoDB copia cada documento una vez por cada elemento de dicho campo, pero reemplaza el valor de la matriz con el elemento de la matriz en cada copia.

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