మొంగోడిబిలో గ్రూప్ అగ్రిగేషన్ ఎలా పని చేస్తుంది?
పేర్కొన్న _id వ్యక్తీకరణ ప్రకారం ఇన్‌పుట్ డాక్యుమెంట్‌లను సమూహపరచడానికి $గ్రూప్ ఆపరేటర్‌ని ఉపయోగించాలి. ఇది ప్రతి ప్రత్యేక సమూహానికి మొత్తం విలువలతో ఒకే పత్రాన్ని అందించాలి. అమలుతో ప్రారంభించడానికి, మేము MongoDBలో “పుస్తకాల” సేకరణను సృష్టించాము. 'పుస్తకాలు' సేకరణను సృష్టించిన తర్వాత, మేము వివిధ ఫీల్డ్‌లతో అనుబంధించబడిన పత్రాలను చొప్పించాము. అమలు చేయవలసిన ప్రశ్న క్రింద చూపబడినందున ఇన్సర్ట్‌మేనీ() పద్ధతి ద్వారా పత్రాలు సేకరణలో చొప్పించబడ్డాయి.
>db.Books.insertMany([{
_id:1,
శీర్షిక: 'అన్నా కరెనినా',
ధర: 290,
సంవత్సరం: 1879,
ఆర్డర్_స్టేటస్: 'ఇన్-స్టాక్',
రచయిత: {
'పేరు': 'లియో టాల్‌స్టాయ్'
}
},
{
_id:2,
శీర్షిక: 'టు కిల్ ఎ మోకింగ్ బర్డ్',
ధర: 500,
సంవత్సరం: 1960,
ఆర్డర్_స్టేటస్: 'అవుట్-ఆఫ్-స్టాక్',
రచయిత: {
'పేరు':'హార్పర్ లీ'
}
},
{
_id:3,
శీర్షిక: 'అదృశ్య మనిషి',
ధర: 312,
సంవత్సరం: 1953,
ఆర్డర్_స్టేటస్: 'ఇన్-స్టాక్',
రచయిత: {
'పేరు':'రాల్ఫ్ ఎల్లిసన్'
}
},
{
_id:4,
శీర్షిక: 'ప్రియమైన',
ధర: 370,
సంవత్సరం: 1873,
ఆర్డర్_స్టేటస్: 'out_of_stock',
రచయిత: {
'పేరు':'టోని మారిసన్'
}
},
{
_id:5,
శీర్షిక: 'థింగ్స్ ఫాల్ అపార్ట్',
ధర: 200,
సంవత్సరం: 1958,
ఆర్డర్_స్టేటస్: 'ఇన్-స్టాక్',
రచయిత: {
'పేరు':'చినువా అచెబే'
}
},
{
_id:6,
శీర్షిక: 'ది కలర్ పర్పుల్',
ధర: 510,
సంవత్సరం: 1982,
ఆర్డర్_స్టేటస్: 'అవుట్-ఆఫ్-స్టాక్',
రచయిత: {
'పేరు':'ఆలిస్ వాకర్'
}
}
])
అవుట్‌పుట్ 'నిజం'గా గుర్తించబడినందున పత్రాలు ఎటువంటి లోపాన్ని ఎదుర్కోకుండా 'పుస్తకాల' సేకరణలో విజయవంతంగా నిల్వ చేయబడతాయి. ఇప్పుడు, మేము “$గ్రూప్” అగ్రిగేషన్‌ని అమలు చేయడానికి “పుస్తకాల” సేకరణ యొక్క ఈ పత్రాలను ఉపయోగించబోతున్నాము.
ఉదాహరణ # 1: $గ్రూప్ అగ్రిగేషన్ యొక్క ఉపయోగం
$గ్రూప్ అగ్రిగేషన్ యొక్క సాధారణ వినియోగం ఇక్కడ ప్రదర్శించబడింది. సమూహ ప్రశ్న ఇన్‌పుట్ మొదట “$గ్రూప్” ఆపరేటర్‌ని ఆపై “$గ్రూప్” ఆపరేటర్ సమూహ పత్రాలను రూపొందించడానికి ఎక్స్‌ప్రెషన్‌లను తీసుకుంటుంది.
>db.Books.aggregate([
{ $group:{ _id:'$author.name'} }
])
అన్ని ఇన్‌పుట్ డాక్యుమెంట్‌ల కోసం మొత్తం విలువలను గణించడానికి $గ్రూప్ ఆపరేటర్ యొక్క ఎగువ ప్రశ్న “_id” ఫీల్డ్‌తో పేర్కొనబడింది. తర్వాత, “_id” ఫీల్డ్ “$author.name”తో కేటాయించబడుతుంది, ఇది “_id” ఫీల్డ్‌లో వేరే సమూహాన్ని ఏర్పరుస్తుంది. $author.name యొక్క ప్రత్యేక విలువలు తిరిగి ఇవ్వబడతాయి ఎందుకంటే మేము సేకరించిన విలువలను గణించము. $సమూహ మొత్తం ప్రశ్న అమలు కింది అవుట్‌పుట్‌ను కలిగి ఉంది. _id ఫీల్డ్ రచయిత.పేర్ల విలువలను కలిగి ఉంది.
ఉదాహరణ # 2: $పుష్ అక్యుమ్యులేటర్‌తో $గ్రూప్ అగ్రిగేషన్‌ని ఉపయోగించడం
$గ్రూప్ అగ్రిగేషన్ యొక్క ఉదాహరణ ఇప్పటికే పైన పేర్కొన్న ఏదైనా అక్యుమ్యులేటర్‌ని ఉపయోగిస్తుంది. కానీ మనం $గ్రూప్ అగ్రిగేషన్‌లో అక్యుమ్యులేటర్‌లను ఉపయోగించవచ్చు. అక్యుమ్యులేటర్ ఆపరేటర్లు అంటే “_id” కింద “గ్రూప్” చేయబడినవి కాకుండా ఇన్‌పుట్ డాక్యుమెంట్ ఫీల్డ్‌లలో ఉపయోగించబడేవి. మేము వ్యక్తీకరణ ఫీల్డ్‌లను శ్రేణిలోకి నెట్టాలనుకుంటున్నామని అనుకుందాం, ఆపై '$పుష్' అక్యుమ్యులేటర్ '$గ్రూప్' ఆపరేటర్‌లో పిలువబడుతుంది. “$సమూహం” యొక్క “$పుష్” అక్యుమ్యులేటర్‌ను మరింత స్పష్టంగా అర్థం చేసుకోవడానికి ఉదాహరణ మీకు సహాయం చేస్తుంది.
>db.Books.aggregate([
{ $group : { _id : '$_id', సంవత్సరం: { $push: '$ year' } } }
]
).చక్కని();
ఇక్కడ, మేము శ్రేణిలో ఇచ్చిన పుస్తకాల యొక్క ప్రచురించిన సంవత్సరం తేదీని సమూహపరచాలనుకుంటున్నాము. దీన్ని పూర్తి చేయడానికి పై ప్రశ్నను వర్తింపజేయాలి. అగ్రిగేషన్ ప్రశ్న '$గ్రూప్' ఆపరేటర్ ఫీల్డ్ ఎక్స్‌ప్రెషన్ '_id' మరియు 'సంవత్సరం' ఫీల్డ్ ఎక్స్‌ప్రెషన్‌ని $పుష్ అక్యుమ్యులేటర్‌ని ఉపయోగించి సమూహ సంవత్సరాన్ని పొందే ఎక్స్‌ప్రెషన్‌తో అందించబడుతుంది. ఈ నిర్దిష్ట ప్రశ్న నుండి తిరిగి పొందిన అవుట్‌పుట్ సంవత్సరపు ఫీల్డ్‌ల శ్రేణిని సృష్టిస్తుంది మరియు తిరిగి వచ్చిన సమూహ పత్రాన్ని దానిలో నిల్వ చేస్తుంది.
ఉదాహరణ # 3: “$min” అక్యుమ్యులేటర్‌తో $గ్రూప్ అగ్రిగేషన్‌ని ఉపయోగించడం
తర్వాత, సేకరణలోని ప్రతి పత్రం నుండి కనీస సరిపోలిక విలువను పొందడానికి $సమూహ అగ్రిగేషన్‌లో ఉపయోగించబడే “$min” అక్యుమ్యులేటర్‌ని మేము కలిగి ఉన్నాము. $min అక్యుమ్యులేటర్ కోసం ప్రశ్న వ్యక్తీకరణ క్రింద ఇవ్వబడింది.
>db.Books.aggregate([{
$సమూహం:{
_id:{
శీర్షిక: '$title',
ఆర్డర్_స్టేటస్: '$order_status'
},
కనీస ధర:{$min: '$price'}
}
}
])
ప్రశ్న '$group' అగ్రిగేషన్ వ్యక్తీకరణను కలిగి ఉంది, ఇక్కడ మేము 'శీర్షిక' మరియు 'order_status' ఫీల్డ్‌ల కోసం పత్రాన్ని సమూహపరిచాము. అప్పుడు, మేము సమూహం చేయని ఫీల్డ్‌ల నుండి కనీస ధర విలువలను పొందడం ద్వారా డాక్యుమెంట్‌లను సమూహపరిచే $min అక్యుమ్యులేటర్‌ని అందించాము. మేము క్రింద $min అక్యుమ్యులేటర్ యొక్క ఈ ప్రశ్నను అమలు చేసినప్పుడు, ఇది ఒక క్రమంలో శీర్షిక మరియు ఆర్డర్_స్టేటస్ ద్వారా సమూహ పత్రాలను అందిస్తుంది. కనిష్ట ధర ముందుగా కనిపిస్తుంది మరియు పత్రం యొక్క అత్యధిక ధర చివరిగా ఉంచబడుతుంది.
ఉదాహరణ # 4: $సమ్ అక్యుమ్యులేటర్‌తో $గ్రూప్ అగ్రిగేషన్‌ని ఉపయోగించండి
$సమూహ ఆపరేటర్‌ని ఉపయోగించి అన్ని సంఖ్యా ఫీల్డ్‌ల మొత్తాన్ని పొందడానికి, $సమ్ అక్యుమ్యులేటర్ ఆపరేషన్ అమలు చేయబడుతుంది. సేకరణలలోని సంఖ్యేతర విలువలు ఈ అక్యుమ్యులేటర్ ద్వారా పరిగణించబడతాయి. అదనంగా, మేము ఇక్కడ $గ్రూప్ అగ్రిగేషన్‌తో $మ్యాచ్ అగ్రిగేషన్‌ని ఉపయోగిస్తున్నాము. $match అగ్రిగేషన్ డాక్యుమెంట్‌లో ఇవ్వబడిన ప్రశ్న షరతులను అంగీకరిస్తుంది మరియు సరిపోలిన డాక్యుమెంట్‌ను $గ్రూప్ అగ్రిగేషన్‌కు పంపుతుంది, ఇది ప్రతి సమూహానికి పత్రం మొత్తాన్ని అందిస్తుంది. $సమ్ అక్యుమ్యులేటర్ కోసం, ప్రశ్న దిగువన ప్రదర్శించబడింది.
>db.Books.aggregate([{ $match:{ order_status:'ఇన్-స్టాక్'}},
{ $group:{ _id:'$author.name', totalBooks: { $sum:1 } }
}])
అగ్రిగేషన్ యొక్క ఎగువ ప్రశ్న $match ఆపరేటర్‌తో ప్రారంభమవుతుంది, ఇది అన్ని 'order_status'తో సరిపోలుతుంది, దీని స్థితి 'ఇన్-స్టాక్' మరియు $సమూహానికి ఇన్‌పుట్‌గా పంపబడుతుంది. అప్పుడు, $సమూహ ఆపరేటర్ స్టాక్‌లోని అన్ని పుస్తకాల మొత్తాన్ని అవుట్‌పుట్ చేసే $సమ్ అక్యుమ్యులేటర్ ఎక్స్‌ప్రెషన్‌ను కలిగి ఉంటుంది. '$sum:1' ఒకే సమూహానికి చెందిన ప్రతి పత్రానికి 1ని జోడిస్తుందని గమనించండి. ఇక్కడ అవుట్‌పుట్ 'ఇన్-స్టాక్'తో అనుబంధించబడిన 'ఆర్డర్_స్టేటస్'ని కలిగి ఉన్న రెండు సమూహ పత్రాలను మాత్రమే చూపింది.
ఉదాహరణ # 5: $sort అగ్రిగేషన్‌తో $సమూహ అగ్రిగేషన్‌ని ఉపయోగించండి
ఇక్కడ $గ్రూప్ ఆపరేటర్ '$sort' ఆపరేటర్‌తో ఉపయోగించబడుతుంది, ఇది సమూహ పత్రాలను క్రమబద్ధీకరించడానికి ఉపయోగించబడుతుంది. కింది ప్రశ్న సార్టింగ్ ఆపరేషన్‌కు మూడు దశలను కలిగి ఉంది. మొదటిది $మ్యాచ్ స్టేజ్, తర్వాత $గ్రూప్ స్టేజ్ మరియు చివరిది $sort స్టేజ్, ఇది సమూహ పత్రాన్ని క్రమబద్ధీకరిస్తుంది.
>db.Books.aggregate([{ $match:{ order_status:'out-of-stock'}},
{ $group:{ _id:{ authorName :'$author.name'}, మొత్తం పుస్తకాలు: { $sum:1} } },
{$sort:{ authorName:1}}
])
ఇక్కడ, మేము సరిపోలిన పత్రాన్ని పొందాము, దీని “ఆర్డర్_స్టేటస్” స్టాక్‌లో లేదు. ఆ తర్వాత, సరిపోలిన పత్రం $సమూహ దశలో ఇన్‌పుట్ చేయబడుతుంది, ఇది పత్రాన్ని “authorName” మరియు “totalBooks” ఫీల్డ్‌తో సమూహం చేస్తుంది. $సమూహ వ్యక్తీకరణ మొత్తం 'అవుట్-ఆఫ్-స్టాక్' పుస్తకాల సంఖ్యకు $సమ్ అక్యుమ్యులేటర్‌తో అనుబంధించబడింది. సమూహం చేయబడిన పత్రాలు $sort వ్యక్తీకరణతో ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడతాయి, ఇక్కడ “1” ఆరోహణ క్రమాన్ని సూచిస్తుంది. పేర్కొన్న క్రమంలో క్రమబద్ధీకరించబడిన సమూహ పత్రం క్రింది అవుట్‌పుట్‌లో పొందబడుతుంది.
ఉదాహరణ # 6: విభిన్న విలువ కోసం $గ్రూప్ అగ్రిగేషన్‌ని ఉపయోగించండి
అగ్రిగేషన్ విధానం విభిన్న అంశం విలువలను సంగ్రహించడానికి $గ్రూప్ ఆపరేటర్‌ని ఉపయోగించి అంశం వారీగా పత్రాలను సమూహపరుస్తుంది. మొంగోడిబిలో ఈ స్టేట్‌మెంట్ యొక్క ప్రశ్న వ్యక్తీకరణను చూద్దాం.
>db.Books.aggregate( [ { $group : { _id : '$title' } ] ).pretty();సమూహ పత్రం యొక్క ప్రత్యేక విలువను పొందడానికి పుస్తకాల సేకరణకు అగ్రిగేషన్ ప్రశ్న వర్తించబడుతుంది. ఇక్కడ $గ్రూప్ _id ఎక్స్‌ప్రెషన్‌ను తీసుకుంటుంది, ఇది మనం “టైటిల్” ఫీల్డ్‌ని ఇన్‌పుట్ చేసినందున విభిన్న విలువలను అవుట్‌పుట్ చేస్తుంది. _id ఫీల్డ్‌కు వ్యతిరేకంగా టైటిల్ పేర్ల సమూహాన్ని కలిగి ఉన్న ఈ ప్రశ్నను అమలు చేయడం ద్వారా సమూహ పత్రం యొక్క అవుట్‌పుట్ పొందబడుతుంది.
ముగింపు
MongoDB డేటాబేస్‌లో డాక్యుమెంట్‌ను సమూహపరచడం కోసం $గ్రూప్ అగ్రిగేషన్ ఆపరేటర్ యొక్క కాన్సెప్ట్‌ను క్లియర్ చేయడం గైడ్ లక్ష్యం. మొంగోడిబి మొత్తం విధానం సమూహ దృగ్విషయాన్ని మెరుగుపరుస్తుంది. $గ్రూప్ ఆపరేటర్ యొక్క సింటాక్స్ నిర్మాణం ఉదాహరణ ప్రోగ్రామ్‌లతో ప్రదర్శించబడుతుంది. $సమూహ ఆపరేటర్‌ల యొక్క ప్రాథమిక ఉదాహరణతో పాటు, మేము ఈ ఆపరేటర్‌ని $push, $min, $sum వంటి కొన్ని అక్యుమ్యులేటర్‌లతో మరియు $match మరియు $sort వంటి ఆపరేటర్‌లతో కూడా ఉపయోగించాము.