JdbcTransaction (avaje-ebeanorm 3.3.1 API)

java.lang.Object
- com.avaje.ebeaninternal.server.transaction.JdbcTransaction

All Implemented Interfaces:

Transaction, SpiTransaction, Closeable, AutoCloseable

Direct Known Subclasses:

ExternalJdbcTransaction, JtaTransaction
```
public class JdbcTransaction
extends Object
implements SpiTransaction
```
JDBC Connection based transaction.

Field Summary

Fields
Modifier and Type Field and Description

protected TransactionManager manager
The associated TransactionManager.
- Fields inherited from interface com.avaje.ebean.Transaction
  READ_COMMITTED, READ_UNCOMMITTED, REPEATABLE_READ, SERIALIZABLE

Fields
Modifier and Type	Field and Description
`protected TransactionManager`	`manager` The associated TransactionManager.

Constructor Summary

Constructors
Constructor and Description
`JdbcTransaction(String id, boolean explicit, Connection connection, TransactionManager manager)` Create a new JdbcTransaction.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addModification(String tableName, boolean inserts, boolean updates, boolean deletes)` Add table modification information to the TransactionEvent.
`void`	`batchFlush()` Deprecated in favour of `Transaction.flushBatch()`.
`void`	`close()` Alias for end(), which enables this class to be used in try-with-resources.
`void`	`commit()` Commit the transaction.
`protected void`	`deactivate()`
`int`	`depth(int diff)` Return the depth of the current persist request plus the diff.
`void`	`end()` If the transaction is active then perform rollback.
`void`	`flushBatch()` Flush any queued persist requests.
`BatchControl`	`getBatchControl()` Return the queue used to batch up persist requests.
`int`	`getBatchSize()` Return the batchSize specifically set for this transaction or 0.
`Connection`	`getConnection()` Return the underlying connection for public use.
`List<DerivedRelationshipData>`	`getDerivedRelationship(Object bean)` Return the list of "Derived Relationships" that must be maintained after insert.
`TransactionEvent`	`getEvent()` Return the underlying TransactionEvent.
`String`	`getId()` Return the transaction id.
`Connection`	`getInternalConnection()` Return the underlying connection for internal use.
`String`	`getLogPrefix()` Return the string prefix with the transactin id and label used in logging.
`PersistenceContext`	`getPersistenceContext()` Return the persistence context associated with this transaction.
`TransactionManager`	`getTransactionManger()`
`Object`	`getUserObject(String name)` Get an object added with `Transaction.putUserObject(String, Object)`.
`boolean`	`isActive()` Return true if the transaction is active.
`boolean`	`isBatchFlushOnQuery()` Return true if the batch (of persisted beans or executed UpdateSql etc) should be flushed prior to executing a query.
`boolean`	`isBatchThisRequest()` Return true if this request should be batched.
`boolean`	`isExplicit()` Return true if this was an explicitly created transaction.
`boolean`	`isLogSql()` Return true if generated SQL and Bind values should be logged to the transaction log.
`boolean`	`isLogSummary()` Return true if summary level events should be logged to the transaction log.
`boolean`	`isPersistCascade()` Whether persistCascade is on for save and delete.
`boolean`	`isReadOnly()` Return true if this transaction is read only.
`boolean`	`isRegisteredBean(Object bean)` Return true if this is a bean that has already been saved.
`boolean`	`isRegisteredDeleteBean(Integer persistingBean)` Return true if this is a bean that has already been saved/deleted.
`boolean`	`isSaveAssocManyIntersection(String intersectionTable, String beanName)` Return true if the m2m intersection save is allowed from a given bean direction.
`void`	`logSql(String msg)` Log a message to the SQL logger.
`void`	`logSummary(String msg)` Log a message to the SUMMARY logger.
`protected void`	`notifyCommit()` Notify the transaction manager.
`protected void`	`notifyRollback(Throwable cause)` Notify the transaction manager.
`void`	`putUserObject(String name, Object value)` Add an arbitrary user object to the transaction.
`void`	`registerDeleteBean(Integer persistingBean)` Add a bean to the registed list.
`void`	`registerDerivedRelationship(DerivedRelationshipData derivedRelationship)` Register a "Derived Relationship" (that requires an additional update).
`void`	`rollback()` Rollback the transaction.
`void`	`rollback(Throwable cause)` Rollback the transaction.
`void`	`setBatchControl(BatchControl batchControl)` Set the BatchControl to the transaction.
`void`	`setBatchFlushOnMixed(boolean batchFlushOnMixed)` By default when mixing UpdateSql (or CallableSql) with Beans the batch is automatically flushed when you change (between persisting beans and executing UpdateSql or CallableSql).
`void`	`setBatchFlushOnQuery(boolean batchFlushOnQuery)` By default executing a query will automatically flush any batched statements (persisted beans, executed UpdateSql etc).
`void`	`setBatchGetGeneratedKeys(boolean getGeneratedKeys)` Specify if you want batched inserts to use getGeneratedKeys.
`void`	`setBatchMode(boolean batchMode)` Turn on or off statement batching.
`void`	`setBatchSize(int batchSize)` Specify the number of statements before a batch is flushed automatically.
`void`	`setLabel(String label)`
`void`	`setLoggingOn(boolean loggingOn)` Set whether transaction logging is on for this transaction.
`void`	`setPersistCascade(boolean persistCascade)` Explicitly turn off or on the cascading nature of save() and delete().
`void`	`setPersistenceContext(PersistenceContext context)` Set the persistence context to this transaction.
`void`	`setReadOnly(boolean readOnly)` Set whether this transaction should be readOnly.
`String`	`toString()`
`void`	`unregisterBean(Object bean)` Unregister the persisted bean.
`void`	`unregisterDeleteBean(Integer persistedBean)` Unregister the persisted bean.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - manager
```
protected final TransactionManager manager
```
    The associated TransactionManager.
- Constructor Detail
  - JdbcTransaction
```
public JdbcTransaction(String id,
               boolean explicit,
               Connection connection,
               TransactionManager manager)
