MongoDB $mergeObjects

Di MongoDB, $mergeObjects operator pipa agregasi menggabungkan beberapa dokumen menjadi satu dokumen.

Sintaks

$mergeObjects operator mendukung dua sintaks.

Sintaks 1

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

Sintaks 2:

{ $mergeObjects: <document> }

Sintaks pertama menerima beberapa argumen dan sintaks kedua menerima satu argumen.

Contoh Sintaks 1 (Beberapa Argumen)

Sintaks pertama melibatkan penyediaan $mergeObjects dengan lebih dari satu argumen/dokumen. $mergeObjects lalu gabungkan dokumen-dokumen tersebut menjadi satu.

Misalkan kita memiliki koleksi yang disebut users dengan dokumen berikut:

{
	"_id" : 1,
	"name" : {
		"f_name" : "Homer",
		"l_name" : "Simpson"
	},
	"contact" : {
		"email" : "[email protected]",
		"ph" : null
	}
}

Kita dapat menggunakan $mergeObjects untuk menggabungkan name dan contact bidang:

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

Hasil:

{
	"_id" : 1,
	"user" : {
		"f_name" : "Homer",
		"l_name" : "Simpson",
		"email" : "[email protected]",
		"ph" : null
	}
}

Dalam hal ini, kami menggabungkan kedua bidang menjadi satu bidang yang disebut user . Jika kami memiliki lebih banyak bidang/dokumen, kami juga dapat menggabungkannya jika kami mau.

Nama Bidang Duplikat

Jika dokumen yang akan digabungkan berisi nama bidang duplikat, $mergeObjects menimpa bidang saat menggabungkan dokumen. Oleh karena itu, bidang dalam dokumen yang dihasilkan berisi nilai dari dokumen terakhir yang digabungkan untuk bidang tersebut.

Misalkan kita memiliki dokumen berikut:

{
	"_id" : 2,
	"name" : {
		"f_name" : "Peter",
		"l_name" : "Griffin"
	},
	"contact" : {
		"email" : "[email protected]",
		"f_name" : "Bart"
	}
}

Kita dapat melihat bahwa kedua dokumen berisi bidang bernama f_name .

Inilah yang terjadi ketika kami menggabungkan dokumen-dokumen itu:

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

Hasil:

{
	"_id" : 2,
	"user" : {
		"f_name" : "Bart",
		"l_name" : "Griffin",
		"email" : "[email protected]"
	}
}

f_name bidang dalam dokumen yang dihasilkan berisi Bart , yang merupakan nilai dari dokumen terakhir yang digabungkan.

Nilai Null

Jika menggabungkan dokumen dengan null , dokumen yang dihasilkan akan dikembalikan tanpa perubahan apa pun.

Tetapi jika semua dokumen yang akan digabungkan adalah null , lalu dokumen kosong dikembalikan.

Misalkan kita memiliki dokumen berikut:

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

Inilah yang terjadi ketika kita menggabungkan name dan contact kolom dalam dua dokumen tersebut:

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

Hasil:

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

Contoh Sintaks 2 (Argumen Tunggal)

Berikut adalah dua contoh yang menggunakan sintaks argumen tunggal.

$group Akumulator Panggung

Pada contoh pertama, $mergeObjects digunakan sebagai $group akumulator panggung.

Misalkan kita memiliki koleksi yang disebut products dengan dokumen sebagai berikut:

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

Kami dapat mengelompokkan dokumen-dokumen ini berdasarkan product mereka bidang, lalu gunakan $mergeObjects untuk menggabungkan inventory kolom untuk setiap grup:

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

Hasil:

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

Array

Contoh ini berlaku $mergeObjects ke satu dokumen yang berisi bidang dengan larik dokumen.

Misalkan kita memiliki koleksi yang disebut test dengan dokumen sebagai berikut:

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

Kita dapat menerapkan $mergeObjects ke data bidang:

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

Hasil:

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

Bidang Tidak Ada

$mergeObjects mengabaikan bidang yang hilang. Artinya, jika Anda menyediakan bidang yang tidak ada, itu akan mengabaikannya. Jika tidak ada bidang yang ada, maka ia akan mengembalikan dokumen kosong.

Contoh:

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

Hasil:

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

Namun, inilah yang terjadi ketika tidak ada bidang yang ada:

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

Hasil:

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

Hasilnya adalah dokumen kosong.

Sama halnya ketika menggunakan sintaks argumen tunggal.

Contoh:

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

Hasil:

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