How to use

TransactionCoordinator

in

org.hibernate.engine.transaction.spi

@Override
public boolean isConnected() {
  return transactionCoordinator.getJdbcCoordinator().getLogicalConnection().isPhysicallyConnected();
}

  @Override
  public boolean shouldDoManagedFlush(TransactionCoordinator coordinator, int jtaStatus) {
    return ! coordinator.getTransactionContext().isClosed() &&
        ! coordinator.getTransactionContext().isFlushModeNever() &&
        coordinator.getTransactionContext().isFlushBeforeCompletionEnabled() &&
        ! JtaStatusHelper.isRollback( jtaStatus );
  }
};

@Override
protected void afterTransactionBegin() {
  transactionCoordinator().pulse();
  if ( !transactionCoordinator().isSynchronizationRegistered() ) {
    isDriver = transactionCoordinator().takeOwnership();
  }
  applyTimeout();
  transactionCoordinator().sendAfterTransactionBeginNotifications( this );
  transactionCoordinator().getTransactionContext().afterTransactionBegin( this );
}

public void afterOperation(boolean success) {
  if ( ! transactionCoordinator.isTransactionInProgress() ) {
    transactionCoordinator.afterNonTransactionalQuery( success );
  }
}

@Override
public void checkTransactionSynchStatus(SessionImplementor session) {
  TransactionCoordinator coordinator = session.getTransactionCoordinator();
  coordinator.pulse();
  coordinator.getSynchronizationCallbackCoordinator().processAnyDelayedAfterCompletion();
}

protected void createTemporaryTableIfNecessary(final Queryable persister, final SessionImplementor 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( persister );
  if ( shouldIsolateTemporaryTableDDL() ) {
    session.getTransactionCoordinator()
        .getTransaction()
        .createIsolationDelegate()
        .delegateWork( work, getFactory().getSettings().isDataDefinitionInTransactionSupported() );
  }
  else {
    final Connection connection = session.getTransactionCoordinator()
        .getJdbcCoordinator()
        .getLogicalConnection()
        .getShareableConnectionProxy();
    work.execute( connection );
    session.getTransactionCoordinator()
        .getJdbcCoordinator()
        .getLogicalConnection()
        .afterStatementExecution();
  }
}

@Override
protected void afterTransactionBegin() {
  if ( getTimeout() > 0 ) {
    transactionCoordinator().getJdbcCoordinator().setTransactionTimeOut( getTimeout() );
  }
  transactionCoordinator().sendAfterTransactionBeginNotifications( this );
  if ( isDriver ) {
    transactionCoordinator().getTransactionContext().afterTransactionBegin( this );
  }
}

@Override
public void afterTransaction(SessionImplementor session, boolean success) {
  TransactionCoordinator coordinator = session.getTransactionCoordinator();
  if (!session.isTransactionInProgress() ) {
    coordinator.getJdbcCoordinator().afterTransaction();
  }
  coordinator.getSynchronizationCallbackCoordinator().processAnyDelayedAfterCompletion();
}

final TransactionImplementor transaction = transactionCoordinator.getTransaction();
transactionCoordinator.pulse();
if ( ! transactionCoordinator.isTransactionJoinable() ) {
  if ( explicitRequest ) {
  SynchronizationCallbackCoordinator callbackCoordinator = transactionCoordinator.getSynchronizationCallbackCoordinator();
  callbackCoordinator.setManagedFlushChecker( new ManagedFlushCheckerImpl() );
  callbackCoordinator.setExceptionMapper( new CallbackExceptionMapperImpl() );

@Override
public Transaction getTransaction() throws HibernateException {
  errorIfClosed();
  return transactionCoordinator.getTransaction();
}

@Override
protected void afterTransactionBegin() {
  if ( ! transactionCoordinator().isSynchronizationRegistered() ) {
    throw new TransactionException("Could not register synchronization for container transaction");
  }
  transactionCoordinator().sendAfterTransactionBeginNotifications( this );
  transactionCoordinator().getTransactionContext().afterTransactionBegin( this );
}

@Override
protected void doBegin() {
  try {
    if ( managedConnection != null ) {
      throw new TransactionException( "Already have an associated managed connection" );
    }
    managedConnection = transactionCoordinator().getJdbcCoordinator().getLogicalConnection().getConnection();
    wasInitiallyAutoCommit = managedConnection.getAutoCommit();
    LOG.debugv( "initial autocommit status: {0}", wasInitiallyAutoCommit );
    if ( wasInitiallyAutoCommit ) {
      LOG.debug( "disabling autocommit" );
      managedConnection.setAutoCommit( false );
    }
  }
  catch( SQLException e ) {
    throw new TransactionException( "JDBC begin transaction failed: ", e );
  }
  isDriver = transactionCoordinator().takeOwnership();
}

@Override
protected void beforeTransactionCommit() {
  transactionCoordinator().sendBeforeTransactionCompletionNotifications( this );
  // basically, if we are the driver of the transaction perform a managed flush prior to
  // physically committing the transaction
  if ( isDriver && !transactionCoordinator().getTransactionContext().isFlushModeNever() ) {
    // if an exception occurs during flush, user must call rollback()
    transactionCoordinator().getTransactionContext().managedFlush();
  }
  if ( isDriver ) {
    transactionCoordinator().getTransactionContext().beforeTransactionCompletion( this );
  }
}

@Override
protected void doBegin() {
  transactionCoordinator().pulse();
}

@Override
protected void afterTransactionCompletion(int status) {
  transactionCoordinator().afterTransaction( this, status );
}

@Override
public void managedClose() {
  if ( isClosed() ) {
    throw new SessionException( "Session was already closed!" );
  }
  transactionCoordinator.close();
  setClosed();
}

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

protected void createTemporaryTableIfNecessary(final Queryable persister, final SessionImplementor 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( persister );
  if ( shouldIsolateTemporaryTableDDL() ) {
    session.getTransactionCoordinator()
        .getTransaction()
        .createIsolationDelegate()
        .delegateWork( work, getFactory().getSettings().isDataDefinitionInTransactionSupported() );
  }
  else {
    final Connection connection = session.getTransactionCoordinator()
        .getJdbcCoordinator()
        .getLogicalConnection()
        .getShareableConnectionProxy();
    work.execute( connection );
    session.getTransactionCoordinator()
        .getJdbcCoordinator()
        .getLogicalConnection()
        .afterStatementExecution();
  }
}

@Override
protected void afterTransactionBegin() {
  if ( getTimeout() > 0 ) {
    transactionCoordinator().getJdbcCoordinator().setTransactionTimeOut( getTimeout() );
  }
  transactionCoordinator().sendAfterTransactionBeginNotifications( this );
  if ( isDriver ) {
    transactionCoordinator().getTransactionContext().afterTransactionBegin( this );
  }
}

@Override
public void afterTransaction(SessionImplementor session, boolean success) {
  TransactionCoordinator coordinator = session.getTransactionCoordinator();
  if (!session.isTransactionInProgress() ) {
    coordinator.getJdbcCoordinator().afterTransaction();
  }
  coordinator.getSynchronizationCallbackCoordinator().processAnyDelayedAfterCompletion();
}