protected TransactionEnvironment transactionEnvironment() { return getTransactionCoordinator().getTransactionContext().getTransactionEnvironment(); }
protected StatementPreparationTemplate(String sql) { this.sql = jdbcCoordinator.getTransactionCoordinator().getTransactionContext().onPrepareStatement(sql); }
public static LogicalConnectionImpl deserialize( ObjectInputStream ois, TransactionContext transactionContext) throws IOException, ClassNotFoundException { boolean isUserSuppliedConnection = ois.readBoolean(); boolean isClosed = ois.readBoolean(); int observerCount = ois.readInt(); List<ConnectionObserver> observers = CollectionHelper.arrayList( observerCount ); for ( int i = 0; i < observerCount; i++ ) { observers.add( (ConnectionObserver) ois.readObject() ); } return new LogicalConnectionImpl( transactionContext.getConnectionReleaseMode(), transactionContext.getTransactionEnvironment().getJdbcServices(), transactionContext.getJdbcConnectionAccess(), isUserSuppliedConnection, isClosed, observers ); } }
@Override public boolean shouldDoManagedFlush(TransactionCoordinator coordinator, int jtaStatus) { return ! coordinator.getTransactionContext().isClosed() && ! coordinator.getTransactionContext().isFlushModeNever() && coordinator.getTransactionContext().isFlushBeforeCompletionEnabled() && ! JtaStatusHelper.isRollback( jtaStatus ); } };
@Override public boolean shouldDoManagedFlush(TransactionCoordinator coordinator, int jtaStatus) { return ! coordinator.getTransactionContext().isClosed() && ! coordinator.getTransactionContext().isFlushModeNever() && ! JtaStatusHelper.isRollback( jtaStatus ); } }
private void closeIfRequired() throws HibernateException { final boolean close = isDriver && transactionCoordinator().getTransactionContext().shouldAutoClose() && ! transactionCoordinator().getTransactionContext().isClosed(); if ( close ) { transactionCoordinator().getTransactionContext().managedClose(); } }
public TransactionCoordinatorImpl( Connection userSuppliedConnection, TransactionContext transactionContext) { this.transactionContext = transactionContext; this.jdbcCoordinator = new JdbcCoordinatorImpl( userSuppliedConnection, this ); this.transactionEnvironment = transactionContext.getTransactionEnvironment(); this.transactionFactory = this.transactionEnvironment.getTransactionFactory(); this.observers = new ArrayList<TransactionObserver>(); this.synchronizationRegistry = new SynchronizationRegistryImpl(); reset(); final boolean registerSynchronization = transactionContext.isAutoCloseSessionEnabled() || transactionContext.isFlushBeforeCompletionEnabled() || transactionContext.getConnectionReleaseMode() == ConnectionReleaseMode.AFTER_TRANSACTION; if ( registerSynchronization ) { pulse(); } }
@Override protected void beforeTransactionCommit() { transactionCoordinator().sendBeforeTransactionCompletionNotifications( this ); final boolean flush = ! transactionCoordinator().getTransactionContext().isFlushModeNever() && ( isDriver || ! transactionCoordinator().getTransactionContext().isFlushBeforeCompletionEnabled() ); if ( flush ) { // if an exception occurs during flush, user must call rollback() transactionCoordinator().getTransactionContext().managedFlush(); } if ( isDriver && isInitiator ) { transactionCoordinator().getTransactionContext().beforeTransactionCompletion( this ); } closeIfRequired(); }
public void beforeCompletion() { LOG.trace( "Transaction before completion callback" ); boolean flush; try { final int status = transactionCoordinator .getTransactionContext() .getTransactionEnvironment() .getJtaPlatform() .getCurrentStatus(); flush = managedFlushChecker.shouldDoManagedFlush( transactionCoordinator, status ); } catch ( SystemException se ) { setRollbackOnly(); throw exceptionMapper.mapStatusCheckFailure( "could not determine transaction status in beforeCompletion()", se ); } try { if ( flush ) { LOG.trace( "Automatically flushing session" ); transactionCoordinator.getTransactionContext().managedFlush(); } } catch ( RuntimeException re ) { setRollbackOnly(); throw exceptionMapper.mapManagedFlushFailure( "error during managed flush", re ); } finally { transactionCoordinator.sendBeforeTransactionCompletionNotifications( null ); transactionCoordinator.getTransactionContext().beforeTransactionCompletion( null ); } }
@Override protected void beforeTransactionCommit() { boolean flush = ! transactionCoordinator().getTransactionContext().isFlushModeNever() && ! transactionCoordinator().getTransactionContext().isFlushBeforeCompletionEnabled(); if ( flush ) { // if an exception occurs during flush, user must call rollback() transactionCoordinator().getTransactionContext().managedFlush(); } }
@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 ); } }
public PreparedStatement prepareStatement() { try { jdbcCoordinator.getLogicalConnection().getJdbcServices().getSqlStatementLogger().logStatement(sql); final PreparedStatement preparedStatement; try { jdbcCoordinator.getTransactionCoordinator().getTransactionContext().startPrepareStatement(); preparedStatement = doPrepare(); setStatementTimeout(preparedStatement); } finally { jdbcCoordinator.getTransactionCoordinator().getTransactionContext().endPrepareStatement(); } postProcess(preparedStatement); return preparedStatement; } catch (SQLException e) { throw sqlExceptionHelper().convert(e, "could not prepare statement", sql); } }
@Override protected void afterTransactionBegin() { if ( ! transactionCoordinator().isSynchronizationRegistered() ) { throw new TransactionException("Could not register synchronization for container transaction"); } transactionCoordinator().sendAfterTransactionBeginNotifications( this ); transactionCoordinator().getTransactionContext().afterTransactionBegin( this ); }
/** * Return whether the given Hibernate Session will always hold the same * JDBC Connection. This is used to check whether the transaction manager * can safely prepare and clean up the JDBC Connection used for a transaction. * <p>The default implementation checks the Session's connection release mode * to be "on_close". * @param session the Hibernate Session to check * @see org.hibernate.engine.transaction.spi.TransactionContext#getConnectionReleaseMode() * @see org.hibernate.ConnectionReleaseMode#ON_CLOSE */ protected boolean isSameConnectionForEntireSession(Session session) { if (!(session instanceof TransactionContext)) { // The best we can do is to assume we're safe. return true; } ConnectionReleaseMode releaseMode = ((TransactionContext) session).getConnectionReleaseMode(); return ConnectionReleaseMode.ON_CLOSE.equals(releaseMode); }
public void afterTransaction(TransactionImplementor hibernateTransaction, int status) { LOG.trace( "after transaction completion" ); final boolean success = JtaStatusHelper.isCommitted( status ); if (sessionFactory().getStatistics().isStatisticsEnabled()) { transactionEnvironment.getStatisticsImplementor().endTransaction( success ); } getJdbcCoordinator().afterTransaction(); getTransactionContext().afterTransactionCompletion( hibernateTransaction, success ); sendAfterTransactionCompletionNotifications( hibernateTransaction, status ); reset(); }
private void closeIfRequired() throws HibernateException { final boolean close = isDriver && transactionCoordinator().getTransactionContext().shouldAutoClose() && ! transactionCoordinator().getTransactionContext().isClosed(); if ( close ) { transactionCoordinator().getTransactionContext().managedClose(); } }
public TransactionCoordinatorImpl( Connection userSuppliedConnection, TransactionContext transactionContext) { this.transactionContext = transactionContext; this.jdbcCoordinator = new JdbcCoordinatorImpl( userSuppliedConnection, this ); this.transactionEnvironment = transactionContext.getTransactionEnvironment(); this.transactionFactory = this.transactionEnvironment.getTransactionFactory(); this.observers = new ArrayList<TransactionObserver>(); this.synchronizationRegistry = new SynchronizationRegistryImpl(); reset(); final boolean registerSynchronization = transactionContext.isAutoCloseSessionEnabled() || transactionContext.isFlushBeforeCompletionEnabled() || transactionContext.getConnectionReleaseMode() == ConnectionReleaseMode.AFTER_TRANSACTION; if ( registerSynchronization ) { pulse(); } }
@Override protected void beforeTransactionCommit() { transactionCoordinator().sendBeforeTransactionCompletionNotifications( this ); final boolean flush = ! transactionCoordinator().getTransactionContext().isFlushModeNever() && ( isDriver || ! transactionCoordinator().getTransactionContext().isFlushBeforeCompletionEnabled() ); if ( flush ) { // if an exception occurs during flush, user must call rollback() transactionCoordinator().getTransactionContext().managedFlush(); } if ( isDriver && isInitiator ) { transactionCoordinator().getTransactionContext().beforeTransactionCompletion( this ); } closeIfRequired(); }
public void beforeCompletion() { LOG.trace( "Transaction before completion callback" ); boolean flush; try { final int status = transactionCoordinator .getTransactionContext() .getTransactionEnvironment() .getJtaPlatform() .getCurrentStatus(); flush = managedFlushChecker.shouldDoManagedFlush( transactionCoordinator, status ); } catch ( SystemException se ) { setRollbackOnly(); throw exceptionMapper.mapStatusCheckFailure( "could not determine transaction status in beforeCompletion()", se ); } try { if ( flush ) { LOG.trace( "Automatically flushing session" ); transactionCoordinator.getTransactionContext().managedFlush(); } } catch ( RuntimeException re ) { setRollbackOnly(); throw exceptionMapper.mapManagedFlushFailure( "error during managed flush", re ); } finally { transactionCoordinator.sendBeforeTransactionCompletionNotifications( null ); transactionCoordinator.getTransactionContext().beforeTransactionCompletion( null ); } }
@Override public boolean shouldDoManagedFlush(TransactionCoordinator coordinator, int jtaStatus) { return ! coordinator.getTransactionContext().isClosed() && ! coordinator.getTransactionContext().isFlushModeNever() && coordinator.getTransactionContext().isFlushBeforeCompletionEnabled() && ! JtaStatusHelper.isRollback( jtaStatus ); } };