Calculate amount of value changes in MongoDB - mongodb

Question

I have a database for example:
{ "_id": ObjectId("54575132a8269c77675ace49"),"power": false, "time": 1415008560000}
{ "_id": ObjectId("54575132a8269c77675ace50"),"power": true, "time": 1415008570000}
{ "_id": ObjectId("54575132a8269c77675ace51"),"power": false, "time": 1415008580000}
{ "_id": ObjectId("54575132a8269c77675ace52"),"power": false, "time": 1415008590000}
{ "_id": ObjectId("54575132a8269c77675ace53"),"power": true, "time": 1415008600000}
{ "_id": ObjectId("54575132a8269c77675ace54"),"power": false, "time": 1415008610000}
How can I calculate amount of power changes from true to false and opposite?
I could iterate through all entries and increase some variable if previous value is different than actual, but how to do this in mongo?
For this example result should be 4

Answer 1

You could use the aggregation framework to do this:
db.yourCollection.aggregate({ $group:{ _id:"$power", count:{$sum:1} } })
which should give you the following result:
{_id:true,count:2}
{_id:false, count:4}
By subtracting the difference of those two values from the total document count (db.yourCollection.count()), you should have the number of state changes:
var cursor = db.yourCollection.aggregate({ $group:{ _id:"$power", count:{$sum:1} } });
var count = db.yourCollection.count();
var changes = count - Math.abs(cursor[0].count - cursor[1].count);
EDIT: Revised approach
As per #JohhnyHK's sharp eye, he found a problem with the above. All kudos, upvotes and alike to him.
Calculating the number of changes
In order to calculate the changes even for large collections efficiently, with the given constraints, once could use map/reduce to count the changes, which should be pretty efficient even for very large collections.
var numberOfStateChanges = db.yourCollection.mapReduce(
// Mapping function
function(){
// Since in the sample data, there is no reasonable
// field for a key, we use an artificial one: 0
emit(0,this.power);
},
// Reduce function
function(key,values){
// The initial number of changes is 0
var changes=0;
// Our initial state, which does not count towards the changes,...
var state = values[0];
// ... hence we start to compare with the second item in the values array
for (var idx=1; idx < value.length; idx++){
// In case the current state is different from
// the one we are comparing with it, we have a state change
if(value[idx] != state) {
//... which we count...
changes +=1;
// ...and save.
state=value[idx]
}
}
return changes;
},
{
// We make sure the values are fed into the map function in the correct order
sort:{time:1},
// and return it directly instead of putting it into a collection, so we can process it
out:{inline:1}
}
).results[0].value
Now numberOfStateChanges holds the correct number of state changes.
Note
In order to have this map/reduce to be processed efficiently, we need an index on the field we are sorting by, time:
db.yourCollection.ensureIndex({time:1})