MongoDB gruppera efter flera fält med hjälp av aggregeringsfunktion

Introduktion
MongoDB Aggregationsfunktion
Mongodb Group by Multiple Fields
Aggregationspipeline
Behandlingsflöde
Grupperingsmetod
Användningen av $group
Mongodb grupperar efter flera fält med hjälp av Aggregate-operationen
Slutsats

Introduktion

I den här artikeln kommer jag att presentera Mongodb gruppera efter flera fält. För att förstå bättre kommer vi först att lära oss om aggregeringsfunktionen.

MongoDB Aggregationsfunktion

Aggregationsfunktioner används i GROUP BY-klausuler för att aggregera grupperade data. Aggregeringsfunktioner fungerar bättre när de används tillsammans med GROUP BY-klausulen. Användningen av aggregeringsfunktionen är dock inte begränsad till grupperade frågor.

När en aggregeringsfunktion används i en fråga utan GROUP BY-klausulen aggregerar aggregeringsfunktionen hela resultatmängden (alla rader som matchar WHERE-klausulen). Om du inte använder GROUP BY-klausulen kan vissa aggregerade funktioner i SELECT-listan endast användas tillsammans med andra aggregerade funktioner. Därför måste den aggregerade funktionen använda GROUP BY-klausulen för att ansluta till listan i SELECT-listan.

Istället för att använda GROUP BY-klausulen kan till exempel AVG i en SELECT-lista endast motsvara SUM, men den kan inte motsvara en specifik kolumn.

MongoDB:s aggregeringsoperation används för batchoperationer på data. Efter att samlingen har grupperats efter villkor utförs en rad operationer som summa, medelvärde och andra. Aggregationsoperationer kan utföra komplexa insamlingsoperationer, särskilt för matematisk statistik och datautvinning.

Inmatningen för aggregeringsoperationen i MongoDB är samlingsdokumentet. Utgången kan vara ett eller flera dokument. MongoDB erbjuder en mycket kraftfull aggregeringsoperation som kan delas in i tre kategorier:

Aggregationspipeline
Aggregationsoperation för enstaka användning
MapReduce-programmeringsmodell

Mongodb Group by Multiple Fields

Grupperingsoperatorn $ är en aggregering som returnerar ett nytt dokument. Den har en egen operatör, vi kan få fram fältet i det aktuella dokumentet genom $-symbol + fältnamn. För att förstå MongoDB group by multiple fields först, låt oss ta en titt på en lista över alla operatörer som kan användas i $ group:

$ sum – Återger summan av alla numeriska fält.
$ avg – Beräknar genomsnittet mellan numeriska fält.
$ min – Återger det minsta värdet från det numeriska fältet
$ max – Hämtar det högsta värdet från det numeriska fältet.
$ push – Infogar fältets värde i resultatfältet
$ addToSet – Infogar ett värde i en array i det resulterande dokumentet, men skapar inga dubbletter.
$ first – Hämtar endast det första dokumentet från de grupperade, vanligtvis för sortering.
$ last – Hämtar det sista dokumentet.

Aggregationspipeline

I POSIX-läge med flera trådar finns det en metod som kallas pipeline, vars dataelementflöde exekveras sekventiellt av en uppsättning trådar i angiven ordning. aggregeringspipeline består av ett steg. Efter att ha behandlat dokumentet i ett steg överför aggregeringspipelinen behandlingsresultatet till nästa steg.

Polymerrörsfunktion Filtrera dokumentet för att ta reda på vilka dokument som uppfyller kriterierna. Konvertera dokumentet och ändra dokumentets utskriftsform.

Varje nivå i aggregeringsrörlinjen definieras med hjälp av stegoperatörer, och varje stegoperatör kan använda uttrycksoperatörer för att beräkna summa, medelvärde, sammanlänkning eller radbrytning före varje nivå. Resultatet returneras i slutet och det returnerade resultatet kan direkt skickas ut eller sparas i samlingen.

Behandlingsflöde

