MongoDB $stdDevPop

Dans MongoDB, le $stdDevPop L'opérateur de pipeline d'agrégation calcule l'écart type de population de ses valeurs d'entrée.

Les valeurs d'entrée peuvent provenir d'un groupe de documents (c'est-à-dire des documents qui sont regroupés par la même clé), ou elles peuvent être plusieurs champs dans un seul document.

Syntaxe

Le $stdDevPop L'opérateur prend en charge deux syntaxes.

Syntaxe 1 :

{ $stdDevPop: <expression> }

Syntaxe 2 :

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

La première syntaxe accepte un argument et la deuxième syntaxe accepte plusieurs arguments.

Lorsqu'il est utilisé dans le $group étape, vous ne pouvez utiliser que la première syntaxe. Dans ce cas, $stdDevPop renvoie l'écart type de population de l'expression spécifiée pour un groupe de documents partageant le même groupe par clé.

Exemples de syntaxe 1 (argument unique)

Voici quelques exemples qui utilisent la syntaxe 1.

Documents groupés

Cet exemple utilise $stdDevPop en conjonction avec $group pour renvoyer l'écart type sur un groupe de documents regroupés par clé.

Supposons que nous ayons une collection appelée stonks avec les documents suivants :

{ "_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 }

Nous pouvons regrouper ces documents par leur ticker champ, puis utilisez $stdDevPop pour retourner l'écart type de population du price champ pour chaque groupe :

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

Résultat :

{ "_id" : "gme", "standardDeviation" : 123.7380746218039 }
{ "_id" : "jnj", "standardDeviation" : 9.752492558885207 }

Nous pouvons voir que gme a un écart type beaucoup plus élevé que jnj .

Tableaux

Cet exemple applique $stdDevPop à un seul document qui contient un champ avec un tableau de valeurs.

Cette option n'est disponible que lors de l'utilisation de la syntaxe à argument unique. Les tableaux sont ignorés lors de l'utilisation de la syntaxe multi-arguments (plus d'informations ci-dessous).

Supposons que nous ayons une collection appelée players avec les documents suivants :

{ "_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 }

Nous pouvons appliquer $stdDevPop aux scores champ dans chaque document :

db.players.aggregate(
   [
     {
       $project:
          {
            standardDeviation: { $stdDevPop: "$scores" }
          }
     }
   ]
)

Résultat :

{ "_id" : 1, "standardDeviation" : 2.849991049037143 }
{ "_id" : 2, "standardDeviation" : 6.968181653455625 }
{ "_id" : 3, "standardDeviation" : 5.467073155618908 }
{ "_id" : 4, "standardDeviation" : 0 }
{ "_id" : 5, "standardDeviation" : null }
{ "_id" : 6, "standardDeviation" : null }

Dans ce cas, les trois premiers documents ont renvoyé l'écart type pour les différents nombres qui se trouvaient dans leurs tableaux respectifs.

Le document 4 a donné un écart type de 0 . C'est parce que nous n'avons fourni qu'un seul numéro dans le tableau.

Le document 5 a renvoyé null car nous avons fourni un tableau vide.

Le document 6 a renvoyé null car nous avons fourni null comme argument.

Exemple de syntaxe 2 (arguments multiples)

La deuxième syntaxe consiste à fournir $stdDevPop avec plus d'un argument. $stdDevPop calcule ensuite l'écart type en fonction de tous les arguments fournis.

Supposons que nous ayons une collection appelée data avec les documents suivants :

{ "_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" }

Nous pouvons utiliser $stdDevPop pour renvoyer l'écart-type de la population du a , b , c , et d champs de chaque document :

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

Résultat :

{ "_id" : 1, "result" : 1.118033988749895 }
{ "_id" : 2, "result" : 0.816496580927726 }
{ "_id" : 3, "result" : 0.816496580927726 }

Le document 1 renvoie l'écart type en fonction de ses valeurs d'entrée de 1 , 2 , 3 , et 4 .

Cependant, les deux derniers documents n'ont renvoyé que l'écart type pour les valeurs d'entrée de 1 , 2 , et 3 . Le $stdDevPop l'opérateur a ignoré son d des champs.

Pourquoi est-ce ?

La façon dont cela fonctionne est que $stdDevPop ignore les valeurs non numériques. Donc, dans ce cas, il a ignoré "Hey" dans le document 3 et calculé l'écart-type de la population à partir des champs (numériques) restants.

Quant au document 2, son d champ contient un tableau. Comme mentionné, le $stdDevPop L'opérateur ignore les tableaux lors de l'utilisation de la syntaxe multi-arguments. Plus précisément, il traite les tableaux comme des valeurs non numériques lorsqu'ils sont utilisés dans ce contexte. Et comme mentionné, $stdDevPop ignore les valeurs non numériques.

Si toutes les valeurs ne sont pas numériques, alors $stdDevPop renvoie null .

Champs manquants

Lors de l'utilisation de la syntaxe multi-arguments, $stdDevPop ignore les champs manquants. Autrement dit, si vous fournissez un champ qui n'existe pas, il l'ignore. Si aucun des champs n'existe, alors il renvoie null .

Exemple :

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

Résultat :

{ "_id" : 1, "result" : 1.118033988749895 }
{ "_id" : 2, "result" : 0.816496580927726 }
{ "_id" : 3, "result" : 0.816496580927726 }

Dans ce cas, j'ai fourni un champ supplémentaire ($e ) qui n'existe pas dans le document. $stdDevPop calculé l'écart type en fonction des champs restants qui font existent.

Cependant, voici ce qui se passe lorsque aucun des champs existent :

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

Résultat :

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

Le résultat est null pour tous les documents.

Lors de l'utilisation de la syntaxe à argument unique, un champ manquant entraîne null .

Exemple :

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

Résultat :

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

Étapes disponibles

$stdDevPop est disponible dans les étapes suivantes :

$group
$project
$addFields
$set
$replaceRoot
$replaceWith
$match étape qui inclut un $expr expression

Calculer l'écart type de l'échantillon

Voir MongoDB $stdDevSamp si vous avez besoin d'obtenir l'échantillon écart type, par opposition à la population écart-type. Cet opérateur est utile si vos valeurs englobent un échantillon d'une population de données à partir desquelles généraliser la population.