In MongoDB, de $stdDevSamp aggregatiepijplijnoperator berekent de standaarddeviatie van de invoerwaarden.
De invoerwaarden kunnen afkomstig zijn uit een groep documenten (d.w.z. documenten die op dezelfde sleutel zijn gegroepeerd), of het kunnen meerdere velden zijn binnen een enkel document.
$stdDevSamp lijkt op $stdDevPop . Het verschil is dat $stdDevSamp berekent de steekproef standaarddeviatie, terwijl $stdDevPop berekent de populatie standaarddeviatie.
Gebruik daarom $stdDevSamp als uw waarden een steekproef van een populatie van gegevens omvatten waaruit u kunt generaliseren over de populatie. Als de waarden de volledige populatie van gegevens vertegenwoordigen of als u niet wilt generaliseren over een grotere populatie, gebruik dan $stdDevPop in plaats daarvan.
Syntaxis
De $stdDevSamp operator ondersteunt twee syntaxis.
Syntaxis 1:
{ $stdDevSamp: <expression> }Syntaxis 2:
{ $stdDevSamp: [ <expression1>, <expression2> ... ] }De eerste syntaxis accepteert één argument en de tweede syntaxis accepteert meerdere argumenten.
Bij gebruik in de $group stadium, kunt u alleen de eerste syntaxis gebruiken. In dit geval $stdDevSamp retourneert de standaarddeviatie van het voorbeeld van de opgegeven uitdrukking voor een groep documenten die dezelfde groep op sleutel delen.
Voorbeelden van syntaxis 1 (enkel argument)
Hier zijn een paar voorbeelden die syntaxis 1 gebruiken.
Gegroepeerde documenten
Dit voorbeeld gebruikt $stdDevSamp in combinatie met $group om de standaarddeviatie van het monster te retourneren voor een groep documenten die op sleutel zijn gegroepeerd.
Stel dat we een verzameling hebben met de naam stonks met de volgende documenten:
{ "_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 }
We kunnen deze documenten groeperen op hun ticker veld, en gebruik dan $stdDevSamp om de standaarddeviatie van het voorbeeld van de price te retourneren veld voor elke groep:
db.stonks.aggregate(
[
{
$group:
{
_id: "$ticker",
result: { $stdDevSamp: "$price" }
}
}
]
)Resultaat:
{ "_id" : "gme", "result" : 131.24404748406687 }
{ "_id" : "jnj", "result" : 10.344080432788612 }
We kunnen zien dat gme heeft een veel hogere steekproefstandaarddeviatie dan jnj .
Arrays
Dit voorbeeld is van toepassing op $stdDevSamp naar een enkel document dat een veld met een reeks waarden bevat.
Deze optie is alleen beschikbaar bij gebruik van de syntaxis voor één argument. Arrays worden genegeerd bij gebruik van de syntaxis met meerdere argumenten (meer hierover hieronder).
Stel dat we een verzameling hebben met de naam players met de volgende documenten:
{ "_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 }
We kunnen $stdDevSamp . toepassen naar de scores veld in elk document:
db.players.aggregate(
[
{
$project:
{
result: { $stdDevSamp: "$scores" }
}
}
]
)Resultaat:
{ "_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 } In dit geval retourneerden de eerste drie documenten de standaarddeviatie van de steekproef voor de verschillende getallen die in hun respectieve arrays stonden.
Document 4 resulteerde in een standaarddeviatie van null . Dit komt omdat we slechts één nummer in de array hebben opgegeven. Als we $stdDevPop . hadden gebruikt , dit zou 0 hebben opgeleverd .
Document 5 retourneerde null omdat we een lege array hebben opgegeven.
Document 6 retourneerde null omdat we null . hebben opgegeven als het argument.
Voorbeeld van syntaxis 2 (meerdere argumenten)
De tweede syntaxis omvat het verstrekken van $stdDevSamp met meer dan één argument. $stdDevSamp berekent vervolgens de standaarddeviatie op basis van alle geleverde argumenten.
Stel dat we een verzameling hebben met de naam data met de volgende documenten:
{ "_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" }
We kunnen $stdDevSamp . gebruiken om de standaarddeviatie van de steekproef van de a . te retourneren , b , c , en d velden van elk document:
db.data.aggregate(
[
{
$project:
{
result: { $stdDevSamp: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Resultaat:
{ "_id" : 1, "result" : 1.2909944487358056 }
{ "_id" : 2, "result" : 1 }
{ "_id" : 3, "result" : 1 }
Het resultaat van het eerste document is gebaseerd op de invoerwaarden van 1 , 2 , 3 , en 4 .
De laatste twee documenten resulteerden echter in slechts 1 , 2 , en 3 wordt geëvalueerd. De $stdDevSamp operator negeerde hun d velden.
De $stdDevSamp negeert niet-numerieke waarden. Dus in dit geval negeerde het "Hey" in document 3 en berekende de standaarddeviatie van de steekproef uit de overige (numerieke) velden.
Wat betreft document 2, het is d veld bevat een array. Zoals gezegd, de $stdDevSamp operator negeert arrays bij gebruik van de syntaxis met meerdere argumenten. Meer precies, het behandelt arrays als niet-numerieke waarden wanneer ze in deze context worden gebruikt. En zoals gezegd, $stdDevSamp negeert niet-numerieke waarden.
Als alle waarden niet-numeriek zijn, dan $stdDevSamp retourneert null .
Ontbrekende velden
Bij gebruik van de syntaxis met meerdere argumenten, $stdDevSamp negeert eventuele ontbrekende velden. Dat wil zeggen, als u een veld opgeeft dat niet bestaat, wordt dit genegeerd. Als geen van de velden bestaat, retourneert het null .
Voorbeeld:
db.data.aggregate(
[
{
$project:
{
result: { $stdDevSamp: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)Resultaat:
{ "_id" : 1, "result" : 1.2909944487358056 }
{ "_id" : 2, "result" : 1 }
{ "_id" : 3, "result" : 1 }
In dit geval heb ik een extra veld ($e ) die niet in het document voorkomt. $stdDevSamp berekende de standaarddeviatie van de steekproef op basis van de resterende velden die doen bestaan.
Dit is echter wat er gebeurt als geen van de velden bestaat:
db.data.aggregate(
[
{
$project:
{
result: { $stdDevSamp: [ "$x", "$y", "$z" ] }
}
}
]
)Resultaat:
{ "_id" : 1, "result" : null }
{ "_id" : 2, "result" : null }
{ "_id" : 3, "result" : null }
Het resultaat is null voor alle documenten.
Bij gebruik van de syntaxis met één argument resulteert een ontbrekend veld in null .
Voorbeeld:
db.stonks.aggregate(
[
{
$group:
{
_id: "$ticker",
result: { $stdDevSamp: "$oops!" }
}
}
]
)Resultaat:
{ "_id" : "gme", "result" : null }
{ "_id" : "jnj", "result" : null } Beschikbare stadia
$stdDevSamp is beschikbaar in de volgende fasen:
$group$project$addFields$set$replaceRoot$replaceWith$matchfase met een$expruitdrukking