sql >> Database >  >> NoSQL >> MongoDB

MongoDB-aggregatie - $ groeperen op datum, zelfs als deze niet bestaat

In plaats van te proberen de database te dwingen resultaten te retourneren voor gegevens die niet bestaan, is het een betere gewoonte om de lege gegevens buiten de query te genereren en de resultaten daarin samen te voegen. Op die manier heb je je "0"-items waar er geen gegevens zijn en laat de database teruggeven wat er is.

Samenvoegen is een basisproces van het maken van een gehashte tabel met unieke sleutels en het eenvoudigweg vervangen van een van de waarden in de aggregatieresultaten in die hashtabel. In JavaScript past een basisobject goed omdat alle sleutels uniek zijn.

Ik geef er ook de voorkeur aan om een ​​Date daadwerkelijk terug te sturen object uit aggregatieresultaten door datumwiskunde te gebruiken om de datum te manipuleren en "af te ronden" naar het vereiste interval in plaats van de datumaggregatieoperatoren te gebruiken. U kunt datums manipuleren met behulp van $subtract om de waarde om te zetten in een numerieke tijdstempelweergave door af te trekken van een andere datum met de epochedatumwaarde en de $mod operator om de rest te krijgen en de datum af te ronden op het vereiste interval.

In tegenstelling tot het gebruik van $add met een vergelijkbaar epoche-datumobject verandert een geheel getal terug in een BSON-datum. En natuurlijk is het veel efficiënter om rechtstreeks naar de $group in plaats van een aparte $project te gebruiken stadium, aangezien u de gewijzigde datums gewoon rechtstreeks kunt verwerken in de groepering _id waarde toch.

Als shell-voorbeeld:

var sample = 30,
    Days = 30,
    OneDay = ( 1000 * 60 * 60 * 24 ),
    now = Date.now(),
    Today = now - ( now % OneDay ) ,
    nDaysAgo = Today - ( OneDay * Days ),
    startDate = new Date( nDaysAgo ),
    endDate = new Date( Today + OneDay ),
    store = {};

var thisDay = new Date( nDaysAgo );
while ( thisDay < endDate ) {
    store[thisDay] = 0;
    thisDay = new Date( thisDay.valueOf() + OneDay );
}

db.datejunk.aggregate([
    { "$match": { "when": { "$gte": startDate } }},
    { "$group": {
        "_id": {
            "$add": [
                { "$subtract": [
                    { "$subtract": [ "$when", new Date(0) ] },
                    { "$mod": [
                        { "$subtract": [ "$when", new Date(0) ] },
                        OneDay
                    ]}
                ]},
                new Date(0)
            ]
        },
        "count": { "$sum": 1 }
    }}
]).forEach(function(result){
    store[result._id] = result.count;
});

Object.keys(store).forEach(function(k) {
    printjson({ "date": k, "count": store[k] })
});

Die alle dagen in het interval teruggeeft, inclusief 0 waarden waar geen gegevens bestaan, zoals:

