[hibernate-commits] Hibernate SVN: r15145 - core/trunk/core/src/main/java/org/hibernate/id/enhanced.

Friday, 29 August 2008

Author: steve.ebersole(a)jboss.com
Date: 2008-08-29 02:22:52 -0400 (Fri, 29 Aug 2008)
New Revision: 15145

Modified:
   core/trunk/core/src/main/java/org/hibernate/id/enhanced/TableGenerator.java
Log:
HHH-2686 : enhanced.TableGenerator - generator table PK;
HHH-3231 : enhanced.TableGenerator - improper SELECT ... FOR UPDATE OF building;
HHH-3249 : enhanced.TableGenerator - extensibility;
HHH-3454 : enhanced.TableGenerator - allow segment value default to be the entity table
name

Modified: core/trunk/core/src/main/java/org/hibernate/id/enhanced/TableGenerator.java
===================================================================

--- core/trunk/core/src/main/java/org/hibernate/id/enhanced/TableGenerator.java	2008-08-29
06:22:14 UTC (rev 15144)
+++ core/trunk/core/src/main/java/org/hibernate/id/enhanced/TableGenerator.java	2008-08-29
06:22:52 UTC (rev 15145)
@@ -31,6 +31,8 @@
 import java.sql.ResultSet;
 import java.util.Properties;
 import java.util.HashMap;
+import java.util.Collections;
+import java.util.Map;
 import java.io.Serializable;
 
 import org.slf4j.Logger;
@@ -49,17 +51,29 @@
 import org.hibernate.mapping.Table;
 import org.hibernate.util.PropertiesHelper;
 import org.hibernate.util.StringHelper;
-import org.hibernate.util.CollectionHelper;
 
 /**
- * An enhanced version of explicit table-based generator.  The main basis
- * conceptualization is similiar to the legacy
+ * An enhanced version of table-based id generation.
+ * <p/>
+ * Unlike the simplistic legacy one (which, btw, was only ever intended for subclassing
+ * support) we "segment" the table into multiple values.  Thus a single table
can
+ * actually serve as the persistent storage for multiple independent generators.  One
+ * approach would be to segment the values by the name of the entity for which we are
+ * performing generation, which would mean that we would have a row in the generator
+ * table for each entity name.  Or any configuration really; the setup is very flexible.
+ * <p/>
+ * In this respect it is very simliar to the legacy
  * {@link org.hibernate.id.MultipleHiLoPerTableGenerator} in terms of the
  * underlying storage structure (namely a single table capable of holding
  * multiple generator values).  The differentiator is, as with
- * {@link SequenceStyleGenerator} as well, the externalization of the notion
+ * {@link SequenceStyleGenerator} as well, the externalized notion
  * of an optimizer.
  * <p/>
+ * <b>NOTE</b> that by default we use a single row for all genertators
(based
+ * on {@link #DEF_SEGMENT_VALUE}).  The configuration parameter
+ * {@link #CONFIG_PREFER_SEGMENT_PER_ENTITY} can be used to change that to
+ * instead default to using a row for each entity name.
+ * <p/>
  * Configuration parameters:
  * <table>
  * 	 <tr>
@@ -114,6 +128,8 @@
 public class TableGenerator extends TransactionHelper implements
PersistentIdentifierGenerator, Configurable {
 	private static final Logger log = LoggerFactory.getLogger( TableGenerator.class );
 
+	public static final String CONFIG_PREFER_SEGMENT_PER_ENTITY =
"hibernate.id.enhanced.table.prefer_segment_per_entity";
+
 	public static final String TABLE_PARAM = "table_name";
 	public static final String DEF_TABLE = "hibernate_sequences";
 
@@ -138,101 +154,281 @@
 	public static final String OPT_PARAM = "optimizer";
 
 
+	private Type identifierType;
+
 	private String tableName;
-	private String valueColumnName;
+
 	private String segmentColumnName;
 	private String segmentValue;
 	private int segmentValueLength;
+
+	private String valueColumnName;
 	private int initialValue;
 	private int incrementSize;
 
-	private Type identifierType;
+	private String selectQuery;
+	private String insertQuery;
+	private String updateQuery;
 
-	private String query;
-	private String insert;
-	private String update;
-
 	private Optimizer optimizer;
 	private long accessCount = 0;
 
-	public String getTableName() {
+	/**
+	 * {@inheritDoc}
+	 */
+	public Object generatorKey() {
 		return tableName;
 	}
 
