/ /

Datos agregados en MongoDB Atlas - Funciones

Los ejemplos de esta página demuestran cómo utilizar la API de consulta de MongoDB en una función Atlas para agregar documentos en su clúster Atlas.

MongoDB Las canalizaciones de agregación ejecutan todos los documentos de una colección a través de una serie de etapas de agregación de datos que le permiten filtrar y dar forma a los documentos, así como recopilar datos de resumen sobre grupos de documentos relacionados.

Nota

Etapas admitidas de agregación

Atlas Functions admite casi todas las etapas del pipeline de agregación de MongoDB y los operadores, pero algunas etapas y operadores deben ejecutarse dentro de un función del sistema. Consulte Limitaciones del marco de agregación para obtener más información.

modelo de datos

Los ejemplos en esta página utilizan una colección llamada store.purchases que contiene información sobre las ventas históricas de artículos en un almacenar en línea. Cada documento contiene una lista de los items adquiridos, incluyendo el artículo name y los quantity adquiridos, así como un valor de ID único para el cliente que adquirió los artículos.

{
  "title": "Purchase",
  "required": ["_id", "customerId", "items"],
  "properties": {
    "_id": { "bsonType": "objectId" },
    "customerId": { "bsonType": "objectId" },
    "items": {
      "bsonType": "array",
      "items": {
        "bsonType": "object",
        "required": ["name", "quantity"],
        "properties": {
          "name": { "bsonType": "string" },
          "quantity": { "bsonType": "int" }
        }
      }
    }
  }
}

Configuración de fragmentos

Para usar un code snippet en una función, primero debes crear una instancia de un handle de colección de 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 ...
}

Ejecuta una pipeline de agregación

Puede ejecutar una canalización de agregación utilizando el collection.aggregate() método.

El siguiente fragmento de función agrupa todos los documentos de la purchases colección por su customerId valor y agrega un recuento del número de artículos que compra cada cliente, así como del número total de compras realizadas. Tras agrupar los documentos, la canalización añade un nuevo campo que calcula el promedio de artículos que cada cliente compra a la vez,, averageNumItemsPurchased al documento de cada cliente:

const pipeline = [
  { "$group": {
      "_id": "$customerId",
      "numPurchases": { "$sum": 1 },
      "numItemsPurchased": { "$sum": { "$size": "$items" } }
  } },
  { "$addFields": {
      "averageNumItemsPurchased": {
        "$divide": ["$numItemsPurchased", "$numPurchases"]
      }
  } }
]
return purchasesCollection.aggregate(pipeline).toArray()
  .then(customers => {
    console.log(`Successfully grouped purchases for ${customers.length} customers.`)
    for(const customer of customers) {
      console.log(`customer: ${customer._id}`)
      console.log(`num purchases: ${customer.numPurchases}`)
      console.log(`total items purchased: ${customer.numItemsPurchased}`)
      console.log(`average items per purchase: ${customer.averageNumItemsPurchased}`)
    }
    return customers
  })
  .catch(err => console.error(`Failed to group purchases by customer: ${err}`))

Encuentra datos con Atlas Search

Puede ejecutar consultas de búsqueda de |service| en una colección con y collection.aggregate() la $search etapa de agregación.

Importante

Las funciones de Atlas realizan operaciones $search como usuario del sistema y aplican reglas a nivel de campo en los resultados de búsqueda devueltos. Esto significa que un usuario puede buscar en un campo al que no tiene acceso de lectura. En este caso, la búsqueda se basa en el campo especificado, pero ningún documento devuelto incluye el campo.

exports = async function searchMoviesAboutBaseball() {
  // 1. Get a reference to the collection you want to search.
  const movies = context.services
    .get("mongodb-atlas")
    .db("sample_mflix")
    .collection("movies");
  // 2. Run an aggregation with $search as the first stage.
  const baseballMovies = await movies
    .aggregate([
      {
        $search: {
          text: {
            query: "baseball",
            path: "plot",
          },
        },
      },
      {
        $limit: 5,
      },
      {
        $project: {
          _id: 0,
          title: 1,
          plot: 1,
        },
      },
    ])
    .toArray();
  return baseballMovies;
};

{
  "plot" : "A trio of guys try and make up for missed
  opportunities in childhood by forming a three-player
  baseball team to compete against standard children
  baseball squads.",
  "title" : "The Benchwarmers"
}
{
  "plot" : "A young boy is bequeathed the ownership of a
  professional baseball team.",
  "title" : "Little Big League"
}
{
  "plot" : "A trained chimpanzee plays third base for a
  minor-league baseball team.",
  "title" : "Ed"
}
{
  "plot" : "The story of the life and career of the famed
  baseball player, Lou Gehrig.",
  "title" : "The Pride of the Yankees"
}
{
  "plot" : "Babe Ruth becomes a baseball legend but is
  unheroic to those who know him.",
  "title" : "The Babe"
}

