MongoDB $mergeObjects

W MongoDB, $mergeObjects Operator potoku agregacji łączy wiele dokumentów w jeden dokument.

Składnia

$mergeObjects operator obsługuje dwie składnie.

Składnia 1:

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

Składnia 2:

{ $mergeObjects: <document> }

Pierwsza składnia akceptuje wiele argumentów, a druga składnia akceptuje jeden argument.

Przykład składni 1 (wiele argumentów)

Pierwsza składnia obejmuje dostarczenie $mergeObjects z więcej niż jednym argumentem/dokumentem. $mergeObjects następnie łączy te dokumenty w jeden.

Załóżmy, że mamy kolekcję o nazwie users z następującym dokumentem:

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

Możemy użyć $mergeObjects scalić name i contact pola:

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

Wynik:

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

W tym przypadku połączyliśmy oba pola w jedno pole o nazwie user . Gdybyśmy mieli więcej pól/dokumentów, moglibyśmy je również połączyć, gdybyśmy chcieli.

Zduplikowane nazwy pól

Jeśli dokumenty, które mają zostać scalone, zawierają zduplikowane nazwy pól, $mergeObjects nadpisuje pole podczas łączenia dokumentów. Dlatego pole w wynikowym dokumencie zawiera wartość z ostatniego dokumentu scalonego dla tego pola.

Załóżmy, że mamy następujący dokument:

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

Widzimy, że oba dokumenty zawierają pole o nazwie f_name .

Oto, co się dzieje, gdy łączymy te dokumenty:

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

Wynik:

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

f_name pole w wynikowym dokumencie zawiera Bart , która jest wartością z ostatniego połączonego dokumentu.

Wartości puste

Jeśli scalasz dokument z null , otrzymany dokument zostanie zwrócony bez zmian.

Ale jeśli wszystkie dokumenty do scalenia są null , zwracany jest pusty dokument.

Załóżmy, że mamy następujące dokumenty:

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

Oto, co się stanie, gdy scalimy name i contact pola w tych dwóch dokumentach:

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

Wynik:

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

Przykłady składni 2 (pojedynczy argument)

Oto dwa przykłady, w których zastosowano składnię jednoargumentową.

$group Akumulator sceniczny

W pierwszym przykładzie $mergeObjects jest używany jako $group akumulator sceniczny.

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

{
	"_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
	}
}

Możemy pogrupować te dokumenty według ich product pole, a następnie użyj $mergeObjects scalić inventory pole dla każdej grupy:

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

Wynik:

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

Tablice

Ten przykład dotyczy $mergeObjects do pojedynczego dokumentu, który zawiera pole z tablicą dokumentów.

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

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

Możemy zastosować $mergeObjects do data pole:

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

Wynik:

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

Brakujące pola

$mergeObjects ignoruje brakujące pola. Oznacza to, że jeśli podasz pole, które nie istnieje, ignoruje je. Jeśli żadne z pól nie istnieje, zwraca pusty dokument.

Przykład:

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

Wynik:

{ "_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" : { } }

Oto jednak, co się dzieje, gdy brak z pól istnieje:

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

Wynik:

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

Wynikiem jest pusty dokument.

To samo dotyczy składni jednoargumentowej.

Przykład:

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

Wynik:

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