In MongoDB, il $stdDevSamp l'operatore della pipeline di aggregazione calcola la deviazione standard del campione dei valori di input.
I valori di input possono provenire da un gruppo di documenti (ovvero documenti raggruppati dalla stessa chiave) oppure possono essere più campi all'interno di un singolo documento.
$stdDevSamp è simile a $stdDevPop . La differenza è che $stdDevSamp calcola il campione deviazione standard, mentre $stdDevPop calcola la popolazione deviazione standard.
Pertanto, usa $stdDevSamp se i tuoi valori comprendono un campione di una popolazione di dati da cui generalizzare sulla popolazione. Se i valori rappresentano l'intera popolazione di dati o non si desidera generalizzare su una popolazione più ampia, utilizzare $stdDevPop invece.
Sintassi
Il $stdDevSamp operatore supporta due sintassi.
Sintassi 1:
{ $stdDevSamp: <expression> }Sintassi 2:
{ $stdDevSamp: [ <expression1>, <expression2> ... ] }La prima sintassi accetta un argomento e la seconda sintassi accetta più argomenti.
Se utilizzato nel $group stage, puoi usare solo la prima sintassi. In questo caso, $stdDevSamp restituisce la deviazione standard campionaria dell'espressione specificata per un gruppo di documenti che condividono lo stesso gruppo per chiave.
Esempi di sintassi 1 (argomento singolo)
Ecco un paio di esempi che utilizzano la sintassi 1.
Documenti raggruppati
Questo esempio usa $stdDevSamp insieme a $group per restituire la deviazione standard campionaria in un gruppo di documenti raggruppati per chiave.
Supponiamo di avere una collezione chiamata stonks con i seguenti documenti:
{ "_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 }
Possiamo raggruppare questi documenti in base al loro ticker campo, quindi utilizzare $stdDevSamp per restituire la deviazione standard del campione del price campo per ogni gruppo:
db.stonks.aggregate(
[
{
$group:
{
_id: "$ticker",
result: { $stdDevSamp: "$price" }
}
}
]
)Risultato:
{ "_id" : "gme", "result" : 131.24404748406687 }
{ "_id" : "jnj", "result" : 10.344080432788612 }
Possiamo vedere che gme ha una deviazione standard campionaria molto più alta di jnj .
Array
Questo esempio applica $stdDevSamp in un singolo documento che contiene un campo con una matrice di valori.
Questa opzione è disponibile solo quando si utilizza la sintassi di argomento singolo. Gli array vengono ignorati quando si utilizza la sintassi multi-argomento (ne parleremo più avanti).
Supponiamo di avere una collezione chiamata players con i seguenti documenti:
{ "_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 }
Possiamo applicare $stdDevSamp ai scores campo in ogni documento:
db.players.aggregate(
[
{
$project:
{
result: { $stdDevSamp: "$scores" }
}
}
]
)Risultato:
{ "_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 questo caso, i primi tre documenti hanno restituito la deviazione standard campionaria per i vari numeri che erano nei rispettivi array.
Il documento 4 ha prodotto una deviazione standard di null . Questo perché abbiamo fornito solo un numero nell'array. Se avessimo usato $stdDevPop , questo avrebbe restituito 0 .
Il documento 5 ha restituito null perché abbiamo fornito un array vuoto.
Il documento 6 ha restituito null perché abbiamo fornito null come argomento.
Esempio di sintassi 2 (argomenti multipli)
La seconda sintassi prevede di fornire $stdDevSamp con più di un argomento. $stdDevSamp quindi calcola la deviazione standard in base a tutti gli argomenti forniti.
Supponiamo di avere una raccolta chiamata data con i seguenti documenti:
{ "_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" }
Possiamo usare $stdDevSamp per restituire la deviazione standard del campione di a , b , c e d campi di ogni documento:
db.data.aggregate(
[
{
$project:
{
result: { $stdDevSamp: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)Risultato:
{ "_id" : 1, "result" : 1.2909944487358056 }
{ "_id" : 2, "result" : 1 }
{ "_id" : 3, "result" : 1 }
Il risultato del primo documento si basa sui valori di input di 1 , 2 , 3 e 4 .
Tuttavia, gli ultimi due documenti hanno prodotto solo 1 , 2 e 3 in fase di valutazione. Il $stdDevSamp l'operatore ha ignorato il suo d campi.
Il $stdDevSamp ignora i valori non numerici. Quindi in questo caso ha ignorato "Hey" nel documento 3 e calcolato la deviazione standard campionaria dai restanti campi (numerici).
Come per il documento 2, il suo d campo contiene una matrice. Come accennato, il $stdDevSamp l'operatore ignora gli array quando si utilizza la sintassi multi-argomento. Più precisamente, tratta gli array come valori non numerici se usati in questo contesto. E come accennato, $stdDevSamp ignora i valori non numerici.
Se tutti i valori non sono numerici, allora $stdDevSamp restituisce null .
Campi mancanti
Quando si utilizza la sintassi multi-argomento, $stdDevSamp ignora tutti i campi mancanti. Cioè, se fornisci un campo che non esiste, lo ignora. Se nessuno dei campi esiste, restituisce null .
Esempio:
db.data.aggregate(
[
{
$project:
{
result: { $stdDevSamp: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)Risultato:
{ "_id" : 1, "result" : 1.2909944487358056 }
{ "_id" : 2, "result" : 1 }
{ "_id" : 3, "result" : 1 }
In questo caso ho fornito un campo aggiuntivo ($e ) che non esiste nel documento. $stdDevSamp ha calcolato la deviazione standard del campione in base ai campi rimanenti che fanno esistono.
Tuttavia, ecco cosa succede quando nessuno dei campi esistono:
db.data.aggregate(
[
{
$project:
{
result: { $stdDevSamp: [ "$x", "$y", "$z" ] }
}
}
]
)Risultato:
{ "_id" : 1, "result" : null }
{ "_id" : 2, "result" : null }
{ "_id" : 3, "result" : null }
Il risultato è null per tutti i documenti.
Quando si utilizza la sintassi a argomento singolo, un campo mancante risulta null .
Esempio:
db.stonks.aggregate(
[
{
$group:
{
_id: "$ticker",
result: { $stdDevSamp: "$oops!" }
}
}
]
)Risultato:
{ "_id" : "gme", "result" : null }
{ "_id" : "jnj", "result" : null } Stadi disponibili
$stdDevSamp è disponibile nelle seguenti fasi:
$group$project$addFields$set$replaceRoot$replaceWith$matchfase che include un$exprespressione
