EntityStatisticsImpl(EntityPersister rootEntityDescriptor) { super( () -> rootEntityDescriptor.getCacheAccessStrategy() != null ? rootEntityDescriptor.getCacheAccessStrategy().getRegion() : null ); this.rootEntityName = rootEntityDescriptor.getRootEntityName(); }
@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 ); }
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(); } }
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(); } }
protected void evictEntityData(EntityPersister entityDescriptor) { EntityPersister rootEntityDescriptor = entityDescriptor; if ( entityDescriptor.isInherited() && ! entityDescriptor.getEntityName().equals( entityDescriptor.getRootEntityName() ) ) { rootEntityDescriptor = getSessionFactory().getMetamodel().entityPersister( entityDescriptor.getRootEntityName() ); } evictEntityData( rootEntityDescriptor.getNavigableRole(), rootEntityDescriptor.getCacheAccessStrategy() ); }
entityCleanups.add( new EntityCleanup( persister.getCacheAccessStrategy(), session ) );
@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 ); }
SoftLock lock = null; final Object ck; final EntityDataAccess cache = persister.getCacheAccessStrategy(); if ( persister.canWriteToCache() ) { ck = cache.generateCacheKey( source.getTenantIdentifier() ); lock = persister.getCacheAccessStrategy().lockItem( source, ck, null );
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; }
sessionFactory().getMetamodel().entityPersister( VersionedItem.class ).getCacheAccessStrategy().getAccessType(), equalTo( AccessType.READ_WRITE ) ); sessionFactory().getMetamodel().entityPersister( Event.class ).getCacheAccessStrategy().getAccessType(), equalTo( AccessType.READ_WRITE ) );
private Object getFromSharedCache( final LoadEvent event, final EntityPersister persister, SessionImplementor source) { final EntityDataAccess cache = persister.getCacheAccessStrategy(); final Object ck = cache.generateCacheKey( event.getEntityId(), persister, source.getFactory(), source.getTenantIdentifier() ); final Object ce = CacheHelper.fromSharedCache( source, ck, persister.getCacheAccessStrategy() ); if ( source.getFactory().getStatistics().isStatisticsEnabled() ) { if ( ce == null ) { source.getFactory().getStatistics().entityCacheMiss( StatsHelper.INSTANCE.getRootEntityRole( persister ), cache.getRegion().getName() ); } else { source.getFactory().getStatistics().entityCacheHit( StatsHelper.INSTANCE.getRootEntityRole( persister ), cache.getRegion().getName() ); } } return ce; }
@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 ); }
@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 ); }
.getCacheAccessStrategy() .getRegion(); final Object fromCache = region.getCacheStorageAccess().getFromCache(
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);
final EntityDataAccess cacheAccess = persister.getCacheAccessStrategy(); if ( cacheAccess != null ) { final Object ck = cacheAccess.generateCacheKey(
assertTrue( persister.canReadFromCache() ); assertTrue( persister.canWriteToCache() ); assertNotNull( persister.getCacheAccessStrategy() );
assertTrue( isPropertyInitialized( d, "summary" ) ); final EntityDataAccess entityDataAccess = persister.getCacheAccessStrategy(); final Object cacheKey = entityDataAccess.generateCacheKey( d.id,
); cacheEntry = persister.getCacheEntryStructure().structure( ce ); final EntityDataAccess cache = persister.getCacheAccessStrategy(); final Object ck = cache.generateCacheKey( id, persister, factory, session.getTenantIdentifier() );