private boolean isVersionChanged(Object entity, EventSource source, EntityPersister persister, Object target) { if ( !persister.isVersioned() ) { return false; } // for merging of versioned entities, we consider the version having // been changed only when: // 1) the two version values are different; // *AND* // 2) The target actually represents database state! // // This second condition is a special case which allows // an entity to be merged during the same transaction // (though during a seperate operation) in which it was // originally persisted/saved boolean changed = !persister.getVersionType().isSame( persister.getVersion( target ), persister.getVersion( entity ) ); // TODO : perhaps we should additionally require that the incoming entity // version be equivalent to the defined unsaved-value? return changed && existsInDatabase( target, source, persister ); }
@Override public void delete(String entityName, Object entity) { checkOpen(); EntityPersister persister = getEntityPersister( entityName, entity ); Serializable id = persister.getIdentifier( entity, this ); Object version = persister.getVersion( entity ); persister.delete( id, version, entity, this ); }
@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 ); }
loadedState, session.generateEntityKey( id, persister ), persister.getVersion( target ), LockMode.NONE, existsInDb,
entity, realOldVersion, persister.getVersion( entity ), persister.getVersionType() );
persister.getVersion( entity ), LockMode.NONE, true,
private boolean isVersionChanged(Object entity, EventSource source, EntityPersister persister, Object target) { if ( ! persister.isVersioned() ) { return false; } // for merging of versioned entities, we consider the version having // been changed only when: // 1) the two version values are different; // *AND* // 2) The target actually represents database state! // // This second condition is a special case which allows // an entity to be merged during the same transaction // (though during a seperate operation) in which it was // originally persisted/saved boolean changed = ! persister.getVersionType().isSame( persister.getVersion( target ), persister.getVersion( entity ) ); // TODO : perhaps we should additionally require that the incoming entity // version be equivalent to the defined unsaved-value? return changed && existsInDatabase( target, source, persister ); }
version = persister.getVersion( instance );
private boolean isVersionChanged(Object entity, EventSource source, EntityPersister persister, Object target) { if ( ! persister.isVersioned() ) { return false; } // for merging of versioned entities, we consider the version having // been changed only when: // 1) the two version values are different; // *AND* // 2) The target actually represents database state! // // This second condition is a special case which allows // an entity to be merged during the same transaction // (though during a seperate operation) in which it was // originally persisted/saved boolean changed = ! persister.getVersionType().isSame( persister.getVersion( target ), persister.getVersion( entity ) ); // TODO : perhaps we should additionally require that the incoming entity // version be equivalent to the defined unsaved-value? return changed && existsInDatabase( target, source, persister ); }
version = persister.getVersion( entity );
private boolean isVersionChanged(Object entity, EventSource source, EntityPersister persister, Object target) { if ( ! persister.isVersioned() ) { return false; } // for merging of versioned entities, we consider the version having // been changed only when: // 1) the two version values are different; // *AND* // 2) The target actually represents database state! // // This second condition is a special case which allows // an entity to be merged during the same transaction // (though during a seperate operation) in which it was // originally persisted/saved boolean changed = ! persister.getVersionType().isSame( persister.getVersion( target, source.getEntityMode() ), persister.getVersion( entity, source.getEntityMode() ), source.getEntityMode() ); // TODO : perhaps we should additionally require that the incoming entity // version be equivalent to the defined unsaved-value? return changed && existsInDatabase( target, source, persister ); }
previousVersion = persister.getVersion( object );
@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); }
previousVersion = persister.getVersion( instance );
public void update(String entityName, Object entity) { errorIfClosed(); EntityPersister persister = getEntityPersister(entityName, entity); Serializable id = persister.getIdentifier(entity, EntityMode.POJO); Object[] state = persister.getPropertyValues(entity, EntityMode.POJO); Object oldVersion; if ( persister.isVersioned() ) { oldVersion = persister.getVersion(entity, EntityMode.POJO); Object newVersion = Versioning.increment( oldVersion, persister.getVersionType(), this ); Versioning.setVersion(state, newVersion, persister); persister.setPropertyValues(entity, state, EntityMode.POJO); } else { oldVersion = null; } persister.update(id, state, null, false, null, oldVersion, entity, null, this); }
@Override public Object getVersion(final Object object) throws HibernateException { try { return persister.getVersion(object); } catch (final PersistenceException ex) { throw HibernateExceptionAdapter.adapt(ex); } }
@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); }
public void delete(String entityName, Object entity) { errorIfClosed(); EntityPersister persister = getEntityPersister(entityName, entity); Serializable id = persister.getIdentifier(entity, EntityMode.POJO); Object version = persister.getVersion(entity, EntityMode.POJO); persister.delete(id, version, entity, this); }
@Override public void delete(String entityName, Object entity) { errorIfClosed(); EntityPersister persister = getEntityPersister(entityName, entity); Serializable id = persister.getIdentifier( entity, this ); Object version = persister.getVersion( entity ); persister.delete(id, version, entity, this); }
@Override public void delete(String entityName, Object entity) { errorIfClosed(); EntityPersister persister = getEntityPersister(entityName, entity); Serializable id = persister.getIdentifier( entity, this ); Object version = persister.getVersion( entity ); persister.delete(id, version, entity, this); }