Open Source Repository

Home /hibernate/hibernate-3.2.4.ga | Repository Home


org/hibernate/id/enhanced/TableGenerator.java
package org.hibernate.id.enhanced;

import java.sql.Types;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;
import java.util.HashMap;
import java.io.Serializable;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.hibernate.engine.TransactionHelper;
import org.hibernate.engine.SessionImplementor;
import org.hibernate.id.PersistentIdentifierGenerator;
import org.hibernate.id.Configurable;
import org.hibernate.type.Type;
import org.hibernate.dialect.Dialect;
import org.hibernate.HibernateException;
import org.hibernate.MappingException;
import org.hibernate.LockMode;
import org.hibernate.mapping.Table;
import org.hibernate.util.PropertiesHelper;
import org.hibernate.util.StringHelper;
import org.hibernate.util.CollectionHelper;

/**
 * A "segmented" version of the enhanced table generator.  The term "segmented"
 * refers to the fact that this table can hold multiple value generators,
 * segmented by a key.
 <p/>
 * Configuration parameters:
 <table>
 *    <tr>
 *     <td><b>NAME</b></td>
 *     <td><b>DEFAULT</b></td>
 *     <td><b>DESCRIPTION</b></td>
 *   </tr>
 *   <tr>
 *     <td>{@link #TABLE_PARAM}</td>
 *     <td>{@link #DEF_TABLE}</td>
 *     <td>The name of the table to use to store/retrieve values</td>
 *   </tr>
 *   <tr>
 *     <td>{@link #VALUE_COLUMN_PARAM}</td>
 *     <td>{@link #DEF_VALUE_COLUMN}</td>
 *     <td>The name of column which holds the sequence value for the given segment</td>
 *   </tr>
 *   <tr>
 *     <td>{@link #SEGMENT_COLUMN_PARAM}</td>
 *     <td>{@link #DEF_SEGMENT_COLUMN}</td>
 *     <td>The name of the column which holds the segment key</td>
 *   </tr>
 *   <tr>
 *     <td>{@link #SEGMENT_VALUE_PARAM}</td>
 *     <td>{@link #DEF_SEGMENT_VALUE}</td>
 *     <td>The value indicating which segment is used by this generator; refers to values in the {@link #SEGMENT_COLUMN_PARAM} column</td>
 *   </tr>
 *   <tr>
 *     <td>{@link #SEGMENT_LENGTH_PARAM}</td>
 *     <td>{@link #DEF_SEGMENT_LENGTH}</td>
 *     <td>The data length of the {@link #SEGMENT_COLUMN_PARAM} column; used for schema creation</td>
 *   </tr>
 *   <tr>
 *     <td>{@link #INITIAL_PARAM}</td>
 *     <td>{@link #DEFAULT_INITIAL_VALUE}</td>
 *     <td>The initial value to be stored for the given segment</td>
 *   </tr>
 *   <tr>
 *     <td>{@link #INCREMENT_PARAM}</td>
 *     <td>{@link #DEFAULT_INCREMENT_SIZE}</td>
 *     <td>The increment size for the underlying segment; see the discussion on {@link Optimizer} for more details.</td>
 *   </tr>
 *   <tr>
 *     <td>{@link #OPT_PARAM}</td>
 *     <td><i>depends on defined increment size</i></td>
 *     <td>Allows explicit definition of which optimization strategy to use</td>
 *   </tr>
 </table>
 *
 @author Steve Ebersole
 */
