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 border layout lays out a container, arranging and resizing its components to
fit in five regions: 

java.awt.BorderLayout

A BufferedInputStream adds functionality to another input stream-namely, the
ability to buffer the i

java.io.BufferedInputStream

Doubly-linked list implementation of the List and Dequeinterfaces. Implements
all optional list oper

java.util.LinkedList

UUID is an immutable representation of a 128-bit universally unique identifier
(UUID). There are mul

java.util.UUID

A task that returns a result and may throw an exception. Implementors define a
single method with no

java.util.concurrent.Callable

A synchronization aid that allows one or more threads to wait until a set of
operations being perfor

java.util.concurrent.CountDownLatch

getContentResolver

notifyDataSetChanged

compareTo

/**
     * INTERNAL:
     * This method performs the logic that occurs at transaction
     * completion time. This includes issuing the SQL, etc.
     * This method executes within the transaction context of the caller of
     * transaction.commit(), or in the case of container-managed transactions,
     * in the context of the method for which the Container started the transaction.
     */

// it's a purely sequencing listener - nothing to do in beforeCompletion.

// In case jts transaction was internally started but completed

// directly by TransactionManager this flag is still set to true.

// If the uow is not active then somebody somewhere messed up 

// Bail out if we don't think we should actually issue the SQL

// Must force concurrency mgrs active thread if in nested transaction

// If sequencing callback for this transaction will be required

// in case it doesn't already exist it will be created on this very listener

// avoiding adding more listeners while processing a listener.

// Fix up our merge state in the unit of work and the session

// Something went wrong (probably while sending SQL to the database).

// Handle the exception according to transaction manager requirements

/**
     * INTERNAL:
     * This method performs the logic that occurs at transaction
     * completion time. This includes issuing the SQL, etc.
     * This method executes within the transaction context of the caller of
     * transaction.commit(), or in the case of container-managed transactions,
     * in the context of the method for which the Container started the transaction.
     */

// If the uow is not active then somebody somewhere messed up

// Log the exception if it has not already been logged, or is a non-EclipseLink exception

/**
     * INTERNAL:
     * The method performs the logic that should be executed after the transaction
     * has been completed. The status passed in indicates whether the transaction
     * was committed or rolled back. This status flag may be different for different
     * implementations.
     * This method executes without a transaction context.
     *
     * @param status The status code of the transaction completion.
     */

// it's a purely sequencing listener - call sequencing callback if the transaction has committed.

// The uow should still be active even in rollback case

// uow in PENDING_MERGE state, merge clones

// call this method again because there may have been no beforeCompletion call

// if case transaction is to be rolled back.

// First log the exception so it gets seen

// Rethrow it just for fun (app servers tend to ignore them at this stage)

// Clean up by releasing the uow and client session

/**
     * INTERNAL:
     * The method performs the logic that should be executed after the transaction
     * has been completed. The status passed in indicates whether the transaction
     * was committed or rolled back. This status flag may be different for different
     * implementations.
     * This method executes without a transaction context.
     *
     * @param status The status code of the transaction completion.
     */

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

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

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