MongoDB $stdDevSamp

Dans MongoDB, le $stdDevSamp l'opérateur de pipeline d'agrégation calcule l'écart type de l'échantillon des 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.

$stdDevSamp est similaire à $stdDevPop . La différence est que $stdDevSamp calcule l'échantillon écart type, alors que $stdDevPop calcule la population écart type.

Par conséquent, utilisez $stdDevSamp si vos valeurs englobent un échantillon d'une population de données à partir desquelles généraliser sur la population. Si les valeurs représentent l'ensemble de la population de données ou si vous ne souhaitez pas généraliser sur une population plus large, utilisez $stdDevPop à la place.

Syntaxe

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

Syntaxe 1 :

{ $stdDevSamp: <expression> }

Syntaxe 2 :

{ $stdDevSamp: [ <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, $stdDevSamp renvoie l'exemple d'écart type 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 $stdDevSamp en conjonction avec $group pour renvoyer l'exemple d'é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 $stdDevSamp pour renvoyer l'exemple d'écart type du price champ pour chaque groupe :

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

Résultat :

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

Nous pouvons voir que gme a un écart-type d'échantillon beaucoup plus élevé que jnj .

Tableaux

Cet exemple applique $stdDevSamp à 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 $stdDevSamp aux scores champ dans chaque document :

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

Résultat :

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

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

Le document 4 a donné un écart type de null . C'est parce que nous n'avons fourni qu'un seul numéro dans le tableau. Si nous avions utilisé $stdDevPop , cela aurait renvoyé 0 .

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 $stdDevSamp avec plus d'un argument. $stdDevSamp 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 $stdDevSamp pour renvoyer l'exemple d'écart type du a , b , c , et d champs de chaque document :

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

Résultat :

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

Le résultat du premier document est basé sur les valeurs d'entrée de 1 , 2 , 3 , et 4 .

Cependant, les deux derniers documents n'ont abouti qu'à 1 , 2 , et 3 en cours d'évaluation. Le $stdDevSamp l'opérateur a ignoré son d des champs.

Le $stdDevSamp ignore les valeurs non numériques. Donc, dans ce cas, il a ignoré "Hey" dans le document 3 et calculé l'écart-type de l'échantillon à partir des champs (numériques) restants.

Quant au document 2, son d champ contient un tableau. Comme mentionné, le $stdDevSamp 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é, $stdDevSamp ignore les valeurs non numériques.

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

Champs manquants

Lors de l'utilisation de la syntaxe multi-arguments, $stdDevSamp 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: { $stdDevSamp: [ "$a", "$b", "$c", "$d", "$e" ] }
          }
     }
   ]
)

Résultat :

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

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

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

db.data.aggregate(
   [
     {
       $project:
          {
            result: { $stdDevSamp: [ "$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",
            result: { $stdDevSamp: "$oops!" }
          }
     }
   ]
)

Résultat :

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

Étapes disponibles

$stdDevSamp est disponible dans les étapes suivantes :

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