MongoDB csoportosítás több mező alapján az aggregációs funkció használatával

Bevezetés
MongoDB aggregációs függvény
Mongodb Group by Multiple Fields
Az aggregációs csővezeték
Feldolgozási folyamat
Grouping method
A $group használata
Mongodb csoportosítás több mező alapján Aggregate művelettel
Következtetés

Bevezetés

Ebben a cikkben bemutatom a Mongodb csoportosítását több mező alapján. A jobb megértéshez először az aggregációs függvényt fogjuk megismerni.

MongoDB aggregációs függvény

Az aggregációs függvényeket a GROUP BY záradékokban használjuk a csoportosított adatok összesítésére. Az aggregációs függvények jobban teljesítenek, ha a GROUP BY záradékkal együtt használják őket. Az aggregáló függvény használata azonban nem korlátozódik a csoportosított lekérdezésekre.

Ha egy aggregáló függvényt GROUP BY záradék nélküli lekérdezésben használunk, az aggregáló függvény a teljes eredményhalmazt (a WHERE záradéknak megfelelő összes sort) aggregálja. Ha nem használja a GROUP BY záradékot, a SELECT listában szereplő egyes aggregáló függvények csak más aggregáló függvényekkel együtt használhatók. Ezért az aggregáló függvénynek a GROUP BY záradékot kell használnia a SELECT listában szereplő listához való kapcsolódáshoz.

A GROUP BY záradék használata helyett például az AVG a SELECT listában csak a SUM-nak felelhet meg, de nem felelhet meg egy adott oszlopnak.

A MongoDB aggregáló művelet az adatokon végzett kötegelt műveletekhez használható. Miután a gyűjteményt feltétel szerint csoportosítottuk, egy sor művelet, például az összeg, az átlag és más műveletek kerülnek végrehajtásra. Az aggregációs műveletekkel összetett gyűjtési műveletek végezhetők, különösen a matematikai statisztikák és az adatbányászat esetében.

A MongoDB-ben az aggregációs művelet bemenete a gyűjtési dokumentum. A kimenet egy vagy több dokumentum lehet. A MongoDB nagyon hatékony aggregációs műveleteket kínál, amelyek három kategóriába sorolhatók:

Aggregációs csővezeték
Aggregációs művelet egyszeri használatra
MapReduce programozási modell

Mongodb Group by Multiple Fields

A $ group operátor egy aggregátor, amely egy új dokumentumot ad vissza. Saját operátorral rendelkezik, az aktuális dokumentum mezőjét a $ szimbólum + mezőnév segítségével kaphatjuk meg. Ahhoz, hogy először megértsük a MongoDB több mező szerinti csoportosítását, nézzük meg a $ groupban használható operátorok listáját:

$ sum – Az összes numerikus mező összegét adja vissza.
$ avg – A numerikus mezők közötti átlagot számítja ki.
$ min – A numerikus mező minimális értékét adja vissza
$ max – A numerikus mező maximális értékének kinyerése.
$ push – beszúrja a mező értékét az eredménymezőbe
$ addToSet – Beilleszti az értéket a kapott dokumentum tömbjébe, de nem hoz létre duplikátumokat.
$ first – Csak az első dokumentumot szerzi ki a csoportosított dokumentumok közül, általában rendezéshez.
$ last – Az utolsó dokumentumot adja vissza.

Az aggregációs csővezeték

A többszálas POSIX módban létezik egy csővezetéknek nevezett módszer, amelynek adatelemfolyamát szálak halmaza hajtja végre egymás után a megadott sorrendben.az aggregációs csővezeték egy szakaszból áll. Miután az egyik szakaszban feldolgozta a dokumentumot, az aggregációs csővezeték a feldolgozás eredményét átadja a következő szakasznak.

Polimer cső funkció A dokumentum szűrése annak megállapítására, hogy mely dokumentumok felelnek meg a kritériumoknak. Konvertálja a dokumentumot, és megváltoztatja a dokumentum kimeneti formáját.

Az aggregációs csővezeték minden szintjét szakaszoperátorok segítségével határozza meg, és minden szakaszoperátor használhat kifejezésoperátorokat az egyes szintek előtti összeg, átlag, összefűzés vagy sortörés kiszámításához. Az eredményt a végén kapjuk vissza, és a visszaadott eredményt közvetlenül ki lehet adni vagy el lehet menteni a gyűjteménybe.

Feldolgozási folyamat

A db.collection.aggregate () egyszerre több csatornát is használhat az adatfeldolgozáshoz.
Adb.collection.aggregate () a MongoDB natív műveleteit használja a hatékony aggregáláshoz és az olyan műveletek támogatásához, mint a GroupBy az SQL-ben, anélkül, hogy egyéni JS rutinokat kellene írni.
A pipeline minden fázisa 100 MB memóriát korlátoz. Ha egy egycsomópontú csővezeték túllépi a korlátot, a MongoDB hibát generál. Nagy mennyiségű adat feldolgozásához állítsa az allowDiskUse tulajdonságot true-ra, hogy az adatokat egy ideiglenes fájlba írja egy aggregált csőcsomóponthoz, és engedélyezze a 100 MB-os memóriakorlátot.
Adb.collection.aggregate () szeletsorozatra is alkalmazható, de az eredmény nem veszhet el a szeletsorozatban. A MapReduce alkalmazható szeletek sorozatára, és az eredmény elveszhet a szeletek sorozatában.
Db.collection.aggregate () visszaad egy kurzort, az adatokat a memóriában tárolja, és közvetlenül MongoShellként kezelhető.
A db.collection.aggregate () kimenete csak egy dokumentumba menthető, és a BSON dokumentum mérete 16 MB-ra van korlátozva.

