Example usage for com.mongodb DBCollection mapReduce

Introduction

In this page you can find the example usage for com.mongodb DBCollection mapReduce.

Prototype

public MapReduceOutput mapReduce(final MapReduceCommand command) 

Source Link

Document

Allows you to run map-reduce aggregation operations over a collection.

Usage

From source file:mongosensors_server.MongoTools.java

License:Open Source License

public MapReduceOutput mongoMapReduce(String collection, String map, String reduce, DBObject query) {
    DBCollection col = db.getCollection(collection);
    MapReduceCommand cmd = new MapReduceCommand(col, map, reduce, null, MapReduceCommand.OutputType.INLINE,
            query);/*from w w  w .  j av  a 2 s  .co m*/
    return col.mapReduce(cmd);
}

---

From source file:org.aw20.mongoworkbench.command.MapReduceMongoCommand.java

License:Open Source License

@SuppressWarnings("deprecation")
@Override//from w  ww .  j a  v a  2 s  . c  om
public void execute() throws Exception {
    MongoClient mdb = MongoFactory.getInst().getMongo(sName);

    if (mdb == null)
        throw new Exception("no server selected");

    if (sDb == null)
        throw new Exception("no database selected");

    MongoFactory.getInst().setActiveDB(sDb);

    DB db = mdb.getDB(sDb);
    BasicDBObject cmdMap = parseMongoCommandString(db, cmd);

    if (!cmdMap.containsField("mapreduceArgs"))
        throw new Exception("no mapReduce document");

    DBCollection collection = db.getCollection(sColl);

    // Build the Map
    BasicDBObject options = (BasicDBObject) ((BasicDBList) cmdMap.get("mapreduceArgs")).get(2);

    String outputCollection = null;
    String outputDB = null;
    MapReduceCommand.OutputType outputType = MapReduceCommand.OutputType.INLINE;

    if (options.get("out") instanceof String) {
        outputCollection = (String) options.get("out");
        outputType = MapReduceCommand.OutputType.REPLACE;
    } else if (options.get("out") instanceof BasicDBObject) {
        BasicDBObject out = (BasicDBObject) options.get("out");

        if (out.containsField("inline")) {
            outputCollection = null;
        } else if (out.containsField("replace")) {
            outputCollection = (String) out.get("replace");
            outputType = MapReduceCommand.OutputType.REPLACE;
        } else if (out.containsField("merge")) {
            outputCollection = (String) out.get("merge");
            outputType = MapReduceCommand.OutputType.MERGE;
        } else if (out.containsField("reduce")) {
            outputCollection = (String) out.get("reduce");
            outputType = MapReduceCommand.OutputType.REDUCE;
        }

        if (out.containsField("db"))
            outputDB = (String) out.get("db");
    }

    MapReduceCommand mrc = new MapReduceCommand(collection,
            ((Code) ((BasicDBList) cmdMap.get("mapreduceArgs")).get(0)).getCode(),
            ((Code) ((BasicDBList) cmdMap.get("mapreduceArgs")).get(1)).getCode(), outputCollection, outputType,
            (BasicDBObject) options.get("query"));

    if (outputDB != null)
        mrc.setOutputDB(outputDB);

    if (options.containsField("sort") && options.get("sort") instanceof DBObject)
        mrc.setSort((DBObject) options.get("sort"));

    if (options.containsField("scope") && options.get("scope") instanceof DBObject)
        mrc.setScope(((DBObject) options.get("scope")).toMap());

    if (options.containsField("finalize") && options.get("scope") instanceof Code)
        mrc.setFinalize(((Code) options.get("scope")).getCode());

    if (options.containsField("limit"))
        mrc.setLimit(StringUtil.toInteger(options.get("limit"), -1));

    mrc.addExtraOption("jsMode", StringUtil.toBoolean(options.get("jsMode"), false));
    mrc.setVerbose(StringUtil.toBoolean(options.get("verbose"), false));

    // Run the actual mapreduce function
    MapReduceOutput mro = collection.mapReduce(mrc);

    // Pull the inline results
    if (mro.getOutputCollection() == null) {
        dbListResult = new BasicDBList();
        Iterable<DBObject> it = mro.results();
        for (DBObject dbo : it) {
            dbListResult.add(dbo);
        }
    }

    BasicDBObject dbo = mro.getRaw();
    StringBuilder sb = new StringBuilder();

    if (dbo.containsField("timeMillis"))
        sb.append("Time=").append(dbo.get("timeMillis")).append("ms; ");

    if (dbo.containsField("counts")) {
        BasicDBObject counts = (BasicDBObject) dbo.get("counts");
        sb.append("Counts: input=" + counts.get("input"));
        sb.append("; emit=" + counts.get("emit"));
        sb.append("; reduce=" + counts.get("reduce"));
        sb.append("; output=" + counts.get("output"));
    }

    setMessage(sb.toString());
}

