MongoDB $strcasecmp

In MongoDB ist der $strcasecmp Der Aggregations-Pipeline-Operator führt einen Vergleich zweier Zeichenfolgen ohne Berücksichtigung der Groß-/Kleinschreibung durch.

Es gibt entweder 1 zurück , 0 , oder -1 , abhängig davon, ob die erste Zeichenfolge größer, gleich oder kleiner als die zweite Zeichenfolge ist.

Insbesondere $strcasecmp gibt zurück:

• 1 wenn der erste String größer als der zweite String ist
• 0 wenn beide Strings gleich sind
• -1 wenn der erste String kleiner als der zweite String ist

Beispiel

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

{ "_id" : 1, "a" : "abc", "b" : "def" }
{ "_id" : 2, "a" : "abc", "b" : "abc" }
{ "_id" : 3, "a" : "def", "b" : "abc" }
{ "_id" : 4, "a" : "abc", "b" : "cba" }
{ "_id" : 5, "a" : "cba", "b" : "abc" }

Folgendes passiert, wenn wir $strcasecmp anwenden zu diesen Dokumenten:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3, 4, 5 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $strcasecmp: [ "$a", "$b" ] }
          }
     }
   ]
)

Ergebnis:

{ "a" : "abc", "b" : "def", "result" : -1 }
{ "a" : "abc", "b" : "abc", "result" : 0 }
{ "a" : "def", "b" : "abc", "result" : 1 }
{ "a" : "abc", "b" : "cba", "result" : -1 }
{ "a" : "cba", "b" : "abc", "result" : 1 }

Groß-/Kleinschreibung

Wie bereits erwähnt, $strcasecmp führt einen Vergleich ohne Berücksichtigung der Groß-/Kleinschreibung durch.

Angenommen, unsere Sammlung enthält das folgende Dokument:

{ "_id" : 6, "a" : "ABC", "b" : "abc" }

Der a Feld enthält eine Zeichenfolge in Großbuchstaben und das b Feld enthält dieselbe Zeichenfolge, jedoch in Kleinbuchstaben.

Folgendes passiert, wenn wir $strcasecmp anwenden zu beiden Feldern:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 6 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $strcasecmp: [ "$a", "$b" ] }
          }
     }
   ]
)

Ergebnis:

{ "a" : "ABC", "b" : "abc", "result" : 0 }

Das Ergebnis ist 0 , was bedeutet, dass beide Zeichenfolgen gleich sind.

Mit anderen Worten, beim Vergleich wurde die Groß-/Kleinschreibung nicht beachtet.

Nullwerte

Der $strcasecmp behandelt zwei Nullwerte als gleich. Außerdem gilt eine Zeichenfolge als größer als null .

Angenommen, wir haben die folgenden Dokumente in unserer Sammlung:

{ "_id" : 7, "a" : "abc", "b" : null }
{ "_id" : 8, "a" : null, "b" : "abc" }
{ "_id" : 9, "a" : null, "b" : null }

Folgendes passiert, wenn wir $strcasecmp anwenden zu diesen Dokumenten:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 7, 8 ,9 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $strcasecmp: [ "$a", "$b" ] }
          }
     }
   ]
)

Ergebnis:

{ "a" : "abc", "b" : null, "result" : 1 }
{ "a" : null, "b" : "abc", "result" : -1 }
{ "a" : null, "b" : null, "result" : 0 }

Fehlende Felder

Fehlende Felder haben denselben Effekt wie null .

Fügen wir unserer Sammlung die folgenden Dokumente hinzu:

{ "_id" : 10, "a" : "abc" }
{ "_id" : 11, "b" : "abc" }
{ "_id" : 12 }

Folgendes passiert, wenn wir $strcasecmp anwenden an sie:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 10, 11, 12 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $strcasecmp: [ "$a", "$b" ] }
          }
     }
   ]
)

Ergebnis:

{ "a" : "abc", "result" : 1 }
{ "b" : "abc", "result" : -1 }
{ "result" : 0 }

Andere Datentypen

Andere Datentypen können verglichen werden, solange sie in eine Zeichenfolge aufgelöst werden können.

Hier sind eine Reihe von Dokumenten, die verschiedene Datentypen enthalten:

{ "_id" : 13, "a" : 123, "b" : 456 }
{ "_id" : 14, "a" : 123, "b" : 123 }
{ "_id" : 15, "a" : 456, "b" : 123 }
{ "_id" : 16, "a" : NumberDecimal("123"), "b" : NumberDecimal("456") }
{ "_id" : 17, "a" : NumberDecimal("123"), "b" : NumberDecimal("123") }
{ "_id" : 18, "a" : NumberDecimal("456"), "b" : NumberDecimal("123") }
{ "_id" : 19, "a" : ISODate("1999-01-03T23:30:15.100Z"), "b" : "2000-01-03T23:30:15.100Z" }
{ "_id" : 20, "a" : ISODate("2000-01-03T23:30:15.100Z"), "b" : "2000-01-03T23:30:15.100Z" }
{ "_id" : 21, "a" : ISODate("2000-01-03T23:30:15.100Z"), "b" : "1999-01-03T23:30:15.100Z" }

Und das passiert, wenn wir $strcasecmp anwenden zu diesen Dokumenten:

db.data.aggregate(
   [
     { $match: { _id: { $in: [ 13, 14, 15, 16, 17, 18, 19, 20, 21 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $strcasecmp: [ "$a", "$b" ] }
          }
     }
   ]
).pretty()

Ergebnis:

{ "a" : 123, "b" : 456, "result" : -1 }
{ "a" : 123, "b" : 123, "result" : 0 }
{ "a" : 456, "b" : 123, "result" : 1 }
{ "a" : NumberDecimal("123"), "b" : NumberDecimal("456"), "result" : -1 }
{ "a" : NumberDecimal("123"), "b" : NumberDecimal("123"), "result" : 0 }
{ "a" : NumberDecimal("456"), "b" : NumberDecimal("123"), "result" : 1 }
{
	"a" : ISODate("1999-01-03T23:30:15.100Z"),
	"b" : "2000-01-03T23:30:15.100Z",
	"result" : -1
}
{
	"a" : ISODate("2000-01-03T23:30:15.100Z"),
	"b" : "2000-01-03T23:30:15.100Z",
	"result" : 0
}
{
	"a" : ISODate("2000-01-03T23:30:15.100Z"),
	"b" : "1999-01-03T23:30:15.100Z",
	"result" : 1
}