Question

I have a collection of entities, which represents a tree. Each entity has a property containing an array of attributes.

For example:

{
    "_id" : 1,
    "parent_id" : null,
    "attributes" : [ "A", "B", "C" ]
}

I would like to use MapReduce to generate another collection which is similar to the original collection, but for each item in the collection it not only contains the attributes directly associated with the entity, but also those of its ancestors, all the way up to the root of the hiearchy.

So given the following entities:

{
    "_id" : 1,
    "parent_id" : null,
    "attributes" : [ "A", "B", "C" ]
}

{
    "_id" : 2,
    "parent_id" : 1,
    "attributes" : [ "D", "E", "F" ]
}

{
    "_id" : 3,
    "parent_id" : 2,
    "attributes" : [ "G", "H", "I" ]
}

The result of the MapReduce job would be the following:

{
    "_id" : 1,
    "attributes" : [ "A", "B", "C" ]
}

{
    "_id" : 2,
    "attributes" : [ "A", "B", "C", "D", "E", "F" ]
}

{
    "_id" : 3,
    "attributes" : [ "A", "B", "C", "D", "E", "F", "G", "H", "I" ]
}

I’ve managed produce MapReduce jobs which do simple things like count the attributes for each entity but can’t get my head round how I might deal with a hierarchy. I am open to alternative ways of storing the data but don’t want to store the whole hierarchy in a single document.

Is this kind of thin possible with MapReduce in MongoDB or am I just thinking about the problem in the wrong way?

Answer 1

Ok, so I don’t think this will be very performant/scalable, because you have to recursively find the parent ids from the child nodes. However, it does provide the output you want.

var mapFunc = function(doc, id) {
  // if this is being invoked by mapReduce, it won't pass any parameters 
  if(doc == null) {
    doc = this; 
    id = this._id; 
  } else if (doc.parent_id != null) {
    // if this is a recursive call, find the parent
    doc = db.test.findOne({_id:doc.parent_id});
  }
  // emit the id, which is always the id of the child node (starting point), and the attributes
  emit(id, {attributes: doc.attributes}); 
  // if parent_id is not null, call mapFunc with the hidden parameters
  if(doc.parent_id != null) {
    // recursive mapFunc call
    mapFunc(doc, id); 
  } 
}
// since we're going to call this from within mapReduce recursively, we have to save it in the system JS
db.system.js.save({ "_id" : "mapFunc", "value" : mapFunc});

var reduceFunc = function(key, values) {
  var result = {attributes:[]}; 
  values.forEach(function(value) {
    // concat the result to the new values (I don't think order is guaranteed here)
    result.attributes = value.attributes.concat(result.attributes);
  }); 
  return result; 
}

// this just moves the attributes up a level
var finalize = function(key, value) {return value.attributes};

// quick test...
db.test.mapReduce(mapFunc, reduceFunc, {out: {inline: 1}, finalize: finalize});

Provides:

"results" : [
    {
        "_id" : 1,
        "value" : [
            "A",
            "B",
            "C"
        ]
    },
    {
        "_id" : 2,
        "value" : [
            "A",
            "B",
            "C",
            "D",
            "E",
            "F"
        ]
    },
    {
        "_id" : 3,
        "value" : [
            "A",
            "B",
            "C",
            "D",
            "E",
            "F",
            "G",
            "H",
            "I"
        ]
    }
],
"timeMillis" : 2,
"counts" : {
    "input" : 3,
    "emit" : 6,
    "reduce" : 2,
    "output" : 3
},
"ok" : 1,
}