Author: smarlow(a)redhat.com Date: 2009-11-24 18:59:50 -0500 (Tue, 24 Nov 2009) New Revision: 18053 Added: core/trunk/core/src/main/java/org/hibernate/LockOptions.java Removed: core/trunk/core/src/main/java/org/hibernate/LockRequest.java Modified: core/trunk/core/src/main/java/org/hibernate/Session.java core/trunk/core/src/main/java/org/hibernate/engine/CascadingAction.java core/trunk/core/src/main/java/org/hibernate/event/LoadEvent.java core/trunk/core/src/main/java/org/hibernate/event/LockEvent.java core/trunk/core/src/main/java/org/hibernate/event/RefreshEvent.java core/trunk/core/src/main/java/org/hibernate/event/def/AbstractLockUpgradeEventListener.java core/trunk/core/src/main/java/org/hibernate/event/def/DefaultLoadEventListener.java core/trunk/core/src/main/java/org/hibernate/event/def/DefaultLockEventListener.java core/trunk/core/src/main/java/org/hibernate/event/def/DefaultRefreshEventListener.java core/trunk/core/src/main/java/org/hibernate/impl/SessionImpl.java core/trunk/core/src/main/java/org/hibernate/loader/AbstractEntityJoinWalker.java core/trunk/core/src/main/java/org/hibernate/loader/entity/BatchingEntityLoader.java core/trunk/core/src/main/java/org/hibernate/loader/entity/EntityJoinWalker.java core/trunk/core/src/main/java/org/hibernate/loader/entity/EntityLoader.java core/trunk/core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java core/trunk/core/src/main/java/org/hibernate/persister/entity/EntityPersister.java core/trunk/core/src/main/java/org/hibernate/util/ArrayHelper.java core/trunk/entitymanager/src/main/java/org/hibernate/ejb/AbstractEntityManagerImpl.java core/trunk/testsuite/src/test/java/org/hibernate/test/legacy/CustomPersister.java Log: HHH-4546 add JPA 2.0 locking. Introduce LockOptions as the wrapper and session.buildLockRequest() (replaces session.lock()). Copied: core/trunk/core/src/main/java/org/hibernate/LockOptions.java (from rev 18016, core/trunk/core/src/main/java/org/hibernate/LockRequest.java) =================================================================== --- core/trunk/core/src/main/java/org/hibernate/LockOptions.java (rev 0) +++ core/trunk/core/src/main/java/org/hibernate/LockOptions.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -0,0 +1,114 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2009, Red Hat Middleware LLC or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors. All third-party contributions are + * distributed under license by Red Hat Middleware LLC. + * + * 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; + +/** + * Contains locking details (LockMode, Timeout and Scope). + * + * @author Scott Marlow + */ +public class LockOptions +{ + + public static final int NO_WAIT = 0; + public static final int WAIT_FOREVER = -1; + + private LockMode lockMode = LockMode.NONE; + + private int timeout = WAIT_FOREVER; // timeout in milliseconds, 0 = no wait, -1 = wait indefinitely + + private boolean scope=false;// if true, cascade (pessimistic only) lock to collections and relationships + // owned by the entity. + + public LockOptions() { + + } + + + public LockOptions( LockMode lockMode) { + this.lockMode = lockMode; + } + + /** + * Get the lock mode. + * @return the lock mode. + */ + public LockMode getLockMode() { + return lockMode; + } + + /** + * Specify the LockMode to be used. The default is LockMode.none. + * + * @param lockMode + * @return this LockRequest instance for operation chaining. + */ + public LockOptions setLockMode(LockMode lockMode) { + this.lockMode = lockMode; + return this; + } + + /** + * Get the timeout setting. + * + * @return timeout in milliseconds, -1 for indefinite wait and 0 for no wait. + */ + public int getTimeOut() { + return timeout; + } + + /** + * Specify the pessimistic lock timeout (check if your dialect supports this option). + * The default pessimistic lock behavior is to wait forever for the lock. + * + * @param timeout is time in milliseconds to wait for lock. -1 means wait forever and 0 means no wait. + * @return this LockRequest instance for operation chaining. + */ + public LockOptions setTimeOut(int timeout) { + this.timeout = timeout; + return this; + } + + /** + * Check if locking is cascaded to owned collections and relationships. + * @return true if locking will be extended to owned collections and relationships. + */ + public boolean getScope() { + return scope; + } + + /** + * Specify if LockMode should be cascaded to owned collections and relationships. + * The association must be mapped with <tt>cascade="lock" for scope=true to work. + * + * @param scope + * @return + */ + public LockOptions setScope(boolean scope) { + this.scope = scope; + return this; + } + +} Deleted: core/trunk/core/src/main/java/org/hibernate/LockRequest.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/LockRequest.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/LockRequest.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -1,115 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * Copyright (c) 2009, Red Hat Middleware LLC or third-party contributors as - * indicated by the @author tags or express copyright attribution - * statements applied by the authors. All third-party contributions are - * distributed under license by Red Hat Middleware LLC. - * - * 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; - -/** - * Contains locking details (LockMode, Timeout and Scope). - * - * @author Scott Marlow - */ -public class LockRequest -{ - - public static final int NO_WAIT = 0; - public static final int WAIT_FOREVER = -1; - - private LockMode lockMode = LockMode.NONE; - - private int timeout = WAIT_FOREVER; // timeout in milliseconds, 0 = no wait, -1 = wait indefinitely - - private boolean scope=false;// if true, cascade (pessimistic only) lock to collections and relationships - // owned by the entity. - - public LockRequest() { - - } - - public LockRequest( LockMode lockMode, int timeout, boolean scope ) { - this.lockMode = lockMode; - this.timeout = timeout; - this.scope = scope; - } - - /** - * Get the lock mode. - * @return the lock mode. - */ - public LockMode getLockMode() { - return lockMode; - } - - /** - * Specify the LockMode to be used. The default is LockMode.none. - * - * @param lockMode - * @return this LockRequest instance for operation chaining. - */ - public LockRequest setLockMode(LockMode lockMode) { - this.lockMode = lockMode; - return this; - } - - /** - * Get the timeout setting. - * - * @return timeout in milliseconds, -1 for indefinite wait and 0 for no wait. - */ - public int getTimeOut() { - return timeout; - } - - /** - * Specify the pessimistic lock timeout (check if your dialect supports this option). - * The default pessimistic lock behavior is to wait forever for the lock. - * - * @param timeout is time in milliseconds to wait for lock. -1 means wait forever and 0 means no wait. - * @return this LockRequest instance for operation chaining. - */ - public LockRequest setTimeOut(int timeout) { - this.timeout = timeout; - return this; - } - - /** - * Check if locking is cascaded to owned collections and relationships. - * @return true if locking will be extended to owned collections and relationships. - */ - public boolean getScope() { - return scope; - } - - /** - * Specify if LockMode should be cascaded to owned collections and relationships. - * The association must be mapped with <tt>cascade="lock" for scope=true to work. - * - * @param scope - * @return - */ - public LockRequest setScope(boolean scope) { - this.scope = scope; - return this; - } - -} Modified: core/trunk/core/src/main/java/org/hibernate/Session.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/Session.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/Session.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -270,7 +270,7 @@ * @param lockMode the lock level * @return the persistent instance or proxy * @throws HibernateException - * @deprecated LockMode parameter should be replaced with a LockRequest + * @deprecated LockMode parameter should be replaced with LockOptions */ public Object load(Class theClass, Serializable id, LockMode lockMode) throws HibernateException; @@ -280,11 +280,11 @@ * * @param theClass a persistent class * @param id a valid identifier of an existing persistent instance of the class - * @param lockRequest contains the lock level + * @param lockOptions contains the lock level * @return the persistent instance or proxy * @throws HibernateException */ - public Object load(Class theClass, Serializable id, LockRequest lockRequest) throws HibernateException; + public Object load(Class theClass, Serializable id, LockOptions lockOptions) throws HibernateException; /** * Return the persistent instance of the given entity class with the given identifier, @@ -295,7 +295,7 @@ * @param lockMode the lock level * @return the persistent instance or proxy * @throws HibernateException - * @deprecated LockMode parameter should be replaced with a LockRequest + * @deprecated LockMode parameter should be replaced with LockOptions */ public Object load(String entityName, Serializable id, LockMode lockMode) throws HibernateException; @@ -305,11 +305,11 @@ * * @param entityName a persistent class * @param id a valid identifier of an existing persistent instance of the class - * @param lockRequest contains the lock level + * @param lockOptions contains the lock level * @return the persistent instance or proxy * @throws HibernateException */ - public Object load(String entityName, Serializable id, LockRequest lockRequest) throws HibernateException; + public Object load(String entityName, Serializable id, LockOptions lockOptions) throws HibernateException; /** * Return the persistent instance of the given entity class with the given identifier, @@ -533,7 +533,7 @@ * @param object a persistent or transient instance * @param lockMode the lock level * @throws HibernateException - * @deprecated LockMode parameter should be replaced with a LockRequest + * @deprecated instead call buildLockRequest(LockMode).lock(object) */ public void lock(Object object, LockMode lockMode) throws HibernateException; @@ -542,51 +542,27 @@ * perform a version check (<tt>LockMode.OPTIMISTIC</tt>), to upgrade to a pessimistic * lock (<tt>LockMode.PESSIMISTIC_WRITE</tt>), or to simply reassociate a transient instance * with a session (<tt>LockMode.NONE</tt>). This operation cascades to associated - * instances if the association is mapped with <tt>cascade="lock" and lockRequest.getScope() == true</tt>. - * - * @param object a persistent or transient instance - * @param lockRequest contains the lock level - * @throws HibernateException - */ - public void lock(Object object, LockRequest lockRequest) throws HibernateException; - - /** - * Obtain the specified lock level upon the given object. This may be used to - * perform a version check (<tt>LockMode.OPTIMISTIC</tt>), to upgrade to a pessimistic - * lock (<tt>LockMode.PESSIMISTIC_WRITE</tt>), or to simply reassociate a transient instance - * with a session (<tt>LockMode.NONE</tt>). This operation cascades to associated * instances if the association is mapped with <tt>cascade="lock"</tt>. * * @param object a persistent or transient instance * @param lockMode the lock level * @throws HibernateException - * @deprecated LockMode parameter should be replaced with a LockRequest + * @deprecated instead call buildLockRequest(LockMode).lock(entityName, object) */ public void lock(String entityName, Object object, LockMode lockMode) throws HibernateException; /** - * Obtain the specified lock level upon the given object. This may be used to - * perform a version check (<tt>LockMode.OPTIMISTIC</tt>), to upgrade to a pessimistic - * lock (<tt>LockMode.PESSIMISTIC_WRITE</tt>), or to simply reassociate a transient instance - * with a session (<tt>LockMode.NONE</tt>). This operation cascades to associated - * instances if the association is mapped with <tt>cascade="lock" and lockRequest.getScope() == true.</tt>. - * - * @param object a persistent or transient instance - * @param lockRequest contains the lock level - * @throws HibernateException - */ - public void lock(String entityName, Object object, LockRequest lockRequest) throws HibernateException; - - /** * Build a lockRequest that specifies the LockMode, pessimistic lock timeout and lock scope. * timeout and scope is ignored for optimistic locking. * - * Use: LockRequest lr = session.buildLockRequest().setLockMode(LockMode.PESSIMISTIC_WRITE).setTimeOut(1000 * 60); - * session.lock(entity, lr); + * Use: session.buildLockRequest(). + * setLockMode(LockMode.PESSIMISTIC_WRITE).setTimeOut(1000 * 60).lock(entity); * + * @param lockOptions contains the lock level + * @return a lockRequest that can be used to lock the passed object. * @throws HibernateException */ - LockRequest buildLockRequest(); + public LockRequest buildLockRequest(LockOptions lockOptions); /** * Re-read the state of the given instance from the underlying database. It is @@ -613,7 +589,7 @@ * @param object a persistent or detached instance * @param lockMode the lock mode to use * @throws HibernateException - * @deprecated LockMode parameter should be replaced with a LockRequest + * @deprecated LockMode parameter should be replaced with LockOptions */ public void refresh(Object object, LockMode lockMode) throws HibernateException; @@ -624,10 +600,10 @@ * useful in certain special circumstances. * * @param object a persistent or detached instance - * @param lockRequest contains the lock mode to use + * @param lockOptions contains the lock mode to use * @throws HibernateException */ - public void refresh(Object object, LockRequest lockRequest) throws HibernateException; + public void refresh(Object object, LockOptions lockOptions) throws HibernateException; /** * Determine the current lock mode of the given object. @@ -766,7 +742,7 @@ * @param lockMode the lock mode * @return a persistent instance or null * @throws HibernateException - * @deprecated LockMode parameter should be replaced with a LockRequest + * @deprecated LockMode parameter should be replaced with LockOptions */ public Object get(Class clazz, Serializable id, LockMode lockMode) throws HibernateException; @@ -778,11 +754,11 @@ * * @param clazz a persistent class * @param id an identifier - * @param lockRequest the lock mode + * @param lockOptions the lock mode * @return a persistent instance or null * @throws HibernateException */ - public Object get(Class clazz, Serializable id, LockRequest lockRequest) throws HibernateException; + public Object get(Class clazz, Serializable id, LockOptions lockOptions) throws HibernateException; /** * Return the persistent instance of the given named entity with the given identifier, @@ -807,7 +783,7 @@ * @param lockMode the lock mode * @return a persistent instance or null * @throws HibernateException - * @deprecated LockMode parameter should be replaced with a LockRequest + * @deprecated LockMode parameter should be replaced with LockOptions */ public Object get(String entityName, Serializable id, LockMode lockMode) throws HibernateException; @@ -819,11 +795,11 @@ * * @param entityName the entity name * @param id an identifier - * @param lockRequest contains the lock mode + * @param lockOptions contains the lock mode * @return a persistent instance or null * @throws HibernateException */ - public Object get(String entityName, Serializable id, LockRequest lockRequest) throws HibernateException; + public Object get(String entityName, Serializable id, LockOptions lockOptions) throws HibernateException; /** @@ -957,4 +933,68 @@ * @see org.hibernate.engine.profile.FetchProfile for discussion of this feature */ public void disableFetchProfile(String name) throws UnknownProfileException; + + + +/** + * Contains locking details (LockMode, Timeout and Scope). + * + */ + public interface LockRequest + { + + static final int PESSIMISTIC_NO_WAIT = 0; + static final int PESSIMISTIC_WAIT_FOREVER = -1; + + /** + * Get the lock mode. + * @return the lock mode. + */ + LockMode getLockMode(); + + /** + * Specify the LockMode to be used. The default is LockMode.none. + * + * @param lockMode + * @return this LockRequest instance for operation chaining. + */ + LockRequest setLockMode(LockMode lockMode); + + /** + * Get the timeout setting. + * + * @return timeout in milliseconds, -1 for indefinite wait and 0 for no wait. + */ + int getTimeOut(); + + /** + * Specify the pessimistic lock timeout (check if your dialect supports this option). + * The default pessimistic lock behavior is to wait forever for the lock. + * + * @param timeout is time in milliseconds to wait for lock. -1 means wait forever and 0 means no wait. + * @return this LockRequest instance for operation chaining. + */ + LockRequest setTimeOut(int timeout); + + /** + * Check if locking is cascaded to owned collections and relationships. + * @return true if locking will be extended to owned collections and relationships. + */ + boolean getScope(); + + /** + * Specify if LockMode should be cascaded to owned collections and relationships. + * The association must be mapped with <tt>cascade="lock" for scope=true to work. + * + * @param scope + * @return + */ + LockRequest setScope(boolean scope); + + void lock(String entityName, Object object) throws HibernateException; + + public void lock(Object object) throws HibernateException; + + } + } Modified: core/trunk/core/src/main/java/org/hibernate/engine/CascadingAction.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/engine/CascadingAction.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/engine/CascadingAction.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -34,7 +34,7 @@ import org.hibernate.LockMode; import org.hibernate.ReplicationMode; import org.hibernate.TransientObjectException; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; import org.hibernate.proxy.HibernateProxy; import org.hibernate.persister.entity.EntityPersister; import org.hibernate.collection.PersistentCollection; @@ -167,16 +167,16 @@ log.trace( "cascading to lock: " + entityName ); } LockMode lockMode = LockMode.NONE; - LockRequest lr = new LockRequest(); - if ( anything instanceof LockRequest ) { - LockRequest lockRequest = (LockRequest)anything; - lr.setTimeOut(lockRequest.getTimeOut()); - lr.setScope( lockRequest.getScope()); - if ( lockRequest.getScope() == true ) // cascade specified lockMode - lockMode = lockRequest.getLockMode(); + LockOptions lr = new LockOptions(); + if ( anything instanceof LockOptions) { + LockOptions lockOptions = (LockOptions)anything; + lr.setTimeOut(lockOptions.getTimeOut()); + lr.setScope( lockOptions.getScope()); + if ( lockOptions.getScope() == true ) // cascade specified lockMode + lockMode = lockOptions.getLockMode(); } lr.setLockMode(lockMode); - session.lock( entityName, child, lr); + session.buildLockRequest(lr).lock(entityName, child); } public Iterator getCascadableChildrenIterator(EventSource session, CollectionType collectionType, Object collection) { // lock doesn't cascade to uninitialized collections Modified: core/trunk/core/src/main/java/org/hibernate/event/LoadEvent.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/event/LoadEvent.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/event/LoadEvent.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -27,7 +27,7 @@ import java.io.Serializable; import org.hibernate.LockMode; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; /** * Defines an event class for the loading of an entity. @@ -41,24 +41,24 @@ private Serializable entityId; private String entityClassName; private Object instanceToLoad; - private LockRequest lockRequest; + private LockOptions lockOptions; private boolean isAssociationFetch; private Object result; public LoadEvent(Serializable entityId, Object instanceToLoad, EventSource source) { - this(entityId, null, instanceToLoad, new LockRequest(), false, source); + this(entityId, null, instanceToLoad, new LockOptions(), false, source); } public LoadEvent(Serializable entityId, String entityClassName, LockMode lockMode, EventSource source) { this(entityId, entityClassName, null, lockMode, false, source); } - public LoadEvent(Serializable entityId, String entityClassName, LockRequest lockRequest, EventSource source) { - this(entityId, entityClassName, null, lockRequest, false, source); + public LoadEvent(Serializable entityId, String entityClassName, LockOptions lockOptions, EventSource source) { + this(entityId, entityClassName, null, lockOptions, false, source); } public LoadEvent(Serializable entityId, String entityClassName, boolean isAssociationFetch, EventSource source) { - this(entityId, entityClassName, null, new LockRequest(), isAssociationFetch, source); + this(entityId, entityClassName, null, new LockOptions(), isAssociationFetch, source); } public boolean isAssociationFetch() { @@ -72,14 +72,14 @@ LockMode lockMode, boolean isAssociationFetch, EventSource source) { - this(entityId, entityClassName, instanceToLoad, new LockRequest().setLockMode(lockMode), isAssociationFetch, source ); + this(entityId, entityClassName, instanceToLoad, new LockOptions().setLockMode(lockMode), isAssociationFetch, source ); } private LoadEvent( Serializable entityId, String entityClassName, Object instanceToLoad, - LockRequest lockRequest, + LockOptions lockOptions, boolean isAssociationFetch, EventSource source) { @@ -89,17 +89,17 @@ throw new IllegalArgumentException("id to load is required for loading"); } - if ( lockRequest.getLockMode() == LockMode.WRITE ) { + if ( lockOptions.getLockMode() == LockMode.WRITE ) { throw new IllegalArgumentException("Invalid lock mode for loading"); } - else if ( lockRequest.getLockMode() == null ) { - lockRequest.setLockMode(DEFAULT_LOCK_MODE); + else if ( lockOptions.getLockMode() == null ) { + lockOptions.setLockMode(DEFAULT_LOCK_MODE); } this.entityId = entityId; this.entityClassName = entityClassName; this.instanceToLoad = instanceToLoad; - this.lockRequest = lockRequest; + this.lockOptions = lockOptions; this.isAssociationFetch = isAssociationFetch; } @@ -127,32 +127,32 @@ this.instanceToLoad = instanceToLoad; } - public LockRequest getLockRequest() { - return lockRequest; + public LockOptions getLockOptions() { + return lockOptions; } public LockMode getLockMode() { - return lockRequest.getLockMode(); + return lockOptions.getLockMode(); } public void setLockMode(LockMode lockMode) { - this.lockRequest.setLockMode(lockMode); + this.lockOptions.setLockMode(lockMode); } public void setLockTimeout(int timeout) { - this.lockRequest.setTimeOut(timeout); + this.lockOptions.setTimeOut(timeout); } public int getLockTimeout() { - return this.lockRequest.getTimeOut(); + return this.lockOptions.getTimeOut(); } public void setLockScope(boolean cascade) { - this.lockRequest.setScope(cascade); + this.lockOptions.setScope(cascade); } public boolean getLockScope() { - return this.lockRequest.getScope(); + return this.lockOptions.getScope(); } public Object getResult() { Modified: core/trunk/core/src/main/java/org/hibernate/event/LockEvent.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/event/LockEvent.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/event/LockEvent.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -25,7 +25,7 @@ package org.hibernate.event; import org.hibernate.LockMode; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; /** * Defines an event class for the locking of an entity. @@ -35,7 +35,7 @@ public class LockEvent extends AbstractEvent { private Object object; - private LockRequest lockRequest; + private LockOptions lockOptions; private String entityName; public LockEvent(String entityName, Object original, LockMode lockMode, EventSource source) { @@ -43,21 +43,21 @@ this.entityName = entityName; } - public LockEvent(String entityName, Object original, LockRequest lockRequest, EventSource source) { - this(original, lockRequest, source); + public LockEvent(String entityName, Object original, LockOptions lockOptions, EventSource source) { + this(original, lockOptions, source); this.entityName = entityName; } public LockEvent(Object object, LockMode lockMode, EventSource source) { super(source); this.object = object; - this.lockRequest = new LockRequest().setLockMode(lockMode); + this.lockOptions = new LockOptions().setLockMode(lockMode); } - public LockEvent(Object object, LockRequest lockRequest, EventSource source) { + public LockEvent(Object object, LockOptions lockOptions, EventSource source) { super(source); this.object = object; - this.lockRequest = lockRequest; + this.lockOptions = lockOptions; } public Object getObject() { @@ -68,32 +68,32 @@ this.object = object; } - public LockRequest getLockRequest() { - return lockRequest; + public LockOptions getLockOptions() { + return lockOptions; } public LockMode getLockMode() { - return lockRequest.getLockMode(); + return lockOptions.getLockMode(); } public void setLockMode(LockMode lockMode) { - this.lockRequest.setLockMode(lockMode); + this.lockOptions.setLockMode(lockMode); } public void setLockTimeout(int timeout) { - this.lockRequest.setTimeOut(timeout); + this.lockOptions.setTimeOut(timeout); } public int getLockTimeout() { - return this.lockRequest.getTimeOut(); + return this.lockOptions.getTimeOut(); } public void setLockScope(boolean cascade) { - this.lockRequest.setScope(cascade); + this.lockOptions.setScope(cascade); } public boolean getLockScope() { - return this.lockRequest.getScope(); + return this.lockOptions.getScope(); } public String getEntityName() { Modified: core/trunk/core/src/main/java/org/hibernate/event/RefreshEvent.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/event/RefreshEvent.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/event/RefreshEvent.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -25,7 +25,7 @@ package org.hibernate.event; import org.hibernate.LockMode; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; /** * Defines an event class for the refreshing of an object. @@ -35,7 +35,7 @@ public class RefreshEvent extends AbstractEvent { private Object object; - private LockRequest lockRequest = new LockRequest().setLockMode(LockMode.READ); + private LockOptions lockOptions = new LockOptions().setLockMode(LockMode.READ); public RefreshEvent(Object object, EventSource source) { super(source); @@ -50,34 +50,34 @@ if (lockMode == null) { throw new IllegalArgumentException("Attempt to generate refresh event with null lock mode"); } - this.lockRequest.setLockMode(lockMode); + this.lockOptions.setLockMode(lockMode); } - public RefreshEvent(Object object, LockRequest lockRequest, EventSource source) { + public RefreshEvent(Object object, LockOptions lockOptions, EventSource source) { this(object, source); - if (lockRequest == null) { + if (lockOptions == null) { throw new IllegalArgumentException("Attempt to generate refresh event with null lock request"); } - this.lockRequest = lockRequest; + this.lockOptions = lockOptions; } public Object getObject() { return object; } - public LockRequest getLockRequest() { - return lockRequest; + public LockOptions getLockOptions() { + return lockOptions; } public LockMode getLockMode() { - return lockRequest.getLockMode(); + return lockOptions.getLockMode(); } public int getLockTimeout() { - return this.lockRequest.getTimeOut(); + return this.lockOptions.getTimeOut(); } public boolean getLockScope() { - return this.lockRequest.getScope(); + return this.lockOptions.getScope(); } } Modified: core/trunk/core/src/main/java/org/hibernate/event/def/AbstractLockUpgradeEventListener.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/event/def/AbstractLockUpgradeEventListener.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/event/def/AbstractLockUpgradeEventListener.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -29,11 +29,8 @@ import org.hibernate.LockMode; import org.hibernate.ObjectDeletedException; -import org.hibernate.OptimisticLockException; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; import org.hibernate.event.EventSource; -import org.hibernate.action.EntityIncrementVersionProcess; -import org.hibernate.action.EntityVerifyVersionProcess; import org.hibernate.cache.CacheKey; import org.hibernate.cache.access.SoftLock; import org.hibernate.engine.EntityEntry; @@ -56,12 +53,12 @@ * * @param object The entity for which to upgrade the lock. * @param entry The entity's EntityEntry instance. - * @param lockRequest contains the requested lock mode. + * @param lockOptions contains the requested lock mode. * @param source The session which is the source of the event being processed. */ - protected void upgradeLock(Object object, EntityEntry entry, LockRequest lockRequest, EventSource source) { + protected void upgradeLock(Object object, EntityEntry entry, LockOptions lockOptions, EventSource source) { - LockMode requestedLockMode = lockRequest.getLockMode(); + LockMode requestedLockMode = lockOptions.getLockMode(); if ( requestedLockMode.greaterThan( entry.getLockMode() ) ) { // The user requested a "greater" (i.e. more restrictive) form of // pessimistic lock Modified: core/trunk/core/src/main/java/org/hibernate/event/def/DefaultLoadEventListener.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/event/def/DefaultLoadEventListener.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/event/def/DefaultLoadEventListener.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -485,7 +485,7 @@ return INCONSISTENT_RTN_CLASS_MARKER; } } - upgradeLock( old, oldEntry, event.getLockRequest(), event.getSession() ); + upgradeLock( old, oldEntry, event.getLockOptions(), event.getSession() ); } return old; Modified: core/trunk/core/src/main/java/org/hibernate/event/def/DefaultLockEventListener.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/event/def/DefaultLockEventListener.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/event/def/DefaultLockEventListener.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -83,7 +83,7 @@ cascadeOnLock(event, persister, entity); } - upgradeLock( entity, entry, event.getLockRequest(), event.getSession() ); + upgradeLock( entity, entry, event.getLockOptions(), event.getSession() ); } private void cascadeOnLock(LockEvent event, EntityPersister persister, Object entity) { @@ -91,7 +91,7 @@ source.getPersistenceContext().incrementCascadeLevel(); try { new Cascade(CascadingAction.LOCK, Cascade.AFTER_LOCK, source) - .cascade( persister, entity, event.getLockRequest() ); + .cascade( persister, entity, event.getLockOptions() ); } finally { source.getPersistenceContext().decrementCascadeLevel(); Modified: core/trunk/core/src/main/java/org/hibernate/event/def/DefaultRefreshEventListener.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/event/def/DefaultRefreshEventListener.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/event/def/DefaultRefreshEventListener.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -142,7 +142,7 @@ String previousFetchProfile = source.getFetchProfile(); source.setFetchProfile("refresh"); - Object result = persister.load( id, object, event.getLockRequest(), source ); + Object result = persister.load( id, object, event.getLockOptions(), source ); source.setFetchProfile(previousFetchProfile); UnresolvableObjectException.throwIfNull( result, id, persister.getEntityName() ); 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-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/impl/SessionImpl.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -69,7 +69,7 @@ import org.hibernate.UnresolvableObjectException; import org.hibernate.UnknownProfileException; import org.hibernate.EntityNameResolver; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; import org.hibernate.collection.PersistentCollection; import org.hibernate.engine.ActionQueue; import org.hibernate.engine.CollectionEntry; @@ -742,21 +742,20 @@ fireLock( new LockEvent(entityName, object, lockMode, this) ); } - public void lock(String entityName, Object object, LockRequest lockRequest) throws HibernateException { - fireLock( new LockEvent(entityName, object, lockRequest, this) ); + public LockRequest buildLockRequest(LockOptions lockOptions) { + return new LockRequestImpl(lockOptions); } - public LockRequest buildLockRequest() { - return new LockRequest(); - } - public void lock(Object object, LockMode lockMode) throws HibernateException { fireLock( new LockEvent(object, lockMode, this) ); } + private void fireLock(String entityName, Object object, LockOptions options) { + fireLock( new LockEvent( entityName, object, options, this) ); + } - public void lock(Object object, LockRequest lockRequest) throws HibernateException { - fireLock( new LockEvent(object, lockRequest, this) ); + private void fireLock( Object object, LockOptions options) { + fireLock( new LockEvent( object, options, this) ); } private void fireLock(LockEvent lockEvent) { @@ -1037,8 +1036,8 @@ return load( entityClass.getName(), id, lockMode ); } - public Object load(Class entityClass, Serializable id, LockRequest lockRequest) throws HibernateException { - return load( entityClass.getName(), id, lockRequest ); + public Object load(Class entityClass, Serializable id, LockOptions lockOptions) throws HibernateException { + return load( entityClass.getName(), id, lockOptions); } public Object load(String entityName, Serializable id, LockMode lockMode) throws HibernateException { @@ -1047,8 +1046,8 @@ return event.getResult(); } - public Object load(String entityName, Serializable id, LockRequest lockRequest) throws HibernateException { - LoadEvent event = new LoadEvent(id, entityName, lockRequest, this); + public Object load(String entityName, Serializable id, LockOptions lockOptions) throws HibernateException { + LoadEvent event = new LoadEvent(id, entityName, lockOptions, this); fireLoad( event, LoadEventListener.LOAD ); return event.getResult(); } @@ -1057,8 +1056,8 @@ return get( entityClass.getName(), id, lockMode ); } - public Object get(Class entityClass, Serializable id, LockRequest lockRequest) throws HibernateException { - return get( entityClass.getName(), id, lockRequest ); + public Object get(Class entityClass, Serializable id, LockOptions lockOptions) throws HibernateException { + return get( entityClass.getName(), id, lockOptions); } public Object get(String entityName, Serializable id, LockMode lockMode) throws HibernateException { @@ -1067,8 +1066,8 @@ return event.getResult(); } - public Object get(String entityName, Serializable id, LockRequest lockRequest) throws HibernateException { - LoadEvent event = new LoadEvent(id, entityName, lockRequest, this); + public Object get(String entityName, Serializable id, LockOptions lockOptions) throws HibernateException { + LoadEvent event = new LoadEvent(id, entityName, lockOptions, this); fireLoad(event, LoadEventListener.GET); return event.getResult(); } @@ -1093,8 +1092,8 @@ fireRefresh( new RefreshEvent(object, lockMode, this) ); } - public void refresh(Object object, LockRequest lockRequest) throws HibernateException { - fireRefresh( new RefreshEvent(object, lockRequest, this) ); + public void refresh(Object object, LockOptions lockOptions) throws HibernateException { + fireRefresh( new RefreshEvent(object, lockOptions, this) ); } public void refresh(Object object, Map refreshedAlready) throws HibernateException { @@ -2217,4 +2216,48 @@ return entity.getClass().getName(); } } + + private class LockRequestImpl implements LockRequest { + private final LockOptions lockOptions; + private LockRequestImpl(LockOptions lo) { + lockOptions = new LockOptions(); + lockOptions.setLockMode(lo.getLockMode()); + lockOptions.setScope(lo.getScope()); + lockOptions.setTimeOut(lo.getTimeOut()); + } + + public LockMode getLockMode() { + return lockOptions.getLockMode(); + } + + public LockRequest setLockMode(LockMode lockMode) { + lockOptions.setLockMode(lockMode); + return this; + } + + public int getTimeOut() { + return lockOptions.getTimeOut(); + } + + public LockRequest setTimeOut(int timeout) { + lockOptions.setTimeOut(timeout); + return this; + } + + public boolean getScope() { + return lockOptions.getScope(); + } + + public LockRequest setScope(boolean scope) { + lockOptions.setScope(scope); + return this; + } + + public void lock(String entityName, Object object) throws HibernateException { + fireLock( entityName, object, lockOptions ); + } + public void lock(Object object) throws HibernateException { + fireLock( object, lockOptions ); + } + } } Modified: core/trunk/core/src/main/java/org/hibernate/loader/AbstractEntityJoinWalker.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/loader/AbstractEntityJoinWalker.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/loader/AbstractEntityJoinWalker.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -31,7 +31,7 @@ import org.hibernate.FetchMode; import org.hibernate.LockMode; import org.hibernate.MappingException; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; import org.hibernate.engine.CascadeStyle; import org.hibernate.engine.SessionFactoryImplementor; import org.hibernate.engine.LoadQueryInfluencers; @@ -98,7 +98,7 @@ protected final void initAll( final String whereString, final String orderByString, - final LockRequest lockRequest) throws MappingException { + final LockOptions lockOptions) throws MappingException { walkEntityTree( persister, getAlias() ); List allAssociations = new ArrayList(); allAssociations.addAll(associations); @@ -114,8 +114,8 @@ CollectionHelper.EMPTY_MAP ) ); - initPersisters(allAssociations, lockRequest.getLockMode()); - initStatementString( whereString, orderByString, lockRequest.getLockMode()); + initPersisters(allAssociations, lockOptions.getLockMode()); + initStatementString( whereString, orderByString, lockOptions.getLockMode()); } protected final void initProjection( Modified: core/trunk/core/src/main/java/org/hibernate/loader/entity/BatchingEntityLoader.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/loader/entity/BatchingEntityLoader.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/loader/entity/BatchingEntityLoader.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -27,13 +27,11 @@ import java.io.Serializable; import java.util.Iterator; import java.util.List; -import java.util.Map; -import java.util.Set; import org.hibernate.HibernateException; import org.hibernate.LockMode; import org.hibernate.MappingException; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; import org.hibernate.engine.SessionFactoryImplementor; import org.hibernate.engine.SessionImplementor; import org.hibernate.engine.LoadQueryInfluencers; @@ -132,7 +130,7 @@ public static UniqueEntityLoader createBatchingEntityLoader( final OuterJoinLoadable persister, final int maxBatchSize, - final LockRequest lockRequest, + final LockOptions lockOptions, final SessionFactoryImplementor factory, final LoadQueryInfluencers loadQueryInfluencers) throws MappingException { @@ -140,12 +138,12 @@ int[] batchSizesToCreate = ArrayHelper.getBatchSizes(maxBatchSize); Loader[] loadersToCreate = new Loader[ batchSizesToCreate.length ]; for ( int i=0; i<batchSizesToCreate.length; i++ ) { - loadersToCreate[i] = new EntityLoader(persister, batchSizesToCreate[i], lockRequest, factory, loadQueryInfluencers); + loadersToCreate[i] = new EntityLoader(persister, batchSizesToCreate[i], lockOptions, factory, loadQueryInfluencers); } return new BatchingEntityLoader(persister, batchSizesToCreate, loadersToCreate); } else { - return new EntityLoader(persister, lockRequest, factory, loadQueryInfluencers); + return new EntityLoader(persister, lockOptions, factory, loadQueryInfluencers); } } Modified: core/trunk/core/src/main/java/org/hibernate/loader/entity/EntityJoinWalker.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/loader/entity/EntityJoinWalker.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/loader/entity/EntityJoinWalker.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -25,17 +25,14 @@ package org.hibernate.loader.entity; import java.util.Collections; -import java.util.Iterator; import org.hibernate.FetchMode; import org.hibernate.LockMode; import org.hibernate.MappingException; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; import org.hibernate.engine.CascadeStyle; import org.hibernate.engine.SessionFactoryImplementor; import org.hibernate.engine.LoadQueryInfluencers; -import org.hibernate.engine.profile.FetchProfile; -import org.hibernate.engine.profile.Fetch; import org.hibernate.loader.AbstractEntityJoinWalker; import org.hibernate.persister.entity.OuterJoinLoadable; import org.hibernate.type.AssociationType; @@ -48,7 +45,7 @@ */ public class EntityJoinWalker extends AbstractEntityJoinWalker { - private final LockRequest lockRequest = new LockRequest(); + private final LockOptions lockOptions = new LockOptions(); public EntityJoinWalker( OuterJoinLoadable persister, @@ -59,33 +56,33 @@ LoadQueryInfluencers loadQueryInfluencers) throws MappingException { super( persister, factory, loadQueryInfluencers ); - this.lockRequest.setLockMode(lockMode); + this.lockOptions.setLockMode(lockMode); StringBuffer whereCondition = whereString( getAlias(), uniqueKey, batchSize ) //include the discriminator and class-level where, but not filters .append( persister.filterFragment( getAlias(), Collections.EMPTY_MAP ) ); - initAll( whereCondition.toString(), "", lockRequest ); + initAll( whereCondition.toString(), "", lockOptions); } public EntityJoinWalker( OuterJoinLoadable persister, String[] uniqueKey, int batchSize, - LockRequest lockRequest, + LockOptions lockOptions, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers) throws MappingException { super( persister, factory, loadQueryInfluencers ); - this.lockRequest.setLockMode(lockRequest.getLockMode()); - this.lockRequest.setTimeOut(lockRequest.getTimeOut()); - this.lockRequest.setScope(lockRequest.getScope()); + this.lockOptions.setLockMode(lockOptions.getLockMode()); + this.lockOptions.setTimeOut(lockOptions.getTimeOut()); + this.lockOptions.setScope(lockOptions.getScope()); StringBuffer whereCondition = whereString( getAlias(), uniqueKey, batchSize ) //include the discriminator and class-level where, but not filters .append( persister.filterFragment( getAlias(), Collections.EMPTY_MAP ) ); - initAll( whereCondition.toString(), "", lockRequest); + initAll( whereCondition.toString(), "", lockOptions); } protected int getJoinType( @@ -102,7 +99,7 @@ // NOTE : we override this form here specifically to account for // fetch profiles. // TODO : how to best handle criteria queries? - if ( lockRequest.getLockMode().greaterThan( LockMode.READ ) ) { + if ( lockOptions.getLockMode().greaterThan( LockMode.READ ) ) { return -1; } if ( isTooDeep( currentDepth ) Modified: core/trunk/core/src/main/java/org/hibernate/loader/entity/EntityLoader.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/loader/entity/EntityLoader.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/loader/entity/EntityLoader.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -27,7 +27,7 @@ import org.hibernate.HibernateException; import org.hibernate.LockMode; import org.hibernate.MappingException; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; import org.hibernate.engine.SessionFactoryImplementor; import org.hibernate.engine.SessionImplementor; import org.hibernate.engine.LoadQueryInfluencers; @@ -57,10 +57,10 @@ public EntityLoader( OuterJoinLoadable persister, - LockRequest lockRequest, + LockOptions lockOptions, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers) throws MappingException { - this( persister, 1, lockRequest, factory, loadQueryInfluencers ); + this( persister, 1, lockOptions, factory, loadQueryInfluencers ); } public EntityLoader( @@ -83,7 +83,7 @@ public EntityLoader( OuterJoinLoadable persister, int batchSize, - LockRequest lockRequest, + LockOptions lockOptions, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers) throws MappingException { this( @@ -91,7 +91,7 @@ persister.getIdentifierColumnNames(), persister.getIdentifierType(), batchSize, - lockRequest, + lockOptions, factory, loadQueryInfluencers ); @@ -130,7 +130,7 @@ String[] uniqueKey, Type uniqueKeyType, int batchSize, - LockRequest lockRequest, + LockOptions lockOptions, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers) throws MappingException { super( persister, uniqueKeyType, factory, loadQueryInfluencers ); @@ -139,7 +139,7 @@ persister, uniqueKey, batchSize, - lockRequest, + lockOptions, factory, loadQueryInfluencers ); 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-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -46,7 +46,7 @@ import org.hibernate.QueryException; import org.hibernate.StaleObjectStateException; import org.hibernate.StaleStateException; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; import org.hibernate.cache.CacheKey; import org.hibernate.cache.access.EntityRegionAccessStrategy; import org.hibernate.cache.entry.CacheEntry; @@ -1413,16 +1413,16 @@ Object object, LockMode lockMode, SessionImplementor session) throws HibernateException { - getLocker( lockMode ).lock( id, version, object, LockRequest.WAIT_FOREVER, session ); + getLocker( lockMode ).lock( id, version, object, LockOptions.WAIT_FOREVER, session ); } public void lock( Serializable id, Object version, Object object, - LockRequest lockRequest, + LockOptions lockOptions, SessionImplementor session) throws HibernateException { - getLocker( lockRequest.getLockMode() ).lock( id, version, object, lockRequest.getTimeOut(), session ); + getLocker( lockOptions.getLockMode() ).lock( id, version, object, lockOptions.getTimeOut(), session ); } public String getRootTableName() { @@ -1882,13 +1882,13 @@ } protected UniqueEntityLoader createEntityLoader( - LockRequest lockRequest, + LockOptions lockOptions, LoadQueryInfluencers loadQueryInfluencers) throws MappingException { //TODO: disable batch loading if lockMode > READ? return BatchingEntityLoader.createBatchingEntityLoader( this, batchSize, - lockRequest, + lockOptions, getFactory(), loadQueryInfluencers ); @@ -3208,7 +3208,7 @@ ); } - final UniqueEntityLoader loader = getAppropriateLoader( new LockRequest().setLockMode(lockMode), session ); + final UniqueEntityLoader loader = getAppropriateLoader( new LockOptions().setLockMode(lockMode), session ); return loader.load( id, optionalObject, session ); } @@ -3216,7 +3216,7 @@ * Load an instance using either the <tt>forUpdateLoader</tt> or the outer joining <tt>loader</tt>, * depending upon the value of the <tt>lock</tt> parameter */ - public Object load(Serializable id, Object optionalObject, LockRequest lockRequest, SessionImplementor session) + public Object load(Serializable id, Object optionalObject, LockOptions lockOptions, SessionImplementor session) throws HibernateException { if ( log.isTraceEnabled() ) { @@ -3226,7 +3226,7 @@ ); } - final UniqueEntityLoader loader = getAppropriateLoader( lockRequest, session ); + final UniqueEntityLoader loader = getAppropriateLoader(lockOptions, session ); return loader.load( id, optionalObject, session ); } @@ -3249,7 +3249,7 @@ && filterHelper.isAffectedBy( session.getLoadQueryInfluencers().getEnabledFilters() ); } - private UniqueEntityLoader getAppropriateLoader(LockRequest lockRequest, SessionImplementor session) { + private UniqueEntityLoader getAppropriateLoader(LockOptions lockOptions, SessionImplementor session) { if ( queryLoader != null ) { // if the user specified a custom query loader we need to that // regardless of any other consideration @@ -3258,9 +3258,9 @@ else if ( isAffectedByEnabledFilters( session ) ) { // because filters affect the rows returned (because they add // restirctions) these need to be next in precendence - return createEntityLoader( lockRequest, session.getLoadQueryInfluencers() ); + return createEntityLoader(lockOptions, session.getLoadQueryInfluencers() ); } - else if ( session.getLoadQueryInfluencers().getInternalFetchProfile() != null && LockMode.UPGRADE.greaterThan( lockRequest.getLockMode() ) ) { + else if ( session.getLoadQueryInfluencers().getInternalFetchProfile() != null && LockMode.UPGRADE.greaterThan( lockOptions.getLockMode() ) ) { // Next, we consider whether an 'internal' fetch profile has been set. // This indicates a special fetch profile Hibernate needs applied // (for its merge loading process e.g.). @@ -3269,10 +3269,10 @@ else if ( isAffectedByEnabledFetchProfiles( session ) ) { // If the session has associated influencers we need to adjust the // SQL query used for loading based on those influencers - return createEntityLoader( lockRequest, session.getLoadQueryInfluencers() ); + return createEntityLoader(lockOptions, session.getLoadQueryInfluencers() ); } else { - return ( UniqueEntityLoader ) loaders.get( lockRequest.getLockMode() ); + return ( UniqueEntityLoader ) loaders.get( lockOptions.getLockMode() ); } } Modified: core/trunk/core/src/main/java/org/hibernate/persister/entity/EntityPersister.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/persister/entity/EntityPersister.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/persister/entity/EntityPersister.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -31,7 +31,7 @@ import org.hibernate.LockMode; import org.hibernate.MappingException; import org.hibernate.EntityMode; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; import org.hibernate.tuple.entity.EntityMetamodel; import org.hibernate.cache.OptimisticCacheSource; import org.hibernate.cache.access.EntityRegionAccessStrategy; @@ -330,7 +330,7 @@ /** * Load an instance of the persistent class. */ - public Object load(Serializable id, Object optionalObject, LockRequest lockRequest, SessionImplementor session) + public Object load(Serializable id, Object optionalObject, LockOptions lockOptions, SessionImplementor session) throws HibernateException; /** @@ -342,7 +342,7 @@ /** * Do a version check (optional operation) */ - public void lock(Serializable id, Object version, Object object, LockRequest lockRequest, SessionImplementor session) + public void lock(Serializable id, Object version, Object object, LockOptions lockOptions, SessionImplementor session) throws HibernateException; /** Modified: core/trunk/core/src/main/java/org/hibernate/util/ArrayHelper.java =================================================================== --- core/trunk/core/src/main/java/org/hibernate/util/ArrayHelper.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/core/src/main/java/org/hibernate/util/ArrayHelper.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -32,7 +32,7 @@ import java.util.List; import org.hibernate.LockMode; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; import org.hibernate.type.Type; public final class ArrayHelper { @@ -84,9 +84,9 @@ return array; } - public static LockMode[] fillArray(LockRequest lockRequest, int length) { + public static LockMode[] fillArray(LockOptions lockOptions, int length) { LockMode[] array = new LockMode[length]; - Arrays.fill(array, lockRequest); + Arrays.fill(array, lockOptions); return array; } Modified: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/AbstractEntityManagerImpl.java =================================================================== --- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/AbstractEntityManagerImpl.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/AbstractEntityManagerImpl.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -29,7 +29,6 @@ import java.io.Serializable; import java.util.Map; import java.util.Set; -import java.util.HashMap; import javax.persistence.EntityNotFoundException; import javax.persistence.EntityTransaction; import javax.persistence.FlushModeType; @@ -521,7 +520,7 @@ if ( !contains( entity ) ) { throw new IllegalArgumentException( "entity not in the persistence context" ); } - getSession().lock( entity, getLockRequest(lockModeType, properties) ); + getSession().buildLockRequest(getLockRequest(lockModeType, properties)).lock( entity ); } catch ( HibernateException he ) { throw convert( he ); @@ -529,31 +528,31 @@ } - private LockRequest getLockRequest(LockModeType lockModeType, Map<String, Object> properties) { - LockRequest lockRequest = new LockRequest(); - lockRequest.setLockMode(getLockMode(lockModeType)); + private LockOptions getLockRequest(LockModeType lockModeType, Map<String, Object> properties) { + LockOptions lockOptions = new LockOptions(); + lockOptions.setLockMode(getLockMode(lockModeType)); if ( properties != null ) { - // lockRequest scope will default to false (PessimisticLockScope.NORMAL) + // lockOptions scope will default to false (PessimisticLockScope.NORMAL) Object value = properties.get(PESSIMISTICLOCKSCOPE); if ( value instanceof String && PessimisticLockScope.valueOf((String) value) == PessimisticLockScope.EXTENDED) { - lockRequest.setScope(true); + lockOptions.setScope(true); } - // lockRequest timeout will default to LockRequest.FOREVER_WAIT + // lockOptions timeout will default to LockOptions.FOREVER_WAIT value = properties.get(PESSIMISTICLOCKTIMEOUT); if ( value instanceof String ) { int timeout = Integer.parseInt((String) value); if ( timeout < 0 ) { - lockRequest.setTimeOut(LockRequest.WAIT_FOREVER); + lockOptions.setTimeOut(LockOptions.WAIT_FOREVER); } else if( timeout == 0 ) { - lockRequest.setTimeOut(LockRequest.NO_WAIT); + lockOptions.setTimeOut(LockOptions.NO_WAIT); } else { - lockRequest.setTimeOut(timeout); + lockOptions.setTimeOut(timeout); } } } - return lockRequest; + return lockOptions; } private LockModeType getLockModeType(LockMode lockMode) { Modified: core/trunk/testsuite/src/test/java/org/hibernate/test/legacy/CustomPersister.java =================================================================== --- core/trunk/testsuite/src/test/java/org/hibernate/test/legacy/CustomPersister.java 2009-11-24 22:28:05 UTC (rev 18052) +++ core/trunk/testsuite/src/test/java/org/hibernate/test/legacy/CustomPersister.java 2009-11-24 23:59:50 UTC (rev 18053) @@ -11,9 +11,8 @@ import org.hibernate.HibernateException; import org.hibernate.LockMode; import org.hibernate.MappingException; -import org.hibernate.LockRequest; +import org.hibernate.LockOptions; import org.hibernate.tuple.entity.EntityMetamodel; -import org.hibernate.cache.CacheConcurrencyStrategy; import org.hibernate.cache.access.EntityRegionAccessStrategy; import org.hibernate.cache.entry.CacheEntryStructure; import org.hibernate.cache.entry.UnstructuredCacheEntry; @@ -281,15 +280,15 @@ } /** - * @see EntityPersister#load(Serializable, Object, LockRequest, SessionImplementor) + * @see EntityPersister#load(Serializable, Object, org.hibernate.LockOptions , SessionImplementor) */ public Object load( Serializable id, Object optionalObject, - LockRequest lockRequest, + LockOptions lockOptions, SessionImplementor session ) throws HibernateException { - return load(id, optionalObject, lockRequest.getLockMode(), session); + return load(id, optionalObject, lockOptions.getLockMode(), session); } /** @@ -343,7 +342,7 @@ Serializable id, Object version, Object object, - LockRequest lockRequest, + LockOptions lockOptions, SessionImplementor session ) throws HibernateException {