/ /

$setWindowFields (estágio de agregação )

Definição

$setWindowFields

Novidade na versão 5.0.

Executa operações em um intervalo especificado de documentos em uma coleção, conhecido como janela, e retorna os resultados com base no operador de blocos escolhido.

Por exemplo, você pode utilizar o estágio $setWindowFields para produzir o:

Diferença nas vendas entre dois documentos em uma coleção.
Classificações de vendas.
Total cumulativo de vendas.
Análise de informações complexas de séries temporais sem exportar os dados para um banco de dados externo.

Sintaxe

A sintaxe de estágio $setWindowFields:

{
   $setWindowFields: {
      partitionBy: <expression>,
      sortBy: {
         <sort field 1>: <sort order>,
         <sort field 2>: <sort order>,
         ...,
         <sort field n>: <sort order>
      },
      output: {
         <output field 1>: {
            <window operator>: <window operator parameters>,
            window: {
               documents: [ <lower boundary>, <upper boundary> ],
               range: [ <lower boundary>, <upper boundary> ],
               unit: <time unit>
            }
         },
         <output field 2>: { ... },
         ...
         <output field n>: { ... }
      }
   }
}

O estágio $setWindowFields toma um documento com estes campos:

Campo	necessidade	Descrição
partitionBy	Opcional	Especifica uma expressão para agrupar os documentos. No estágio `$setWindowFields`, o grupo de documentos é conhecido como uma partição. O padrão é uma partição para toda a coleção.
sortBy	Necessário para alguns operadores (consulte Restrições)	Especifica o(s) campo(s) para classificar os documentos na partição. Usa a mesma sintaxe do estágio `$sort`. O padrão não está classificando.
saída	Obrigatório	Especifica o(s) campo(s) a ser(em) anexado(s) aos documentos no resultado retornado pelo estágio `$setWindowFields`. Cada campo é definido como o resultado retornado pelo operador de blocos. Um campo pode conter pontos para especificar campos de documento incorporados e campos de array. A semântica da notação pontilhada do documento incorporado no estágio `$setWindowFields` é a mesma dos estágios `$addFields` e `$set`. Consulte exemplo de documento incorporado $addFields e exemplo de documento incorporado $set. `window operator` é o nome do operador de blocos para usar no estágio `$setWindowFields`. `window operator parameters` são os parâmetros a serem passados para o operador de blocos.
window	Opcional	Especifica os parâmetros e limites da janela. Os limites da janela são inclusivos. O padrão é uma janela sem limite, que inclui todos os documentos na partição. Especifique uma janela de documentos ou faixa.
documentos	Opcional	Uma janela onde os limites inferior e superior são especificados em relação à posição do documento atual lido na collection. Os limites da janela são especificados usando uma array de dois elementos contendo uma string ou número inteiro de limite inferior e superior. Usar: A string `"current"` para a posição atual do documento no resultado. A string `"unbounded"` para a posição do primeiro ou último documento na partição. Um número inteiro para uma posição relativa ao documento atual. Use um número inteiro negativo para uma posição antes do documento atual. Use um número inteiro positivo para uma posição após o documento atual. `0` é a posição atual do documento. Consulte Exemplos de janelas de documentos.
faixa	Opcional	Uma janela onde os limites inferior e superior são definidos utilizando uma faixa de valores baseada no campo sortBy no documento atual. Os limites da janela são especificados usando uma array de dois elementos contendo uma string ou número de limite inferior e superior. Usar: A string `"current"` para a posição atual do documento no resultado. A string `"unbounded"` para a posição do primeiro ou último documento na partição. Um número a ser adicionado ao valor do campo sortBy do documento atual. Um documento estará na janela se o valor do campo sortBy estiver inclusive dentro dos limites inferior e superior. Consulte Exemplo de janela de faixa.
unidade	Opcional	Especifica as unidades para os limites da janela de faixa de tempo. Pode-se definir como uma destas strings: `"year"` `"quarter"` `"month"` `"week"` `"day"` `"hour"` `"minute"` `"second"` `"millisecond"` No caso de omissão, os limites numéricos padrão da janela de faixa serão usados. Consulte Exemplos de janela de faixa de tempo.

Dica

Exemplos

Comportamento

O estágio $setWindowFields acrescenta novos campos aos documentos existentes. Você pode incluir um ou mais estágios $setWindowFields em uma operação de agregação.

A partir do MongoDB 5.3, você pode usar o estágio $setWindowFields com transações e a preocupação de leitura "snapshot".

O estágio $setWindowFields não garante a ordem dos documentos retornados.

Operadores de Janela

Esses operadores podem ser utilizados com o estágio $setWindowFields:

