How to use

flush

method

in

org.hibernate.engine.spi.SessionImplementor

@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 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()
    );
  } );
}

@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()
    );
  } );
}

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;
  
}