{ "date" : "Tue Sep 22 2015 10:00:00 GMT+1000 (AEST)", "count" : 0 }
{ "date" : "Wed Sep 23 2015 10:00:00 GMT+1000 (AEST)", "count" : 1 }
{ "date" : "Thu Sep 24 2015 10:00:00 GMT+1000 (AEST)", "count" : 0 }
{ "date" : "Fri Sep 25 2015 10:00:00 GMT+1000 (AEST)", "count" : 1 }
{ "date" : "Sat Sep 26 2015 10:00:00 GMT+1000 (AEST)", "count" : 1 }
{ "date" : "Sun Sep 27 2015 10:00:00 GMT+1000 (AEST)", "count" : 0 }
{ "date" : "Mon Sep 28 2015 10:00:00 GMT+1000 (AEST)", "count" : 1 }
{ "date" : "Tue Sep 29 2015 10:00:00 GMT+1000 (AEST)", "count" : 1 }
{ "date" : "Wed Sep 30 2015 10:00:00 GMT+1000 (AEST)", "count" : 0 }
{ "date" : "Thu Oct 01 2015 10:00:00 GMT+1000 (AEST)", "count" : 1 }
{ "date" : "Fri Oct 02 2015 10:00:00 GMT+1000 (AEST)", "count" : 2 }
{ "date" : "Sat Oct 03 2015 10:00:00 GMT+1000 (AEST)", "count" : 0 }
{ "date" : "Sun Oct 04 2015 11:00:00 GMT+1100 (AEST)", "count" : 1 }
{ "date" : "Mon Oct 05 2015 11:00:00 GMT+1100 (AEDT)", "count" : 0 }
{ "date" : "Tue Oct 06 2015 11:00:00 GMT+1100 (AEDT)", "count" : 1 }
{ "date" : "Wed Oct 07 2015 11:00:00 GMT+1100 (AEDT)", "count" : 2 }
{ "date" : "Thu Oct 08 2015 11:00:00 GMT+1100 (AEDT)", "count" : 2 }
{ "date" : "Fri Oct 09 2015 11:00:00 GMT+1100 (AEDT)", "count" : 1 }
{ "date" : "Sat Oct 10 2015 11:00:00 GMT+1100 (AEDT)", "count" : 1 }
{ "date" : "Sun Oct 11 2015 11:00:00 GMT+1100 (AEDT)", "count" : 1 }
{ "date" : "Mon Oct 12 2015 11:00:00 GMT+1100 (AEDT)", "count" : 0 }
{ "date" : "Tue Oct 13 2015 11:00:00 GMT+1100 (AEDT)", "count" : 3 }
{ "date" : "Wed Oct 14 2015 11:00:00 GMT+1100 (AEDT)", "count" : 2 }
{ "date" : "Thu Oct 15 2015 11:00:00 GMT+1100 (AEDT)", "count" : 2 }
{ "date" : "Fri Oct 16 2015 11:00:00 GMT+1100 (AEDT)", "count" : 0 }
{ "date" : "Sat Oct 17 2015 11:00:00 GMT+1100 (AEDT)", "count" : 3 }
{ "date" : "Sun Oct 18 2015 11:00:00 GMT+1100 (AEDT)", "count" : 0 }
{ "date" : "Mon Oct 19 2015 11:00:00 GMT+1100 (AEDT)", "count" : 0 }
{ "date" : "Tue Oct 20 2015 11:00:00 GMT+1100 (AEDT)", "count" : 0 }
{ "date" : "Wed Oct 21 2015 11:00:00 GMT+1100 (AEDT)", "count" : 2 }
{ "date" : "Thu Oct 22 2015 11:00:00 GMT+1100 (AEDT)", "count" : 1 }

Merk op dat alle "datum" -waarden eigenlijk nog steeds BSON-datums zijn, maar gewoon zo stringificeren in de uitvoer van .printjson() als een shell-methode.

Een wat beknopter voorbeeld kan worden getoond met nodejs waar u bewerkingen kunt gebruiken zoals async.parallel om zowel de hashconstructie als de aggregatiequery tegelijkertijd te verwerken, evenals een ander nuttig hulpprogramma in nedb die de "hash" implementeert met behulp van functies die bekend zijn bij het gebruik van een MongoDB-verzameling. Het laat ook zien hoe dit kan worden geschaald voor grote resultaten door een echte MongoDB-verzameling te gebruiken als u ook de afhandeling hebt gewijzigd om de verwerking van de geretourneerde cursor te streamen van .aggregate() :

var async = require('async'),
    mongodb = require('mongodb'),
    MongoClient = mongodb.MongoClient,
    nedb = require('nedb'),
    DataStore = new nedb();

