DatastoreImpl (Morphia 1.2.1-SNAPSHOT API)

java.lang.Object
- org.mongodb.morphia.DatastoreImpl

All Implemented Interfaces:

AdvancedDatastore, Datastore
```
public class DatastoreImpl
extends Object
implements AdvancedDatastore
```
A generic (type-safe) wrapper around mongodb collections

Author:

Scott Hernandez

Constructor Summary

Constructors
Constructor and Description
`DatastoreImpl(Morphia morphia, Mapper mapper, MongoClient mongoClient, DB db)` Create a new DatastoreImpl
`DatastoreImpl(Morphia morphia, Mapper mapper, MongoClient mongoClient, String dbName)` Create a new DatastoreImpl
`DatastoreImpl(Morphia morphia, MongoClient mongoClient, String dbName)` Create a new DatastoreImpl

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`DatastoreImpl`	`copy(String database)` Creates a copy of this Datastore and all its configuration but with a new database
`AggregationPipeline`	`createAggregation(Class source)` Returns a new query bound to the kind (a specific `DBCollection`)
`<T> Query<T>`	`createQuery(Class<T> collection)` Returns a new query bound to the collection (a specific `DBCollection`)
`<T> Query<T>`	`createQuery(Class<T> clazz, DBObject q)`
`<T> Query<T>`	`createQuery(String collection, Class<T> type)`
`<T> Query<T>`	`createQuery(String collection, Class<T> type, DBObject q)`
`<T,V> DBRef`	`createRef(Class<T> clazz, V id)` Creates a reference to the entity (using the current DB -can be null-, the collectionName, and id)
`<T> DBRef`	`createRef(T entity)` Creates a reference to the entity (using the current DB -can be null-, the collectionName, and id)
`<T> UpdateOperations<T>`	`createUpdateOperations(Class<T> clazz)` The builder for all update operations
`<T> UpdateOperations<T>`	`createUpdateOperations(Class<T> type, DBObject ops)` Creates an UpdateOperations instance for the given type.
`<T,V> WriteResult`	`delete(Class<T> clazz, Iterable<V> ids)` Deletes the given entities (by id)
`<T,V> WriteResult`	`delete(Class<T> clazz, V id)` Deletes the given entity (by id)
`<T,V> WriteResult`	`delete(Class<T> clazz, V id, WriteConcern wc)` Deletes entities based on the query, with the WriteConcern
`<T> WriteResult`	`delete(Query<T> query)` Deletes entities based on the query
`<T> WriteResult`	`delete(Query<T> query, WriteConcern wc)` Deletes entities based on the query, with the WriteConcern
`<T,V> WriteResult`	`delete(String kind, Class<T> clazz, V id)` Deletes an entity of the given type T, with the given `id`, from the collection with the name in the `kind` param.
`<T,V> WriteResult`	`delete(String kind, Class<T> clazz, V id, WriteConcern wc)` Deletes an entity of the given type T, with the given `id`, from the collection with the name in the `kind` param.
`<T> WriteResult`	`delete(T entity)` Deletes the given entity (by @Id)
`<T> WriteResult`	`delete(T entity, WriteConcern wc)` Deletes the given entity (by @Id), with the WriteConcern
`void`	`ensureCaps()` ensure capped DBCollections for `Entity`(s)
`<T> void`	`ensureIndex(Class<T> type, String fields)` Ensures (creating if necessary) the index including the field(s) + directions on the given collection name; eg fields = "field1, -field2" ({field1:1, field2:-1})
`protected <T> void`	`ensureIndex(Class<T> clazz, String name, BasicDBObject fields, boolean unique, boolean dropDupsOnCreate, boolean background, boolean sparse, int expireAfterSeconds)`
`<T> void`	`ensureIndex(Class<T> clazz, String name, String fields, boolean unique, boolean dropDupsOnCreate)` Ensures (creating if necessary) the index including the field(s) + directions on the given collection name; eg fields = "field1, -field2" ({field1:1, field2:-1})
`protected void`	`ensureIndex(DBCollection dbColl, DBObject keys, DBObject options)`
`protected void`	`ensureIndex(DBCollection dbColl, String name, BasicDBObject fields, boolean unique, boolean dropDupsOnCreate, boolean background, boolean sparse, int expireAfterSeconds)`
`protected void`	`ensureIndex(MappedClass mc, DBCollection dbColl, Field[] fields, IndexOptions options, boolean background, List<MappedClass> parentMCs, List<MappedField> parentMFs)`
`<T> void`	`ensureIndex(String collection, Class<T> type, String fields)` Ensures (creating if necessary) the index including the field(s) + directions on the given collection name; eg fields = "field1, -field2" ({field1:1, field2:-1})
`<T> void`	`ensureIndex(String collection, Class<T> clazz, String name, String fields, boolean unique, boolean dropDupsOnCreate)` Ensures (creating if necessary) the index including the field(s) + directions on the given collection name; eg fields = "field1, -field2" ({field1:1, field2:-1})
`void`	`ensureIndexes()` Ensures (creating if necessary) the indexes found during class mapping (using `@Indexed, @Indexes)`
`void`	`ensureIndexes(boolean background)` Ensures (creating if necessary) the indexes found during class mapping (using `@Indexed, @Indexes)` on the given collection name, possibly in the background
`<T> void`	`ensureIndexes(Class<T> clazz)` Ensures (creating if necessary) the indexes found during class mapping (using `@Indexed, @Indexes)`
`<T> void`	`ensureIndexes(Class<T> clazz, boolean background)` Ensures (creating if necessary) the indexes found during class mapping (using `@Indexed, @Indexes)`, possibly in the background
`protected void`	`ensureIndexes(DBCollection dbColl, MappedClass mc, boolean background, List<MappedClass> parentMCs, List<MappedField> parentMFs)`
`protected void`	`ensureIndexes(MappedClass mc, boolean background)`
`protected void`	`ensureIndexes(MappedClass mc, boolean background, List<MappedClass> parentMCs, List<MappedField> parentMFs)`
`<T> void`	`ensureIndexes(String collection, Class<T> clazz)` Ensures (creating if necessary) the indexes found during class mapping (using `@Indexed, @Indexes)` on the given collection name.
`<T> void`	`ensureIndexes(String collection, Class<T> clazz, boolean background)` Ensures (creating if necessary) the indexes found during class mapping (using `@Indexed, @Indexes)` on the given collection name, possibly in the background
`protected void`	`ensureIndexes(String collName, MappedClass mc, boolean background)`
`Key<?>`	`exists(Object entityOrKey)` Does a query to check if the keyOrEntity exists in mongodb
`Key<?>`	`exists(Object entityOrKey, ReadPreference readPreference)` Checks that an entity exists for the given key or entity
`<T> Query<T>`	`find(Class<T> clazz)` Find all instances by type
`<T,V> Query<T>`	`find(Class<T> clazz, String property, V value)` Find all instances by collectionName, and filter property.
`<T,V> Query<T>`	`find(Class<T> clazz, String property, V value, int offset, int size)` Find all instances by type in a different collection than what is mapped on the class given skipping some documents and returning a fixed number of the remaining.
`<T> Query<T>`	`find(String collection, Class<T> clazz)` Find all instances by type in a different collection than what is mapped on the class given.
`<T,V> Query<T>`	`find(String collection, Class<T> clazz, String property, V value, int offset, int size)` Find all instances by type in a different collection than what is mapped on the class given skipping some documents and returning a fixed number of the remaining.
`<T,V> Query<T>`	`find(String collection, Class<T> clazz, String property, V value, int offset, int size, boolean validate)` Find all instances by type in a different collection than what is mapped on the class given skipping some documents and returning a fixed number of the remaining.
`<T> T`	`findAndDelete(Query<T> query)` Deletes the given entities based on the query (first item only).
`<T> T`	`findAndModify(Query<T> query, UpdateOperations<T> operations)` Find the first Entity from the Query, and modify it.
`<T> T`	`findAndModify(Query<T> query, UpdateOperations<T> operations, boolean oldVersion)` Find the first Entity from the Query, and modify it.
`<T> T`	`findAndModify(Query<T> query, UpdateOperations<T> operations, boolean oldVersion, boolean createIfMissing)` Find the first Entity from the Query, and modify it.
`<T> T`	`get(Class<T> clazz, DBRef ref)` Find the given entity (by collectionName/id);
`<T,V> Query<T>`	`get(Class<T> clazz, Iterable<V> ids)` Find the given entities (by id); shorthand for `find("_id in", ids)`
`<T,V> T`	`get(Class<T> clazz, V id)` Find the given entity (by id); shorthand for `find("_id ", id)`
`<T,V> T`	`get(String collection, Class<T> clazz, V id)` Finds an entity in the named collection whose id matches the value given.
`<T> T`	`get(T entity)` Find the given entity (by collectionName/id); think of this as refresh
`<T> T`	`getByKey(Class<T> clazz, Key<T> key)` Find the given entity (by collectionName/id);
`<T> List<T>`	`getByKeys(Class<T> clazz, Iterable<Key<T>> keys)` Find the given entities (by id), verifying they are of the correct type; shorthand for `find("_id in", ids)`
`<T> List<T>`	`getByKeys(Iterable<Key<T>> keys)` Find the given entities (by id); shorthand for `find("_id in", ids)`
`DBCollection`	`getCollection(Class clazz)`
`DBCollection`	`getCollection(Object obj)`
`protected DBCollection`	`getCollection(String kind)`
`<T> long`	`getCount(Class<T> clazz)` Gets the count this kind (`DBCollection`)
`<T> long`	`getCount(Query<T> query)` Gets the count of items returned by this query; same as `query.countAll()`
`long`	`getCount(String collection)` Gets the count this collection
`<T> long`	`getCount(T entity)` Gets the count this kind (`DBCollection`)
`DB`	`getDB()`
`DBDecoderFactory`	`getDecoderFact()` Returns the DBDecoderFactory used by this Datastore
`WriteConcern`	`getDefaultWriteConcern()`
`protected Object`	`getId(Object entity)` Deprecated.
`<T> Key<T>`	`getKey(T entity)` Deprecated.
`Mapper`	`getMapper()`
`MongoClient`	`getMongo()` Get the underlying MongoClient that allows connection to the MongoDB instance being used.
`QueryFactory`	`getQueryFactory()`
`protected <T> Key<T>`	`insert(DBCollection dbColl, T entity, WriteConcern wc)`
`<T> Iterable<Key<T>>`	`insert(Iterable<T> entities)` Inserts entities in to the database
`<T> Iterable<Key<T>>`	`insert(Iterable<T> entities, WriteConcern wc)` Inserts entities in to the mapped collection.
`<T> Iterable<Key<T>>`	`insert(String collection, Iterable<T> entities)` Inserts an entity in to the named collection.
`<T> Iterable<Key<T>>`	`insert(String collection, Iterable<T> entities, WriteConcern wc)` Inserts an entity in to the named collection.
`<T> Key<T>`	`insert(String collection, T entity)` Inserts an entity in to the named collection.
`<T> Key<T>`	`insert(String collection, T entity, WriteConcern wc)` Inserts an entity in to the database
`<T> Iterable<Key<T>>`	`insert(T... entities)` Inserts entities in to the mapped collection.
`<T> Key<T>`	`insert(T entity)` Inserts an entity in to the mapped collection.
`<T> Key<T>`	`insert(T entity, WriteConcern wc)` Inserts an entity in to the mapped collection.
`<T> MapreduceResults<T>`	`mapReduce(MapreduceType type, Query query, Class<T> outputType, MapReduceCommand baseCommand)` Runs a map/reduce job at the server; this should be used with a server version 1.7.4 or higher
`<T> MapreduceResults<T>`	`mapReduce(MapreduceType type, Query query, String map, String reduce, String finalize, Map<String,Object> scopeFields, Class<T> outputType)` Runs a map/reduce job at the server; this should be used with a server version 1.7.4 or higher
`<T> Key<T>`	`merge(T entity)` Work as if you did an update with each field in the entity doing a $set; Only at the top level of the entity.
`<T> Key<T>`	`merge(T entity, WriteConcern wc)` Work as if you did an update with each field in the entity doing a $set; Only at the top level of the entity.
`<T> Query<T>`	`queryByExample(String collection, T ex)` Returns a new query based on the example object
`<T> Query<T>`	`queryByExample(T ex)` Returns a new query based on the example object
`protected <T> Key<T>`	`save(DBCollection dbColl, T entity, WriteConcern wc)`
`<T> Iterable<Key<T>>`	`save(Iterable<T> entities)` Saves the entities (Objects) and updates the @Id field
`<T> Iterable<Key<T>>`	`save(Iterable<T> entities, WriteConcern wc)` Saves the entities (Objects) and updates the @Id field, with the WriteConcern
`<T> Key<T>`	`save(String collection, T entity)` Saves an entity in to the named collection.
`<T> Key<T>`	`save(String collection, T entity, WriteConcern wc)` Saves an entity in to the named collection.
`<T> Iterable<Key<T>>`	`save(T... entities)` Saves the entities (Objects) and updates the @Id field
`<T> Key<T>`	`save(T entity)` Saves an entity (Object) and updates the @Id field
`<T> Key<T>`	`save(T entity, WriteConcern wc)` Saves an entity (Object) and updates the @Id field, with the WriteConcern
`void`	`setDecoderFact(DBDecoderFactory fact)` Sets the DBDecoderFactory to use in this Datastore
`void`	`setDefaultWriteConcern(WriteConcern wc)` Sets the default WriteConcern for this Datastore
`void`	`setMapper(Mapper mapper)` Sets the Mapper this Datastore uses
`void`	`setQueryFactory(QueryFactory queryFactory)` Replaces the current `QueryFactory` with the given value.
`protected <T> WriteResult`	`tryVersionedUpdate(DBCollection dbColl, T entity, DBObject dbObj, Object idValue, WriteConcern wc, MappedClass mc)`
`<T> UpdateResults`	`update(Key<T> key, UpdateOperations<T> operations)` Updates an entity with the operations; this is an atomic operation
`<T> UpdateResults`	`update(Query<T> query, UpdateOperations<T> operations)` Updates all entities found with the operations; this is an atomic operation per entity
`<T> UpdateResults`	`update(Query<T> query, UpdateOperations<T> operations, boolean createIfMissing)` Updates all entities found with the operations, if nothing is found insert the update as an entity if "createIfMissing" is true; this is an atomic operation per entity
`<T> UpdateResults`	`update(Query<T> query, UpdateOperations<T> operations, boolean createIfMissing, WriteConcern wc)` Updates all entities found with the operations, if nothing is found insert the update as an entity if "createIfMissing" is true; this is an atomic operation per entity
`<T> UpdateResults`	`update(T entity, UpdateOperations<T> operations)` Updates an entity with the operations; this is an atomic operation
`<T> UpdateResults`	`updateFirst(Query<T> query, T entity, boolean createIfMissing)` updates the first entity found using the entity as a template, if nothing is found insert the update as an entity if "createIfMissing" is true.
`<T> UpdateResults`	`updateFirst(Query<T> query, UpdateOperations<T> operations)` Updates the first entity found with the operations; this is an atomic operation
`<T> UpdateResults`	`updateFirst(Query<T> query, UpdateOperations<T> operations, boolean createIfMissing)` Updates the first entity found with the operations, if nothing is found insert the update as an entity if "createIfMissing" is true.
`<T> UpdateResults`	`updateFirst(Query<T> query, UpdateOperations<T> operations, boolean createIfMissing, WriteConcern wc)` Updates the first entity found with the operations, if nothing is found insert the update as an entity if "createIfMissing" is true.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DatastoreImpl
```
public DatastoreImpl(Morphia morphia,
                     MongoClient mongoClient,
                     String dbName)
```
    Create a new DatastoreImpl
    
    Parameters:
    
    morphia - the Morphia instance
    
    mongoClient - the connection to the MongoDB instance
    
    dbName - the name of the database for this data store.
  - DatastoreImpl
```
public DatastoreImpl(Morphia morphia,
                     Mapper mapper,
                     MongoClient mongoClient,
                     String dbName)
```
    Create a new DatastoreImpl
    
    Parameters:
    
    morphia - the Morphia instance
    
    mapper - an initialised Mapper
    
    mongoClient - the connection to the MongoDB instance
    
    dbName - the name of the database for this data store.
  - DatastoreImpl
```
public DatastoreImpl(Morphia morphia,
                     Mapper mapper,
                     MongoClient mongoClient,
                     DB db)
```
    Create a new DatastoreImpl
    
    Parameters:
    
    morphia - the Morphia instance
    
    mapper - an initialised Mapper
    
    mongoClient - the connection to the MongoDB instance
    
    db - the database for this data store.
- Method Detail
  - copy
```
public DatastoreImpl copy(String database)
```
    Creates a copy of this Datastore and all its configuration but with a new database
    
    Parameters:
    
    database - the new database to use for operations
    
    Returns:
    
    the new Datastore instance
  - createAggregation
```
public AggregationPipeline createAggregation(Class source)
```
    Description copied from interface: Datastore
    
    Returns a new query bound to the kind (a specific DBCollection)
    
    Specified by:
    
    createAggregation in interface Datastore
    
    Parameters:
    
    source - the initial type/collection to aggregate against
    
    Returns:
    
    a new query bound to the kind (a specific DBCollection)
  - createQuery
```
public <T> Query<T> createQuery(Class<T> collection)
```
    Description copied from interface: Datastore
    
    Returns a new query bound to the collection (a specific DBCollection)
    
    Specified by:
    
    createQuery in interface Datastore
    
    Type Parameters:
    
    T - the type of the query
    
    Parameters:
    
    collection - The collection to query
    
    Returns:
    
    the query
  - createUpdateOperations
```
public <T> UpdateOperations<T> createUpdateOperations(Class<T> clazz)
```
    Description copied from interface: Datastore
    
    The builder for all update operations
    
    Specified by:
    
    createUpdateOperations in interface Datastore
    
    Type Parameters:
    
    T - the type to update
    
    Parameters:
    
    clazz - the type to update
    
    Returns:
    
    the new UpdateOperations instance
  - delete
```
public <T,V> WriteResult delete(Class<T> clazz,
                                V id)
```
    Description copied from interface: Datastore
    
    Deletes the given entity (by id)
    
    Specified by:
    
    delete in interface Datastore
    
    Type Parameters:
    
    T - the type to delete
    
    V - the type of the id
    
    Parameters:
    
    clazz - the type to delete
    
    id - the ID of the entity to delete
    
    Returns:
    
    results of the delete
  - delete
```
public <T,V> WriteResult delete(Class<T> clazz,
                                Iterable<V> ids)
```
    Description copied from interface: Datastore
    
    Deletes the given entities (by id)
    
    Specified by:
    
    delete in interface Datastore
    
    Type Parameters:
    
    T - the type to delete
    
    V - the type of the id
    
    Parameters:
    
    clazz - the type to delete
    
    ids - the IDs of the entity to delete
    
    Returns:
    
    results of the delete
  - delete
```
public <T> WriteResult delete(Query<T> query)
```
    Description copied from interface: Datastore
    
    Deletes entities based on the query
    
    Specified by:
    
    delete in interface Datastore
    
    Type Parameters:
    
    T - the type to delete
    
    Parameters:
    
    query - the query to use when finding documents to delete
    
    Returns:
    
    results of the delete
  - delete
```
public <T> WriteResult delete(Query<T> query,
                              WriteConcern wc)
```
    Description copied from interface: Datastore
    
    Deletes entities based on the query, with the WriteConcern
    
    Specified by:
    
    delete in interface Datastore
    
    Type Parameters:
    
    T - the type to delete
    
    Parameters:
    
    query - the query to use when finding documents to delete
    
    wc - the WriteConcern to use when deleting
    
    Returns:
    
    results of the delete
  - delete
```
public <T> WriteResult delete(T entity)
```
    Description copied from interface: Datastore
    
    Deletes the given entity (by @Id)
    
    Specified by:
    
    delete in interface Datastore
    
    Type Parameters:
    
    T - the type to delete
    
    Parameters:
    
    entity - the entity to delete
    
    Returns:
    
    results of the delete
  - delete
```
public <T> WriteResult delete(T entity,
                              WriteConcern wc)
```
    Description copied from interface: Datastore
    
    Deletes the given entity (by @Id), with the WriteConcern
    
    Specified by:
    
    delete in interface Datastore
    
    Type Parameters:
    
    T - the type to delete
    
    Parameters:
    
    entity - the entity to delete
    
    wc - the WriteConcern to use when deleting
    
    Returns:
    
    results of the delete
  - ensureCaps
```
public void ensureCaps()
```
    Description copied from interface: Datastore
    
    ensure capped DBCollections for Entity(s)
    
    Specified by:
    
    ensureCaps in interface Datastore
  - ensureIndex
```
public <T> void ensureIndex(Class<T> type,
                            String fields)
```
    Description copied from interface: Datastore
    
    Ensures (creating if necessary) the index including the field(s) + directions on the given collection name; eg fields = "field1, -field2" ({field1:1, field2:-1})
    
    Specified by:
    
    ensureIndex in interface Datastore
    
    Type Parameters:
    
    T - the type to index
    
    Parameters:
    
    type - the class from which to get the index definitions
    
    fields - the fields to index
  - ensureIndex
```
public <T> void ensureIndex(Class<T> clazz,
                            String name,
                            String fields,
                            boolean unique,
                            boolean dropDupsOnCreate)
```
    Description copied from interface: Datastore
    
    Ensures (creating if necessary) the index including the field(s) + directions on the given collection name; eg fields = "field1, -field2" ({field1:1, field2:-1})
    
    Specified by:
    
    ensureIndex in interface Datastore
    
    Type Parameters:
    
    T - the type to index
    
    Parameters:
    
    clazz - the class from which to get the index definitions
    
    name - the name of the index to create
    
    fields - the fields to index
    
    unique - true if the index should enforce uniqueness on the fields indexed
    
    dropDupsOnCreate - if unique is true and this is true, any documents with duplicated fields being indexed will be dropped. If this is false, index creation will fail.
  - ensureIndexes
```
public void ensureIndexes()
```
    Description copied from interface: Datastore
    
    Ensures (creating if necessary) the indexes found during class mapping (using @Indexed, @Indexes)
    
    Specified by:
    
    ensureIndexes in interface Datastore
  - ensureIndexes
```
public void ensureIndexes(boolean background)
```
    Description copied from interface: Datastore
    
    Ensures (creating if necessary) the indexes found during class mapping (using @Indexed, @Indexes) on the given collection name, possibly in the background
    
    Specified by:
    
    ensureIndexes in interface Datastore
    
    Parameters:
    
    background - if true, the index will be built in the background. If false, the method will block until the index is created.
  - ensureIndexes
```
public <T> void ensureIndexes(Class<T> clazz)
```
    Description copied from interface: Datastore
    
    Ensures (creating if necessary) the indexes found during class mapping (using @Indexed, @Indexes)
    
    Specified by:
    
    ensureIndexes in interface Datastore
    
    Type Parameters:
    
    T - the type to index
    
    Parameters:
    
    clazz - the class from which to get the index definitions
  - ensureIndexes
```
public <T> void ensureIndexes(Class<T> clazz,
                              boolean background)
```
    Description copied from interface: Datastore
    
    Ensures (creating if necessary) the indexes found during class mapping (using @Indexed, @Indexes), possibly in the background
    
    Specified by:
    
    ensureIndexes in interface Datastore
    
    Type Parameters:
    
    T - the type to index
    
    Parameters:
    
    clazz - the class from which to get the index definitions
    
    background - if true, the index will be built in the background. If false, the method will block until the index is created.
  - exists
```
public Key<?> exists(Object entityOrKey)
```
    Description copied from interface: Datastore
    
    Does a query to check if the keyOrEntity exists in mongodb
    
    Specified by:
    
    exists in interface Datastore
    
    Parameters:
    
    entityOrKey - the value to check for
    
    Returns:
    
    the key if the entity exists
  - find
```
public <T> Query<T> find(Class<T> clazz)
```
    Description copied from interface: Datastore
    
    Find all instances by type
    
    Specified by:
    
    find in interface Datastore
    
    Type Parameters:
    
    T - the type to query
    
    Parameters:
    
    clazz - the class to use for mapping the results
    
    Returns:
    
    the query
  - find
```
public <T,V> Query<T> find(Class<T> clazz,
                           String property,
                           V value)
```
    Description copied from interface: Datastore
    
    Find all instances by collectionName, and filter property.
    This is the same as: find(clazzOrEntity).filter (property, value);
    
    Specified by:
    
    find in interface Datastore
    
    Type Parameters:
    
    T - the type to query
    
    V - the type to filter value
    
    Parameters:
    
    clazz - the class to use for mapping the results
    
    property - the document property to query against
    
    value - the value to check for
    
    Returns:
    
    the query
  - find
```
public <T,V> Query<T> find(Class<T> clazz,
                           String property,
                           V value,
                           int offset,
                           int size)
```
    Description copied from interface: Datastore
    
    Find all instances by type in a different collection than what is mapped on the class given skipping some documents and returning a fixed number of the remaining.
    
    Specified by:
    
    find in interface Datastore
    
    Type Parameters:
    
    T - the type to query
    
    V - the type to filter value
    
    Parameters:
    
    clazz - the class to use for mapping the results
    
    property - the document property to query against
    
    value - the value to check for
    
    offset - the number of results to skip
    
    size - the maximum number of results to return
    
    Returns:
    
    the query
  - findAndDelete
```
public <T> T findAndDelete(Query<T> query)
```
    Description copied from interface: Datastore
    
    Deletes the given entities based on the query (first item only).
    
    Specified by:
    
    findAndDelete in interface Datastore
    
    Type Parameters:
    
    T - the type to query
    
    Parameters:
    
    query - the query to use when finding entities to delete
    
    Returns:
    
    the deleted Entity
  - findAndModify
```
public <T> T findAndModify(Query<T> query,
                           UpdateOperations<T> operations)
```
    Description copied from interface: Datastore
    
    Find the first Entity from the Query, and modify it.
    
    Specified by:
    
    findAndModify in interface Datastore
    
    Type Parameters:
    
    T - the type to query
    
    Parameters:
    
    query - the query to use when finding entities to update
    
    operations - the updates to apply to the matched documents
    
    Returns:
    
    The modified Entity (the result of the update)
  - findAndModify
```
public <T> T findAndModify(Query<T> query,
                           UpdateOperations<T> operations,
                           boolean oldVersion)
```
    Description copied from interface: Datastore
    
    Find the first Entity from the Query, and modify it.
    
    Specified by:
    
    findAndModify in interface Datastore
    
    Type Parameters:
    
    T - the type to query
    
    Parameters:
    
    query - the query to find the Entity with; You are not allowed to offset/skip in the query.
    
    operations - the updates to apply to the matched documents
    
    oldVersion - indicated the old version of the Entity should be returned
    
    Returns:
    
    The Entity (the result of the update if oldVersion is false)
  - findAndModify
```
public <T> T findAndModify(Query<T> query,
                           UpdateOperations<T> operations,
                           boolean oldVersion,
                           boolean createIfMissing)
```
    Description copied from interface: Datastore
    
    Find the first Entity from the Query, and modify it.
    
    Specified by:
    
    findAndModify in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    query - the query to find the Entity with; You are not allowed to offset/skip in the query.
    
    operations - the updates to apply to the matched documents
    
    oldVersion - indicated the old version of the Entity should be returned
    
    createIfMissing - if the query returns no results, then a new object will be created (sets upsert=true)
    
    Returns:
    
    The Entity (the result of the update if oldVersion is false)
  - get
```
public <T,V> Query<T> get(Class<T> clazz,
                          Iterable<V> ids)
```
    Description copied from interface: Datastore
    
    Find the given entities (by id); shorthand for find("_id in", ids)
    
    Specified by:
    
    get in interface Datastore
    
    Type Parameters:
    
    T - the type to fetch
    
    V - the type of the ID
    
    Parameters:
    
    clazz - the class to use for mapping
    
    ids - the IDs to query
    
    Returns:
    
    the query to find the entities
  - get
```
public <T,V> T get(Class<T> clazz,
                   V id)
```
    Description copied from interface: Datastore
    
    Find the given entity (by id); shorthand for find("_id ", id)
    
    Specified by:
    
    get in interface Datastore
    
    Type Parameters:
    
    T - the type to fetch
    
    V - the type of the ID
    
    Parameters:
    
    clazz - the class to use for mapping
    
    id - the ID to query
    
    Returns:
    
    the matched entity. may be null.
  - get
```
public <T> T get(T entity)
```
    Description copied from interface: Datastore
    
    Find the given entity (by collectionName/id); think of this as refresh
    
    Specified by:
    
    get in interface Datastore
    
    Type Parameters:
    
    T - the type to fetch
    
    Parameters:
    
    entity - The entity to search for
    
    Returns:
    
    the matched entity. may be null.
  - getByKey
```
public <T> T getByKey(Class<T> clazz,
                      Key<T> key)
```
    Description copied from interface: Datastore
    
    Find the given entity (by collectionName/id);
    
    Specified by:
    
    getByKey in interface Datastore
    
    Type Parameters:
    
    T - the type to fetch
    
    Parameters:
    
    clazz - the class to use for mapping
    
    key - the key search with
    
    Returns:
    
    the matched entity. may be null.
  - getByKeys
```
public <T> List<T> getByKeys(Class<T> clazz,
                             Iterable<Key<T>> keys)
```
    Description copied from interface: Datastore
    
    Find the given entities (by id), verifying they are of the correct type; shorthand for find("_id in", ids)
    
    Specified by:
    
    getByKeys in interface Datastore
    
    Type Parameters:
    
    T - the type to fetch
    
    Parameters:
    
    clazz - the class to use for mapping
    
    keys - the keys to search with
    
    Returns:
    
    the matched entities. may be null.
  - getByKeys
```
public <T> List<T> getByKeys(Iterable<Key<T>> keys)
```
    Description copied from interface: Datastore
    
    Find the given entities (by id); shorthand for find("_id in", ids)
    
    Specified by:
    
    getByKeys in interface Datastore
    
    Type Parameters:
    
    T - the type to fetch
    
    Parameters:
    
    keys - the keys to search with
    
    Returns:
    
    the matched entities. may be null.
  - getCollection
```
public DBCollection getCollection(Class clazz)
```
    Specified by:
    
    getCollection in interface Datastore
    
    Parameters:
    
    clazz - the class to use for mapping
    
    Returns:
    
    the mapped collection for the collection
  - getCount
```
public <T> long getCount(T entity)
```
    Description copied from interface: Datastore
    
    Gets the count this kind (DBCollection)
    
    Specified by:
    
    getCount in interface Datastore
    
    Type Parameters:
    
    T - the type to count
    
    Parameters:
    
    entity - The entity whose type to count
    
    Returns:
    
    the count
  - getCount
```
public <T> long getCount(Class<T> clazz)
```
    Description copied from interface: Datastore
    
    Gets the count this kind (DBCollection)
    
    Specified by:
    
    getCount in interface Datastore
    
    Type Parameters:
    
    T - the type to count
    
    Parameters:
    
    clazz - The clazz type to count
    
    Returns:
    
    the count
  - getCount
```
public <T> long getCount(Query<T> query)
```
    Description copied from interface: Datastore
    
    Gets the count of items returned by this query; same as query.countAll()
    
    Specified by:
    
    getCount in interface Datastore
    
    Type Parameters:
    
    T - the type to count
    
    Parameters:
    
    query - the query to filter the documents to count
    
    Returns:
    
    the count
  - getDB
```
public DB getDB()
```
    Specified by:
    
    getDB in interface Datastore
    
    Returns:
    
    the DB this Datastore uses
  - getDefaultWriteConcern
```
public WriteConcern getDefaultWriteConcern()
```
    Specified by:
    
    getDefaultWriteConcern in interface Datastore
    
    Returns:
    
    the default WriteConcern used by this Datastore
  - setDefaultWriteConcern
```
public void setDefaultWriteConcern(WriteConcern wc)
```
    Description copied from interface: Datastore
    
    Sets the default WriteConcern for this Datastore
    
    Specified by:
    
    setDefaultWriteConcern in interface Datastore
    
    Parameters:
    
    wc - the default WriteConcern to be used by this Datastore
  - getKey
```
@Deprecated
public <T> Key<T> getKey(T entity)
```
    Deprecated.
    
    Description copied from interface: Datastore
    
    Creates a (type-safe) reference to the entity; if stored this will become a DBRef
    
    Specified by:
    
    getKey in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entity - the entity whose key is to be returned
    
    Returns:
    
    the Key
  - getMongo
```
public MongoClient getMongo()
```
    Description copied from interface: Datastore
    
    Get the underlying MongoClient that allows connection to the MongoDB instance being used.
    
    Specified by:
    
    getMongo in interface Datastore
    
    Returns:
    
    the MongoClient being used by this datastore.
  - getQueryFactory
```
public QueryFactory getQueryFactory()
```
    Specified by:
    
    getQueryFactory in interface Datastore
    
    Returns:
    
    the current QueryFactory.
    
    See Also:
    
    QueryFactory
  - setQueryFactory
```
public void setQueryFactory(QueryFactory queryFactory)
```
    Description copied from interface: Datastore
    
    Replaces the current QueryFactory with the given value.
    
    Specified by:
    
    setQueryFactory in interface Datastore
    
    Parameters:
    
    queryFactory - the QueryFactory to use
    
    See Also:
    
    QueryFactory
  - mapReduce
```
public <T> MapreduceResults<T> mapReduce(MapreduceType type,
                                         Query query,
                                         String map,
                                         String reduce,
                                         String finalize,
                                         Map<String,Object> scopeFields,
                                         Class<T> outputType)
```
    Description copied from interface: Datastore
    
    Runs a map/reduce job at the server; this should be used with a server version 1.7.4 or higher
    
    Specified by:
    
    mapReduce in interface Datastore
    
    Type Parameters:
    
    T - The type of resulting data
    
    Parameters:
    
    type - MapreduceType
    
    query - The query (only the criteria, limit and sort will be used)
    
    map - The map function, in javascript, as a string
    
    reduce - The reduce function, in javascript, as a string
    
    finalize - The finalize function, in javascript, as a string; can be null
    
    scopeFields - Each map entry will be a global variable in all the functions; can be null
    
    outputType - The type of resulting data; inline is not working yet
    
    Returns:
    
    counts and stuff
  - mapReduce
```
public <T> MapreduceResults<T> mapReduce(MapreduceType type,
                                         Query query,
                                         Class<T> outputType,
                                         MapReduceCommand baseCommand)
```
    Description copied from interface: Datastore
    
    Runs a map/reduce job at the server; this should be used with a server version 1.7.4 or higher
    
    Specified by:
    
    mapReduce in interface Datastore
    
    Type Parameters:
    
    T - The type of resulting data
    
    Parameters:
    
    type - MapreduceType
    
    query - The query (only the criteria, limit and sort will be used)
    
    outputType - The type of resulting data; inline is not working yet
    
    baseCommand - The base command to fill in and send to the server
    
    Returns:
    
    counts and stuff
  - merge
```
public <T> Key<T> merge(T entity)
```
    Description copied from interface: Datastore
    
    Work as if you did an update with each field in the entity doing a $set; Only at the top level of the entity.
    
    Specified by:
    
    merge in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entity - the entity to merge back in to the database
    
    Returns:
    
    the key of the entity
  - merge
```
public <T> Key<T> merge(T entity,
                        WriteConcern wc)
```
    Description copied from interface: Datastore
    
    Work as if you did an update with each field in the entity doing a $set; Only at the top level of the entity.
    
    Specified by:
    
    merge in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entity - the entity to merge back in to the database
    
    wc - the WriteConcern to use
    
    Returns:
    
    the key of the entity
  - queryByExample
```
public <T> Query<T> queryByExample(T ex)
```
    Description copied from interface: Datastore
    
    Returns a new query based on the example object
    
    Specified by:
    
    queryByExample in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    ex - the example entity to use when creating the query
    
    Returns:
    
    the query
  - save
```
public <T> Iterable<Key<T>> save(Iterable<T> entities)
```
    Description copied from interface: Datastore
    
    Saves the entities (Objects) and updates the @Id field
    
    Specified by:
    
    save in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entities - the entities to save
    
    Returns:
    
    the keys of the entities
  - save
```
public <T> Iterable<Key<T>> save(Iterable<T> entities,
                                 WriteConcern wc)
```
    Description copied from interface: Datastore
    
    Saves the entities (Objects) and updates the @Id field, with the WriteConcern
    
    Specified by:
    
    save in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entities - the entities to save
    
    wc - the WriteConcern to use
    
    Returns:
    
    the keys of the entities
  - save
```
public <T> Iterable<Key<T>> save(T... entities)
```
    Description copied from interface: Datastore
    
    Saves the entities (Objects) and updates the @Id field
    
    Specified by:
    
    save in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entities - the entities to save
    
    Returns:
    
    the keys of the entities
  - save
```
public <T> Key<T> save(T entity)
```
    Description copied from interface: Datastore
    
    Saves an entity (Object) and updates the @Id field
    
    Specified by:
    
    save in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entity - the entity to save
    
    Returns:
    
    the keys of the entity
  - save
```
public <T> Key<T> save(T entity,
                       WriteConcern wc)
```
    Description copied from interface: Datastore
    
    Saves an entity (Object) and updates the @Id field, with the WriteConcern
    
    Specified by:
    
    save in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entity - the entity to save
    
    wc - the WriteConcern to use
    
    Returns:
    
    the keys of the entity
  - update
```
public <T> UpdateResults update(T entity,
                                UpdateOperations<T> operations)
```
    Description copied from interface: Datastore
    
    Updates an entity with the operations; this is an atomic operation
    
    Specified by:
    
    update in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entity - the entity to update
    
    operations - the update operations to perform
    
    Returns:
    
    the update results
    
    See Also:
    
    UpdateResults
  - update
```
public <T> UpdateResults update(Key<T> key,
                                UpdateOperations<T> operations)
```
    Description copied from interface: Datastore
    
    Updates an entity with the operations; this is an atomic operation
    
    Specified by:
    
    update in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    key - the key of entity to update
    
    operations - the update operations to perform
    
    Returns:
    
    the update results
    
    See Also:
    
    UpdateResults
  - update
```
public <T> UpdateResults update(Query<T> query,
                                UpdateOperations<T> operations)
```
    Description copied from interface: Datastore
    
    Updates all entities found with the operations; this is an atomic operation per entity
    
    Specified by:
    
    update in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    query - the query used to match the documents to update
    
    operations - the update operations to perform
    
    Returns:
    
    the results of the updates
  - update
```
public <T> UpdateResults update(Query<T> query,
                                UpdateOperations<T> operations,
                                boolean createIfMissing)
```
    Description copied from interface: Datastore
    
    Updates all entities found with the operations, if nothing is found insert the update as an entity if "createIfMissing" is true; this is an atomic operation per entity
    
    Specified by:
    
    update in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    query - the query used to match the documents to update
    
    operations - the update operations to perform
    
    createIfMissing - if true, a document will be created if none can be found that match the query
    
    Returns:
    
    the results of the updates
  - update
```
public <T> UpdateResults update(Query<T> query,
                                UpdateOperations<T> operations,
                                boolean createIfMissing,
                                WriteConcern wc)
```
    Description copied from interface: Datastore
    
    Updates all entities found with the operations, if nothing is found insert the update as an entity if "createIfMissing" is true; this is an atomic operation per entity
    
    Specified by:
    
    update in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    query - the query used to match the documents to update
    
    operations - the update operations to perform
    
    createIfMissing - if true, a document will be created if none can be found that match the query
    
    wc - the WriteConcern to use
    
    Returns:
    
    the results of the updates
  - updateFirst
```
public <T> UpdateResults updateFirst(Query<T> query,
                                     UpdateOperations<T> operations)
```
    Description copied from interface: Datastore
    
    Updates the first entity found with the operations; this is an atomic operation
    
    Specified by:
    
    updateFirst in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    query - the query used to match the document to update
    
    operations - the update operations to perform
    
    Returns:
    
    the results of the update
  - updateFirst
```
public <T> UpdateResults updateFirst(Query<T> query,
                                     UpdateOperations<T> operations,
                                     boolean createIfMissing)
```
    Description copied from interface: Datastore
    
    Updates the first entity found with the operations, if nothing is found insert the update as an entity if "createIfMissing" is true.
    
    Specified by:
    
    updateFirst in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    query - the query used to match the documents to update
    
    operations - the update operations to perform
    
    createIfMissing - if true, a document will be created if none can be found that match the query
    
    Returns:
    
    the results of the updates
  - updateFirst
```
public <T> UpdateResults updateFirst(Query<T> query,
                                     UpdateOperations<T> operations,
                                     boolean createIfMissing,
                                     WriteConcern wc)
```
    Description copied from interface: Datastore
    
    Updates the first entity found with the operations, if nothing is found insert the update as an entity if "createIfMissing" is true.
    
    Specified by:
    
    updateFirst in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    query - the query used to match the documents to update
    
    operations - the update operations to perform
    
    createIfMissing - if true, a document will be created if none can be found that match the query
    
    wc - the WriteConcern to use
    
    Returns:
    
    the results of the updates
  - updateFirst
```
public <T> UpdateResults updateFirst(Query<T> query,
                                     T entity,
                                     boolean createIfMissing)
```
    Description copied from interface: Datastore
    
    updates the first entity found using the entity as a template, if nothing is found insert the update as an entity if "createIfMissing" is true.
    
    Specified by:
    
    updateFirst in interface Datastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    query - the query used to match the documents to update
    
    entity - the entity whose state will be used as an update template for any matching documents
    
    createIfMissing - if true, a document will be created if none can be found that match the query
    
    Returns:
    
    the results of the updates
  - createQuery
```
public <T> Query<T> createQuery(String collection,
                                Class<T> type)
```
    Specified by:
    
    createQuery in interface AdvancedDatastore
    
    Type Parameters:
    
    T - The type of the entity
    
    Parameters:
    
    collection - the collection to query
    
    type - the class of objects to be returned
    
    Returns:
    
    Query for the specified class clazz
  - createQuery
```
public <T> Query<T> createQuery(Class<T> clazz,
                                DBObject q)
```
    Specified by:
    
    createQuery in interface AdvancedDatastore
    
    Type Parameters:
    
    T - The type of the entity
    
    Parameters:
    
    clazz - the class of objects to be returned
    
    q - the query which will be passed to a QueryFactory
    
    Returns:
    
    Query for the specified class clazz
  - createQuery
```
public <T> Query<T> createQuery(String collection,
                                Class<T> type,
                                DBObject q)
```
    Specified by:
    
    createQuery in interface AdvancedDatastore
    
    Type Parameters:
    
    T - The type of the entity
    
    Parameters:
    
    collection - the collection to query
    
    type - the class of objects to be returned
    
    q - the query which will be passed to a QueryFactory
    
    Returns:
    
    Query for the specified class clazz
  - createRef
```
public <T,V> DBRef createRef(Class<T> clazz,
                             V id)
```
    Description copied from interface: AdvancedDatastore
    
    Creates a reference to the entity (using the current DB -can be null-, the collectionName, and id)
    
    Specified by:
    
    createRef in interface AdvancedDatastore
    
    Type Parameters:
    
    T - The type of the entity
    
    V - The type of the ID value
    
    Parameters:
    
    clazz - The type of the entity
    
    id - The ID value of the entity
    
    Returns:
    
    the DBRef for the entity
  - createRef
```
public <T> DBRef createRef(T entity)
```
    Description copied from interface: AdvancedDatastore
    
    Creates a reference to the entity (using the current DB -can be null-, the collectionName, and id)
    
    Specified by:
    
    createRef in interface AdvancedDatastore
    
    Type Parameters:
    
    T - The type of the entity
    
    Parameters:
    
    entity - the entity to create a DBRef for
    
    Returns:
    
    the DBRef for the entity
  - createUpdateOperations
```
public <T> UpdateOperations<T> createUpdateOperations(Class<T> type,
                                                      DBObject ops)
```
    Description copied from interface: AdvancedDatastore
    
    Creates an UpdateOperations instance for the given type.
    
    Specified by:
    
    createUpdateOperations in interface AdvancedDatastore
    
    Type Parameters:
    
    T - The type of the entity
    
    Parameters:
    
    type - The type of the entity
    
    ops - The operations to perform
    
    Returns:
    
    the UpdateOperations instance
  - delete
```
public <T,V> WriteResult delete(String kind,
                                Class<T> clazz,
                                V id)
```
    Description copied from interface: AdvancedDatastore
    
    Deletes an entity of the given type T, with the given id, from the collection with the name in the kind param. Validates the id, checking it's the correct type for an ID for entities of type T. The entity type clazz is used only for validation, not for filtering, therefore if you have entities of different types in the same collection (kind), this method will delete any entity with the given id, regardless of its type.
    
    Specified by:
    
    delete in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the entity type
    
    V - is the type of the ID, for example ObjectId
    
    Parameters:
    
    kind - the collection name
    
    clazz - the Class of the entity to delete
    
    id - the value of the ID
    
    Returns:
    
    the result of this delete operation.
  - delete
```
public <T,V> WriteResult delete(String kind,
                                Class<T> clazz,
                                V id,
                                WriteConcern wc)
```
    Description copied from interface: AdvancedDatastore
    
    Deletes an entity of the given type T, with the given id, from the collection with the name in the kind param. Validates the id, checking it's the correct type for an ID for entities of type T. The entity type clazz is used only for validation, not for filtering, therefore if you have entities of different types in the same collection (kind), this method will delete any entity with the given id, regardless of its type.
    
    Specified by:
    
    delete in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the entity type
    
    V - is the type of the ID, for example ObjectId
    
    Parameters:
    
    kind - the collection name
    
    clazz - the Class of the entity to delete
    
    id - the value of the ID
    
    wc - the WriteConcern for this operation
    
    Returns:
    
    the result of this delete operation.
  - ensureIndex
```
public <T> void ensureIndex(String collection,
                            Class<T> type,
                            String fields)
```
    Description copied from interface: AdvancedDatastore
    
    Ensures (creating if necessary) the index including the field(s) + directions on the given collection name; eg fields = "field1, -field2" ({field1:1, field2:-1})
    
    Specified by:
    
    ensureIndex in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type to index
    
    Parameters:
    
    collection - the collection to update
    
    type - the class from which to get the index definitions
    
    fields - the fields to index
  - ensureIndex
```
public <T> void ensureIndex(String collection,
                            Class<T> clazz,
                            String name,
                            String fields,
                            boolean unique,
                            boolean dropDupsOnCreate)
```
    Description copied from interface: AdvancedDatastore
    
    Ensures (creating if necessary) the index including the field(s) + directions on the given collection name; eg fields = "field1, -field2" ({field1:1, field2:-1})
    
    Specified by:
    
    ensureIndex in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type to index
    
    Parameters:
    
    collection - the collection to update
    
    clazz - the class from which to get the index definitions
    
    name - the name of the index to create
    
    fields - the fields to index
    
    unique - true if the index should enforce uniqueness on the fields indexed
    
    dropDupsOnCreate - if unique is true and this is true, any documents with duplicated fields being indexed will be dropped. If this is false, index creation will fail.
  - ensureIndexes
```
public <T> void ensureIndexes(String collection,
                              Class<T> clazz)
```
    Description copied from interface: AdvancedDatastore
    
    Ensures (creating if necessary) the indexes found during class mapping (using @Indexed, @Indexes) on the given collection name.
    
    Specified by:
    
    ensureIndexes in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type to index
    
    Parameters:
    
    collection - the collection to update
    
    clazz - the class from which to get the index definitions
  - ensureIndexes
```
public <T> void ensureIndexes(String collection,
                              Class<T> clazz,
                              boolean background)
```
    Description copied from interface: AdvancedDatastore
    
    Ensures (creating if necessary) the indexes found during class mapping (using @Indexed, @Indexes) on the given collection name, possibly in the background
    
    Specified by:
    
    ensureIndexes in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type to index
    
    Parameters:
    
    collection - the collection to update
    
    clazz - the class from which to get the index definitions
    
    background - if true, the index will be built in the background. If false, the method will block until the index is created.
  - exists
```
public Key<?> exists(Object entityOrKey,
                     ReadPreference readPreference)
```
    Description copied from interface: AdvancedDatastore
    
    Checks that an entity exists for the given key or entity
    
    Specified by:
    
    exists in interface AdvancedDatastore
    
    Parameters:
    
    entityOrKey - the value to check for
    
    readPreference - Uses the supplied ReadPreference for the check. If readPreference is null the preference is taken from the annotation or uses the default preference.
    
    Returns:
    
    the key if the entity exists
    
    See Also:
    
    Datastore.exists(Object)
  - find
```
public <T> Query<T> find(String collection,
                         Class<T> clazz)
```
    Description copied from interface: AdvancedDatastore
    
    Find all instances by type in a different collection than what is mapped on the class given.
    
    Specified by:
    
    find in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type to query
    
    Parameters:
    
    collection - the collection to query against
    
    clazz - the class to use for mapping the results
    
    Returns:
    
    the query
  - find
```
public <T,V> Query<T> find(String collection,
                           Class<T> clazz,
                           String property,
                           V value,
                           int offset,
                           int size)
```
    Description copied from interface: AdvancedDatastore
    
    Find all instances by type in a different collection than what is mapped on the class given skipping some documents and returning a fixed number of the remaining.
    
    Specified by:
    
    find in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type to query
    
    V - the type to filter value
    
    Parameters:
    
    collection - the collection to query against
    
    clazz - the class to use for mapping the results
    
    property - the document property to query against
    
    value - the value to check for
    
    offset - the number of results to skip
    
    size - the maximum number of results to return
    
    Returns:
    
    the query
  - get
```
public <T> T get(Class<T> clazz,
                 DBRef ref)
```
    Description copied from interface: AdvancedDatastore
    
    Find the given entity (by collectionName/id);
    
    Specified by:
    
    get in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type to fetch
    
    Parameters:
    
    clazz - the class to use for mapping
    
    ref - the DBRef to use when querying
    
    Returns:
    
    the entity referenced in the DBRef. May be null.
  - get
```
public <T,V> T get(String collection,
                   Class<T> clazz,
                   V id)
```
    Description copied from interface: AdvancedDatastore
    
    Finds an entity in the named collection whose id matches the value given.
    
    Specified by:
    
    get in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type to fetch
    
    V - the type of the ID
    
    Parameters:
    
    collection - the collection to query
    
    clazz - the class to use for mapping
    
    id - the ID to query
    
    Returns:
    
    the entity with the id. May be null.
  - getCount
```
public long getCount(String collection)
```
    Description copied from interface: AdvancedDatastore
    
    Gets the count this collection
    
    Specified by:
    
    getCount in interface AdvancedDatastore
    
    Parameters:
    
    collection - the collection to count
    
    Returns:
    
    the collection size
  - getDecoderFact
```
public DBDecoderFactory getDecoderFact()
```
    Description copied from interface: AdvancedDatastore
    
    Returns the DBDecoderFactory used by this Datastore
    
    Specified by:
    
    getDecoderFact in interface AdvancedDatastore
    
    Returns:
    
    the decoder factory
    
    See Also:
    
    DBDecoderFactory
  - setDecoderFact
```
public void setDecoderFact(DBDecoderFactory fact)
```
    Description copied from interface: AdvancedDatastore
    
    Sets the DBDecoderFactory to use in this Datastore
    
    Specified by:
    
    setDecoderFact in interface AdvancedDatastore
    
    Parameters:
    
    fact - the DBDecoderFactory to use
  - insert
```
public <T> Key<T> insert(String collection,
                         T entity)
```
    Description copied from interface: AdvancedDatastore
    
    Inserts an entity in to the named collection.
    
    Specified by:
    
    insert in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    collection - the collection to update
    
    entity - the entity to insert
    
    Returns:
    
    the new key of the inserted entity
  - insert
```
public <T> Key<T> insert(T entity)
```
    Description copied from interface: AdvancedDatastore
    
    Inserts an entity in to the mapped collection.
    
    Specified by:
    
    insert in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entity - the entity to insert
    
    Returns:
    
    the new key of the inserted entity
  - insert
```
public <T> Key<T> insert(T entity,
                         WriteConcern wc)
```
    Description copied from interface: AdvancedDatastore
    
    Inserts an entity in to the mapped collection.
    
    Specified by:
    
    insert in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entity - the entity to insert
    
    wc - the WriteConcern to use when inserting
    
    Returns:
    
    the new key of the inserted entity
    
    See Also:
    
    WriteConcern
  - insert
```
public <T> Iterable<Key<T>> insert(T... entities)
```
    Description copied from interface: AdvancedDatastore
    
    Inserts entities in to the mapped collection.
    
    Specified by:
    
    insert in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entities - the entities to insert
    
    Returns:
    
    the new keys of the inserted entities
  - insert
```
public <T> Iterable<Key<T>> insert(Iterable<T> entities,
                                   WriteConcern wc)
```
    Description copied from interface: AdvancedDatastore
    
    Inserts entities in to the mapped collection.
    
    Specified by:
    
    insert in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    entities - the entities to insert
    
    wc - the WriteConcern to use when inserting
    
    Returns:
    
    the new keys of the inserted entities
  - insert
```
public <T> Iterable<Key<T>> insert(String collection,
                                   Iterable<T> entities)
```
    Description copied from interface: AdvancedDatastore
    
    Inserts an entity in to the named collection.
    
    Specified by:
    
    insert in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    collection - the collection to update
    
    entities - the entities to insert
    
    Returns:
    
    the new keys of the inserted entities
    
    See Also:
    
    WriteConcern
  - insert
```
public <T> Iterable<Key<T>> insert(String collection,
                                   Iterable<T> entities,
                                   WriteConcern wc)
```
    Description copied from interface: AdvancedDatastore
    
    Inserts an entity in to the named collection.
    
    Specified by:
    
    insert in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    collection - the collection to update
    
    entities - the entities to insert
    
    wc - the WriteConcern to use when inserting
    
    Returns:
    
    the new keys of the inserted entities
    
    See Also:
    
    WriteConcern
  - queryByExample
```
public <T> Query<T> queryByExample(String collection,
                                   T ex)
```
    Description copied from interface: AdvancedDatastore
    
    Returns a new query based on the example object
    
    Specified by:
    
    queryByExample in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    collection - the collection to query
    
    ex - the example entity to use when building the query
    
    Returns:
    
    the query
  - save
```
public <T> Key<T> save(String collection,
                       T entity)
```
    Description copied from interface: AdvancedDatastore
    
    Saves an entity in to the named collection.
    
    Specified by:
    
    save in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    collection - the collection to update
    
    entity - the entity to insert
    
    Returns:
    
    the new key of the inserted entity
  - save
```
public <T> Key<T> save(String collection,
                       T entity,
                       WriteConcern wc)
```
    Description copied from interface: AdvancedDatastore
    
    Saves an entity in to the named collection.
    
    Specified by:
    
    save in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type of the entity
    
    Parameters:
    
    collection - the collection to update
    
    entity - the entity to insert
    
    wc - the WriteConcern to use when inserting
    
    Returns:
    
    the new key of the inserted entity
  - delete
```
public <T,V> WriteResult delete(Class<T> clazz,
                                V id,
                                WriteConcern wc)
```
    Deletes entities based on the query, with the WriteConcern
    
    Type Parameters:
    
    T - the type to delete
    
    V - the type of the key
    
    Parameters:
    
    clazz - the clazz to query against when finding documents to delete
    
    id - the ID to look for
    
    wc - the WriteConcern to use when deleting
    
    Returns:
    
    results of the delete
  - find
```
public <T,V> Query<T> find(String collection,
                           Class<T> clazz,
                           String property,
                           V value,
                           int offset,
                           int size,
                           boolean validate)
```
    Find all instances by type in a different collection than what is mapped on the class given skipping some documents and returning a fixed number of the remaining.
    
    Type Parameters:
    
    T - the type to query
    
    V - the type to filter value
    
    Parameters:
    
    collection - The collection use when querying
    
    clazz - the class to use for mapping the results
    
    property - the document property to query against
    
    value - the value to check for
    
    offset - the number of results to skip
    
    size - the maximum number of results to return
    
    validate - if true, validate the query
    
    Returns:
    
    the query
  - getCollection
```
public DBCollection getCollection(Object obj)
```
    Parameters:
    
    obj - the instance to use for looking up the collection mapping
    
    Returns:
    
    the collection mapped for the type of obj
  - getMapper
```
public Mapper getMapper()
```
    Returns:
    
    the Mapper used by this Datastore
  - setMapper
```
public void setMapper(Mapper mapper)
```
    Sets the Mapper this Datastore uses
    
    Parameters:
    
    mapper - the new Mapper
  - insert
```
public <T> Iterable<Key<T>> insert(Iterable<T> entities)
```
    Inserts entities in to the database
    
    Specified by:
    
    insert in interface AdvancedDatastore
    
    Type Parameters:
    
    T - the type of the entities
    
    Parameters:
    
    entities - the entities to insert
    
    Returns:
    
    the keys of entities
  - insert
```
public <T> Key<T> insert(String collection,
                         T entity,
                         WriteConcern wc)
```
    Inserts an entity in to the database
    
    Type Parameters:
    
    T - the type of the entities
    
    Parameters:
    
    collection - the collection to query against
    
    entity - the entity to insert
    
    wc - the WriteConcern to use when deleting
    
    Returns:
    
    the key of entity
  - ensureIndex
```
protected <T> void ensureIndex(Class<T> clazz,
                               String name,
                               BasicDBObject fields,
                               boolean unique,
                               boolean dropDupsOnCreate,
                               boolean background,
                               boolean sparse,
                               int expireAfterSeconds)
```
  - ensureIndex
```
protected void ensureIndex(DBCollection dbColl,
                           String name,
                           BasicDBObject fields,
                           boolean unique,
                           boolean dropDupsOnCreate,
                           boolean background,
                           boolean sparse,
                           int expireAfterSeconds)
```
  - ensureIndex
```
protected void ensureIndex(MappedClass mc,
                           DBCollection dbColl,
                           Field[] fields,
                           IndexOptions options,
                           boolean background,
                           List<MappedClass> parentMCs,
                           List<MappedField> parentMFs)
```
  - ensureIndex
```
protected void ensureIndex(DBCollection dbColl,
                           DBObject keys,
                           DBObject options)
```
  - ensureIndexes
```
protected void ensureIndexes(MappedClass mc,
                             boolean background,
                             List<MappedClass> parentMCs,
                             List<MappedField> parentMFs)
```
  - ensureIndexes
```
protected void ensureIndexes(String collName,
                             MappedClass mc,
                             boolean background)
```
  - ensureIndexes
```
protected void ensureIndexes(DBCollection dbColl,
                             MappedClass mc,
                             boolean background,
                             List<MappedClass> parentMCs,
                             List<MappedField> parentMFs)
```
  - ensureIndexes
```
protected void ensureIndexes(MappedClass mc,
                             boolean background)
```
  - getCollection
```
protected DBCollection getCollection(String kind)
```
  - getId
```
@Deprecated
protected Object getId(Object entity)
```
    Deprecated.
  - insert
```
protected <T> Key<T> insert(DBCollection dbColl,
                            T entity,
                            WriteConcern wc)
```
  - save
```
protected <T> Key<T> save(DBCollection dbColl,
                          T entity,
                          WriteConcern wc)
```
  - tryVersionedUpdate
```
protected <T> WriteResult tryVersionedUpdate(DBCollection dbColl,
                                             T entity,
                                             DBObject dbObj,
                                             Object idValue,
                                             WriteConcern wc,
                                             MappedClass mc)
```

Class DatastoreImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DatastoreImpl

DatastoreImpl

DatastoreImpl

Method Detail

copy

createAggregation

createQuery

createUpdateOperations

delete

delete

delete

delete

delete

delete

ensureCaps

ensureIndex

ensureIndex

ensureIndexes

ensureIndexes

ensureIndexes

ensureIndexes

exists

find

find

find

findAndDelete

findAndModify

findAndModify

findAndModify

get

get

get

getByKey

getByKeys

getByKeys

getCollection

getCount

getCount

getCount

getDB

getDefaultWriteConcern

setDefaultWriteConcern

getKey

getMongo

getQueryFactory

setQueryFactory

mapReduce

mapReduce

merge

merge

queryByExample

save

save

save

save

save

update

update

update

update

update

updateFirst

updateFirst

updateFirst

updateFirst

createQuery

createQuery

createQuery

createRef

createRef

createUpdateOperations

delete

delete

ensureIndex

ensureIndex