Operadores acumuladores: $addToSet, $avg, $bottom, $bottomN, $concatArrays, $count, $covariancePop, $covarianceSamp, $derivative, $expMovingAvg, $firstN, $integral, $lastN, $max, $maxN, $median, $mergeObjects, $min, $minN, $percentile, $push, $setUnion, $stdDevSamp, $stdDevPop, $sum, $top, $topN.

Operadores de preenchimento de lacunas: $linearFill e $locf.

Operadores de ordem: $first, $last e $shift.

Operadores de classificação: $denseRank, $documentNumber e $rank.
Operador de faixa: $minMaxScaler

Explicar a saída

Novidades na versão 8.3.

Se você executar explain em uma operação $setWindowsFields, a saída conterá um campo peakTrackedMemBytes que contém o número máximo de bytes de memória monitorada em uso. Para mais informações, consulte explain.executionStats.peakTrackedMemBytes.

Restrições

Restrições para o estágio $setWindowFields:

Antes do MongoDB 5.3, o estágio $setWindowFields não pode ser usado:
- Dentro de transações.
- Com a read concern "snapshot".
sortBy é necessário para:
- classifique e ordene operadores de blocos.
- Janelas com limites (uma janela de documentos ou uma janela de faixa).
- $linearFill operador.
As janelas de faixa exigem que todos os valores sortBy sejam números.
As janelas de faixa de tempo exigem que todos os valores de sortBy sejam datas.
As janelas de faixa e faixa de tempo só podem conter um campo sortBy e a ordem deve ser ascendente.
Você não pode especificar uma janela de documentos e uma janela de faixa.
Estes operadores usam uma janela implícita e retornam um erro se você especificar uma opção de janela:
- Operadores de classificação.
- $shift operador.
No caso das janelas de faixa, somente números na faixa especificada são incluídos na janela. Valores ausentes, indefinidos e null são excluídos.
Para janelas de faixa de tempo:
- Somente tipos de data e hora são incluídos na janela.
- Os valores de limite numéricos devem ser inteiros. Por exemplo, você pode usar 2 horas como limite, mas não pode usar 1,5 hora.
Para janelas vazias ou janelas com valores incompatíveis (por exemplo, utilizando $sum em strings), o valor retornado depende do operador:
- Para $count e $sum, o valor retornado é 0.
- Para $addToSet e $push, o valor retornado é uma array vazia.
- Para todos os outros operadores, o valor retornado é null.

Exemplos

Crie uma collection cakeSales que contenha vendas de bolo nos estados da Califórnia (CA) e de Washington (WA):

db.cakeSales.insertMany( [
   { _id: 0, type: "chocolate", orderDate: new Date("2020-05-18T14:10:30Z"),
     state: "CA", price: 13, quantity: 120 },
   { _id: 1, type: "chocolate", orderDate: new Date("2021-03-20T11:30:05Z"),
     state: "WA", price: 14, quantity: 140 },
   { _id: 2, type: "vanilla", orderDate: new Date("2021-01-11T06:31:15Z"),
     state: "CA", price: 12, quantity: 145 },
   { _id: 3, type: "vanilla", orderDate: new Date("2020-02-08T13:13:23Z"),
     state: "WA", price: 13, quantity: 104 },
   { _id: 4, type: "strawberry", orderDate: new Date("2019-05-18T16:09:01Z"),
     state: "CA", price: 41, quantity: 162 },
   { _id: 5, type: "strawberry", orderDate: new Date("2019-01-08T06:12:03Z"),
     state: "WA", price: 43, quantity: 134 }
] )

Os exemplos a seguir usam a collection cakeSales.

Exemplos de janelas de documentos

Use a janela de documentos para obter a quantidade cumulativa para cada estado

Este exemplo usa uma janela de documentos em $setWindowFields para gerar as vendas cumulativas de bolos quantity para cada state. No resultado de exemplo , o campo cumulativeQuantityForState mostra o quantity cumulativo para CA e WA.

db.cakeSales.aggregate( [
   {
      $setWindowFields: {
         partitionBy: "$state",
         sortBy: { orderDate: 1 },
         output: {
            cumulativeQuantityForState: {
               $sum: "$quantity",
               window: {
                  documents: [ "unbounded", "current" ]
               }
            }
         }
      }
   }
] )

