map_reduce.MapReduceCommand.scala Maven / Gradle / Ivy
/**
* Copyright (c) 2010 MongoDB, Inc.
* Copyright (c) 2009, 2010 Novus Partners, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* For questions and comments about this product, please see the project page at:
*
* http://github.com/mongodb/casbah
*
*/
package com.mongodb.casbah
package map_reduce
import scala.concurrent.duration.Duration
import com.mongodb.casbah.Imports._
class MapReduceException(msg: String) extends MongoException("MongoDB Map/Reduce Error: " + msg)
trait MapReduceOutputTarget
case class MapReduceStandardOutput(collection: String) extends MapReduceOutputTarget
case class MapReduceMergeOutput(collection: String) extends MapReduceOutputTarget
case class MapReduceReduceOutput(collection: String) extends MapReduceOutputTarget
case object MapReduceInlineOutput extends MapReduceOutputTarget
/**
* Case class for invoking MongoDB mapReduces.
*
* This wrapper class is used in it's place, and passed directly to a db.runCommand call.
*
* @see The MongoDB Map/Reduce Documentation
*
* @param input the collection name to run the map reduce on
* @param map the map function (JSFunction is just a type alias for String)
* @param reduce the reduce function (JSFunction is just a type alias for String)
* @param output (optional) the location of the result of the map-reduce operation, defaults to inline.
* You can output to a collection, output to a collection with an action, or output inline.
* @param query (optional) the selection criteria for the documents input to the map function.
* @param sort (optional) the input documents, useful for optimization.
* @param limit (optional) the maximum number of documents to return from the collection before map reduce
* @param finalizeFunction (optional) the finalize function (JSFunction is just a type alias for String)
* @param jsScope (optional) global variables that are accessible in the map, reduce and finalize functions
* @param verbose (optional) include the timing information in the result information
* @param maxTime (optional) the maximum duration that the server will allow this operation to execute before killing it
*/
case class MapReduceCommand protected[mongodb] (input: String = "", map: JSFunction = "", reduce: JSFunction = "",
output: MapReduceOutputTarget = MapReduceInlineOutput,
query: Option[DBObject] = None, sort: Option[DBObject] = None,
limit: Option[Int] = None, finalizeFunction: Option[JSFunction] = None,
jsScope: Option[DBObject] = None, verbose: Boolean = false,
maxTime: Option[Duration] = None) {
// scalastyle:off null cyclomatic.complexity method.length
def toDBObject: DBObject = {
val dataObj = MongoDBObject.newBuilder
input match {
case "" => throw new MapReduceException("input must be defined.")
case null => throw new MapReduceException("input must be defined.")
case other => dataObj += "mapreduce" -> input
}
map match {
case "" => throw new MapReduceException("map must be defined.")
case null => throw new MapReduceException("map must be defined.")
case other => dataObj += "map" -> map.toString
}
reduce match {
case "" => throw new MapReduceException("reduce must be defined.")
case null => throw new MapReduceException("reduce must be defined.")
case other => dataObj += "reduce" -> reduce.toString
}
dataObj += "verbose" -> verbose
dataObj += "out" -> (output match {
case MapReduceStandardOutput(coll: String) => coll
case MapReduceMergeOutput(coll: String) => MongoDBObject("merge" -> coll)
case MapReduceReduceOutput(coll: String) => MongoDBObject("reduce" -> coll)
case MapReduceInlineOutput => MongoDBObject("inline" -> true)
case other => throw new IllegalArgumentException("Invalid Output Type '%s'".format(other))
})
query match {
case Some(q) => dataObj += "query" -> q
case None => {}
}
sort match {
case Some(s) => dataObj += "sort" -> s
case None => {}
}
limit match {
case Some(i) => dataObj += "limit" -> i
case None => {}
}
finalizeFunction match {
case Some(fF) => dataObj += "finalize" -> fF.toString
case None => {}
}
jsScope match {
case Some(s) => dataObj += "scope" -> s
case None => {}
}
maxTime match {
case Some(mD) => dataObj += "maxTimeMS" -> mD.toMillis
case None => {}
}
dataObj.result()
}
override def toString: String = toDBObject.toString
}