-	public String getSegmentColumnName() {
+	/**
+	 * Type mapping for the identifier.
+	 *
+	 * @return The identifier type mapping.
+	 */
+	public final Type getIdentifierType() {
+		return identifierType;
+	}
+
+	/**
+	 * The name of the table in which we store this generator's persistent state.
+	 *
+	 * @return The table name.
+	 */
+	public final String getTableName() {
+		return tableName;
+	}
+
+	/**
+	 * The name of the column in which we store the segment to which each row
+	 * belongs.  The value here acts as PK.
+	 *
+	 * @return The segment column name
+	 */
+	public final String getSegmentColumnName() {
 		return segmentColumnName;
 	}
 
-	public String getSegmentValue() {
+	/**
+	 * The value in {@link #getSegmentColumnName segment column} which
+	 * corresponding to this generator instance.  In other words this value
+	 * indicates the row in which this generator instance will store values.
+	 *
+	 * @return The segment value for this generator instance.
+	 */
+	public final String getSegmentValue() {
 		return segmentValue;
 	}
 
-	public int getSegmentValueLength() {
+	/**
+	 * The size of the {@link #getSegmentColumnName segment column} in the
+	 * underlying table.
+	 * <p/>
+	 * <b>NOTE</b> : should really have been called
'segmentColumnLength' or
+	 * even better 'segmentColumnSize'
+	 *
+	 * @return the column size.
+	 */
+	public final int getSegmentValueLength() {
 		return segmentValueLength;
 	}
 
-	public String getValueColumnName() {
+	/**
+	 * The name of the column in which we store our persistent generator value.
+	 *
+	 * @return The name of the value column.
+	 */
+	public final String getValueColumnName() {
 		return valueColumnName;
 	}
 
-	public Type getIdentifierType() {
-		return identifierType;
-	}
-
-	public int getInitialValue() {
+	/**
+	 * The initial value to use when we find no previous state in the
+	 * generator table corresponding to our sequence.
+	 *
+	 * @return The initial value to use.
+	 */
+	public final int getInitialValue() {
 		return initialValue;
 	}
 
-	public int getIncrementSize() {
+	/**
+	 * The amount of increment to use.  The exact implications of this
+	 * depends on the {@link #getOptimizer() optimizer} being used.
+	 *
+	 * @return The increment amount.
+	 */
+	public final int getIncrementSize() {
 		return incrementSize;
 	}
 
-	public Optimizer getOptimizer() {
+	/**
+	 * The optimizer being used by this generator.
+	 *
+	 * @return Out optimizer.
+	 */
+	public final Optimizer getOptimizer() {
 		return optimizer;
 	}
 
-	public long getTableAccessCount() {
+	/**
+	 * Getter for property 'tableAccessCount'.  Only really useful for unit test
+	 * assertions.
+	 *
+	 * @return Value for property 'tableAccessCount'.
+	 */
+	public final long getTableAccessCount() {
 		return accessCount;
 	}
 
+	/**
+	 * {@inheritDoc}
+	 */
 	public void configure(Type type, Properties params, Dialect dialect) throws
MappingException {
-		tableName = PropertiesHelper.getString( TABLE_PARAM, params, DEF_TABLE );
-		if ( tableName.indexOf( '.' ) < 0 ) {
+		identifierType = type;
+
+		tableName = determneGeneratorTableName( params );
+		segmentColumnName = determineSegmentColumnName( params );
+		valueColumnName = determineValueColumnName( params );
+
+		segmentValue = determineSegmentValue( params );
+
+		segmentValueLength = determineSegmentColumnSize( params );
+		initialValue = determineInitialValue( params );
+		incrementSize = determineIncrementSize( params );
+
+		this.selectQuery = buildSelectQuery( dialect );
+		this.updateQuery = buildUpdateQuery();
+		this.insertQuery = buildInsertQuery();
+
+		String defOptStrategy = incrementSize <= 1 ? OptimizerFactory.NONE :
OptimizerFactory.POOL;
+		String optimizationStrategy = PropertiesHelper.getString( OPT_PARAM, params,
defOptStrategy );
+		optimizer = OptimizerFactory.buildOptimizer( optimizationStrategy,
identifierType.getReturnedClass(), incrementSize );
+	}
+
+	/**
+	 * Determine the table name to use for the generator values.
+	 * <p/>
+	 * Called during {@link #configure configuration}.
+	 *
+	 * @see #getTableName()
+	 * @param params The params supplied in the generator config (plus some standard useful
extras).
+	 * @return The table name to use.
+	 */
+	protected String determneGeneratorTableName(Properties params) {
+		String name = PropertiesHelper.getString( TABLE_PARAM, params, DEF_TABLE );
+		boolean isGivenNameUnqualified = name.indexOf( '.' ) < 0;
+		if ( isGivenNameUnqualified ) {
+			// if the given name is un-qualified we may neen to qualify it
 			String schemaName = params.getProperty( SCHEMA );
 			String catalogName = params.getProperty( CATALOG );
-			tableName = Table.qualify( catalogName, schemaName, tableName );
+			name = Table.qualify( catalogName, schemaName, name );
 		}
+		return name;
+	}
 
-		segmentColumnName = PropertiesHelper.getString( SEGMENT_COLUMN_PARAM, params,
DEF_SEGMENT_COLUMN );
-		segmentValue = params.getProperty( SEGMENT_VALUE_PARAM );
+	/**
+	 * Determine the name of the column used to indicate the segment for each
+	 * row.  This column acts as the primary key.
+	 * <p/>
+	 * Called during {@link #configure configuration}.
+	 *
+	 * @see #getSegmentColumnName()
+	 * @param params The params supplied in the generator config (plus some standard useful
extras).
+	 * @return The name of the segment column
+	 */
+	protected String determineSegmentColumnName(Properties params) {
+		return PropertiesHelper.getString( SEGMENT_COLUMN_PARAM, params, DEF_SEGMENT_COLUMN );
+	}
+
+	/**
+	 * Determine the name of the column in which we will store the generator persistent
value.
+	 * <p/>
+	 * Called during {@link #configure configuration}.
+	 *
+	 * @see #getValueColumnName()
+	 * @param params The params supplied in the generator config (plus some standard useful
extras).
+	 * @return The name of the value column
+	 */
+	protected String determineValueColumnName(Properties params) {
+		return PropertiesHelper.getString( VALUE_COLUMN_PARAM, params, DEF_VALUE_COLUMN );
+	}
+
+	/**
+	 * Determine the segment value corresponding to this generator instance.
+	 * <p/>
+	 * Called during {@link #configure configuration}.
+	 *
+	 * @see #getSegmentValue()
+	 * @param params The params supplied in the generator config (plus some standard useful
extras).
+	 * @return The name of the value column
+	 */
+	protected String determineSegmentValue(Properties params) {
+		String segmentValue = params.getProperty( SEGMENT_VALUE_PARAM );
 		if ( StringHelper.isEmpty( segmentValue ) ) {
-			log.debug( "explicit segment value for id generator [" + tableName +
'.' + segmentColumnName + "] suggested; using default [" +
DEF_SEGMENT_VALUE + "]" );
-			segmentValue = DEF_SEGMENT_VALUE;
+			segmentValue = determineDefaultSegmentValue( params );
 		}
-		segmentValueLength = PropertiesHelper.getInt( SEGMENT_LENGTH_PARAM, params,
DEF_SEGMENT_LENGTH );
-		valueColumnName = PropertiesHelper.getString( VALUE_COLUMN_PARAM, params,
DEF_VALUE_COLUMN );
-		initialValue = PropertiesHelper.getInt( INITIAL_PARAM, params, DEFAULT_INITIAL_VALUE
);
-		incrementSize = PropertiesHelper.getInt( INCREMENT_PARAM, params,
DEFAULT_INCREMENT_SIZE );
-		identifierType = type;
+		return segmentValue;
+	}
 
-		String query = "select " + valueColumnName +
-				" from " + tableName + " tbl" +
-				" where tbl." + segmentColumnName + "=?";
+	/**
+	 * Used in the cases where {@link #determineSegmentValue} is unable to
+	 * determine the value to use.
+	 *
+	 * @param params The params supplied in the generator config (plus some standard useful
extras).
+	 * @return The default segment value to use.
+	 */
+	protected String determineDefaultSegmentValue(Properties params) {
+		boolean preferSegmentPerEntity = PropertiesHelper.getBoolean(
CONFIG_PREFER_SEGMENT_PER_ENTITY, params, false );
+		String defaultToUse = preferSegmentPerEntity ? params.getProperty( TABLE ) :
DEF_SEGMENT_VALUE;
+		log.info( "explicit segment value for id generator [" + tableName +
'.' + segmentColumnName + "] suggested; using default [" + defaultToUse
+ "]" );
+		return defaultToUse;
+	}
+
+	/**
+	 * Determine the size of the {@link #getSegmentColumnName segment column}
+	 * <p/>
+	 * Called during {@link #configure configuration}.
+	 *
+	 * @see #getSegmentValueLength()
+	 * @param params The params supplied in the generator config (plus some standard useful
extras).
+	 * @return The size of the segment column
+	 */
+	protected int determineSegmentColumnSize(Properties params) {
+		return PropertiesHelper.getInt( SEGMENT_LENGTH_PARAM, params, DEF_SEGMENT_LENGTH );
+	}
+
+	protected int determineInitialValue(Properties params) {
+		return PropertiesHelper.getInt( INITIAL_PARAM, params, DEFAULT_INITIAL_VALUE );
+	}
+
+	protected int determineIncrementSize(Properties params) {
+		return PropertiesHelper.getInt( INCREMENT_PARAM, params, DEFAULT_INCREMENT_SIZE );
+	}
+
+	protected String buildSelectQuery(Dialect dialect) {
+		final String alias = "tbl";
+		String query = "select " + StringHelper.qualify( alias, valueColumnName ) +
+				" from " + tableName + ' ' + alias +
+				" where " + StringHelper.qualify( alias, segmentColumnName ) +
"=?";
 		HashMap lockMap = new HashMap();
-		lockMap.put( "tbl", LockMode.UPGRADE );
-		this.query = dialect.applyLocksToSql( query, lockMap, CollectionHelper.EMPTY_MAP );
+		lockMap.put( alias, LockMode.UPGRADE );
+		Map updateTargetColumnsMap = Collections.singletonMap( alias, new String[] {
valueColumnName } );
+		return dialect.applyLocksToSql( query, lockMap, updateTargetColumnsMap );
+	}
 
-		update = "update " + tableName +
+	protected String buildUpdateQuery() {
+		return "update " + tableName +
 				" set " + valueColumnName + "=? " +
 				" where " + valueColumnName + "=? and " + segmentColumnName +
"=?";
+	}
 
-		insert = "insert into " + tableName + " (" + segmentColumnName +
", " + valueColumnName + ") " + " values (?,?)";
-
-		String defOptStrategy = incrementSize <= 1 ? OptimizerFactory.NONE :
OptimizerFactory.POOL;
-		String optimizationStrategy = PropertiesHelper.getString( OPT_PARAM, params,
defOptStrategy );
-		optimizer = OptimizerFactory.buildOptimizer( optimizationStrategy,
identifierType.getReturnedClass(), incrementSize );
+	protected String buildInsertQuery() {
+		return "insert into " + tableName + " (" + segmentColumnName +
", " + valueColumnName + ") " + " values (?,?)";
 	}
 
+	/**
+	 * {@inheritDoc}
+	 */
 	public synchronized Serializable generate(final SessionImplementor session, Object obj)
{
 		return optimizer.generate(
 				new AccessCallback() {
@@ -243,23 +439,24 @@
 		);
 	}
 
+	/**
+	 * {@inheritDoc}
+	 */
 	public Serializable doWorkInCurrentTransaction(Connection conn, String sql) throws
SQLException {
 		int result;
 		int rows;
 		do {
-			sql = query;
-			SQL_STATEMENT_LOGGER.logStatement( sql, FormatStyle.BASIC );
-			PreparedStatement queryPS = conn.prepareStatement( query );
+			SQL_STATEMENT_LOGGER.logStatement( selectQuery, FormatStyle.BASIC );
+			PreparedStatement selectPS = conn.prepareStatement( selectQuery );
 			try {
-				queryPS.setString( 1, segmentValue );
-				ResultSet queryRS = queryPS.executeQuery();
-				if ( !queryRS.next() ) {
+				selectPS.setString( 1, segmentValue );
+				ResultSet selectRS = selectPS.executeQuery();
+				if ( !selectRS.next() ) {
 					PreparedStatement insertPS = null;
 					try {
 						result = initialValue;
-						sql = insert;
-						SQL_STATEMENT_LOGGER.logStatement( sql, FormatStyle.BASIC );
-						insertPS = conn.prepareStatement( insert );
+						SQL_STATEMENT_LOGGER.logStatement( insertQuery, FormatStyle.BASIC );
+						insertPS = conn.prepareStatement( insertQuery );
 						insertPS.setString( 1, segmentValue );
 						insertPS.setLong( 2, result );
 						insertPS.execute();
@@ -271,21 +468,20 @@
 					}
 				}
 				else {
-					result = queryRS.getInt( 1 );
+					result = selectRS.getInt( 1 );
 				}
-				queryRS.close();
+				selectRS.close();
 			}
 			catch ( SQLException sqle ) {
 				log.error( "could not read or init a hi value", sqle );
 				throw sqle;
 			}
 			finally {
-				queryPS.close();
+				selectPS.close();
 			}
 
-			sql = update;
-			SQL_STATEMENT_LOGGER.logStatement( sql, FormatStyle.BASIC );
-			PreparedStatement updatePS = conn.prepareStatement( update );
+			SQL_STATEMENT_LOGGER.logStatement( updateQuery, FormatStyle.BASIC );
+			PreparedStatement updatePS = conn.prepareStatement( updateQuery );
 			try {
 				long newValue = optimizer.applyIncrementSizeToSourceValues()
 						? result + incrementSize : result + 1;
@@ -295,7 +491,7 @@
 				rows = updatePS.executeUpdate();
 			}
 			catch ( SQLException sqle ) {
-				log.error( "could not update hi value in: " + tableName, sqle );
+				log.error( "could not updateQuery hi value in: " + tableName, sqle );
 				throw sqle;
 			}
 			finally {
@@ -309,6 +505,9 @@
 		return new Integer( result );
 	}
 
+	/**
+	 * {@inheritDoc}
+	 */
 	public String[] sqlCreateStrings(Dialect dialect) throws HibernateException {
 		return new String[] {
 				new StringBuffer()
@@ -323,11 +522,16 @@
 						.append( valueColumnName )
 						.append( ' ' )
 						.append( dialect.getTypeName( Types.BIGINT ) )
-						.append( " ) " )
+						.append( ", primary key ( " )
+						.append( segmentColumnName )
+						.append( " ) ) " )
 						.toString()
 		};
 	}
 
+	/**
+	 * {@inheritDoc}
+	 */
 	public String[] sqlDropStrings(Dialect dialect) throws HibernateException {
 		StringBuffer sqlDropString = new StringBuffer().append( "drop table " );
 		if ( dialect.supportsIfExistsBeforeTableName() ) {
@@ -339,8 +543,4 @@
 		}
 		return new String[] { sqlDropString.toString() };
 	}
-
-	public Object generatorKey() {
-		return tableName;
-	}
 }


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

[hibernate-commits] Hibernate SVN: r15145 - core/trunk/core/src/main/java/org/hibernate/id/enhanced.