[
  {
    _id: 4,
    type: 'strawberry',
    orderDate: ISODate('2019-05-18T16:09:01.000Z'),
    state: 'CA',
    price: 41,
    quantity: 162,
    cumulativeQuantityForState: 162
  },
  {
    _id: 0,
    type: 'chocolate',
    orderDate: ISODate('2020-05-18T14:10:30.000Z'),
    state: 'CA',
    price: 13,
    quantity: 120,
    cumulativeQuantityForState: 282
  },
  {
    _id: 2,
    type: 'vanilla',
    orderDate: ISODate('2021-01-11T06:31:15.000Z'),
    state: 'CA',
    price: 12,
    quantity: 145,
    cumulativeQuantityForState: 427
  },
  {
    _id: 5,
    type: 'strawberry',
    orderDate: ISODate('2019-01-08T06:12:03.000Z'),
    state: 'WA',
    price: 43,
    quantity: 134,
    cumulativeQuantityForState: 134
  },
  {
    _id: 3,
    type: 'vanilla',
    orderDate: ISODate('2020-02-08T13:13:23.000Z'),
    state: 'WA',
    price: 13,
    quantity: 104,
    cumulativeQuantityForState: 238
  },
  {
    _id: 1,
    type: 'chocolate',
    orderDate: ISODate('2021-03-20T11:30:05.000Z'),
    state: 'WA',
    price: 14,
    quantity: 140,
    cumulativeQuantityForState: 378
  }
]

No exemplo:

partitionBy: "$state" divide os documentos da coleção por state. Existem divisões para CA e WA.
sortBy: { orderDate: 1 } ordena os documentos em cada partição por orderDate em ordem crescente (1), de modo que o orderDate mais antigo seja o primeiro.

output:
- Define o campo cumulativeQuantityForState para o quantity cumulativo para cada state, o que aumenta sucessivamente ao valor anterior na partição.
- Calcula o quantity cumulativo utilizando o operador $sum executado em uma janela de documentos.
  
  A janela contém documentos entre um limite inferior unbounded e o documento current. Isso significa que $sum retorna a quantity cumulativa dos documentos entre o início da partição e o documento atual.

Use a janela de documentos para obter a quantidade cumulativa para cada ano

Este exemplo usa uma janela de documentos em $setWindowFields para gerar as vendas cumulativas de bolos quantity para cada $year em orderDate. No exemplo de resultados, o campo cumulativeQuantityForYear mostra o quantity cumulativo para cada ano.

db.cakeSales.aggregate( [
   {
      $setWindowFields: {
         partitionBy: { $year: "$orderDate" },
         sortBy: { orderDate: 1 },
         output: {
            cumulativeQuantityForYear: {
               $sum: "$quantity",
               window: {
                  documents: [ "unbounded", "current" ]
               }
            }
         }
      }
   }
] )

[
  {
    _id: 5,
    type: 'strawberry',
    orderDate: ISODate('2019-01-08T06:12:03.000Z'),
    state: 'WA',
    price: 43,
    quantity: 134,
    cumulativeQuantityForYear: 134
  },
  {
    _id: 4,
    type: 'strawberry',
    orderDate: ISODate('2019-05-18T16:09:01.000Z'),
    state: 'CA',
    price: 41,
    quantity: 162,
    cumulativeQuantityForYear: 296
  },
  {
    _id: 3,
    type: 'vanilla',
    orderDate: ISODate('2020-02-08T13:13:23.000Z'),
    state: 'WA',
    price: 13,
    quantity: 104,
    cumulativeQuantityForYear: 104
  },
  {
    _id: 0,
    type: 'chocolate',
    orderDate: ISODate('2020-05-18T14:10:30.000Z'),
    state: 'CA',
    price: 13,
    quantity: 120,
    cumulativeQuantityForYear: 224
  },
  {
    _id: 2,
    type: 'vanilla',
    orderDate: ISODate('2021-01-11T06:31:15.000Z'),
    state: 'CA',
    price: 12,
    quantity: 145,
    cumulativeQuantityForYear: 145
  },
  {
    _id: 1,
    type: 'chocolate',
    orderDate: ISODate('2021-03-20T11:30:05.000Z'),
    state: 'WA',
    price: 14,
    quantity: 140,
    cumulativeQuantityForYear: 285
  }
]

No exemplo:

partitionBy: { $year: "$orderDate" } divide os documentos na collection por $year em orderDate. Existem partições para 2019, 2020 e 2021.
sortBy: { orderDate: 1 } ordena os documentos em cada partição por orderDate em ordem crescente (1), de modo que o orderDate mais antigo seja o primeiro.
output:
- Define o campo cumulativeQuantityForYear para o quantity cumulativo para cada ano, que aumenta sucessivamente o valor anterior na partição.
- Calcula o quantity cumulativo utilizando o operador $sum executado em uma janela de documentos.
  
  A janela contém documentos entre um limite inferior unbounded e o documento current. Isso significa que $sum retorna a quantity cumulativa dos documentos entre o início da partição e o documento atual.

Use a janela de documentos para obter a quantidade média móvel para cada ano

Este exemplo utiliza uma janela de documentos em $setWindowFields para produzir a média móvel para as vendas de bolo quantity. No resultado do exemplo , o campo averageQuantity mostra a média móvel quantity.