public class TableGenerator extends TransactionHelper implements PersistentIdentifierGenerator, Configurable {
  private static final Log log = LogFactory.getLogTableGenerator.class );

  public static final String TABLE_PARAM = "table_name";
  public static final String DEF_TABLE = "hibernate_sequences";

  public static final String VALUE_COLUMN_PARAM = "value_column_name";
  public static final String DEF_VALUE_COLUMN = "next_val";

  public static final String SEGMENT_COLUMN_PARAM = "segment_column_name";
  public static final String DEF_SEGMENT_COLUMN = "sequence_name";

  public static final String SEGMENT_VALUE_PARAM = "segment_value";
  public static final String DEF_SEGMENT_VALUE = "default";

  public static final String SEGMENT_LENGTH_PARAM = "segment_value_length";
  public static final int DEF_SEGMENT_LENGTH = 255;

  public static final String INITIAL_PARAM = "initial_value";
  public static final int DEFAULT_INITIAL_VALUE = 1;

  public static final String INCREMENT_PARAM = "increment_size";
  public static final int DEFAULT_INCREMENT_SIZE = 1;

  public static final String OPT_PARAM = "optimizer";


  private String tableName;
  private String valueColumnName;
  private String segmentColumnName;
  private String segmentValue;
  private int segmentValueLength;
  private int initialValue;
  private int incrementSize;

  private Type identifierType;

  private String query;
  private String insert;
  private String update;

  private Optimizer optimizer;
  private long accessCount = 0;

  public String getTableName() {
    return tableName;
  }

  public String getSegmentColumnName() {
    return segmentColumnName;
  }

  public String getSegmentValue() {
    return segmentValue;
  }

  public int getSegmentValueLength() {
    return segmentValueLength;
  }

  public String getValueColumnName() {
    return valueColumnName;
  }

  public Type getIdentifierType() {
    return identifierType;
  }

  public int getInitialValue() {
    return initialValue;
  }

  public int getIncrementSize() {
    return incrementSize;
  }

  public Optimizer getOptimizer() {
    return optimizer;
  }

  public long getTableAccessCount() {
    return accessCount;
  }

  public void configure(Type type, Properties params, Dialect dialectthrows MappingException {
    tableName = PropertiesHelper.getStringTABLE_PARAM, params, DEF_TABLE );
    if tableName.indexOf'.' ) {
      String schemaName = params.getPropertySCHEMA );
      String catalogName = params.getPropertyCATALOG );
      tableName = Table.qualifycatalogName, schemaName, tableName );
    }

    segmentColumnName = PropertiesHelper.getStringSEGMENT_COLUMN_PARAM, params, DEF_SEGMENT_COLUMN );
    segmentValue = params.getPropertySEGMENT_VALUE_PARAM );
    if StringHelper.isEmptysegmentValue ) ) {
      log.debug"explicit segment value for id generator [" + tableName + '.' + segmentColumnName + "] suggested; using default [" + DEF_SEGMENT_VALUE + "]" );
      segmentValue = DEF_SEGMENT_VALUE;
    }
    segmentValueLength = PropertiesHelper.getIntSEGMENT_LENGTH_PARAM, params, DEF_SEGMENT_LENGTH );
    valueColumnName = PropertiesHelper.getStringVALUE_COLUMN_PARAM, params, DEF_VALUE_COLUMN );
    initialValue = PropertiesHelper.getIntINITIAL_PARAM, params, DEFAULT_INITIAL_VALUE );
    incrementSize = PropertiesHelper.getIntINCREMENT_PARAM, params, DEFAULT_INCREMENT_SIZE );
    identifierType = type;

    String query = "select " + valueColumnName +
        " from " + tableName + " tbl" +
        " where tbl." + segmentColumnName + "=?";
    HashMap lockMap = new HashMap();
    lockMap.put"tbl", LockMode.UPGRADE );
    this.query = dialect.applyLocksToSqlquery, lockMap, CollectionHelper.EMPTY_MAP );

    update = "update " + tableName +
        " set " + valueColumnName + "=? " +
        " where " + valueColumnName + "=? and " + segmentColumnName + "=?";

    insert = "insert into " + tableName + " (" + segmentColumnName + ", " + valueColumnName + ") " " values (?,?)";

    String defOptStrategy = incrementSize <= ? OptimizerFactory.NONE : OptimizerFactory.POOL;
    String optimizationStrategy = PropertiesHelper.getStringOPT_PARAM, params, defOptStrategy );
    optimizer = OptimizerFactory.buildOptimizeroptimizationStrategy, identifierType.getReturnedClass(), incrementSize );
  }

  public synchronized Serializable generate(final SessionImplementor session, Object obj) {
    return optimizer.generate(
        new AccessCallback() {
          public long getNextValue() {
            return ( ( Number doWorkInNewTransactionsession ) ).longValue();
          }
        }
    );
  }

  public Serializable doWorkInCurrentTransaction(Connection conn, String sqlthrows SQLException {
    int result;
    int rows;
    do {
      sql = query;
      SQL.debugsql );
      PreparedStatement queryPS = conn.prepareStatementquery );
      try {
        queryPS.setString1, segmentValue );
        ResultSet queryRS = queryPS.executeQuery();
        if !queryRS.next() ) {
          PreparedStatement insertPS = null;
          try {
            result = initialValue;
            sql = insert;
            SQL.debugsql );
            insertPS = conn.prepareStatementinsert );
            insertPS.setString1, segmentValue );
            insertPS.setLong2, result );
            insertPS.execute();
          }
          finally {
            if insertPS != null ) {
              insertPS.close();
            }
          }
        }
        else {
          result = queryRS.getInt);
        }
        queryRS.close();
      }
      catch SQLException sqle ) {
        log.error"could not read or init a hi value", sqle );
        throw sqle;
      }
      finally {
        queryPS.close();
      }

      sql = update;
      SQL.debugsql );
      PreparedStatement updatePS = conn.prepareStatementupdate );
      try {
        long newValue = optimizer.applyIncrementSizeToSourceValues()
            ? result + incrementSize : result + 1;
        updatePS.setLong1, newValue );
        updatePS.setLong2, result );
        updatePS.setString3, segmentValue );
        rows = updatePS.executeUpdate();
      }
      catch SQLException sqle ) {
        log.error"could not update hi value in: " + tableName, sqle );
        throw sqle;
      }
      finally {
        updatePS.close();
      }
    }
    while rows == );

    accessCount++;

    return new Integerresult );
  }

  public String[] sqlCreateStrings(Dialect dialectthrows HibernateException {
    return new String[] {
        new StringBuffer()
            .appenddialect.getCreateTableString() )
            .append' ' )
            .appendtableName )
            .append" ( " )
            .appendsegmentColumnName )
            .append' ' )
            .appenddialect.getTypeNameTypes.VARCHAR, segmentValueLength, 0) )
            .append",  " )
            .appendvalueColumnName )
            .append' ' )
            .appenddialect.getTypeNameTypes.BIGINT ) )
            .append" ) " )
            .toString()
    };
  }

  public String[] sqlDropStrings(Dialect dialectthrows HibernateException {
    StringBuffer sqlDropString = new StringBuffer().append"drop table " );
    if dialect.supportsIfExistsBeforeTableName() ) {
      sqlDropString.append"if exists " );
    }
    sqlDropString.appendtableName ).appenddialect.getCascadeConstraintsString() );
    if dialect.supportsIfExistsAfterTableName() ) {
      sqlDropString.append" if exists" );
    }
    return new String[] { sqlDropString.toString() };
  }

  public Object generatorKey() {
    return tableName;
  }
}