Em vez de tentar forçar o banco de dados a retornar resultados para dados que não existem, é uma prática melhor gerar os dados em branco externos à consulta e mesclar os resultados neles. Dessa forma, você tem suas entradas "0" onde não há dados e permite que o banco de dados retorne o que está lá.
A mesclagem é um processo básico de criação de uma tabela com hash de chaves exclusivas e a simples substituição de qualquer um dos valores encontrados nos resultados da agregação nessa tabela de hash. Em JavaScript, um objeto básico serve bem, pois todas as chaves são únicas.
Eu também prefiro retornar uma
Date objeto dos resultados de agregação usando a matemática de data para manipular e "arredondar" a data para o intervalo necessário, em vez de usar os operadores de agregação de data. Você pode manipular datas usando $subtract
para transformar o valor em uma representação numérica de carimbo de data/hora subtraindo de outra data com o valor de data de época e o $mod
operador para obter o restante e arredondar a data para o intervalo necessário. Em contraste, usando
$add
com um objeto de data de época semelhante transformará um valor inteiro de volta em uma data BSON. E é claro que é muito mais eficiente processar diretamente para o $group
em vez de usar um $project separado
stage, pois você pode simplesmente processar as datas modificadas diretamente no agrupamento _id valor de qualquer maneira. Como um exemplo de shell:
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] })
});
Que retornará todos os dias no intervalo, incluindo
0 valores onde não existem dados, como:{ "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 }
Observando que todos os valores de "data" ainda são datas BSON, mas apenas stringifique assim na saída de
.printjson() como um método de shell. Um exemplo um pouco mais conciso pode ser mostrado usando
nodejs onde você pode utilizar operações como async.parallel
para processar a construção de hash e a consulta de agregação ao mesmo tempo, bem como outro utilitário útil em nedb
que implementa o "hash" usando funções familiares ao uso de uma coleção do MongoDB. Ele também mostra como isso pode ser dimensionado para grandes resultados usando uma coleção real do MongoDB se você também alterou a manipulação para o processamento de fluxo do cursor retornado de .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();
});
}
);
});
Isso é muito adequado para dados para tabelas e gráficos. O procedimento básico é o mesmo para qualquer implementação de linguagem e idealmente feito em processamento paralelo para melhor desempenho, então ambientes assíncronos ou encadeados oferecem um bônus real, mesmo que para uma pequena amostra como essa a tabela de hash básica possa ser gerada na memória muito rapidamente do seu ambiente requer operações sequenciais.
Portanto, não tente forçar o banco de dados a fazer isso. Certamente existem exemplos de consultas SQL que fazem essa "mesclagem" no servidor de banco de dados, mas nunca foi realmente uma ótima ideia e realmente deve ser tratada com um processo de mesclagem "cliente" semelhante, pois está apenas criando uma sobrecarga de banco de dados que realmente não é necessário.
É tudo muito eficiente e prático para o propósito, e claro que não requer o processamento de uma consulta de agregação separada para cada dia do período, o que não seria nada eficiente.
