MongoDB
 sql >> Baza danych >  >> NoSQL >> MongoDB

MongoDB $avg Operator potoku agregacji

W MongoDB $avg Operator potoku agregacji oblicza i zwraca średnią wartość określonych wartości liczbowych.

Składnia

$avg operator obsługuje dwie składnie.

Składnia 1:

{ $avg: <expression> }

Składnia 2:

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

Pierwsza składnia akceptuje jeden argument, a druga – wiele argumentów.

W przypadku użycia w grupie $group etapie, możesz użyć tylko pierwszej składni. W tym przypadku $avg zwraca zbiorczą średnią wszystkich wartości liczbowych, które wynikają z zastosowania określonego wyrażenia do każdego dokumentu w grupie dokumentów, które dzielą tę samą grupę według klucza.

Przykłady składni 1 (pojedynczy argument)

Oto kilka przykładów używających składni 1.

Dokumenty zgrupowane

W tym przykładzie użyto $avg w połączeniu z $group aby zwrócić średnią z grupy dokumentów pogrupowanych według klucza.

Załóżmy, że mamy kolekcję o nazwie pets z następującymi dokumentami:

{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 }
{ "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 }
{ "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 }
{ "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 }
{ "_id" : 5, "name" : "Bruce", "type" : "Kangaroo", "weight" : 100 }
{ "_id" : 6, "name" : "Hop", "type" : "Kangaroo", "weight" : 130 }
{ "_id" : 7, "name" : "Punch", "type" : "Kangaroo", "weight" : 200 }
{ "_id" : 8, "name" : "Snap", "type" : "Cat", "weight" : 12 }
{ "_id" : 9, "name" : "Ruff", "type" : "Dog", "weight" : 30 }

Możemy pogrupować te dokumenty według ich type pole, a następnie użyj $avg aby zwrócić średnią wagę każdej grupy:

db.pets.aggregate(
   [
     {
       $group:
          {
            _id: "$type",
            average_weight: { $avg: "$weight" }
          }
     }
   ]
)

Wynik:

{ "_id" : "Dog", "average_weight" : 20 }
{ "_id" : "Cat", "average_weight" : 9 }
{ "_id" : "Kangaroo", "average_weight" : 143.33333333333334 }

Tablice

Ten przykład dotyczy $avg do pojedynczego dokumentu, który zawiera pole z tablicą wartości.

Ta opcja jest dostępna tylko w przypadku używania składni jednoargumentowej. Tablice są ignorowane podczas używania składni wieloargumentowej (więcej na ten temat poniżej).

Załóżmy, że mamy kolekcję o nazwie players z następującymi dokumentami:

{ "_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 }
{ "_id" : 7, "player" : "Ron" }

Możemy zastosować $avg do scores pole w każdym dokumencie:

db.players.aggregate(
   [
     {
       $project:
          {
            player: 1,
            averageScore: { $avg: "$scores" }
          }
     }
   ]
)

Wynik:

{ "_id" : 1, "player" : "Homer", "averageScore" : 4.142857142857143 }
{ "_id" : 2, "player" : "Marge", "averageScore" : 8.666666666666666 }
{ "_id" : 3, "player" : "Bart", "averageScore" : 6.333333333333333 }
{ "_id" : 4, "player" : "Brian", "averageScore" : 7 }
{ "_id" : 5, "player" : "Farnsworth", "averageScore" : null }
{ "_id" : 6, "player" : "Meg", "averageScore" : null }
{ "_id" : 7, "player" : "Ron", "averageScore" : null }

W tym przypadku pierwsze cztery dokumenty zwróciły średnią różnych liczb, które znajdowały się w ich odpowiednich tablicach.

W przypadku dokumentu 4 było to to samo co liczba, ponieważ w tablicy była tylko jedna liczba.

Dokument 5 zwrócił null ponieważ dostarczyliśmy pustą tablicę.

Dokument 6 zwrócił null ponieważ podaliśmy null jako argument.

Dokument 7 zwrócił null ponieważ pole nawet nie istniało.

Przykład składni 2 (wiele argumentów)

Druga składnia obejmuje podanie $avg z więcej niż jednym argumentem. $avg następnie oblicza średnią na podstawie wszystkich dostarczonych argumentów.

Załóżmy, że mamy kolekcję o nazwie data z następującymi dokumentami:

{ "_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" }
{ "_id" : 4, "a" : "One", "b" : "Two", "c" : "Three", "d" : "Four" }

Możemy użyć $avg aby zwrócić średnią a , b , c i d pola każdego dokumentu:

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

Wynik:

{ "_id" : 1, "avg" : 2.5 }
{ "_id" : 2, "avg" : 2 }
{ "_id" : 3, "avg" : 2 }
{ "_id" : 4, "avg" : null }

Dokument 1 zwraca średnią wartości wejściowych 1 , 2 , 3 i 4 .

Jednak następne dwa dokumenty zwróciły tylko średnią wartości wejściowych 1 , 2 i 3 . $avg operator zignorował ich d pola.

Dzieje się tak, ponieważ $avg ignoruje wartości nieliczbowe. Więc w tym przypadku zignorował "Hey" w dokumencie 3 i obliczył średnią z pozostałych (liczbowych) pól.

Jeśli chodzi o dokument 2, jego d pole zawiera tablicę. Jak wspomniano, $avg operator ignoruje tablice podczas używania składni wieloargumentowej. Dokładniej, w tym kontekście traktuje tablice jako wartości nieliczbowe, a $avg ignoruje wartości nieliczbowe.

Jeśli wszystkie wartości nie są liczbowe, to $avg zwraca null . Możemy to zobaczyć w dokumencie 4.

Brakujące pola

Używając składni wieloargumentowej, $avg ignoruje brakujące pola. Oznacza to, że jeśli podasz pole, które nie istnieje, ignoruje je. Jeśli żadne z pól nie istnieje, zwraca null .

Przykład:

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

Wynik:

{ "_id" : 1, "avg" : 2.5 }
{ "_id" : 2, "avg" : 2 }
{ "_id" : 3, "avg" : 2 }
{ "_id" : 4, "avg" : null }

W tym przypadku dodałem dodatkowe pole ($e ), która nie istnieje w dokumentach. $avg obliczył średnią na podstawie pozostałych pól, które wykonaj istnieje.

Oto jednak, co się dzieje, gdy brak z pól istnieje:

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

Wynik:

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

Wynik to null dla wszystkich dokumentów.

Jak widzieliśmy wcześniej, podczas korzystania ze składni jednoargumentowej brakujące pole daje w wyniku null .

Przykład:

db.pets.aggregate(
   [
     {
       $group:
          {
            _id: "$type",
            avg: { $avg: "$oops!" }
          }
     }
   ]
)

Wynik:

{ "_id" : "Kangaroo", "avg" : null }
{ "_id" : "Cat", "avg" : null }
{ "_id" : "Dog", "avg" : null }

Dostępne etapy

$avg jest dostępny w następujących etapach:

  • $group
  • $project
  • $addFields
  • $set
  • $replaceRoot
  • $replaceWith
  • $match etap zawierający $expr wyrażenie

  1. Redis
  2.   
  3. MongoDB
  4.   
  5. Memcached
  6.   
  7. HBase
  8.   
  9. CouchDB
  1. Zalety MongoDB | Wady MongoDB

  2. SocketException:adres już używany MONGODB

  3. MongoDB — Usuń bazę danych

  4. Usuń duplikat w MongoDB

  5. Schemat mongusty:„unikalny” nie jest szanowany