Public

<init>

errorBeginningExternalTransaction

errorBindingToExternalTransaction

errorCommittingExternalTransaction

errorGettingExternalTransaction

errorGettingExternalTransactionStatus

errorMarkingTransactionForRollback

errorObtainingTransactionManager

errorRollingBackExternalTransaction

externalTransactionNotActive

inactiveUnitOfWork

jndiLookupException

setErrorCode

setInternalException

getErrorCode

entityTransactionWithJTANotAllowed

getMessage

internalProxyException

multipleResourceException

transactionIsActive

TransactionException

Updating database using SQL prepared statement

A readable source of bytes.Most clients will use input streams that read data
from the file system (

java.io.InputStream

A ConnectException is thrown if a connection cannot be established to a remote
host on a specific po

java.net.ConnectException

A Uniform Resource Locator that identifies the location of an Internet resource
as specified by RFC 

java.net.URL

The Manifest class is used to obtain attribute information for a JarFile and its
entries.

java.util.jar.Manifest

javax.swing.JTable

org.hibernate.mapping.Join

setContentView

addToBackStack

getExternalFilesDir

/**
     * INTERNAL:
     * Returns sequencingCallback for the current active external transaction.
     * DatabaseSession is passed for the sake of SessionBroker case.
     * This method requires active external transaction.
     */

// This method requires active external transaction.

// In case this request was triggered from beforeCompletion method of existing listener -

// Create and register the new synchronization listener with uow==session==null.

/**
     * INTERNAL:
     * Returns sequencingCallback for the current active external transaction.
     * DatabaseSession is passed for the sake of SessionBroker case.
     * This method requires active external transaction.
     */

//EM already validated that there is a JTA transaction.

//we have a context initialized, so have it register with the transaction

//                In general, a persistence context will be synchronized to the database as described below. However, a

//                persistence context of type SynchronizationType.UNSYNCHRONIZED or an application-managed

//                persistence context that has been created outside the scope of the current transaction will only be

//                synchronized to the database if it has been joined to the current transaction by the application's use of

//                the EntityManager joinTransaction method.

//                If there is no transaction active

//                or if the persistence context has not been joined to the current transaction, the persistence provider must

//                not flush to the database.

//              App managed, so we need to start the active persistence Context.  Or do we?

//          } else if (syncType.equals(SynchronizationType.SYNCHRONIZED)) {

//              need to ensure we do not init the context until we need too

//              this is unsynchronized, so we need to start the active persistence Context.  Or do we?

//            duplicating what is done in

//            TransactionController.registerSynchronizationListener(this, this.parent);

//            This will need to change if javax.transaction dependencies are to be removed from JPA. See TransactionImpl 

//let the wrapper know the listener is no longer registered to an active transaction

/**
     * INTERNAL:
     * Associate the given unit of work and EclipseLink session with the active external
     * transaction. This may be done by whatever means supported by the transaction
     * manager (i.e. through a synchronization protocol).
     *
     * @param unitOfWork The unit of work that is to be bound to the active transaction
     * @param session The session ancestor of the unit of work
     */

// If no external transaction is active then start one through the uow

// If there still is no active txn then something is wrong

// Create and register the synchronization listener

/**
     * INTERNAL:
     * Associate the given unit of work and EclipseLink session with the active external
     * transaction. This may be done by whatever means supported by the transaction
     * manager (i.e. through a synchronization protocol).
     *
     * @param unitOfWork The unit of work that is to be bound to the active transaction
     * @param session The session ancestor of the unit of work
     */

How to use errorBindingToExternalTransactionmethodin org.eclipse.persistence.exceptions.TransactionException

Best Java code snippets using org.eclipse.persistence.exceptions.TransactionException.errorBindingToExternalTransaction (Showing top 7 results out of 315)

How to use
errorBindingToExternalTransaction
method
in
org.eclipse.persistence.exceptions.TransactionException