How to use

Versioning

in

org.hibernate.engine.internal

/**
 * Perform an SQL INSERT, and then retrieve a generated identifier.
 * <p/>
 * This form is used for PostInsertIdentifierGenerator-style ids (IDENTITY,
 * select, etc).
 */
protected Serializable insert(
    final Object[] fields,
    final boolean[] notNull,
    String sql,
    final Object object,
    final SharedSessionContractImplementor session) throws HibernateException {
  if ( LOG.isTraceEnabled() ) {
    LOG.tracev( "Inserting entity: {0} (native id)", getEntityName() );
    if ( isVersioned() ) {
      LOG.tracev( "Version: {0}", Versioning.getVersion( fields, this ) );
    }
  }
  Binder binder = new Binder() {
    public void bindValues(PreparedStatement ps) throws SQLException {
      dehydrate( null, fields, notNull, propertyColumnInsertable, 0, ps, session, false );
    }
    public Object getEntity() {
      return object;
    }
  };
  return identityDelegate.performInsert( sql, session, binder );
}

/**
 * Convenience method to retrieve an entities next version value
 */
private Object getNextVersion(FlushEntityEvent event) throws HibernateException {
  EntityEntry entry = event.getEntityEntry();
  EntityPersister persister = entry.getPersister();
  if ( persister.isVersioned() ) {
    Object[] values = event.getPropertyValues();
    if ( entry.isBeingReplicated() ) {
      return Versioning.getVersion( values, persister );
    }
    else {
      int[] dirtyProperties = event.getDirtyProperties();
      final boolean isVersionIncrementRequired = isVersionIncrementRequired(
          event,
          entry,
          persister,
          dirtyProperties
      );
      final Object nextVersion = isVersionIncrementRequired ?
          Versioning.increment( entry.getVersion(), persister.getVersionType(), event.getSession() ) :
          entry.getVersion(); //use the current version
      Versioning.setVersion( values, nextVersion, persister );
      return nextVersion;
    }
  }
  else {
    return null;
  }
}

private boolean isVersionIncrementRequired(
    FlushEntityEvent event,
    EntityEntry entry,
    EntityPersister persister,
    int[] dirtyProperties
) {
  final boolean isVersionIncrementRequired = entry.getStatus() != Status.DELETED && (
      dirtyProperties == null ||
          Versioning.isVersionIncrementRequired(
              dirtyProperties,
              event.hasDirtyCollection(),
              persister.getPropertyVersionability()
          )
  );
  return isVersionIncrementRequired;
}

@Override
public void update(String entityName, Object entity) {
  checkOpen();
  EntityPersister persister = getEntityPersister( entityName, entity );
  Serializable id = persister.getIdentifier( entity, this );
  Object[] state = persister.getPropertyValues( entity );
  Object oldVersion;
  if ( persister.isVersioned() ) {
    oldVersion = persister.getVersion( entity );
    Object newVersion = Versioning.increment( oldVersion, persister.getVersionType(), this );
    Versioning.setVersion( state, newVersion, persister );
    persister.setPropertyValues( entity, state );
  }
  else {
    oldVersion = null;
  }
  persister.update( id, state, null, false, null, oldVersion, entity, null, this );
}

