gmongo MapReducer with Finalizer

Question

I do not know how to set Finalizer when using gmongo. My 'reduce' contains an Array that I want to use in 'Finalize'

Map and Reduce are as shown below

String map="""
  function map(){
  key = this.vendor
  var inSec=Math.round(this.timeTook/1000*100)/100
  value= {response_time:[inSec]}
  emit(key, value)
}
"""
String reduce = """
    function reduce(key,values){
      var call_list={response_time:[]}
      var count = 0
      var total=0
      for (var i in values){
        call_list.response_time=values[i].response_time.concat(call_list.response_time)
      }
      call_list.response_time= call_list.response_time.sort(function(a,b){return a-b})
      return call_list
    }
"""
        String collection="mapreduceresult"

When I invoke mapreduce as below, I get an error - query too large

            MapReduceCommand cmd = new MapReduceCommand(logCollection, map,reduce,null,MapReduceCommand.OutputType.MERGE,null)
            cmd.setOutputDB(collection)
            cmd.setFinalize(finalizer) //- wanted to use Finalize as the reducer returns an Array
            logCollection.mapReduce(cmd) //This is giving an error - Query is too large..

Only this is working for me but do not know how to set Finalize

   logCollection.mapReduce(map,reduce,collection,[:])

Answer 1

take a look at this working example, the finalize function is just converting the number to a String:

@Grab(group='com.gmongo', module='gmongo', version='1.2')
import com.gmongo.GMongo
import com.mongodb.MapReduceCommand
import com.mongodb.BasicDBObject

def mongo = new GMongo()
def db = mongo.getDB("gmongo")

def words = ['foo', 'bar', 'baz']
def rand  = new Random()        

db.words.drop()

1000.times { 
    db.words << [word: words[rand.nextInt(3)]]
}

assert db.words.count() == 1000

def map = """
    function map() {
        emit(this.word, {count: 1})
    }
    """

def reduce = """
    function reduce(key, values) {
        var count = 0
        for (var i = 0; i < values.length; i++)
            count += values[i].count
        return {count: count}
    }
    """

def finalize = """
    function finalize(key, reducedValue) {
        return {count: reducedValue.count.toString()}
    }
    """

def command = new MapReduceCommand(db.words, map, reduce, 'mrresult', MapReduceCommand.OutputType.REPLACE, new BasicDBObject())

command.setFinalize(finalize)

db.words.mapReduce(command)

println db.mrresult.findOne()