@Override public void flush() { delegate.flush(); }
session.flush();
@Test @TestForIssue( jiraKey = "HHH-3930" ) public void testEagerFetchBidirectionalOneToOneWithDirectFetching() { inTransaction( session -> { EntityA a = new EntityA( 1L, new EntityB( 2L ) ); session.persist( a ); session.flush(); session.clear(); // Use atomic integer because we need something mutable final AtomicInteger queryExecutionCount = new AtomicInteger(); session.getEventListenerManager().addListener( new StatisticalLoggingSessionEventListener() { @Override public void jdbcExecuteStatementStart() { super.jdbcExecuteStatementStart(); queryExecutionCount.getAndIncrement(); } } ); session.find( EntityA.class, 1L ); assertEquals( "Join fetching inverse one-to-one didn't use the object already present in the result set!", 1, queryExecutionCount.get() ); } ); }
@Test @TestForIssue( jiraKey = "HHH-3930" ) public void testFetchBidirectionalOneToOneWithOneJoinFetch() { inTransaction( session -> { EntityA a = new EntityA( 1L, new EntityB( 2L ) ); session.persist( a ); session.flush(); session.clear(); // Use atomic integer because we need something mutable final AtomicInteger queryExecutionCount = new AtomicInteger(); session.getEventListenerManager().addListener( new StatisticalLoggingSessionEventListener() { @Override public void jdbcExecuteStatementStart() { super.jdbcExecuteStatementStart(); queryExecutionCount.getAndIncrement(); } } ); session.createQuery( "from EntityA a join fetch a.b" ).list(); assertEquals( "Join fetching inverse one-to-one didn't use the object already present in the result set!", 1, queryExecutionCount.get() ); } ); }
@Test @TestForIssue( jiraKey = "HHH-3930" ) public void testFetchBidirectionalOneToOneWithCircularJoinFetch() { inTransaction( session -> { EntityA a = new EntityA( 1L, new EntityB( 2L ) ); session.persist( a ); session.flush(); session.clear(); // Use atomic integer because we need something mutable final AtomicInteger queryExecutionCount = new AtomicInteger(); session.getEventListenerManager().addListener( new StatisticalLoggingSessionEventListener() { @Override public void jdbcExecuteStatementStart() { super.jdbcExecuteStatementStart(); queryExecutionCount.getAndIncrement(); } } ); session.createQuery( "from EntityA a join fetch a.b b join fetch b.a" ).list(); assertEquals( "Join fetching inverse one-to-one didn't use the object already present in the result set!", 1, queryExecutionCount.get() ); } ); }
nonStrictReadWriteVersionedCacheableItem1.getTags().remove("ORM"); s1.flush(); s1.refresh( readWriteCacheableItem1 ); s1.refresh( readWriteVersionedCacheableItem1 );
@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 testInsertWithClear() { sessionFactory().getCache().evictEntityRegions(); sessionFactory().getStatistics().clear(); inTransaction( sessionFactory, s -> { CacheableItem item = new CacheableItem( "data" ); s.save( item ); s.flush(); s.clear(); } ); assertTrue( sessionFactory().getCache().containsEntity( CacheableItem.class, 1L ) ); inTransaction( sessionFactory, s -> s.createQuery( "delete CacheableItem" ).executeUpdate() ); }
@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 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 ); } ); }
CacheableItem item = new CacheableItem( "data" ); s.save( item ); s.flush(); s.refresh( item ); s.getTransaction().markRollbackOnly();
@Override public void flush() { delegate.flush(); }
public void flush() { ((SessionImplementor) delegate).flush(); }
public void flush() { session.flush(); }
@Override protected Ref<V> onVisionallyRead(K key, QueuedOperationType nullOrOperationType) { SessionImplementor session = this.session; if (session != null && this.hasQueuedOrphans()) { session.flush(); } return this.basePersistence.visionallyRead(key); }
@Override protected Ref<V> onVisionallyRead(K key, QueuedOperationType nullOrOperationType) { SessionImplementor session = this.session; if (session != null && this.hasQueuedOrphans()) { session.flush(); } return this.basePersistence.visionallyRead(key); }
@Override protected int onGetVisionalSize() { SessionImplementor session = this.session; CollectionEntry ce = session .getPersistenceContext() .getCollectionEntry(this.<PersistentMANavigableMap<K, V>>getRootWrapper()); CollectionPersister persister = ce.getLoadedPersister(); if (!persister.isInverse()) { return -1; } if (session != null && this.hasQueuedOrphans()) { session.flush(); } return persister.getSize(ce.getLoadedKey(), session); }
protected Boolean readElementExistence(Object element) { if (!initialized) { throwLazyInitializationExceptionIfNotConnected(); CollectionEntry entry = session.getPersistenceContext().getCollectionEntry(this); CollectionPersister persister = entry.getLoadedPersister(); if ( persister.isExtraLazy() ) { if ( hasQueuedOperations() ) { session.flush(); } return persister.elementExists( entry.getLoadedKey(), element, session ); } } read(); return null; }