@Override public CacheImplementor getCache() { return delegate.getCache(); }
protected void cleanupCache() { if ( sessionFactory != null ) { sessionFactory.getCache().evictAllRegions(); } }
@Override public String[] getSecondLevelCacheRegionNames() { if ( sessionFactory == null ) { throw new IllegalStateException( "Statistics no longer associated with SessionFactory - cannot get (legacy) region names" ); } return sessionFactory.getCache().getSecondLevelCacheRegionNames(); }
protected void cleanupCache() { if ( sessionFactory != null ) { sessionFactory.getCache().evictAllRegions(); } }
@Override public DeprecatedNaturalIdCacheStatisticsImpl getNaturalIdCacheStatistics(String regionName) { return deprecatedNaturalIdStatsMap.computeIfAbsent( sessionFactory.getCache().unqualifyRegionName( regionName ), unqualifiedRegionName -> new DeprecatedNaturalIdCacheStatisticsImpl( unqualifiedRegionName, sessionFactory.getCache().getNaturalIdAccessesInRegion( unqualifiedRegionName ) ) ); }
@Override public CacheRegionStatisticsImpl getSecondLevelCacheStatistics(String regionName) { if ( sessionFactory == null ) { return null; } return getCacheRegionStatistics( sessionFactory.getCache().unqualifyRegionName( regionName ) ); }
private CacheRegionStatisticsImpl getQueryRegionStats(String regionName) { return l2CacheStatsMap.computeIfAbsent( regionName, s -> new CacheRegionStatisticsImpl( sessionFactory.getCache().getQueryResultsCache( regionName ).getRegion() ) ); }
@Override public CacheRegionStatisticsImpl getQueryRegionStatistics(String regionName) { final CacheRegionStatisticsImpl existing = l2CacheStatsMap.get( regionName ); if ( existing != null ) { return existing; } if ( sessionFactory == null ) { return null; } final QueryResultsCache regionAccess = sessionFactory.getCache() .getQueryResultsCacheStrictly( regionName ); if ( regionAccess == null ) { return null; } return l2CacheStatsMap.computeIfAbsent( regionName, s -> new CacheRegionStatisticsImpl( regionAccess.getRegion() ) ); }
@Test public void testValidCall() { MatcherAssert.assertThat( sessionFactory().getCache().unqualifyRegionName( PREFIX + '.' + LOCAL_NAME ), CoreMatchers.is( LOCAL_NAME ) ); }
protected void clearCache() { sessionFactory().getCache().evictQueryRegions(); }
public static Cache getCache(SessionFactoryImplementor sessionFactoryImplementor, String regionName) { final RegionFactory regionFactory = sessionFactoryImplementor.getCache().getRegionFactory(); final EhcacheRegionFactory ehcacheRegionFactory = (EhcacheRegionFactory) regionFactory; final CacheManager cacheManager = ehcacheRegionFactory.getCacheManager(); regionName = prefix( regionName ); return cacheManager.getCache( regionName ); }
/** * This method is now called once per execution of an ExecutableList or once for execution of an Execution. * * @param spaces The spaces to invalidate */ private void invalidateSpaces(String... spaces) { if ( spaces != null && spaces.length > 0 ) { for ( Serializable s : spaces ) { if( afterTransactionProcesses == null ) { afterTransactionProcesses = new AfterTransactionCompletionProcessQueue( session ); } afterTransactionProcesses.addSpaceToInvalidate( (String) s ); } // Performance win: If we are processing an ExecutableList, this will only be called once session.getFactory().getCache().getTimestampsCache().preInvalidate( spaces, session ); } }
@Test public void testUnqualifiedNameUsed() { try { sessionFactory().getCache().unqualifyRegionName( LOCAL_NAME ); } catch (IllegalArgumentException expected) { } } }
@Test public void test() { CacheImplementor cacheImplementor = sessionFactory().getCache(); EhcacheRegionFactory regionFactory = (EhcacheRegionFactory) cacheImplementor.getRegion( Event.class.getName() ).getRegionFactory(); assertEquals( TimeUnit.SECONDS.toMillis( 1 ) * SimpleTimestamper.ONE_MS, regionFactory.getTimeout() ); }
@Test public void testInsertWithRollback() { sessionFactory().getCache().evictEntityRegions(); sessionFactory().getStatistics().clear(); inTransaction( sessionFactory, s -> { CacheableItem item = new CacheableItem( "data" ); s.save( item ); s.flush(); s.getTransaction().markRollbackOnly(); } ); assertFalse( sessionFactory().getCache().containsEntity( CacheableItem.class, 1L ) ); }
@Test public void testInsertThenUpdateThenRollback() { sessionFactory().getCache().evictEntityRegions(); sessionFactory().getStatistics().clear(); inTransaction( sessionFactory, s -> { CacheableItem item = new CacheableItem( "data" ); s.save( item ); s.flush(); item.setName( "new data" ); s.getTransaction().markRollbackOnly(); } ); assertFalse( sessionFactory().getCache().containsEntity( CacheableItem.class, 1L ) ); }
@Test public void testOnlySubclassIsCached() { final StatisticsImplementor statistics = sessionFactory().getStatistics(); inTransaction( s -> s.persist( new Customer( 1, "Acme Corp", "123" ) ) ); assertTrue( sessionFactory().getCache().contains( Customer.class, 1 ) ); inTransaction( s -> { statistics.clear(); final Customer customer = s.get( Customer.class, 1 ); assertTrue( Hibernate.isInitialized( customer ) ); assertThat( statistics.getSecondLevelCacheHitCount(), CoreMatchers.is(1L) ); } ); }
@Test public void testInsertWithRefresh() { sessionFactory().getCache().evictEntityRegions(); sessionFactory().getStatistics().clear(); inTransaction( sessionFactory, s -> { CacheableItem item = new CacheableItem( "data" ); s.save( item ); s.flush(); s.refresh( item ); } ); assertTrue( sessionFactory().getCache().containsEntity( CacheableItem.class, 1L ) ); inTransaction( sessionFactory, s -> s.createQuery( "delete CacheableItem" ).executeUpdate() ); }
@Test public void testInsertThenUpdate() { sessionFactory().getCache().evictEntityRegions(); sessionFactory().getStatistics().clear(); inTransaction( sessionFactory, s -> { CacheableItem item = new CacheableItem( "data" ); s.save( item ); s.flush(); item.setName( "new data" ); } ); assertTrue( sessionFactory().getCache().containsEntity( CacheableItem.class, 1L ) ); inTransaction( sessionFactory, s -> s.createQuery( "delete CacheableItem" ).executeUpdate() ); }
@Test public void testOneToOneCache() throws HibernateException { //create a new MainObject createMainObject(); // load the MainObject readMainObject(); //create and add Ojbect2 addObject2(); //here the newly created Object2 is written to the database //but the MainObject does not know it yet MainObject mainObject = readMainObject(); assertNotNull( mainObject.getObj2() ); // after evicting, it works. sessionFactory().getCache().evictEntityRegion( MainObject.class ); mainObject = readMainObject(); assertNotNull( mainObject.getObj2() ); }