Revision: 12458
http://datanucleus.svn.sourceforge.net/datanucleus/?rev=12458&view=rev
Author: andy_jefferson
Date: 2011-03-02 17:06:33 +0000 (Wed, 02 Mar 2011)
Log Message:
-----------
[NUCMONGODB-29] Implementation of optimised insert, where we can insert N objects in a single call to DBCollection. Still need to fix uniqueness check etc.
Modified Paths:
--------------
platform/store.mongodb/trunk/src/java/org/datanucleus/store/mongodb/MongoDBPersistenceHandler.java
Modified: platform/store.mongodb/trunk/src/java/org/datanucleus/store/mongodb/MongoDBPersistenceHandler.java
===================================================================
--- platform/store.mongodb/trunk/src/java/org/datanucleus/store/mongodb/MongoDBPersistenceHandler.java 2011-03-02 16:23:03 UTC (rev 12457)
+++ platform/store.mongodb/trunk/src/java/org/datanucleus/store/mongodb/MongoDBPersistenceHandler.java 2011-03-02 17:06:33 UTC (rev 12458)
@@ -19,6 +19,10 @@
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;
@@ -49,6 +53,7 @@
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
{
@@ -90,151 +95,155 @@
@Override
public void insertObjects(ObjectProvider... ops)
{
- // TODO Check for any of these needing "identity" value strategy and do first
- // TODO Then process all others, grouping by the object collection so we can do some in same persist
- super.insertObjects(ops);
- }
-
- public void insertObject(ObjectProvider sm)
- {
- storeMgr.assertReadOnlyForUpdateOfObject(sm);
-
- AbstractClassMetaData cmd = sm.getClassMetaData();
- if (!storeMgr.managesClass(cmd.getFullClassName()))
+ // Process "identity" cases first in case they are referenced
+ for (int i=0;i<ops.length;i++)
{
- storeMgr.addClass(cmd.getFullClassName(), sm.getExecutionContext().getClassLoaderResolver());
- }
-
- // TODO Remove this when we enforce uniqueness on the PK reliably
- if (cmd.getIdentityType() != IdentityType.NONDURABLE)
- {
- // Enforce uniqueness of datastore rows in this plugin
- try
+ AbstractClassMetaData cmd = ops[i].getClassMetaData();
+ if (cmd.pkUsesIdentityValueGenerator())
{
- locateObject(sm);
- throw new NucleusUserException(LOCALISER.msg("MongoDB.Insert.ObjectWithIdAlreadyExists",
- sm.toPrintableID(), sm.getInternalObjectId()));
+ insertObject(ops[i]);
}
- catch (NucleusObjectNotFoundException onfe)
- {
- // Do nothing since object with this id doesn't exist
- }
}
- ExecutionContext ec = sm.getExecutionContext();
- ManagedConnection mconn = storeMgr.getConnection(ec);
- try
+ // 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++)
{
- DB db = (DB)mconn.getConnection();
-
- long startTime = System.currentTimeMillis();
- if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
+ AbstractClassMetaData cmd = ops[i].getClassMetaData();
+ if (!cmd.pkUsesIdentityValueGenerator())
{
- NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.Start",
- sm.toPrintableID(), sm.getInternalObjectId()));
- }
-
- DBCollection collection = db.getCollection(MongoDBUtils.getCollectionName(cmd));
- BasicDBObject dbObject = new BasicDBObject();
-
- 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) sm.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)
+ String tableName = MongoDBUtils.getCollectionName(cmd);
+ Set<ObjectProvider> opsForTable = opsByTable.get(tableName);
+ if (opsForTable == null)
{
- discVal = cmd.getFullClassName();
+ opsForTable = new HashSet<ObjectProvider>();
+ opsByTable.put(tableName, opsForTable);
}
- else
- {
- discVal = discmd.getValue();
- }
- dbObject.put(fieldName, discVal);
+ opsForTable.add(ops[i]);
}
+ }
- String versionStr = null;
- if (cmd.hasVersionStrategy())
+ for (String tableName : opsByTable.keySet())
+ {
+ Set<ObjectProvider> opsForTable = opsByTable.get(tableName);
+ ExecutionContext ec = ops[0].getExecutionContext();
+ ManagedConnection mconn = storeMgr.getConnection(ec);
+ try
{
- if (cmd.getVersionMetaData().getVersionStrategy() == VersionStrategy.VERSION_NUMBER)
+ 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)
{
- long versionNumber = 1;
- sm.setTransactionalVersion(Long.valueOf(versionNumber));
- versionStr = "" + versionNumber;
- if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
+ storeMgr.assertReadOnlyForUpdateOfObject(op);
+ AbstractClassMetaData cmd = op.getClassMetaData();
+ if (!storeMgr.managesClass(cmd.getFullClassName()))
{
- NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.ObjectPersistedWithVersion",
- sm.toPrintableID(), sm.getInternalObjectId(), "" + versionNumber));
+ storeMgr.addClass(cmd.getFullClassName(), op.getExecutionContext().getClassLoaderResolver());
}
+ assertUnique(op);
- if (cmd.getVersionMetaData().getFieldName() != null)
+ if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
- // 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);
- }
- sm.replaceField(verMmd.getAbsoluteFieldNumber(), verFieldValue);
+ NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.Start",
+ op.toPrintableID(), op.getInternalObjectId()));
}
- else
+
+ dbObjects[i] = getDBObjectForObjectProviderToInsert(op);
+
+ if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
- // Surrogate version
- String fieldName = MongoDBUtils.getFieldName(cmd.getVersionMetaData());
- dbObject.put(fieldName, new Long(versionNumber));
+ NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.ObjectPersisted",
+ op.toPrintableID(), op.getInternalObjectId()));
}
+
+ i++;
}
- else if (cmd.getVersionMetaData().getVersionStrategy() == VersionStrategy.DATE_TIME)
+
+ if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
- Date date = new Date();
- Timestamp ts = new Timestamp(date.getTime());
- sm.setTransactionalVersion(ts);
- versionStr = "" + ts;
+ NucleusLogger.DATASTORE_PERSIST.debug("Persisting objects as " + StringUtils.objectArrayToString(dbObjects));
+ }
+ collection.insert(dbObjects);
+ if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
+ {
+ NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.ExecutionTime",
+ (System.currentTimeMillis() - startTime)));
+ }
+ if (storeMgr.getRuntimeManager() != null)
+ {
+ storeMgr.getRuntimeManager().incrementInsertCount();
+ }
+ }
+ finally
+ {
+ mconn.release();
+ }
+ // TODO Process all of these in single call
+ }
+ }
- if (cmd.getVersionMetaData().getFieldName() != null)
- {
- // Version field
- AbstractMemberMetaData verMmd = cmd.getMetaDataForMember(cmd.getVersionMetaData().getFieldName());
- sm.replaceField(verMmd.getAbsoluteFieldNumber(), ts);
- }
- else
- {
- // Surrogate version
- String fieldName = MongoDBUtils.getFieldName(cmd.getVersionMetaData());
- dbObject.put(fieldName, ts);
- }
+ private void assertUnique(ObjectProvider op)
+ {
+ AbstractClassMetaData cmd = op.getClassMetaData();
+ // TODO Remove this when we enforce uniqueness on the PK reliably
+ if (cmd.getIdentityType() != IdentityType.NONDURABLE)
+ {
+ if (!cmd.pkUsesIdentityValueGenerator())
+ {
+ // Enforce uniqueness of datastore rows in this plugin
+ try
+ {
+ locateObject(op);
+ throw new NucleusUserException(LOCALISER.msg("MongoDB.Insert.ObjectWithIdAlreadyExists",
+ op.toPrintableID(), op.getInternalObjectId()));
}
+ catch (NucleusObjectNotFoundException onfe)
+ {
+ // Do nothing since object with this id doesn't exist
+ }
}
+ }
+ }
- StoreFieldManager fieldManager = new StoreFieldManager(sm, dbObject, cmd);
- sm.provideFields(cmd.getAllMemberPositions(), fieldManager);
+ public void insertObject(ObjectProvider op)
+ {
+ storeMgr.assertReadOnlyForUpdateOfObject(op);
+
+ AbstractClassMetaData cmd = op.getClassMetaData();
+ if (!storeMgr.managesClass(cmd.getFullClassName()))
+ {
+ storeMgr.addClass(cmd.getFullClassName(), op.getExecutionContext().getClassLoaderResolver());
+ }
+
+ assertUnique(op);
+
+ 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);
+
collection.insert(dbObject);
NucleusLogger.DATASTORE_PERSIST.debug("Persisting object as " + dbObject);
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
- if (versionStr != null)
- {
- NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.ObjectPersistedWithVersion",
- sm.toPrintableID(), sm.getInternalObjectId(), versionStr));
- }
- else
- {
- NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.ObjectPersisted",
- sm.toPrintableID(), sm.getInternalObjectId()));
- }
+ NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.ObjectPersisted",
+ op.toPrintableID(), op.getInternalObjectId()));
}
// Retrieve any datastore-generated IDENTITY strategy value as necessary
@@ -243,11 +252,11 @@
{
// Set identity from MongoDB "_id" field
ObjectId idKey = (ObjectId) dbObject.get("_id");
- sm.setPostStoreNewObjectId(idKey.toString());
+ op.setPostStoreNewObjectId(idKey.toString());
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Insert.ObjectPersistedWithIdentity",
- sm.toPrintableID(), idKey));
+ op.toPrintableID(), idKey));
}
}
else if (cmd.getIdentityType() == IdentityType.APPLICATION)
@@ -264,12 +273,12 @@
throw new NucleusUserException("Any field using IDENTITY value generation with MongoDB should be of type String");
}
ObjectId idKey = (ObjectId)dbObject.get("_id");
- sm.replaceField(mmd.getAbsoluteFieldNumber(), idKey.toString());
- sm.setPostStoreNewObjectId(idKey); // TODO This is incorrect if part of a composite PK
+ 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",
- sm.toPrintableID(), idKey));
+ op.toPrintableID(), idKey));
}
}
}
@@ -291,18 +300,112 @@
}
}
- public void updateObject(ObjectProvider sm, int[] fieldNumbers)
+ /**
+ * 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)
{
- storeMgr.assertReadOnlyForUpdateOfObject(sm);
+ DBObject dbObject = new BasicDBObject();
+ AbstractClassMetaData cmd = op.getClassMetaData();
- ExecutionContext ec = sm.getExecutionContext();
+ 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);
+ }
+ }
+ }
+
+ 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 = sm.getClassMetaData();
+ AbstractClassMetaData cmd = op.getClassMetaData();
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
StringBuffer fieldStr = new StringBuffer();
@@ -315,37 +418,37 @@
fieldStr.append(cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumbers[i]).getName());
}
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Update.Start",
- sm.toPrintableID(), sm.getInternalObjectId(), fieldStr.toString()));
+ op.toPrintableID(), op.getInternalObjectId(), fieldStr.toString()));
}
DBCollection collection = db.getCollection(MongoDBUtils.getCollectionName(cmd));
- DBObject dbObject = MongoDBUtils.getObjectForObjectProvider(collection, sm, true);
+ DBObject dbObject = MongoDBUtils.getObjectForObjectProvider(collection, op, true);
if (dbObject == null)
{
if (cmd.hasVersionStrategy())
{
- throw new NucleusOptimisticException("Object with id " + sm.getObjectId() +
- " and version " + sm.getTransactionalVersion() + " no longer present");
+ 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 " + sm.getObjectId());
+ throw new NucleusDataStoreException("Could not find object with id " + op.getObjectId());
}
}
if (cmd.hasVersionStrategy())
{
// Version object so calculate version to store with
- Object currentVersion = sm.getTransactionalVersion();
+ Object currentVersion = op.getTransactionalVersion();
VersionMetaData vermd = cmd.getVersionMetaData();
Object nextVersion = vermd.getNextVersion(currentVersion);
- sm.setTransactionalVersion(nextVersion);
+ op.setTransactionalVersion(nextVersion);
if (cmd.getVersionMetaData().getFieldName() != null)
{
// Update the version field value
AbstractMemberMetaData verMmd = cmd.getMetaDataForMember(cmd.getVersionMetaData().getFieldName());
- sm.replaceField(verMmd.getAbsoluteFieldNumber(), nextVersion);
+ op.replaceField(verMmd.getAbsoluteFieldNumber(), nextVersion);
}
else
{
@@ -355,8 +458,8 @@
}
}
- StoreFieldManager fieldManager = new StoreFieldManager(sm, dbObject, cmd);
- sm.provideFields(cmd.getAllMemberPositions(), fieldManager);
+ StoreFieldManager fieldManager = new StoreFieldManager(op, dbObject, cmd);
+ op.provideFields(cmd.getAllMemberPositions(), fieldManager);
collection.save(dbObject);
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
@@ -385,14 +488,14 @@
super.deleteObjects(ops);
}
- public void deleteObject(ObjectProvider sm)
+ public void deleteObject(ObjectProvider op)
{
// Check if read-only so update not permitted
- storeMgr.assertReadOnlyForUpdateOfObject(sm);
+ storeMgr.assertReadOnlyForUpdateOfObject(op);
- AbstractClassMetaData cmd = sm.getClassMetaData();
+ AbstractClassMetaData cmd = op.getClassMetaData();
- ExecutionContext ec = sm.getExecutionContext();
+ ExecutionContext ec = op.getExecutionContext();
ManagedConnection mconn = storeMgr.getConnection(ec);
try
{
@@ -401,27 +504,27 @@
if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
{
NucleusLogger.DATASTORE_PERSIST.debug(LOCALISER.msg("MongoDB.Delete.Start",
- sm.toPrintableID(), sm.getInternalObjectId()));
+ op.toPrintableID(), op.getInternalObjectId()));
}
DBCollection collection = db.getCollection(MongoDBUtils.getCollectionName(cmd));
- DBObject dbObject = MongoDBUtils.getObjectForObjectProvider(collection, sm, true);
+ DBObject dbObject = MongoDBUtils.getObjectForObjectProvider(collection, op, true);
if (dbObject == null)
{
if (cmd.hasVersionStrategy())
{
- throw new NucleusOptimisticException("Object with id " + sm.getObjectId() +
- " and version " + sm.getTransactionalVersion() + " no longer present");
+ 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 " + sm.getObjectId());
+ throw new NucleusDataStoreException("Could not find object with id " + op.getObjectId());
}
}
// Invoke any cascade deletion
- sm.loadUnloadedFields();
- sm.provideFields(cmd.getAllMemberPositions(), new DeleteFieldManager(sm));
+ op.loadUnloadedFields();
+ op.provideFields(cmd.getAllMemberPositions(), new DeleteFieldManager(op));
// Delete this object
collection.remove(dbObject);
@@ -442,11 +545,11 @@
}
}
- public void fetchObject(ObjectProvider sm, int[] fieldNumbers)
+ public void fetchObject(ObjectProvider op, int[] fieldNumbers)
{
- AbstractClassMetaData cmd = sm.getClassMetaData();
+ AbstractClassMetaData cmd = op.getClassMetaData();
- ExecutionContext ec = sm.getExecutionContext();
+ ExecutionContext ec = op.getExecutionContext();
ManagedConnection mconn = storeMgr.getConnection(ec);
try
{
@@ -455,8 +558,8 @@
{
// Debug information about what we are retrieving
StringBuffer str = new StringBuffer("Fetching object \"");
- str.append(sm.toPrintableID()).append("\" (id=");
- str.append(sm.getExecutionContext().getApiAdapter().getObjectId(sm)).append(")").append(" fields [");
+ 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)
@@ -473,37 +576,37 @@
if (NucleusLogger.DATASTORE_RETRIEVE.isDebugEnabled())
{
NucleusLogger.DATASTORE_RETRIEVE.debug(LOCALISER.msg("MongoDB.Fetch.Start",
- sm.toPrintableID(), sm.getInternalObjectId()));
+ op.toPrintableID(), op.getInternalObjectId()));
}
DBCollection collection = db.getCollection(MongoDBUtils.getCollectionName(cmd));
- DBObject dbObject = MongoDBUtils.getObjectForObjectProvider(collection, sm, false);
+ DBObject dbObject = MongoDBUtils.getObjectForObjectProvider(collection, op, false);
if (dbObject == null)
{
- throw new NucleusDataStoreException("Could not find object with id " + sm.getObjectId());
+ throw new NucleusDataStoreException("Could not find object with id " + op.getObjectId());
}
- if (cmd.hasVersionStrategy() && sm.getTransactionalVersion() == null)
+ if (cmd.hasVersionStrategy() && op.getTransactionalVersion() == null)
{
// No version set, so retrieve it
if (cmd.getVersionMetaData().getFieldName() != null)
{
// Version stored in a field
Object datastoreVersion =
- sm.provideField(cmd.getAbsolutePositionOfMember(cmd.getVersionMetaData().getFieldName()));
- sm.setVersion(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);
- sm.setVersion(datastoreVersion);
+ op.setVersion(datastoreVersion);
}
}
- FetchFieldManager fieldManager = new FetchFieldManager(sm, dbObject, cmd);
- sm.replaceFields(fieldNumbers, fieldManager);
+ FetchFieldManager fieldManager = new FetchFieldManager(op, dbObject, cmd);
+ op.replaceFields(fieldNumbers, fieldManager);
if (NucleusLogger.DATASTORE_RETRIEVE.isDebugEnabled())
{
@@ -526,19 +629,19 @@
return null;
}
- public void locateObject(ObjectProvider sm)
+ public void locateObject(ObjectProvider op)
{
- final AbstractClassMetaData cmd = sm.getClassMetaData();
+ final AbstractClassMetaData cmd = op.getClassMetaData();
if (cmd.getIdentityType() == IdentityType.APPLICATION ||
cmd.getIdentityType() == IdentityType.DATASTORE)
{
- ExecutionContext ec = sm.getExecutionContext();
+ 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, sm, false);
+ DBObject dbObject = MongoDBUtils.getObjectForObjectProvider(collection, op, false);
if (dbObject == null)
{
throw new NucleusObjectNotFoundException();
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|