db.cakeSales.aggregate( [
   {
      $setWindowFields: {
         partitionBy: { $year: "$orderDate" },
         sortBy: { orderDate: 1 },
         output: {
            averageQuantity: {
               $avg: "$quantity",
               window: {
                  documents: [ -1, 0 ]
               }
            }
         }
      }
   }
] )

[
  {
    _id: 5,
    type: 'strawberry',
    orderDate: ISODate('2019-01-08T06:12:03.000Z'),
    state: 'WA',
    price: 43,
    quantity: 134,
    averageQuantity: 134
  },
  {
    _id: 4,
    type: 'strawberry',
    orderDate: ISODate('2019-05-18T16:09:01.000Z'),
    state: 'CA',
    price: 41,
    quantity: 162,
    averageQuantity: 148
  },
  {
    _id: 3,
    type: 'vanilla',
    orderDate: ISODate('2020-02-08T13:13:23.000Z'),
    state: 'WA',
    price: 13,
    quantity: 104,
    averageQuantity: 104
  },
  {
    _id: 0,
    type: 'chocolate',
    orderDate: ISODate('2020-05-18T14:10:30.000Z'),
    state: 'CA',
    price: 13,
    quantity: 120,
    averageQuantity: 112
  },
  {
    _id: 2,
    type: 'vanilla',
    orderDate: ISODate('2021-01-11T06:31:15.000Z'),
    state: 'CA',
    price: 12,
    quantity: 145,
    averageQuantity: 145
  },
  {
    _id: 1,
    type: 'chocolate',
    orderDate: ISODate('2021-03-20T11:30:05.000Z'),
    state: 'WA',
    price: 14,
    quantity: 140,
    averageQuantity: 142.5
  }
]

No exemplo:

partitionBy: "$orderDate" divide os documentos na collection por $year em orderDate. Existem partições para 2019, 2020 e 2021.
sortBy: { orderDate: 1 } ordena os documentos em cada partição por orderDate em ordem crescente (1), de modo que o orderDate mais antigo seja o primeiro.
output:
- Define o campo averageQuantity para a média móvel quantity para cada ano.
- Calcula a média móvel quantity utilizando o operador $avg executado em uma janela de documentos.
  
  A janela contém documentos entre -1 e 0. Isso significa que $avg retorna a média móvel quantity entre o documento antes do documento atual (-1) e o documento atual (0) na partição.

Use a janela de documentos para obter a quantidade máxima e cumulativa para cada ano

Este exemplo usa uma janela de documentos em $setWindowFields para gerar os valores quantity cumulativos e máximos de vendas de bolo para cada $year em orderDate. No resultado de exemplo , o campo cumulativeQuantityForYear mostra o quantity cumulativo e o campo maximumQuantityForYear mostra o quantity máximo.

db.cakeSales.aggregate( [
   {
      $setWindowFields: {
         partitionBy: { $year: "$orderDate" },
         sortBy: { orderDate: 1 },
         output: {
            cumulativeQuantityForYear: {
               $sum: "$quantity",
               window: {
                  documents: [ "unbounded", "current" ]
               }
            },
            maximumQuantityForYear: {
               $max: "$quantity",
               window: {
                  documents: [ "unbounded", "unbounded" ]
               }
            }
         }
      }
   }
] )

[
  {
    _id: 5,
    type: 'strawberry',
    orderDate: ISODate('2019-01-08T06:12:03.000Z'),
    state: 'WA',
    price: 43,
    quantity: 134,
    cumulativeQuantityForYear: 134,
    maximumQuantityForYear: 162
  },
  {
    _id: 4,
    type: 'strawberry',
    orderDate: ISODate('2019-05-18T16:09:01.000Z'),
    state: 'CA',
    price: 41,
    quantity: 162,
    cumulativeQuantityForYear: 296,
    maximumQuantityForYear: 162
  },
  {
    _id: 3,
    type: 'vanilla',
    orderDate: ISODate('2020-02-08T13:13:23.000Z'),
    state: 'WA',
    price: 13,
    quantity: 104,
    cumulativeQuantityForYear: 104,
    maximumQuantityForYear: 120
  },
  {
    _id: 0,
    type: 'chocolate',
    orderDate: ISODate('2020-05-18T14:10:30.000Z'),
    state: 'CA',
    price: 13,
    quantity: 120,
    cumulativeQuantityForYear: 224,
    maximumQuantityForYear: 120
  },
  {
    _id: 2,
    type: 'vanilla',
    orderDate: ISODate('2021-01-11T06:31:15.000Z'),
    state: 'CA',
    price: 12,
    quantity: 145,
    cumulativeQuantityForYear: 145,
    maximumQuantityForYear: 145
  },
  {
    _id: 1,
    type: 'chocolate',
    orderDate: ISODate('2021-03-20T11:30:05.000Z'),
    state: 'WA',
    price: 14,
    quantity: 140,
    cumulativeQuantityForYear: 285,
    maximumQuantityForYear: 145
  }
]

No exemplo:

partitionBy: "$orderDate" divide os documentos na collection por $year em orderDate. Existem partições para 2019, 2020 e 2021.
sortBy: { orderDate: 1 } ordena os documentos em cada partição por orderDate em ordem crescente (1), de modo que o orderDate mais antigo seja o primeiro.
output:
- Define o campo cumulativeQuantityForYear como quantity cumulativo para cada ano.
- Calcula o quantity cumulativo utilizando o operador $sum executado em uma janela de documentos.
  
  A janela contém documentos entre um limite inferior unbounded e o documento current. Isso significa que $sum retorna a quantidade cumulativa para os documentos entre o início da partição e o documento atual.
- Define o campo maximumQuantityForYear para a quantity máxima para cada ano.
- Calcula a quantity máxima de todos os documentos usando o operador $max executado em uma janela de documentos.
  
  A janela contém documentos entre um upper inferior e limite unbounded. Isso significa que $max retorna a quantidade máxima para os documentos na partição.

Exemplo de janela de faixa

Este exemplo usa uma janela de faixa em $setWindowFields para retornar a soma dos valores quantity de bolos vendidos para pedidos dentro de mais ou menos 10 dólares do valor price do documento atual. No resultado do exemplo , o campo quantityFromSimilarOrders mostra a soma dos valores quantity para documentos na janela.

db.cakeSales.aggregate( [
   {
      $setWindowFields: {
         partitionBy: "$state",
         sortBy: { price: 1 },
         output: {
            quantityFromSimilarOrders: {
               $sum: "$quantity",
               window: {
                  range: [ -10, 10 ]
               }
            }
         }
      }
   }
] )

[
  {
    _id: 2,
    type: 'vanilla',
    orderDate: ISODate('2021-01-11T06:31:15.000Z'),
    state: 'CA',
    price: 12,
    quantity: 145,
    quantityFromSimilarOrders: 265
  },
  {
    _id: 0,
    type: 'chocolate',
    orderDate: ISODate('2020-05-18T14:10:30.000Z'),
    state: 'CA',
    price: 13,
    quantity: 120,
    quantityFromSimilarOrders: 265
  },
  {
    _id: 4,
    type: 'strawberry',
    orderDate: ISODate('2019-05-18T16:09:01.000Z'),
    state: 'CA',
    price: 41,
    quantity: 162,
    quantityFromSimilarOrders: 162
  },
  {
    _id: 3,
    type: 'vanilla',
    orderDate: ISODate('2020-02-08T13:13:23.000Z'),
    state: 'WA',
    price: 13,
    quantity: 104,
    quantityFromSimilarOrders: 244
  },
  {
    _id: 1,
    type: 'chocolate',
    orderDate: ISODate('2021-03-20T11:30:05.000Z'),
    state: 'WA',
    price: 14,
    quantity: 140,
    quantityFromSimilarOrders: 244
  },
  {
    _id: 5,
    type: 'strawberry',
    orderDate: ISODate('2019-01-08T06:12:03.000Z'),
    state: 'WA',
    price: 43,
    quantity: 134,
    quantityFromSimilarOrders: 134
  }
]

No exemplo:

partitionBy: "$state" divide os documentos da coleção por state. Existem divisões para CA e WA.
sortBy: { price: 1 } ordena os documentos em cada partição por price em ordem crescente (1), de modo que o price mais baixo seja o primeiro.
output define o campo quantityFromSimilarOrders como a soma dos valores quantity dos documentos em uma janela de faixa.
- A janela contém documentos entre um limite inferior de -10 e um limite superior de 10. A faixa é inclusiva.
- $sum retorna a soma de valores quantity contidos em uma faixa de mais ou menos 10 dólares do valor price do documento atual.

Exemplos de janelas de faixa de tempo

Usar uma janela de faixa de tempo com um limite superior positivo

O exemplo seguinte utiliza uma janela com uma unidade de faixa de tempo de limite superior positivo em $setWindowFields. O pipeline gera uma array de valores orderDate para cada state que correspondem à faixa de tempo especificada. Na saída de exemplo , o campo recentOrders mostra a array de valores orderDate para CA e WA.

db.cakeSales.aggregate( [
   {
      $setWindowFields: {
         partitionBy: "$state",
         sortBy: { orderDate: 1 },
         output: {
            recentOrders: {
               $push: "$orderDate",
               window: {
                  range: [ "unbounded", 10 ],
                  unit: "month"
               }
            }
         }
      }
   }
] )

