MongoDB $trunc

In MongoDB ist der $trunc Der Aggregations-Pipeline-Operator kürzt eine Zahl auf eine ganze Zahl oder auf eine bestimmte Dezimalstelle.

Sie haben die Möglichkeit anzugeben, um wie viele Nachkommastellen die Zahl gekürzt werden soll. Übergeben Sie dazu ein zweites Argument. Das erste Argument ist die Zahl, die gekürzt werden soll, und das zweite (optionale) Argument ist die Anzahl der Dezimalstellen, auf die gekürzt werden soll.

Das Weglassen des zweiten Arguments schneidet alle Ziffern rechts vom Dezimalzeichen ab und gibt den ganzen ganzzahligen Wert zurück.

Beispiel

Angenommen, wir haben eine Sammlung namens test mit folgenden Dokumenten:

{ "_id" : 1, "data" : 8.99 }
{ "_id" : 2, "data" : 8.45 }
{ "_id" : 3, "data" : 8.451 }
{ "_id" : 4, "data" : -8.99 }
{ "_id" : 5, "data" : -8.45 }
{ "_id" : 6, "data" : -8.451 }
{ "_id" : 7, "data" : 8 }
{ "_id" : 8, "data" : 0 }

Wir können den $trunc verwenden -Operator, um die Werte in den data zu kürzen Feld:

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data" ] }
          }
     }
   ]
)

Ergebnis:

{ "data" : 8.99, "truncated" : 8 }
{ "data" : 8.45, "truncated" : 8 }
{ "data" : 8.451, "truncated" : 8 }
{ "data" : -8.99, "truncated" : -8 }
{ "data" : -8.45, "truncated" : -8 }
{ "data" : -8.451, "truncated" : -8 }
{ "data" : 8, "truncated" : 8 }
{ "data" : 0, "truncated" : 0 }

Beachten Sie, dass $trunc rundet keine Zahlen wie $round tut. Der $trunc Operator kürzt einfach die Zahl. Wenn wir $round angewendet hätten zu dieser Sammlung wären das erste und vierte Dokument auf 9 gerundet worden und -9 bzw..

Geben Sie eine Dezimalstelle an

Wir haben die Möglichkeit, ein zweites Argument zu verwenden, um anzugeben, auf wie viele Dezimalstellen die Zahl gekürzt werden soll.

Beispiel:

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data", 1 ] }
          }
     }
   ]
)

Ergebnis:

{ "data" : 8.99, "truncated" : 8.9 }
{ "data" : 8.45, "truncated" : 8.4 }
{ "data" : 8.451, "truncated" : 8.4 }
{ "data" : -8.99, "truncated" : -8.9 }
{ "data" : -8.45, "truncated" : -8.4 }
{ "data" : -8.451, "truncated" : -8.4 }
{ "data" : 8, "truncated" : 8 }
{ "data" : 0, "truncated" : 0 }

Auch hier wird die Nummer einfach abgeschnitten. Wenn wir $round verwendet hätten , hätte es einige dieser Zahlen gerundet.

Negative Dezimalstellen

Das zweite Argument kann ein beliebiger gültiger Ausdruck sein, der sich in eine ganze Zahl zwischen -20 und 100 (ausschließlich) auflösen lässt. Daher können Sie eine negative Dezimalstelle angeben.

Dabei wird die Zahl links von der Dezimalstelle abgeschnitten. Wenn der Absolutwert der negativen Ganzzahl größer ist als die Anzahl der Stellen links vom Dezimalpunkt, ist das Ergebnis 0 .

Angenommen, wir fügen unserer Sammlung die folgenden Dokumente hinzu:

{ "_id" : 9, "data" : 8111.32 }
{ "_id" : 10, "data" : 8514.321 }
{ "_id" : 11, "data" : 8999.454 }

Hier ist ein Beispiel für die Verwendung verschiedener negativer Dezimalstellen bei der Anwendung von $trunc zu diesen Dokumenten:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 9, 10, 11 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            a: { $trunc: [ "$data", -1 ] },
            b: { $trunc: [ "$data", -2 ] },
            c: { $trunc: [ "$data", -3 ] },
            d: { $trunc: [ "$data", -4 ] },
            e: { $trunc: [ "$data", -5 ] }
          }
     }
   ]
).pretty()

Ergebnis:

{
	"data" : 8111.32,
	"a" : 8110,
	"b" : 8100,
	"c" : 8000,
	"d" : 0,
	"e" : 0
}
{
	"data" : 8514.321,
	"a" : 8510,
	"b" : 8500,
	"c" : 8000,
	"d" : 0,
	"e" : 0
}
{
	"data" : 8999.454,
	"a" : 8990,
	"b" : 8900,
	"c" : 8000,
	"d" : 0,
	"e" : 0
}

Dezimalstelle von Null

Wenn Sie eine Dezimalstelle von 0 angeben , der $trunc -Operator schneidet alle Ziffern rechts vom Dezimalzeichen ab und gibt den ganzen ganzzahligen Wert zurück.

Beispiel:

db.test.aggregate(
   [
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data", 0 ] }
          }
     }
   ]
)

