@Override public <T> T get(Class<T> theClass, Serializable id, LockMode lockMode) { return delegate.get( theClass, id, lockMode ); }
@Test public void testInsertWithClearThenRollback() { sessionFactory().getCache().evictEntityRegions(); sessionFactory().getStatistics().clear(); inTransaction( sessionFactory, s -> { CacheableItem item = new CacheableItem( "data" ); s.save( item ); s.flush(); s.clear(); item = s.get( CacheableItem.class, item.getId() ); s.getTransaction().markRollbackOnly(); } ); assertFalse( sessionFactory().getCache().containsEntity( CacheableItem.class, 1L ) ); inTransaction( sessionFactory, s -> { final CacheableItem item = s.get( CacheableItem.class, 1L ); assertNull( "it should be null", item ); } ); }
@Override public Object get(String entityName, Serializable id) { return delegate.get( entityName, id ); }
@Override public <T> T get(Class<T> theClass, Serializable id, LockOptions lockOptions) { return delegate.get( theClass, id, lockOptions ); }
@Override public <T> T get(Class<T> theClass, Serializable id) { return delegate.get( theClass, id ); }
@Override public Object get(String entityName, Serializable id, LockOptions lockOptions) { return delegate.get( entityName, id, lockOptions ); }
@Override public Object get(String entityName, Serializable id, LockMode lockMode) { return delegate.get( entityName, id, lockMode ); }
@Test @TestForIssue( jiraKey = "HHH-12150" ) public void testReferenceToAlreadyMappedColumn() { inTransaction( session -> { AddressCapable2 holder = new AddressCapable2( 1, "osd"); Address2 address = new Address2( 1, "123 Main St" ); session.persist( holder ); session.persist( address ); } ); inTransaction( session -> { AddressCapable2 holder = session.get( AddressCapable2.class, 1 ); Address2 address = session.get( Address2.class, 1 ); holder.addresses.put( "work", address ); session.persist( holder ); } ); inTransaction( session -> { AddressCapable2 holder = session.get( AddressCapable2.class, 1 ); assertEquals( 1, holder.addresses.size() ); final Map.Entry<String,Address2> entry = holder.addresses.entrySet().iterator().next(); assertEquals( "work", entry.getKey() ); assertEquals( "work", entry.getValue().type ); session.remove( holder ); } ); }
@Test @TestForIssue( jiraKey = "HHH-12150" ) public void testReferenceToAlreadyMappedColumn() { inTransaction( session -> { AddressCapable2 holder = new AddressCapable2( 1, "osd"); Address2 address = new Address2( 1, "123 Main St" ); session.persist( holder ); session.persist( address ); } ); inTransaction( session -> { AddressCapable2 holder = session.get( AddressCapable2.class, 1 ); Address2 address = session.get( Address2.class, 1 ); holder.addresses.put( "work", address ); session.persist( holder ); } ); inTransaction( session -> { AddressCapable2 holder = session.get( AddressCapable2.class, 1 ); assertEquals( 1, holder.addresses.size() ); final Map.Entry<String,Address2> entry = holder.addresses.entrySet().iterator().next(); assertEquals( "work", entry.getKey() ); assertEquals( null, entry.getValue().type ); session.remove( holder ); } ); }
inTransaction( session -> { AddressCapable2 holder = session.get( AddressCapable2.class, 1 ); Address2 address = session.get( Address2.class, 1 ); inTransaction( session -> { AddressCapable2 holder = session.get( AddressCapable2.class, 1 ); assertEquals( 1, holder.addresses.size() ); final Map.Entry<String,Address2> entry = holder.addresses.entrySet().iterator().next();
@Test @TestForIssue( jiraKey = "HHH-12150" ) public void testReferenceToAlreadyMappedColumn() { inTransaction( session -> { AddressCapable2 holder = new AddressCapable2( 1, "osd"); session.persist( holder ); } ); inTransaction( session -> { AddressCapable2 holder = session.get( AddressCapable2.class, 1 ); Address2 address = new Address2( 1, "123 Main St" ); address.type = "work"; holder.addresses.put( "work", address ); session.persist( holder ); } ); inTransaction( session -> { AddressCapable2 holder = session.get( AddressCapable2.class, 1 ); assertEquals( 1, holder.addresses.size() ); final Map.Entry<String,Address2> entry = holder.addresses.entrySet().iterator().next(); assertEquals( "work", entry.getKey() ); assertEquals( "work", entry.getValue().type ); session.remove( holder ); } ); }
@Test @TestForIssue( jiraKey = "HHH-12150" ) public void testReferenceToNonMappedColumn() { inTransaction( session -> { AddressCapable holder = new AddressCapable( 1, "osd"); Address address = new Address( 1, "123 Main St" ); session.persist( holder ); session.persist( address ); } ); inTransaction( session -> { AddressCapable holder = session.get( AddressCapable.class, 1 ); Address address = session.get( Address.class, 1 ); holder.addresses.put( "work", address ); session.persist( holder ); } ); inTransaction( session -> { AddressCapable holder = session.get( AddressCapable.class, 1 ); assertEquals( 1, holder.addresses.size() ); final Map.Entry<String,Address> entry = holder.addresses.entrySet().iterator().next(); assertEquals( "work", entry.getKey() ); session.remove( holder ); } ); }
@Test @TestForIssue( jiraKey = "HHH-12150" ) public void testReferenceToNonMappedColumn() { inTransaction( session -> { AddressCapable holder = new AddressCapable( 1, "osd"); Address address = new Address( 1, "123 Main St" ); session.persist( holder ); session.persist( address ); } ); inTransaction( session -> { AddressCapable holder = session.get( AddressCapable.class, 1 ); Address address = session.get( Address.class, 1 ); holder.addresses.put( "work", address ); session.persist( holder ); } ); inTransaction( session -> { AddressCapable holder = session.get( AddressCapable.class, 1 ); assertEquals( 1, holder.addresses.size() ); final Map.Entry<String,Address> entry = holder.addresses.entrySet().iterator().next(); assertEquals( "work", entry.getKey() ); session.remove( holder ); } ); }
@Test @TestForIssue( jiraKey = "HHH-12150" ) public void testReferenceToNonMappedColumn() { inTransaction( session -> { AddressCapable holder = new AddressCapable( 1, "osd"); Address address = new Address( 1, "123 Main St" ); session.persist( holder ); session.persist( address ); } ); inTransaction( session -> { AddressCapable holder = session.get( AddressCapable.class, 1 ); Address address = session.get( Address.class, 1 ); address.holder = holder; holder.addresses.put( "work", address ); session.persist( holder ); } ); inTransaction( session -> { AddressCapable holder = session.get( AddressCapable.class, 1 ); assertEquals( 1, holder.addresses.size() ); final Map.Entry<String,Address> entry = holder.addresses.entrySet().iterator().next(); assertEquals( "work", entry.getKey() ); session.remove( holder ); } ); }
@Test @TestForIssue( jiraKey = "HHH-12150" ) public void testReferenceToNonMappedColumn() { inTransaction( session -> { AddressCapable holder = new AddressCapable( 1, "osd"); session.persist( holder ); } ); inTransaction( session -> { AddressCapable holder = session.get( AddressCapable.class, 1 ); holder.addresses.put( "work", new Address( 1, "123 Main St" ) ); session.persist( holder ); } ); inTransaction( session -> { AddressCapable holder = session.get( AddressCapable.class, 1 ); assertEquals( 1, holder.addresses.size() ); final Map.Entry<String,Address> entry = holder.addresses.entrySet().iterator().next(); assertEquals( "work", entry.getKey() ); session.remove( holder ); } ); }
@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 testStrictUnversioned() { sessionFactory = buildSessionFactory( Person.class, true ); final StatisticsImplementor statistics = sessionFactory.getStatistics(); inTransaction( sessionFactory, s -> s.persist( new Person( "1", "John Doe", true ) ) ); // this time it should be iun the cache because we enabled JPA compliance assertEquals( statistics.getSecondLevelCachePutCount(), 1 ); assertTrue( sessionFactory.getCache().contains( Person.class, "1" ) ); inTransaction( sessionFactory, s -> { statistics.clear(); final Person person = s.get( Person.class, "1" ); assertTrue( Hibernate.isInitialized( person ) ); assertThat( statistics.getSecondLevelCacheHitCount(), CoreMatchers.is( 1L) ); statistics.clear(); } ); }
@Test public void testVersioned() { sessionFactory = buildSessionFactory( VersionedPerson.class, false ); final StatisticsImplementor statistics = sessionFactory.getStatistics(); inTransaction( sessionFactory, s -> s.persist( new VersionedPerson( "1", "John Doe", true ) ) ); // versioned data should be cacheable regardless assertEquals( statistics.getSecondLevelCachePutCount(), 1 ); assertTrue( sessionFactory.getCache().contains( VersionedPerson.class, "1" ) ); inTransaction( sessionFactory, s -> { statistics.clear(); final VersionedPerson person = s.get( VersionedPerson.class, "1" ); assertTrue( Hibernate.isInitialized( person ) ); assertThat( statistics.getSecondLevelCacheHitCount(), CoreMatchers.is( 1L ) ); statistics.clear(); } ); }
@Test public void testUnstrictUnversioned() { sessionFactory = buildSessionFactory( Person.class, false ); final StatisticsImplementor statistics = sessionFactory.getStatistics(); inTransaction( sessionFactory, s -> s.persist( new Person( "1", "John Doe", true ) ) ); // it should not be in the cache because it should be invalidated instead assertEquals( statistics.getSecondLevelCachePutCount(), 0 ); assertFalse( sessionFactory.getCache().contains( Person.class, "1" ) ); inTransaction( sessionFactory, s -> { statistics.clear(); final Person person = s.get( Person.class, "1" ); assertTrue( Hibernate.isInitialized( person ) ); assertThat( statistics.getSecondLevelCacheHitCount(), CoreMatchers.is( 0L) ); statistics.clear(); } ); }
@Test public void testOnlySubclassIsCached() { final StatisticsImplementor statistics = sessionFactory().getStatistics(); inTransaction( s -> { s.persist( new Employee( "1", "John Doe", "987", "engineering") ); s.persist( new Customer( "2", "Acme Corp", "123" ) ); } ); assertTrue( sessionFactory().getCache().contains( Employee.class, "1" ) ); assertTrue( sessionFactory().getCache().contains( Person.class, "1" ) ); assertFalse( sessionFactory().getCache().contains( Customer.class, "2" ) ); assertFalse( sessionFactory().getCache().contains( Person.class, "2" ) ); inTransaction( s -> { statistics.clear(); final Customer customer = s.get( Customer.class, "2" ); assertTrue( Hibernate.isInitialized( customer ) ); assertThat( statistics.getSecondLevelCacheHitCount(), CoreMatchers.is(0L) ); statistics.clear(); final Employee emp = s.get( Employee.class, "1" ); assertTrue( Hibernate.isInitialized( emp ) ); assertThat( statistics.getSecondLevelCacheHitCount(), CoreMatchers.is(1L) ); } ); }