All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.github.jmkgreen.morphia.DatastoreImpl Maven / Gradle / Ivy

    The newest version!
    package com.github.jmkgreen.morphia;

import com.github.jmkgreen.morphia.annotations.*;
import com.github.jmkgreen.morphia.indexing.TextIndexCommand;
import com.github.jmkgreen.morphia.logging.Logr;
import com.github.jmkgreen.morphia.logging.MorphiaLoggerFactory;
import com.github.jmkgreen.morphia.mapping.MappedClass;
import com.github.jmkgreen.morphia.mapping.MappedField;
import com.github.jmkgreen.morphia.mapping.Mapper;
import com.github.jmkgreen.morphia.mapping.MappingException;
import com.github.jmkgreen.morphia.mapping.cache.EntityCache;
import com.github.jmkgreen.morphia.mapping.lazy.DatastoreHolder;
import com.github.jmkgreen.morphia.mapping.lazy.proxy.ProxyHelper;
import com.github.jmkgreen.morphia.query.Query;
import com.github.jmkgreen.morphia.query.QueryException;
import com.github.jmkgreen.morphia.query.QueryImpl;
import com.github.jmkgreen.morphia.query.UpdateException;
import com.github.jmkgreen.morphia.query.UpdateOperations;
import com.github.jmkgreen.morphia.query.UpdateOpsImpl;
import com.github.jmkgreen.morphia.query.UpdateResults;
import com.github.jmkgreen.morphia.utils.Assert;
import com.github.jmkgreen.morphia.utils.IndexDirection;
import com.github.jmkgreen.morphia.utils.IndexFieldDef;
import com.mongodb.BasicDBObject;
import com.mongodb.BasicDBObjectBuilder;
import com.mongodb.CommandResult;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBDecoderFactory;
import com.mongodb.DBObject;
import com.mongodb.DBRef;
import com.mongodb.MapReduceCommand;
import com.mongodb.MapReduceCommand.OutputType;
import com.mongodb.MapReduceOutput;
import com.mongodb.Mongo;
import com.mongodb.MongoException;
import com.mongodb.WriteConcern;
import com.mongodb.WriteResult;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * A generic (type-safe) wrapper around mongodb collections.
 *
 * @author Scott Hernandez
 */
@SuppressWarnings({"unchecked", "deprecation"})
public class DatastoreImpl implements Datastore, AdvancedDatastore {
    /**
     *
     */
    private static final Logr log = MorphiaLoggerFactory.get(DatastoreImpl.class);

    /**
     *
     */
    protected Mapper mapr;

    /**
     *
     */
    protected Mongo mongo;

    /**
     *
     */
    protected DB db;

    /**
     *
     */
    protected WriteConcern defConcern = WriteConcern.SAFE;

    /**
     *
     */
    protected DBDecoderFactory decoderFactory = null;

    /**
     * @param mapr
     * @param mongo
     * @param dbName
     */
    public DatastoreImpl(Mapper mapr, Mongo mongo, String dbName) {
        this.mapr = mapr;
        this.mongo = mongo;
        this.db = mongo.getDB(dbName);

        // VERY discussable
        DatastoreHolder.getInstance().set(this);
    }

    /**
     * @param morphia
     * @param mongo
     */
    public DatastoreImpl(Morphia morphia, Mongo mongo) {
        this(morphia, mongo, null);
    }

    /**
     * @param morphia
     * @param mongo
     * @param dbName
     * @param username
     * @param password
     */
    public DatastoreImpl(Morphia morphia, Mongo mongo, String dbName, String username, char[] password) {
        this(morphia.getMapper(), mongo, dbName);

        if (username != null)
            if (!this.db.authenticate(username, password))
                throw new AuthenticationException("User '" + username
                        + "' cannot be authenticated with the given password for database '" + dbName + "'");

    }

    /**
     * @param morphia
     * @param mongo
     * @param dbName
     */
    public DatastoreImpl(Morphia morphia, Mongo mongo, String dbName) {
        this(morphia.getMapper(), mongo, dbName);
    }

    /**
     * @param db
     * @return
     */
    public Datastore copy(String db) {
        return new DatastoreImpl(mapr, mongo, db);
    }

    /**
     * @param clazz
     * @param id
     * @param 
     * @param 
     * @return
     */
    public  DBRef createRef(Class clazz, V id) {
        if (id == null)
            throw new MappingException("Could not get id for " + clazz.getName());
        return new DBRef(getDB(), getCollection(clazz).getName(), id);
    }

    /**
     * @param entity
     * @param 
     * @return
     */
    public  DBRef createRef(T entity) {
        entity = ProxyHelper.unwrap(entity);
        Object id = getId(entity);
        if (id == null)
            throw new MappingException("Could not get id for " + entity.getClass().getName());
        return createRef(entity.getClass(), id);
    }

    /**
     * @param entity
     * @return
     */
    @Deprecated
    protected Object getId(Object entity) {
        return mapr.getId(entity);
    }

    /**
     * @param entity
     * @param 
     * @return
     */
    @Deprecated // use mapper instead.
    public  Key getKey(T entity) {
        return mapr.getKey(entity);
    }

    /**
     * @param kind
     * @param id
     * @param 
     * @return
     */
    public  WriteResult delete(String kind, T id) {
        DBCollection dbColl = getCollection(kind);
        WriteResult wr = dbColl.remove(BasicDBObjectBuilder.start().add(Mapper.ID_KEY, id).get());
        throwOnError(null, wr);
        return wr;
    }

    /**
     * @param kind
     * @param clazz
     * @param id
     * @param 
     * @param 
     * @return
     */
    public  WriteResult delete(String kind, Class clazz, V id) {
        return delete(find(kind, clazz).filter(Mapper.ID_KEY, id));
    }

    /**
     * @param clazz
     * @param id
     * @param wc
     * @param 
     * @param 
     * @return
     */
    public  WriteResult delete(Class clazz, V id, WriteConcern wc) {
        return delete(createQuery(clazz).filter(Mapper.ID_KEY, id), wc);
    }

    /**
     * @param clazz
     * @param id
     * @param 
     * @param 
     * @return
     */
    public  WriteResult delete(Class clazz, V id) {
        return delete(clazz, id, getWriteConcern(clazz));
    }

    /**
     * @param clazz
     * @param ids
     * @param 
     * @param 
     * @return
     */
    public  WriteResult delete(Class clazz, Iterable ids) {
        Query q = find(clazz).disableValidation().filter(Mapper.ID_KEY + " in", ids);
        return delete(q);
    }

    /**
     * @param entity
     * @param 
     * @return
     */
    public  WriteResult delete(T entity) {
        return delete(entity, getWriteConcern(entity));
    }

