Creador de agregaciones

Documentos de muestra

Los siguientes ejemplos ejecutan canalizaciones de agregación en una colección representada por el modelo User. Puedes agregar los datos de muestra ejecutando el siguiente método insert():

User::insert([
    ['name' => 'Alda Gröndal', 'occupation' => 'engineer', 'birthday' => new UTCDateTime(new DateTimeImmutable('2002-01-01'))],
    ['name' => 'Francois Soma', 'occupation' => 'engineer', 'birthday' => new UTCDateTime(new DateTimeImmutable('1998-02-02'))],
    ['name' => 'Janet Doe', 'occupation' => 'designer', 'birthday' => new UTCDateTime(new DateTimeImmutable('1987-03-03'))],
    ['name' => 'Eliud Nkosana', 'occupation' => 'engineer', 'birthday' => new UTCDateTime(new DateTimeImmutable('1984-04-04'))],
    ['name' => 'Bran Steafan', 'occupation' => 'engineer', 'birthday' => new UTCDateTime(new DateTimeImmutable('1998-05-05'))],
    ['name' => 'Ellis Lee', 'occupation' => 'designer', 'birthday' => new UTCDateTime(new DateTimeImmutable('1996-06-06'))],
]);

Ejemplo de etapa de coincidencia

Puedes encadenar el método match() a tu pipeline de agregación para especificar un filtro de query. Si omites esta etapa, el método aggregate() genera todos los documentos en la colección del modelo para la siguiente etapa.

Esta etapa de agregación a menudo se coloca primero para recuperar los datos utilizando los índices disponibles y reducir la cantidad de datos que procesan las etapas posteriores.

Este ejemplo construye un filtro de query para una etapa de agregación match utilizando el constructor MongoDB\Builder\Query. La etapa de coincidencia incluye los siguientes criterios:

• Devuelve resultados que coinciden con cualquiera de los filtros de consulta mediante la función Query::or()

• Coincide con documentos que contienen un campo occupation con un valor de "designer" utilizando las funciones Query::query() y Query::eq()

• Coincide con documentos que contienen un campo name con un valor de "Eliud Nkosana" mediante el uso de las funciones Query::query() y Query::eq()

Haga clic en el VIEW OUTPUT botón para ver los documentos devueltos al ejecutar el código:

$pipeline = User::aggregate()
    ->match(Query::or(
        Query::query(occupation: Query::eq('designer')),
        Query::query(name: Query::eq('Eliud Nkosana')),
    ));
$result = $pipeline->get();

[
  {
    "_id": ...,
    "name": "Janet Doe",
    "occupation": "designer",
    "birthday": {
      "$date": {
        "$numberLong": "541728000000"
      }
    }
  },
  {
    "_id": ...,
    "name": "Eliud Nkosana",
    "occupation": "engineer",
    "birthday": {
      "$date": {
        "$numberLong": "449884800000"
      }
    }
  },
  {
    "_id": ...,
    "name": "Ellis Lee",
    "occupation": "designer",
    "birthday": {
      "$date": {
        "$numberLong": "834019200000"
      }
    }
  }
]

Ejemplo de fase de grupos

Puede encadenar el método group() en su pipeline de agregación para modificar la estructura de los datos realizando cálculos y agrupándolos por valores comunes de campos.

Esta etapa de agregación a menudo se coloca inmediatamente después de una etapa de coincidencia para reducir los datos que las etapas posteriores procesan.

Este ejemplo utiliza el MongoDB\Builder\Expression constructor para definir las claves de grupo en una etapa de agregación de grupos. La etapa de grupo especifica el siguiente comportamiento de agrupación:

• Establece el valor de la clave de grupo, representada por el campo _id, al valor de campo definido por el generador Expression

• Hace referencia a los valores del documento en el campo occupation llamando a la función Expression::fieldPath()

Haz clic en el botón VIEW OUTPUT para ver los documentos devueltos al ejecutar el código:

$pipeline = User::aggregate()
    ->group(_id: Expression::fieldPath('occupation'));
$result = $pipeline->get();

[
  { "_id": "engineer" },
  { "_id": "designer" }
]

Ejemplo de etapa de clasificación