---

From source file:org.basex.modules.MongoDB.java

License:BSD License

/**
 * Mongodb Mapreduce function with 3 parameters, Map, reduce and query Option.
 * @param handler Database Handler.//from   w  ww  .  jav a 2  s. c om
 * @param col Collection name
 * @param map Map method
 * @param reduce Reduce Method
 * @param query Selection options.
 * @return Items.
 * @throws Exception
 */
public Item mapreduce(final Str handler, final Str col, final Str map, final Str reduce, final Item finalalize,
        final Item query, final Map options) throws Exception {
    final DB db = getDbHandler(handler);
    if (map == null) {
        throw MongoDBErrors.generalExceptionError("Map function cannot be empty in Mapreduce");
    }
    final DBObject q = query != null ? getDbObjectFromStr(query) : null;
    final DBCollection collection = db.getCollection(itemToString(col));
    String out = null;
    String outType = null;
    OutputType op = MapReduceCommand.OutputType.INLINE;
    if (options != null) {
        for (Item k : options.keys()) {
            String key = (String) k.toJava();
            if (key.equals("outputs")) {
                out = (String) options.get(k, null).toJava();
            }
            if (key.equals("outputype")) {
                outType = (String) options.get(k, null).toJava();
            }
        }
        if (out != null) {
            if (outType.toUpperCase().equals("REPLACE")) {
                op = MapReduceCommand.OutputType.REPLACE;
            } else if (outType.toUpperCase().equals("MERGE")) {
                op = MapReduceCommand.OutputType.MERGE;
            } else if (outType.toUpperCase().equals("REDUCE")) {
                op = MapReduceCommand.OutputType.REDUCE;
            }
        }
    }
    db.requestStart();
    try {
        MapReduceCommand cmd = new MapReduceCommand(collection, map.toJava(), reduce.toJava(), out, op, q);
        if (finalalize != null) {
            cmd.setFinalize((String) finalalize.toJava());
        }
        final MapReduceOutput outcmd = collection.mapReduce(cmd);
        return returnResult(handler, Str.get(JSON.serialize(outcmd.results())));
    } catch (MongoException e) {
        throw MongoDBErrors.generalExceptionError(e);
    } finally {
        db.requestDone();
    }
}

---

From source file:org.basex.modules.MongoDB.java

License:BSD License

/**
 * Mapreduce all functions in xquery's Map like :{"map":"function(){..}"
 * , "reduce":"function(){}"}.//  w  ww. ja  v a 2s  .com
 * @param handler
 * @param col collection name
 * @param options all options of Mapreduce including "map" in key.
 * @return
 * @throws Exception
 */