    /**
     * @param entity
     * @param wc
     * @param 
     * @return
     */
    public  WriteResult delete(T entity, WriteConcern wc) {
        entity = ProxyHelper.unwrap(entity);
        if (entity instanceof Class)
            throw new MappingException("Did you mean to delete all documents? -- delete(ds.createQuery(???.class))");
        try {
            Object id = getId(entity);
            return delete(entity.getClass(), id, wc);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @param query
     * @param 
     * @return
     */
    public  WriteResult delete(Query query) {
        return delete(query, getWriteConcern(query.getEntityClass()));
    }

    /**
     * @param query
     * @param wc
     * @param 
     * @return
     */
    public  WriteResult delete(Query query, WriteConcern wc) {
        QueryImpl q = (QueryImpl) query;

        DBCollection dbColl = q.getCollection();
        //TODO remove this after testing.
        if (dbColl == null)
            dbColl = getCollection(q.getEntityClass());

        WriteResult wr;

        if (q.getSortObject() != null || q.getOffset() != 0 || q.getLimit() > 0)
            throw new QueryException("Delete does not allow sort/offset/limit query options.");

        if (q.getQueryObject() != null)
            if (wc == null)
                wr = dbColl.remove(q.getQueryObject());
            else
                wr = dbColl.remove(q.getQueryObject(), wc);
        else if (wc == null)
            wr = dbColl.remove(new BasicDBObject());
        else
            wr = dbColl.remove(new BasicDBObject(), wc);

        throwOnError(wc, wr);

        return wr;
    }

    /**
     * @param type
     * @param fields
     * @param 
     */
    public  void ensureIndex(Class type, String fields) {
        ensureIndex(type, null, fields, false, false);
    }

    /**
     * @param clazz
     * @param name
     * @param defs
     * @param unique
     * @param dropDupsOnCreate
     * @param 
     */
    public  void ensureIndex(Class clazz, String name, IndexFieldDef[] defs, boolean unique, boolean dropDupsOnCreate) {
        ensureIndex(clazz, name, defs, unique, dropDupsOnCreate, false);
    }

    /**
     * @param clazz
     * @param name
     * @param fields
     * @param unique
     * @param dropDupsOnCreate
     * @param 
     */
    public  void ensureIndex(Class clazz, String name, String fields, boolean unique, boolean dropDupsOnCreate) {
        ensureIndex(clazz, name, QueryImpl.parseFieldsString(fields, clazz, mapr, true), unique, dropDupsOnCreate, false, false, -1);
    }

    /**
     * @param clazz
     * @param name
     * @param fields
     * @param unique
     * @param dropDupsOnCreate
     * @param background
     * @param 
     */
    public  void ensureIndex(Class clazz, String name, String fields, boolean unique, boolean dropDupsOnCreate, boolean background) {
        ensureIndex(clazz, name, QueryImpl.parseFieldsString(fields, clazz, mapr, true), unique, dropDupsOnCreate, background, false, -1);
    }

    /**
     * This method actually adds indexes to the selected collection.
     *
     * @param clazz The class/collection to index
     * @param name Optional index name
     * @param fields
     * @param unique
     * @param dropDupsOnCreate
     * @param background
     * @param sparse
     */
    protected  void ensureIndex(Class clazz, String name, BasicDBObject fields, boolean unique, boolean dropDupsOnCreate, boolean background, boolean sparse, int expireAfterSeconds) {
        BasicDBObjectBuilder keyOpts = new BasicDBObjectBuilder();
        if (name != null && name.length() > 0) {
            keyOpts.add("name", name);
        }
        if (unique) {
            keyOpts.add("unique", true);
            if (dropDupsOnCreate)
                keyOpts.add("dropDups", true);
        }

        if (background)
            keyOpts.add("background", true);
        if (sparse)
            keyOpts.add("sparse", true);
        if (expireAfterSeconds > -1) {
            keyOpts.add("expireAfterSeconds", expireAfterSeconds);
        }

        DBCollection dbColl = getCollection(clazz);

        BasicDBObject opts = (BasicDBObject) keyOpts.get();
        if (opts.isEmpty()) {
            log.debug("Ensuring index for " + dbColl.getName() + " with keys:" + fields);
            dbColl.ensureIndex(fields);
        } else {
            log.debug("Ensuring index for " + dbColl.getName() + " with keys:" + fields + " and opts:" + opts);
            dbColl.ensureIndex(fields, opts);
        }
    }

    /**
     * @param clazz
     * @param name
     * @param defs
     * @param unique
     * @param dropDupsOnCreate
     * @param background
     */
    @SuppressWarnings({"rawtypes"})
    public void ensureIndex(Class clazz, String name, IndexFieldDef[] defs, boolean unique, boolean dropDupsOnCreate, boolean background) {
        BasicDBObjectBuilder keys = BasicDBObjectBuilder.start();

        for (IndexFieldDef def : defs) {
            String fieldName = def.getField();
            IndexDirection dir = def.getDirection();
            keys.add(fieldName, dir.toIndexValue());
        }

        ensureIndex(clazz, name, (BasicDBObject) keys.get(), unique, dropDupsOnCreate, background, false, -1);
    }

    /**
     * @param type
     * @param name
     * @param dir
     * @param 
     */
    public  void ensureIndex(Class type, String name, IndexDirection dir) {
        ensureIndex(type, new IndexFieldDef(name, dir));
    }

    /**
     * @param type
     * @param fields
     * @param 
     */
    public  void ensureIndex(Class type, IndexFieldDef... fields) {
        ensureIndex(type, null, fields, false, false);
    }

    /**
     * @param type
     * @param background
     * @param fields
     * @param 
     */
    public  void ensureIndex(Class type, boolean background, IndexFieldDef... fields) {
        ensureIndex(type, null, fields, false, false, background);
    }

    /**
     * Causes a (foreground, blocking) index creation across mapped classes.
     * A proxy to {@link #ensureIndexes(boolean)} passing false in.
     */
    public void ensureIndexes() {
        ensureIndexes(false);
    }

    /**
     * Proxy to {@link #ensureIndexes(Class, boolean)} running the task in the foreground.
     *
     * @param clazz The class to index.
     */
    public  void ensureIndexes(Class clazz) {
        ensureIndexes(clazz, false);
    }

    /**
     * @param clazz
     * @param background
     * @param 
     */
    public  void ensureIndexes(Class clazz, boolean background) {
        MappedClass mc = mapr.getMappedClass(clazz);
        ensureIndexes(mc, background);
    }

    /**
     * Proxy to {@link #ensureIndexes(MappedClass, boolean)} for each mapped class.
     *
     * @param background If true, run the indexing in the background; otherwise it's a foreground task.
     */
    public void ensureIndexes(boolean background) {
        for (MappedClass mc : mapr.getMappedClasses()) {
            ensureIndexes(mc, background);
        }
    }

    /**
     * Runs the indexing process for the given mapped class.
     *
     * @param mc The mapped class to index
     * @param background In the background?
     */
    protected void ensureIndexes(MappedClass mc, boolean background) {
        ensureIndexes(mc, background, new ArrayList(), new ArrayList());
    }

    /**
     * @param mc
     * @param background
     * @param parentMCs
     * @param parentMFs
     */
    protected void ensureIndexes(MappedClass mc, boolean background, ArrayList parentMCs, ArrayList parentMFs) {
        if (parentMCs.contains(mc))
            return;

        //skip embedded types
        if (mc.getEmbeddedAnnotation() != null && parentMCs.isEmpty())
            return;

        ensureIndexesFromClassAnnotation(mc, background);

        ensureIndexesFromFieldsAndEmbeddedEntities(mc, background, parentMCs, parentMFs);
    }

    /**
     * Ensure indexes from class annotation
     * @param mc
     * @param background
     */
    private void ensureIndexesFromClassAnnotation(MappedClass mc, boolean background) {
        ArrayList idxs = mc.getAnnotations(Indexes.class);
        if (idxs != null)
            for (Annotation ann : idxs) {
                Indexes idx = (Indexes) ann;
                if (idx != null && idx.value() != null && idx.value().length > 0)
                    for (Index index : idx.value()) {
                        BasicDBObject fields = QueryImpl.parseFieldsString(index.value(), mc.getClazz(), mapr, !index.disableValidation());
                        ensureIndex(mc.getClazz(), index.name(), fields, index.unique(), index.dropDups(), index.background() ? index.background() : background, index.sparse() ? index.sparse() : false, index.expireAfterSeconds());
                    }
            }
    }

    /**
     * Ensure indexes from field annotations, and embedded entities.
     * @param mc
     * @param background
     * @param parentMCs
     * @param parentMFs
     */
    private void ensureIndexesFromFieldsAndEmbeddedEntities(MappedClass mc, boolean background, ArrayList parentMCs, ArrayList parentMFs) {
        for (MappedField mf : mc.getMappedFields()) {
            Class indexedClass = (parentMCs.isEmpty() ? mc : parentMCs.get(0)).getClazz();
            String field = getFullFieldName(parentMCs, parentMFs, mf);
            if (mf.hasAnnotation(Indexed.class)) {
                Indexed index = mf.getAnnotation(Indexed.class);

                ensureIndex(indexedClass, index.name(), new BasicDBObject(field.toString(), index.value().toIndexValue()), index.unique(), index.dropDups(), index.background() ? index.background() : background, index.sparse() ? index.sparse() : false, index.expireAfterSeconds());
            }

            if (mf.hasAnnotation(SimpleTextIndex.class)) {
                createTextIndex(mf, indexedClass, field);
            }

            if (!mf.isTypeMongoCompatible() && !mf.hasAnnotation(Reference.class) && !mf.hasAnnotation(Serialized.class)) {
                ArrayList newParentClasses = (ArrayList) parentMCs.clone();
                ArrayList newParents = (ArrayList) parentMFs.clone();
                newParentClasses.add(mc);
                newParents.add(mf);
                ensureIndexes(mapr.getMappedClass(mf.isSingleValue() ? mf.getType() : mf.getSubClass()), background, newParentClasses, newParents);
            }

        }
    }

    private void createTextIndex(MappedField mf, Class indexedClass, String field) {
        SimpleTextIndex txtIndex = mf.getAnnotation(SimpleTextIndex.class);
        TextIndexCommand cmd = new TextIndexCommand();
        cmd.setName(field);
        if (!txtIndex.name().isEmpty()) {
            cmd.setName(txtIndex.name());
        }
        cmd.setDefaultLanguage(txtIndex.defaultLanguage());
        List fields = new ArrayList();
        fields.add(field);
        cmd.setFields(fields);
        createTextIndex(indexedClass, cmd);
    }

    private void createTextIndex(Class indexedClass, TextIndexCommand cmd) {
        DBCollection col = getCollection(indexedClass);
        col.ensureIndex(cmd.getKeys(), cmd.getOptions());
    }

    private String getFullFieldName(ArrayList parentMCs, ArrayList parentMFs, MappedField mf) {
        StringBuilder field = new StringBuilder();
        if (!parentMCs.isEmpty())
            for (MappedField pmf : parentMFs)
                field.append(pmf.getNameToStore()).append(".");

        field.append(mf.getNameToStore());
        return field.toString();
    }

    /**
     *
     */
    public void ensureCaps() {
        for (MappedClass mc : mapr.getMappedClasses())
            if (mc.getEntityAnnotation() != null && mc.getEntityAnnotation().cap().value() > 0) {
                CappedAt cap = mc.getEntityAnnotation().cap();
                String collName = mapr.getCollectionName(mc.getClazz());
                BasicDBObjectBuilder dbCapOpts = BasicDBObjectBuilder.start("capped", true);
                if (cap.value() > 0)
                    dbCapOpts.add("size", cap.value());
                if (cap.count() > 0)
                    dbCapOpts.add("max", cap.count());
                DB db = getDB();
                if (db.getCollectionNames().contains(collName)) {
                    DBObject dbResult = db.command(BasicDBObjectBuilder.start("collstats", collName).get());
                    if (dbResult.containsField("capped")) {
                        // TODO: check the cap options.
                        log.warning("DBCollection already exists is cap'd already; doing nothing. " + dbResult);
                    } else {
                        log.warning("DBCollection already exists with same name(" + collName
                                + ") and is not cap'd; not creating cap'd version!");
                    }
                } else {
                    getDB().createCollection(collName, dbCapOpts.get());
                    log.debug("Created cap'd DBCollection (" + collName + ") with opts " + dbCapOpts);
                }
            }
    }

    /**
     * @param ex
     * @param 
     * @return
     */
    public  Query queryByExample(T ex) {
        return queryByExample(getCollection(ex), ex);
    }

    /**
     * @param kind
     * @param ex
     * @param 
     * @return
     */
    public  Query queryByExample(String kind, T ex) {
        return queryByExample(db.getCollection(kind), ex);
    }

    /**
     * @param coll
     * @param example
     * @param 
     * @return
     */
    private  Query queryByExample(DBCollection coll, T example) {
        //TODO: think about remove className from baseQuery param below.
        return new QueryImpl((Class) example.getClass(), coll, this, entityToDBObj(example, new HashMap()));

    }

    /**
     * @param clazz
     * @param 
     * @return
     */
    public  Query createQuery(Class clazz) {
        return new QueryImpl(clazz, getCollection(clazz), this);
    }

    /**
     * @param kind
     * @param q
     * @param 
     * @return
     */
    public  Query createQuery(Class kind, DBObject q) {
        return new QueryImpl(kind, getCollection(kind), this, q);
    }

    /**
     * @param kind
     * @param clazz
     * @param q
     * @param 
     * @return
     */
    public  Query createQuery(String kind, Class clazz, DBObject q) {
        return new QueryImpl(clazz, db.getCollection(kind), this, q);
    }

    /**
     * @param kind
     * @param clazz
     * @param 
     * @return
     */
    public  Query createQuery(String kind, Class clazz) {
        return new QueryImpl(clazz, db.getCollection(kind), this);
    }

    /**
     * @param kind
     * @param clazz
     * @param 
     * @return
     */
    public  Query find(String kind, Class clazz) {
        return new QueryImpl(clazz, getCollection(kind), this);
    }

    /**
     * @param clazz
     * @param 
     * @return
     */
    public  Query find(Class clazz) {
        return createQuery(clazz);
    }

    /**
     * @param clazz
     * @param property
     * @param value
     * @param 
     * @param 
     * @return
     */
    public  Query find(Class clazz, String property, V value) {
        Query query = createQuery(clazz);
        return query.filter(property, value);
    }

    /**
     * @param kind
     * @param clazz
     * @param property
     * @param value
     * @param offset
     * @param size
     * @param 
     * @param 
     * @return
     */
    public  Query find(String kind, Class clazz, String property, V value, int offset, int size) {
        return find(kind, clazz, property, value, offset, size, true);
    }

    /**
     * @param kind
     * @param clazz
     * @param property
     * @param value
     * @param offset
     * @param size
     * @param validate
     * @param 
     * @param 
     * @return
     */
    public  Query find(String kind, Class clazz, String property, V value, int offset, int size,
                                boolean validate) {
        Query query = find(kind, clazz);
        if (!validate)
            query.disableValidation();
        query.offset(offset);
        query.limit(size);
        return query.filter(property, value).enableValidation();
    }

    /**
     * @param clazz
     * @param property
     * @param value
     * @param offset
     * @param size
     * @param 
     * @param 
     * @return
     */
    public  Query find(Class clazz, String property, V value, int offset, int size) {
        Query query = createQuery(clazz);
        query.offset(offset);
        query.limit(size);
        return query.filter(property, value);
    }

    /**
     * @param clazz
     * @param ref
     * @param 
     * @return
     */
    public  T get(Class clazz, DBRef ref) {
        return (T) mapr.fromDBObject(clazz, ref.fetch(), createCache());
    }

    /**
     * @param clazz
     * @param ids
     * @param 
     * @param 
     * @return
     */
    public  Query get(Class clazz, Iterable ids) {
        return find(clazz).disableValidation().filter(Mapper.ID_KEY + " in", ids).enableValidation();
    }

    /**
     * Queries the server to check for each DBRef.
     */
    public  List> getKeysByRefs(List refs) {
        ArrayList> tempKeys = new ArrayList>(refs.size());

        Map> kindMap = new HashMap>();
        for (DBRef ref : refs) {
            if (kindMap.containsKey(ref.getRef()))
                kindMap.get(ref.getRef()).add(ref);
            else
                kindMap.put(ref.getRef(), new ArrayList(Collections.singletonList((DBRef) ref)));
        }
        for (String kind : kindMap.keySet()) {
            List objIds = new ArrayList();
            List kindRefs = kindMap.get(kind);
            for (DBRef key : kindRefs) {
                objIds.add(key.getId());
            }
            List> kindResults = this.find(kind, null).disableValidation().filter("_id in", objIds).asKeyList();
            tempKeys.addAll(kindResults);
        }

        //put them back in order, minus the missing ones.
        ArrayList> keys = new ArrayList>(refs.size());
        for (DBRef ref : refs) {
            Key testKey = mapr.refToKey(ref);
            if (tempKeys.contains(testKey))
                keys.add(testKey);
        }
        return keys;
    }

    /**
     * @param keys
     * @param 
     * @return
     */
    public  List getByKeys(Iterable> keys) {
        return this.getByKeys((Class) null, keys);
    }

    /**
     * @param clazz
     * @param keys
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public  List getByKeys(Class clazz, Iterable> keys) {

        Map> kindMap = new HashMap>();
        List entities = new ArrayList();
        String clazzKind = (clazz == null) ? null :
                getMapper().getCollectionName(clazz);
        for (Key key : keys) {
            mapr.updateKind(key);

            if (clazzKind != null && !key.getKind().equals(clazzKind))
                throw new IllegalArgumentException("Types are not equal (" +
                        clazz + "!=" + key.getKindClass() +
                        ") for key and method parameter clazz");

            if (kindMap.containsKey(key.getKind()))
                kindMap.get(key.getKind()).add(key);
            else
                kindMap.put(key.getKind(), new ArrayList(Collections.singletonList((Key) key)));
        }
        for (String kind : kindMap.keySet()) {
            List objIds = new ArrayList();
            List kindKeys = kindMap.get(kind);
            Class kindClass = clazz == null ? kindKeys.get(0).getKindClass() : clazz;
            for (Key key : kindKeys) {
                objIds.add(key.getId());
            }
            List kindResults = find(kind, kindClass).disableValidation().filter("_id in", objIds).asList();
            entities.addAll(kindResults);
        }

        //TODO: order them based on the incoming Keys.
        return entities;
    }

    /**
     * @param kind
     * @param clazz
     * @param id
     * @param 
     * @param 
     * @return
     */
    public  T get(String kind, Class clazz, V id) {
        List results = find(kind, clazz, Mapper.ID_KEY, id, 0, 1).asList();
        if (results == null || results.size() == 0)
            return null;
        return results.get(0);
    }

    /**
     * @param clazz
     * @param id
     * @param 
     * @param 
     * @return
     */
    public  T get(Class clazz, V id) {
        return find(getCollection(clazz).getName(), clazz, Mapper.ID_KEY, id, 0, 1, true).get();
    }

    /**
     * @param clazz
     * @param key
     * @param 
     * @return
     */
    public  T getByKey(Class clazz, Key key) {
        String kind = mapr.getCollectionName(clazz);
        String keyKind = mapr.updateKind(key);
        if (!kind.equals(keyKind))
            throw new RuntimeException("collection names don't match for key and class: " + kind + " != " + keyKind);

        return get(clazz, key.getId());
    }

    /**
     * @param entity
     * @param 
     * @return
     */
    public  T get(T entity) {
        entity = ProxyHelper.unwrap(entity);
        Object id = getId(entity);
        if (id == null)
            throw new MappingException("Could not get id for " + entity.getClass().getName());
        return (T) get(entity.getClass(), id);
    }

    /**
     * @param entityOrKey
     * @return
     */
    public Key exists(Object entityOrKey) {
        entityOrKey = ProxyHelper.unwrap(entityOrKey);
        Key key = getKey(entityOrKey);
        Object id = key.getId();
        if (id == null)
            throw new MappingException("Could not get id for " + entityOrKey.getClass().getName());

        String collName = key.getKind();
        if (collName == null)
            collName = getCollection(key.getKindClass()).getName();

        return find(collName, key.getKindClass()).filter(Mapper.ID_KEY, key.getId()).getKey();
    }

    /**
     * @param clazz
     * @return
     */
    @SuppressWarnings("rawtypes")
    public DBCollection getCollection(Class clazz) {
        String collName = mapr.getCollectionName(clazz);
        DBCollection dbC = getDB().getCollection(collName);
        return dbC;
    }

    /**
     * @param obj
     * @return
     */
    public DBCollection getCollection(Object obj) {
        if (obj == null) return null;
        return getCollection(obj.getClass());
    }

    /**
     * @param kind
     * @return
     */
    protected DBCollection getCollection(String kind) {
        if (kind == null) return null;
        return getDB().getCollection(kind);
    }

    /**
     * @param entity
     * @param 
     * @return
     */
    public  long getCount(T entity) {
        entity = ProxyHelper.unwrap(entity);
        return getCollection(entity).count();
    }

    /**
     * @param clazz
     * @param 
     * @return
     */
    public  long getCount(Class clazz) {
        return getCollection(clazz).count();
    }

    /**
     * @param kind
     * @return
     */
    public long getCount(String kind) {
        return getCollection(kind).count();
    }

    /**
     * @param query
     * @param 
     * @return
     */
    public  long getCount(Query query) {
        return query.countAll();
    }

    /**
     * @return
     */
    public Mongo getMongo() {
        return this.mongo;
    }

    /**
     * @return
     */
    public DB getDB() {
        return db;
    }

    /**
     * @return
     */
    public Mapper getMapper() {
        return mapr;
    }

    /**
     * @param entities
     * @param 
     * @return
     */
    public  Iterable> insert(Iterable entities) {
        //TODO: try not to create two iterators...
        Object first = entities.iterator().next();
        return insert(entities, getWriteConcern(first));
    }

    /**
     * @param kind
     * @param entities
     * @param wc
     * @param 
     * @return
     */
    public  Iterable> insert(String kind, Iterable entities, WriteConcern wc) {
        DBCollection dbColl = db.getCollection(kind);
        return insert(dbColl, entities, wc);
    }

    /**
     * @param kind
     * @param entities
     * @param 
     * @return
     */
    public  Iterable> insert(String kind, Iterable entities) {
        return insert(kind, entities, getWriteConcern(entities.iterator().next()));
    }

    /**
     * @param entities
     * @param wc
     * @param 
     * @return
     */
    public  Iterable> insert(Iterable entities, WriteConcern wc) {
        //TODO: Do this without creating another iterator
        DBCollection dbColl = getCollection(entities.iterator().next());
        return insert(dbColl, entities, wc);
    }

    /**
     * @param dbColl
     * @param entities
     * @param wc
     * @param 
     * @return
     */
    private  Iterable> insert(DBCollection dbColl, Iterable entities, WriteConcern wc) {
        ArrayList ents = entities instanceof List ? new ArrayList(((List) entities).size()) : new ArrayList();

        Map involvedObjects = new LinkedHashMap();
        for (T ent : entities) {
            MappedClass mc = mapr.getMappedClass(ent);
            if (mc.getAnnotation(NotSaved.class) != null)
                throw new MappingException("Entity type: " + mc.getClazz().getName() + " is marked as NotSaved which means you should not try to save it!");
            ents.add(entityToDBObj(ent, involvedObjects));
        }

        WriteResult wr = null;

        DBObject[] dbObjs = new DBObject[ents.size()];
        dbColl.insert(ents.toArray(dbObjs), wc);

        throwOnError(wc, wr);

        ArrayList> savedKeys = new ArrayList>();
        Iterator entitiesIT = entities.iterator();
        Iterator dbObjsIT = ents.iterator();

        while (entitiesIT.hasNext()) {
            T entity = entitiesIT.next();
            DBObject dbObj = dbObjsIT.next();
            savedKeys.add(postSaveGetKey(entity, dbObj, dbColl, involvedObjects));
        }

        return savedKeys;
    }

    /**
     * @param entities
     * @param 
     * @return
     */
    public  Iterable> insert(T... entities) {
        return insert(Arrays.asList(entities), getWriteConcern(entities[0]));
    }

    /**
     * @param entity
     * @param 
     * @return
     */
    public  Key insert(T entity) {
        return insert(entity, getWriteConcern(entity));
    }

    /**
     * @param entity
     * @param wc
     * @param 
     * @return
     */
    public  Key insert(T entity, WriteConcern wc) {
        entity = ProxyHelper.unwrap(entity);
        DBCollection dbColl = getCollection(entity);
        return insert(dbColl, entity, wc);
    }

    /**
     * @param kind
     * @param entity
     * @param 
     * @return
     */
    public  Key insert(String kind, T entity) {
        entity = ProxyHelper.unwrap(entity);
        DBCollection dbColl = getCollection(kind);
        return insert(dbColl, entity, getWriteConcern(entity));
    }

    /**
     * @param kind
     * @param entity
     * @param wc
     * @param 
     * @return
     */
    public  Key insert(String kind, T entity, WriteConcern wc) {
        entity = ProxyHelper.unwrap(entity);
        DBCollection dbColl = getCollection(kind);
        return insert(dbColl, entity, wc);
    }

    /**
     * @param dbColl
     * @param entity
     * @param wc
     * @param 
     * @return
     */
    protected  Key insert(DBCollection dbColl, T entity, WriteConcern wc) {
        LinkedHashMap involvedObjects = new LinkedHashMap();
        DBObject dbObj = entityToDBObj(entity, involvedObjects);
        WriteResult wr;
        if (wc == null)
            wr = dbColl.insert(dbObj);
        else
            wr = dbColl.insert(dbObj, wc);

        throwOnError(wc, wr);

        return postSaveGetKey(entity, dbObj, dbColl, involvedObjects);

    }

    /**
     * @param entity
     * @param involvedObjects
     * @return
     */
    protected DBObject entityToDBObj(Object entity, Map involvedObjects) {
        entity = ProxyHelper.unwrap(entity);
        DBObject dbObj = mapr.toDBObject(entity, involvedObjects);
        return dbObj;
    }

    /**
     * call postSaveOperations and returns Key for entity.
     */
    protected  Key postSaveGetKey(T entity, DBObject dbObj, DBCollection dbColl, Map involvedObjects) {
        if (dbObj.get(Mapper.ID_KEY) == null)
            throw new MappingException("Missing _id after save!");

        postSaveOperations(entity, dbObj, involvedObjects);
        Key key = new Key(dbColl.getName(), getId(entity));
        key.setKindClass((Class) entity.getClass());

        return key;
    }

    /**
     * @param entities
     * @param 
     * @return
     */
    public  Iterable> save(Iterable entities) {
        Object first = null;
        try {
            first = entities.iterator().next();
        } catch (Exception e) {
            //do nothing
        }
        return save(entities, getWriteConcern(first));
    }

    /**
     * @param entities
     * @param wc
     * @param 
     * @return
     */
    public  Iterable> save(Iterable entities, WriteConcern wc) {
        ArrayList> savedKeys = new ArrayList>();
        for (T ent : entities)
            savedKeys.add(save(ent, wc));
        return savedKeys;

    }

    /**
     * @param entities
     * @param 
     * @return
     */
    public  Iterable> save(T... entities) {
        ArrayList> savedKeys = new ArrayList>();
        for (T ent : entities)
            savedKeys.add(save(ent));
        return savedKeys;
    }

    /**
     * @param dbColl
     * @param entity
     * @param wc
     * @param 
     * @return
     */
    protected  Key save(DBCollection dbColl, T entity, WriteConcern wc) {
        MappedClass mc = mapr.getMappedClass(entity);
        if (mc.getAnnotation(NotSaved.class) != null)
            throw new MappingException("Entity type: " + mc.getClazz().getName() + " is marked as NotSaved which means you should not try to save it!");

        WriteResult wr = null;

        //involvedObjects is used not only as a cache but also as a list of what needs to be called for life-cycle methods at the end.
        LinkedHashMap involvedObjects = new LinkedHashMap();
        DBObject dbObj = entityToDBObj(entity, involvedObjects);

        //try to do an update if there is a @Version field
        wr = tryVersionedUpdate(dbColl, entity, dbObj, wc, db, mc);

        if (wr == null)
            if (wc == null)
                wr = dbColl.save(dbObj);
            else
                wr = dbColl.save(dbObj, wc);

        throwOnError(wc, wr);
        return postSaveGetKey(entity, dbObj, dbColl, involvedObjects);
    }

    /**
     * @param dbColl
     * @param entity
     * @param dbObj
     * @param wc
     * @param db
     * @param mc
     * @param 
     * @return
     */
    protected  WriteResult tryVersionedUpdate(DBCollection dbColl, T entity, DBObject dbObj, WriteConcern wc, DB db, MappedClass mc) {
        WriteResult wr = null;
        if (mc.getFieldsAnnotatedWith(Version.class).isEmpty())
            return wr;


        MappedField mfVersion = mc.getFieldsAnnotatedWith(Version.class).get(0);
        String versionKeyName = mfVersion.getNameToStore();
        Long oldVersion = (Long) mfVersion.getFieldValue(entity);
        long newVersion = VersionHelper.nextValue(oldVersion);
        dbObj.put(versionKeyName, newVersion);
        if (oldVersion != null && oldVersion > 0) {
            Object idValue = dbObj.get(Mapper.ID_KEY);

            UpdateResults res = update(find(dbColl.getName(), (Class) entity.getClass()).filter(Mapper.ID_KEY, idValue).filter(versionKeyName, oldVersion),
                    dbObj,
                    false,
                    false,
                    wc);

            wr = res.getWriteResult();

            if (res.getUpdatedCount() != 1)
                throw new ConcurrentModificationException("Entity of class " + entity.getClass().getName()
                        + " (id='" + idValue + "',version='" + oldVersion + "') was concurrently updated.");
        } else if (wc == null)
            wr = dbColl.save(dbObj);
        else
            wr = dbColl.save(dbObj, wc);

        //update the version.
        mfVersion.setFieldValue(entity, newVersion);
        return wr;
    }

    /**
     * @param wc
     * @param wr
     */
    protected void throwOnError(WriteConcern wc, WriteResult wr) {
        if (wc == null && wr.getLastConcern() == null) {
            CommandResult cr = wr.getLastError();
            if (cr != null && cr.getErrorMessage() != null && cr.getErrorMessage().length() > 0)
                cr.throwOnError();
        }
    }

    /**
     * @param kind
     * @param entity
     * @param 
     * @return
     */
    public  Key save(String kind, T entity) {
        entity = ProxyHelper.unwrap(entity);
        DBCollection dbColl = getCollection(kind);
        return save(dbColl, entity, getWriteConcern(entity));
    }

    /**
     * @param entity
     * @param 
     * @return
     */
    public  Key save(T entity) {
        return save(entity, getWriteConcern(entity));
    }

    /**
     * @param entity
     * @param wc
     * @param 
     * @return
     */
    public  Key save(T entity, WriteConcern wc) {
        entity = ProxyHelper.unwrap(entity);
        DBCollection dbColl = getCollection(entity);
        return save(dbColl, entity, wc);
    }

    /**
     * @param clazz
     * @param 
     * @return
     */
    public  UpdateOperations createUpdateOperations(Class clazz) {
        return new UpdateOpsImpl(clazz, getMapper());
    }

    /**
     * @param kind
     * @param ops
     * @param 
     * @return
     */
    public  UpdateOperations createUpdateOperations(Class kind, DBObject ops) {
        UpdateOpsImpl upOps = (UpdateOpsImpl) createUpdateOperations(kind);
        upOps.setOps(ops);
        return upOps;
    }

    /**
     * @param query
     * @param ops
     * @param createIfMissing
     * @param 
     * @return
     */
    public  UpdateResults update(Query query, UpdateOperations ops, boolean createIfMissing) {
        return update(query, ops, createIfMissing, getWriteConcern(query.getEntityClass()));
    }

    /**
     * @param query
     * @param ops
     * @param createIfMissing
     * @param wc
     * @param 
     * @return
     */
    public  UpdateResults update(Query query, UpdateOperations ops, boolean createIfMissing, WriteConcern wc) {
        return update(query, ops, createIfMissing, true, wc);
    }

    /**
     * @param ent
     * @param ops
     * @param 
     * @return
     */
    public  UpdateResults update(T ent, UpdateOperations ops) {
        if (ent instanceof Query)
            return update((Query) ent, ops);

        MappedClass mc = mapr.getMappedClass(ent);
        Query q = (Query) createQuery(mc.getClazz());
        q.disableValidation().filter(Mapper.ID_KEY, getId(ent));

        if (mc.getFieldsAnnotatedWith(Version.class).size() > 0) {
            MappedField versionMF = mc.getFieldsAnnotatedWith(Version.class).get(0);
            Long oldVer = (Long) versionMF.getFieldValue(ent);
            q.filter(versionMF.getNameToStore(), oldVer);
            ops.set(versionMF.getNameToStore(), VersionHelper.nextValue(oldVer));
        }

        return update(q, ops);
    }

    /**
     * @param key
     * @param ops
     * @param 
     * @return
     */
    public  UpdateResults update(Key key, UpdateOperations ops) {
        Class clazz = (Class) key.getKindClass();
        if (clazz == null)
            clazz = (Class) mapr.getClassFromKind(key.getKind());
        return updateFirst(createQuery(clazz).disableValidation().filter(Mapper.ID_KEY, key.getId()), ops);
    }

    /**
     * @param query
     * @param ops
     * @param 
     * @return
     */
    public  UpdateResults update(Query query, UpdateOperations ops) {
        return update(query, ops, false, true);
    }

    /**
     * @param query
     * @param ops
     * @param 
     * @return
     */
    public  UpdateResults updateFirst(Query query, UpdateOperations ops) {
        return update(query, ops, false, false);
    }

    /**
     * @param query
     * @param ops
     * @param createIfMissing
     * @param 
     * @return
     */
    public  UpdateResults updateFirst(Query query, UpdateOperations ops, boolean createIfMissing) {
        return update(query, ops, createIfMissing, getWriteConcern(query.getEntityClass()));

    }

    /**
     * @param query
     * @param ops
     * @param createIfMissing
     * @param wc
     * @param 
     * @return
     */
    public  UpdateResults updateFirst(Query query, UpdateOperations ops, boolean createIfMissing, WriteConcern wc) {
        return update(query, ops, createIfMissing, false, wc);
    }

    /**
     * @param query
     * @param entity
     * @param createIfMissing
     * @param 
     * @return
     */
    public  UpdateResults updateFirst(Query query, T entity, boolean createIfMissing) {
        LinkedHashMap involvedObjects = new LinkedHashMap();
        DBObject dbObj = mapr.toDBObject(entity, involvedObjects);

        UpdateResults res = update(query, dbObj, createIfMissing, false, getWriteConcern(entity));

        //update _id field
        CommandResult gle = res.getWriteResult().getCachedLastError();
        if (gle != null && res.getInsertedCount() > 0)
            dbObj.put(Mapper.ID_KEY, res.getNewId());

        postSaveOperations(entity, dbObj, involvedObjects);
        return res;
    }

    /**
     * @param entity
     * @param 
     * @return
     */
    public  Key merge(T entity) {
        return merge(entity, getWriteConcern(entity));
    }

    /**
     * @param entity
     * @param wc
     * @param 
     * @return
     */
    public  Key merge(T entity, WriteConcern wc) {
        LinkedHashMap involvedObjects = new LinkedHashMap();
        DBObject dbObj = mapr.toDBObject(entity, involvedObjects);
        Key key = getKey(entity);
        entity = ProxyHelper.unwrap(entity);
        Object id = getId(entity);
        if (id == null)
            throw new MappingException("Could not get id for " + entity.getClass().getName());

        //remove (immutable) _id field for update.
        dbObj.removeField(Mapper.ID_KEY);

        WriteResult wr = null;

        MappedClass mc = mapr.getMappedClass(entity);
        DBCollection dbColl = getCollection(entity);

        //try to do an update if there is a @Version field
        wr = tryVersionedUpdate(dbColl, entity, dbObj, wc, db, mc);

        if (wr == null) {
            Query query = (Query) createQuery(entity.getClass()).filter(Mapper.ID_KEY, id);
            wr = update(query, new BasicDBObject("$set", dbObj), false, false, wc).getWriteResult();
        }

        UpdateResults res = new UpdateResults(wr);

        throwOnError(wc, wr);

        //check for updated count if we have a gle
        CommandResult gle = wr.getCachedLastError();
        if (gle != null && res.getUpdatedCount() == 0)
            throw new UpdateException("Not updated: " + gle);

        postSaveOperations(entity, dbObj, involvedObjects);
        return key;
    }

    /**
     * @param entity
     * @param dbObj
     * @param involvedObjects
     * @param 
     */
    private  void postSaveOperations(Object entity, DBObject dbObj, Map involvedObjects) {
        mapr.updateKeyInfo(entity, dbObj, createCache());

        //call PostPersist on all involved entities (including the entity)
        for (Map.Entry e : involvedObjects.entrySet()) {
            Object ent = e.getKey();
            DBObject dbO = e.getValue();
            MappedClass mc = mapr.getMappedClass(ent);
            mc.callLifecycleMethods(PostPersist.class, ent, dbO, mapr);
        }
    }

    /**
     * @param query
     * @param ops
     * @param createIfMissing
     * @param multi
     * @param wc
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    private  UpdateResults update(Query query, UpdateOperations ops, boolean createIfMissing, boolean multi, WriteConcern wc) {
        DBObject u = ((UpdateOpsImpl) ops).getOps();
        if (((UpdateOpsImpl) ops).isIsolated()) {
            Query q = query.clone();
            q.disableValidation().filter("$atomic", true);
            return update(q, u, createIfMissing, multi, wc);
        }
        return update(query, u, createIfMissing, multi, wc);
    }

    /**
     * @param query
     * @param ops
     * @param createIfMissing
     * @param multi
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    private  UpdateResults update(Query query, UpdateOperations ops, boolean createIfMissing, boolean multi) {
        return update(query, ops, createIfMissing, multi, getWriteConcern(query.getEntityClass()));
    }

    /**
     * @param query
     * @param u
     * @param createIfMissing
     * @param multi
     * @param wc
     * @param 
     * @return
     */
    private  UpdateResults update(Query query, DBObject u, boolean createIfMissing, boolean multi, WriteConcern wc) {
        QueryImpl qi = (QueryImpl) query;

        DBCollection dbColl = qi.getCollection();
        //TODO remove this after testing.
        if (dbColl == null)
            dbColl = getCollection(qi.getEntityClass());

        if (qi.getSortObject() != null && qi.getSortObject().keySet() != null && !qi.getSortObject().keySet().isEmpty())
            throw new QueryException("sorting is not allowed for updates.");
        if (qi.getOffset() > 0)
            throw new QueryException("a query offset is not allowed for updates.");
        if (qi.getLimit() > 0)
            throw new QueryException("a query limit is not allowed for updates.");

        DBObject q = qi.getQueryObject();
        if (q == null)
            q = new BasicDBObject();

        if (log.isTraceEnabled())
            log.trace("Executing update(" + dbColl.getName() + ") for query: " + q + ", ops: " + u + ", multi: " + multi + ", upsert: " + createIfMissing);

        WriteResult wr;
        if (wc == null)
            wr = dbColl.update(q, u, createIfMissing, multi);
        else
            wr = dbColl.update(q, u, createIfMissing, multi, wc);

        throwOnError(wc, wr);

        return new UpdateResults(wr);
    }

    /**
     * @param query
     * @param 
     * @return
     */
    public  T findAndDelete(Query query) {
        DBCollection dbColl = ((QueryImpl) query).getCollection();
        //TODO remove this after testing.
        if (dbColl == null)
            dbColl = getCollection(((QueryImpl) query).getEntityClass());

        QueryImpl qi = ((QueryImpl) query);
        EntityCache cache = createCache();

        if (log.isTraceEnabled())
            log.trace("Executing findAndModify(" + dbColl.getName() + ") with delete ...");

        DBObject result = dbColl.findAndModify(qi.getQueryObject(), qi.getFieldsObject(), qi.getSortObject(), true, null, false, false);

        if (result != null) {
            T entity = (T) mapr.fromDBObject(qi.getEntityClass(), result, cache);
            return entity;
        }

        return null;
    }

    /**
     * @param q
     * @param ops
     * @param 
     * @return
     */
    public  T findAndModify(Query q, UpdateOperations ops) {
        return findAndModify(q, ops, false);
    }

    /**
     * @param query
     * @param ops
     * @param oldVersion indicated the old version of the Entity should be returned
     * @param 
     * @return
     */
    public  T findAndModify(Query query, UpdateOperations ops, boolean oldVersion) {
        return findAndModify(query, ops, oldVersion, false);
    }

    /**
     * @param query
     * @param ops
     * @param oldVersion      indicated the old version of the Entity should be returned
     * @param createIfMissing if the query returns no results, then a new object will be created (sets upsert=true)
     * @param 
     * @return
     */
    public  T findAndModify(Query query, UpdateOperations ops, boolean oldVersion, boolean createIfMissing) {
        QueryImpl qi = (QueryImpl) query;

        DBCollection dbColl = qi.getCollection();
        //TODO remove this after testing.
        if (dbColl == null)
            dbColl = getCollection(qi.getEntityClass());

        if (log.isTraceEnabled())
            log.info("Executing findAndModify(" + dbColl.getName() + ") with update ");
        DBObject res = null;
        try {
            res = dbColl.findAndModify(qi.getQueryObject(),
                    qi.getFieldsObject(),
                    qi.getSortObject(),
                    false,
                    ((UpdateOpsImpl) ops).getOps(), !oldVersion,
                    createIfMissing);
        } catch (MongoException e) {
            if (e.getMessage() == null || !e.getMessage().contains("matching"))
                throw e;
        }

        if (res == null)
            return null;
        else
            return (T) mapr.fromDBObject(qi.getEntityClass(), res, createCache());
    }

    /**
     * @param type        MapreduceType
     * @param q           The query (only the criteria, limit and sort will be used)
     * @param outputType  The type of resulting data; inline is not working yet
     * @param baseCommand The base command to fill in and send to the server
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public  MapreduceResults mapReduce(MapreduceType type, Query q, Class outputType, MapReduceCommand baseCommand) {

        Assert.parametersNotNull("map", baseCommand.getMap());
        Assert.parameterNotEmpty(baseCommand.getMap(), "map");
        Assert.parametersNotNull("reduce", baseCommand.getReduce());
        Assert.parameterNotEmpty(baseCommand.getMap(), "reduce");


        if (MapreduceType.INLINE.equals(type))
            throw new IllegalArgumentException("Inline map/reduce is not supported.");

        QueryImpl qi = (QueryImpl) q;
        if (qi.getOffset() != 0 || qi.getFieldsObject() != null)
            throw new QueryException("mapReduce does not allow the offset/retrievedFields query options.");


        OutputType outType = OutputType.REPLACE;
        switch (type) {
            case REDUCE:
                outType = OutputType.REDUCE;
                break;
            case MERGE:
                outType = OutputType.MERGE;
                break;
            case INLINE:
                outType = OutputType.INLINE;
                break;
            default:
                outType = OutputType.REPLACE;
                break;
        }

        DBCollection dbColl = qi.getCollection();

        MapReduceCommand cmd = new MapReduceCommand(dbColl, baseCommand.getMap(), baseCommand.getReduce(), baseCommand.getOutputTarget(), outType, qi.getQueryObject());
        cmd.setFinalize(baseCommand.getFinalize());
        cmd.setScope(baseCommand.getScope());

        if (qi.getLimit() > 0)
            cmd.setLimit(qi.getLimit());
        if (qi.getSortObject() != null)
            cmd.setSort(qi.getSortObject());

        if (log.isTraceEnabled())
            log.info("Executing " + cmd.toString());

        MapReduceOutput mpo = dbColl.mapReduce(baseCommand);
        MapreduceResults mrRes = (MapreduceResults) mapr.fromDBObject(MapreduceResults.class, mpo.getRaw(), createCache());

        QueryImpl baseQ = null;
        if (!MapreduceType.INLINE.equals(type))
            baseQ = new QueryImpl(outputType, db.getCollection(mrRes.getOutputCollectionName()), this);
        //TODO Handle inline case and create an iterator/able.

        mrRes.setBits(type, baseQ);
        return mrRes;

    }

    /**
     * @param type
     * @param query
     * @param map
     * @param reduce
     * @param finalize
     * @param scopeFields
     * @param outputType
     * @param 
     * @return
     */
    @SuppressWarnings("rawtypes")
    public  MapreduceResults mapReduce(MapreduceType type, Query query, String map, String reduce, String finalize, Map scopeFields, Class outputType) {

        QueryImpl qi = (QueryImpl) query;
        DBCollection dbColl = qi.getCollection();

        String outColl = mapr.getCollectionName(outputType);

        OutputType outType = OutputType.REPLACE;
        switch (type) {
            case REDUCE:
                outType = OutputType.REDUCE;
                break;
            case MERGE:
                outType = OutputType.MERGE;
                break;
            case INLINE:
                outType = OutputType.INLINE;
                break;
            default:
                outType = OutputType.REPLACE;
                break;
        }

        MapReduceCommand cmd = new MapReduceCommand(dbColl, map, reduce, outColl, outType, qi.getQueryObject());

        if (qi.getLimit() > 0)
            cmd.setLimit(qi.getLimit());
        if (qi.getSortObject() != null)
            cmd.setSort(qi.getSortObject());

        if (finalize != null && finalize.length() > 0)
            cmd.setFinalize(finalize);

        if (scopeFields != null && scopeFields.size() > 0)
            cmd.setScope(scopeFields);

        return mapReduce(type, query, outputType, cmd);
    }

    /**
     * Converts a list of keys to refs.
     */
    public static  List keysAsRefs(List> keys, Mapper mapr) {
        ArrayList refs = new ArrayList(keys.size());
        for (Key key : keys)
            refs.add(mapr.keyToRef(key));
        return refs;
    }

    /**
     * Converts a list of refs to keys.
     */
    public static  List> refsToKeys(Mapper mapr, List refs, Class c) {
        ArrayList> keys = new ArrayList>(refs.size());
        for (DBRef ref : refs) {
            keys.add((Key) mapr.refToKey(ref));
        }
        return keys;
    }

    /**
     * @return
     */
    private EntityCache createCache() {
        return mapr.createEntityCache();
    }

    /**
     * Gets the write concern for entity or returns the default write concern for this datastore.
     */
    public WriteConcern getWriteConcern(Object clazzOrEntity) {
        WriteConcern wc = defConcern;
        if (clazzOrEntity != null) {
            Entity entityAnn = getMapper().getMappedClass(clazzOrEntity).getEntityAnnotation();
            if (entityAnn != null && !"".equals(entityAnn.concern()))
                wc = WriteConcern.valueOf(entityAnn.concern());
        }

        return wc;
    }

    /**
     * @return
     */
    public WriteConcern getDefaultWriteConcern() {
        return defConcern;
    }

    /**
     * @param wc
     */
    public void setDefaultWriteConcern(WriteConcern wc) {
        defConcern = wc;
    }

    /**
     * @param fact
     * @return
     */
    public DBDecoderFactory setDecoderFact(DBDecoderFactory fact) {
        return decoderFactory = fact;
    }

    /**
     * @return
     */
    public DBDecoderFactory getDecoderFact() {
        return decoderFactory != null ? decoderFactory : mongo.getMongoOptions().dbDecoderFactory;
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy