Example usage for com.mongodb MapReduceCommand setLimit

List of usage examples for com.mongodb MapReduceCommand setLimit

  1. HOME
  2. Java
  3. com.mongodb
  4. com.mongodb.*
  5. MapReduceCommand
  6. setLimit

Introduction

In this page you can find the example usage for com.mongodb MapReduceCommand setLimit.

Prototype

public void setLimit(final int limit)

Source Link

Document

Sets the (optional) limit on input

Usage

From source file:com.edgytech.umongo.CollectionPanel.java

License:Apache License

public void mapReduce(final ButtonBase button) {
    final DBCollection col = getCollectionNode().getCollection();
    String map = getStringFieldValue(Item.mrMap);
    String reduce = getStringFieldValue(Item.mrReduce);
    String finalize = getStringFieldValue(Item.mrFinalize);
    String stype = getStringFieldValue(Item.mrType);
    final OutputType type = OutputType.valueOf(stype.toUpperCase());
    String out = getStringFieldValue(Item.mrOut);
    if (type != OutputType.INLINE && (out.isEmpty())) {
        new InfoDialog(id, null, null, "Output collection cannot be empty if type is not inline.").show();
        return;/*from www.  ja v a 2  s  .  co m*/
    }

    String outDB = getStringFieldValue(Item.mrOutDB);
    DBObject query = ((DocBuilderField) getBoundUnit(Item.mrQuery)).getDBObject();
    int limit = getIntFieldValue(Item.mrLimit);
    final MapReduceCommand cmd = new MapReduceCommand(col, map, reduce, out, type, query);
    DBObject sort = ((DocBuilderField) getBoundUnit(Item.mrSort)).getDBObject();
    if (sort != null) {
        cmd.setSort(sort);
    }
    if (!outDB.isEmpty()) {
        cmd.setOutputDB(outDB);
    }
    if (!finalize.isEmpty()) {
        cmd.setFinalize(finalize);
    }
    if (limit > 0) {
        cmd.setLimit(limit);
    }

    if (getBooleanFieldValue(Item.mrJSMode)) {
        cmd.addExtraOption("jsMode", true);
    }

    final BasicDBObject cmdobj = (BasicDBObject) cmd.toDBObject();
    if (getBooleanFieldValue(Item.mrOutSharded)) {
        ((BasicDBObject) cmdobj.get("out")).put("sharded", true);
    }
    if (getBooleanFieldValue(Item.mrNonAtomic)) {
        ((BasicDBObject) cmdobj.get("out")).put("nonAtomic", true);
    }

    new DbJob() {
        MapReduceOutput output;

        @Override
        public Object doRun() {
            //                output = col.mapReduce(cmd);

            // if type in inline, then query options like slaveOk is fine
            CommandResult res = null;
            if (type == MapReduceCommand.OutputType.INLINE) {
                res = col.getDB().command(cmdobj, col.getOptions());
                return res;
            }

            res = col.getDB().command(cmdobj);
            res.throwOnError();
            output = new MapReduceOutput(col, cmdobj, res);
            return output;
        }

        @Override
        public void wrapUp(Object res) {
            if (output != null) {
                if (cmd.getOutputType() == OutputType.INLINE) {
                    res = output.results();
                } else {
                    // spawn a find
                    doFind(output.getOutputCollection(), null);
                    res = output.getRaw();
                }
            }
            super.wrapUp(res);
        }

        @Override
        public String getNS() {
            return col.getFullName();
        }

        @Override
        public String getShortName() {
            return "MR";
        }

        @Override
        public DBObject getRoot(Object result) {
            return cmdobj;
        }

        @Override
        public ButtonBase getButton() {
            return button;
        }

        @Override
        DBObject getCommand() {
            return cmdobj;
        }

        @Override
        DB getDB() {
            return col.getDB();
        }
    }.addJob();
}

From source file:com.hangum.tadpole.mongodb.core.editors.mapreduce.MapReduceEditor.java

License:Open Source License

/**
 * execute map reduce/*from w  w  w. j a v a2s  .c  om*/
 */
private void executeMapReduce() throws Exception {
    String strMap = textMap.getText();
    String strReduce = textReduce.getText();
    String strFinilize = textFinalize.getText();
    String strOutputTarget = textOutputTarget.getText();
    MapReduceCommand.OutputType outputType = (MapReduceCommand.OutputType) comboOutputType
            .getData(comboOutputType.getText());

    DBObject dbQuery = null;
    if (!"".equals(textQuery.getText()))
        dbQuery = (DBObject) JSON.parse(textQuery.getText());

    DBObject dbSort = null;
    if (!"".equals(textSort.getText()))
        dbSort = (DBObject) JSON.parse(textSort.getText());

    //  .
    DBCollection dbCol = MongoDBQuery.findCollection(userDB, initColName);
    MapReduceCommand mrCmd = new MapReduceCommand(dbCol, strMap, strReduce, strOutputTarget, outputType,
            dbQuery);
    if (!"".equals(strFinilize))
        mrCmd.setFinalize(strFinilize);
    if (dbSort != null)
        mrCmd.setSort(dbSort);
    if (getLimit() > 0)
        mrCmd.setLimit(getLimit());
    if (btnJsMode.getSelection())
        mrCmd.addExtraOption("jsMode", true);

    final BasicDBObject searchObj = (BasicDBObject) mrCmd.toDBObject();
    if (btnSharded.getSelection())
        ((BasicDBObject) searchObj.get("out")).put("sharded", true);
    if (btnNoneAtomic.getSelection())
        ((BasicDBObject) searchObj.get("out")).put("nonAtomic", true);

    goMapReduce(dbCol, searchObj, outputType);
}

