[Hibernate-commits] Hibernate3/src/org/hibernate/persister/entity AbstractEntityPersister.java,1.30,1.31

[<ste...@us...>]

Update of /cvsroot/hibernate/Hibernate3/src/org/hibernate/persister/entity
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv25533/src/org/hibernate/persister/entity

Modified Files:
	AbstractEntityPersister.java 
Log Message:
HHH-1518 : locking strategies

Index: AbstractEntityPersister.java
===================================================================
RCS file: /cvsroot/hibernate/Hibernate3/src/org/hibernate/persister/entity/AbstractEntityPersister.java,v
retrieving revision 1.30
retrieving revision 1.31
diff -u -d -r1.30 -r1.31
--- AbstractEntityPersister.java	15 Feb 2006 22:28:15 -0000	1.30
+++ AbstractEntityPersister.java	23 Feb 2006 17:30:39 -0000	1.31
@@ -26,6 +26,8 @@
 import org.hibernate.MappingException;
 import org.hibernate.QueryException;
 import org.hibernate.StaleObjectStateException;
+import org.hibernate.dialect.lock.LockingStrategy;
+import org.hibernate.dialect.lock.SelectLockingStrategy;
 import org.hibernate.cache.CacheConcurrencyStrategy;
 import org.hibernate.cache.CacheKey;
 import org.hibernate.cache.entry.CacheEntry;
@@ -91,7 +93,7 @@
  */
 public abstract class AbstractEntityPersister
 		implements OuterJoinLoadable, Queryable, ClassMetadata, UniqueKeyLoadable,
-		SQLLoadable, LazyPropertyInitializer, PostInsertIdentityPersister {
+		SQLLoadable, LazyPropertyInitializer, PostInsertIdentityPersister, Lockable {
 
 	private static final Log log = LogFactory.getLog( AbstractEntityPersister.class );
 
@@ -858,10 +860,6 @@
 		return lazyProperties;
 	}
 
-	private String getLockString(LockMode lockMode) {
-		return ( String ) lockers.get( lockMode );
-	}
-
 	public boolean isBatchLoadable() {
 		return batchSize > 1;
 	}
@@ -1151,65 +1149,6 @@
 				.toStatementString();
 	}
 