```
    Create a new JdbcTransaction.
- Method Detail
  - setLabel
```
public void setLabel(String label)
```
  - getLogPrefix
```
public String getLogPrefix()
```
    Description copied from interface: SpiTransaction
    
    Return the string prefix with the transactin id and label used in logging.
    
    Specified by:
    
    getLogPrefix in interface SpiTransaction
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getDerivedRelationship
```
public List<DerivedRelationshipData> getDerivedRelationship(Object bean)
```
    Description copied from interface: SpiTransaction
    
    Return the list of "Derived Relationships" that must be maintained after insert.
    
    Specified by:
    
    getDerivedRelationship in interface SpiTransaction
  - registerDerivedRelationship
```
public void registerDerivedRelationship(DerivedRelationshipData derivedRelationship)
```
    Description copied from interface: SpiTransaction
    
    Register a "Derived Relationship" (that requires an additional update).
    
    Specified by:
    
    registerDerivedRelationship in interface SpiTransaction
  - registerDeleteBean
```
public void registerDeleteBean(Integer persistingBean)
```
    Add a bean to the registed list.
    This is to handle bi-directional relationships where both sides Cascade.
    
    Specified by:
    
    registerDeleteBean in interface SpiTransaction
  - unregisterDeleteBean
```
public void unregisterDeleteBean(Integer persistedBean)
```
    Unregister the persisted bean.
    
    Specified by:
    
    unregisterDeleteBean in interface SpiTransaction
  - isRegisteredDeleteBean
```
public boolean isRegisteredDeleteBean(Integer persistingBean)
```
    Return true if this is a bean that has already been saved/deleted.
    
    Specified by:
    
    isRegisteredDeleteBean in interface SpiTransaction
  - unregisterBean
```
public void unregisterBean(Object bean)
```
    Unregister the persisted bean.
    
    Specified by:
    
    unregisterBean in interface SpiTransaction
  - isRegisteredBean
```
public boolean isRegisteredBean(Object bean)
```
    Return true if this is a bean that has already been saved. This will register the bean if it is not already.
    
    Specified by:
    
    isRegisteredBean in interface SpiTransaction
  - isSaveAssocManyIntersection
```
public boolean isSaveAssocManyIntersection(String intersectionTable,
                                  String beanName)
