@Override public void jdbcPrepareStatementStart() { session.getEventListenerManager().jdbcPrepareStatementStart(); }
@Override public void jdbcExecuteBatchStart() { session.getEventListenerManager().jdbcExecuteBatchStart(); }
@Override public void jdbcExecuteStatementStart() { session.getEventListenerManager().jdbcExecuteStatementStart(); }
@Override public void jdbcExecuteStatementEnd() { session.getEventListenerManager().jdbcExecuteStatementEnd(); }
@Override public void jdbcExecuteBatchEnd() { session.getEventListenerManager().jdbcExecuteBatchEnd(); }
private CacheItem getCachedData(QueryKey key, SharedSessionContractImplementor session) { CacheItem cachedItem = null; try { session.getEventListenerManager().cacheGetStart(); cachedItem = (CacheItem) cacheRegion.getFromCache( key, session ); } finally { session.getEventListenerManager().cacheGetEnd( cachedItem != null ); } return cachedItem; }
private Long getLastUpdateTimestampForSpace(Serializable space, SharedSessionContractImplementor session) { Long ts = null; try { session.getEventListenerManager().cacheGetStart(); ts = (Long) timestampsRegion.getFromCache( space, session ); } finally { session.getEventListenerManager().cacheGetEnd( ts != null ); } return ts; }
@Override public void jdbcPrepareStatementEnd() { for ( ConnectionObserver observer : observers ) { observer.statementPrepared(); } session.getEventListenerManager().jdbcPrepareStatementEnd(); }
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(); } }
public static Serializable fromSharedCache( SharedSessionContractImplementor session, Object cacheKey, CachedDomainDataAccess cacheAccess) { final SessionEventListenerManager eventListenerManager = session.getEventListenerManager(); Serializable cachedValue = null; eventListenerManager.cacheGetStart(); try { cachedValue = (Serializable) cacheAccess.get( session, cacheKey ); } finally { eventListenerManager.cacheGetEnd( cachedValue != null ); } return cachedValue; }
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(); } }
session.getEventListenerManager().cachePutStart(); cacheRegion.putIntoCache( key, cacheItem, session ); 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(); } } }
final SessionEventListenerManager statsCollector = session.getEventListenerManager();
.getService( JdbcServices.class ) .getSqlStatementLogger(); final SessionEventListenerManager statsCollector = session.getEventListenerManager();
.getService( JdbcServices.class ) .getSqlStatementLogger(); final SessionEventListenerManager statsCollector = session.getEventListenerManager();
session.getEventListenerManager().cachePutStart(); final boolean put = cacheAccess.putFromLoad( session, session.getEventListenerManager().cachePutEnd();