Paano Gumagana ang Group Aggregation sa MongoDB?
Ang operator ng $group ay dapat gamitin upang pagpangkatin ang mga dokumento ng input ayon sa tinukoy na _id expression. Dapat itong magbalik ng isang dokumento na may kabuuang halaga para sa bawat hiwalay na grupo. Upang magsimula sa pagpapatupad, ginawa namin ang koleksyon ng 'Mga Aklat' sa MongoDB. Matapos ang paglikha ng koleksyon ng 'Mga Aklat', ipinasok namin ang mga dokumento na nauugnay sa iba't ibang mga field. Ang mga dokumento ay ipinasok sa koleksyon sa pamamagitan ng insertMany() na pamamaraan habang ang query na isasagawa ay ipinapakita sa ibaba.
>db.Books.insertMany([{
_id:1,
pamagat: 'Anna Karenina',
presyo: 290,
taon: 1879,
order_status: 'In-stock',
may-akda: {
'pangalan': 'Leo Tolstoy'
}
},
{
_id:2,
pamagat: 'Upang Pumatay ng Mockingbird',
presyo: 500,
taon: 1960,
order_status: 'out-of-stock',
may-akda: {
'pangalan': 'Harper Lee'
}
},
{
_id:3,
pamagat: 'Invisible Man',
presyo: 312,
taon: 1953,
order_status: 'In-Stock',
may-akda: {
'pangalan': 'Ralph Ellison'
}
},
{
_id:4,
pamagat: 'Minamahal',
presyo: 370,
taon: 1873,
order_status: 'out_of_stock',
may-akda: {
'pangalan':'Toni Morrison'
}
},
{
_id:5,
pamagat: 'Ang mga bagay ay nahuhulog',
presyo: 200,
taon: 1958,
order_status: 'In-Stock',
may-akda: {
'pangalan':'Chinua Achebe'
}
},
{
_id:6,
pamagat: 'Ang Kulay Lila',
presyo: 510,
taon: 1982,
order_status: 'out-of-stock',
may-akda: {
'pangalan': 'Alice Walker'
}
}
])
Matagumpay na naiimbak ang mga dokumento sa koleksyon ng 'Mga Aklat' nang hindi nakakaranas ng anumang error dahil kinikilala ang output bilang 'totoo'. Ngayon, gagamitin namin ang mga dokumentong ito ng koleksyon ng 'Mga Aklat' para sa pagsasagawa ng pagsasama-sama ng '$group'.
Halimbawa # 1: Paggamit ng $group Aggregation
Ang simpleng paggamit ng $group aggregation ay ipinapakita dito. Ang pinagsama-samang query ay nag-input sa '$group' operator muna pagkatapos ay ang '$group' na operator ay karagdagang kukuha ng mga expression upang bumuo ng mga nakapangkat na dokumento.
>db.Books.aggregate([
{ $group:{ _id:'$author.name'} }
])
Tinukoy ang query sa itaas ng operator ng $group kasama ang field na “_id” upang kalkulahin ang kabuuang halaga para sa lahat ng mga dokumento ng pag-input. Pagkatapos, ang field na “_id” ay inilalaan kasama ng “$author.name” na bumubuo ng ibang grupo sa field na “_id”. Ibabalik ang mga hiwalay na halaga ng $author.name dahil hindi namin kino-compute ang anumang mga naipong value. Ang execution ng $group aggregate query ay may sumusunod na output. Ang _id field ay may mga halaga ng author.name.
Halimbawa # 2: Paggamit ng $group Aggregation kasama ang $push Accumulator
Ang halimbawa ng $group aggregation ay gumagamit ng anumang accumulator na nabanggit na sa itaas. Ngunit maaari naming gamitin ang mga nagtitipon sa $group aggregation. Ang mga operator ng accumulator ay ang mga ginagamit sa mga field ng input ng dokumento maliban sa mga 'nakapangkat' sa ilalim ng '_id'. Ipagpalagay natin na gusto nating itulak ang mga field ng expression sa isang array pagkatapos ay tinawag ang '$push' accumulator sa operator na '$group'. Tutulungan ka ng halimbawa na maunawaan ang '$push' accumulator ng '$group' nang mas malinaw.
>db.Books.aggregate([
{ $group : { _id : '$_id', taon: { $push: '$year' } } }
]
).maganda();
Dito, gusto naming igrupo ang petsa ng nai-publish na taon ng mga ibinigay na aklat sa array. Ang query sa itaas ay dapat ilapat upang magawa ito. Ang aggregation query ay binibigyan ng expression kung saan kinukuha ng operator ng '$group' ang field na expression na '_id' at ang 'year' na field expression upang makuha ang taon ng grupo gamit ang $push accumulator. Ang output na nakuha mula sa partikular na query na ito ay lumilikha ng hanay ng mga field ng taon at iniimbak ang ibinalik na nakagrupong dokumento sa loob nito.
Halimbawa # 3: Paggamit ng $group Aggregation na may '$min' Accumulator
Susunod, mayroon kaming '$min' na nagtitipon na ginagamit sa pagsasama-sama ng $group upang makuha ang pinakamababang katumbas na halaga mula sa bawat dokumento sa koleksyon. Ang query expression para sa $min accumulator ay ibinigay sa ibaba.
>db.Books.aggregate([{
$group:{
_id:{
pamagat: '$title',
order_status: '$order_status'
},
minPrice:{$min: '$price'}
}
}
])
Ang query ay may '$group' aggregation expression kung saan namin pinagsama-sama ang dokumento para sa 'title' at 'order_status' na mga field. Pagkatapos, ibinigay namin ang $min accumulator na nagpangkat sa mga dokumento sa pamamagitan ng pagkuha ng pinakamababang halaga ng presyo mula sa mga hindi nakagrupong field. Kapag pinatakbo namin ang query na ito ng $min accumulator sa ibaba, ibinabalik nito ang mga nakapangkat na dokumento ayon sa pamagat at order_status sa isang pagkakasunod-sunod. Ang pinakamababang presyo ay unang lilitaw, at ang pinakamataas na presyo ng dokumento ay ilalagay sa huli.
Halimbawa # 4: Gamitin ang $group Aggregation kasama ang $sum Accumulator
Upang makuha ang kabuuan ng lahat ng mga numerical na patlang gamit ang operator ng $group, ang operasyon ng $sum accumulator ay naka-deploy. Ang mga hindi numeric na halaga sa mga koleksyon ay isinasaalang-alang ng accumulator na ito. Bilang karagdagan, ginagamit namin ang $match aggregation dito kasama ang $group aggregation. Tinatanggap ng $match aggregation ang mga kundisyon ng query na ibinigay sa isang dokumento at ipinapasa ang katugmang dokumento sa $group aggregation na nagbabalik ng kabuuan ng dokumento para sa bawat pangkat. Para sa $sum accumulator, ang query ay ipinakita sa ibaba.
>db.Books.aggregate([{ $match:{ order_status:'In-Stock'}},
{ $group:{ _id:'$author.name', totalBooks: { $sum:1 } }
}])
Ang query sa itaas ng pagsasama-sama ay nagsisimula sa $match operator na tumutugma sa lahat ng 'order_status' na ang status ay 'In-Stock' at ipinasa sa $group bilang input. Pagkatapos, ang operator ng $group ay may expression na $sum accumulator na naglalabas ng kabuuan ng lahat ng aklat sa stock. Tandaan na ang “$sum:1” ay nagdaragdag ng 1 sa bawat dokumento na kabilang sa parehong pangkat. Ang output dito ay nagpakita lamang ng dalawang nakagrupong dokumento na may 'order_status' na nauugnay sa 'In-Stock'.
Halimbawa # 5: Gamitin ang $group Aggregation kasama ang $sort Aggregation
Ang operator ng $group dito ay ginagamit kasama ng operator na '$sort' na ginagamit upang pagbukud-bukurin ang mga nakagrupong dokumento. Ang sumusunod na query ay may tatlong hakbang sa pagpapatakbo ng pag-uuri. Una ay ang $match stage, pagkatapos ay ang $group stage, at ang huli ay ang $sort stage na nag-uuri ng nakapangkat na dokumento.
>db.Books.aggregate([{ $match:{ order_status:'out-of-stock'}},
{ $group:{ _id:{ authorName :'$author.name'}, totalBooks: { $sum:1} } },
{ $sort:{ authorName:1}}
])
Dito, kinuha namin ang katugmang dokumento na ang 'order_status' ay out-of-stock. Pagkatapos, ang katugmang dokumento ay input sa yugto ng $group na nagpangkat ng dokumento sa field na 'authorName' at ang 'totalBooks'. Ang expression ng $group ay nauugnay sa $sum accumulator sa kabuuang bilang ng mga librong 'out-of-stock'. Ang mga nakagrupong dokumento ay pinagbubukod-bukod sa $sort expression sa pataas na pagkakasunod-sunod bilang '1' dito ay nagpapahiwatig ng pataas na pagkakasunud-sunod. Ang pinagsunod-sunod na dokumento ng pangkat sa tinukoy na pagkakasunud-sunod ay nakuha sa sumusunod na output.
Halimbawa # 6: Gamitin ang $group Aggregation para sa Distinct Value
Pinagpangkat din ng pamamaraan ng pagsasama-sama ang mga dokumento ayon sa item gamit ang operator ng $group upang kunin ang mga natatanging halaga ng item. Hayaan kaming magkaroon ng query expression ng pahayag na ito sa MongoDB.
>db.Books.aggregate( [ { $group : { _id : '$title' } } ] ).pretty();Inilapat ang pagsasama-sama ng query sa koleksyon ng Mga Aklat upang makuha ang natatanging halaga ng dokumento ng pangkat. Ang $group dito ay kumukuha ng _id expression na naglalabas ng mga natatanging value habang inilalagay namin ang field na 'title' dito. Ang output ng dokumento ng pangkat ay nakuha sa pagpapatakbo ng query na ito na mayroong pangkat ng mga pangalan ng pamagat laban sa _id na patlang.
Konklusyon
Nilalayon ng gabay na i-clear ang konsepto ng operator ng $group aggregation para sa pagpapangkat ng dokumento sa database ng MongoDB. Pinapabuti ng pinagsama-samang diskarte ng MongoDB ang mga pangyayari sa pagpapangkat. Ang istruktura ng syntax ng operator ng $group ay ipinapakita kasama ng mga halimbawang programa. Bilang karagdagan sa pangunahing halimbawa ng mga operator ng $group, ginamit din namin ang operator na ito sa ilang mga accumulator tulad ng $push, $min, $sum, at mga operator tulad ng $match at $sort.