MongoDB $mergeObjects

V MongoDB, $mergeObjects operátor agregačního kanálu spojuje více dokumentů do jednoho dokumentu.

Syntaxe

$mergeObjects operátor podporuje dvě syntaxe.

Syntaxe 1:

{ $mergeObjects: [ <document1>, <document2>, ... ] }

Syntaxe 2:

{ $mergeObjects: <document> }

První syntaxe přijímá více argumentů a druhá syntaxe přijímá jeden argument.

Příklad syntaxe 1 (více argumentů)

První syntaxe zahrnuje poskytnutí $mergeObjects s více než jedním argumentem/dokumentem. $mergeObjects pak tyto dokumenty spojí do jednoho.

Předpokládejme, že máme kolekci nazvanou users s následujícím dokumentem:

{
	"_id" : 1,
	"name" : {
		"f_name" : "Homer",
		"l_name" : "Simpson"
	},
	"contact" : {
		"email" : "example@sqldat.com",
		"ph" : null
	}
}

Můžeme použít $mergeObjects sloučit name a contact pole:

db.users.aggregate(
  [
    {
      $project:
        { 
          user: { $mergeObjects: [ "$name", "$contact" ] }
        }
    }
  ]
).pretty()

Výsledek:

{
	"_id" : 1,
	"user" : {
		"f_name" : "Homer",
		"l_name" : "Simpson",
		"email" : "example@sqldat.com",
		"ph" : null
	}
}

V tomto případě jsme obě pole sloučili do jednoho pole s názvem user . Kdybychom měli více polí/dokumentů, mohli bychom je také sloučit, kdybychom chtěli.

Duplicitní názvy polí

Pokud dokumenty, které mají být sloučeny, obsahují duplicitní názvy polí, $mergeObjects přepíše pole při slučování dokumentů. Pole ve výsledném dokumentu tedy obsahuje hodnotu z posledního dokumentu sloučeného pro toto pole.

Předpokládejme, že máme následující dokument:

{
	"_id" : 2,
	"name" : {
		"f_name" : "Peter",
		"l_name" : "Griffin"
	},
	"contact" : {
		"email" : "example@sqldat.com",
		"f_name" : "Bart"
	}
}

Vidíme, že oba dokumenty obsahují pole s názvem f_name .

Když tyto dokumenty sloučíme, stane se toto:

db.users.aggregate(
  [
    { $match: { _id: 2 } },
    {
      $project:
        { 
          user: { $mergeObjects: [ "$name", "$contact" ] }
        }
    }
  ]
).pretty()

Výsledek:

{
	"_id" : 2,
	"user" : {
		"f_name" : "Bart",
		"l_name" : "Griffin",
		"email" : "example@sqldat.com"
	}
}

f_name pole ve výsledném dokumentu obsahuje Bart , což je hodnota z posledního dokumentu, který byl sloučen.

Nulové hodnoty

Při slučování dokumentu pomocí null , bude výsledný dokument vrácen bez jakýchkoli změn.

Ale pokud jsou všechny dokumenty ke sloučení null , pak se vrátí prázdný dokument.

Předpokládejme, že máme následující dokumenty:

{
	"_id" : 3,
	"name" : {
		"f_name" : "Hubert",
		"l_name" : "Farnsworth"
	},
	"contact" : null
}
{ "_id" : 4, "name" : null, "contact" : null }

Zde je to, co se stane, když sloučíme name a contact pole v těchto dvou dokumentech:

db.users.aggregate(
  [
    { $match: { _id: { $in: [ 3, 4 ] } } },
    {
      $project:
        { 
          user: { $mergeObjects: [ "$name", "$contact" ] }
        }
    }
  ]
)

Výsledek:

{ "_id" : 3, "user" : { "f_name" : "Hubert", "l_name" : "Farnsworth" } }
{ "_id" : 4, "user" : {  } }

