runCommand vs aggregate method to do aggregation

Question

To run aggregation query it is possible to use either of these:

db.collectionName.aggregate(query1);

OR

db.runCommand(query2)

But I noticed something bizarre this morning. While this:

db.runCommand(

{
   "aggregate":"collectionName",
    allowDiskUse: true,
   "pipeline":[
      {
         "$match":{
            "field":param


         }
      }

   ]
});

fails with error:

{
    "ok" : 0.0,
    "errmsg" : "aggregation result exceeds maximum document size (16MB)",
    "code" : 16389,
    "codeName" : "Location16389"
}

This:

db.collectionName.aggregate([

{
  $match: {
           field: param
   }
}

])

is working (gives the expected aggregation result).

How is this possible?

That does seem odd. If you try with a different aggregation (one which returns less data), is there anything different about the two routes - for example does one of them try to bundle up the aggregation results into a single document? — Vince Bowdren, May 03 '18 at 11:49
Technically, the second one returns a [cursor](https://docs.mongodb.com/manual/reference/method/db.collection.aggregate/), not a list of documents. It's that level of detail that might explain the differences you're seeing. — Vince Bowdren, May 03 '18 at 12:02

Neil Lunn · Accepted Answer · 2018-05-03T12:20:40.020

Well the difference is of course that the .aggregate() method returns a "cursor", where as the options you are providing to runCommand() you are not. This actually was the legacy form which returned the response as a single BSON document with all it's limitations. Cursors on the other hand do not have the limitation.

Of course you can use the runCommand() method to "make your own cursor" with the shell, since after-all that is exactly what the .aggregate() method is doing "under the covers". The same goes for all drivers, which essentially invoke the database command for everything.

With the shell, you can transform your request like this:

var cmdRes = db.runReadCommand({
   "aggregate": "collectionName",
   "allowDiskUse": true,
   "pipeline":[
      {
         "$match":{
            "field":param
         }
      }
   ],
   "cursor": { "batchSize": 25 }
});

var cursor = new DBCommandCursor(db, cmdRes);

cursor.next();   // will actually iterate the cursor

If you really want to dig into it then type in db.collectionName.aggregate without the parenthesis () so you actually print the function definition. This will show you some other function calls and you can dig further into them and eventually see what is effectively the lines shown above, amongst a lot of other stuff.

But the way you ran it, it's a "single BSON Document" response. Run it the way shown here, and you get the same "cursor" response.

Thanks it really makes sense. Unfortunately I am running the query from jasper and jasper does not know how to read the cursor returned from runCommand :( — dsharew, May 03 '18 at 12:09

runCommand vs aggregate method to do aggregation

1 Answers1