Tabnine Logo
org.hibernate.engine.transaction.spi
Code IndexAdd Tabnine to your IDE (free)

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

Best Java code snippets using org.hibernate.engine.transaction.spi (Showing top 20 results out of 315)

origin: hibernate/hibernate-orm

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;
}
origin: hibernate/hibernate-orm

public IntegralDataTypeHolder getNextValue() {
  return session.getTransactionCoordinator().createIsolationDelegate().delegateWork(
      work,
      true
  );
}
origin: hibernate/hibernate-orm

  @Test
  public void testMarkRollbackOnlyAnActiveTransaction() {
    EntityTransaction transaction = entityManager.getTransaction();
    final TransactionImplementor hibernateTransaction = (TransactionImplementor) transaction;
    transaction.begin();
    hibernateTransaction.markRollbackOnly();
    transaction.rollback();
    assertFalse( transaction.isActive() );
  }
}
origin: org.hibernate/com.springsource.org.hibernate

/**
 * 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();
}
origin: org.hibernate/com.springsource.org.hibernate

protected ConnectionProvider connectionProvider() {
  return transactionCoordinator.getTransactionContext()
      .getTransactionEnvironment()
      .getJdbcServices()
      .getConnectionProvider();
}
origin: hibernate/hibernate-orm

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

origin: hibernate/hibernate-orm

@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();
    }
  }
}
origin: org.hibernate/com.springsource.org.hibernate

@Override
public void registerSynchronization(Synchronization synchronization) {
  transactionCoordinator().getSynchronizationRegistry().registerSynchronization( synchronization );
}
origin: hibernate/hibernate-orm

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" );
}
origin: hibernate/hibernate-orm

currentHibernateTransaction.invalidate();
origin: org.hibernate/com.springsource.org.hibernate.core

/**
 * 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();
}
origin: org.hibernate/com.springsource.org.hibernate

protected SqlExceptionHelper sqlExceptionHelper() {
  return transactionCoordinator.getTransactionContext()
      .getTransactionEnvironment()
      .getJdbcServices()
      .getSqlExceptionHelper();
}
origin: hibernate/hibernate-orm

@Override
public IntegralDataTypeHolder getNextValue() {
  return session.getTransactionCoordinator().createIsolationDelegate().delegateWork(
      new AbstractReturningWork<IntegralDataTypeHolder>() {
        @Override
origin: hibernate/hibernate-orm

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 );
  }
}
origin: hibernate/hibernate-orm

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;
  }
}
origin: hibernate/hibernate-orm

@Test
public void testMarkRollbackOnlyAnUnactiveTransaction() {
  EntityTransaction transaction = entityManager.getTransaction();
  final TransactionImplementor hibernateTransaction = (TransactionImplementor) transaction;
  hibernateTransaction.markRollbackOnly();
  transaction.rollback();
  assertFalse( transaction.isActive() );
}
origin: hibernate/hibernate-orm

@Override
public IntegralDataTypeHolder getNextValue() {
  return session.getTransactionCoordinator().createIsolationDelegate().delegateWork(
      new AbstractReturningWork<IntegralDataTypeHolder>() {
        @Override
origin: hibernate/hibernate-orm

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 );
  }
}
origin: hibernate/hibernate-orm

value = session.getTransactionCoordinator().createIsolationDelegate().delegateWork( work, true );
origin: hibernate/hibernate-orm

session.getTransactionCoordinator()
    .createIsolationDelegate()
    .delegateWork( work, ddlTransactionHandling == TempTableDdlTransactionHandling.ISOLATE_AND_TRANSACT );
org.hibernate.engine.transaction.spi

Most used classes

  • TransactionCoordinator
    Acts as the coordinator between the Hibernate engine and physical transactions.
  • IsolationDelegate
    Contract for performing work in a manner that isolates it from any current transaction.
  • TransactionContext
    Access to services needed in the context of processing transaction requests. The context is roughly
  • TransactionImplementor
    Additional contract for implementors of the Hibernate Transaction API.
  • TransactionObserver
    Observer of internal transaction events.
  • TransactionFactory,
  • AbstractTransactionImpl,
  • SynchronizationRegistry,
  • LocalStatus
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now