From source file:com.machinelinking.storage.mongodb.MongoJSONStorageConnection.java

License:Apache License

@Override
public JsonNode processMapReduce(DBObject query, String map, String reduce, int limit) {
    final MapReduceCommand command = new MapReduceCommand(this.collection, map, reduce, null,
            MapReduceCommand.OutputType.INLINE, query);
    command.setLimit(limit);
    final MapReduceOutput out = this.collection.mapReduce(command);
    final DBObject results = (DBObject) out.getCommandResult().get("results");
    return MongoUtils.convertToJsonNode(results);
}

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

License:Open Source License

@SuppressWarnings("deprecation")
@Override/*from  ww w.  j  av 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

/**
 * Mapreduce all functions in xquery's Map like :{"map":"function(){..}"
 * , "reduce":"function(){}"}.//from www. ja v a 2  s.  c  o m
 * @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

/**
 * Mapreduce all functions in xquery's Map like :{"map":"function(){..}"
 * , "reduce":"function(){}"}./*www.  j  ava 2s  . c o  m*/
 * @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.mongodb.morphia.MapReduceOptions.java

License:Apache License

@SuppressWarnings("deprecation")
MapReduceCommand toCommand(final Mapper mapper) {
    if (query.getOffset() != 0 || query.getFieldsObject() != null) {
        throw new QueryException("mapReduce does not allow the offset/retrievedFields query ");
    }/*from  w  w w . j a v  a 2s. co m*/

    final DBCollection dbColl = inputCollection != null
            ? getQuery().getCollection().getDB().getCollection(inputCollection)
            : query.getCollection();
    final String target = outputCollection != null ? outputCollection
            : mapper.getMappedClass(resultType).getCollectionName();

    final MapReduceCommand command = new MapReduceCommand(dbColl, map, reduce, target, outputType,
            query.getQueryObject());
    command.setBypassDocumentValidation(bypassDocumentValidation);
    command.setCollation(collation);
    command.setFinalize(finalize);
    command.setJsMode(jsMode);
    command.setLimit(limit);
    command.setMaxTime(maxTimeMS, TimeUnit.MILLISECONDS);
    command.setOutputDB(outputDB);
    command.setReadPreference(readPreference);
    command.setScope(scope);
    command.setSort(query.getSortObject());
    command.setVerbose(verbose);

    return command;
}

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

License:Apache License

private void copyMapReduceOptionsToCommand(Query query, MapReduceOptions mapReduceOptions,
        MapReduceCommand mapReduceCommand) {

    if (query != null) {
        if (query.getSkip() != 0 || query.getFieldsObject() != null) {
            throw new InvalidDataAccessApiUsageException(
                    "Can not use skip or field specification with map reduce operations");
        }/*www. j  a v a 2s. c o  m*/
        if (query.getLimit() > 0 && mapReduceOptions.getLimit() == null) {
            mapReduceCommand.setLimit(query.getLimit());
        }
        if (query.getSortObject() != null) {
            mapReduceCommand.setSort(queryMapper.getMappedObject(query.getSortObject(), null));
        }
    }

    if (mapReduceOptions.getLimit() != null && mapReduceOptions.getLimit().intValue() > 0) {
        mapReduceCommand.setLimit(mapReduceOptions.getLimit());
    }

    if (mapReduceOptions.getJavaScriptMode() != null) {
        mapReduceCommand.setJsMode(true);
    }
    if (!mapReduceOptions.getExtraOptions().isEmpty()) {
        for (Map.Entry<String, Object> entry : mapReduceOptions.getExtraOptions().entrySet()) {
            ReflectiveMapReduceInvoker.addExtraOption(mapReduceCommand, entry.getKey(), entry.getValue());
        }
    }
    if (mapReduceOptions.getFinalizeFunction() != null) {
        mapReduceCommand
                .setFinalize(this.replaceWithResourceIfNecessary(mapReduceOptions.getFinalizeFunction()));
    }
    if (mapReduceOptions.getOutputDatabase() != null) {
        mapReduceCommand.setOutputDB(mapReduceOptions.getOutputDatabase());
    }
    if (!mapReduceOptions.getScopeVariables().isEmpty()) {
        mapReduceCommand.setScope(mapReduceOptions.getScopeVariables());
    }
}