private boolean isCollectionDirtyCheckNecessary(EntityPersister persister, Status status) { return ( status == Status.MANAGED || status == Status.READ_ONLY ) && persister.isVersioned() && persister.hasCollections(); }
@Override public boolean isVersioned() { return isVersioned && getOwnerEntityPersister().isVersioned(); }
/** * Extract the optimistic locking value out of the entity state snapshot. * * @param fields The state snapshot * @param persister The entity persister * @return The extracted optimistic locking value */ public static Object getVersion(Object[] fields, EntityPersister persister) { if ( !persister.isVersioned() ) { return null; } return fields[ persister.getVersionProperty() ]; }
/** * Inject the optimistic locking value into the entity state snapshot. * * @param fields The state snapshot * @param version The optimistic locking value * @param persister The entity persister */ public static void setVersion(Object[] fields, Object version, EntityPersister persister) { if ( !persister.isVersioned() ) { return; } fields[ persister.getVersionProperty() ] = version; }
/** * Is the owning entity versioned? * * @param session The session from which the request is originating. * @return True if the collection owner is versioned; false otherwise. * @throws org.hibernate.MappingException Indicates our persister could not be located. */ private boolean isOwnerVersioned(SharedSessionContractImplementor session) throws MappingException { return getPersister( session ).getOwnerEntityPersister().isVersioned(); }
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 ); }
if ( persister.isVersioned() ) { substitute = Versioning.seedVersion( values,
@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 ); }
protected void prepareTest() throws Exception { super.prepareTest(); isContractPartiesInverse = sessionFactory().getCollectionPersister( Contract.class.getName() + ".parties" ).isInverse(); try { sessionFactory().getEntityPersister( Party.class.getName() ).getPropertyType( "contract" ); isContractPartiesBidirectional = true; } catch ( QueryException ex) { isContractPartiesBidirectional = false; } try { sessionFactory().getEntityPersister( ContractVariation.class.getName() ).getPropertyType( "contract" ); isContractVariationsBidirectional = true; } catch ( QueryException ex) { isContractVariationsBidirectional = false; } isContractVersioned = sessionFactory().getEntityPersister( Contract.class.getName() ).isVersioned(); }
final String versionStr = persister.isVersioned() ? persister.getVersionType().toLoggableString( version, session.getFactory() ) : "null";
@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; }
@Override public void postUpdate(Object entity, Object[] updatedState, Object nextVersion) { this.loadedState = updatedState; setLockMode( LockMode.WRITE ); if ( getPersister().isVersioned() ) { this.version = nextVersion; getPersister().setPropertyValue( entity, getPersister().getVersionProperty(), nextVersion ); } if( entity instanceof SelfDirtinessTracker ) { ( (SelfDirtinessTracker) entity ).$$_hibernate_clearDirtyAttributes(); } getPersistenceContext().getSession() .getFactory() .getCustomEntityDirtinessStrategy() .resetDirty( entity, getPersister(), (Session) getPersistenceContext().getSession() ); }
/** * 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 void checkVersion( ResultSet resultSet, ResultSetProcessingContext context, EntityKey entityKey, Object existing) { final LockMode requestedLockMode = context.resolveLockMode( entityReference ); if ( requestedLockMode != LockMode.NONE ) { final LockMode currentLockMode = context.getSession().getPersistenceContext().getEntry( existing ).getLockMode(); final boolean isVersionCheckNeeded = entityReference.getEntityPersister().isVersioned() && currentLockMode.lessThan( requestedLockMode ); // we don't need to worry about existing version being uninitialized because this block isn't called // by a re-entrant load (re-entrant loads *always* have lock mode NONE) if ( isVersionCheckNeeded ) { //we only check the version when *upgrading* lock modes checkVersion( context.getSession(), resultSet, entityReference.getEntityPersister(), entityReferenceAliases.getColumnAliases(), entityKey, existing ); //we need to upgrade the lock mode to the mode requested context.getSession().getPersistenceContext().getEntry( existing ).setLockMode( requestedLockMode ); } } }
if ( persister.isVersioned() && requestedLockMode == LockMode.FORCE ) {
final Object realOldVersion = persister.isVersioned() ? oldVersion : null;
/** * Get the version number of the given instance state snapshot */ public static Object getVersion(Object[] fields, EntityPersister persister) throws HibernateException { return persister.isVersioned() ? getVersion( fields, persister.getVersionProperty() ) : null; }
/** * Is the owning entity versioned? * * @param session The session from which the request is originating. * @return True if the collection owner is versioned; false otherwise. * @throws org.hibernate.MappingException Indicates our persister could not be located. */ private boolean isOwnerVersioned(SessionImplementor session) throws MappingException { return getPersister( session ).getOwnerEntityPersister().isVersioned(); }
/** * Is the owning entity versioned? * * @param session The session from which the request is originating. * @return True if the collection owner is versioned; false otherwise. * @throws org.hibernate.MappingException Indicates our persister could not be located. */ private boolean isOwnerVersioned(SessionImplementor session) throws MappingException { return getPersister( session ).getOwnerEntityPersister().isVersioned(); }
/** * Get the version number of the given instance state snapshot */ public static Object getVersion(Object[] fields, EntityPersister persister) throws HibernateException { return persister.isVersioned() ? getVersion( fields, persister.getVersionProperty() ) : null; }