Puedes encadenar el método sort() a tu pipeline de agregación para especificar el orden de salida de los documentos.

Puedes agregar esta etapa de agregación en cualquier lugar del pipeline. A menudo se coloca después de la etapa de grupo ya que puede depender de los datos agrupados. Recomendamos colocar la etapa de ordenamiento lo más tarde posible en el pipeline para limitar los datos que procesa.

Para especificar un ordenamiento, establece el valor del campo en el enumerado Sort::Asc para un orden ascendente o en el enumerado Sort::Desc para un orden descendente.

Este ejemplo muestra una etapa de canalización de agregación sort() que ordena los documentos desde el campo name hasta el Sort::Desc, lo que corresponde al orden alfabético inverso. Haga clic en el botón VIEW OUTPUT para ver los documentos devueltos al ejecutar el código:

$pipeline = User::aggregate()
    ->sort(name: Sort::Desc);
$result = $pipeline->get();

[
  {
    "_id": ...,
    "name": "Janet Doe",
    "occupation": "designer",
    "birthday": {
      "$date": {
        "$numberLong": "541728000000"
      }
    }
  },
  {
    "_id": ...,
    "name": "Francois Soma",
    "occupation": "engineer",
    "birthday": {
      "$date": {
        "$numberLong": "886377600000"
      }
    }
  },
  {
    "_id": ...,
    "name": "Ellis Lee",
    "occupation": "designer",
    "birthday": {
      "$date": {
        "$numberLong": "834019200000"
      }
    }
  },
  {
    "_id": ...,
    "name": "Eliud Nkosana",
    "occupation": "engineer",
    "birthday": {
      "$date": {
        "$numberLong": "449884800000"
      }
    }
  },
  {
    "_id": ...,
    "name": "Bran Steafan",
    "occupation": "engineer",
    "birthday": {
      "$date": {
        "$numberLong": "894326400000"
      }
    }
  },
  {
    "_id": ...,
    "name": "Alda Gröndal",
    "occupation": "engineer",
    "birthday": {
      "$date": {
        "$numberLong": "1009843200000"
      }
    }
  }
]

Ejemplo de etapa del proyecto

Puedes encadenar el método project() a tu pipeline de agregación para especificar los campos de los documentos que se mostrarán en esta etapa.

Para especificar los campos a incluir, pasa el nombre de un campo y un valor verdadero, como 1 o true. Todos los demás campos se omiten de la salida.

Como alternativa, para especificar los campos que se excluirán, pase el nombre de cada campo y un valor falso, como 0 o false. Todos los demás campos se incluyen en la salida.

Este ejemplo muestra cómo usar la etapa de agregación del método project() para incluir solo el campo name y excluir todos los demás campos de la salida. Haga clic en el botón VIEW OUTPUT para ver los datos devueltos al ejecutar el código:

$pipeline = User::aggregate()
    ->project(_id: 0, name: 1);
$result = $pipeline->get();

[
  { "name": "Alda Gröndal" },
  { "name": "Francois Soma" },
  { "name": "Janet Doe" },
  { "name": "Eliud Nkosana" },
  { "name": "Bran Steafan" },
  { "name": "Ellis Lee" }
]

Ejemplo de Filtro y Agrupación

Este ejemplo utiliza los datos de muestra proporcionados en la sección Calcular recuento, suma y promedio de la referencia de etapa $group en el manual del servidor.

El siguiente ejemplo de código calcula el monto total de ventas, la cantidad promedio de ventas y el recuento de ventas para cada día del año 2014. Para ello, utiliza una pipeline de agregación que contiene las siguientes etapas:

1. $match etapa para filtrar documentos que tengan un campo date en el que el año sea 2014

2. $group etapa para agrupar los documentos por fecha y calcular el monto total de las ventas, la cantidad media de ventas y el recuento de ventas para cada grupo

3. Etapa $sort para ordenar los resultados por el monto total de venta para cada grupo en orden descendente

Haz clic en el botón VIEW OUTPUT para ver los datos devueltos al ejecutar el código:

$pipeline = Sale::aggregate()
    ->match(
        date: [
            Query::gte(new UTCDateTime(new DateTimeImmutable('2014-01-01'))),
            Query::lt(new UTCDateTime(new DateTimeImmutable('2015-01-01'))),
        ],
    )
    ->group(
        _id: Expression::dateToString(Expression::dateFieldPath('date'), '%Y-%m-%d'),
        totalSaleAmount: Accumulator::sum(
            Expression::multiply(
                Expression::numberFieldPath('price'),
                Expression::numberFieldPath('quantity'),
            ),
        ),
        averageQuantity: Accumulator::avg(
            Expression::numberFieldPath('quantity'),
        ),
        count: Accumulator::sum(1),
    )
    ->sort(
        totalSaleAmount: Sort::Desc,
    );

[
  { "_id": "2014-04-04", "totalSaleAmount": { "$numberDecimal": "200" }, "averageQuantity": 15, "count": 2 },
  { "_id": "2014-03-15", "totalSaleAmount": { "$numberDecimal": "50" }, "averageQuantity": 10, "count": 1 },
  { "_id": "2014-03-01", "totalSaleAmount": { "$numberDecimal": "40" }, "averageQuantity": 1.5, "count": 2 }
]

Ejemplo para desanidar arrays embebidos

Este ejemplo utiliza los datos de muestra proporcionados en la sección Unwind Embedded Arrays de la $unwind referencia de la etapa en el manual del servidor.

El siguiente ejemplo de código agrupa los artículos vendidos por sus etiquetas y calcula el importe total de ventas para cada etiqueta. Para ello, utiliza una pipeline de agregación que contiene las siguientes etapas:

1. $unwind etapa para emitir un documento separado para cada elemento en el arreglo items

2. La etapa $unwind para generar un documento independiente para cada elemento en los arreglos items.tags.

3. Etapa de grupo para agrupar los documentos por valor de etiqueta y calcular el monto total de ventas de los artículos que tienen cada etiqueta

Haz clic en el botón VIEW OUTPUT para ver los datos devueltos al ejecutar el código:

$pipeline = Sale::aggregate()
    ->unwind(Expression::arrayFieldPath('items'))
    ->unwind(Expression::arrayFieldPath('items.tags'))
    ->group(
        _id: Expression::fieldPath('items.tags'),
        totalSalesAmount: Accumulator::sum(
            Expression::multiply(
                Expression::numberFieldPath('items.price'),
                Expression::numberFieldPath('items.quantity'),
            ),
        ),
    );

[
  { "_id": "school", "totalSalesAmount": { "$numberDecimal": "104.85" } },
  { "_id": "electronics", "totalSalesAmount": { "$numberDecimal": "800.00" } },
  { "_id": "writing", "totalSalesAmount": { "$numberDecimal": "60.00" } },
  { "_id": "office", "totalSalesAmount": { "$numberDecimal": "1019.60" } },
  { "_id": "stationary", "totalSalesAmount": { "$numberDecimal": "264.45" } }
]

Ejemplo de unión de igualdad simple

Este ejemplo utiliza los datos de muestra proporcionados en la sección Realizar una unión de igualdad única con $lookup de la referencia de la $lookup etapa en el manual del servidor.

El siguiente ejemplo de código une los documentos de la colección orders con los documentos de la colección inventory usando el campo item de la colección orders y el campo sku de la colección inventory.

Para ello, el ejemplo utiliza una canalización de agregación que contiene una etapa $lookup que especifica la colección de la que se recuperarán los datos y los nombres de los campos locales y externos.

Haz clic en el botón VIEW OUTPUT para ver los datos devueltos al ejecutar el código:

$pipeline = Order::aggregate()
    ->lookup(
        from: 'inventory',
        localField: 'item',
        foreignField: 'sku',
        as: 'inventory_docs',
    );

[
  { "_id": 1, "item": "almonds", "price": 12, "quantity": 2, "inventory_docs": [
      { "_id": 1, "sku": "almonds", "description": "product 1", "instock": 120 }
  ] },
  { "_id": 2, "item": "pecans", "price": 20, "quantity": 1, "inventory_docs": [
      { "_id": 4, "sku": "pecans", "description": "product 4", "instock": 70 }
  ] },
  { "_id": 3, "inventory_docs": [
      { "_id": 5, "sku": null, "description": "Incomplete" },
      { "_id": 6 }
  ] }
]