Example usage for com.mongodb MapReduceCommand MapReduceCommand

List of usage examples for com.mongodb MapReduceCommand MapReduceCommand

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

Introduction

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

Prototype

public MapReduceCommand(final DBCollection inputCollection, final String map, final String reduce,
        @Nullable final String outputCollection, final OutputType type, final DBObject query)

Source Link

Document

Represents the command for a map reduce operation Runs the command in REPLACE output type to a named collection

Usage

From source file:govt_import_export.Order.java

private void sort_cars() {
    MongoClient mongo = null;//from  www . j av a  2 s . c o m
    try {
        mongo = new MongoClient("localhost", 27017);
        //get database
    } catch (UnknownHostException | MongoException e) {
    }
    String[] st = new String[10];
    st[0] = "HYUNDAI";
    st[1] = "MARUTISUZUKI";
    st[2] = "NISSAN";
    st[3] = "BAJAJ";
    st[4] = "KTM";
    st[5] = "VOLKSVAGEN";
    DB db = mongo.getDB("AUTOMOBILEXPO");
    DBCollection table;

    ArrayList<Order> arr = new ArrayList<Order>();
    for (int j = 0; j < 6; j++) {
        table = db.getCollection(st[j]);

        if (table.findOne() != null) {
            String map = "function () {" + "emit(this.model,this.Units);" + "}";
            String reduce;
            reduce = "function (key,value) { " + "return Array.sum(value)}";

            MapReduceCommand cmd = new MapReduceCommand(table, map, reduce, null,
                    MapReduceCommand.OutputType.INLINE, null);

            MapReduceOutput out = table.mapReduce(cmd);
            String str;
            for (DBObject o : out.results()) {
                str = o.get("value").toString().trim();
                System.out.println(str);
                int i = 0;
                // var i=(int)(Convert.ToDouble("1.2"));
                //int a = int.Parse("1.2".Split('.')[0]);
                if (!str.equals(null)) {
                    Float f = Float.parseFloat(str);
                    i = (int) Math.ceil(f);
                    arr.add(new Order(o.get("_id").toString(), i) {

                        @Override
                        public int compare(Order o1, Order o2) {
                            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
                        }

                        @Override
                        public int compareTo(Order o) {
                            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
                        }
                    });
                }
            }
        }

    }
    Collections.sort(arr, new Order() {
    });
    for (Order a : arr)
        System.out.println(" " + a.getid() + " " + a.getval());
    this.dispose();
    Sorted s = new Sorted(arr);
    s.setVisible(true);

}

From source file:govt_import_export.export.java

private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton3ActionPerformed
    // TODO add your handling code here:
    JLabel p = new JLabel();
    MongoClient mongo = null;//  w  ww .  ja  v  a2  s .  c  o m
    try {
        mongo = new MongoClient("localhost", 27017);
        //get database
    } catch (UnknownHostException e) {
        e.printStackTrace();
    }

    catch (MongoException e) {
        e.printStackTrace();
    }
    DB db = mongo.getDB("AUTOMOBILEXPO");
    DBCollection table = db.getCollection(manufac);
    String map = "function () {" + "emit(this.model,this.Units);" + "}";
    String reduce = "function (key, values) { " + "return Array.sum(values)}";

    MapReduceCommand cmd = new MapReduceCommand(table, map, reduce, null, MapReduceCommand.OutputType.INLINE,
            null);

    MapReduceOutput out = table.mapReduce(cmd);

    for (DBObject o : out.results()) {
        System.out.println(o.toString());
    }

}

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);//  w ww .  j a  v a 2  s  .  c o m
    return col.mapReduce(cmd);
}

From source file:net.vz.mongodb.jackson.JacksonDBCollection.java

License:Apache License

/**
 * performs a map reduce operation/*from   w  w w. j  a v  a  2s . co m*/
 * Runs the command in REPLACE output mode (saves to named collection)
 *
 * @param map          map function in javascript code
 * @param outputTarget optional - leave null if want to use temp collection
 * @param reduce       reduce function in javascript code
 * @param query        to match
 * @return The output
 * @throws MongoException If an error occurred
 */
public MapReduceOutput mapReduce(String map, String reduce, String outputTarget, DBObject query)
        throws MongoException {
    return mapReduce(new MapReduceCommand(dbCollection, map, reduce, outputTarget,
            MapReduceCommand.OutputType.REPLACE, query));
}

From source file:net.vz.mongodb.jackson.JacksonDBCollection.java

License:Apache License

/**
 * performs a map reduce operation//  w w w.j av a 2s .c o  m
 * Specify an outputType to control job execution
 * * INLINE - Return results inline
 * * REPLACE - Replace the output collection with the job output
 * * MERGE - Merge the job output with the existing contents of outputTarget
 * * REDUCE - Reduce the job output with the existing contents of
 * outputTarget
 *
 * @param map          map function in javascript code
 * @param outputTarget optional - leave null if want to use temp collection
 * @param outputType   set the type of job output
 * @param reduce       reduce function in javascript code
 * @param query        to match
 * @return The output
 * @throws MongoException If an error occurred
 */
public MapReduceOutput mapReduce(String map, String reduce, String outputTarget,
        MapReduceCommand.OutputType outputType, DBObject query) throws MongoException {
    return mapReduce(new MapReduceCommand(dbCollection, map, reduce, outputTarget, outputType, query));
}

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

License:Open Source License

@SuppressWarnings("deprecation")
@Override//from   ww w .  j a v  a  2 s .  co m
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.//  w  ww.  j a v 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(){}"}./*ww  w  .j a va 2s  .c om*/
 * @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//  w  w  w.j  ava  2s. c om
 * @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(){}"}./*from   w w  w.  j  a v a2  s  . co  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();
    }
}