MongoDB $log

W MongoDB $log Operator potoku agregacji oblicza logarytm liczby w określonej podstawie i zwraca wynik jako podwójny.

Składnia

Składnia wygląda tak:

{ $log: [ <number>, <base> ] }

Gdzie:

może być dowolnym prawidłowym wyrażeniem, które prowadzi do liczby nieujemnej.


  może być dowolnym prawidłowym wyrażeniem, które daje liczbę dodatnią większą niż 1 .


 Przykład
 
 Załóżmy, że mamy kolekcję o nazwie test z następującym dokumentem:
 { "_id" : 1, "data" : 0.5 }
{ "_id" : 2, "data" : 20 }
{ "_id" : 3, "data" : 200 }
 
 Możemy użyć $log operator do zwrócenia bazy logu 10 danych pole:
 db.test.aggregate(
  [
    { $match: { _id: { $in: [ 1, 2, 3 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", 10 ] }
        }
    }
  ]
)
 
 Wynik:
 { "data" : 0.5, "result" : -0.30102999566398114 }
{ "data" : 20, "result" : 1.301029995663981 }
{ "data" : 200, "result" : 2.301029995663981 }
 
 Innym sposobem na zrobienie tego byłoby użycie $log10 operatora.
 
 Jednak $log10 zwraca tylko podstawę logarytmu 10 liczby. Z $logem , z drugiej strony możemy określić bazę do użycia.
 
 Oto przykład określenia podstawy 16:
 db.test.aggregate(
  [
    { $match: { _id: { $in: [ 1, 2, 3 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", 16 ] }
        }
    }
  ]
)
 
 Wynik:
 { "data" : 0.5, "result" : -0.25 }
{ "data" : 20, "result" : 1.0804820237218407 }
{ "data" : 200, "result" : 1.910964047443681 }
 Logarytm naturalny
 
 Logarytm naturalny liczby to jej logarytm do podstawy stałej matematycznej e , gdzie e to irracjonalna i transcendentalna liczba, która zaczyna się od 2.7182818284590452353602874713527 i trwa w nieskończoność. 
 
 Stała matematyczna e jest również znany jako liczba Eulera.
 
 W JavaScript możemy użyć Math.E do reprezentowania e . Możemy zatem uzyskać logarytm naturalny liczby za pomocą Math.E jako drugi argument przy użyciu $log .
 
 Przykład:
 db.test.aggregate(
  [
    { $match: { _id: { $in: [ 1, 2, 3 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", Math.E ] }
        }
    }
  ]
)
 
 Wynik:
 { "data" : 0.5, "result" : -0.6931471805599453 }
{ "data" : 20, "result" : 2.995732273553991 }
{ "data" : 200, "result" : 5.298317366548036 }
 
 Pamiętaj, że MongoDB ma również $ln operator, który jest specjalnie zaprojektowany do zwracania logarytmu naturalnego liczby, więc może być łatwiej użyć tego operatora. Zobacz MongoDB $ln na przykład.
 Wartości poza zakresem
 
 Jak wspomniano, $log operator akceptuje dowolne prawidłowe wyrażenie, które rozwiązuje do liczby nieujemnej. Wartości spoza tego zakresu spowodują błąd.
 
 Załóżmy, że do naszej kolekcji dodamy następujący dokument:
 { "_id" : 4, "data" : -20 }
 
 Uruchommy $log operatora względem tego dokumentu:
 db.test.aggregate(
  [
    { $match: { _id: { $in: [ 4 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", 16 ] }
        }
    }
  ]
)
 
 Wynik:
 uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$log's argument must be a positive number, but is -20",
	"code" : 28758,
	"codeName" : "Location28758"
} : aggregate failed :
example@sqldat.com/mongo/shell/utils.js:25:13
example@sqldat.com/mongo/shell/assert.js:18:14
example@sqldat.com/mongo/shell/assert.js:639:17
example@sqldat.com/mongo/shell/assert.js:729:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1058:12
@(shell):1:1
 Niewłaściwy typ danych
 
 Podanie nieprawidłowego typu danych również spowoduje błąd.
 
 Załóżmy, że do naszej kolekcji dodamy następujący dokument:
 { "_id" : 5, "data" : "Ten" }
 
 Uruchommy $log operatora względem tego dokumentu:
 db.test.aggregate(
  [
    { $match: { _id: { $in: [ 5 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", 16 ] }
        }
    }
  ]
)
 
 Wynik:
 uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$log's argument must be numeric, not string",
	"code" : 28756,
	"codeName" : "Location28756"
} : aggregate failed :
example@sqldat.com/mongo/shell/utils.js:25:13
example@sqldat.com/mongo/shell/assert.js:18:14
example@sqldat.com/mongo/shell/assert.js:639:17
example@sqldat.com/mongo/shell/assert.js:729:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1058:12
@(shell):1:1
 
 Dostarczyliśmy ciąg, więc komunikat o błędzie mówi nam, że Argument $log musi być liczbowy, a nie łańcuchowy .
 Wartości puste
 
 Wartości null zwracają null podczas korzystania z $log operatora.
 
 Załóżmy, że do naszej kolekcji dodamy następujący dokument:
 { "_id" : 6, "data" : null }
 
 Uruchommy $log operatora względem tego dokumentu:
 db.test.aggregate(
  [
    { $match: { _id: { $in: [ 6 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data", 16 ] }
        }
    }
  ]
)
 
 Wynik:
 { "data" : null, "result" : null }
 
 Widzimy, że wynikiem jest null . 
 Wartości NaN
 
 Jeśli argument ma postać NaN , $log zwraca NaN .
 
 Przykład:
 db.test.aggregate(
  [
    { $match: { _id: { $in: [ 1 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$data" * 1, 16 ] }
        }
    }
  ]
)
 
 Wynik:
 { "data" : 0.5, "result" : NaN }
 Nieistniejące pola
 
 Jeśli $log operator jest stosowany do pola, które nie istnieje, null jest zwracany.
 
 Przykład:
 db.test.aggregate(
  [
    { $match: { _id: { $in: [ 1 ] } } },
    {
      $project:
        { 
          _id: 0,
          data: 1,
          result: { $log: [ "$age", 16 ] }
        }
    }
  ]
)
 
 Wynik:
 { "data" : 0.5, "result" : null }
 
 W tym przypadku próbowaliśmy zastosować $log w polu o nazwie wiek , ale to pole nie istnieje w dokumencie, więc otrzymujemy null .