Nota

$$SEARCH_META Variable Availability

La variable de agregación $$SEARCH_META solo está disponible para funciones que se ejecutan como sistema o si el primer rol sobre la colección buscada tiene sus expresiones apply_when y read configuradas en true.

Si ninguno de estos dos escenarios se aplica, $$SEARCH_META no está definido y la agregación fallará.

Etapas de agregación

Filtrar Documentos

Puede utilizar la etapa $match para filtrar los documentos entrantes utilizando la sintaxis de consulta estándar de MongoDB.

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

Ejemplo

La siguiente etapa $match filtra los documentos entrantes para incluir solo aquellos donde el campo graduation_year tiene un valor entre 2019 y 2024, inclusive.

{
  "$match": {
    "graduation_year": {
      "$gte": 2019,
      "$lte": 2024
    },
  }
}

Documentos de grupo

Puedes usar la etapa $group para agregar datos resumidos para grupos de uno o más documentos. MongoDB agrupa documentos en función de la expresión _id.

Nota

Puedes hacer referencia a un campo de documento específico anteponiendo el nombre del campo con un $.

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

Ejemplo

La siguiente $group etapa agrupa los documentos por el valor de su campo customerId y calcula el número de documentos de compra en los que aparece cada customerId.

{
  "$group": {
    "_id": "$customerId",
    "numPurchases": { "$sum": 1 }
  }
}

Campos del documento del proyecto

Puedes utilizar la etapa $project para incluir u omitir campos específicos de los documentos o calcular nuevos campos utilizando operadores de agregación. Para incluir un campo, establece su valor a 1. Para omitir un campo, establezca su valor en 0.

Nota

No se puede omitir e incluir simultáneamente campos distintos de _id. Si se incluye de forma explícita un campo diferente a _id, cualquier campo que no se haya incluido explícitamente se omite automáticamente (y viceversa).

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

Ejemplo

La siguiente etapa de $project omite el campo _id, incluye el campo customerId, y crea un campo nuevo llamado numItems donde el valor es el número de documentos en el arreglo items:

{
  "$project": {
    "_id": 0,
    "customerId": 1,
    "numItems": { "$sum": { "$size": "$items" } }
  }
}

Agregar campos a los documentos

Puedes utilizar la etapa $addFields para añadir nuevos campos con valores calculados utilizando operadores de agregación.

Nota

$addFields es similar a $project pero no te permite incluir ni omitir campos.

Ejemplo

Las siguientes $addFields etapas crean un nuevo campo llamado numItems donde el valor es el número de documentos en el arreglo items:

{
  "$addFields": {
    "numItems": { "$sum": { "$size": "$items" } }
  }
}

Unwind Array Values

Puedes utilizar la etapa $unwind para agregar elementos individuales de campos de tipo arreglo. Cuando desenrollas un campo de un arreglo, MongoDB copia cada documento una vez por cada elemento del arreglo, pero reemplaza el valor del arreglo por el elemento del arreglo en cada copia.

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

Ejemplo

La siguiente etapa $unwind crea un documento nuevo para cada elemento del arreglo items en cada documento. También agrega un campo llamado itemIndex a cada nuevo documento que especifica el índice de posición del elemento en el arreglo original:

{
  "$unwind": {
    "path": "$items",
    "includeArrayIndex": "itemIndex"
  }
}

Considere el siguiente documento de la colección purchases:

{
  _id: 123,
  customerId: 24601,
  items: [
    { name: "Baseball", quantity: 5 },
    { name: "Baseball Mitt", quantity: 1 },
    { name: "Baseball Bat", quantity: 1 },
  ]
}

Si aplicamos la etapa de ejemplo $unwind a este documento, la etapa produce los siguientes tres documentos:

{
  _id: 123,
  customerId: 24601,
  itemIndex: 0,
  items: { name: "Baseball", quantity: 5 }
}, {
  _id: 123,
  customerId: 24601,
  itemIndex: 1,
  items: { name: "Baseball Mitt", quantity: 1 }
}, {
  _id: 123,
  customerId: 24601,
  itemIndex: 2,
  items: { name: "Baseball Bat", quantity: 1 }
}

Limitaciones del marco de agregación

Métodos de Agregación

Las funciones Atlas admiten la agregación tanto en el nivel de base de datos como en el de colección mediante los siguientes comandos:

Disponibilidad de etapas del pipeline de agregación

Todas las etapas del proceso de agregación están disponibles para el usuario del sistema $indexStats excepto.

Disponibilidad del operador de tuberías de agregación

Atlas Functions admite todos los operadores de pipeline de agregación cuando ejecuta un pipeline de agregación en el contexto de usuario del sistema.

Volver

Guardar

Definir y gestionar secretos