MongoDB $in Operator potoku agregacji

W MongoDB $in Operator potoku agregacji zwraca wartość logiczną wskazującą, czy określona wartość znajduje się w tablicy.

$in Operator potoku agregacji nie powinien być mylony z $in operator zapytań, który wybiera dokumenty, w których wartość pola jest równa dowolnej wartości w określonej tablicy.

Przykład

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

{ "_id" : 1, "prod" : "Bat", "sizes" : [ "S", "M", "XL", "XXL" ] }
{ "_id" : 2, "prod" : "Hat", "sizes" : [ "S", "L", "XL" ] }
{ "_id" : 3, "prod" : "Cap", "sizes" : [ "XS", "S", "M", "L", "XL" ] }

Możemy użyć $in operator, aby dowiedzieć się, czy sizes pole zawiera wartość L .

Przykład:

db.products.aggregate(
   [
     {
       $project:
          {
            hasLarge: { $in: [ "L", "$sizes" ] }
          }
     }
   ]
)

Wynik:

{ "_id" : 1, "hasLarge" : false }
{ "_id" : 2, "hasLarge" : true }
{ "_id" : 3, "hasLarge" : true }

Drugi argument musi zostać rozwiązany w postaci tablicy

Drugi argument $in operator musi rozwiązać do tablicy. Jeśli tak się nie stanie, zwracany jest błąd.

Załóżmy, że dodajemy do kolekcji następujący dokument:

{ "_id" : 4, "prod" : "Shirt", "sizes" : "L" }

Zwróć uwagę, że sizes pole nie jest tablicą – to ciąg znaków.

Zastosujmy $in do tego dokumentu:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 4 ] } } },
     {
       $project:
          {
            hasLarge: { $in: [ "L", "$sizes" ] }
          }
     }
   ]
)

Wynik:

Error: command failed: {
	"ok" : 0,
	"errmsg" : "$in requires an array as a second argument, found: string",
	"code" : 40081,
	"codeName" : "Location40081"
} : 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:618:17
example@sqldat.com/mongo/shell/assert.js:708:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1046:12
@(shell):1:1

W tym przypadku sizes pole zawiera ciąg znaków, dlatego zwracany jest błąd.

W tym przykładzie używam również $in z $match operator w celu filtrowania dokumentów tylko do tych, którymi jestem zainteresowany. Zauważ, że używa on $in składnia operatora zapytania, która przyjmuje jeden argument i nie należy jej mylić ze składnią dwuargumentową.

Wartości puste

To samo stanie się, jeśli drugim argumentem będzie null .

Dodajmy do kolekcji następujący dokument:

{ "_id" : 5, "prod" : "Jeans", "sizes" : null }

Oto, co się stanie, jeśli spróbujemy użyć $in z tym dokumentem:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 5 ] } } },
     {
       $project:
          {
            hasLarge: { $in: [ "L", "$sizes" ] }
          }
     }
   ]
)

Wynik:

Error: command failed: {
	"ok" : 0,
	"errmsg" : "$in requires an array as a second argument, found: null",
	"code" : 40081,
	"codeName" : "Location40081"
} : 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:618:17
example@sqldat.com/mongo/shell/assert.js:708:16
DB.prototype._runAggregaexample@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1046:12
@(shell):1:1

Ten sam błąd.

Brakujące pola

To samo dotyczy brakujących pól.

Załóżmy, że do naszej kolekcji dodamy następujący dokument:

{ "_id" : 6, "prod" : "Shorts" }

A teraz próbujemy zastosować $in do (nieistniejących) sizes pole:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 6 ] } } },
     {
       $project:
          {
            hasLarge: { $in: [ "L", "$sizes" ] }
          }
     }
   ]
)

Wynik:

Error: command failed: {
	"ok" : 0,
	"errmsg" : "$in requires an array as a second argument, found: missing",
	"code" : 40081,
	"codeName" : "Location40081"
} : 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:618:17
example@sqldat.com/mongo/shell/assert.js:708:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1046:12
@(shell):1:1

Wyrażenia regularne

W przeciwieństwie do $in operator zapytania, $in Operator potoku agregacji nie obsługuje używania wyrażeń regularnych.

Dlatego poniższy kod nie powoduje dopasowania:

db.products.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2, 3 ] } } },
     {
       $project:
          {
            hasLarge: { $in: [ /^X/, "$sizes" ] }
          }
     }
   ]
)

Wynik:

{ "_id" : 1, "hasLarge" : false }
{ "_id" : 2, "hasLarge" : false }
{ "_id" : 3, "hasLarge" : false }

Wynik dla wszystkich dokumentów to false , mimo że sizes pole we wszystkich trzech dokumentach zawiera elementy tablicy, które zaczynają się od wielkich liter X .