Ergebnis:

{ "data" : 8.99, "truncated" : 8 }
{ "data" : 8.45, "truncated" : 8 }
{ "data" : 8.451, "truncated" : 8 }
{ "data" : -8.99, "truncated" : -8 }
{ "data" : -8.45, "truncated" : -8 }
{ "data" : -8.451, "truncated" : -8 }
{ "data" : 8, "truncated" : 8 }
{ "data" : 0, "truncated" : 0 }
{ "data" : 8111.32, "truncated" : 8111 }
{ "data" : 8514.321, "truncated" : 8514 }
{ "data" : 8999.454, "truncated" : 8999 }

Nummerntypen

Die zu kürzende Zahl kann ein beliebiger gültiger Ausdruck sein, der sich in eine Ganzzahl, Double, Dezimalzahl oder Länge auflösen lässt. Der Rückgabewert entspricht dem Datentyp des Eingabewerts.

Wenn wir also unserer Sammlung die folgenden Dokumente hinzufügen:

{ "_id" : 12, "data" : NumberDecimal("128.4585") }
{ "_id" : 13, "data" : NumberDecimal("128.12345678912") }

Wir können $trunc anwenden zu den data Feld:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 12, 13 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            a: { $trunc: [ "$data", -1 ] },
            b: { $trunc: [ "$data", 0 ] },
            c: { $trunc: [ "$data", 3 ] },
            d: { $trunc: [ "$data", 4 ] },
            e: { $trunc: [ "$data", 5 ] }
          }
     }
   ]
).pretty()

Ergebnis:

{
	"data" : NumberDecimal("128.4585"),
	"a" : NumberDecimal("1.2E+2"),
	"b" : NumberDecimal("128"),
	"c" : NumberDecimal("128.458"),
	"d" : NumberDecimal("128.4585"),
	"e" : NumberDecimal("128.45850")
}
{
	"data" : NumberDecimal("128.12345678912"),
	"a" : NumberDecimal("1.2E+2"),
	"b" : NumberDecimal("128"),
	"c" : NumberDecimal("128.123"),
	"d" : NumberDecimal("128.1234"),
	"e" : NumberDecimal("128.12345")
}

Abschneiden auf Null-Dezimalstellen

Wenn das zweite Argument null ist , ist das Ergebnis null .

Beispiel:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data", null ] }
          }
     }
   ]
)

Ergebnis:

{ "data" : 8.99, "truncated" : null }
{ "data" : 8.45, "truncated" : null }
{ "data" : 8.451, "truncated" : null }

Abschneiden eines Nullwerts

Wenn der abzuschneidende Wert null ist , ist das Ergebnis null .

Angenommen, wir fügen der Sammlung das folgende Dokument hinzu:

{ "_id" : 14, "data" : null }

Und wir verwenden $trunc um den Nullwert abzuschneiden:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 14 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data", null ] }
          }
     }
   ]
)

Ergebnis:

{ "data" : null, "truncated" : null }

Abschneiden der Unendlichkeit

Wenn die abzuschneidende Zahl Infinity ist , ist das Ergebnis Infinity . Ebenso, wenn es -Infinity ist , ist das Ergebnis -Infinity .

Lassen Sie uns zwei Dokumente mit solchen Werten hinzufügen:

{ "_id" : 15, "data" : Infinity }
{ "_id" : 16, "data" : -Infinity }

Und kürzen wir sie:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 15, 16 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data", 2 ] }
          }
     }
   ]
)

Ergebnis:

{ "data" : Infinity, "truncated" : Infinity }
{ "data" : -Infinity, "truncated" : -Infinity }

Abschneiden von NaN

Abschneiden von NaN ergibt NaN .

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data" * 2 ] }
          }
     }
   ]
)

Ergebnis:

{ "data" : 8.99, "truncated" : NaN }
{ "data" : 8.45, "truncated" : NaN }

Nicht numerische Typen

Wenn Sie versuchen, einen Wert zu kürzen, der den falschen Datentyp hat (d. h. er ist keine ganze Zahl, doppelt, dezimal oder lang), wird ein Fehler zurückgegeben.

Angenommen, wir fügen unserer Sammlung das folgende Dokument hinzu:

{ "_id" : 17, "data" : "Thirty five" }

Und jetzt versuchen wir, die data abzuschneiden Feld:

db.test.aggregate(
   [
     { $match: { _id: { $in: [ 17 ] } } },
     {
       $project:
          {
            _id: 0,
            data: 1,
            truncated: { $trunc: [ "$data" ] }
          }
     }
   ]
)

Ergebnis:

uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$trunc only supports numeric types, not string",
	"code" : 51081,
	"codeName" : "Location51081"
} : aggregate failed :
[email protected]/mongo/shell/utils.js:25:13
[email protected]/mongo/shell/assert.js:18:14
[email protected]/mongo/shell/assert.js:639:17
[email protected]/mongo/shell/assert.js:729:16
[email protected]/mongo/shell/db.js:266:5
[email protected]/mongo/shell/collection.js:1058:12
@(shell):1:1