public Item mapreduce(final Str handler, final Str col, final Map options) throws Exception {
    if (options == null) {
        throw MongoDBErrors.generalExceptionError("Map optoins are empty");
    }
    final DB db = getDbHandler(handler);
    final DBCollection collection = db.getCollection(itemToString(col));
    String out = null;
    String outType = null;
    String map = null;
    String reduce = null;
    DBObject query = null;
    DBObject sort = null;
    int limit = 0;
    String finalalize = null;
    OutputType op = MapReduceCommand.OutputType.INLINE;
    for (Item k : options.keys()) {
        String key = (String) k.toJava();
        Value val = options.get(k, null);
        String value = (String) val.toJava();
        if (key.toLowerCase().equals("map")) {
            map = (String) value;
        } else if (key.toLowerCase().equals("reduce")) {
            reduce = value;
        } else if (key.toLowerCase().equals("outputs")) {
            out = value;
        } else if (key.toLowerCase().equals("outputype")) {
            outType = value;
        } else if (key.toLowerCase().equals("limit")) {
            if (val.type().instanceOf(SeqType.ITR_OM)) {
                long l = ((Item) val).itr(null);
                limit = (int) l;
            } else {
                throw MongoDBErrors.generalExceptionError(" Expected integer Value");
            }
        } else if (key.toLowerCase().equals(SORT)) {
            sort = getDbObjectFromStr(Str.get(value));
        } else if (key.toLowerCase().equals(QUERY)) {
            query = getDbObjectFromStr(Str.get(value));
        } else if (key.toLowerCase().equals(FINALIZE)) {
            finalalize = value;
        }
    }
    if (out != null && outType != null) {
        if (outType.toUpperCase().equals("REPLACE")) {
            op = MapReduceCommand.OutputType.REPLACE;
        } else if (outType.toUpperCase().equals("MERGE")) {
            op = MapReduceCommand.OutputType.MERGE;
        } else if (outType.toUpperCase().equals("REDUCE")) {
            op = MapReduceCommand.OutputType.REDUCE;
        }
    } else if (out != null) {
        op = MapReduceCommand.OutputType.REPLACE;
    }
    if (map == null) {
        throw MongoDBErrors.generalExceptionError("Map function cannot be empty");
    }
    db.requestStart();
    try {
        MapReduceCommand cmd = new MapReduceCommand(collection, map, reduce, out, op, query);
        if (finalalize != null) {
            cmd.setFinalize(finalalize);
        }
        if (limit != 0) {
            cmd.setLimit(limit);
        }
        if (sort != null) {
            cmd.setSort(sort);
        }
        final MapReduceOutput outcmd = collection.mapReduce(cmd);
        return returnResult(handler, Str.get(JSON.serialize(outcmd.results())));
    } catch (MongoException e) {
        throw MongoDBErrors.generalExceptionError(e);
    } finally {
        db.requestDone();
    }
}

---

From source file:org.basex.modules.nosql.MongoDB.java

License:BSD License

/**
 * Mongodb Mapreduce function with 5 parameters, Map, reduce and query Option.
 * @param handler database handler/*from   w  w  w.  j  a v  a2  s.  com*/
 * @param col collection name
 * @param map Map method
 * @param reduce Reduce Method
 * @param finalalize mongodb finalize parameter
 * @param query Selection options.
 * @param options additional options
 * @return Item
 * @throws Exception exception
 */
public Item mapreduce(final Str handler, final Str col, final Str map, final Str reduce, final Item finalalize,
        final Item query, final Map options) throws Exception {
    final DB db = getDbHandler(handler);
    if (map == null) {
        throw MongoDBErrors.generalExceptionError("Map function cannot be empty in Mapreduce");
    }
    final DBObject q = query != null ? getDbObjectFromItem(query) : null;
    final DBCollection collection = db.getCollection(itemToString(col));
    String out = null;
    String outType = null;
    OutputType op = MapReduceCommand.OutputType.INLINE;
    if (options != null) {
        for (Item k : options.keys()) {
            String key = (String) k.toJava();
            if (key.equals("outputs")) {
                out = (String) options.get(k, null).toJava();
            }
            if (key.equals("outputype")) {
                outType = (String) options.get(k, null).toJava();
            }
        }
        if (out != null) {
            if (outType.toUpperCase().equals("REPLACE")) {
                op = MapReduceCommand.OutputType.REPLACE;
            } else if (outType.toUpperCase().equals("MERGE")) {
                op = MapReduceCommand.OutputType.MERGE;
            } else if (outType.toUpperCase().equals("REDUCE")) {
                op = MapReduceCommand.OutputType.REDUCE;
            }
        }
    }
    db.requestStart();
    try {
        MapReduceCommand cmd = new MapReduceCommand(collection, map.toJava(), reduce.toJava(), out, op, q);
        if (finalalize != null) {
            cmd.setFinalize((String) finalalize.toJava());
        }
        final MapReduceOutput outcmd = collection.mapReduce(cmd);
        return returnResult(handler, Str.get(JSON.serialize(outcmd.results())));
    } catch (MongoException e) {
        throw MongoDBErrors.generalExceptionError(e);
    } finally {
        db.requestDone();
    }
}

