コード例 #1
0
 @SuppressWarnings("unchecked")
 public void onSaveOrUpdate(SaveOrUpdateEvent event) throws HibernateException {
   Object entity = event.getObject();
   boolean newEntity = !event.getSession().contains(entity);
   if (newEntity) {
     if (beforeInsertCaller != null) {
       beforeInsertCaller.call(entity);
       if (event.getSession().contains(entity)) {
         EntityEntry entry = event.getEntry();
         if (entry != null) {
           Object[] state = entry.getLoadedState();
           synchronizePersisterState(entity, entry.getPersister(), state);
         }
       }
     }
     if (shouldTimestamp) {
       long time = System.currentTimeMillis();
       if (dateCreatedProperty != null && newEntity) {
         Object now =
             DefaultGroovyMethods.newInstance(dateCreatedProperty.getType(), new Object[] {time});
         dateCreatedProperty.setProperty(entity, now);
       }
       if (lastUpdatedProperty != null) {
         Object now =
             DefaultGroovyMethods.newInstance(lastUpdatedProperty.getType(), new Object[] {time});
         lastUpdatedProperty.setProperty(entity, now);
       }
     }
   }
 }
コード例 #2
0
  @SuppressWarnings("unchecked")
  @Override
  /**
   * Handle the given delete event. This is the cascaded form.
   *
   * @param event The delete event.
   * @param transientEntities The cache of entities already deleted
   * @throws HibernateException
   */
  public void onDelete(DeleteEvent event, Set transientEntities) throws HibernateException {
    final EventSource source = event.getSession();

    final PersistenceContext persistenceContext = source.getPersistenceContext();
    Object entity = persistenceContext.unproxyAndReassociate(event.getObject());
    EntityEntry entityEntry = persistenceContext.getEntry(entity);

    final EntityPersister persister = source.getEntityPersister(event.getEntityName(), entity);
    final Object version;

    if (persister.isVersioned()) {
      version = persister.getVersion(entity, source.getEntityMode());
      // Make sure version has not changed on deleted entities
      if ((entity instanceof TimelineEntity) && !((TimelineEntity) entity).isNew()) {
        if (!persister.getVersionType().isEqual(version, entityEntry.getVersion())) {
          throw new StaleObjectStateException(persister.getEntityName(), entityEntry.getId());
        }
      }
    }
    super.onDelete(event, transientEntities);
  }
コード例 #3
0
  /** 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;
    }
  }
コード例 #4
0
 private void checkNaturalId(
     EntityPersister persister,
     EntityEntry entry,
     Object[] current,
     Object[] loaded,
     EntityMode entityMode,
     SessionImplementor session) {
   if (persister.hasNaturalIdentifier() && entry.getStatus() != Status.READ_ONLY) {
     Object[] snapshot = null;
     Type[] types = persister.getPropertyTypes();
     int[] props = persister.getNaturalIdentifierProperties();
     boolean[] updateable = persister.getPropertyUpdateability();
     for (int i = 0; i < props.length; i++) {
       int prop = props[i];
       if (!updateable[prop]) {
         Object loadedVal;
         if (loaded == null) {
           if (snapshot == null) {
             snapshot =
                 session.getPersistenceContext().getNaturalIdSnapshot(entry.getId(), persister);
           }
           loadedVal = snapshot[i];
         } else {
           loadedVal = loaded[prop];
         }
         if (!types[prop].isEqual(current[prop], loadedVal, entityMode)) {
           throw new HibernateException(
               "immutable natural identifier of an instance of "
                   + persister.getEntityName()
                   + " was altered");
         }
       }
     }
   }
 }
コード例 #5
0
  private Object[] getValues(
      Object entity,
      EntityEntry entry,
      EntityMode entityMode,
      boolean mightBeDirty,
      SessionImplementor session) {
    final Object[] loadedState = entry.getLoadedState();
    final Status status = entry.getStatus();
    final EntityPersister persister = entry.getPersister();

    final Object[] values;
    if (status == Status.DELETED) {
      // grab its state saved at deletion
      values = entry.getDeletedState();
    } else if (!mightBeDirty && loadedState != null) {
      values = loadedState;
    } else {
      checkId(entity, persister, entry.getId(), entityMode, session);

      // grab its current state
      values = persister.getPropertyValues(entity, entityMode);

      checkNaturalId(persister, entry, values, loadedState, entityMode, session);
    }
    return values;
  }
コード例 #6
0
  /**
   * Flushes a single entity's state to the database, by scheduling an update action, if necessary
   */
  public void onFlushEntity(FlushEntityEvent event) throws HibernateException {
    final Object entity = event.getEntity();
    final EntityEntry entry = event.getEntityEntry();
    final EventSource session = event.getSession();
    final EntityPersister persister = entry.getPersister();
    final Status status = entry.getStatus();
    final EntityMode entityMode = session.getEntityMode();
    final Type[] types = persister.getPropertyTypes();

    final boolean mightBeDirty = entry.requiresDirtyCheck(entity);

    final Object[] values = getValues(entity, entry, entityMode, mightBeDirty, session);

    event.setPropertyValues(values);

    // TODO: avoid this for non-new instances where mightBeDirty==false
    boolean substitute = wrapCollections(session, persister, types, values);

    if (isUpdateNecessary(event, mightBeDirty)) {
      substitute = scheduleUpdate(event) || substitute;
    }

    if (status != Status.DELETED) {
      // now update the object .. has to be outside the main if block above (because of collections)
      if (substitute) persister.setPropertyValues(entity, values, entityMode);

      // Search for collections by reachability, updating their role.
      // We don't want to touch collections reachable from a deleted object
      if (persister.hasCollections()) {
        new FlushVisitor(session, entity).processEntityPropertyValues(values, types);
      }
    }
  }
