/**********************************************************************
Copyright (c) 2011 Andy Jefferson. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Contributors :
...
***********************************************************************/
package org.datanucleus.store.mongodb;
import java.sql.Timestamp;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBObject;
import com.mongodb.MongoException;
import com.mongodb.WriteConcern;
import org.bson.types.ObjectId;
import org.datanucleus.exceptions.NucleusDataStoreException;
import org.datanucleus.exceptions.NucleusObjectNotFoundException;
import org.datanucleus.exceptions.NucleusOptimisticException;
import org.datanucleus.exceptions.NucleusUserException;
import org.datanucleus.identity.OID;
import org.datanucleus.metadata.AbstractClassMetaData;
import org.datanucleus.metadata.AbstractMemberMetaData;
import org.datanucleus.metadata.DiscriminatorMetaData;
import org.datanucleus.metadata.DiscriminatorStrategy;
import org.datanucleus.metadata.IdentityStrategy;
import org.datanucleus.metadata.IdentityType;
import org.datanucleus.metadata.VersionMetaData;
import org.datanucleus.metadata.VersionStrategy;
import org.datanucleus.store.AbstractPersistenceHandler;
import org.datanucleus.store.ExecutionContext;
import org.datanucleus.store.ObjectProvider;
import org.datanucleus.store.StoreManager;
import org.datanucleus.store.VersionHelper;
import org.datanucleus.store.connection.ManagedConnection;
import org.datanucleus.store.fieldmanager.DeleteFieldManager;
import org.datanucleus.store.mongodb.fieldmanager.FetchFieldManager;
import org.datanucleus.store.mongodb.fieldmanager.StoreFieldManager;
import org.datanucleus.util.Localiser;
import org.datanucleus.util.NucleusLogger;
import org.datanucleus.util.StringUtils;
public class MongoDBPersistenceHandler extends AbstractPersistenceHandler
{
protected static final Localiser LOCALISER = Localiser.getInstance(
"org.datanucleus.store.mongodb.Localisation", MongoDBStoreManager.class.getClassLoader());
protected final MongoDBStoreManager storeMgr;
public MongoDBPersistenceHandler(StoreManager storeMgr)
{
this.storeMgr = (MongoDBStoreManager) storeMgr;
}
public void close()
{
}
/* (non-Javadoc)
* @see org.datanucleus.store.AbstractPersistenceHandler#batchStart(org.datanucleus.store.ExecutionContext)
*/
@Override
public void batchStart(ExecutionContext ec)
{
// TODO When we support batched inserts/deletes this should set a flag for this thread
}
/* (non-Javadoc)
* @see org.datanucleus.store.AbstractPersistenceHandler#batchEnd(org.datanucleus.store.ExecutionContext)
*/
@Override
public void batchEnd(ExecutionContext ec)
{
// TODO When we support batched inserts/deletes this should process the inserts/deletes
}
/* (non-Javadoc)
* @see org.datanucleus.store.AbstractPersistenceHandler#insertObjects(org.datanucleus.store.ObjectProvider[])
*/
@Override
public void insertObjects(ObjectProvider... ops)
{
if (ops.length == 1)
{
insertObject(ops[0]);
return;
}
// Process "identity" cases first in case they are referenced
for (int i=0;i<ops.length;i++)
{
AbstractClassMetaData cmd = ops[i].getClassMetaData();
if (cmd.pkUsesIdentityValueGenerator())
{
insertObject(ops[i]);
}
}
// Separate the objects to be persisted into groups, for the "table" in question
Map<String, Set<ObjectProvider>> opsByTable = new HashMap();
for (int i=0;i<ops.length;i++)
{
AbstractClassMetaData cmd = ops[i].getClassMetaData();
if (!cmd.pkUsesIdentityValueGenerator())
{
String tableName = MongoDBUtils.getCollectionName(cmd);
Set<ObjectProvider> opsForTable = opsByTable.get(tableName);
if (opsForTable == null)
{
opsForTable = new HashSet<ObjectProvider>();
opsByTable.put(tableName, opsForTable);
}
opsForTable.add(ops[i]);
}
}
for (String tableName : opsByTable.keySet())
{
Set<ObjectProvider> opsForTable = opsByTable.get(tableName);
ExecutionContext ec = ops[0].getExecutionContext();
ManagedConnection mconn = storeMgr.getConnection(ec);
try
{
DB db = (DB)mconn.getConnection();
long startTime = System.currentTimeMillis();
DBCollection collection = db.getCollection(tableName);
DBObject[] dbObjects = new DBObject[opsForTable.size()];
int i=0;
for (ObjectProvider op : opsForTable)
{
storeMgr.assertReadOnlyForUpdateOfObject(op);
AbstractClassMetaData cmd = op.getClassMetaData();
if (!storeMgr.managesClass(cmd.getFullClassName()))
{
storeMgr.addClass(cmd.getFullClassName(), op.getExecutionContext().getClassLoaderResolver());
}
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.Start",
op.toPrintableID(), op.getInternalObjectId()));
}
dbObjects[i] = getDBObjectForObjectProviderToInsert(op);
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.ObjectPersisted",
op.toPrintableID(), op.getInternalObjectId()));
}
i++;
}
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug("Persisting objects as " + StringUtils.objectArrayToString(dbObjects));
}
collection.insert(dbObjects, new WriteConcern(1));
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.ExecutionTime",
(System.currentTimeMillis() - startTime)));
}
if (storeMgr.getRuntimeManager() != null)
{
for (int j=0;j<dbObjects.length;j++)
{
storeMgr.getRuntimeManager().incrementInsertCount();
}
}
}
catch (MongoException me)
{
NucleusLogger.PERSISTENCE.error("Exception inserting objects", me);
throw new NucleusDataStoreException("Exception inserting objects", me);
}
finally
{
mconn.release();
}
}
}
public void insertObject(ObjectProvider op)
{
storeMgr.assertReadOnlyForUpdateOfObject(op);
AbstractClassMetaData cmd = op.getClassMetaData();
if (!storeMgr.managesClass(cmd.getFullClassName()))
{
storeMgr.addClass(cmd.getFullClassName(), op.getExecutionContext().getClassLoaderResolver());
}
ExecutionContext ec = op.getExecutionContext();
ManagedConnection mconn = storeMgr.getConnection(ec);
try
{
DB db = (DB)mconn.getConnection();
long startTime = System.currentTimeMillis();
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.Start",
op.toPrintableID(), op.getInternalObjectId()));
}
DBCollection collection = db.getCollection(MongoDBUtils.getCollectionName(cmd));
DBObject dbObject = getDBObjectForObjectProviderToInsert(op);
NucleusLogger.DATASTORE_PERSIST.debug("Persisting object " + op + " as " + dbObject);
collection.insert(dbObject, new WriteConcern(1));
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.ObjectPersisted",
op.toPrintableID(), op.getInternalObjectId()));
}
// Retrieve any datastore-generated IDENTITY strategy value as necessary
if (cmd.getIdentityType() == IdentityType.DATASTORE &&
cmd.getIdentityMetaData().getValueStrategy() == IdentityStrategy.IDENTITY)
{
// Set identity from MongoDB "_id" field
ObjectId idKey = (ObjectId) dbObject.get("_id");
op.setPostStoreNewObjectId(idKey.toString());
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.ObjectPersistedWithIdentity",
op.toPrintableID(), idKey));
}
}
else if (cmd.getIdentityType() == IdentityType.APPLICATION)
{
int[] pkFieldNumbers = cmd.getPKMemberPositions();
for (int i=0;i<pkFieldNumbers.length;i++)
{
AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(pkFieldNumbers[i]);
if (mmd.getValueStrategy() == IdentityStrategy.IDENTITY)
{
if (mmd.getType() != String.class)
{
// Field type must be String since MongoDB "_id" is a hex String.
throw new NucleusUserException("Any field using IDENTITY value generation with MongoDB should be of type String");
}
ObjectId idKey = (ObjectId)dbObject.get("_id");
op.replaceField(mmd.getAbsoluteFieldNumber(), idKey.toString());
op.setPostStoreNewObjectId(idKey); // TODO This is incorrect if part of a composite PK
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.ObjectPersistedWithIdentity",
op.toPrintableID(), idKey));
}
}
}
}
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.ExecutionTime",
(System.currentTimeMillis() - startTime)));
}
if (storeMgr.getRuntimeManager() != null)
{
storeMgr.getRuntimeManager().incrementInsertCount();
}
}
catch (MongoException me)
{
NucleusLogger.PERSISTENCE.error("Exception inserting object " + op, me);
throw new NucleusDataStoreException("Exception inserting object for " + op, me);
}
finally
{
mconn.release();
}
}
/**
* Convenience method to populate the DBObject for the object managed by the ObjectProvider.
* @param op ObjectProvider
* @return The DBObject to persist
*/
private static DBObject getDBObjectForObjectProviderToInsert(ObjectProvider op)
{
DBObject dbObject = new BasicDBObject();
AbstractClassMetaData cmd = op.getClassMetaData();
if (cmd.getIdentityType() == IdentityType.DATASTORE &&
cmd.getIdentityMetaData().getValueStrategy() != IdentityStrategy.IDENTITY)
{
// Add surrogate datastore identity field (if using identity then just uses "_id" MongoDB special)
String fieldName = MongoDBUtils.getFieldName(cmd.getIdentityMetaData());
OID oid = (OID) op.getInternalObjectId();
Object key = oid.getKeyValue();
dbObject.put(fieldName, key);
}
if (cmd.hasDiscriminatorStrategy())
{
// Add discriminator field
DiscriminatorMetaData discmd = cmd.getDiscriminatorMetaData();
String fieldName = MongoDBUtils.getFieldName(discmd);
Object discVal = null;
if (cmd.getDiscriminatorStrategy() == DiscriminatorStrategy.CLASS_NAME)
{
discVal = cmd.getFullClassName();
}
else
{
discVal = discmd.getValue();
}
dbObject.put(fieldName, discVal);
}
if (cmd.hasVersionStrategy())
{
if (cmd.getVersionMetaData().getVersionStrategy() == VersionStrategy.VERSION_NUMBER)
{
long versionNumber = 1;
op.setTransactionalVersion(Long.valueOf(versionNumber));
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.ObjectPersistedWithVersion",
op.toPrintableID(), op.getInternalObjectId(), "" + versionNumber));
}
if (cmd.getVersionMetaData().getFieldName() != null)
{
// Version stored in a field
AbstractMemberMetaData verMmd = cmd.getMetaDataForMember(cmd.getVersionMetaData().getFieldName());
Object verFieldValue = Long.valueOf(versionNumber);
if (verMmd.getType() == int.class || verMmd.getType() == Integer.class)
{
verFieldValue = Integer.valueOf((int)versionNumber);
}
op.replaceField(verMmd.getAbsoluteFieldNumber(), verFieldValue);
}
else
{
// Surrogate version
String fieldName = MongoDBUtils.getFieldName(cmd.getVersionMetaData());
dbObject.put(fieldName, new Long(versionNumber));
}
}
else if (cmd.getVersionMetaData().getVersionStrategy() == VersionStrategy.DATE_TIME)
{
Date date = new Date();
Timestamp ts = new Timestamp(date.getTime());
op.setTransactionalVersion(ts);
if (cmd.getVersionMetaData().getFieldName() != null)
{
// Version field
AbstractMemberMetaData verMmd = cmd.getMetaDataForMember(cmd.getVersionMetaData().getFieldName());
op.replaceField(verMmd.getAbsoluteFieldNumber(), ts);
}
else
{
// Surrogate version
String fieldName = MongoDBUtils.getFieldName(cmd.getVersionMetaData());
dbObject.put(fieldName, ts);
}
}
}
// TODO If using IDENTITY on a field really should omit it from the put since not using it
StoreFieldManager fieldManager = new StoreFieldManager(op, dbObject, cmd);
op.provideFields(cmd.getAllMemberPositions(), fieldManager);
return dbObject;
}
public void updateObject(ObjectProvider op, int[] fieldNumbers)
{
storeMgr.assertReadOnlyForUpdateOfObject(op);
ExecutionContext ec = op.getExecutionContext();
ManagedConnection mconn = storeMgr.getConnection(ec);
try
{
DB db = (DB)mconn.getConnection();
long startTime = System.currentTimeMillis();
AbstractClassMetaData cmd = op.getClassMetaData();
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
StringBuffer fieldStr = new StringBuffer();
for (int i=0;i<fieldNumbers.length;i++)
{
if (i > 0)
{
fieldStr.append(",");
}
fieldStr.append(cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumbers[i]).getName());
}
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Update.Start",
op.toPrintableID(), op.getInternalObjectId(), fieldStr.toString()));
}
DBCollection collection = db.getCollection(MongoDBUtils.getCollectionName(cmd));
DBObject dbObject = MongoDBUtils.getObjectForObjectProvider(collection, op, true);
if (dbObject == null)
{
if (cmd.hasVersionStrategy())
{
throw new NucleusOptimisticException("Object with id " + op.getObjectId() +
" and version " + op.getTransactionalVersion() + " no longer present");
}
else
{
throw new NucleusDataStoreException("Could not find object with id " + op.getObjectId());
}
}
if (cmd.hasVersionStrategy())
{
// Version object so calculate version to store with
Object currentVersion = op.getTransactionalVersion();
VersionMetaData vermd = cmd.getVersionMetaData();
Object nextVersion = VersionHelper.getNextVersion(vermd.getVersionStrategy(), currentVersion);
op.setTransactionalVersion(nextVersion);
if (cmd.getVersionMetaData().getFieldName() != null)
{
// Update the version field value
AbstractMemberMetaData verMmd = cmd.getMetaDataForMember(cmd.getVersionMetaData().getFieldName());
op.replaceField(verMmd.getAbsoluteFieldNumber(), nextVersion);
}
else
{
// Update the stored surrogate value
String fieldName = MongoDBUtils.getFieldName(cmd.getVersionMetaData());
dbObject.put(fieldName, nextVersion);
}
}
StoreFieldManager fieldManager = new StoreFieldManager(op, dbObject, cmd);
op.provideFields(cmd.getAllMemberPositions(), fieldManager);
collection.save(dbObject);
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.ExecutionTime",
(System.currentTimeMillis() - startTime)));
}
if (storeMgr.getRuntimeManager() != null)
{
storeMgr.getRuntimeManager().incrementUpdateCount();
}
}
catch (MongoException me)
{
NucleusLogger.PERSISTENCE.error("Exception updating object " + op, me);
throw new NucleusDataStoreException("Exception updating object for " + op, me);
}
finally
{
mconn.release();
}
}
/* (non-Javadoc)
* @see org.datanucleus.store.AbstractPersistenceHandler#deleteObjects(org.datanucleus.store.ObjectProvider[])
*/
@Override
public void deleteObjects(ObjectProvider... ops)
{
// TODO If MongoDB java driver ever provides bulk delete of multiple objects at once, support it
super.deleteObjects(ops);
}
public void deleteObject(ObjectProvider op)
{
// Check if read-only so update not permitted
storeMgr.assertReadOnlyForUpdateOfObject(op);
AbstractClassMetaData cmd = op.getClassMetaData();
ExecutionContext ec = op.getExecutionContext();
ManagedConnection mconn = storeMgr.getConnection(ec);
try
{
DB db = (DB)mconn.getConnection();
long startTime = System.currentTimeMillis();
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Delete.Start",
op.toPrintableID(), op.getInternalObjectId()));
}
DBCollection collection = db.getCollection(MongoDBUtils.getCollectionName(cmd));
DBObject dbObject = MongoDBUtils.getObjectForObjectProvider(collection, op, true);
if (dbObject == null)
{
if (cmd.hasVersionStrategy())
{
throw new NucleusOptimisticException("Object with id " + op.getObjectId() +
" and version " + op.getTransactionalVersion() + " no longer present");
}
else
{
throw new NucleusDataStoreException("Could not find object with id " + op.getObjectId());
}
}
// Invoke any cascade deletion
op.loadUnloadedFields();
op.provideFields(cmd.getAllMemberPositions(), new DeleteFieldManager(op));
// Delete this object
collection.remove(dbObject);
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.ExecutionTime",
(System.currentTimeMillis() - startTime)));
}
if (storeMgr.getRuntimeManager() != null)
{
storeMgr.getRuntimeManager().incrementDeleteCount();
}
}
catch (MongoException me)
{
NucleusLogger.PERSISTENCE.error("Exception deleting object " + op, me);
throw new NucleusDataStoreException("Exception deleting object for " + op, me);
}
finally
{
mconn.release();
}
}
public void fetchObject(ObjectProvider op, int[] fieldNumbers)
{
AbstractClassMetaData cmd = op.getClassMetaData();
ExecutionContext ec = op.getExecutionContext();
ManagedConnection mconn = storeMgr.getConnection(ec);
try
{
DB db = (DB)mconn.getConnection();
if (NucleusLogger.DATASTORE_RETRIEVE.isDebugEnabled())
{
// Debug information about what we are retrieving
StringBuffer str = new StringBuffer("Fetching object \"");
str.append(op.toPrintableID()).append("\" (id=");
str.append(op.getExecutionContext().getApiAdapter().getObjectId(op)).append(")").append(" fields [");
for (int i=0;i<fieldNumbers.length;i++)
{
if (i > 0)
{
str.append(",");
}
str.append(cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumbers[i]).getName());
}
str.append("]");
NucleusLogger.DATASTORE_RETRIEVE.debug(str);
}
long startTime = System.currentTimeMillis();
if (NucleusLogger.DATASTORE_RETRIEVE.isDebugEnabled())
{
NucleusLogger.DATASTORE_RETRIEVE.debug(LOCALISER.msg("MongoDB.Fetch.Start",
op.toPrintableID(), op.getInternalObjectId()));
}
DBCollection collection = db.getCollection(MongoDBUtils.getCollectionName(cmd));
DBObject dbObject = MongoDBUtils.getObjectForObjectProvider(collection, op, false);
if (dbObject == null)
{
throw new NucleusObjectNotFoundException("Could not find object with id " + op.getInternalObjectId() + " op="+op);
}
if (cmd.hasVersionStrategy() && op.getTransactionalVersion() == null)
{
// No version set, so retrieve it
if (cmd.getVersionMetaData().getFieldName() != null)
{
// Version stored in a field
Object datastoreVersion =
op.provideField(cmd.getAbsolutePositionOfMember(cmd.getVersionMetaData().getFieldName()));
op.setVersion(datastoreVersion);
}
else
{
// Surrogate version
String fieldName = MongoDBUtils.getFieldName(cmd.getVersionMetaData());
Object datastoreVersion = dbObject.get(fieldName);
op.setVersion(datastoreVersion);
}
}
FetchFieldManager fieldManager = new FetchFieldManager(op, dbObject, cmd);
op.replaceFields(fieldNumbers, fieldManager);
if (NucleusLogger.DATASTORE_RETRIEVE.isDebugEnabled())
{
NucleusLogger.DATASTORE_RETRIEVE.debug(LOCALISER.msg("MongoDB.ExecutionTime",
(System.currentTimeMillis() - startTime)));
}
if (storeMgr.getRuntimeManager() != null)
{
storeMgr.getRuntimeManager().incrementFetchCount();
}
}
finally
{
mconn.release();
}
}
public Object findObject(ExecutionContext om, Object id)
{
return null;
}
public void locateObject(ObjectProvider op)
{
final AbstractClassMetaData cmd = op.getClassMetaData();
if (cmd.getIdentityType() == IdentityType.APPLICATION ||
cmd.getIdentityType() == IdentityType.DATASTORE)
{
ExecutionContext ec = op.getExecutionContext();
ManagedConnection mconn = storeMgr.getConnection(ec);
try
{
DB db = (DB)mconn.getConnection();
DBCollection collection = db.getCollection(MongoDBUtils.getCollectionName(cmd));
DBObject dbObject = MongoDBUtils.getObjectForObjectProvider(collection, op, false);
if (dbObject == null)
{
throw new NucleusObjectNotFoundException();
}
}
finally
{
mconn.release();
}
}
}
}