[
  {
    _id: 4,
    type: 'strawberry',
    orderDate: ISODate('2019-05-18T16:09:01.000Z'),
    state: 'CA',
    price: 41,
    quantity: 162,
    recentOrders: [
      ISODate('2019-05-18T16:09:01.000Z')
    ]
  },
  {
    _id: 0,
    type: 'chocolate',
    orderDate: ISODate('2020-05-18T14:10:30.000Z'),
    state: 'CA',
    price: 13,
    quantity: 120,
    recentOrders: [
      ISODate('2019-05-18T16:09:01.000Z'),
      ISODate('2020-05-18T14:10:30.000Z'),
      ISODate('2021-01-11T06:31:15.000Z')
    ]
  },
  {
    _id: 2,
    type: 'vanilla',
    orderDate: ISODate('2021-01-11T06:31:15.000Z'),
    state: 'CA',
    price: 12,
    quantity: 145,
    recentOrders: [
      ISODate('2019-05-18T16:09:01.000Z'),
      ISODate('2020-05-18T14:10:30.000Z'),
      ISODate('2021-01-11T06:31:15.000Z')
    ]
  },
  {
    _id: 5,
    type: 'strawberry',
    orderDate: ISODate('2019-01-08T06:12:03.000Z'),
    state: 'WA',
    price: 43,
    quantity: 134,
    recentOrders: [
      ISODate('2019-01-08T06:12:03.000Z')
    ]
  },
  {
    _id: 3,
    type: 'vanilla',
    orderDate: ISODate('2020-02-08T13:13:23.000Z'),
    state: 'WA',
    price: 13,
    quantity: 104,
    recentOrders: [
      ISODate('2019-01-08T06:12:03.000Z'),
      ISODate('2020-02-08T13:13:23.000Z')
    ]
  },
  {
    _id: 1,
    type: 'chocolate',
    orderDate: ISODate('2021-03-20T11:30:05.000Z'),
    state: 'WA',
    price: 14,
    quantity: 140,
    recentOrders: [
      ISODate('2019-01-08T06:12:03.000Z'),
      ISODate('2020-02-08T13:13:23.000Z'),
      ISODate('2021-03-20T11:30:05.000Z')
    ]
  }
]

No exemplo:

partitionBy: "$state" divide os documentos da coleção por state. Existem divisões para CA e WA.
sortBy: { orderDate: 1 } ordena os documentos em cada partição por orderDate em ordem crescente (1), de modo que o orderDate mais antigo seja o primeiro.
output:
- Define o campo recentOrders para uma array de valores orderDate para os documentos em cada state. Os elementos de array são expandidos com adições aos elementos anteriores na array.
- Usa $push para retornar uma array de valores orderDate dos documentos em uma janela de faixa.

A janela contém documentos entre um limite inferior unbounded e um limite superior definido como 10 (10 meses após o valor orderDate do documento atual) usando uma unidade de intervalo de tempo.
$push retorna a array de valores orderDate para os documentos entre o início da partição e os documentos com valores orderDate inclusive em uma faixa do valor orderDate do documento atual mais 10 meses.

Usar uma janela de faixa de tempo com limite superior negativo

O exemplo seguinte utiliza uma janela com uma unidade de faixa de tempo de limite superior negativo em $setWindowFields. O pipeline gera uma array de valores orderDate para cada state que correspondem à faixa de tempo especificada. Na saída de exemplo , o campo recentOrders mostra a array de valores orderDate para CA e WA.

db.cakeSales.aggregate( [
   {
      $setWindowFields: {
         partitionBy: "$state",
         sortBy: { orderDate: 1 },
         output: {
            recentOrders: {
               $push: "$orderDate",
               window: {
                  range: [ "unbounded", -10 ],
                  unit: "month"
               }
            }
         }
      }
   }
] )

[
  {
    _id: 4,
    type: 'strawberry',
    orderDate: ISODate('2019-05-18T16:09:01.000Z'),
    state: 'CA',
    price: 41,
    quantity: 162,
    recentOrders: []
  },
  {
    _id: 0,
    type: 'chocolate',
    orderDate: ISODate('2020-05-18T14:10:30.000Z'),
    state: 'CA',
    price: 13,
    quantity: 120,
    recentOrders: [
      ISODate('2019-05-18T16:09:01.000Z')
    ]
  },
  {
    _id: 2,
    type: 'vanilla',
    orderDate: ISODate('2021-01-11T06:31:15.000Z'),
    state: 'CA',
    price: 12,
    quantity: 145,
    recentOrders: [
      ISODate('2019-05-18T16:09:01.000Z')
    ]
  },
  {
    _id: 5,
    type: 'strawberry',
    orderDate: ISODate('2019-01-08T06:12:03.000Z'),
    state: 'WA',
    price: 43,
    quantity: 134,
    recentOrders: []
  },
  {
    _id: 3,
    type: 'vanilla',
    orderDate: ISODate('2020-02-08T13:13:23.000Z'),
    state: 'WA',
    price: 13,
    quantity: 104,
    recentOrders: [
      ISODate('2019-01-08T06:12:03.000Z')
    ]
  },
  {
    _id: 1,
    type: 'chocolate',
    orderDate: ISODate('2021-03-20T11:30:05.000Z'),
    state: 'WA',
    price: 14,
    quantity: 140,
    recentOrders: [
      ISODate('2019-01-08T06:12:03.000Z'),
      ISODate('2020-02-08T13:13:23.000Z')
    ]
  }
]

