MongoDB $stdDevSamp

No MongoDB, o $stdDevSamp o operador de pipeline de agregação calcula o desvio padrão de amostra dos valores de entrada.

Os valores de entrada podem ser de um grupo de documentos (ou seja, documentos agrupados pela mesma chave) ou podem ser vários campos em um único documento.

$stdDevSamp é semelhante a $stdDevPop . A diferença é que $stdDevSamp calcula a amostra desvio padrão, enquanto $stdDevPop calcula a população desvio padrão.

Portanto, use $stdDevSamp se seus valores abrangerem uma amostra de uma população de dados a partir da qual generalizar sobre a população. Se os valores representam toda a população de dados ou você não deseja generalizar sobre uma população maior, use $stdDevPop em vez de.

Sintaxe

O $stdDevSamp O operador suporta duas sintaxes.

Sintaxe 1:

{ $stdDevSamp: <expression> }

Sintaxe 2:

{ $stdDevSamp: [ <expression1>, <expression2> ... ]  }

A primeira sintaxe aceita um argumento e a segunda sintaxe aceita vários argumentos.

Quando usado no $group stage, você só pode usar a primeira sintaxe. Neste caso, $stdDevSamp retorna o desvio padrão de amostra da expressão especificada para um grupo de documentos que compartilham o mesmo grupo por chave.

Exemplos de sintaxe 1 (argumento único)

Aqui estão alguns exemplos que usam a sintaxe 1.

Documentos agrupados

Este exemplo usa $stdDevSamp em conjunto com $group para retornar o desvio padrão da amostra em um grupo de documentos agrupados por chave.

Suponha que tenhamos uma coleção chamada stonks com os seguintes documentos:

{ "_id" : 1, "ticker" : "gme", "price" : 10 }
{ "_id" : 2, "ticker" : "gme", "price" : 40 }
{ "_id" : 3, "ticker" : "gme", "price" : 90 }
{ "_id" : 4, "ticker" : "gme", "price" : 180 }
{ "_id" : 5, "ticker" : "gme", "price" : 290 }
{ "_id" : 6, "ticker" : "gme", "price" : 390 }
{ "_id" : 7, "ticker" : "gme", "price" : 190 }
{ "_id" : 8, "ticker" : "gme", "price" : 90 }
{ "_id" : 9, "ticker" : "gme", "price" : 10 }
{ "_id" : 10, "ticker" : "jnj", "price" : 131 }
{ "_id" : 11, "ticker" : "jnj", "price" : 133 }
{ "_id" : 12, "ticker" : "jnj", "price" : 138 }
{ "_id" : 13, "ticker" : "jnj", "price" : 141 }
{ "_id" : 14, "ticker" : "jnj", "price" : 145 }
{ "_id" : 15, "ticker" : "jnj", "price" : 150 }
{ "_id" : 16, "ticker" : "jnj", "price" : 154 }
{ "_id" : 17, "ticker" : "jnj", "price" : 156 }
{ "_id" : 18, "ticker" : "jnj", "price" : 160 }

Podemos agrupar esses documentos por seu ticker campo e, em seguida, use $stdDevSamp para retornar o desvio padrão da amostra do price campo para cada grupo:

db.stonks.aggregate(
   [
     {
       $group:
          {
            _id: "$ticker",
            result: { $stdDevSamp: "$price" }
          }
     }
   ]
)

Resultado:

{ "_id" : "gme", "result" : 131.24404748406687 }
{ "_id" : "jnj", "result" : 10.344080432788612 }

Podemos ver que gme tem um desvio padrão de amostra muito maior do que jnj .

Matrizes

Este exemplo se aplica a $stdDevSamp para um único documento que contém um campo com uma matriz de valores.

Esta opção só está disponível ao usar a sintaxe de argumento único. As matrizes são ignoradas ao usar a sintaxe de vários argumentos (mais sobre isso abaixo).

Suponha que tenhamos uma coleção chamada players com os seguintes documentos:

{ "_id" : 1, "player" : "Homer", "scores" : [ 1, 7, 2, 3, 8, 7, 1 ] }
{ "_id" : 2, "player" : "Marge", "scores" : [ 0, 1, 8, 17, 18, 8 ] }
{ "_id" : 3, "player" : "Bart", "scores" : [ 15, 11, 8, 0, 1, 3 ] }
{ "_id" : 4, "player" : "Brian", "scores" : [ 7 ] }
{ "_id" : 5, "player" : "Farnsworth", "scores" : [ ] }
{ "_id" : 6, "player" : "Meg", "scores" : null }