---

From source file:org.basex.modules.nosql.MongoDB.java

License:BSD License

/**
 * Mapreduce all functions in xquery's Map like :{"map":"function(){..}"
 * , "reduce":"function(){}"}./*  ww  w .j a  va 2 s  .c om*/
 * @param handler database handler
 * @param col collection name
 * @param options all options of Mapreduce including "map" in key.
 * @return Item
 * @throws Exception exception
 */
public Item mapreduce(final Str handler, final Str col, final Map options) throws Exception {
    if (options == null) {
        throw MongoDBErrors.generalExceptionError("Map optoins are empty");
    }
    final DB db = getDbHandler(handler);
    final DBCollection collection = db.getCollection(itemToString(col));
    String out = null;
    String outType = null;
    String map = null;
    String reduce = null;
    DBObject query = null;
    DBObject sort = null;
    int limit = 0;
    String finalalize = null;
    OutputType op = MapReduceCommand.OutputType.INLINE;
    for (Item k : options.keys()) {
        String key = (String) k.toJava();
        Value val = options.get(k, null);
        String value = (String) val.toJava();
        if (key.toLowerCase().equals(MAP)) {
            map = value;
        } else if (key.toLowerCase().equals(REDUCE)) {
            reduce = value;
        } else if (key.toLowerCase().equals(OUTPUTS)) {
            out = value;
        } else if (key.toLowerCase().equals(OUTPUTTYPE)) {
            outType = value;
        } else if (key.toLowerCase().equals(LIMIT)) {
            if (val.seqType().instanceOf(SeqType.ITR_OM)) {
                long l = ((Item) val).itr(null);
                limit = (int) l;
            } else {
                throw MongoDBErrors.generalExceptionError(" Expected integer Value");
            }
        } else if (key.toLowerCase().equals(SORT)) {
            sort = getDbObjectFromItem(Str.get(value));
        } else if (key.toLowerCase().equals(QUERY)) {
            query = getDbObjectFromItem(Str.get(value));
        } else if (key.toLowerCase().equals(FINALIZE)) {
            finalalize = value;
        }
    }
    if (out != null && outType != null) {
        if (outType.toUpperCase().equals("REPLACE")) {
            op = MapReduceCommand.OutputType.REPLACE;
        } else if (outType.toUpperCase().equals("MERGE")) {
            op = MapReduceCommand.OutputType.MERGE;
        } else if (outType.toUpperCase().equals("REDUCE")) {
            op = MapReduceCommand.OutputType.REDUCE;
        }
    } else if (out != null) {
        op = MapReduceCommand.OutputType.REPLACE;
    }
    if (map == null) {
        throw MongoDBErrors.generalExceptionError("Map function cannot be empty");
    }
    db.requestStart();
    try {
        MapReduceCommand cmd = new MapReduceCommand(collection, map, reduce, out, op, query);
        if (finalalize != null) {
            cmd.setFinalize(finalalize);
        }
        if (limit != 0) {
            cmd.setLimit(limit);
        }
        if (sort != null) {
            cmd.setSort(sort);
        }
        final MapReduceOutput outcmd = collection.mapReduce(cmd);
        return returnResult(handler, Str.get(JSON.serialize(outcmd.results())));
    } catch (MongoException e) {
        throw MongoDBErrors.generalExceptionError(e);
    } finally {
        db.requestDone();
    }
}

---

From source file:org.eclipse.birt.data.oda.mongodb.internal.impl.MDbOperation.java

