I MongoDB, $stdDevSamp aggregeringspipeline-operatören beräknar provets standardavvikelse för ingångsvärdena.
Inmatningsvärdena kan komma från en grupp av dokument (dvs. dokument som är grupperade efter samma nyckel), eller så kan de vara flera fält inom ett enda dokument.
$stdDevSamp liknar $stdDevPop . Skillnaden är att $stdDevSamp beräknar provet standardavvikelse, medan $stdDevPop beräknar populationen standardavvikelse.
Använd därför $stdDevSamp om dina värden omfattar ett urval av en population av data för att generalisera om populationen. Om värdena representerar hela populationen av data eller om du inte vill generalisera om en större population, använd $stdDevPop istället.
Syntax
$stdDevSamp operatorn stöder två syntaxer.
Syntax 1:
{ $stdDevSamp: <expression> }Syntax 2:
{ $stdDevSamp: [ <expression1>, <expression2> ... ] }Den första syntaxen accepterar ett argument och den andra syntaxen accepterar flera argument.
När den används i $group steg kan du bara använda den första syntaxen. I det här fallet, $stdDevSamp returnerar exempel på standardavvikelsen för det angivna uttrycket för en grupp dokument som delar samma grupp med nyckel.
Exempel på syntax 1 (enkelt argument)
Här är ett par exempel som använder syntax 1.
Grupperade dokument
Det här exemplet använder $stdDevSamp i samband med $group för att returnera provet standardavvikelse över en grupp av dokument som är grupperade efter nyckel.
Anta att vi har en samling som heter stonks med följande dokument:
{ "_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 }
Vi kan gruppera dessa dokument efter deras ticker och använd sedan $stdDevSamp för att returnera provets standardavvikelse för price fält för varje grupp:
db.stonks.aggregate(
[
{
$group:
{
_id: "$ticker",
result: { $stdDevSamp: "$price" }
}
}
]
)Resultat:
{ "_id" : "gme", "result" : 131.24404748406687 }
{ "_id" : "jnj", "result" : 10.344080432788612 }
Vi kan se den gme har en mycket högre provstandardavvikelse än jnj .
Arrayer
Det här exemplet gäller $stdDevSamp till ett enda dokument som innehåller ett fält med en rad värden.
Det här alternativet är endast tillgängligt när du använder syntaxen för enstaka argument. Matriser ignoreras när man använder flerargumentsyntaxen (mer om detta nedan).
Anta att vi har en samling som heter players med följande dokument:
{ "_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 }
Vi kan använda $stdDevSamp till scores fält i varje dokument:
db.players.aggregate(
[
{
$project:
{
result: { $stdDevSamp: "$scores" }
}
}
]
)Resultat:
{ "_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 } I det här fallet returnerade de tre första dokumenten provets standardavvikelse för de olika siffrorna som fanns i deras respektive arrayer.
Dokument 4 resulterade i en standardavvikelse på null . Detta beror på att vi bara angav ett nummer i arrayen. Om vi hade använt $stdDevPop , detta skulle ha returnerat 0 .
Dokument 5 returnerade null eftersom vi tillhandahållit en tom array.
Dokument 6 returnerade null eftersom vi tillhandahållit null som argument.
Exempel på syntax 2 (flera argument)
Den andra syntaxen innebär att tillhandahålla $stdDevSamp med mer än ett argument. $stdDevSamp beräknar sedan standardavvikelsen baserat på alla angivna argument.
Anta att vi har en samling som heter data med följande dokument:
{ "_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" }
Vi kan använda $stdDevSamp för att returnera exempelstandardavvikelsen för a , b , c och d fält för varje dokument:
db.data.aggregate(
[
{
$project:
{
result: { $stdDevSamp: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Resultat:
{ "_id" : 1, "result" : 1.2909944487358056 }
{ "_id" : 2, "result" : 1 }
{ "_id" : 3, "result" : 1 }
Det första dokumentets resultat är baserat på ingångsvärdena för 1 , 2 , 3 och 4 .
Men de två senaste dokumenten resulterade i endast 1 , 2 och 3 utvärderas. $stdDevSamp operatören ignorerade deras d fält.
$stdDevSamp ignorerar icke-numeriska värden. Så i det här fallet ignorerade den "Hey" i dokument 3 och beräknade provets standardavvikelse från de återstående (numeriska) fälten.
När det gäller dokument 2, dess d fältet innehåller en array. Som nämnts, $stdDevSamp operatorn ignorerar matriser när syntaxen för flera argument används. Mer exakt behandlar den arrayer som icke-numeriska värden när de används i detta sammanhang. Och som nämnts, $stdDevSamp ignorerar icke-numeriska värden.
Om alla värden är icke-numeriska, då $stdDevSamp returnerar null .
Fält saknas
När du använder syntaxen för flera argument, $stdDevSamp ignorerar eventuella saknade fält. Det vill säga, om du anger ett fält som inte finns ignorerar det det. Om inget av fälten finns returnerar det null .
Exempel:
db.data.aggregate(
[
{
$project:
{
result: { $stdDevSamp: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)Resultat:
{ "_id" : 1, "result" : 1.2909944487358056 }
{ "_id" : 2, "result" : 1 }
{ "_id" : 3, "result" : 1 }
I det här fallet angav jag ett extra fält ($e ) som inte finns i dokumentet. $stdDevSamp beräknade provets standardavvikelse baserat på de återstående fälten som gör finns.
Men här är vad som händer när ingen av fälten finns:
db.data.aggregate(
[
{
$project:
{
result: { $stdDevSamp: [ "$x", "$y", "$z" ] }
}
}
]
)Resultat:
{ "_id" : 1, "result" : null }
{ "_id" : 2, "result" : null }
{ "_id" : 3, "result" : null }
Resultatet är null för alla dokument.
När du använder syntaxen med ett argument resulterar ett saknat fält i null .
Exempel:
db.stonks.aggregate(
[
{
$group:
{
_id: "$ticker",
result: { $stdDevSamp: "$oops!" }
}
}
]
)Resultat:
{ "_id" : "gme", "result" : null }
{ "_id" : "jnj", "result" : null } Tillgängliga steg
$stdDevSamp är tillgänglig i följande steg:
$group$project$addFields$set$replaceRoot$replaceWith$matchsteg som inkluderar en$expruttryck