Db.collection.aggregate () kan använda flera kanaler samtidigt för databehandling.
Db.collection.aggregate () använder MongoDB:s inhemska operationer för att effektivt aggregera och stödja operationer som GroupBy i SQL utan att behöva skriva anpassade JS-rutiner.
Varje fas i pipeline begränsar 100 MB minne. Om en pipeline med en enda nod överskrider gränsen genererar MongoDB ett fel. Om du vill bearbeta stora datamängder kan du ställa in egenskapen allowDiskUse till true för att skriva data till en temporär fil för en aggregerad rörnod och tillåta en minnesgräns på 100 MB.
Db.collection.aggregate () kan tillämpas på en serie av skivor, men resultatet kan inte förloras i serien av skivor. MapReduce kan tillämpas på en serie skivor, och resultatet kan gå förlorat i en serie skivor.
Db.collection.aggregate () returnerar en markör, data lagras i minnet och kan hanteras direkt som MongoShell.
Uppgiften från db.collection.aggregate () kan endast sparas i ett dokument och BSON-dokumentets storlek är begränsad till 16 MB.

Grupperingsmetod

Användning av grupperingsmetoden liknar användning av GROUP BY-klausulen i SQL. Grupperingsmetoden har tre parametrar:

Nyckel: Visar nyckeln för gruppen
Initial: Visar nyckeln för gruppen
Initial: Visar nyckeln för gruppen: Initialiserar dokumentfältet som representerar dokumentgruppen
Reduce: En funktion som returnerar antalet element. Funktionen använder två parametrar som argument: det aktuella elementet och det aggregerade resultatdokumentet för den aktuella gruppen.
Keyf: valfri parameter. Använd en annan funktion än nyckelargumentet för att representera det returnerade nyckelobjektet.
Cond: valfri parameter. Anger att villkoret ska returnera sant, annars kommer dokumentet inte att delta i grupperingen. Om den här parametern inte anges deltar alla dokument i grupperingen.
Finalize: valfri parameter. Detta representerar en funktion som utlöses innan ett grupperat resultat returneras.

Till exempel:`js> db.users.group ({key: {name : true}, initial: {total : 0},reduce : function (curr, res){res.total += 1}}})`

Låt oss ta en titt på uttrycket. Parametern key anger att gruppen ska grupperas efter namn: key: {name: true}

Värdet för parametern initial initialiserar fälten som representerar resultatdokumentet för gruppen. I det här fallet sätts initialvärdet för fältet total. Detta fält anger antalet element i gruppen. Eftersom det kanske inte finns några element initialiserar vi till noll.

Reduceringsparametern representerar en funktion där parametern curr pekar på det aktuella objektet i gruppen och res representerar den aktuella gruppen. Om du hittar ett annat objekt med ett specifikt värde för fältet name, lägger du till det dokumentet i gruppen och ökar det totala värdet i res-dokumentet med 1.

Användningen av $group

Den $group använder _id för att ange det nyckelnamn som ska grupperas, med hjälp av den anpassade fältstatistiken. Användning av aggregerad operation kommer att rensa begreppet Mongodb group by multiple fields.

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 group by multiple fields
db.users.aggregate({
$match: {age: {$gte:18} }},
$group: {_id:{användarnamn:$användarnamn, ålder:$ge}, ’count’:{$sum:1} }
})
/// $sum:val Lägg till val till varje dokument
/// $avg:val Medelvärdet för varje dokument
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 Bli först i gruppen
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 grupperar efter flera fält med hjälp av Aggregate-operationen

Först väljs nyckeln som grupperingen baseras på och sedan delas samlingen in i grupper enligt det valda nyckelvärdet. Du kan sedan skapa ett slutdokument genom att aggregera dokumenten i varje grupp.

Gruppen har inte stöd för fragmenterade kluster och kan inte utföra shardklustring. Om du behöver distribuerat stöd måste du använda aggregate eller mapReduce.

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

db.collection.group(document)
{
# Grupperingsfält
key:{key1, key2:1},
# Förfrågningsvillkor
cond:{},
# Aggregeringsfunktion
reduce:function(current, result){},
# Initialisering
initial:{},
# Räknefunktion för returfunktion set
finalize:function(){}
}

Beräkna antalet objekt i varje kolumn

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:{},// all together
reduce:function(current, result){/// Corresponding to the current line，result Corresponding to multiple rows in the group
result.total += 1;
},
initial:{total:0}
})

Slutsats

Den här artikeln är skriven för att utvecklarna ska förstå Mongodb group by multiple fields using aggregate function. Om du tycker att den här artikeln är användbar fortsätter du att besöka Object Rocket för fler databasrelaterade artiklar.

Om du behöver råd eller hjälp med att hantera din databassäkerhet, skalbarhet eller säkerhetskopiering, tveka inte att kontakta oss på Object Rocket.