// Setup vars
var sample = 30,
    Days = 30,
    OneDay = ( 1000 * 60 * 60 * 24 ),
    now = Date.now(),
    Today = now - ( now % OneDay ) ,
    nDaysAgo = Today - ( OneDay * Days ),
    startDate = new Date( nDaysAgo ),
    endDate = new Date( Today + OneDay );

MongoClient.connect('mongodb://localhost/test',function(err,db) {

  var coll = db.collection('datejunk');

  async.series(
    [
      // Clear test collection
      function(callback) {
        coll.remove({},callback)
      },

      // Generate a random sample
      function(callback) {
        var bulk = coll.initializeUnorderedBulkOp();

        while (sample--) {
          bulk.insert({
            "when": new Date(
              Math.floor(
                Math.random()*(Today-nDaysAgo+OneDay)+nDaysAgo
              )
            )
          });
        }
        bulk.execute(callback);
      },

      // Aggregate data and dummy data
      function(callback) {
        console.log("generated");
        async.parallel(
          [
            // Dummy data per day
            function(callback) {
              var thisDay = new Date( nDaysAgo );
              async.whilst(
                function() { return thisDay < endDate },
                function(callback) {
                  DataStore.update(
                    { "date": thisDay },
                    { "$inc": { "count": 0 } },
                    { "upsert": true },
                    function(err) {
                      thisDay = new Date( thisDay.valueOf() + OneDay );
                      callback(err);
                    }
                  );
                },
                callback
              );
            },
            // Aggregate data in collection
            function(callback) {
              coll.aggregate(
                [
                  { "$match": { "when": { "$gte": startDate } } },
                  { "$group": {
                    "_id": {
                      "$add": [
                        { "$subtract": [
                          { "$subtract": [ "$when", new Date(0) ] },
                          { "$mod": [
                            { "$subtract": [ "$when", new Date(0) ] },
                            OneDay
                          ]}
                        ]},
                        new Date(0)
                      ]
                    },
                    "count": { "$sum": 1 }
                  }}
                ],
                function(err,results) {
                  if (err) callback(err);
                  async.each(results,function(result,callback) {
                    DataStore.update(
                      { "date": result._id },
                      { "$inc": { "count": result.count } },
                      { "upsert": true },
                      callback
                    );
                  },callback);
                }
              );
            }
          ],
          callback
        );
      }
    ],
    // Return result or error
    function(err) {
      if (err) throw err;
      DataStore.find({},{ "_id": 0 })
        .sort({ "date": 1 })
        .exec(function(err,results) {
        if (err) throw err;
        console.log(results);
        db.close();
      });
    }
  );

});

Dit is zeer geschikt voor gegevens voor grafieken en diagrammen. De basisprocedure is hetzelfde voor elke taalimplementatie en wordt idealiter parallel verwerkt voor de beste prestaties, dus async- of threaded-omgevingen geven u een echte bonus, ook al kan voor een klein voorbeeld als dit de basishashtabel zeer snel in het geheugen worden gegenereerd van uw omgeving vereist opeenvolgende bewerkingen.

Probeer de database dus niet te forceren om dit te doen. Er zijn zeker voorbeelden van SQL-query's die deze "samenvoeging" op de databaseserver doen, maar het was daar nooit echt een geweldig idee en zou echt moeten worden afgehandeld met een soortgelijk "client"-samenvoegproces, omdat het alleen maar database-overhead creëert, wat echt niet zo is t vereist.

Het is allemaal erg efficiënt en praktisch voor het doel, en het vereist natuurlijk niet de verwerking van een afzonderlijke aggregatiequery voor elke dag in de periode, wat helemaal niet efficiënt zou zijn.




  1. Alle records zoeken die een bepaald subveld bevatten in mongodb

  2. Wat is gedistribueerde atoomvergrendeling in cachestuurprogramma's?

  3. Identificeer het laatste document van MongoDB find() resultatenset

  4. Hoe wordt Redis gebruikt in Trello?