コード例 #7
0
 private void throwObjectDeletedIfNecessary(LoadEvent event, EntityEntry oldEntry) {
   Status status = oldEntry.getStatus();
   if (status == Status.DELETED || status == Status.GONE) {
     throw new ObjectDeletedException(
         "The object with that id was deleted", event.getEntityId(), event.getEntityClassName());
   }
 }
コード例 #8
0
 protected boolean invokeInterceptor(
     SessionImplementor session,
     Object entity,
     EntityEntry entry,
     final Object[] values,
     EntityPersister persister) {
   return session
       .getInterceptor()
       .onFlushDirty(
           entity,
           entry.getId(),
           values,
           entry.getLoadedState(),
           persister.getPropertyNames(),
           persister.getPropertyTypes());
 }
コード例 #9
0
 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;
 }
コード例 #10
0
  /**
   * The given save-update event named a transient entity.
   *
   * <p>Here, we will perform the save processing.
   *
   * @param event The save event to be handled.
   * @return The entity's identifier after saving.
   */
  protected Serializable entityIsTransient(SaveOrUpdateEvent event) {

    LOG.trace("Saving transient instance");

    final EventSource source = event.getSession();

    EntityEntry entityEntry = event.getEntry();
    if (entityEntry != null) {
      if (entityEntry.getStatus() == Status.DELETED) {
        source.forceFlush(entityEntry);
      } else {
        throw new AssertionFailure("entity was persistent");
      }
    }

    Serializable id = saveWithGeneratedOrRequestedId(event);

    source.getPersistenceContext().reassociateProxy(event.getObject(), id);

    return id;
  }
コード例 #11
0
 @Override
 protected boolean invokeInterceptor(
     SessionImplementor session,
     Object entity,
     EntityEntry entry,
     Object[] values,
     EntityPersister persister) {
   boolean isDirty = false;
   if (entry.getStatus() != Status.DELETED) {
     if (callbackHandler.preUpdate(entity)) {
       isDirty = copyState(entity, persister.getPropertyTypes(), values, session.getFactory());
     }
   }
   return super.invokeInterceptor(session, entity, entry, values, persister) || isDirty;
 }
コード例 #12
0
  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;
  }
コード例 #13
0
  protected Serializable entityIsPersistent(SaveOrUpdateEvent event) throws HibernateException {
    LOG.trace("Ignoring persistent instance");

    EntityEntry entityEntry = event.getEntry();
    if (entityEntry == null) {
      throw new AssertionFailure("entity was transient or detached");
    } else {

      if (entityEntry.getStatus() == Status.DELETED) {
        throw new AssertionFailure("entity was deleted");
      }

      final SessionFactoryImplementor factory = event.getSession().getFactory();

      Serializable requestedId = event.getRequestedId();

      Serializable savedId;
      if (requestedId == null) {
        savedId = entityEntry.getId();
      } else {

        final boolean isEqual =
            !entityEntry
                .getPersister()
                .getIdentifierType()
                .isEqual(
                    requestedId, entityEntry.getId(), event.getSession().getEntityMode(), factory);

        if (isEqual) {
          throw new PersistentObjectException(
              "object passed to save() was already persistent: "
                  + MessageHelper.infoString(entityEntry.getPersister(), requestedId, factory));
        }

        savedId = requestedId;
      }

      if (LOG.isTraceEnabled())
        LOG.trace(
            "Object already associated with session: "
                + MessageHelper.infoString(entityEntry.getPersister(), savedId, factory));

      return savedId;
    }
  }
コード例 #14
0
  public void execute() throws HibernateException {
    Serializable id = getId();
    EntityPersister persister = getPersister();
    SessionImplementor session = getSession();
    Object instance = getInstance();

    boolean veto = preDelete();

    Object version = this.version;
    if (persister.isVersionPropertyGenerated()) {
      // we need to grab the version value from the entity, otherwise
      // we have issues with generated-version entities that may have
      // multiple actions queued during the same flush
      version = persister.getVersion(instance, session.getEntityMode());
    }

    final CacheKey ck;
    if (persister.hasCache()) {
      ck =
          new CacheKey(
              id,
              persister.getIdentifierType(),
              persister.getRootEntityName(),
              session.getEntityMode(),
              session.getFactory());
      lock = persister.getCacheAccessStrategy().lockItem(ck, version);
    } else {
      ck = null;
    }

    if (!isCascadeDeleteEnabled && !veto) {
      persister.delete(id, version, instance, session);
    }

    // postDelete:
    // After actually deleting a row, record the fact that the instance no longer
    // exists on the database (needed for identity-column key generation), and
    // remove it from the session cache
    final PersistenceContext persistenceContext = session.getPersistenceContext();
    EntityEntry entry = persistenceContext.removeEntry(instance);
    if (entry == null) {
      throw new AssertionFailure("possible nonthreadsafe access to session");
    }
    entry.postDelete();

    persistenceContext.removeEntity(entry.getEntityKey());
    persistenceContext.removeProxy(entry.getEntityKey());

    if (persister.hasCache()) {
      persister.getCacheAccessStrategy().remove(ck);
    }

    postDelete();

    if (getSession().getFactory().getStatistics().isStatisticsEnabled() && !veto) {
      getSession()
          .getFactory()
          .getStatisticsImplementor()
          .deleteEntity(getPersister().getEntityName());
    }
  }
コード例 #15
0
  /** 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);
  }
コード例 #16
0
  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;
  }