Grouping method

A group módszer használata hasonló az SQL-ben a GROUP BY záradék használatához. A csoportosítási módszernek három paramétere van:

Key: Megjeleníti a csoport kulcsát
Initial: A dokumentumcsoportot reprezentáló dokumentummező inicializálása
Redukálás: Az elemek számát visszaadó függvény. Ez a függvény két paramétert használ argumentumként: az aktuális elemet és az aktuális csoport összesített eredménydokumentumát.
Keyf: opcionális paraméter. A kulcs argumentumtól eltérő függvényt használhat a visszatérő kulcsobjektum megjelenítésére.
Cond: opcionális paraméter. Megadja, hogy a feltételnek igazat kell visszaadnia, különben a dokumentum nem vesz részt a csoportosításban. Ha ez a paraméter nincs megadva, akkor minden dokumentum részt vesz a csoportosításban.
Finalize: opcionális paraméter. Olyan függvényt jelöl, amely a csoportosított eredmény visszaadása előtt lép működésbe.

Például:`js> db.users.group ({key: {name : true}, initial: {total : 0}},reduce : function (curr, res){res.total += 1}})`

Nézzük meg a kifejezést. A key paraméter megadja, hogy a csoportot név szerint csoportosítjuk: key: {name: true}

Az initial paraméter értéke inicializálja a csoport eredménydokumentumát jelentő mezőket. Ebben az esetben a total mező kezdeti értéke kerül beállításra. Ez a mező a csoportban lévő elemek számát jelzi. Mivel előfordulhat, hogy nincsenek elemek, ezért nullával inicializáljuk.

A reduce paraméter egy függvényt képvisel, ahol a curr paraméter a csoport aktuális objektumára mutat, az res pedig az aktuális csoportot képviseli. Ha találunk egy másik objektumot, amelynek a name mezője egy adott értéket tartalmaz, akkor azt a dokumentumot hozzáadjuk a csoporthoz, és a res dokumentumban lévő összértéket 1-gyel növeljük.

A $group használata

A $group az _id segítségével adja meg a csoportosítandó kulcs nevét, az egyéni mezőstatisztika segítségével. Az aggregált művelet használata törli a Mongodb több mező szerinti csoportosítás fogalmát.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

db.users.aggregate({
$match : { age: { $gte : 18 } }
},{
$group : { _id:$username, count:{$sum:1} }
});
// Mongodb csoportosítás több mező alapján
db.users.aggregate({
$match: {$gte:18} }}},
$group: {_id:{felhasználónév:$felhasználónév, életkor:$ge}, ‘count’:{$összeg:1} }
}})
// $sum:val Val hozzáadása minden dokumentumhoz
// $avg:val Minden dokumentum értékének átlaga
db.users.aggregate({
$group: { _id:$username, count:{$avg:$age} }
})
db.users.aggregate({
$group: { _id:$username, count:{$max:$age} }
})
db.users.aggregate({
$group: {_id:$username, count:{$min:$age} }
})
// $first:val Legyen a csoport első tagja
db.users.aggregate({
$group:{_id:$username, count:{$first: $age} }
})
db.users.aggregate({
$group:{_id:$username, count:{$last: $age} }
})
db.users.aggregate({
$group: {_id:$username, count:{$addToSet: $age} }
})
db.users.aggregate({
$group:{_id:$username, count:{$push: $age} }
})

Mongodb csoportosítás több mező alapján Aggregate művelettel

Először kiválasztjuk a csoportosítás alapjául szolgáló kulcsot, majd a gyűjteményt a kiválasztott kulcsérték alapján csoportokra osztjuk. Ezután az egyes csoportokban lévő dokumentumok aggregálásával létrehozható egy végső dokumentum.

A csoportosítás nem támogatja a töredezett fürtöket, és nem képes shard fürtözést végezni. Ha elosztott támogatásra van szüksége, akkor aggregátumot vagy mapReduce-t kell használnia.

1
2
3
4
5
6
7
8
9
10
11
12
13

db.collection.group(document)
{
# Csoportosítási mező
key:{key1, key2:1},
# Lekérdezési feltételek
cond:{},
# Összesítő függvény
reduce:function(current, result){},
# inicializálás
initial:{},
# Számláló visszatérési függvénykészlet
finalize:function(){}
}

Kiszámítja az egyes oszlopokban lévő elemek számát

1
2
3
4
5
6
7
8
9

SELECT COUNT(*) FROM goods GROUP BY category_id;
db.goods.group({
key:{category_id:1},
cond:{},// mind együtt
reduce:function(current, result){// Az aktuális sornak megfelelő，result A csoport több sorának megfelelő
result.total += 1;
},
initial:{total:0}
})

Következtetés

Ez a cikk a fejlesztők számára íródott, hogy megértsék a Mongodb csoportosítását több mező alapján az aggregátum függvény használatával. Ha hasznosnak találta ezt a cikket, látogasson el továbbra is az Object Rocket oldalára további adatbázisokkal kapcsolatos cikkekért.

Ha tanácsra vagy segítségre van szüksége az adatbázis biztonságának, skálázhatóságának vagy biztonsági mentésének kezelésével kapcsolatban, kérjük, ne habozzon kapcsolatba lépni velünk az Object Rocketnél.