```
    Return true if the m2m intersection save is allowed from a given bean direction. This is to stop m2m intersection management via both directions of a m2m.
    
    Specified by:
    
    isSaveAssocManyIntersection in interface SpiTransaction
  - depth
```
public int depth(int diff)
```
    Return the depth of the current persist request plus the diff. This has the effect of changing the current depth and returning the new value. Pass diff=0 to return the current depth.
    The depth of 0 is for the initial persist request. It is modified as the cascading of the save or delete traverses to the the associated Ones (-1) and associated Manys (+1).
    
    The depth is used to help the ordering of batched statements.
    
    Specified by:
    
    depth in interface SpiTransaction
    
    Parameters:
    diff - the amount to add or subtract from the depth.
    
    Returns:
    the current depth plus the diff
  - isReadOnly
```
public boolean isReadOnly()
```
    Description copied from interface: Transaction
    
    Return true if this transaction is read only.
    
    Specified by:
    
    isReadOnly in interface Transaction
  - setReadOnly
```
public void setReadOnly(boolean readOnly)
```
    Description copied from interface: Transaction
    
    Set whether this transaction should be readOnly.
    
    Specified by:
    
    setReadOnly in interface Transaction
  - setBatchMode
```
public void setBatchMode(boolean batchMode)
```
    Description copied from interface: Transaction
    Turn on or off statement batching. Statement batching can be transparent for drivers and databases that support getGeneratedKeys. Otherwise you may wish to specifically control when batching is used via this method.
    Refer to java.sql.PreparedStatement.addBatch();
    Note that you may also wish to use the setPersistCascade method to stop save and delete cascade behaviour. You may do this to have full control over the order of execution rather than the normal cascading fashion.
    
    Note that the execution order in batch mode may be different from non batch mode execution order. Also note that insert behaviour may be different depending on the JDBC driver and its support for getGeneratedKeys. That is, for JDBC drivers that do not support getGeneratedKeys you may not get back the generated IDs (used for inserting associated detail beans etc).
    
    Calls to save(), delete(), insert() and execute() all support batch processing. This includes normal beans, MapBean, CallableSql and UpdateSql.
    
    The flushing of the batched statements is automatic but you can call batchFlush when you like. Note that flushing occurs when a query is executed or when you mix UpdateSql and CallableSql with save and delete of beans.
    
    Example: batch processing executing every 3 rows
```
 String data = "This is a simple test of the batch processing"
     + " mode and the transaction execute batch method";
 
 String[] da = data.split(" ");
 
 String sql = "{call sp_t3(?,?)}";
 
 CallableSql cs = new CallableSql(sql);
 cs.registerOut(2, Types.INTEGER);
 
 // (optional) inform eBean this stored procedure
 // inserts into a table called sp_test
 cs.addModification("sp_test", true, false, false);
 
 Transaction t = Ebean.beginTransaction();
 t.setBatchMode(true);
 t.setBatchSize(3);
 try {
   for (int i = 0; i < da.length;) {
 
     cs.setParameter(1, da[i]);
     Ebean.execute(cs);
   }
 
   // NB: commit implicitly flushes
   Ebean.commitTransaction();
 
 } finally {
   Ebean.endTransaction();
 }
 