No exemplo:

partitionBy: "$state" divide os documentos da coleção por state. Existem divisões para CA e WA.
sortBy: { orderDate: 1 } ordena os documentos em cada partição por orderDate em ordem crescente (1), de modo que o orderDate mais antigo seja o primeiro.
output:
- Define o campo recentOrders para uma array de valores orderDate para os documentos em cada state. Os elementos de array são expandidos com adições aos elementos anteriores na array.
- Usa $push para retornar uma array de valores orderDate dos documentos em uma janela de faixa.

A janela contém documentos entre um limite inferior unbounded e um limite superior definido como -10 (10 meses antes do valor orderDate do documento atual) usando uma unidadede intervalo de tempo.
$push retorna a array de orderDate valores para os documentos entre o início da partição e os documentos com valores orderDate inclusive em uma faixa do valor orderDate do documento atual menos 10 meses.

Exemplo de comparação com valores anteriores

O exemplo a seguir usa $setWindowFields com o operador $shift e o estágio $set para comparar campos em uma collection. Na saída do exemplo , o campo priceComparison mostra o resultado da comparação.

db.cakeSales.aggregate( [
  {
    $setWindowFields: {
      partitionBy: "$type",
      sortBy: { orderDate: 1 },
      output: {
        previousPrice: {
          $shift: {
            output: "$price",
            by: -1
          }
        }
      }
    }
  },
  {
    $set: {
      priceComparison: {
        $cond: [
          { $eq: ["$price", "$previousPrice"] },
          "same",
          {
            $cond: [
              { $gt: ["$price", "$previousPrice"] },
              "higher",
              "lower"
            ]
          }
        ]
      }
    }
  },
] )

[
  {
    _id: 0,
    type: 'chocolate',
    orderDate: ISODate('2020-05-18T14:10:30.000Z'),
    state: 'CA',
    price: 13,
    quantity: 120,
    previousPrice: null,
    priceComparison: 'higher'
  },
  {
    _id: 1,
    type: 'chocolate',
    orderDate: ISODate('2021-03-20T11:30:05.000Z'),
    state: 'WA',
    price: 14,
    quantity: 140,
    previousPrice: 13,
    priceComparison: 'higher'
  },
  {
    _id: 5,
    type: 'strawberry',
    orderDate: ISODate('2019-01-08T06:12:03.000Z'),
    state: 'WA',
    price: 43,
    quantity: 134,
    previousPrice: null,
    priceComparison: 'higher'
  },
  {
    _id: 4,
    type: 'strawberry',
    orderDate: ISODate('2019-05-18T16:09:01.000Z'),
    state: 'CA',
    price: 41,
    quantity: 162,
    previousPrice: 43,
    priceComparison: 'lower'
  },
  {
    _id: 3,
    type: 'vanilla',
    orderDate: ISODate('2020-02-08T13:13:23.000Z'),
    state: 'WA',
    price: 13,
    quantity: 104,
    previousPrice: null,
    priceComparison: 'higher'
  },
  {
    _id: 2,
    type: 'vanilla',
    orderDate: ISODate('2021-01-11T06:31:15.000Z'),
    state: 'CA',
    price: 12,
    quantity: 145,
    previousPrice: 13,
    priceComparison: 'lower'
  }
]

No exemplo:

partitionBy: "$type" particiona os documentos na collection por type para que os cálculos de cada tipo sejam mantidos separados.
sortBy: { orderDate: 1 } classifica os documentos em cada partição por orderDate em ordem crescente1().
output.previousPrice usa o operador $shift para capturar o price da ordem imediatamente anterior dentro do mesmo ano.
$set adiciona um novo campo chamado priceComparison e define o valor desse campo como higher, lower ou same com base na comparação com previousPrice.

A seguinte classe WeatherMeasurement representa documentos em uma coleção de medições meteorológicas:

