В MongoDB, $mergeObjects
Операторът на тръбопровода за агрегиране комбинира множество документи в един документ.
Синтаксис
$mergeObjects
операторът поддържа два синтаксиса.
Синтаксис 1:
{ $mergeObjects: [ <document1>, <document2>, ... ] }
Синтаксис 2:
{ $mergeObjects: <document> }
Първият синтаксис приема множество аргументи, а вторият синтаксис приема един аргумент.
Пример за синтаксис 1 (множество аргументи)
Първият синтаксис включва предоставяне на $mergeObjects
с повече от един аргумент/документ. $mergeObjects
след това комбинира тези документи в един.
Да предположим, че имаме колекция, наречена users
със следния документ:
{ "_id" : 1, "name" : { "f_name" : "Homer", "l_name" : "Simpson" }, "contact" : { "email" : "[email protected]", "ph" : null } }
Можем да използваме $mergeObjects
за да обедините name
и contact
полета:
db.users.aggregate(
[
{
$project:
{
user: { $mergeObjects: [ "$name", "$contact" ] }
}
}
]
).pretty()
Резултат:
{ "_id" : 1, "user" : { "f_name" : "Homer", "l_name" : "Simpson", "email" : "[email protected]", "ph" : null } }
В този случай обединихме двете полета в едно поле, наречено user
. Ако имахме повече полета/документи, бихме могли да обединим и тях, ако искахме.
Дублиращи се имена на полета
Ако документите, които ще бъдат обединени, съдържат дублиращи се имена на полета, $mergeObjects
презаписва полето, докато обединява документите. Следователно полето в получения документ съдържа стойността от последния документ, обединен за това поле.
Да предположим, че имаме следния документ:
{ "_id" : 2, "name" : { "f_name" : "Peter", "l_name" : "Griffin" }, "contact" : { "email" : "[email protected]", "f_name" : "Bart" } }
Можем да видим, че и двата документа съдържат поле с име f_name
.
Ето какво се случва, когато обединим тези документи:
db.users.aggregate(
[
{ $match: { _id: 2 } },
{
$project:
{
user: { $mergeObjects: [ "$name", "$contact" ] }
}
}
]
).pretty()
Резултат:
{ "_id" : 2, "user" : { "f_name" : "Bart", "l_name" : "Griffin", "email" : "[email protected]" } }
f_name
полето в получения документ съдържа Bart
, което е стойността от последния документ, който е бил обединен.
Нулеви стойности
Ако обединявате документ с null
, полученият документ ще бъде върнат без никакви промени.
Но ако всички документи за сливане са null
, след което се връща празен документ.
Да предположим, че имаме следните документи:
{ "_id" : 3, "name" : { "f_name" : "Hubert", "l_name" : "Farnsworth" }, "contact" : null } { "_id" : 4, "name" : null, "contact" : null }
Ето какво се случва, когато обединим name
и contact
полета в тези два документа:
db.users.aggregate(
[
{ $match: { _id: { $in: [ 3, 4 ] } } },
{
$project:
{
user: { $mergeObjects: [ "$name", "$contact" ] }
}
}
]
)
Резултат:
{ "_id" : 3, "user" : { "f_name" : "Hubert", "l_name" : "Farnsworth" } } { "_id" : 4, "user" : { } }
Примери за синтаксис 2 (единичен аргумент)
Ето два примера, които използват синтаксиса на единичния аргумент.
$group
Сценичен акумулатор
В първия пример $mergeObjects
се използва като $group
сценичен акумулатор.
Да предположим, че имаме колекция, наречена products
със следните документи:
{ "_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 } }
Можем да групираме тези документи по техния product
поле и след това използвайте $mergeObjects
за да обедините inventory
поле за всяка група:
db.products.aggregate( [
{ $group: {
_id: "$product",
mergedProducts: { $mergeObjects: "$inventory" }
}
}
]).pretty()
Резултат:
{ "_id" : "Shorts", "mergedProducts" : { "blue" : 2, "red" : 8, "green" : 5, "black" : 3 } } { "_id" : "Shirt", "mergedProducts" : { "blue" : 10, "red" : 2, "green" : 3, "black" : 1 } }
Масиви
Този пример се прилага $mergeObjects
към един документ, който съдържа поле с масив от документи.
Да предположим, че имаме колекция, наречена test
със следните документи:
{ "_id" : 1, "data" : [ { "a" : 1, "b" : 2 }, { "c" : 3, "d" : 4 } ] }
Можем да приложим $mergeObjects
към data
поле:
db.test.aggregate(
[
{
$project:
{
result: { $mergeObjects: "$data" }
}
}
]
)
Резултат:
{ "_id" : 1, "result" : { "a" : 1, "b" : 2, "c" : 3, "d" : 4 } }
Липсващи полета
$mergeObjects
игнорира всички липсващи полета. Тоест, ако предоставите поле, което не съществува, то го игнорира. Ако нито едно от полетата не съществува, то връща празен документ.
Пример:
db.users.aggregate(
[
{
$project:
{
user: { $mergeObjects: [ "$name", "$oops" ] }
}
}
]
).pretty()
Резултат:
{ "_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" : { } }
Но ето какво се случва, когато няма от полетата съществуват:
db.users.aggregate(
[
{
$project:
{
user: { $mergeObjects: [ "$wrong", "$oops" ] }
}
}
]
).pretty()
Резултат:
{ "_id" : 1, "user" : { } } { "_id" : 2, "user" : { } } { "_id" : 3, "user" : { } } { "_id" : 4, "user" : { } }
Резултатът е празен документ.
Същото е и при използване на синтаксис с един аргумент.
Пример:
db.products.aggregate( [
{ $group: {
_id: "$product",
mergedProducts: { $mergeObjects: "$oops!" }
}
}
]).pretty()
Резултат:
{ "_id" : "Shorts", "mergedProducts" : { } } { "_id" : "Shirt", "mergedProducts" : { } }