```
    Specified by:
    
    setBatchMode in interface Transaction
  - setBatchGetGeneratedKeys
```
public void setBatchGetGeneratedKeys(boolean getGeneratedKeys)
```
    Description copied from interface: Transaction
    
    Specify if you want batched inserts to use getGeneratedKeys.
    By default batched inserts will try to use getGeneratedKeys if it is supported by the underlying jdbc driver and database.
    
    You may want to turn getGeneratedKeys off when you are inserting a large number of objects and you don't care about getting back the ids.
    
    Specified by:
    
    setBatchGetGeneratedKeys in interface Transaction
  - setBatchFlushOnMixed
```
public void setBatchFlushOnMixed(boolean batchFlushOnMixed)
```
    Description copied from interface: Transaction
    
    By default when mixing UpdateSql (or CallableSql) with Beans the batch is automatically flushed when you change (between persisting beans and executing UpdateSql or CallableSql).
    If you want to execute both WITHOUT having the batch automatically flush you need to call this with batchFlushOnMixed = false.
    
    Note that UpdateSql and CallableSql are ALWAYS executed first (before the beans are executed). This is because the UpdateSql and CallableSql have already been bound to their PreparedStatements. The beans on the other hand have a 2 step process (delayed binding).
    
    Specified by:
    
    setBatchFlushOnMixed in interface Transaction
  - getBatchSize
```
public int getBatchSize()
```
    Return the batchSize specifically set for this transaction or 0.
    Returning 0 implies to use the system wide default batch size.
    
    Specified by:
    
    getBatchSize in interface SpiTransaction
  - setBatchSize
```
public void setBatchSize(int batchSize)
```
    Description copied from interface: Transaction
    
    Specify the number of statements before a batch is flushed automatically.
    
    Specified by:
    
    setBatchSize in interface Transaction
  - isBatchFlushOnQuery
```
public boolean isBatchFlushOnQuery()
```
    Description copied from interface: Transaction
    
    Return true if the batch (of persisted beans or executed UpdateSql etc) should be flushed prior to executing a query.
    The default is for this to be true.
    
    Specified by:
    
    isBatchFlushOnQuery in interface Transaction
  - setBatchFlushOnQuery
```
public void setBatchFlushOnQuery(boolean batchFlushOnQuery)
```
    Description copied from interface: Transaction
    
    By default executing a query will automatically flush any batched statements (persisted beans, executed UpdateSql etc).
    Calling this method with batchFlushOnQuery = false means that you can execute a query and the batch will not be automatically flushed.
    
    Specified by:
    
    setBatchFlushOnQuery in interface Transaction
  - isBatchThisRequest
```
public boolean isBatchThisRequest()
```
    Return true if this request should be batched. Returning false means that this request should be executed immediately.
    
    Specified by:
    
    isBatchThisRequest in interface SpiTransaction
  - getBatchControl
```
public BatchControl getBatchControl()
```
    Description copied from interface: SpiTransaction
    
    Return the queue used to batch up persist requests.
    
    Specified by:
    
    getBatchControl in interface SpiTransaction
  - setBatchControl
```
public void setBatchControl(BatchControl batchControl)
```
    Set the BatchControl to the transaction. This is done once per transaction on the first persist request.
    
    Specified by:
    
    setBatchControl in interface SpiTransaction
  - flushBatch
```
public void flushBatch()
```
    Flush any queued persist requests.
    This is general will result in a number of batched PreparedStatements executing.
    
    Specified by:
    
    flushBatch in interface Transaction
  - batchFlush
```
public void batchFlush()
```
    Description copied from interface: Transaction
    
    Deprecated in favour of Transaction.flushBatch().
    Exactly the same as flushBatch. Deprecated as a name change.
    
    Specified by:
    
    batchFlush in interface Transaction
  - getPersistenceContext
```
public PersistenceContext getPersistenceContext()
```
    Return the persistence context associated with this transaction.
    
    Specified by:
    
    getPersistenceContext in interface SpiTransaction
  - setPersistenceContext
```
public void setPersistenceContext(PersistenceContext context)
```
    Set the persistence context to this transaction.
    This could be considered similar to EJB3 Extended PersistanceContext. In that you get the PersistanceContext from a transaction, hold onto it, and then set it back later to a second transaction.
    
    Specified by:
    
    setPersistenceContext in interface SpiTransaction
  - getEvent
```
public TransactionEvent getEvent()
```
    Return the underlying TransactionEvent.
    
    Specified by:
    
    getEvent in interface SpiTransaction
  - setLoggingOn
```
public void setLoggingOn(boolean loggingOn)
```
    Set whether transaction logging is on for this transaction.
  - isExplicit
```
public boolean isExplicit()
```
    Return true if this was an explicitly created transaction.
    
    Specified by:
    
    isExplicit in interface SpiTransaction
  - isLogSql
```
public boolean isLogSql()
```
    Description copied from interface: SpiTransaction
    
    Return true if generated SQL and Bind values should be logged to the transaction log.
    
    Specified by:
    
    isLogSql in interface SpiTransaction
  - isLogSummary
```
public boolean isLogSummary()
```
    Description copied from interface: SpiTransaction
    
    Return true if summary level events should be logged to the transaction log.
    
    Specified by:
    
    isLogSummary in interface SpiTransaction
  - logSql
```
public void logSql(String msg)
```
    Description copied from interface: SpiTransaction
    
    Log a message to the SQL logger.
    
    Specified by:
    
    logSql in interface SpiTransaction
  - logSummary
```
public void logSummary(String msg)
```
    Description copied from interface: SpiTransaction
    
    Log a message to the SUMMARY logger.
    
    Specified by:
    
    logSummary in interface SpiTransaction
  - getId
```
public String getId()
```
    Return the transaction id.
    
    Specified by:
    
    getId in interface SpiTransaction
  - getInternalConnection
```
public Connection getInternalConnection()
```
    Return the underlying connection for internal use.
    
    Specified by:
    
    getInternalConnection in interface SpiTransaction
  - getConnection
```
public Connection getConnection()
```
    Return the underlying connection for public use.
    
    Specified by:
    
    getConnection in interface Transaction
  - deactivate
```
protected void deactivate()
```
  - notifyCommit
```
protected void notifyCommit()
```
    Notify the transaction manager.
  - commit
```
public void commit()
            throws javax.persistence.RollbackException