[BsonIgnoreExtraElements]
public class WeatherMeasurement
{
    [BsonId]
    public ObjectId Id { get; set; }
    [BsonElement("localityId")]
    public string LocalityId { get; set; } = null!;
    [BsonElement("measurementDateTime")]
    public DateTime MeasurementDateTime { get; set; }
    [BsonElement("rainfall")]
    public float Rainfall { get; set; }
    [BsonElement("temperature")]
    public float Temperature { get; set; }
}

Para usar o driver MongoDB .NET/C# para adicionar um estágio $setWindowFields a uma agregação pipeline, chame o método UnionWith() em um objeto PipelineDefinition.

O exemplo a seguir cria um estágio de pipeline que usa os campos Rainfall e Temperature para calcular a precipitação acumulada, a temperatura média móvel, a temperatura mediana e o 90º percentil de precipitação no mês passado para cada localidade:

var pipeline = new EmptyPipelineDefinition<WeatherMeasurement>()
    .SetWindowFields(
        partitionBy: w => w.LocalityId,
        sortBy: Builders<WeatherMeasurement>.Sort.Ascending(
            w => w.MeasurementDateTime),
        output: o => new
        {
            MonthlyRainfall = o.Sum(
                w => w.Rainfall, RangeWindow.Create(
                    RangeWindow.Months(-1),
                    RangeWindow.Current)
            ),
            TemperatureAvg = o.Average(
                w => w.Temperature, RangeWindow.Create(
                    RangeWindow.Months(-1),
                    RangeWindow.Current)
            ),
            MedianTemperature = o.Median(
                w => w.Temperature,
                RangeWindow.Create(
                    RangeWindow.Months(-1),
                    RangeWindow.Current)
            ),
            NinetiethPercentileRainfall = o.Percentile(
                w => w.Rainfall,
                new[] { 0.9 },
                RangeWindow.Create(
                    RangeWindow.Months(-1),
                    RangeWindow.Current)
            )
        }
    );

{ "_id" : "...", "localityId" : "L1", "measurementDateTime" : "...", "rainfall" : 5.0, "temperature" : 20.0, "MonthlyRainfall" : 5.0, "TemperatureAvg" : 20.0, "MedianTemperature" : 20.0, "NinetiethPercentileRainfall" : [5.0] }
{ "_id" : "...", "localityId" : "L1", "measurementDateTime" : "...", "rainfall" : 10.0, "temperature" : 25.0, "MonthlyRainfall" : 10.0, "TemperatureAvg" : 25.0, "MedianTemperature" : 25.0, "NinetiethPercentileRainfall" : [10.0] }
{ "_id" : "...", "localityId" : "L1", "measurementDateTime" : "...", "rainfall" : 8.0, "temperature" : 22.0, "MonthlyRainfall" : 8.0, "TemperatureAvg" : 22.0, "MedianTemperature" : 22.0, "NinetiethPercentileRainfall" : [8.0] }
{ "_id" : "...", "localityId" : "L2", "measurementDateTime" : "...", "rainfall" : 6.0, "temperature" : 18.0, "MonthlyRainfall" : 6.0, "TemperatureAvg" : 18.0, "MedianTemperature" : 18.0, "NinetiethPercentileRainfall" : [6.0] }
{ "_id" : "...", "localityId" : "L2", "measurementDateTime" : "...", "rainfall" : 6.0, "temperature" : 18.0, "MonthlyRainfall" : 12.0, "TemperatureAvg" : 18.0, "MedianTemperature" : 18.0, "NinetiethPercentileRainfall" : [6.0] }

Os exemplos de Node.js nesta página usam a coleção sample_weatherdata.data dos conjuntos de dados de amostra do Atlas. Para aprender como criar um cluster gratuito do MongoDB Atlas e carregar os conjuntos de dados de amostra, consulte Introdução na documentação do driver MongoDB Node.js.

Para usar o driver Node.js do MongoDB para adicionar um estágio $setWindowFields a um pipeline de agregação , use o operador $setWindowFields em um objeto de pipeline.

O exemplo a seguir cria um estágio de pipeline que calcula a média de airTemperature.value e o total de waveMeasurement.waves.height para cada valor único de callLetters no último mês. O exemplo em seguida executa o pipeline de agregação:

const pipeline = [
  {
    $setWindowFields: {
      partitionBy: "$callLetters",
      sortBy: { ts: 1 },
      output: {
        temperatureAvg: {
          $avg: "$airTemperature.value",
          window: {
            range: [-1, "current"],
            unit: "month"
          }
        },
        totalWaveHeight: {
          $sum: "$waveMeasurement.waves.height",
          window: {
            range: [-1, "current"],
            unit: "month"
          }
        }
      }
    }
  },
];
const cursor = collection.aggregate(pipeline);
return cursor;

Dica

Para obter um exemplo adicional sobre o consumo de energia IOT, consulte o e-book Aggregations práticas do MongoDB.

Voltar

$set

$shardedDataDistribution