MongoDB $setEquals

I MongoDB er $setEquals aggregeringspipeline-operatør sammenligner to eller flere arrays og returnerer true hvis de har de samme særskilte elementer og false ellers.

$setEquals accepterer to eller flere argumenter, som alle kan være et hvilket som helst gyldigt udtryk, så længe de hver især løses til en matrix. $setEquals behandler arrays som sæt.

Eksempel

Antag, at vi har en samling kaldet data med følgende dokumenter:

{ "_id" :1, "a" :[ 1, 2, 3 ], "b" :[ 1, 2, 3 ] }{ "_id" :2, "a" :[ 1, 2, 3 ], "b" :[ 1, 2 ] }{ "_id" :3, "a" :[ 1, 2 ], "b" :[ 1, 2, 3 ] }{ "_id" :4, " a" :[ 1, 2, 3 ], "b" :[ 3, 4, 5 ] }{ "_id" :5, "a" :[ 1, 2, 3 ], "b" :[ 4, 5 , 6 ] }

Vi kan anvende $setEquals operator mod a og b felter i disse dokumenter.

Eksempel:

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

Resultat:

{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2, 3 ], "result" :sand }{ "a" :[ 1, 2, 3 ], "b" :[ 1, 2 ], "result" :false }{ "a" :[ 1, 2 ], "b" :[ 1, 2, 3 ], "result" :falsk }{ "a" :[ 1, 2, 3 ], "b" :[ 3, 4, 5 ], "resultat" :falsk }{ "a" :[ 1, 2, 3 ], "b" :[ 4, 5, 6 ], "resultat " :falsk }

Indlejrede arrays

$setEquals operatoren går ikke ned i nogen indlejrede arrays. Den evaluerer kun arrays på øverste niveau.

Antag, at vores samling også indeholder følgende dokumenter:

{ "_id" :6, "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ] }{ "_id" :7, "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2 ], 3 ] }

Og vi anvender $setEquals til disse to dokumenter:

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

Resultat:

{ "a" :[ 1, 2, 3 ], "b" :[ [ 1, 2, 3 ] ], "result" :false }{ "a" :[ 1, 2, 3 ], " b" :[ [ 1, 2 ], 3 ], "result" :falsk }

I det første dokument er b felt indeholdt et array, der kun indeholdt ét element – et andet array. I dette tilfælde blev det ydre array evalueret, og det viste sig ikke at indeholde de samme værdier, som var i arrayet ved a .

Men hvis a felt havde indeholdt et indlejret array i sig selv, kunne det have været en anden historie.

Antag, at vi har følgende dokumenter:

{ "_id" :8, "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ] }{ "_id" :9, "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ] }

Og vi anvender $setEquals til disse dokumenter:

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

Resultat:

{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2, 3 ] ], "result" :sand }{ "a" :[ [ 1, 2, 3 ] ], "b" :[ [ 1, 2 ], 3 ], "resultat" :falsk }

I det første dokument, a matcher b præcis, og så resultatet er true .

I det andet dokument, det indlejrede array ved a er forskellig fra det indlejrede array ved b , og så får vi false .

Manglende felter

Anvender $setEquals til et ikke-eksisterende felt resulterer i en fejl.

Overvej følgende dokumenter:

{ "_id" :10, "a" :[ 1, 2, 3 ] }{ "_id" :11, "b" :[ 1, 2, 3 ] }{ "_id" :12 } 
 Det første dokument har ikke en b felt, har det andet dokument ikke en a felt, og det tredje dokument har heller ikke.
 
 Her er, hvad der sker, når vi anvender $setEquals til a og b felter:
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 10, 11, 12 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setEquals: [ "$a", "$b" ] }
          }
     }
   ]
) 
 
 Resultat:
 Fejl:kommando mislykkedes:{ "ok" :0, "errmsg" :"Alle operander af $setEquals skal være arrays. Et argument er af typen:mangler", "code" :17044, "codeName" :"Location17044 "} :aggregat mislykkedes :[email protected]/mongo/shell/utils.js:25:[email protected]/mongo/shell/assert.js:18:[email protected]/mongo/shell/assert. js:639:[email protected]/mongo/shell/assert.js:729:[email protected]/mongo/shell/db.js:266:[email protected]/mongo/shell/collection.js:1058:12@(shell):1:1
 
 Som meddelelsen siger, skal alle operander være arrays. Et manglende argument/felt er ikke et array.
 Forkert datatype
 
 Som det ses i det foregående eksempel, er alle operander af $setEquals skal være arrays. Hvis feltet de refererer til mangler, bliver der kastet en fejl. Den samme fejl opstår, når operanden ikke mangler, men blot er den forkerte type.
 
 Antag, at vores samling indeholder følgende dokumenter:
 { "_id" :13, "a" :[ 1, 2, 3 ], "b" :3 }{ "_id" :14, "a" :3, "b" :[ 1, 2, 3 ] }{ "_id" :15, "a" :2, "b" :3 }
 
 Og vi anvender $setEquals til disse dokumenter:
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 13, 14, 15 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setEquals: [ "$a", "$b" ] }
          }
     }
   ]
) 
 
 Resultat:
 Fejl:kommando mislykkedes:{ "ok" :0, "errmsg" :"Alle operander af $setEquals skal være arrays. Et argument er af typen:double", "code" :17044, "codeName" :"Location17044 "} :aggregat mislykkedes :[email protected]/mongo/shell/utils.js:25:[email protected]/mongo/shell/assert.js:18:[email protected]/mongo/shell/assert. js:639:[email protected]/mongo/shell/assert.js:729:[email protected]/mongo/shell/db.js:266:[email protected]/mongo/shell/collection.js:1058:12@(shell):1:1
 Dublerede værdier
 
 $setEquals operatør ignorerer duplikerede indtastninger. Den ignorerer også rækkefølgen af elementerne.
 
 Antag, at vi har følgende dokumenter:
 { "_id" :16, "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ] }{ "_id" :17, "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2 ] }{ "_id" :18, "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ ] }{ "_id" :19, "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ] }{ "_id" :20 , "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ] }{ "_id" :21, "a" :[ 2, 3, 1, 2, 3 , 1 ], "b" :[ ] }
 
 Derefter anvender vi $setEquals operatør til dem:
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setEquals: [ "$a", "$b" ] }
          }
     }
   ]
) 
 
 Resultat:
 { "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ], "result" :sand }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2 ], "resultat" :falsk }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ ] , "result" :false }{ "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ], "result" :sand }{ "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ], "resultat" :falsk }{ "a" :[ 2, 3, 1, 2, 3, 1 ], "b " :[ ], "resultat" :falsk }
 Mere end to argumenter
 
 Som nævnt, $setEquals accepterer to eller flere argumenter. I alle tilfælde skal argumenterne have de samme distinkte værdier for at returnere true . Ellers vil resultatet være false .
 
 Antag, at vi har følgende dokumenter:
 { "_id" :22, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ] }{ "_id" :23, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ] }
 
 Disse dokumenter har et ekstra felt – en c felt.
 
 Lad os nu anvende $setEquals til disse tre felter:
 db.data.aggregate(
   [
     { $match: { _id: { $in: [ 22, 23 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            c: 1,
            result: { $setEquals: [ "$a", "$b", "$c" ] }
          }
     }
   ]
) 
 
 Resultat:
 { "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ], "result" :sand }{ "a" :[ 1, 2 ] , "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ], "resultat" :falsk }