/** * Schedules audit data removal from session level cache after transaction completion. The operation is performed * regardless of commit success. * * @param session Active Hibernate session. * @param data Audit data that shall be evicted (e.g. revision data or entity snapshot) */ public void scheduleAuditDataRemoval(final Session session, final Object data) { ( (EventSource) session ).getActionQueue().registerProcess( new AfterTransactionCompletionProcess() { public void doAfterTransactionCompletion(boolean success, SharedSessionContractImplementor sessionImplementor) { if ( !sessionImplementor.isClosed() ) { try { ( (Session) sessionImplementor ).evict( data ); } catch ( HibernateException ignore ) { } } } } ); } }
auditProcesses.put( transaction, auditProcess ); session.getActionQueue().registerProcess( new BeforeTransactionCompletionProcess() { public void doBeforeTransactionCompletion(SessionImplementor session) { session.getActionQueue().registerProcess( new AfterTransactionCompletionProcess() { public void doAfterTransactionCompletion(boolean success, SharedSessionContractImplementor session) {
private boolean flushIsReallyNeeded(AutoFlushEvent event, final EventSource source) { return source.getHibernateFlushMode() == FlushMode.ALWAYS || source.getActionQueue().areTablesToBeUpdated( event.getQuerySpaces() ); }
private void evict(Serializable id, CollectionPersister collectionPersister, EventSource session) { if ( LOG.isDebugEnabled() ) { LOG.debug( "Evict CollectionRegion " + collectionPersister.getRole() + " for id " + id ); } AfterTransactionCompletionProcess afterTransactionProcess = new CollectionEvictCacheAction( collectionPersister, null, id, session ).lockCache(); session.getActionQueue().registerProcess( afterTransactionProcess ); }
@SuppressWarnings( value = {"unchecked"} ) private void logFlushResults(FlushEvent event) { if ( !LOG.isDebugEnabled() ) { return; } final EventSource session = event.getSession(); final PersistenceContext persistenceContext = session.getPersistenceContext(); LOG.debugf( "Flushed: %s insertions, %s updates, %s deletions to %s objects", session.getActionQueue().numberOfInsertions(), session.getActionQueue().numberOfUpdates(), session.getActionQueue().numberOfDeletions(), persistenceContext.getNumberOfManagedEntities() ); LOG.debugf( "Flushed: %s (re)creations, %s updates, %s removals to %s collections", session.getActionQueue().numberOfCollectionCreations(), session.getActionQueue().numberOfCollectionUpdates(), session.getActionQueue().numberOfCollectionRemovals(), persistenceContext.getCollectionEntries().size() ); new EntityPrinter( session.getFactory() ).toString( persistenceContext.getEntitiesByKey().entrySet() ); }
/** * Handle the given dirty-check event. * * @param event The dirty-check event to be handled. * @throws HibernateException */ public void onDirtyCheck(DirtyCheckEvent event) throws HibernateException { int oldSize = event.getSession().getActionQueue().numberOfCollectionRemovals(); try { flushEverythingToExecutions(event); boolean wasNeeded = event.getSession().getActionQueue().hasAnyQueuedActions(); if ( wasNeeded ) { LOG.debug( "Session dirty" ); } else { LOG.debug( "Session not dirty" ); } event.setDirty( wasNeeded ); } finally { event.getSession().getActionQueue().clearFromFlushNeededCheck( oldSize ); } } }
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; } }
@Override public void onPostInsert(PostInsertEvent event) { event.getSession().getActionQueue().registerProcess( new BeforeTransactionCompletionProcess() { @Override public void doBeforeTransactionCompletion(SessionImplementor session) { beforeCounter.increase(); } } ); event.getSession().getActionQueue().registerProcess( new AfterTransactionCompletionProcess() { @Override public void doAfterTransactionCompletion(boolean success, SharedSessionContractImplementor session) { afterCounter.increase(); } } ); }
@Override public void lock(Serializable id, Object version, Object object, int timeout, SharedSessionContractImplementor session) { if ( !lockable.isVersioned() ) { throw new OptimisticLockException( object, "[" + lockMode + "] not supported for non-versioned entities [" + lockable.getEntityName() + "]" ); } final EntityEntry entry = session.getPersistenceContext().getEntry( object ); // Register the EntityVerifyVersionProcess action to run just prior to transaction commit. ( (EventSource) session ).getActionQueue().registerProcess( new EntityVerifyVersionProcess( object, entry ) ); }
protected void coordinateSharedCacheCleanup(SharedSessionContractImplementor session) { final BulkOperationCleanupAction action = new BulkOperationCleanupAction( session, getCustomQuery().getQuerySpaces() ); if ( session.isEventSource() ) { ( (EventSource) session ).getActionQueue().addAction( action ); } else { action.getAfterTransactionCompletionProcess().doAfterTransactionCompletion( true, session ); } }
@Override public void lock(Serializable id, Object version, Object object, int timeout, SharedSessionContractImplementor session) { if ( !lockable.isVersioned() ) { throw new HibernateException( "[" + lockMode + "] not supported for non-versioned entities [" + lockable.getEntityName() + "]" ); } final EntityEntry entry = session.getPersistenceContext().getEntry( object ); // Register the EntityIncrementVersionProcess action to run just prior to transaction commit. ( (EventSource) session ).getActionQueue().registerProcess( new EntityIncrementVersionProcess( object, entry ) ); }
@Override public int execute(QueryParameters parameters, SharedSessionContractImplementor session) throws HibernateException { BulkOperationCleanupAction action = new BulkOperationCleanupAction( session, deleteHandler.getTargetedQueryable() ); if ( session.isEventSource() ) { ( (EventSource) session ).getActionQueue().addAction( action ); } else { action.getAfterTransactionCompletionProcess().doAfterTransactionCompletion( true, session ); } return deleteHandler.execute( session, parameters ); } }
public int execute(QueryParameters parameters, SharedSessionContractImplementor session) throws HibernateException { BulkOperationCleanupAction action = new BulkOperationCleanupAction( session, updateHandler.getTargetedQueryable() ); if ( session.isEventSource() ) { ( (EventSource) session ).getActionQueue().addAction( action ); } else { action.getAfterTransactionCompletionProcess().doAfterTransactionCompletion( true, session ); } return updateHandler.execute( session, parameters ); } }
/** * Schedules a collection for deletion. * * @param role The persister representing the collection to be removed. * @param collectionKey The collection key (differs from owner-id in the case of property-refs). * @param source The session from which the request originated. * * @throws HibernateException */ void removeCollection(CollectionPersister role, Serializable collectionKey, EventSource source) throws HibernateException { if ( LOG.isTraceEnabled() ) { LOG.tracev( "Collection dereferenced while transient {0}", MessageHelper.collectionInfoString( role, ownerIdentifier, source.getFactory() ) ); } source.getActionQueue().addAction( new CollectionRemoveAction( owner, role, collectionKey, false, source ) ); }
session.getActionQueue().prepareActions(); session.getActionQueue().executeActions();
source.getActionQueue().sortActions();
BulkOperationCleanupAction action = new BulkOperationCleanupAction( session, persister ); if ( session.isEventSource() ) { ( (EventSource) session ).getActionQueue().addAction( action );
event.getSession().getActionQueue().registerProcess( incrementVersion ); event.getSession().getActionQueue().registerProcess( verifyVersion );
final int oldSize = source.getActionQueue().numberOfCollectionRemovals(); flushEverythingToExecutions(event); if ( flushIsReallyNeeded(event, source) ) { source.getActionQueue().clearFromFlushNeededCheck( oldSize );
private void evictCachedCollections(Type[] types, Serializable id, EventSource source) throws HibernateException { for ( Type type : types ) { if ( type.isCollectionType() ) { CollectionPersister collectionPersister = source.getFactory().getMetamodel().collectionPersister( ( (CollectionType) type ).getRole() ); if ( collectionPersister.hasCache() ) { final CollectionDataAccess cache = collectionPersister.getCacheAccessStrategy(); final Object ck = cache.generateCacheKey( id, collectionPersister, source.getFactory(), source.getTenantIdentifier() ); final SoftLock lock = cache.lockItem( source, ck, null ); cache.remove( source, ck ); source.getActionQueue().registerProcess( (success, session) -> cache.unlockItem( session, ck, lock ) ); } } else if ( type.isComponentType() ) { CompositeType actype = (CompositeType) type; evictCachedCollections( actype.getSubtypes(), id, source ); } } } }