Podemos aplicar $stdDevSamp para as scores campo em cada documento:

db.players.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevSamp: "$scores" }
          }
     }
   ]
)

Resultado:

{ "_id" : 1, "result" : 3.0783421635988546 }
{ "_id" : 2, "result" : 7.633260552782583 }
{ "_id" : 3, "result" : 5.988878581726855 }
{ "_id" : 4, "result" : null }
{ "_id" : 5, "result" : null }
{ "_id" : 6, "result" : null }

Nesse caso, os três primeiros documentos retornaram o desvio padrão amostral para os diversos números que estavam em suas respectivas matrizes.

O documento 4 resultou em um desvio padrão de null . Isso ocorre porque fornecemos apenas um número na matriz. Se tivéssemos usado $stdDevPop , isso teria retornado 0 .

O documento 5 retornou null porque fornecemos um array vazio.

O documento 6 retornou null porque fornecemos null como o argumento.

Exemplo de sintaxe 2 (vários argumentos)

A segunda sintaxe envolve fornecer $stdDevSamp com mais de um argumento. $stdDevSamp em seguida, calcula o desvio padrão com base em todos os argumentos fornecidos.

Suponha que tenhamos uma coleção chamada data com os seguintes documentos:

{ "_id" : 1, "a" : 1, "b" : 2, "c" : 3, "d" : 4 }
{ "_id" : 2, "a" : 1, "b" : 2, "c" : 3, "d" : [ 4 ] }
{ "_id" : 3, "a" : 1, "b" : 2, "c" : 3, "d" : "Hey" }

Podemos usar $stdDevSamp para retornar o desvio padrão da amostra de a , b , c e d campos de cada documento:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevSamp: [ "$a", "$b", "$c", "$d" ] }
          }
     }
   ]
)

Resultado:

{ "_id" : 1, "result" : 1.2909944487358056 }
{ "_id" : 2, "result" : 1 }
{ "_id" : 3, "result" : 1 }

O resultado do primeiro documento é baseado nos valores de entrada de 1 , 2 , 3 e 4 .

No entanto, os dois últimos documentos resultaram em apenas 1 , 2 e 3 sendo avaliado. O $stdDevSamp operador ignorou seu d Campos.

O $stdDevSamp ignora valores não numéricos. Então, neste caso, ele ignorou "Hey" no documento 3 e calculou o desvio padrão da amostra dos demais campos (numéricos).

Quanto ao documento 2, seu d campo contém uma matriz. Como mencionado, o $stdDevSamp O operador ignora matrizes ao usar a sintaxe de vários argumentos. Mais precisamente, trata arrays como valores não numéricos quando usados neste contexto. E como mencionado, $stdDevSamp ignora valores não numéricos.

Se todos os valores não forem numéricos, então $stdDevSamp retorna null .

Campos ausentes

Ao usar a sintaxe de vários argumentos, $stdDevSamp ignora quaisquer campos ausentes. Ou seja, se você fornecer um campo que não existe, ele o ignora. Se nenhum dos campos existir, ele retornará null .

Exemplo:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevSamp: [ "$a", "$b", "$c", "$d", "$e" ] }
          }
     }
   ]
)

Resultado:

{ "_id" : 1, "result" : 1.2909944487358056 }
{ "_id" : 2, "result" : 1 }
{ "_id" : 3, "result" : 1 }

Neste caso forneci um campo extra ($e ) que não existe no documento. $stdDevSamp calculou o desvio padrão da amostra com base nos campos restantes que fazem existir.

No entanto, veja o que acontece quando nenhum dos campos existem:

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevSamp: [ "$x", "$y", "$z" ] }
          }
     }
   ]
)

Resultado:

{ "_id" : 1, "result" : null }
{ "_id" : 2, "result" : null }
{ "_id" : 3, "result" : null }

O resultado é null para todos os documentos.

Ao usar a sintaxe de argumento único, um campo ausente resulta em null .

Exemplo:

db.stonks.aggregate(
   [
     {
       $group:
          {
            _id: "$ticker",
            result: { $stdDevSamp: "$oops!" }
          }
     }
   ]
)

Resultado:

{ "_id" : "gme", "result" : null }
{ "_id" : "jnj", "result" : null }

Etapas disponíveis

$stdDevSamp está disponível nas seguintes etapas:

$group
$project
$addFields
$set
$replaceRoot
$replaceWith
$match estágio que inclui um $expr expressão