```
    Commit the transaction.
    
    Specified by:
    
    commit in interface Transaction
    
    Throws:
    
    javax.persistence.RollbackException
  - notifyRollback
```
protected void notifyRollback(Throwable cause)
```
    Notify the transaction manager.
  - rollback
```
public void rollback()
              throws javax.persistence.PersistenceException
```
    Rollback the transaction.
    
    Specified by:
    
    rollback in interface Transaction
    
    Throws:
    
    javax.persistence.PersistenceException
  - rollback
```
public void rollback(Throwable cause)
              throws javax.persistence.PersistenceException
```
    Rollback the transaction. If there is a throwable it is logged as the cause in the transaction log.
    
    Specified by:
    
    rollback in interface Transaction
    
    Throws:
    
    javax.persistence.PersistenceException
  - end
```
public void end()
         throws javax.persistence.PersistenceException
```
    If the transaction is active then perform rollback.
    
    Specified by:
    
    end in interface Transaction
    
    Throws:
    
    javax.persistence.PersistenceException
  - isActive
```
public boolean isActive()
```
    Return true if the transaction is active.
    
    Specified by:
    
    isActive in interface Transaction
  - isPersistCascade
```
public boolean isPersistCascade()
```
    Description copied from interface: SpiTransaction
    
    Whether persistCascade is on for save and delete.
    
    Specified by:
    
    isPersistCascade in interface SpiTransaction
  - setPersistCascade
```
public void setPersistCascade(boolean persistCascade)
```
    Description copied from interface: Transaction
    
    Explicitly turn off or on the cascading nature of save() and delete(). This gives the developer exact control over what beans are saved and deleted rather than Ebean cascading detecting 'dirty/modified' beans etc.
    This is useful if you can getting back entity beans from a layer of code (potentially remote) and you prefer to have exact control.
    
    This may also be useful if you are using jdbc batching with jdbc drivers that do not support getGeneratedKeys.
    
    Specified by:
    
    setPersistCascade in interface Transaction
  - addModification
```
public void addModification(String tableName,
                   boolean inserts,
                   boolean updates,
                   boolean deletes)
```
    Description copied from interface: Transaction
    
    Add table modification information to the TransactionEvent.
    Use this in conjunction with getConnection() and raw JDBC.
    
    This effectively informs Ebean of the data that has been changed by the transaction and this information is normally automatically handled by Ebean when you save entity beans or use UpdateSql etc.
    
    If you use raw JDBC then you can use this method to inform Ebean for the tables that have been modified. Ebean uses this information to keep its caches in synch and maintain text indexes.
    
    Specified by:
    
    addModification in interface Transaction
  - putUserObject
```
public void putUserObject(String name,
                 Object value)
```
    Description copied from interface: Transaction
    
    Add an arbitrary user object to the transaction. The objects added have no impact on any internals of ebena and are solely meant as a convenient method push user information to e.g. the TransactionEventListener.
    
    Specified by:
    
    putUserObject in interface Transaction
  - getUserObject
```
public Object getUserObject(String name)
```
    Description copied from interface: Transaction
    
    Get an object added with Transaction.putUserObject(String, Object).
    
    Specified by:
    
    getUserObject in interface Transaction
  - getTransactionManger
```
public final TransactionManager getTransactionManger()
```
  - close
```
public void close()
           throws IOException
```
    Alias for end(), which enables this class to be used in try-with-resources.
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Throws:
    
    IOException

Class JdbcTransaction

Field Summary

Fields inherited from interface com.avaje.ebean.Transaction

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

manager

Constructor Detail

JdbcTransaction

Method Detail

setLabel

getLogPrefix

toString

getDerivedRelationship

registerDerivedRelationship

registerDeleteBean

unregisterDeleteBean

isRegisteredDeleteBean

unregisterBean

isRegisteredBean

isSaveAssocManyIntersection

depth

isReadOnly

setReadOnly

setBatchMode

setBatchGetGeneratedKeys

setBatchFlushOnMixed

getBatchSize

setBatchSize

isBatchFlushOnQuery

setBatchFlushOnQuery

isBatchThisRequest

getBatchControl

setBatchControl

flushBatch

batchFlush

getPersistenceContext

setPersistenceContext

getEvent

setLoggingOn

isExplicit

isLogSql

isLogSummary

logSql

logSummary

getId

getInternalConnection

getConnection

deactivate

notifyCommit

commit

notifyRollback

rollback

rollback

end

isActive

isPersistCascade

setPersistCascade

addModification

putUserObject

getUserObject

getTransactionManger

close