MongoDB $setUnion

I MongoDB, $setUnion aggregeringspipeline-operatör accepterar två eller flera arrayer och returnerar en array som innehåller de element som förekommer i någon av dessa inmatningsarrayer.

$setUnion accepterar två eller flera argument, som alla kan vara vilket giltigt uttryck som helst så länge som var och en löser sig till en array. $setUnion behandlar arrayerna som uppsättningar.

Exempel

Anta att vi har en samling som heter data med följande dokument:

{ "_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 använda $setUnion operatorn mot a och b fält i dessa dokument.

Exempel:

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

Resultat:

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

Inkapslade arrayer

$setUnion operatorn går inte ner i några kapslade arrayer. Den utvärderar bara arrayer på toppnivå.

Anta att vår samling också innehåller följande dokument:

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

Och vi tillämpar $setUnion till dessa två dokument:

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

Resultat:

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

Fält saknas

Använder $setUnion till ett icke-existerande fält resulterar i null .

Tänk på följande dokument:

{ "_id" :10, "a" :[ 1, 2, 3 ] }{ "_id" :11, "b" :[ 1, 2, 3 ] }{ "_id" :12 } 

 Det första dokumentet har ingen b fältet har det andra dokumentet ingen a och det tredje dokumentet har inte heller.
 

 Det här är vad som händer när vi tillämpar $setUnion till a och b fält:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 10, 11, 12 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setUnion: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Resultat:
 
{ "a" :[ 1, 2, 3 ], "result" :null }{ "b" :[ 1, 2, 3 ], "result" :null }{ "result" :null } 
Fel datatyp
 

 Alla operander för $setUnion måste vara arrayer. Om de inte är det skapas ett felmeddelande.
 

 Anta att vår samling innehåller följande dokument:
 
{ "_id" :13, "a" :[ 1, 2, 3 ], "b" :3 }{ "_id" :14, "a" :3, "b" :[ 1, 2, 3 ] }{ "_id" :15, "a" :2, "b" :3 }
 

 Och vi tillämpar $setUnion till dessa dokument:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 13, 14, 15 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setUnion: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Resultat:
 
Fel:kommando misslyckades:{ "ok" :0, "errmsg" :"Alla operander av $setUnion måste vara arrayer. Ett argument är av typen:double", "code" :17043, "codeName" :"Location17043 "} :aggregat misslyckades :example@sqldat.com/mongo/shell/utils.js:25:13example@sqldat.com/mongo/shell/assert.js:18:14example@sqldat.com/mongo/shell/assert. js:639:17example@sqldat.com/mongo/shell/assert.js:729:16example@sqldat.com/mongo/shell/db.js:266:5example@sqldat.com/mongo/shell/collection.js:1058:12@(skal):1:1
 
Duplicera värden
 

 $setUnion operatören filtrerar bort dubbletter i sitt resultat för att mata ut en array som bara innehåller unika poster. Ordningen på elementen i utgångsmatrisen är också ospecificerad.
 

 Anta att vi har följande dokument:
 
{ "_id" :16, "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ] }{ "_id" :17, "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 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" :[ ] }
 

 Sedan tillämpar vi $setUnion operatör till dem:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 16, 17, 18, 19, 20, 21 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            result: { $setUnion: [ "$a", "$b" ] }
          }
     }
   ]
) 
 

 Resultat:
 
{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 2, 3 ], "result" :[ 1, 2, 3 ] }{ "a" :[ 1, 1, 2, 2, 3, 3 ], "b" :[ 1, 1, 2 ], "resultat" :[ 1, 2, 3 ] }{ "a" :[ 1, 1, 2 , 2, 3, 3 ], "b" :[ ], "resultat" :[ 1, 2, 3 ] }{ "a" :[ 3, 2, 1, 2, 3, 1 ], "b" :[ 2, 3, 1 ], "resultat" :[ 1, 2, 3 ] }{ "a" :[ 1, 3, 2, 2, 3, 1 ], "b" :[ 2, 1 ], " resultat" :[ 1, 2, 3 ] }{ "a" :[ 2, 3, 1, 2, 3, 1 ], "b" :[ ], "resultat" :[ 1, 2, 3 ] }
 
Fler än två argument
 

 Som nämnts, $setUnion accepterar två eller flera argument. Alla tidigare exempel använde två argument. Här är en som använder tre argument.
 

 Anta att vi har följande dokument:
 
{ "_id" :22, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ] }{ "_id" :23, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ] }{ "_id" :24, "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 4, 5 ] }
 

 Dessa dokument har ett extra fält – ett c fältet.
 

 Låt oss nu tillämpa $setUnion till dessa tre fält:
 
db.data.aggregate(
   [
     { $match: { _id: { $in: [ 22, 23, 24 ] } } },
     {
       $project:
          {
            _id: 0,
            a: 1,
            b: 1,
            c: 1,
            result: { $setUnion: [ "$a", "$b", "$c" ] }
          }
     }
   ]
) 
 

 Resultat:
 
{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2 ], "result" :[ 1, 2 ] }{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 1, 2, 3 ], "resultat" :[ 1, 2, 3 ] }{ "a" :[ 1, 2 ], "b" :[ 1, 2 ], "c" :[ 4, 5 ], "resultat" :[ 1, 2, 4, 5 ] }