You are viewing a plain text version of this content. The canonical link for it is here.
Posted to ojb-dev@db.apache.org by ar...@apache.org on 2005/10/27 20:19:07 UTC
cvs commit: db-ojb/src/java/org/apache/ojb/odmg DatabaseImpl.java ImplementationExt.java ImplementationImpl.java NarrowTransaction.java TransactionImpl.java
arminw 2005/10/27 11:19:07
Modified: src/java/org/apache/ojb/odmg Tag: OJB_1_0_RELEASE
DatabaseImpl.java ImplementationExt.java
ImplementationImpl.java NarrowTransaction.java
TransactionImpl.java
Log:
remove redundant method, combination of setImplicitLocking(false) and setOrdering(false) will have the same effect, code cleanup
Revision Changes Path
No revision
No revision
1.26.2.8 +4 -5 db-ojb/src/java/org/apache/ojb/odmg/DatabaseImpl.java
Index: DatabaseImpl.java
===================================================================
RCS file: /home/cvs/db-ojb/src/java/org/apache/ojb/odmg/DatabaseImpl.java,v
retrieving revision 1.26.2.7
retrieving revision 1.26.2.8
diff -u -r1.26.2.7 -r1.26.2.8
--- DatabaseImpl.java 16 Aug 2005 15:04:38 -0000 1.26.2.7
+++ DatabaseImpl.java 27 Oct 2005 18:19:06 -0000 1.26.2.8
@@ -166,8 +166,7 @@
" Transaction status is '" + TxUtil.getStatusString(getTransaction().getStatus()) + "'." +
" Used PBKey was "+getTransaction().getBroker().getPBKey();
log.error(msg);
- TransactionInProgressException ex = new TransactionInProgressException(msg);
- throw ex;
+ throw new TransactionInProgressException(msg);
}
isOpen = false;
// remove the current PBKey
@@ -294,7 +293,7 @@
}
RuntimeObject rt = new RuntimeObject(object, getTransaction());
tx.makePersistent(rt);
- tx.moveToLastInOrderList(rt.getIdentity());
+// tx.moveToLastInOrderList(rt.getIdentity());
}
/**
@@ -321,6 +320,6 @@
}
RuntimeObject rt = new RuntimeObject(object, tx);
tx.deletePersistent(rt);
- tx.moveToLastInOrderList(rt.getIdentity());
+// tx.moveToLastInOrderList(rt.getIdentity());
}
}
1.1.2.5 +30 -30 db-ojb/src/java/org/apache/ojb/odmg/ImplementationExt.java
Index: ImplementationExt.java
===================================================================
RCS file: /home/cvs/db-ojb/src/java/org/apache/ojb/odmg/ImplementationExt.java,v
retrieving revision 1.1.2.4
retrieving revision 1.1.2.5
diff -u -r1.1.2.4 -r1.1.2.5
--- ImplementationExt.java 9 Sep 2005 00:36:18 -0000 1.1.2.4
+++ ImplementationExt.java 27 Oct 2005 18:19:06 -0000 1.1.2.5
@@ -133,35 +133,35 @@
*/
public void setOrdering(boolean ordering);
- /**
- * Returns whether or not the persistent method calls determine
- * the persistent object order on commit.
- *
- * @see #setNoteUserOrder(boolean)
- */
- public boolean isNoteUserOrder();
-
- /**
- * If <em>true</em> the order of persisting method calls like
- * <br/> - {@link org.odmg.Transaction#lock(Object, int)}).
- * <br/> - {@link org.odmg.Database#deletePersistent(Object)}).
- * <br/> - {@link org.odmg.Database#makePersistent(Object)})
- * determine the order of objects before commit.
- * <br/>
- * If <em>false</em> the ordering was determined by OJB's internal
- * method calls and user calls.
- * <br/>
- * However it's possible to set this value only for the current
- * used {@link org.odmg.Transaction} using {@link TransactionExt#setNoteUserOrder(boolean)}
- * <p/>
- * <strong>NOTE:</strong> If OJB's ordering algorithm (see
- * {@link #setOrdering(boolean)}) is enabled, the
- * order of objects may change on commit.
- *
- * @param noteUserOrder If <em>true</em> the order of persisting
- * method calls determine the order of objects.
- */
- public void setNoteUserOrder(boolean noteUserOrder);
+// /**
+// * Returns whether or not the persistent method calls determine
+// * the persistent object order on commit.
+// *
+// * @see #setNoteUserOrder(boolean)
+// */
+// public boolean isNoteUserOrder();
+//
+// /**
+// * If <em>true</em> the order of persisting method calls like
+// * <br/> - {@link org.odmg.Transaction#lock(Object, int)}).
+// * <br/> - {@link org.odmg.Database#deletePersistent(Object)}).
+// * <br/> - {@link org.odmg.Database#makePersistent(Object)})
+// * determine the order of objects before commit.
+// * <br/>
+// * If <em>false</em> the ordering was determined by OJB's internal
+// * method calls and user calls.
+// * <br/>
+// * However it's possible to set this value only for the current
+// * used {@link org.odmg.Transaction} using {@link TransactionExt#setNoteUserOrder(boolean)}
+// * <p/>
+// * <strong>NOTE:</strong> If OJB's ordering algorithm (see
+// * {@link #setOrdering(boolean)}) is enabled, the
+// * order of objects may change on commit.
+// *
+// * @param noteUserOrder If <em>true</em> the order of persisting
+// * method calls determine the order of objects.
+// */
+// public void setNoteUserOrder(boolean noteUserOrder);
// /**
1.1.2.11 +18 -23 db-ojb/src/java/org/apache/ojb/odmg/ImplementationImpl.java
Index: ImplementationImpl.java
===================================================================
RCS file: /home/cvs/db-ojb/src/java/org/apache/ojb/odmg/ImplementationImpl.java,v
retrieving revision 1.1.2.10
retrieving revision 1.1.2.11
diff -u -r1.1.2.10 -r1.1.2.11
--- ImplementationImpl.java 8 Jun 2005 23:29:29 -0000 1.1.2.10
+++ ImplementationImpl.java 27 Oct 2005 18:19:06 -0000 1.1.2.11
@@ -15,9 +15,6 @@
* limitations under the License.
*/
-import java.util.ArrayList;
-import java.util.List;
-
import org.apache.commons.lang.SerializationUtils;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
@@ -57,11 +54,11 @@
*
* @version $Id$
*/
-public class ImplementationImpl extends Object implements ImplementationExt
+public class ImplementationImpl implements ImplementationExt
{
private Logger log = LoggerFactory.getLogger(ImplementationImpl.class);
- private List usedDatabases = new ArrayList();
+// private List usedDatabases = new ArrayList();
private DatabaseImpl currentDatabase;
private Configurator configurator;
private OJBTxManager ojbTxManager;
@@ -72,7 +69,7 @@
private boolean implicitLocking;
private boolean implicitLockingBackward;
private boolean ordering;
- private boolean noteUserOrder;
+// private boolean noteUserOrder;
/**
* private Constructor: use static factory method
@@ -85,10 +82,10 @@
setConfigurator(PersistenceBrokerFactory.getConfigurator());
Configuration conf = getConfigurator().getConfigurationFor(null);
oqlCollectionClass = conf.getClass("OqlCollectionClass", ManageableArrayList.class);
- impliciteWriteLocks = (conf.getString("LockAssociations", "WRITE").equalsIgnoreCase("WRITE") ? true : false);
+ impliciteWriteLocks = (conf.getString("LockAssociations", "WRITE").equalsIgnoreCase("WRITE"));
implicitLocking = conf.getBoolean("ImplicitLocking", true);
ordering = conf.getBoolean("Ordering", true);
- noteUserOrder = conf.getBoolean("NoteUserOrder", true);
+// noteUserOrder = conf.getBoolean("NoteUserOrder", true);
implicitLockingBackward = conf.getBoolean("ImplicitLockingBackward", false);
if(log.isEnabledFor(Logger.INFO))
{
@@ -179,7 +176,7 @@
public boolean hasOpenTransaction()
{
TransactionImpl tx = ojbTxManager.getTransaction();
- return tx != null ? tx.isOpen() : false;
+ return tx != null && tx.isOpen();
}
/**
@@ -203,8 +200,7 @@
{
throw new DatabaseClosedException("Database is not open");
}
- OQLQueryImpl query = new OQLQueryImpl(this);
- return query;
+ return new OQLQueryImpl(this);
}
/**
@@ -350,7 +346,7 @@
}
if (log.isDebugEnabled()) log.debug("Set current database " + newDB + " PBKey was " + newDB.getPBKey());
setCurrentDatabase(newDB);
- usedDatabases.add(newDB.getPBKey());
+// usedDatabases.add(newDB.getPBKey());
}
/**
@@ -423,15 +419,15 @@
this.ordering = ordering;
}
- public boolean isNoteUserOrder()
- {
- return noteUserOrder;
- }
-
- public void setNoteUserOrder(boolean noteUserOrder)
- {
- this.noteUserOrder = noteUserOrder;
- }
+// public boolean isNoteUserOrder()
+// {
+// return noteUserOrder;
+// }
+//
+// public void setNoteUserOrder(boolean noteUserOrder)
+// {
+// this.noteUserOrder = noteUserOrder;
+// }
/**
* Allow to use method {@link #setImplicitLocking(boolean)} in the same way
@@ -451,7 +447,6 @@
.append("implicitLocking", isImplicitLocking())
.append("implicitWriteLocks", isImpliciteWriteLocks())
.append("ordering", isOrdering())
- .append("noteUserOrder", isNoteUserOrder())
.append("oqlCollectionClass", getOqlCollectionClass())
.append("txManager", getTxManager())
.append("lockManager", getLockManager())
1.10.2.7 +9 -9 db-ojb/src/java/org/apache/ojb/odmg/NarrowTransaction.java
Index: NarrowTransaction.java
===================================================================
RCS file: /home/cvs/db-ojb/src/java/org/apache/ojb/odmg/NarrowTransaction.java,v
retrieving revision 1.10.2.6
retrieving revision 1.10.2.7
diff -u -r1.10.2.6 -r1.10.2.7
--- NarrowTransaction.java 22 Jun 2005 17:29:36 -0000 1.10.2.6
+++ NarrowTransaction.java 27 Oct 2005 18:19:06 -0000 1.10.2.7
@@ -185,15 +185,15 @@
tx.setOrdering(ordering);
}
- public boolean isNoteUserOrder()
- {
- return tx.isNoteUserOrder();
- }
-
- public void setNoteUserOrder(boolean noteUserOrder)
- {
- tx.setNoteUserOrder(noteUserOrder);
- }
+// public boolean isNoteUserOrder()
+// {
+// return tx.isNoteUserOrder();
+// }
+//
+// public void setNoteUserOrder(boolean noteUserOrder)
+// {
+// tx.setNoteUserOrder(noteUserOrder);
+// }
public boolean isDeleted(Identity id)
{
1.59.2.21 +77 -66 db-ojb/src/java/org/apache/ojb/odmg/TransactionImpl.java
Index: TransactionImpl.java
===================================================================
RCS file: /home/cvs/db-ojb/src/java/org/apache/ojb/odmg/TransactionImpl.java,v
retrieving revision 1.59.2.20
retrieving revision 1.59.2.21
diff -u -r1.59.2.20 -r1.59.2.21
--- TransactionImpl.java 22 Aug 2005 15:30:59 -0000 1.59.2.20
+++ TransactionImpl.java 27 Oct 2005 18:19:06 -0000 1.59.2.21
@@ -73,7 +73,7 @@
private boolean impliciteWriteLocks;
private boolean implicitLocking;
private boolean ordering;
- private boolean noteUserOrdering;
+ //private boolean noteUserOrdering;
private String txGUID;
protected PersistenceBrokerInternal broker = null;
@@ -127,7 +127,7 @@
this.impliciteWriteLocks = implementation.isImpliciteWriteLocks();
this.implicitLocking = implementation.isImplicitLocking();
this.ordering = implementation.isOrdering();
- this.noteUserOrdering = implementation.isNoteUserOrder();
+ //this.noteUserOrdering = implementation.isNoteUserOrder();
// assign a globally uniqe id to this tx
txGUID = new GUID().toString();
@@ -228,7 +228,7 @@
checkOpen();
RuntimeObject rtObject = new RuntimeObject(obj, this);
lockAndRegister(rtObject, lockMode, isImplicitLocking(), getRegistrationList());
- if(isImplicitLocking()) moveToLastInOrderList(rtObject.getIdentity());
+// if(isImplicitLocking()) moveToLastInOrderList(rtObject.getIdentity());
}
/**
@@ -261,13 +261,20 @@
* Lock and register the specified object, make sure that when cascading locking and register
* is enabled to specify a List to register the already processed object Identiy.
*/
- public void lockAndRegister(RuntimeObject rtObject, int lockMode, boolean cascade, List registeredObjects)
+ public synchronized void lockAndRegister(RuntimeObject rtObject, int lockMode, boolean cascade, List registeredObjects)
{
// if current object was already locked, do nothing
// avoid endless loops when circular object references are used
if(!registeredObjects.contains(rtObject.getIdentity()))
{
- if(cascade) registeredObjects.add(rtObject.getIdentity());
+ if(cascade)
+ {
+ // if implicite locking is enabled, first add the current object to
+ // list of registered objects to avoid
+ registeredObjects.add(rtObject.getIdentity());
+ // lock and register 1:1 references first
+ lockAndRegisterReferences(rtObject.getCld(), rtObject.getObj(), lockMode, registeredObjects);
+ }
try
{
// perform the lock on the object
@@ -276,14 +283,14 @@
{
doSingleLock(rtObject.getCld(), rtObject.getObj(), rtObject.getIdentity(), lockMode);
}
- // now register specified object + register and lock recursive all referenced objects
// after we locked the object, register it to detect status and changes while tx
- register(rtObject, lockMode, cascade, registeredObjects);
+ doSingleRegister(rtObject, lockMode);
}
catch (Throwable t)
{
//log.error("Locking of obj " + rtObject.getIdentity() + " failed", t);
- // if registering of object fails, release lock on object
+ // if registering of object fails release lock on object, because later we don't
+ // get a change to do this.
implementation.getLockManager().releaseLock(this, rtObject.getIdentity(), rtObject.getObj());
if(t instanceof LockNotGrantedException)
{
@@ -297,6 +304,11 @@
+ ": " + t.getMessage() + "]");
}
}
+ if(cascade)
+ {
+ // perform locks and register 1:n and m:n references
+ lockAndRegisterCollections(rtObject.getCld(), rtObject.getObj(), lockMode, registeredObjects);
+ }
}
}
@@ -525,7 +537,7 @@
}
catch (Throwable t)
{
- log.error("flush failed", t);
+ log.error("Calling method 'tx.flush()' failed", t);
txStatus = Status.STATUS_MARKED_ROLLBACK;
abort();
if(!(t instanceof ODMGRuntimeException))
@@ -807,6 +819,7 @@
finally
{
txStatus = Status.STATUS_ROLLEDBACK;
+ // cleanup things, e.g. release all locks
doClose();
}
}
@@ -877,11 +890,10 @@
}
/**
- * Registers the object (without locking) with this transaction and if cascade is <em>true</em>
- * recursively all associations (a implicite lock is acquired for associations). This method
- * expect that the main object is already locked!!!
+ * Registers the object (without locking) with this transaction. This method
+ * expects that the object was already locked, no check is done!!!
*/
- private synchronized void register(RuntimeObject rtObject, int lockMode, boolean cascade, List registeredObjects)
+ void doSingleRegister(RuntimeObject rtObject, int lockMode)
throws LockNotGrantedException, PersistenceBrokerException
{
Object objectToRegister = rtObject.getObj();
@@ -924,15 +936,6 @@
// no Proxy and is not null, register real object
if (objectToRegister != null)
{
- // register associated 1:1 objects
- if(cascade)
- {
- // it's save to call RTO#getObjMaterialized because we know that
- // the object is a non-null normal object or an materialized proxy
- // and the method returns in any case the real object
- lockAndRegisterReferences(rtObject.getCld(), rtObject.getObjMaterialized(), getImpliciteLockType(lockMode), registeredObjects);
- }
-
ObjectEnvelope envelope = objectEnvelopeTable.getByIdentity(rtObject.getIdentity());
// if we found an envelope, object is already registered --> we do nothing
// than refreshing the object!
@@ -961,15 +964,6 @@
// signal ObjectEnvelope that a WRITE lock is already acquired
envelope.setWriteLocked(true);
}
- // register associated 1:n and m:n objects
- if(cascade)
- {
- // it's save to call RTO#getObjMaterialized because we know that
- // the object is a non-null normal object or an materialized proxy
- // and the method returns in any case the real object
- //lockAndRegisterReferences(rtObject.getCld(), rtObject.getObjMaterialized(), getImpliciteLockType(lockMode), registeredObjects);
- lockAndRegisterCollections(rtObject.getCld(), rtObject.getObjMaterialized(), getImpliciteLockType(lockMode), registeredObjects);
- }
}
}
@@ -1035,7 +1029,7 @@
IndirectionHandler handler = ProxyHelper.getIndirectionHandler(item);
if (!handler.alreadyMaterialized())
{
- handler.addListener(this);
+ registerToIndirectionHandler(handler);
continue;
}
else
@@ -1103,7 +1097,7 @@
}
ClassDescriptor cld = getBroker().getClassDescriptor(materializedObject.getClass());
RuntimeObject rt = new RuntimeObject(materializedObject, oid, cld, false, false);
- lockAndRegister(rt, Transaction.READ, false, getRegistrationList());
+ lockAndRegister(rt, Transaction.READ, isImplicitLocking(), getRegistrationList());
}
catch (Throwable t)
{
@@ -1273,7 +1267,7 @@
Identity oid = getBroker().serviceIdentity().buildIdentity(o);
ClassDescriptor cld = getBroker().getClassDescriptor(ProxyHelper.getRealClass(o));
RuntimeObject rt = new RuntimeObject(o, oid, cld, false, ProxyHelper.isProxy(o));
- lockAndRegister(rt, Transaction.READ, false, getRegistrationList());
+ lockAndRegister(rt, Transaction.READ, isImplicitLocking(), getRegistrationList());
}
}
unregisterFromCollectionProxy(colProxy);
@@ -1362,7 +1356,9 @@
/**
* Allows to change the <em>cascading delete</em> behavior of all references of the
- * specified class while this transaction is in use.
+ * specified class while this transaction is in use - if the specified class is an
+ * interface, abstract class or class with "extent" classes the cascading flag will
+ * be propagated.
*
* @param target The class to change cascading delete behavior of all references.
* @param doCascade If <em>true</em> cascading delete is enabled, <em>false</em> disabled.
@@ -1370,18 +1366,33 @@
public void setCascadingDelete(Class target, boolean doCascade)
{
ClassDescriptor cld = getBroker().getClassDescriptor(target);
+ List extents = cld.getExtentClasses();
Boolean result = doCascade ? Boolean.TRUE : Boolean.FALSE;
+ setCascadingDelete(cld, result);
+ if(extents != null && extents.size() > 0)
+ {
+ for(int i = 0; i < extents.size(); i++)
+ {
+ Class extent = (Class) extents.get(i);
+ ClassDescriptor tmp = getBroker().getClassDescriptor(extent);
+ setCascadingDelete(tmp, result);
+ }
+ }
+ }
+
+ private void setCascadingDelete(ClassDescriptor cld, Boolean cascade)
+ {
List singleRefs = cld.getObjectReferenceDescriptors(true);
for(int i = 0; i < singleRefs.size(); i++)
{
Object o = singleRefs.get(i);
- runtimeCascadeDeleteMap.put(o, result);
+ runtimeCascadeDeleteMap.put(o, cascade);
}
List collectionRefs = cld.getCollectionDescriptors(true);
for(int i = 0; i < collectionRefs.size(); i++)
{
Object o = collectionRefs.get(i);
- runtimeCascadeDeleteMap.put(o, result);
+ runtimeCascadeDeleteMap.put(o, cascade);
}
}
@@ -1458,34 +1469,34 @@
this.ordering = ordering;
}
- /**
- * @see ImplementationExt#isNoteUserOrder()
- */
- public boolean isNoteUserOrder()
- {
- return noteUserOrdering;
- }
-
- /**
- * @see ImplementationExt#setNoteUserOrder(boolean)
- */
- public void setNoteUserOrder(boolean noteUserOrder)
- {
- this.noteUserOrdering = noteUserOrder;
- }
-
- /**
- * Move the specified {@link org.apache.ojb.broker.Identity} to the
- * last position in the order list if {@link #isNoteUserOrder()} returns <em>true</em>.
- * @param oid The object identity to move.
- */
- public void moveToLastInOrderList(Identity oid)
- {
- if(isNoteUserOrder())
- {
- objectEnvelopeTable.moveToLastInOrderList(oid);
- }
- }
+// /**
+// * @see ImplementationExt#isNoteUserOrder()
+// */
+// public boolean isNoteUserOrder()
+// {
+// return noteUserOrdering;
+// }
+//
+// /**
+// * @see ImplementationExt#setNoteUserOrder(boolean)
+// */
+// public void setNoteUserOrder(boolean noteUserOrder)
+// {
+// this.noteUserOrdering = noteUserOrder;
+// }
+//
+// /**
+// * Move the specified {@link org.apache.ojb.broker.Identity} to the
+// * last position in the order list if {@link #isNoteUserOrder()} returns <em>true</em>.
+// * @param oid The object identity to move.
+// */
+// public void moveToLastInOrderList(Identity oid)
+// {
+// if(isNoteUserOrder())
+// {
+// objectEnvelopeTable.moveToLastInOrderList(oid);
+// }
+// }
//============================================================
// inner class
---------------------------------------------------------------------
To unsubscribe, e-mail: ojb-dev-unsubscribe@db.apache.org
For additional commands, e-mail: ojb-dev-help@db.apache.org