-	/**
-	 * Do a version check
-	 */
-	public void lock(Serializable id, Object version, Object object, LockMode lockMode, SessionImplementor session)
-	throws HibernateException {
-
-		if ( lockMode != LockMode.NONE ) {
-
-			if ( log.isTraceEnabled() ) {
-				log.trace( "Locking entity: " + MessageHelper.infoString( this, id, getFactory() ) );
-				if ( isVersioned() ) {
-					log.trace( "Version: " + version );
-				}
-			}
-
-			final String sql = getLockString( lockMode );
-
-			try {
-
-				PreparedStatement st = session.getBatcher().prepareSelectStatement( sql );
-				try {
-					getIdentifierType().nullSafeSet( st, id, 1, session );
-					if ( isVersioned() ) {
-						getVersionType().nullSafeSet( st, version, getIdentifierColumnSpan() + 1, session );
-					}
-
-					ResultSet rs = st.executeQuery();
-					try {
-						if ( !rs.next() ) {
-							if ( getFactory().getStatistics().isStatisticsEnabled() ) {
-								getFactory().getStatisticsImplementor()
-										.optimisticFailure( getEntityName() );
-							}
-							throw new StaleObjectStateException( getEntityName(), id );
-						}
-					}
-					finally {
-						rs.close();
-					}
-				}
-				finally {
-					session.getBatcher().closeStatement( st );
-				}
-
-			}
-			catch ( SQLException sqle ) {
-				throw JDBCExceptionHelper.convert(
-						getFactory().getSQLExceptionConverter(),
-						sqle,
-						"could not lock: " +
-						MessageHelper.infoString( this, id, getFactory() ),
-						sql
-					);
-			}
-
-		}
-
-	}
-
 	public Object forceVersionIncrement(Serializable id, Object currentVersion, SessionImplementor session) {
 		if ( !isVersioned() ) {
 			throw new AssertionFailure( "cannot force version increment on non-versioned entity" );
@@ -1319,32 +1258,124 @@
 
 	}
 
-	/**
-	 * Generate the SQL that pessimistic locks a row by id (and version)
-	 */
-	protected String generateLockString(LockMode lockMode) {
+	protected void initLockers() {
+		lockers.put( LockMode.READ, generateLocker( LockMode.READ ) );
+		lockers.put( LockMode.UPGRADE, generateLocker( LockMode.UPGRADE ) );
+		lockers.put( LockMode.UPGRADE_NOWAIT, generateLocker( LockMode.UPGRADE_NOWAIT ) );
+	}
 
-		SimpleSelect select = new SimpleSelect( getFactory().getDialect() )
-				.setLockMode( lockMode )
-				.setTableName( getVersionedTableName() )
-				.addColumn( rootTableKeyColumnNames[0] )
-				.addCondition( rootTableKeyColumnNames, "=?" );
-		if ( isVersioned() ) {
-			select.addCondition( getVersionColumnName(), "=?" );
-		}
-		if ( getFactory().getSettings().isCommentsEnabled() ) {
-			select.setComment( "lock " + getEntityName() );
-		}
-		return select.toStatementString();
+	protected LockingStrategy generateLocker(LockMode lockMode) {
+		return factory.getDialect().getLockingStrategy( this, lockMode );
+	}
 
+	private LockingStrategy getLocker(LockMode lockMode) {
+		return ( LockingStrategy ) lockers.get( lockMode );
 	}
 
-	protected void initLockers() {
-		lockers.put( LockMode.READ, generateLockString( LockMode.READ ) );
-		lockers.put( LockMode.UPGRADE, generateLockString( LockMode.UPGRADE ) );
-		lockers.put( LockMode.UPGRADE_NOWAIT, generateLockString( LockMode.UPGRADE_NOWAIT ) );
+	public void lock(
+			Serializable id,
+	        Object version,
+	        Object object,
+	        LockMode lockMode,
+	        SessionImplementor session) throws HibernateException {
+		getLocker( lockMode ).lock( id, version, object, session );
 	}
 
+	public String getRootTableName() {
+		return getSubclassTableName( 0 );
+	}
+
+	public String[] getRootTableIdentifierColumnNames() {
+		return getRootTableKeyColumnNames();
+	}
+
+//	/**
+//	 * Generate the SQL that pessimistic locks a row by id (and version)
+//	 */
+//	protected String generateLockString(LockMode lockMode) {
+//		SimpleSelect select = new SimpleSelect( getFactory().getDialect() )
+//				.setLockMode( lockMode )
+//				.setTableName( getVersionedTableName() )
+//				.addColumn( rootTableKeyColumnNames[0] )
+//				.addCondition( rootTableKeyColumnNames, "=?" );
+//		if ( isVersioned() ) {
+//			select.addCondition( getVersionColumnName(), "=?" );
+//		}
+//		if ( getFactory().getSettings().isCommentsEnabled() ) {
+//			select.setComment( "lock " + getEntityName() );
+//		}
+//		return select.toStatementString();
+//	}
+//
+//	protected void initLockers() {
+//		lockers.put( LockMode.READ, generateLockString( LockMode.READ ) );
+//		lockers.put( LockMode.UPGRADE, generateLockString( LockMode.UPGRADE ) );
+//		lockers.put( LockMode.UPGRADE_NOWAIT, generateLockString( LockMode.UPGRADE_NOWAIT ) );
+//	}
+//
+//	private String getLockString(LockMode lockMode) {
+//		return ( String ) lockers.get( lockMode );
+//	}
+//
+//	/**
+//	 * Do a version check
+//	 */
+//	public void lock(Serializable id, Object version, Object object, LockMode lockMode, SessionImplementor session)
+//	throws HibernateException {
+//
+//		if ( lockMode != LockMode.NONE ) {
+//
+//			if ( log.isTraceEnabled() ) {
+//				log.trace( "Locking entity: " + MessageHelper.infoString( this, id, getFactory() ) );
+//				if ( isVersioned() ) {
+//					log.trace( "Version: " + version );
+//				}
+//			}
+//
+//			final String sql = getLockString( lockMode );
+//
+//			try {
+//
+//				PreparedStatement st = session.getBatcher().prepareSelectStatement( sql );
+//				try {
+//					getIdentifierType().nullSafeSet( st, id, 1, session );
+//					if ( isVersioned() ) {
+//						getVersionType().nullSafeSet( st, version, getIdentifierColumnSpan() + 1, session );
+//					}
+//
+//					ResultSet rs = st.executeQuery();
+//					try {
+//						if ( !rs.next() ) {
+//							if ( getFactory().getStatistics().isStatisticsEnabled() ) {
+//								getFactory().getStatisticsImplementor()
+//										.optimisticFailure( getEntityName() );
+//							}
+//							throw new StaleObjectStateException( getEntityName(), id );
+//						}
+//					}
+//					finally {
+//						rs.close();
+//					}
+//				}
+//				finally {
+//					session.getBatcher().closeStatement( st );
+//				}
+//
+//			}
+//			catch ( SQLException sqle ) {
+//				throw JDBCExceptionHelper.convert(
+//						getFactory().getSQLExceptionConverter(),
+//						sqle,
+//						"could not lock: " +
+//						MessageHelper.infoString( this, id, getFactory() ),
+//						sql
+//					);
+//			}
+//
+//		}
+//
+//	}
+
 	public String[] toColumns(String alias, String propertyName) throws QueryException {
 		return propertyMapping.toColumns( alias, propertyName );
 	}