Příklady syntaxe 2 (jediný argument)

Zde jsou dva příklady, které používají syntaxi jediného argumentu.

$group Jevištní akumulátor

V prvním příkladu $mergeObjects se používá jako $group jevištní akumulátor.

Předpokládejme, že máme kolekci nazvanou products s následujícími dokumenty:

{
	"_id" : 1,
	"product" : "Shirt",
	"inventory" : {
		"blue" : 10,
		"red" : 2
	}
}
{
	"_id" : 2,
	"product" : "Shirt",
	"inventory" : {
		"green" : 3,
		"black" : 1
	}
}
{
	"_id" : 3,
	"product" : "Shorts",
	"inventory" : {
		"blue" : 2,
		"red" : 8
	}
}
{
	"_id" : 4,
	"product" : "Shorts",
	"inventory" : {
		"green" : 5,
		"black" : 3
	}
}

Tyto dokumenty můžeme seskupit podle jejich product a poté použijte $mergeObjects sloučit inventory pole pro každou skupinu:

db.products.aggregate( [
   { $group: { 
     _id: "$product", 
     mergedProducts: { $mergeObjects: "$inventory" } 
     } 
    }
]).pretty()

Výsledek:

{
	"_id" : "Shorts",
	"mergedProducts" : {
		"blue" : 2,
		"red" : 8,
		"green" : 5,
		"black" : 3
	}
}
{
	"_id" : "Shirt",
	"mergedProducts" : {
		"blue" : 10,
		"red" : 2,
		"green" : 3,
		"black" : 1
	}
}

Pole

Tento příklad platí $mergeObjects na jeden dokument, který obsahuje pole s polem dokumentů.

Předpokládejme, že máme kolekci nazvanou test s následujícími dokumenty:

{
	"_id" : 1,
	"data" : [
		{
			"a" : 1,
			"b" : 2
		},
		{
			"c" : 3,
			"d" : 4
		}
	]
}

Můžeme použít $mergeObjects na data pole:

db.test.aggregate(
  [
    {
      $project:
        { 
          result: { $mergeObjects: "$data" }
        }
    }
  ]
)

Výsledek:

{ "_id" : 1, "result" : { "a" : 1, "b" : 2, "c" : 3, "d" : 4 } }

Chybějící pole

$mergeObjects ignoruje všechna chybějící pole. To znamená, že pokud zadáte pole, které neexistuje, bude je ignorovat. Pokud žádné z polí neexistuje, vrátí prázdný dokument.

Příklad:

db.users.aggregate(
  [
    {
      $project:
        { 
          user: { $mergeObjects: [ "$name", "$oops" ] }
        }
    }
  ]
).pretty()

Výsledek:

{ "_id" : 1, "user" : { "f_name" : "Homer", "l_name" : "Simpson" } }
{ "_id" : 2, "user" : { "f_name" : "Peter", "l_name" : "Griffin" } }
{ "_id" : 3, "user" : { "f_name" : "Hubert", "l_name" : "Farnsworth" } }
{ "_id" : 4, "user" : { } }

Co se však stane, když žádné z polí existují:

db.users.aggregate(
  [
    {
      $project:
        { 
          user: { $mergeObjects: [ "$wrong", "$oops" ] }
        }
    }
  ]
).pretty()

Výsledek:

{ "_id" : 1, "user" : { } }
{ "_id" : 2, "user" : { } }
{ "_id" : 3, "user" : { } }
{ "_id" : 4, "user" : { } }

Výsledkem je prázdný dokument.

Je to stejné při použití syntaxe jednoho argumentu.

Příklad:

db.products.aggregate( [
   { $group: { 
     _id: "$product", 
     mergedProducts: { $mergeObjects: "$oops!" } 
     } 
    }
]).pretty()

Výsledek:

{ "_id" : "Shorts", "mergedProducts" : { } }
{ "_id" : "Shirt", "mergedProducts" : { } }