private boolean cacheAfterUpdate(EntityDataAccess cache, Object ck) { final SharedSessionContractImplementor session = getSession(); SessionEventListenerManager eventListenerManager = session.getEventListenerManager(); try { eventListenerManager.cachePutStart(); return cache.afterUpdate( session, ck, cacheEntry, nextVersion, previousVersion, lock ); } finally { eventListenerManager.cachePutEnd(); } }
private boolean cacheAfterInsert(EntityDataAccess cache, Object ck) { SharedSessionContractImplementor session = getSession(); final SessionEventListenerManager eventListenerManager = session.getEventListenerManager(); try { eventListenerManager.cachePutStart(); return cache.afterInsert( session, ck, cacheEntry, version ); } finally { eventListenerManager.cachePutEnd(); } }
private boolean cacheInsert(EntityPersister persister, Object ck) { SharedSessionContractImplementor session = getSession(); try { session.getEventListenerManager().cachePutStart(); return persister.getCacheAccessStrategy().insert( session, ck, cacheEntry, version); } finally { session.getEventListenerManager().cachePutEnd(); } }
private boolean cacheUpdate(EntityPersister persister, Object previousVersion, Object ck) { final SharedSessionContractImplementor session = getSession(); try { session.getEventListenerManager().cachePutStart(); return persister.getCacheAccessStrategy().update( session, ck, cacheEntry, nextVersion, previousVersion ); } finally { session.getEventListenerManager().cachePutEnd(); } }
session.getEventListenerManager().cachePutEnd();
@Override public void invalidate( String[] spaces, SharedSessionContractImplementor session) { final boolean stats = session.getFactory().getStatistics().isStatisticsEnabled(); final Long ts = session.getFactory().getCache().getRegionFactory().nextTimestamp(); for (Serializable space : spaces) { if ( DEBUG_ENABLED ) { log.debugf( "Invalidating space [%s], timestamp: %s", space, ts ); } try { session.getEventListenerManager().cachePutStart(); timestampsRegion.putIntoCache( space, ts, session ); } finally { session.getEventListenerManager().cachePutEnd(); if ( stats ) { session.getFactory().getStatistics().updateTimestampsCachePut(); } } } }
@Override public void preInvalidate( String[] spaces, SharedSessionContractImplementor session) { final SessionFactoryImplementor factory = session.getFactory(); final RegionFactory regionFactory = factory.getCache().getRegionFactory(); final boolean stats = factory.getStatistics().isStatisticsEnabled(); final Long ts = regionFactory.nextTimestamp() + regionFactory.getTimeout(); for ( Serializable space : spaces ) { if ( DEBUG_ENABLED ) { log.debugf( "Pre-invalidating space [%s], timestamp: %s", space, ts ); } try { session.getEventListenerManager().cachePutStart(); //put() has nowait semantics, is this really appropriate? //note that it needs to be async replication, never local or sync timestampsRegion.putIntoCache( space, ts, session ); } finally { session.getEventListenerManager().cachePutEnd(); } if ( stats ) { factory.getStatistics().updateTimestampsCachePut(); } } }
session.getEventListenerManager().cachePutEnd();
eventListenerManager.cachePutEnd();
private boolean cacheAfterInsert(EntityDataAccess cache, Object ck) { SharedSessionContractImplementor session = getSession(); final SessionEventListenerManager eventListenerManager = session.getEventListenerManager(); try { eventListenerManager.cachePutStart(); return cache.afterInsert( session, ck, cacheEntry, version ); } finally { eventListenerManager.cachePutEnd(); } }
private boolean cacheAfterUpdate(EntityDataAccess cache, Object ck) { final SharedSessionContractImplementor session = getSession(); SessionEventListenerManager eventListenerManager = session.getEventListenerManager(); try { eventListenerManager.cachePutStart(); return cache.afterUpdate( session, ck, cacheEntry, nextVersion, previousVersion, lock ); } finally { eventListenerManager.cachePutEnd(); } }
private boolean cacheUpdate(EntityTypeDescriptor entityDescriptor, Object previousVersion, Object ck) { final SharedSessionContractImplementor session = getSession(); try { session.getEventListenerManager().cachePutStart(); final EntityTypeDescriptor rootDescriptor = entityDescriptor.getHierarchy().getRootEntityType(); return session.getFactory().getCache().getEntityRegionAccess( rootDescriptor.getNavigableRole() ).update( session, ck, cacheEntry, nextVersion, previousVersion ); } finally { session.getEventListenerManager().cachePutEnd(); } }
@Override @SuppressWarnings({ "unchecked" }) public boolean put( final QueryKey key, final List results, final SharedSessionContractImplementor session) throws HibernateException { if ( DEBUGGING ) { LOG.debugf( "Caching query results in region: %s; timestamp=%s", cacheRegion.getName(), session.getTransactionStartTimestamp() ); } final CacheItem cacheItem = new CacheItem( session.getTransactionStartTimestamp(), deepCopy( results ) ); try { session.getEventListenerManager().cachePutStart(); cacheRegion.putIntoCache( key, cacheItem, session ); } finally { session.getEventListenerManager().cachePutEnd(); } return true; }
private boolean cacheInsert(EntityTypeDescriptor descriptor, Object ck) { SharedSessionContractImplementor session = getSession(); try { session.getEventListenerManager().cachePutStart(); final EntityTypeDescriptor rootDescriptor = descriptor.getHierarchy().getRootEntityType(); return session.getFactory().getCache().getEntityRegionAccess( rootDescriptor.getNavigableRole() ).insert( session, ck, cacheEntry, version ); } finally { session.getEventListenerManager().cachePutEnd(); } }
@Override public void preInvalidate( String[] spaces, SharedSessionContractImplementor session) { final SessionFactoryImplementor factory = session.getFactory(); final RegionFactory regionFactory = factory.getCache().getRegionFactory(); final boolean stats = factory.getStatistics().isStatisticsEnabled(); final Long ts = regionFactory.nextTimestamp() + regionFactory.getTimeout(); for ( Serializable space : spaces ) { if ( DEBUG_ENABLED ) { log.debugf( "Pre-invalidating space [%s], timestamp: %s", space, ts ); } try { session.getEventListenerManager().cachePutStart(); //put() has nowait semantics, is this really appropriate? //note that it needs to be async replication, never local or sync timestampsRegion.putIntoCache( space, ts, session ); } finally { session.getEventListenerManager().cachePutEnd(); } if ( stats ) { factory.getStatistics().updateTimestampsCachePut(); } } }
@Override public void invalidate( String[] spaces, SharedSessionContractImplementor session) { final boolean stats = session.getFactory().getStatistics().isStatisticsEnabled(); final Long ts = session.getFactory().getCache().getRegionFactory().nextTimestamp(); for (Serializable space : spaces) { if ( DEBUG_ENABLED ) { log.debugf( "Invalidating space [%s], timestamp: %s", space, ts ); } try { session.getEventListenerManager().cachePutStart(); timestampsRegion.putIntoCache( space, ts, session ); } finally { session.getEventListenerManager().cachePutEnd(); if ( stats ) { session.getFactory().getStatistics().updateTimestampsCachePut(); } } } }
eventListenerManager.cachePutEnd();