How to use org.hibernate.engine.transaction.spi

private boolean isTransactionFlushable() {
  if ( getCurrentTransaction() == null ) {
    // assume it is flushable - CMT, auto-commit, etc
    return true;
  }
  final TransactionStatus status = getCurrentTransaction().getStatus();
  return status == TransactionStatus.ACTIVE || status == TransactionStatus.COMMITTING;
}

public IntegralDataTypeHolder getNextValue() {
  return session.getTransactionCoordinator().createIsolationDelegate().delegateWork(
      work,
      true
  );
}

  @Test
  public void testMarkRollbackOnlyAnActiveTransaction() {
    EntityTransaction transaction = entityManager.getTransaction();
    final TransactionImplementor hibernateTransaction = (TransactionImplementor) transaction;
    transaction.begin();
    hibernateTransaction.markRollbackOnly();
    transaction.rollback();
    assertFalse( transaction.isActive() );
  }
}

/**
 * Provide subclasses with convenient access to the configured {@link JtaPlatform}
 *
 * @return The {@link org.hibernate.service.jta.platform.spi.JtaPlatform}
 */
protected JtaPlatform jtaPlatform() {
  return transactionCoordinator().getTransactionContext().getTransactionEnvironment().getJtaPlatform();
}

protected ConnectionProvider connectionProvider() {
  return transactionCoordinator.getTransactionContext()
      .getTransactionEnvironment()
      .getJdbcServices()
      .getConnectionProvider();
}

  @Override
  public void afterCompletion(boolean successful, boolean delayed) {
    if ( !transactionCoordinatorOwner.isActive() ) {
      return;
    }

    final int statusToSend =  successful ? Status.STATUS_COMMITTED : Status.STATUS_UNKNOWN;
    synchronizationRegistry.notifySynchronizationsAfterTransactionCompletion( statusToSend );

//        afterCompletionAction.doAction( this, statusToSend );

    transactionCoordinatorOwner.afterTransactionCompletion( successful, delayed );

    for ( TransactionObserver observer : observers() ) {
      observer.afterCompletion( successful, delayed );
    }

    synchronizationRegistered = false;
  }

@Override
public void beforeCompletion() {
  try {
    transactionCoordinatorOwner.beforeTransactionCompletion();
  }
  catch (HibernateException e) {
    physicalTransactionDelegate.markRollbackOnly();
    throw e;
  }
  catch (RuntimeException re) {
    physicalTransactionDelegate.markRollbackOnly();
    throw re;
  }
  finally {
    synchronizationRegistry.notifySynchronizationsBeforeTransactionCompletion();
    for ( TransactionObserver observer : observers() ) {
      observer.beforeCompletion();
    }
  }
}

@Override
public void registerSynchronization(Synchronization synchronization) {
  transactionCoordinator().getSynchronizationRegistry().registerSynchronization( synchronization );
}

private void afterBeginCallback() {
  if(this.timeOut > 0) {
    transactionCoordinatorOwner.setTransactionTimeOut( this.timeOut );
  }
  // report entering into a "transactional context"
  transactionCoordinatorOwner.startTransactionBoundary();
  // trigger the Transaction-API-only after-begin callback
  transactionCoordinatorOwner.afterTransactionBegin();
  // notify all registered observers
  for ( TransactionObserver observer : observers() ) {
    observer.afterBegin();
  }
  log.trace( "ResourceLocalTransactionCoordinatorImpl#afterBeginCallback" );
}

currentHibernateTransaction.invalidate();

/**
 * Provide subclasses with convenient access to the configured {@link JtaPlatform}
 *
 * @return The {@link org.hibernate.service.jta.platform.spi.JtaPlatform}
 */
protected JtaPlatform jtaPlatform() {
  return transactionCoordinator().getTransactionContext().getTransactionEnvironment().getJtaPlatform();
}

protected SqlExceptionHelper sqlExceptionHelper() {
  return transactionCoordinator.getTransactionContext()
      .getTransactionEnvironment()
      .getJdbcServices()
      .getSqlExceptionHelper();
}

@Override
public IntegralDataTypeHolder getNextValue() {
  return session.getTransactionCoordinator().createIsolationDelegate().delegateWork(
      new AbstractReturningWork<IntegralDataTypeHolder>() {
        @Override

private void afterCompletionCallback(boolean successful) {
  log.tracef( "ResourceLocalTransactionCoordinatorImpl#afterCompletionCallback(%s)", successful );
  final int statusToSend = successful ? Status.STATUS_COMMITTED : Status.STATUS_UNKNOWN;
  synchronizationRegistry.notifySynchronizationsAfterTransactionCompletion( statusToSend );
  transactionCoordinatorOwner.afterTransactionCompletion( successful, false );
  for ( TransactionObserver observer : observers() ) {
    observer.afterCompletion( successful, false );
  }
}

private void beforeCompletionCallback() {
  log.trace( "ResourceLocalTransactionCoordinatorImpl#beforeCompletionCallback" );
  try {
    transactionCoordinatorOwner.beforeTransactionCompletion();
    synchronizationRegistry.notifySynchronizationsBeforeTransactionCompletion();
    for ( TransactionObserver observer : observers() ) {
      observer.beforeCompletion();
    }
  }
  catch (RuntimeException e) {
    if ( physicalTransactionDelegate != null ) {
      // should never happen that the physicalTransactionDelegate is null, but to be safe
      physicalTransactionDelegate.markRollbackOnly();
    }
    throw e;
  }
}

@Test
public void testMarkRollbackOnlyAnUnactiveTransaction() {
  EntityTransaction transaction = entityManager.getTransaction();
  final TransactionImplementor hibernateTransaction = (TransactionImplementor) transaction;
  hibernateTransaction.markRollbackOnly();
  transaction.rollback();
  assertFalse( transaction.isActive() );
}

@Override
public IntegralDataTypeHolder getNextValue() {
  return session.getTransactionCoordinator().createIsolationDelegate().delegateWork(
      new AbstractReturningWork<IntegralDataTypeHolder>() {
        @Override

public void createTempTable(
    IdTableInfoImpl idTableInfo,
    TempTableDdlTransactionHandling ddlTransactionHandling,
    SharedSessionContractImplementor session) {
  // Don't really know all the codes required to adequately decipher returned jdbc exceptions here.
  // simply allow the failure to be eaten and the subsequent insert-selects/deletes should fail
  TemporaryTableCreationWork work = new TemporaryTableCreationWork( idTableInfo, session.getFactory() );
  if ( ddlTransactionHandling == TempTableDdlTransactionHandling.NONE ) {
    final Connection connection = session.getJdbcCoordinator()
        .getLogicalConnection()
        .getPhysicalConnection();
    work.execute( connection );
    session.getJdbcCoordinator().afterStatementExecution();
  }
  else {
    session.getTransactionCoordinator()
        .createIsolationDelegate()
        .delegateWork( work, ddlTransactionHandling == TempTableDdlTransactionHandling.ISOLATE_AND_TRANSACT );
  }
}

value = session.getTransactionCoordinator().createIsolationDelegate().delegateWork( work, true );

session.getTransactionCoordinator()
    .createIsolationDelegate()
    .delegateWork( work, ddlTransactionHandling == TempTableDdlTransactionHandling.ISOLATE_AND_TRANSACT );