Página inicial do Docs

/ /

Referência

Página inicial do Docs

Desenvolvimento

Operações de agregação

Referência

Página inicial do Docs

Desenvolvimento

Operações de agregação

Referência

Gráfico de mapeamento SQL para agregação

Opipeline de agregação do permite que o MongoDB forneça recursos de agregação nativos que correspondem a muitas operações comuns de agregação de dados no SQL.

A tabela a seguir fornece uma visão geral dos termos, funções e conceitos de agregação SQL comuns e dos operadores de agregaçãoMongoDB correspondentes:

Termos, funções e conceitos do SQL	Operadores de agregação do MongoDB
WHERE	`$match`
AGRUPAR POR	`$group`
HAVING	`$match`
SELECT	`$project`
ORDENAR POR	`$sort`
LIMIT	`$limit`
SUM()	`$sum`
COUNT()	`$sum` `$sortByCount`
juntar	`$lookup`
SELECIONAR EM NEW_TABLE	`$out`
MESCLAR NA TABELA	`$merge`
UNION ALL	`$unionWith`

Para obter uma lista de todos os operadores de expressão e pipeline de agregação, consulte:

Dica

Gráfico de mapeamento SQL para MongoDB

Exemplos

A tabela a seguir apresenta uma referência rápida de declarações de agregação SQL e as declarações MongoDB correspondentes. Os exemplos na tabela pressupõem as seguintes condições:

Os exemplos SQL assumem duas tabelas, orders e order_lineitem que participam pelas colunas order_lineitem.order_id e orders.id.

Os exemplos do MongoDB assumem uma coleção orders que contém documentos do seguinte protótipo:

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

Exemplo de SQL

Exemplo de MongoDB

Descrição

SELECT COUNT(*) AS count
FROM orders

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

Contagem de todos os registros de orders

SELECT SUM(price) AS total
FROM orders

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

Soma o 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, soma o 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 exclusivo, some o campo price , resultados classificados por soma.

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 agrupamento exclusivo cust_id, ord_date , some o campo price . Exclui a parte de tempo da data.

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 com múltiplos registros, retorne o cust_id e a contagem de registro correspondente.

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 agrupamento exclusivo de cust_id, ord_date, some o campo price e retorne somente quando a soma for maior que 250. Exclui a parte de tempo da data.

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 com status A, soma o 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 exclusivo com status A, some o campo price e retorne apenas quando a soma for maior 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, soma os campos de item de linha qty correspondentes associados aos 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 }
     }
   }
] )

Conte o número de agrupamentos cust_id, ord_date distintos. Exclui a parte de tempo da data.

Dica

Voltar

variáveis

Map-Reduce