/ /

Operaciones de agregación

Referencia

Docs Home

Desarrollo

Operaciones de agregación

Referencia

Gráfica de mapeo de SQL a agregación

El La canalización de agregación permite a MongoDB proporcionar capacidades de agregación nativas que corresponden a muchas operaciones de agregación de datos comunes en SQL.

La siguiente tabla proporciona una descripción general de los términos, funciones y conceptos de agregación de SQL comunes y los operadores de agregación de MongoDB correspondientes:

Términos, funciones y conceptos de SQL	Operadores de agregación de MongoDB
DONDE	`$match`
AGRUPAR POR	`$group`
TENIENDO	`$match`
SELECCIONE	`$project`
ORDENAR POR	`$sort`
LIMIT	`$limit`
SUMA()	`$sum`
CONTAR()	`$sum` `$sortByCount`
Join	`$lookup`
SELECCIONAR A NEW_TABLE	`$out`
INSERTAR EN TABLA	`$merge`
UNIR TODO	`$unionWith`

Para obtener una lista de todos los operadores de expresión y canalización de agregación, consulte:

Tip

Gráfica de mapeo de SQL a MongoDB

Ejemplos

La siguiente tabla presenta una referencia rápida de las sentencias de agregación de SQL y las sentencias correspondientes de MongoDB. Los ejemplos de la tabla asumen las siguientes condiciones:

Los ejemplos de SQL suponen dos tablas, orders y,order_lineitem que se unen mediante order_lineitem.order_id las orders.id columnas y.

Los ejemplos de MongoDB asumen una colección orders que contiene documentos del siguiente prototipo:

{
  cust_id: "abc123",
  ord_date: ISODate("2012-11-02T17:04:11.102Z"),
  status: 'A',
  price: 50,
  items: [ { sku: "xxx", qty: 25, price: 1 },
           { sku: "yyy", qty: 25, price: 1 } ]
}

Ejemplo de SQL

Ejemplo de MongoDB

Descripción

SELECT COUNT(*) AS count
FROM orders

db.orders.aggregate( [
   {
     $group: {
        _id: null,
        count: { $sum: 1 }
     }
   }
] )

Cuente todos los registros de orders

SELECT SUM(price) AS total
FROM orders

db.orders.aggregate( [
   {
     $group: {
        _id: null,
        total: { $sum: "$price" }
     }
   }
] )

Sumar el campo price de orders

SELECT cust_id,
       SUM(price) AS total
FROM orders
GROUP BY cust_id

db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   }
] )

Para cada cust_id único, sume el campo price.

SELECT cust_id,
       SUM(price) AS total
FROM orders
GROUP BY cust_id
ORDER BY total

db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   },
   { $sort: { total: 1 } }
] )

Para cada cust_id único, suma el campo price y los resultados se ordenan por suma.

SELECT cust_id,
       ord_date,
       SUM(price) AS total
FROM orders
GROUP BY cust_id,
         ord_date

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: { $dateToString: {
              format: "%Y-%m-%d",
              date: "$ord_date"
           }}
        },
        total: { $sum: "$price" }
     }
   }
] )

Para cada agrupación única cust_id, ord_date, sume el campo price. Excluye la parte horaria de la fecha.

SELECT cust_id,
       count(*)
FROM orders
GROUP BY cust_id
HAVING count(*) > 1

db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        count: { $sum: 1 }
     }
   },
   { $match: { count: { $gt: 1 } } }
] )

Para cust_id con múltiples registros, devuelve cust_id y el recuento de registros correspondiente.

SELECT cust_id,
       ord_date,
       SUM(price) AS total
FROM orders
GROUP BY cust_id,
         ord_date
HAVING total > 250

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: { $dateToString: {
              format: "%Y-%m-%d",
              date: "$ord_date"
           }}
        },
        total: { $sum: "$price" }
     }
   },
   { $match: { total: { $gt: 250 } } }
] )

Para cada agrupación única cust_id, ord_date, se suma el campo price y se devuelve solo cuando la suma es mayor que 250. Se excluye la parte horaria de la fecha.

SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id

db.orders.aggregate( [
   { $match: { status: 'A' } },
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   }
] )

Para cada cust_id único con estado A, sume el campo price.

SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id
HAVING total > 250

db.orders.aggregate( [
   { $match: { status: 'A' } },
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   },
   { $match: { total: { $gt: 250 } } }
] )

Para cada cust_id único con estado A, sume el campo price y devuelva solo donde la suma sea mayor que 250.

SELECT cust_id,
       SUM(li.qty) as qty
FROM orders o,
     order_lineitem li
WHERE li.order_id = o.id
GROUP BY cust_id

db.orders.aggregate( [
   { $unwind: "$items" },
   {
     $group: {
        _id: "$cust_id",
        qty: { $sum: "$items.qty" }
     }
   }
] )

Para cada cust_id único, sume los campos de la línea de artículo qty correspondientes asociados con los pedidos.

SELECT COUNT(*)
FROM (SELECT cust_id,
             ord_date
      FROM orders
      GROUP BY cust_id,
               ord_date)
      as DerivedTable

db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: { $dateToString: {
              format: "%Y-%m-%d",
              date: "$ord_date"
           }}
        }
     }
   },
   {
     $group: {
        _id: null,
        count: { $sum: 1 }
     }
   }
] )

Cuenta el número de agrupaciones cust_id y ord_date distintas. Excluye la parte horaria de la fecha.

Tip

Volver

Variables

Map-Reduce