[hibernate-commits] Hibernate SVN: r17913 - in core/trunk: core/src/main/java/org/hibernate/context and 16 other directories.
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Wed Nov 4 16:19:23 EST 2009
Author: steve.ebersole at jboss.com
Date: 2009-11-04 16:19:21 -0500 (Wed, 04 Nov 2009)
New Revision: 17913
Added:
core/trunk/core/src/main/java/org/hibernate/action/AfterTransactionCompletionProcess.java
core/trunk/core/src/main/java/org/hibernate/action/BeforeTransactionCompletionProcess.java
Modified:
core/trunk/core/src/main/java/org/hibernate/action/BulkOperationCleanupAction.java
core/trunk/core/src/main/java/org/hibernate/action/CollectionAction.java
core/trunk/core/src/main/java/org/hibernate/action/EntityAction.java
core/trunk/core/src/main/java/org/hibernate/action/EntityDeleteAction.java
core/trunk/core/src/main/java/org/hibernate/action/EntityIdentityInsertAction.java
core/trunk/core/src/main/java/org/hibernate/action/EntityInsertAction.java
core/trunk/core/src/main/java/org/hibernate/action/EntityUpdateAction.java
core/trunk/core/src/main/java/org/hibernate/action/Executable.java
core/trunk/core/src/main/java/org/hibernate/context/ThreadLocalSessionContext.java
core/trunk/core/src/main/java/org/hibernate/dialect/MySQLDialect.java
core/trunk/core/src/main/java/org/hibernate/engine/ActionQueue.java
core/trunk/core/src/main/java/org/hibernate/engine/query/NativeSQLQueryPlan.java
core/trunk/core/src/main/java/org/hibernate/engine/transaction/Isolater.java
core/trunk/core/src/main/java/org/hibernate/event/def/DefaultFlushEntityEventListener.java
core/trunk/core/src/main/java/org/hibernate/hql/ast/QueryTranslatorImpl.java
core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/AbstractStatementExecutor.java
core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/MultiTableDeleteExecutor.java
core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/MultiTableUpdateExecutor.java
core/trunk/core/src/main/java/org/hibernate/hql/ast/tree/FromClause.java
core/trunk/core/src/main/java/org/hibernate/hql/ast/tree/IntoClause.java
core/trunk/core/src/main/java/org/hibernate/impl/SessionImpl.java
core/trunk/core/src/main/java/org/hibernate/jdbc/Expectations.java
core/trunk/core/src/main/java/org/hibernate/loader/Loader.java
core/trunk/core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java
core/trunk/core/src/main/java/org/hibernate/type/CollectionType.java
core/trunk/testsuite/src/test/java/org/hibernate/test/cid/CompositeIdWithGeneratorTest.java
core/trunk/testsuite/src/test/java/org/hibernate/test/hql/ASTParserLoadingTest.java
core/trunk/testsuite/src/test/java/org/hibernate/test/jpa/lock/JPALockTest.java
Log:
HHH-4545 - Allow o.h.action.Executable to register for either (or both) before or after transaction completion callbacks
Added: core/trunk/core/src/main/java/org/hibernate/action/AfterTransactionCompletionProcess.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/action/AfterTransactionCompletionProcess.java (rev 0)
+++ core/trunk/core/src/main/java/org/hibernate/action/AfterTransactionCompletionProcess.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -0,0 +1,41 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009 by Red Hat Inc and/or its affiliates or by
+ * third-party contributors as indicated by either @author tags or express
+ * copyright attribution statements applied by the authors. All
+ * third-party contributions are distributed under license by Red Hat Inc.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ */
+package org.hibernate.action;
+
+import org.hibernate.engine.SessionImplementor;
+
+/**
+ * Contract representing some process that needs to occur during after transaction completion.
+ *
+ * @author Steve Ebersole
+ */
+public interface AfterTransactionCompletionProcess {
+ /**
+ * Perform whatever processing is encapsulated here after completion of the transaction.
+ *
+ * @param success Did the transaction complete successfully? True means it did.
+ * @param session The session on which the transaction is completing.
+ */
+ public void doAfterTransactionCompletion(boolean success, SessionImplementor session);
+}
Added: core/trunk/core/src/main/java/org/hibernate/action/BeforeTransactionCompletionProcess.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/action/BeforeTransactionCompletionProcess.java (rev 0)
+++ core/trunk/core/src/main/java/org/hibernate/action/BeforeTransactionCompletionProcess.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -0,0 +1,40 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2009 by Red Hat Inc and/or its affiliates or by
+ * third-party contributors as indicated by either @author tags or express
+ * copyright attribution statements applied by the authors. All
+ * third-party contributions are distributed under license by Red Hat Inc.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ */
+package org.hibernate.action;
+
+import org.hibernate.engine.SessionImplementor;
+
+/**
+ * Contract representing some process that needs to occur during before transaction completion.
+ *
+ * @author Steve Ebersole
+ */
+public interface BeforeTransactionCompletionProcess {
+ /**
+ * Perform whatever processing is encapsulated here before completion of the transaction.
+ *
+ * @param session The session on which the transaction is preparing to complete.
+ */
+ public void doBeforeTransactionCompletion(SessionImplementor session);
+}
Modified: core/trunk/core/src/main/java/org/hibernate/action/BulkOperationCleanupAction.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/action/BulkOperationCleanupAction.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/action/BulkOperationCleanupAction.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -70,19 +70,13 @@
* @param session The session to which this request is tied.
* @param affectedQueryables The affected entity persisters.
*/
- public BulkOperationCleanupAction(
- SessionImplementor session,
- Queryable[] affectedQueryables) {
+ public BulkOperationCleanupAction(SessionImplementor session, Queryable[] affectedQueryables) {
SessionFactoryImplementor factory = session.getFactory();
ArrayList tmpSpaces = new ArrayList();
for ( int i = 0; i < affectedQueryables.length; i++ ) {
tmpSpaces.addAll( Arrays.asList( affectedQueryables[i].getQuerySpaces() ) );
if ( affectedQueryables[i].hasCache() ) {
- entityCleanups.add(
- new EntityCleanup(
- affectedQueryables[i].getCacheAccessStrategy()
- )
- );
+ entityCleanups.add( new EntityCleanup( affectedQueryables[i].getCacheAccessStrategy() ) );
}
Set roles = factory.getCollectionRolesByEntityParticipant( affectedQueryables[i].getEntityName() );
if ( roles != null ) {
@@ -91,11 +85,7 @@
String role = ( String ) itr.next();
CollectionPersister collectionPersister = factory.getCollectionPersister( role );
if ( collectionPersister.hasCache() ) {
- collectionCleanups.add(
- new CollectionCleanup(
- collectionPersister.getCacheAccessStrategy()
- )
- );
+ collectionCleanups.add( new CollectionCleanup( collectionPersister.getCacheAccessStrategy() ) );
}
}
}
@@ -129,11 +119,7 @@
if ( affectedEntity( tableSpaces, entitySpaces ) ) {
tmpSpaces.addAll( Arrays.asList( entitySpaces ) );
if ( persister.hasCache() ) {
- entityCleanups.add(
- new EntityCleanup(
- persister.getCacheAccessStrategy()
- )
- );
+ entityCleanups.add( new EntityCleanup( persister.getCacheAccessStrategy() ) );
}
Set roles = session.getFactory().getCollectionRolesByEntityParticipant( persister.getEntityName() );
if ( roles != null ) {
@@ -143,9 +129,7 @@
CollectionPersister collectionPersister = factory.getCollectionPersister( role );
if ( collectionPersister.hasCache() ) {
collectionCleanups.add(
- new CollectionCleanup(
- collectionPersister.getCacheAccessStrategy()
- )
+ new CollectionCleanup( collectionPersister.getCacheAccessStrategy() )
);
}
}
@@ -169,9 +153,7 @@
* @return True if there are affected table spaces and any of the incoming
* check table spaces occur in that set.
*/
- private boolean affectedEntity(
- Set affectedTableSpaces,
- Serializable[] checkTableSpaces) {
+ private boolean affectedEntity(Set affectedTableSpaces, Serializable[] checkTableSpaces) {
if ( affectedTableSpaces == null || affectedTableSpaces.isEmpty() ) {
return true;
}
@@ -188,22 +170,26 @@
return affectedTableSpaces;
}
- public boolean hasAfterTransactionCompletion() {
- return true;
+ public BeforeTransactionCompletionProcess getBeforeTransactionCompletionProcess() {
+ return null;
}
- public void afterTransactionCompletion(boolean success) throws HibernateException {
- Iterator itr = entityCleanups.iterator();
- while ( itr.hasNext() ) {
- final EntityCleanup cleanup = ( EntityCleanup ) itr.next();
- cleanup.release();
- }
+ public AfterTransactionCompletionProcess getAfterTransactionCompletionProcess() {
+ return new AfterTransactionCompletionProcess() {
+ public void doAfterTransactionCompletion(boolean success, SessionImplementor session) {
+ Iterator itr = entityCleanups.iterator();
+ while ( itr.hasNext() ) {
+ final EntityCleanup cleanup = ( EntityCleanup ) itr.next();
+ cleanup.release();
+ }
- itr = collectionCleanups.iterator();
- while ( itr.hasNext() ) {
- final CollectionCleanup cleanup = ( CollectionCleanup ) itr.next();
- cleanup.release();
- }
+ itr = collectionCleanups.iterator();
+ while ( itr.hasNext() ) {
+ final CollectionCleanup cleanup = ( CollectionCleanup ) itr.next();
+ cleanup.release();
+ }
+ }
+ };
}
public void beforeExecutions() throws HibernateException {
Modified: core/trunk/core/src/main/java/org/hibernate/action/CollectionAction.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/action/CollectionAction.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/action/CollectionAction.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -39,15 +39,13 @@
/**
* Any action relating to insert/update/delete of a collection
+ *
* @author Gavin King
*/
public abstract class CollectionAction implements Executable, Serializable, Comparable {
-
private transient CollectionPersister persister;
private final Serializable key;
- private Serializable finalKey;
private final SessionImplementor session;
- private SoftLock lock;
private final String collectionRole;
private final PersistentCollection collection;
@@ -62,33 +60,47 @@
this.collectionRole = persister.getRole();
this.collection = collection;
}
-
+
protected PersistentCollection getCollection() {
return collection;
}
- private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+ protected void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ois.defaultReadObject();
persister = session.getFactory().getCollectionPersister( collectionRole );
}
- public void afterTransactionCompletion(boolean success) throws CacheException {
+ public final void beforeExecutions() throws CacheException {
+ // we need to obtain the lock before any actions are
+ // executed, since this may be an inverse="true"
+ // bidirectional association and it is one of the
+ // earlier entity actions which actually updates
+ // the database (this action is resposible for
+ // second-level cache invalidation only)
if ( persister.hasCache() ) {
- final CacheKey ck = new CacheKey(
- key,
- persister.getKeyType(),
- persister.getRole(),
- session.getEntityMode(),
- session.getFactory()
- );
- persister.getCacheAccessStrategy().unlockItem( ck, lock );
+ final CacheKey ck = new CacheKey(
+ key,
+ persister.getKeyType(),
+ persister.getRole(),
+ session.getEntityMode(),
+ session.getFactory()
+ );
+ final SoftLock lock = persister.getCacheAccessStrategy().lockItem( ck, null );
+ // the old behavior used key as opposed to getKey()
+ afterTransactionProcess = new CacheCleanupProcess( key, persister, lock );
}
}
- public boolean hasAfterTransactionCompletion() {
- return persister.hasCache();
+ public BeforeTransactionCompletionProcess getBeforeTransactionCompletionProcess() {
+ return null;
}
+ private AfterTransactionCompletionProcess afterTransactionProcess;
+
+ public AfterTransactionCompletionProcess getAfterTransactionCompletionProcess() {
+ return afterTransactionProcess;
+ }
+
public Serializable[] getPropertySpaces() {
return persister.getCollectionSpaces();
}
@@ -98,7 +110,7 @@
}
protected final Serializable getKey() {
- finalKey = key;
+ Serializable finalKey = key;
if ( key instanceof DelayedPostInsertIdentifier ) {
// need to look it up from the persistence-context
finalKey = session.getPersistenceContext().getEntry( collection.getOwner() ).getId();
@@ -114,25 +126,6 @@
return session;
}
- public final void beforeExecutions() throws CacheException {
- // we need to obtain the lock before any actions are
- // executed, since this may be an inverse="true"
- // bidirectional association and it is one of the
- // earlier entity actions which actually updates
- // the database (this action is resposible for
- // second-level cache invalidation only)
- if ( persister.hasCache() ) {
- final CacheKey ck = new CacheKey(
- key,
- persister.getKeyType(),
- persister.getRole(),
- session.getEntityMode(),
- session.getFactory()
- );
- lock = persister.getCacheAccessStrategy().lockItem( ck, null );
- }
- }
-
protected final void evict() throws CacheException {
if ( persister.hasCache() ) {
CacheKey ck = new CacheKey(
@@ -164,6 +157,29 @@
.compare( key, action.key, session.getEntityMode() );
}
}
+
+ private static class CacheCleanupProcess implements AfterTransactionCompletionProcess {
+ private final Serializable key;
+ private final CollectionPersister persister;
+ private final SoftLock lock;
+
+ private CacheCleanupProcess(Serializable key, CollectionPersister persister, SoftLock lock) {
+ this.key = key;
+ this.persister = persister;
+ this.lock = lock;
+ }
+
+ public void doAfterTransactionCompletion(boolean success, SessionImplementor session) {
+ final CacheKey ck = new CacheKey(
+ key,
+ persister.getKeyType(),
+ persister.getRole(),
+ session.getEntityMode(),
+ session.getFactory()
+ );
+ persister.getCacheAccessStrategy().unlockItem( ck, lock );
+ }
+ }
}
Modified: core/trunk/core/src/main/java/org/hibernate/action/EntityAction.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/action/EntityAction.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/action/EntityAction.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -40,7 +40,8 @@
*
* @author Gavin King
*/
-public abstract class EntityAction implements Executable, Serializable, Comparable {
+public abstract class EntityAction
+ implements Executable, Serializable, Comparable, AfterTransactionCompletionProcess {
private final String entityName;
private final Serializable id;
@@ -65,8 +66,22 @@
this.persister = persister;
}
+ public BeforeTransactionCompletionProcess getBeforeTransactionCompletionProcess() {
+ return null;
+ }
+
+ public AfterTransactionCompletionProcess getAfterTransactionCompletionProcess() {
+ return needsAfterTransactionCompletion()
+ ? this
+ : null;
+ }
+
protected abstract boolean hasPostCommitEventListeners();
+ public boolean needsAfterTransactionCompletion() {
+ return persister.hasCache() || hasPostCommitEventListeners();
+ }
+
/**
* entity name accessor
*
@@ -123,10 +138,6 @@
throw new AssertionFailure( "beforeExecutions() called for non-collection action" );
}
- public boolean hasAfterTransactionCompletion() {
- return persister.hasCache() || hasPostCommitEventListeners();
- }
-
public String toString() {
return StringHelper.unqualify( getClass().getName() ) + MessageHelper.infoString( entityName, id );
}
Modified: core/trunk/core/src/main/java/org/hibernate/action/EntityDeleteAction.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/action/EntityDeleteAction.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/action/EntityDeleteAction.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -42,12 +42,12 @@
import org.hibernate.persister.entity.EntityPersister;
public final class EntityDeleteAction extends EntityAction {
-
private final Object version;
- private SoftLock lock;
private final boolean isCascadeDeleteEnabled;
private final Object[] state;
+ private SoftLock lock;
+
public EntityDeleteAction(
final Serializable id,
final Object[] state,
@@ -86,7 +86,7 @@
persister.getRootEntityName(),
session.getEntityMode(),
session.getFactory()
- );
+ );
lock = persister.getCacheAccessStrategy().lockItem( ck, version );
}
else {
@@ -112,19 +112,19 @@
persistenceContext.removeEntity(key);
persistenceContext.removeProxy(key);
- if ( persister.hasCache() ) persister.getCacheAccessStrategy().remove( ck );
+ if ( persister.hasCache() ) {
+ persister.getCacheAccessStrategy().remove( ck );
+ }
postDelete();
if ( getSession().getFactory().getStatistics().isStatisticsEnabled() && !veto ) {
- getSession().getFactory().getStatisticsImplementor()
- .deleteEntity( getPersister().getEntityName() );
+ getSession().getFactory().getStatisticsImplementor().deleteEntity( getPersister().getEntityName() );
}
}
private boolean preDelete() {
- PreDeleteEventListener[] preListeners = getSession().getListeners()
- .getPreDeleteEventListeners();
+ PreDeleteEventListener[] preListeners = getSession().getListeners().getPreDeleteEventListeners();
boolean veto = false;
if (preListeners.length>0) {
PreDeleteEvent preEvent = new PreDeleteEvent( getInstance(), getId(), state, getPersister() ,(EventSource) getSession() );
@@ -169,29 +169,21 @@
}
}
- public void afterTransactionCompletion(boolean success) throws HibernateException {
+ public void doAfterTransactionCompletion(boolean success, SessionImplementor session) throws HibernateException {
if ( getPersister().hasCache() ) {
- final CacheKey ck = new CacheKey(
- getId(),
- getPersister().getIdentifierType(),
+ final CacheKey ck = new CacheKey(
+ getId(),
+ getPersister().getIdentifierType(),
getPersister().getRootEntityName(),
- getSession().getEntityMode(),
+ getSession().getEntityMode(),
getSession().getFactory()
- );
+ );
getPersister().getCacheAccessStrategy().unlockItem( ck, lock );
}
postCommitDelete();
}
protected boolean hasPostCommitEventListeners() {
- return getSession().getListeners().getPostCommitDeleteEventListeners().length>0;
+ return getSession().getListeners().getPostCommitDeleteEventListeners().length > 0;
}
-
}
-
-
-
-
-
-
-
Modified: core/trunk/core/src/main/java/org/hibernate/action/EntityIdentityInsertAction.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/action/EntityIdentityInsertAction.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/action/EntityIdentityInsertAction.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -37,7 +37,8 @@
import org.hibernate.event.EventSource;
import org.hibernate.persister.entity.EntityPersister;
-public final class EntityIdentityInsertAction extends EntityAction {
+public final class EntityIdentityInsertAction extends EntityAction {
+
private final Object[] state;
private final boolean isDelayed;
private final EntityKey delayedEntityKey;
@@ -53,11 +54,10 @@
super( session, null, instance, persister );
this.state = state;
this.isDelayed = isDelayed;
- delayedEntityKey = isDelayed ? generateDelayedEntityKey() : null;
+ this.delayedEntityKey = isDelayed ? generateDelayedEntityKey() : null;
}
public void execute() throws HibernateException {
-
final EntityPersister persister = getPersister();
final SessionImplementor session = getSession();
final Object instance = getInstance();
@@ -89,12 +89,29 @@
postInsert();
if ( session.getFactory().getStatistics().isStatisticsEnabled() && !veto ) {
- session.getFactory().getStatisticsImplementor()
- .insertEntity( getPersister().getEntityName() );
+ session.getFactory().getStatisticsImplementor().insertEntity( getPersister().getEntityName() );
}
}
+ public boolean needsAfterTransactionCompletion() {
+ //TODO: simply remove this override if we fix the above todos
+ return hasPostCommitEventListeners();
+ }
+
+ protected boolean hasPostCommitEventListeners() {
+ return getSession().getListeners().getPostCommitInsertEventListeners().length>0;
+ }
+
+ public void doAfterTransactionCompletion(boolean success, SessionImplementor session) {
+ //TODO: reenable if we also fix the above todo
+ /*EntityPersister persister = getEntityPersister();
+ if ( success && persister.hasCache() && !persister.isCacheInvalidationRequired() ) {
+ persister.getCache().afterInsert( getGeneratedId(), cacheEntry );
+ }*/
+ postCommitInsert();
+ }
+
private void postInsert() {
if ( isDelayed ) {
getSession().getPersistenceContext().replaceDelayedEntityIdentityInsertKeys( delayedEntityKey, generatedId );
@@ -145,26 +162,6 @@
return veto;
}
- //Make 100% certain that this is called before any subsequent ScheduledUpdate.afterTransactionCompletion()!!
- public void afterTransactionCompletion(boolean success) throws HibernateException {
- //TODO: reenable if we also fix the above todo
- /*EntityPersister persister = getEntityPersister();
- if ( success && persister.hasCache() && !persister.isCacheInvalidationRequired() ) {
- persister.getCache().afterInsert( getGeneratedId(), cacheEntry );
- }*/
- postCommitInsert();
- }
-
- public boolean hasAfterTransactionCompletion() {
- //TODO: simply remove this override
- // if we fix the above todos
- return hasPostCommitEventListeners();
- }
-
- protected boolean hasPostCommitEventListeners() {
- return getSession().getListeners().getPostCommitInsertEventListeners().length>0;
- }
-
public final Serializable getGeneratedId() {
return generatedId;
}
Modified: core/trunk/core/src/main/java/org/hibernate/action/EntityInsertAction.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/action/EntityInsertAction.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/action/EntityInsertAction.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -116,7 +116,6 @@
session.getEntityMode(),
session.getFactory()
);
-// boolean put = persister.getCache().insert(ck, cacheEntry);
boolean put = persister.getCacheAccessStrategy().insert( ck, cacheEntry, version );
if ( put && factory.getStatistics().isStatisticsEnabled() ) {
@@ -181,8 +180,10 @@
return veto;
}
- //Make 100% certain that this is called before any subsequent ScheduledUpdate.afterTransactionCompletion()!!
- public void afterTransactionCompletion(boolean success) throws HibernateException {
+ /**
+ * {@inheritDoc}
+ */
+ public void doAfterTransactionCompletion(boolean success, SessionImplementor session) throws HibernateException {
EntityPersister persister = getPersister();
if ( success && isCachePutEnabled( persister, getSession() ) ) {
final CacheKey ck = new CacheKey(
@@ -191,7 +192,7 @@
persister.getRootEntityName(),
getSession().getEntityMode(),
getSession().getFactory()
- );
+ );
boolean put = persister.getCacheAccessStrategy().afterInsert( ck, cacheEntry, version );
if ( put && getSession().getFactory().getStatistics().isStatisticsEnabled() ) {
@@ -207,16 +208,9 @@
}
private boolean isCachePutEnabled(EntityPersister persister, SessionImplementor session) {
- return persister.hasCache() &&
- !persister.isCacheInvalidationRequired() &&
- session.getCacheMode().isPutEnabled();
+ return persister.hasCache()
+ && !persister.isCacheInvalidationRequired()
+ && session.getCacheMode().isPutEnabled();
}
}
-
-
-
-
-
-
-
Modified: core/trunk/core/src/main/java/org/hibernate/action/EntityUpdateAction.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/action/EntityUpdateAction.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/action/EntityUpdateAction.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -46,14 +46,13 @@
import org.hibernate.type.TypeFactory;
public final class EntityUpdateAction extends EntityAction {
-
private final Object[] state;
private final Object[] previousState;
private final Object previousVersion;
- private Object nextVersion;
private final int[] dirtyFields;
private final boolean hasDirtyCollection;
private final Object rowId;
+ private Object nextVersion;
private Object cacheEntry;
private SoftLock lock;
@@ -149,7 +148,7 @@
nextVersion = Versioning.getVersion( state, persister );
}
}
- // have the entity entry perform post-update processing, passing it the
+ // have the entity entry doAfterTransactionCompletion post-update processing, passing it the
// update state and the new version (if one).
entry.postUpdate( instance, state, nextVersion );
}
@@ -240,7 +239,11 @@
return veto;
}
- public void afterTransactionCompletion(boolean success) throws CacheException {
+ protected boolean hasPostCommitEventListeners() {
+ return getSession().getListeners().getPostCommitUpdateEventListeners().length>0;
+ }
+
+ public void doAfterTransactionCompletion(boolean success, SessionImplementor session) throws CacheException {
EntityPersister persister = getPersister();
if ( persister.hasCache() ) {
@@ -266,10 +269,6 @@
postCommitUpdate();
}
- protected boolean hasPostCommitEventListeners() {
- return getSession().getListeners().getPostCommitUpdateEventListeners().length>0;
- }
-
}
Modified: core/trunk/core/src/main/java/org/hibernate/action/Executable.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/action/Executable.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/action/Executable.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -34,29 +34,43 @@
* together with required second-level cache management.
*
* @author Gavin King
+ * @author Steve Ebersole
*/
public interface Executable {
/**
- * Called before executing any actions
+ * What spaces (tables) are affected by this action?
+ *
+ * @return The spaces affected by this action.
*/
+ public Serializable[] getPropertySpaces();
+
+ /**
+ * Called before executing any actions. Gives actions a chance to perform any preparation.
+ *
+ * @throws HibernateException Indicates a problem during preparation.
+ */
public void beforeExecutions() throws HibernateException;
+
/**
* Execute this action
+ *
+ * @throws HibernateException Indicates a problem during execution.
*/
public void execute() throws HibernateException;
+
/**
- * Do we need to retain this instance until after the
- * transaction completes?
- * @return false if this class defines a no-op
- * <tt>hasAfterTransactionCompletion()</tt>
+ * Get the after-transaction-completion process, if any, for this action.
+ *
+ * @return The after-transaction-completion process, or null if we have no
+ * after-transaction-completion process
*/
- public boolean hasAfterTransactionCompletion();
+ public AfterTransactionCompletionProcess getAfterTransactionCompletionProcess();
+
/**
- * Called after the transaction completes
+ * Get the before-transaction-completion process, if any, for this action.
+ *
+ * @return The before-transaction-completion process, or null if we have no
+ * before-transaction-completion process
*/
- public void afterTransactionCompletion(boolean success) throws HibernateException;
- /**
- * What spaces (tables) are affected by this action?
- */
- public Serializable[] getPropertySpaces();
+ public BeforeTransactionCompletionProcess getBeforeTransactionCompletionProcess();
}
Modified: core/trunk/core/src/main/java/org/hibernate/context/ThreadLocalSessionContext.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/context/ThreadLocalSessionContext.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/context/ThreadLocalSessionContext.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -319,7 +319,7 @@
// method call to pass through since the real session
// will complain by throwing an appropriate exception;
// NOTE that allowing close() above has the same basic effect,
- // but we capture that there simply to perform the unbind...
+ // but we capture that there simply to doAfterTransactionCompletion the unbind...
}
else if ( !realSession.getTransaction().isActive() ) {
// limit the methods available if no transaction is active
Modified: core/trunk/core/src/main/java/org/hibernate/dialect/MySQLDialect.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/dialect/MySQLDialect.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/dialect/MySQLDialect.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -287,7 +287,7 @@
public Boolean performTemporaryTableDDLInIsolation() {
// because we [drop *temporary* table...] we do not
- // have to perform these in isolation.
+ // have to doAfterTransactionCompletion these in isolation.
return Boolean.FALSE;
}
Modified: core/trunk/core/src/main/java/org/hibernate/engine/ActionQueue.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/engine/ActionQueue.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/engine/ActionQueue.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -34,6 +34,7 @@
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
+import java.util.HashSet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -49,6 +50,8 @@
import org.hibernate.action.EntityInsertAction;
import org.hibernate.action.EntityUpdateAction;
import org.hibernate.action.Executable;
+import org.hibernate.action.AfterTransactionCompletionProcess;
+import org.hibernate.action.BeforeTransactionCompletionProcess;
import org.hibernate.cache.CacheException;
import org.hibernate.type.Type;
@@ -82,7 +85,8 @@
private ArrayList collectionUpdates;
private ArrayList collectionRemovals;
- private ArrayList executions;
+ private AfterTransactionCompletionProcessQueue afterTransactionProcesses;
+ private BeforeTransactionCompletionProcessQueue beforeTransactionProcesses;
/**
* Constructs an action queue bound to the given session.
@@ -103,7 +107,8 @@
collectionRemovals = new ArrayList( INIT_QUEUE_LIST_SIZE );
collectionUpdates = new ArrayList( INIT_QUEUE_LIST_SIZE );
- executions = new ArrayList( INIT_QUEUE_LIST_SIZE * 3 );
+ afterTransactionProcesses = new AfterTransactionCompletionProcessQueue( session );
+ beforeTransactionProcesses = new BeforeTransactionCompletionProcessQueue( session );
}
public void clear() {
@@ -145,10 +150,17 @@
}
public void addAction(BulkOperationCleanupAction cleanupAction) {
- // Add these directly to the executions queue
- executions.add( cleanupAction );
+ registerProcess( cleanupAction.getAfterTransactionCompletionProcess() );
}
+ public void registerProcess(AfterTransactionCompletionProcess process) {
+ afterTransactionProcesses.register( process );
+ }
+
+ public void registerProcess(BeforeTransactionCompletionProcess process) {
+ beforeTransactionProcesses.register( process );
+ }
+
/**
* Perform all currently queued entity-insertion actions.
*
@@ -189,32 +201,17 @@
* @param success Was the transaction successful.
*/
public void afterTransactionCompletion(boolean success) {
- int size = executions.size();
- final boolean invalidateQueryCache = session.getFactory().getSettings().isQueryCacheEnabled();
- for ( int i = 0; i < size; i++ ) {
- try {
- Executable exec = ( Executable ) executions.get( i );
- try {
- exec.afterTransactionCompletion( success );
- }
- finally {
- if ( invalidateQueryCache ) {
- session.getFactory().getUpdateTimestampsCache().invalidate( exec.getPropertySpaces() );
- }
- }
- }
- catch ( CacheException ce ) {
- log.error( "could not release a cache lock", ce );
- // continue loop
- }
- catch ( Exception e ) {
- throw new AssertionFailure( "Exception releasing cache locks", e );
- }
- }
- executions.clear();
+ afterTransactionProcesses.afterTransactionCompletion( success );
}
/**
+ * Execute any registered {@link BeforeTransactionCompletionProcess}
+ */
+ public void beforeTransactionCompletion() {
+ beforeTransactionProcesses.beforeTransactionCompletion();
+ }
+
+ /**
* Check whether the given tables/query-spaces are to be executed against
* given the currently queued actions.
*
@@ -267,16 +264,18 @@
}
public void execute(Executable executable) {
- final boolean lockQueryCache = session.getFactory().getSettings().isQueryCacheEnabled();
- if ( executable.hasAfterTransactionCompletion() || lockQueryCache ) {
- executions.add( executable );
+ try {
+ executable.execute();
}
- if ( lockQueryCache ) {
- session.getFactory()
- .getUpdateTimestampsCache()
- .preinvalidate( executable.getPropertySpaces() );
+ finally {
+ beforeTransactionProcesses.register( executable.getBeforeTransactionCompletionProcess() );
+ if ( session.getFactory().getSettings().isQueryCacheEnabled() ) {
+ final String[] spaces = (String[]) executable.getPropertySpaces();
+ afterTransactionProcesses.addSpacesToInvalidate( spaces );
+ session.getFactory().getUpdateTimestampsCache().preinvalidate( executable.getPropertySpaces() );
+ }
+ afterTransactionProcesses.register( executable.getAfterTransactionCompletionProcess() );
}
- executable.execute();
}
private void prepareActions(List queue) throws HibernateException {
@@ -376,7 +375,8 @@
}
public boolean hasAfterTransactionActions() {
- return executions.size() > 0;
+ // todo : method is not used anywhere; why is it here?
+ return afterTransactionProcesses.processes.size() > 0;
}
public boolean hasAnyQueuedActions() {
@@ -394,7 +394,7 @@
*
* @param oos The stream to which the action queue should get written
*
- * @throws IOException
+ * @throws IOException Indicates an error writing to the stream
*/
public void serialize(ObjectOutputStream oos) throws IOException {
log.trace( "serializing action-queue" );
@@ -447,8 +447,12 @@
* action queue
*
* @param ois The stream from which to read the action queue
+ * @param session The session to which the action queue belongs
*
- * @throws IOException
+ * @return The deserialized action queue
+ *
+ * @throws IOException indicates a problem reading from the stream
+ * @throws ClassNotFoundException Generally means we were unable to locate user classes.
*/
public static ActionQueue deserialize(
ObjectInputStream ois,
@@ -500,14 +504,100 @@
return rtn;
}
+ private static class BeforeTransactionCompletionProcessQueue {
+ private SessionImplementor session;
+ private List processes = new ArrayList();
+ private BeforeTransactionCompletionProcessQueue(SessionImplementor session) {
+ this.session = session;
+ }
+
+ public void register(BeforeTransactionCompletionProcess process) {
+ if ( process == null ) {
+ return;
+ }
+ processes.add( process );
+ }
+
+ public void beforeTransactionCompletion() {
+ final int size = processes.size();
+ for ( int i = 0; i < size; i++ ) {
+ try {
+ BeforeTransactionCompletionProcess process = ( BeforeTransactionCompletionProcess ) processes.get( i );
+ process.doBeforeTransactionCompletion( session );
+ }
+ catch ( HibernateException he ) {
+ throw he;
+ }
+ catch ( Exception e ) {
+ throw new AssertionFailure( "Unable to perform beforeTransactionCompletion callback", e );
+ }
+ }
+ processes.clear();
+ }
+ }
+
+ private static class AfterTransactionCompletionProcessQueue {
+ private SessionImplementor session;
+ private Set querySpacesToInvalidate = new HashSet();
+ private List processes = new ArrayList( INIT_QUEUE_LIST_SIZE * 3 );
+
+ private AfterTransactionCompletionProcessQueue(SessionImplementor session) {
+ this.session = session;
+ }
+
+ public void addSpacesToInvalidate(String[] spaces) {
+ if ( spaces == null ) {
+ return;
+ }
+ for ( int i = 0, max = spaces.length; i < max; i++ ) {
+ addSpaceToInvalidate( spaces[i] );
+ }
+ }
+
+ public void addSpaceToInvalidate(String space) {
+ querySpacesToInvalidate.add( space );
+ }
+
+ public void register(AfterTransactionCompletionProcess process) {
+ if ( process == null ) {
+ return;
+ }
+ processes.add( process );
+ }
+
+ public void afterTransactionCompletion(boolean success) {
+ final int size = processes.size();
+ for ( int i = 0; i < size; i++ ) {
+ try {
+ AfterTransactionCompletionProcess process = ( AfterTransactionCompletionProcess ) processes.get( i );
+ process.doAfterTransactionCompletion( success, session );
+ }
+ catch ( CacheException ce ) {
+ log.error( "could not release a cache lock", ce );
+ // continue loop
+ }
+ catch ( Exception e ) {
+ throw new AssertionFailure( "Exception releasing cache locks", e );
+ }
+ }
+ processes.clear();
+
+ if ( session.getFactory().getSettings().isQueryCacheEnabled() ) {
+ session.getFactory().getUpdateTimestampsCache().invalidate(
+ ( String[] ) querySpacesToInvalidate.toArray( new String[ querySpacesToInvalidate.size()] )
+ );
+ }
+ querySpacesToInvalidate.clear();
+ }
+ }
+
/**
* Sorts the insert actions using more hashes.
*
* @author Jay Erb
*/
private class InsertActionSorter {
-
// the mapping of entity names to their latest batch numbers.
private HashMap latestBatches = new HashMap();
private HashMap entityBatchNumber;
@@ -567,10 +657,16 @@
}
/**
- * Finds an acceptable batch for this entity to be a member.
+ * Finds an acceptable batch for this entity to be a member as part of the {@link InsertActionSorter}
+ *
+ * @param action The action being sorted
+ * @param entityName The name of the entity affected by the action
+ *
+ * @return An appropriate batch number; todo document this process better
*/
- private Integer findBatchNumber(EntityInsertAction action,
- String entityName) {
+ private Integer findBatchNumber(
+ EntityInsertAction action,
+ String entityName) {
// loop through all the associated entities and make sure they have been
// processed before the latest
// batch associated with this entity type.
Modified: core/trunk/core/src/main/java/org/hibernate/engine/query/NativeSQLQueryPlan.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/engine/query/NativeSQLQueryPlan.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/engine/query/NativeSQLQueryPlan.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -179,7 +179,7 @@
( ( EventSource ) session ).getActionQueue().addAction( action );
}
else {
- action.afterTransactionCompletion( true );
+ action.getAfterTransactionCompletionProcess().doAfterTransactionCompletion( true, session );
}
}
Modified: core/trunk/core/src/main/java/org/hibernate/engine/transaction/Isolater.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/engine/transaction/Isolater.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/engine/transaction/Isolater.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -126,7 +126,7 @@
connection = session.getBatcher().openConnection();
- // perform the actual work
+ // doAfterTransactionCompletion the actual work
work.doWork( connection );
// if everything went ok, commit the transaction and close the obtained
Modified: core/trunk/core/src/main/java/org/hibernate/event/def/DefaultFlushEntityEventListener.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/event/def/DefaultFlushEntityEventListener.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/event/def/DefaultFlushEntityEventListener.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -287,7 +287,7 @@
dirtyProperties = ArrayHelper.EMPTY_INT_ARRAY;
}
- // check nullability but do not perform command execute
+ // check nullability but do not doAfterTransactionCompletion command execute
// we'll use scheduled updates for that.
new Nullability(session).checkNullability( values, persister, true );
Modified: core/trunk/core/src/main/java/org/hibernate/hql/ast/QueryTranslatorImpl.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/hql/ast/QueryTranslatorImpl.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/hql/ast/QueryTranslatorImpl.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -547,7 +547,7 @@
if ( persister.isMultiTable() ) {
// even here, if only properties mapped to the "base table" are referenced
// in the set and where clauses, this could be handled by the BasicDelegate.
- // TODO : decide if it is better performance-wise to perform that check, or to simply use the MultiTableUpdateDelegate
+ // TODO : decide if it is better performance-wise to doAfterTransactionCompletion that check, or to simply use the MultiTableUpdateDelegate
return new MultiTableUpdateExecutor( walker );
}
else {
Modified: core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/AbstractStatementExecutor.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/AbstractStatementExecutor.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/AbstractStatementExecutor.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -245,7 +245,7 @@
( ( EventSource ) session ).getActionQueue().addAction( action );
}
else {
- action.afterTransactionCompletion( true );
+ action.getAfterTransactionCompletionProcess().doAfterTransactionCompletion( true, session );
}
}
Modified: core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/MultiTableDeleteExecutor.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/MultiTableDeleteExecutor.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/MultiTableDeleteExecutor.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -59,7 +59,7 @@
super( walker, log );
if ( !walker.getSessionFactoryHelper().getFactory().getDialect().supportsTemporaryTables() ) {
- throw new HibernateException( "cannot perform multi-table deletes using dialect not supporting temp tables" );
+ throw new HibernateException( "cannot doAfterTransactionCompletion multi-table deletes using dialect not supporting temp tables" );
}
DeleteStatement deleteStatement = ( DeleteStatement ) walker.getAST();
Modified: core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/MultiTableUpdateExecutor.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/MultiTableUpdateExecutor.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/hql/ast/exec/MultiTableUpdateExecutor.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -63,7 +63,7 @@
super( walker, log );
if ( !walker.getSessionFactoryHelper().getFactory().getDialect().supportsTemporaryTables() ) {
- throw new HibernateException( "cannot perform multi-table updates using dialect not supporting temp tables" );
+ throw new HibernateException( "cannot doAfterTransactionCompletion multi-table updates using dialect not supporting temp tables" );
}
UpdateStatement updateStatement = ( UpdateStatement ) walker.getAST();
Modified: core/trunk/core/src/main/java/org/hibernate/hql/ast/tree/FromClause.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/hql/ast/tree/FromClause.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/hql/ast/tree/FromClause.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -333,7 +333,7 @@
// the subquery has already been performed (meaning that for
// theta-join dialects, the join conditions have already been moved
// over to the where clause). A "simple" solution here might to
- // perform "join post processing" once for the entire query (including
+ // doAfterTransactionCompletion "join post processing" once for the entire query (including
// any subqueries) at one fell swoop
}
Modified: core/trunk/core/src/main/java/org/hibernate/hql/ast/tree/IntoClause.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/hql/ast/tree/IntoClause.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/hql/ast/tree/IntoClause.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -220,7 +220,7 @@
return true;
}
- // otherwise, perform a "deep equivalence" check...
+ // otherwise, doAfterTransactionCompletion a "deep equivalence" check...
if ( !target.getReturnedClass().isAssignableFrom( source.getReturnedClass() ) ) {
return false;
Modified: core/trunk/core/src/main/java/org/hibernate/impl/SessionImpl.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/impl/SessionImpl.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/impl/SessionImpl.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -423,6 +423,7 @@
public void beforeTransactionCompletion(Transaction tx) {
log.trace( "before transaction completion" );
+ actionQueue.beforeTransactionCompletion();
if ( rootSession == null ) {
try {
interceptor.beforeTransactionCompletion(tx);
@@ -1185,7 +1186,7 @@
errorIfClosed();
checkTransactionSynchStatus();
if ( query == null ) {
- throw new IllegalArgumentException("attempt to perform delete-by-query with null query");
+ throw new IllegalArgumentException("attempt to doAfterTransactionCompletion delete-by-query with null query");
}
if ( log.isTraceEnabled() ) {
Modified: core/trunk/core/src/main/java/org/hibernate/jdbc/Expectations.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/jdbc/Expectations.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/jdbc/Expectations.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -161,7 +161,7 @@
public static final Expectation NONE = new Expectation() {
public void verifyOutcome(int rowCount, PreparedStatement statement, int batchPosition) {
- // explicitly perform no checking...
+ // explicitly doAfterTransactionCompletion no checking...
}
public int prepare(PreparedStatement statement) {
Modified: core/trunk/core/src/main/java/org/hibernate/loader/Loader.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/loader/Loader.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/loader/Loader.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -352,7 +352,7 @@
throw JDBCExceptionHelper.convert(
factory.getSQLExceptionConverter(),
sqle,
- "could not perform sequential read of results (forward)",
+ "could not doAfterTransactionCompletion sequential read of results (forward)",
getSQLString()
);
}
@@ -400,7 +400,7 @@
}
// We call getKeyFromResultSet() here so that we can know the
- // key value upon which to perform the breaking logic. However,
+ // key value upon which to doAfterTransactionCompletion the breaking logic. However,
// it is also then called from getRowFromResultSet() which is certainly
// not the most efficient. But the call here is needed, and there
// currently is no other way without refactoring of the doQuery()/getRowFromResultSet()
@@ -419,7 +419,7 @@
throw JDBCExceptionHelper.convert(
factory.getSQLExceptionConverter(),
sqle,
- "could not perform sequential read of results (forward)",
+ "could not doAfterTransactionCompletion sequential read of results (forward)",
getSQLString()
);
}
@@ -538,14 +538,14 @@
// at the first physical row we are interested in loading
resultSet.next();
- // and perform the load
+ // and doAfterTransactionCompletion the load
return sequentialLoad( resultSet, session, queryParameters, returnProxies, keyToRead );
}
catch ( SQLException sqle ) {
throw JDBCExceptionHelper.convert(
factory.getSQLExceptionConverter(),
sqle,
- "could not perform sequential read of results (forward)",
+ "could not doAfterTransactionCompletion sequential read of results (forward)",
getSQLString()
);
}
Modified: core/trunk/core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -2794,7 +2794,7 @@
// need to treat this as if it where optimistic-lock="all" (dirty does *not* make sense);
// first we need to locate the "loaded" state
//
- // Note, it potentially could be a proxy, so perform the location the safe way...
+ // Note, it potentially could be a proxy, so doAfterTransactionCompletion the location the safe way...
EntityKey key = new EntityKey( id, this, session.getEntityMode() );
Object entity = session.getPersistenceContext().getEntity( key );
if ( entity != null ) {
Modified: core/trunk/core/src/main/java/org/hibernate/type/CollectionType.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/type/CollectionType.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/core/src/main/java/org/hibernate/type/CollectionType.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -120,7 +120,7 @@
}
public int getHashCode(Object x, EntityMode entityMode) {
- throw new UnsupportedOperationException( "cannot perform lookups on collections" );
+ throw new UnsupportedOperationException( "cannot doAfterTransactionCompletion lookups on collections" );
}
/**
Modified: core/trunk/testsuite/src/test/java/org/hibernate/test/cid/CompositeIdWithGeneratorTest.java
===================================================================
--- core/trunk/testsuite/src/test/java/org/hibernate/test/cid/CompositeIdWithGeneratorTest.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/testsuite/src/test/java/org/hibernate/test/cid/CompositeIdWithGeneratorTest.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -494,7 +494,7 @@
s = openSession();
t = s.beginTransaction();
- // perform a find to show that it will wire together fine
+ // doAfterTransactionCompletion a find to show that it will wire together fine
PurchaseRecord foundRecord = (PurchaseRecord) s.get(PurchaseRecord.class,
new PurchaseRecord.Id(foundPurchaseNumber, foundPurchaseSequence)
);
Modified: core/trunk/testsuite/src/test/java/org/hibernate/test/hql/ASTParserLoadingTest.java
===================================================================
--- core/trunk/testsuite/src/test/java/org/hibernate/test/hql/ASTParserLoadingTest.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/testsuite/src/test/java/org/hibernate/test/hql/ASTParserLoadingTest.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -527,14 +527,14 @@
assertEquals( 1, types.length );
assertTrue( types[0] instanceof ComponentType );
- // Test the ability to perform comparisions between component values
+ // Test the ability to doAfterTransactionCompletion comparisions between component values
s.createQuery( "from Human h where h.name = h.name" ).list();
s.createQuery( "from Human h where h.name = :name" ).setParameter( "name", new Name() ).list();
s.createQuery( "from Human where name = :name" ).setParameter( "name", new Name() ).list();
s.createQuery( "from Human h where :name = h.name" ).setParameter( "name", new Name() ).list();
s.createQuery( "from Human h where :name <> h.name" ).setParameter( "name", new Name() ).list();
- // Test the ability to perform comparisions between a component and an explicit row-value
+ // Test the ability to doAfterTransactionCompletion comparisions between a component and an explicit row-value
s.createQuery( "from Human h where h.name = ('John', 'X', 'Doe')" ).list();
s.createQuery( "from Human h where ('John', 'X', 'Doe') = h.name" ).list();
s.createQuery( "from Human h where ('John', 'X', 'Doe') <> h.name" ).list();
Modified: core/trunk/testsuite/src/test/java/org/hibernate/test/jpa/lock/JPALockTest.java
===================================================================
--- core/trunk/testsuite/src/test/java/org/hibernate/test/jpa/lock/JPALockTest.java 2009-11-04 18:40:13 UTC (rev 17912)
+++ core/trunk/testsuite/src/test/java/org/hibernate/test/jpa/lock/JPALockTest.java 2009-11-04 21:19:21 UTC (rev 17913)
@@ -74,7 +74,7 @@
Long itemId = item.getId();
- // perform the isolated update
+ // doAfterTransactionCompletion the isolated update
s1 = getSessions().openSession();
t1 = s1.beginTransaction();
item = (Item) s1.get( Item.class, itemId );
More information about the hibernate-commits
mailing list