/** 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;
    }
  }
 private boolean hasDirtyCollections(
     FlushEntityEvent event, EntityPersister persister, Status status) {
   if (isCollectionDirtyCheckNecessary(persister, status)) {
     DirtyCollectionSearchVisitor visitor =
         new DirtyCollectionSearchVisitor(
             event.getSession(), persister.getPropertyVersionability());
     visitor.processEntityPropertyValues(event.getPropertyValues(), persister.getPropertyTypes());
     boolean hasDirtyCollections = visitor.wasDirtyCollectionFound();
     event.setHasDirtyCollection(hasDirtyCollections);
     return hasDirtyCollections;
   } else {
     return false;
   }
 }
  protected boolean handleInterception(FlushEntityEvent event) {
    SessionImplementor session = event.getSession();
    EntityEntry entry = event.getEntityEntry();
    EntityPersister persister = entry.getPersister();
    Object entity = event.getEntity();

    // give the Interceptor a chance to modify property values
    final Object[] values = event.getPropertyValues();
    final boolean intercepted = invokeInterceptor(session, entity, entry, values, persister);

    // now we might need to recalculate the dirtyProperties array
    if (intercepted && event.isDirtyCheckPossible() && !event.isDirtyCheckHandledByInterceptor()) {
      int[] dirtyProperties;
      if (event.hasDatabaseSnapshot()) {
        dirtyProperties =
            persister.findModified(event.getDatabaseSnapshot(), values, entity, session);
      } else {
        dirtyProperties = persister.findDirty(values, entry.getLoadedState(), entity, session);
      }
      event.setDirtyProperties(dirtyProperties);
    }

    return intercepted;
  }
  /** Perform a dirty check, and attach the results to the event */
  protected void dirtyCheck(FlushEntityEvent event) throws HibernateException {

    final Object entity = event.getEntity();
    final Object[] values = event.getPropertyValues();
    final SessionImplementor session = event.getSession();
    final EntityEntry entry = event.getEntityEntry();
    final EntityPersister persister = entry.getPersister();
    final Serializable id = entry.getId();
    final Object[] loadedState = entry.getLoadedState();

    int[] dirtyProperties =
        session
            .getInterceptor()
            .findDirty(
                entity,
                id,
                values,
                loadedState,
                persister.getPropertyNames(),
                persister.getPropertyTypes());

    event.setDatabaseSnapshot(null);

    final boolean interceptorHandledDirtyCheck;
    boolean cannotDirtyCheck;

    if (dirtyProperties == null) {
      // Interceptor returned null, so do the dirtycheck ourself, if possible
      interceptorHandledDirtyCheck = false;

      cannotDirtyCheck = loadedState == null; // object loaded by update()
      if (!cannotDirtyCheck) {
        // dirty check against the usual snapshot of the entity
        dirtyProperties = persister.findDirty(values, loadedState, entity, session);
      } else if (entry.getStatus() == Status.DELETED
          && !event.getEntityEntry().isModifiableEntity()) {
        // A non-modifiable (e.g., read-only or immutable) entity needs to be have
        // references to transient entities set to null before being deleted. No other
        // fields should be updated.
        if (values != entry.getDeletedState()) {
          throw new IllegalStateException(
              "Entity has status Status.DELETED but values != entry.getDeletedState");
        }
        // Even if loadedState == null, we can dirty-check by comparing currentState and
        // entry.getDeletedState() because the only fields to be updated are those that
        // refer to transient entities that are being set to null.
        // - currentState contains the entity's current property values.
        // - entry.getDeletedState() contains the entity's current property values with
        //   references to transient entities set to null.
        // - dirtyProperties will only contain properties that refer to transient entities
        final Object[] currentState =
            persister.getPropertyValues(event.getEntity(), event.getSession().getEntityMode());
        dirtyProperties =
            persister.findDirty(entry.getDeletedState(), currentState, entity, session);
        cannotDirtyCheck = false;
      } else {
        // dirty check against the database snapshot, if possible/necessary
        final Object[] databaseSnapshot = getDatabaseSnapshot(session, persister, id);
        if (databaseSnapshot != null) {
          dirtyProperties = persister.findModified(databaseSnapshot, values, entity, session);
          cannotDirtyCheck = false;
          event.setDatabaseSnapshot(databaseSnapshot);
        }
      }
    } else {
      // the Interceptor handled the dirty checking
      cannotDirtyCheck = false;
      interceptorHandledDirtyCheck = true;
    }

    logDirtyProperties(id, dirtyProperties, persister);

    event.setDirtyProperties(dirtyProperties);
    event.setDirtyCheckHandledByInterceptor(interceptorHandledDirtyCheck);
    event.setDirtyCheckPossible(!cannotDirtyCheck);
  }
  private boolean scheduleUpdate(final FlushEntityEvent event) {

    final EntityEntry entry = event.getEntityEntry();
    final EventSource session = event.getSession();
    final Object entity = event.getEntity();
    final Status status = entry.getStatus();
    final EntityMode entityMode = session.getEntityMode();
    final EntityPersister persister = entry.getPersister();
    final Object[] values = event.getPropertyValues();

    if (LOG.isTraceEnabled()) {
      if (status == Status.DELETED) {
        if (!persister.isMutable())
          LOG.trace(
              "Updating immutable, deleted entity: "
                  + MessageHelper.infoString(persister, entry.getId(), session.getFactory()));
        else if (!entry.isModifiableEntity())
          LOG.trace(
              "Updating non-modifiable, deleted entity: "
                  + MessageHelper.infoString(persister, entry.getId(), session.getFactory()));
        else
          LOG.trace(
              "Updating deleted entity: "
                  + MessageHelper.infoString(persister, entry.getId(), session.getFactory()));
      } else
        LOG.trace(
            "Updating entity: "
                + MessageHelper.infoString(persister, entry.getId(), session.getFactory()));
    }

    final boolean intercepted = !entry.isBeingReplicated() && handleInterception(event);

    // increment the version number (if necessary)
    final Object nextVersion = getNextVersion(event);

    // if it was dirtied by a collection only
    int[] dirtyProperties = event.getDirtyProperties();
    if (event.isDirtyCheckPossible() && dirtyProperties == null) {
      if (!intercepted && !event.hasDirtyCollection()) {
        throw new AssertionFailure("dirty, but no dirty properties");
      }
      dirtyProperties = ArrayHelper.EMPTY_INT_ARRAY;
    }

    // check nullability but do not doAfterTransactionCompletion command execute
    // we'll use scheduled updates for that.
    new Nullability(session).checkNullability(values, persister, true);

    // schedule the update
    // note that we intentionally do _not_ pass in currentPersistentState!
    session
        .getActionQueue()
        .addAction(
            new EntityUpdateAction(
                entry.getId(),
                values,
                dirtyProperties,
                event.hasDirtyCollection(),
                (status == Status.DELETED && !entry.isModifiableEntity()
                    ? persister.getPropertyValues(entity, entityMode)
                    : entry.getLoadedState()),
                entry.getVersion(),
                nextVersion,
                entity,
                entry.getRowId(),
                persister,
                session));

    return intercepted;
  }