@Override public void doAfterTransactionCompletion(boolean success, SharedSessionContractImplementor session) throws HibernateException { final EntityPersister persister = getPersister(); if ( success && isCachePutEnabled( persister, getSession() ) ) { final EntityDataAccess cache = persister.getCacheAccessStrategy(); SessionFactoryImplementor factory = session.getFactory(); final Object ck = cache.generateCacheKey( getId(), persister, factory, session.getTenantIdentifier() ); final boolean put = cacheAfterInsert( cache, ck ); if ( put && factory.getStatistics().isStatisticsEnabled() ) { factory.getStatistics().entityCachePut( StatsHelper.INSTANCE.getRootEntityRole( persister ), cache.getRegion().getName() ); } } postCommitInsert( success ); }
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(); } }
@Override public boolean containsEntity(String entityName, Serializable identifier) { final EntityPersister entityDescriptor = sessionFactory.getMetamodel().entityPersister( entityName ); final EntityDataAccess cacheAccess = entityDescriptor.getCacheAccessStrategy(); if ( cacheAccess == null ) { return false; } final Object key = cacheAccess.generateCacheKey( identifier, entityDescriptor, sessionFactory, null ); return cacheAccess.contains( key ); }
@Override public void evictEntityData(String entityName, Serializable identifier) { final EntityPersister entityDescriptor = sessionFactory.getMetamodel().entityPersister( entityName ); final EntityDataAccess cacheAccess = entityDescriptor.getCacheAccessStrategy(); if ( cacheAccess == null ) { return; } if ( LOG.isDebugEnabled() ) { LOG.debugf( "Evicting second-level cache: %s", MessageHelper.infoString( entityDescriptor, identifier, sessionFactory ) ); } final Object key = cacheAccess.generateCacheKey( identifier, entityDescriptor, sessionFactory, null ); cacheAccess.evict( key ); }
@Override public void doAfterTransactionCompletion(boolean success, SharedSessionContractImplementor session) throws HibernateException { EntityPersister entityPersister = getPersister(); if ( entityPersister.canWriteToCache() ) { EntityDataAccess cache = entityPersister.getCacheAccessStrategy(); final Object ck = cache.generateCacheKey( getId(), entityPersister, session.getFactory(), session.getTenantIdentifier() ); cache.unlockItem( session, ck, lock ); } postCommitDelete( success ); }
if ( persister.canWriteToCache() ) { final EntityDataAccess cache = persister.getCacheAccessStrategy(); ck = cache.generateCacheKey( id, persister, session.getTenantIdentifier() ); lock = cache.lockItem( session, ck, previousVersion ); persister.getCacheAccessStrategy().remove( session, ck); factory.getStatistics().entityCachePut( StatsHelper.INSTANCE.getRootEntityRole( persister ), getPersister().getCacheAccessStrategy().getRegion().getName() );
final CacheEntry entry = persister.buildCacheEntry( entity, hydratedState, version, session ); final EntityDataAccess cache = persister.getCacheAccessStrategy(); final Object cacheKey = cache.generateCacheKey( id, persister, factory, session.getTenantIdentifier() ); cache.update( session, cacheKey, try { eventListenerManager.cachePutStart(); final boolean put = cache.putFromLoad( session, cacheKey, factory.getStatistics().entityCachePut( StatsHelper.INSTANCE.getRootEntityRole( persister ), cache.getRegion().getName() );
final EntityDataAccess cache = persister.getCacheAccessStrategy(); if ( persister.canWriteToCache() ) { ck = cache.generateCacheKey( event.getEntityId(), persister, source.getTenantIdentifier() ); lock = persister.getCacheAccessStrategy().lockItem( source, ck, null ); cache.unlockItem( source, ck, lock );
@Override public void doAfterTransactionCompletion(boolean success, SharedSessionContractImplementor session) throws CacheException { final EntityPersister persister = getPersister(); if ( persister.canWriteToCache() ) { final EntityDataAccess cache = persister.getCacheAccessStrategy(); final Object ck = cache.generateCacheKey( getId(), persister, session.getFactory(), session.getTenantIdentifier() ); if ( success && cacheEntry != null && !persister.isCacheInvalidationRequired() && session.getCacheMode().isPutEnabled() ) { final boolean put = cacheAfterUpdate( cache, ck ); if ( put && getSession().getFactory().getStatistics().isStatisticsEnabled() ) { session.getFactory().getStatistics().entityCachePut( StatsHelper.INSTANCE.getRootEntityRole( persister ), getPersister().getCacheAccessStrategy().getRegion().getName() ); } } else { cache.unlockItem(session, ck, lock ); } } postCommitUpdate( success ); }
public void basicCacheStructureTest() { EntityPersister persister = sessionFactory().getMetamodel().entityPersisters().get( Address.class.getName() ); final DomainDataRegion region = persister.getCacheAccessStrategy().getRegion(); s -> { final EntityDataAccess entityDataAccess = region.getEntityDataAccess( persister.getNavigableRole() ); final Object cacheKey = entityDataAccess.generateCacheKey( 1, persister, null ); final Object cachedItem = entityDataAccess.get( s, cacheKey ); final StandardCacheEntryImpl state = (StandardCacheEntryImpl) cachedItem; s -> { final EntityDataAccess entityDataAccess = region.getEntityDataAccess( persister.getNavigableRole() ); final Object cacheKey = entityDataAccess.generateCacheKey( 1, persister, null ); final Object cachedItem = entityDataAccess.get( s, cacheKey ); final StandardCacheEntryImpl state = (StandardCacheEntryImpl) cachedItem;
final Object ck = cache.generateCacheKey( id, persister, source.getTenantIdentifier() ); final SoftLock lock = cache.lockItem( source, ck, previousVersion ); cache.remove( source, ck ); source.getActionQueue().registerProcess( (success, session) -> cache.unlockItem( session, ck, lock ) );
if ( persister.canWriteToCache() ) { final EntityDataAccess cache = persister.getCacheAccessStrategy(); ck = cache.generateCacheKey( id, persister, session.getFactory(), session.getTenantIdentifier() ); lock = cache.lockItem( session, ck, version ); persister.getCacheAccessStrategy().remove( session, ck);
EntityStatisticsImpl(EntityPersister rootEntityDescriptor) { super( () -> rootEntityDescriptor.getCacheAccessStrategy() != null ? rootEntityDescriptor.getCacheAccessStrategy().getRegion() : null ); this.rootEntityName = rootEntityDescriptor.getRootEntityName(); }
private boolean isCached(EntityKey entityKey, EntityPersister persister) { final SharedSessionContractImplementor session = context.getSession(); if ( context.getSession().getCacheMode().isGetEnabled() && persister.canReadFromCache() ) { final EntityDataAccess cache = persister.getCacheAccessStrategy(); final Object key = cache.generateCacheKey( entityKey.getIdentifier(), persister, session.getFactory(), session.getTenantIdentifier() ); return CacheHelper.fromSharedCache( session, key, cache ) != null; } return false; }
final Object cacheKey = entityDataAccess.generateCacheKey( d.id, persister, null ); final Object cachedItem = entityDataAccess.get( (SharedSessionContractImplementor) s, cacheKey ); assertNotNull( cachedItem ); assertTyping( StandardCacheEntryImpl.class, cachedItem );
@Override public void clear() { for ( EntityDataAccess cacheAccess : entityDataAccessMap.values() ) { cacheAccess.evictAll(); } for ( NaturalIdDataAccess cacheAccess : naturalIdDataAccessMap.values() ) { cacheAccess.evictAll(); } for ( CollectionDataAccess cacheAccess : collectionDataAccessMap.values() ) { cacheAccess.evictAll(); } }
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(); } }
if ( entityDescriptor.canWriteToCache() ) { final EntityDataAccess cache = entityDescriptor.getHierarchy().getEntityCacheAccess(); ck = cache.generateCacheKey( id, entityDescriptor.getHierarchy(), session.getTenantIdentifier() ); lock = cache.lockItem( session, ck, previousVersion ); entityDescriptor.getHierarchy().getEntityCacheAccess().remove( session, ck); factory.getStatistics().entityCachePut( entityDescriptor.getNavigableRole(), entityDescriptor.getHierarchy().getEntityCacheAccess().getRegion().getName() );
final Object cacheKey = cacheAccess.generateCacheKey( entityIdentifier, entityDescriptor.getHierarchy(), cacheAccess.update( session, cacheKey, try { eventListenerManager.cachePutStart(); final boolean put = cacheAccess.putFromLoad( session, cacheKey, factory.getStatistics().entityCachePut( entityDescriptor.getNavigableRole(), cacheAccess.getRegion().getName() );