substitute = Versioning.seedVersion(
    values,
    persister.getVersionProperty(),

fields[versionProperty] = seed( versionType, session );
return true;

@Override
public void update(String entityName, Object entity) {
  errorIfClosed();
  EntityPersister persister = getEntityPersister(entityName, entity);
  Serializable id = persister.getIdentifier( entity, this );
  Object[] state = persister.getPropertyValues( entity );
  Object oldVersion;
  if ( persister.isVersioned() ) {
    oldVersion = persister.getVersion( entity );
    Object newVersion = Versioning.increment( oldVersion, persister.getVersionType(), this );
    Versioning.setVersion(state, newVersion, persister);
    persister.setPropertyValues( entity, state );
  }
  else {
    oldVersion = null;
  }
  persister.update(id, state, null, false, null, oldVersion, entity, null, this);
}

@Override
public Serializable insert(String entityName, Object entity) {
  checkOpen();
  EntityPersister persister = getEntityPersister( entityName, entity );
  Serializable id = persister.getIdentifierGenerator().generate( this, entity );
  Object[] state = persister.getPropertyValues( entity );
  if ( persister.isVersioned() ) {
    boolean substitute = Versioning.seedVersion(
        state,
        persister.getVersionProperty(),
        persister.getVersionType(),
        this
    );
    if ( substitute ) {
      persister.setPropertyValues( entity, state );
    }
  }
  if ( id == IdentifierGeneratorHelper.POST_INSERT_INDICATOR ) {
    id = persister.insert( state, entity, this );
  }
  else {
    persister.insert( id, state, entity, this );
  }
  persister.setIdentifier( entity, id, this );
  return id;
}

fields[versionProperty] = seed( versionType, session );
return true;

private AbstractEntityInsertAction addInsertAction(
    Object[] values,
    Serializable id,
    Object entity,
    EntityPersister persister,
    boolean useIdentityColumn,
    EventSource source,
    boolean shouldDelayIdentityInserts) {
  if ( useIdentityColumn ) {
    EntityIdentityInsertAction insert = new EntityIdentityInsertAction(
        values, entity, persister, isVersionIncrementDisabled(), source, shouldDelayIdentityInserts
    );
    source.getActionQueue().addAction( insert );
    return insert;
  }
  else {
    Object version = Versioning.getVersion( values, persister );
    EntityInsertAction insert = new EntityInsertAction(
        id, values, entity, version, persister, isVersionIncrementDisabled(), source
    );
    source.getActionQueue().addAction( insert );
    return insert;
  }
}

/**
 * Convience method to retreive an entities next version value
 */
private Object getNextVersion(FlushEntityEvent event) throws HibernateException {
  EntityEntry entry = event.getEntityEntry();
  EntityPersister persister = entry.getPersister();
  if ( persister.isVersioned() ) {
    Object[] values = event.getPropertyValues();
    if ( entry.isBeingReplicated() ) {
      return Versioning.getVersion(values, persister);
    }
    else {
      int[] dirtyProperties = event.getDirtyProperties();
      final boolean isVersionIncrementRequired = isVersionIncrementRequired(
          event,
          entry,
          persister,
          dirtyProperties
        );
      final Object nextVersion = isVersionIncrementRequired ?
          Versioning.increment( entry.getVersion(), persister.getVersionType(), event.getSession() ) :
          entry.getVersion(); //use the current version
      Versioning.setVersion(values, nextVersion, persister);
      return nextVersion;
    }
  }
  else {
    return null;
  }
}

@Override
public void update(String entityName, Object entity) {
  errorIfClosed();
  EntityPersister persister = getEntityPersister(entityName, entity);
  Serializable id = persister.getIdentifier( entity, this );
  Object[] state = persister.getPropertyValues( entity );
  Object oldVersion;
  if ( persister.isVersioned() ) {
    oldVersion = persister.getVersion( entity );
    Object newVersion = Versioning.increment( oldVersion, persister.getVersionType(), this );
    Versioning.setVersion(state, newVersion, persister);
    persister.setPropertyValues( entity, state );
  }
  else {
    oldVersion = null;
  }
  persister.update(id, state, null, false, null, oldVersion, entity, null, this);
}

/**
 * Transform the array of property indexes to an array of booleans,
 * true when the property is dirty
 */
protected final boolean[] getPropertiesToUpdate(final int[] dirtyProperties, final boolean hasDirtyCollection) {
  final boolean[] propsToUpdate = new boolean[entityMetamodel.getPropertySpan()];
  final boolean[] updateability = getPropertyUpdateability(); //no need to check laziness, dirty checking handles that
  for ( int j = 0; j < dirtyProperties.length; j++ ) {
    int property = dirtyProperties[j];
    if ( updateability[property] ) {
      propsToUpdate[property] = true;
    }
  }
  if ( isVersioned() && updateability[getVersionProperty()] ) {
    propsToUpdate[getVersionProperty()] =
        Versioning.isVersionIncrementRequired(
            dirtyProperties,
            hasDirtyCollection,
            getPropertyVersionability()
        );
  }
  return propsToUpdate;
}

substitute = Versioning.seedVersion(
    values,
    versionDescriptor,

fields[versionProperty] = seed( versionType, session );
return true;

  final LockMode lockMode,
  final SharedSessionContractImplementor session) {
final Object version = Versioning.getVersion( values, persister );
session.getPersistenceContext().addEntry(
    object,

/**
 * Convience method to retreive an entities next version value
 */
private Object getNextVersion(FlushEntityEvent event) throws HibernateException {
  EntityEntry entry = event.getEntityEntry();
  EntityPersister persister = entry.getPersister();
  if ( persister.isVersioned() ) {
    Object[] values = event.getPropertyValues();
    if ( entry.isBeingReplicated() ) {
      return Versioning.getVersion(values, persister);
    }
    else {
      int[] dirtyProperties = event.getDirtyProperties();
      final boolean isVersionIncrementRequired = isVersionIncrementRequired(
          event,
          entry,
          persister,
          dirtyProperties
        );
      final Object nextVersion = isVersionIncrementRequired ?
          Versioning.increment( entry.getVersion(), persister.getVersionType(), event.getSession() ) :
          entry.getVersion(); //use the current version
      Versioning.setVersion(values, nextVersion, persister);
      return nextVersion;
    }
  }
  else {
    return null;
  }
}

@Override
public void update(String entityName, Object entity) {
  checkOpen();
  EntityTypeDescriptor entityDescriptor = getEntityDescriptor( entityName, entity );
  Object id = entityDescriptor.getHierarchy().getIdentifierDescriptor().extractIdentifier( entity, this );
  Object[] state = entityDescriptor.getPropertyValues( entity );
  Object oldVersion;
  final VersionDescriptor<Object, Object> versionDescriptor = entityDescriptor.getHierarchy().getVersionDescriptor();
  if ( versionDescriptor != null ) {
    oldVersion = entityDescriptor.getVersion( entity );
    final VersionSupport versionSupport = versionDescriptor.getVersionSupport();
    Object newVersion = Versioning.increment( oldVersion, versionSupport, this );
    Versioning.setVersion( state, newVersion, entityDescriptor );
    entityDescriptor.setPropertyValues( entity, state );
  }
  else {
    oldVersion = null;
  }
  entityDescriptor.update( id, state, null, false, null, oldVersion, entity, null, this );
}

Versioning.isVersionIncrementRequired(
    dirtyProperties,
    hasDirtyCollection,

substitute = Versioning.seedVersion(
    values,
    persister.getVersionProperty(),