License:Open Source License

static MapReduceOutput callMapReduceCmd(DBCollection dbCollection, QueryProperties queryProps)
        throws OdaException {
    if (!queryProps.hasMapReduceCommand())
        return null;
    DBObject command = queryProps.getOperationExprAsParsedObject(false);
    if (command == null)
        return null;

    // check if mapreduce key is already specified in user-defined expression
    DBObject mapReduceCmd;/*from  www  .j  a va 2  s .  c  o m*/
    if (command.containsField(QueryModel.MAP_REDUCE_CMD_KEY)
            || command.containsField(QueryModel.MAP_REDUCE_CMD_KEY2))
        mapReduceCmd = command;
    else {
        // add MapReduce input collection as first entry in command Map 
        mapReduceCmd = new BasicDBObject(QueryModel.MAP_REDUCE_CMD_KEY, dbCollection.getName());
        mapReduceCmd.putAll(command); // copy existing command entries
    }

    // mapReduce command's optional "limit" parameter applies to the number 
    // of documents in the *input* collection, and thus cannot be used to apply
    // the searchLimit property defined for data set

    // execute the mapreduce command
    MapReduceOutput output;
    try {
        output = dbCollection.mapReduce(mapReduceCmd);
        output.getCommandResult().throwOnError();
        return output;
    } catch (RuntimeException ex) {
        OdaException odaEx = new OdaException(
                Messages.bind(Messages.mDbOp_mapReduceCmdFailed, queryProps.getOperationExpression()));
        odaEx.initCause(ex);
        throw odaEx;
    }
}

---

From source file:org.jeo.mongo.DefaultMapper.java

License:Open Source License

@Override
public Envelope bbox(DBCollection dbcol, MongoDataset data) {
    MapReduceCommand mr = new MapReduceCommand(dbcol, bboxMap, bboxReduce, null, OutputType.INLINE,
            new BasicDBObject());

    BasicDBList list = (BasicDBList) dbcol.mapReduce(mr).getCommandResult().get("results");
    DBObject bbox = (DBObject) ((DBObject) list.get(0)).get("value");

    return new Envelope((Double) bbox.get("x1"), (Double) bbox.get("x2"), (Double) bbox.get("y1"),
            (Double) bbox.get("y2"));
}

---

From source file:org.springframework.data.mongodb.core.MongoTemplate.java

License:Apache License

public <T> MapReduceResults<T> mapReduce(Query query, String inputCollectionName, String mapFunction,
        String reduceFunction, MapReduceOptions mapReduceOptions, Class<T> entityClass) {

    String mapFunc = replaceWithResourceIfNecessary(mapFunction);
    String reduceFunc = replaceWithResourceIfNecessary(reduceFunction);
    DBCollection inputCollection = getCollection(inputCollectionName);

    MapReduceCommand command = new MapReduceCommand(inputCollection, mapFunc, reduceFunc,
            mapReduceOptions.getOutputCollection(), mapReduceOptions.getOutputType(),
            query == null || query.getQueryObject() == null ? null
                    : queryMapper.getMappedObject(query.getQueryObject(), null));

    copyMapReduceOptionsToCommand(query, mapReduceOptions, command);

    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Executing MapReduce on collection [{}], mapFunction [{}], reduceFunction [{}]",
                command.getInput(), mapFunc, reduceFunc);
    }//from   w ww.  j a v a 2 s.c o  m

    MapReduceOutput mapReduceOutput = inputCollection.mapReduce(command);

    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("MapReduce command result = [{}]", serializeToJsonSafely(mapReduceOutput.results()));
    }

    List<T> mappedResults = new ArrayList<T>();
    DbObjectCallback<T> callback = new ReadDbObjectCallback<T>(mongoConverter, entityClass,
            inputCollectionName);

    for (DBObject dbObject : mapReduceOutput.results()) {
        mappedResults.add(callback.doWith(dbObject));
    }

    return new MapReduceResults<T>(mappedResults, mapReduceOutput);
}

---

• «
• 1
• 2
• »