|
Oracle Fusion Middleware Java API Reference for Oracle ADF Model 11g Release 2 (11.1.2.0.0) E17483-01 |
||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object oracle.jbo.server.DBTransactionImpl
public class DBTransactionImpl
The superclass of classes representing connections of middle-tier objects to databases.
Instances encapsulate the JDBC connection, provide commit() and rollback() operations, and maintain various internal framework states, events and caches of entity data.
Advanced applications can provide custom subclass implementations
using DatabaseTransactionFactory
.
From 9.0.3 onwards, this class is no longer used to represent
a connected transaction. The connected state, by default, is now
represented by DBTransactionImpl2
.
Applications using custom DBTransactionImpl and/or NullDBTransactionImpl subclass(es)
should now subclass DBTransactionImpl2 instead.
In contrast to the "create View Object" methods on the
ApplicationModuleImpl
class, the methods on
DBTransaction do not take a String voNname parameter. These methods
create anonymous View Objects on the database transaction. Anonymous View
Objects do not require an Application Module. An anonymous View Object is
a View Object to which you do not give a name and that is usually used
locally.
For example, you could use an anonymous View Object when you want to perform
a query (for example, a look-up) through a View Object, then remove it.
Anonymous View Objects should not be passed around between Application Modules. As soon as the anonymous View Object has performed its task, it should be discarded with the View Object remove() method.
Using anonymous View Objects also lets you avoid name clashes between View Objects. For example, if one Entity Object developer builds some code that is expecting to create a View Object in its own Application Module with a name like "temp" and another unrelated Entity Object developer builds some code that is expecting to work with a View Object in its own Application Module named "temp" (but which is for a totally different View Object), then if an application required both of these Application Modules to works as peers, name clashes could result.
The method getDBTransaction().createViewObject()
creates a View Object from a definition created at design time
which can be based on Entity Objects just like the ones you might have been creating
with the
createViewObject
from the
ApplicationModule class.
The DBTransactionImpl class also has createViewObjectFromQueryStmt and createViewObjectFromQueryClauses just like the Application Module class does; all of the same functionality is available to the Entity Object business logic writer.
The only difference is that the DBTransactionImpl class approach forces the Entity Object business logic writer to not pre-select an "instance" name for the View Object being used (the equivalent of calling the Application Module-level methods with a null instance name argument) so that the system ensures the "instance" names are unique and no unintended clashes occur.
To illustrate the differences between using the create View Object methods on the Application Module class versus the DBTransaction class, consider the following code snippets. Assume you have a method called doSomething() on an Entity Object to implement some operation. Two possible implementations are:
// Implementation 1 public void doSomething() { DBTransaction txn = this.getDBTransaction(); ViewObject vo1 = txn.createViewObject("myPackage.MyFirstViewObject"); ViewObject vo2 = txn.createViewObject("myPackage.MySecondViewObject"); // Do something here... vo1.remove(); vo2.remove(); } // Implementation 2 public void doSomething() { DBTransaction txn = this.getDBTransaction(); MyApplicationModule am = txn.createApplicationModule("myPackage.MyAppModule"); ViewObject vo1 = am.getMyFirstViewObject(); ViewObject vo2 = am.getMySecondViewObject(); // Do the same something here... am.remove(); }The following lists compare the advantages and disadvangages of each implementation.
Implementation 1:
Implementation 2:
Generally, the motivation for separating code out into an Application Module would be the same as the general motivation for separating code out into a different a class.
In that sense, you may choose to take your example one step further and move the "Do Something Here" code into the Application Module class:
// Implementation 3 public void doSomething() { DBTransaction txn = this.getDBTransaction(); MyApplicationModule am = (MyApplicationModule) txn.createApplicationModule("myPackage.MyAppModule"); am.doSomethingThere(...); am.remove(); }Implementations 1 and 2 are both correct approaches. Creating a nested Application Module is good for multi-View Object data models, and DbTransaction is good for simple one-off queries. If your application is using one-off queries most of the time, you might find that the extra overhead of creating an Application Module "container" might not add sufficient value.
Field Summary | |
---|---|
static int |
MAX_CURSORS_UNINITIALIZED
|
protected ConnectionCredentials |
mConnectionCredentials
|
protected int |
mDMLOperationTimeOut
|
protected ConnectionCredentials |
mInternalCredentials
|
protected java.util.List |
mLongRunningDMLOperationHandles
|
protected SQLBuilder |
mSQLBuilder
The SQLBuilder instance used to interact with JDBC in this transaction. |
protected java.util.ArrayList |
mTxnListeners
|
static int |
POST_ABORT_ON_FIRST_EXCEPTION
|
static int |
POST_ALL_NO_RESET_ON_EXCEPTION
|
static int |
POST_ALL_RESET_ON_EXCEPTION
|
Fields inherited from interface oracle.jbo.server.DBTransaction |
---|
DEFAULT |
Fields inherited from interface oracle.jbo.Transaction |
---|
DML_OPERATION_TIMEOUT_WAIT_FOREVER, LOCK_NONE, LOCK_OPTIMISTIC, LOCK_OPTUPDATE, LOCK_PESSIMISTIC |
Constructor Summary | |
---|---|
DBTransactionImpl(java.sql.Connection connection)
Creates an instance from an existing JDBC connection. |
|
DBTransactionImpl(javax.sql.DataSource ds)
|
|
DBTransactionImpl(javax.sql.DataSource ds,
java.lang.String user,
java.lang.String passwd)
|
|
DBTransactionImpl(java.lang.String url)
Deprecated. Since 9.0.3. This constructor is no longer called to create a connected DBTransaction instance. Instead, DBTransactionImpl2 instance, created by create() , migrates from
disconnected to connected state. |
|
DBTransactionImpl(java.lang.String url,
java.util.Properties info)
Deprecated. Since 9.0.3. This constructor is no longer called to create a connected DBTransaction instance. Instead, DBTransactionImpl2 instance, created by create() , migrates from
disconnected to connected state. |
|
DBTransactionImpl(java.lang.String url,
java.lang.String user,
java.lang.String password)
Deprecated. Since 9.0.3. This constructor is no longer called to create a connected DBTransaction instance. Instead, DBTransactionImpl2 instance, created by create() , migrates from
disconnected to connected state. |
|
DBTransactionImpl(java.lang.String url,
java.lang.String user,
java.lang.String password,
java.util.Properties info)
Deprecated. Since 9.0.3. This constructor is no longer called to create a connected DBTransaction instance. Instead, DBTransactionImpl2 instance, created by create() , migrates from
disconnected to connected state. |
Method Summary | |
---|---|
void |
addLongRunningDMLOperationHandle(LongRunningStatementHandle handle)
|
void |
addToValidationListeners(ValidationListener entity)
Adds an entity validation listener. |
void |
addTransactionListener(TransactionListener listener)
Adds a listener to the transaction's list. |
void |
addTransactionListenerNoCheck(TransactionListener listener)
Internal: Applications should not call this method. |
void |
addTransactionPostListener(TransactionPostListener listener)
Adds a subscriber to the transaction's post-events list. |
void |
addTransactionPostListenerNoCheck(TransactionPostListener listener)
Internal: Applications should not use this method. |
void |
addTransactionStateListener(TransactionStateListener target)
Add this TransactionListener to the list and notify all such listeners whenever commit and rollback occurs in this transaction. |
void |
addViewClearCacheListener(ViewClearCacheListener target)
|
void |
addWarning(JboWarning warn)
Adds a warning to the root Application Module warning stack. |
void |
applyChangeSet(int id)
Applies the changes committed by another transaction in order to synchronize caches between root Application Module instances. |
boolean |
cancelDMLOperations()
Cancels the currently running Entity Object DML operations. |
protected void |
checkConnected()
|
void |
clearEntityCache(java.lang.String entityName)
Clears the cache of the specified Entity Object. |
void |
closeTransaction()
Internal: Applications should not use this method. |
void |
commit()
Commits all changes in this transaction to the database, making them visible to other users and transactions. |
int |
commitAndSaveChangeSet()
Commits the transaction and writes updated EntityImpls to the persistent store. |
void |
connect(java.sql.Connection sqlConnection)
Deprecated. |
void |
connect(java.lang.String url)
Uses this JDBC Connection object to connect to the database for all operations via this transaction. |
void |
connect(java.lang.String url,
java.util.Properties info)
Internal: Applications should not use this method. |
void |
connect(java.lang.String url,
java.lang.String user,
java.lang.String password)
Internal: Applications should not use this method. |
void |
connectToDataSource(javax.sql.DataSource ds,
boolean isJTAbased)
|
void |
connectToDataSource(javax.sql.DataSource ds,
java.lang.String user,
java.lang.String passwd,
boolean isJTAbased)
|
void |
connectToDataSource(java.util.Hashtable env,
java.lang.String dsName,
boolean isJTABased)
Looks up a datasource from a jndi tree and acquires the jdbc connection from the looked up datasource using the javax.sql.Datasource.getConnection(String user, String passwd) method. |
void |
connectToDataSource(java.util.Hashtable env,
java.lang.String dsName,
java.lang.String user,
java.lang.String passwd,
boolean isJTABased)
Looks up a datasource from a jndi tree and acquires the jdbc connection from the looked up datasource using the javax.sql.Datasource.getConnection(String user, String passwd) method. |
void |
connectToDataSource(java.lang.String nsUrl,
java.lang.String nsUser,
java.lang.String nsPasswd,
java.lang.String dsUrl)
Looks up a datasource from Oracle 8i namespace using the jdbc_access protocol and acquires the default jdbc connection from the looked up datasource using the javax.sql.Datasource.getConnection() method. |
void |
connectToDataSource(java.lang.String nsUrl,
java.lang.String nsUser,
java.lang.String nsPasswd,
java.lang.String dsUrl,
java.lang.String user,
java.lang.String passwd)
Looks up a datasource from Oracle 8i namespace using the jdbc_access protocol and acquires the jdbc connection from the looked up datasource using the javax.sql.Datasource.getConnection(String user, String password) method. |
ApplicationModule |
createApplicationModule(java.lang.String defName)
Creates an anonymous Application Module. |
ApplicationModule |
createApplicationModule(java.lang.String amName,
java.lang.String defName)
Creates an instance of an nested Application Module within this Transaction For example, |
java.sql.CallableStatement |
createCallableStatement(java.lang.String str,
int noRowsPrefetch)
Creates a JDBC CallableStatement instance. |
EntityImpl |
createEntityInstance(EntityDefImpl entityDef,
AttributeList al)
Creates an EntityImpl object based on the given defintion, in the context
of the root Application Module. |
EntityImpl |
createEntityInstance(java.lang.String entityDefName,
AttributeList al)
Creates an EntityImpl object based on the given defintion, in the context
of the root Application Module. |
java.sql.PreparedStatement |
createPreparedStatement(java.lang.String str,
int noRowsPrefetch)
Creates a JDBC PreparedStatement instance. |
java.lang.Object |
createRef(java.lang.String structName,
byte[] data)
Internal: Applications should not use this method. |
java.sql.Statement |
createStatement(int noRowsPrefetch)
Creates a JDBC Statement instance. |
ViewLink |
createViewLink(java.lang.String viewLinkDefName,
ViewObject master,
ViewObject detail)
Creates an anonymous View Link. |
ViewLink |
createViewLinkBetweenViewObjects(java.lang.String accessorName,
ViewObject master,
AttributeDef[] srcAttrs,
ViewObject detail,
AttributeDef[] destAttrs,
java.lang.String assocClause)
Creates an anonymous View Link. |
ViewLink |
createViewLinkFromEntityAssocName(java.lang.String entityAssocName,
ViewObject master,
ViewObject detail)
Creates a View Link. |
ViewObject |
createViewObject(java.lang.String voDefName)
Creates an anonymous query definition from the name of a ViewObject class. |
ViewObject |
createViewObjectFromQueryClauses(java.lang.String eoName,
java.lang.String selectClause,
java.lang.String fromClause,
java.lang.String whereClause,
java.lang.String orderByClause)
Creates an updatable query definition. |
ViewObject |
createViewObjectFromQueryStmt(java.lang.String sqlStatement)
Creates an anonymous query definition from an SQL statement. |
ViewObject |
createViewObjectFromQueryStmt(java.lang.String sqlStatement,
java.lang.String voImplClassName)
Creates an anonymous query definition from an SQL statement. |
static java.lang.String |
diagCleanURL(java.lang.String url)
|
void |
disconnect()
Closes the JDBC connection object and removes this transaction from the root application module. |
void |
disconnect(boolean retainState)
Closes the JDBC connection object. |
void |
doAfterCommit()
|
void |
doBeforeCommit()
|
protected void |
doCommit()
Called by the commit method to issue the commit call. |
protected void |
doRollback()
Called by the rollback method to issue the rollback call. |
void |
doValidatePostChanges()
invoke validate() and postChanges() iteratively based on validateThreshold and postThreshold setting. |
void |
dumpEntityCaches(java.io.Writer out)
Iterates over the currently populated caches of entities, and write a representation of them to a charater stream. |
java.lang.String |
dumpQueryResult(java.lang.String query,
java.lang.String dumpClassName,
java.lang.String[] data)
Writes the result of the query to a (potentially very long) string. |
int |
executeCommand(java.lang.String command)
Executes a SQL command using a JDBC Statement under the current transaction. |
ApplicationModule |
findApplicationModule(java.lang.String amName)
Returns the named Application Module. |
EntityImpl |
findByPrimaryKey(EntityDefImpl entityDef,
Key key)
Finds an Entity Object in this transaction given an EntityDef object and a Primary Key. |
EntityImpl |
findByPrimaryKey(java.lang.String entityDefName,
Key key)
Finds an Entity Object in this transaction given the String name of the EntityDef and a Primary Key. |
EntityCache |
findEntityCache(EntityDefImpl source)
Finds a Cache table for the entity. |
ViewObject |
findViewObject(java.lang.String voName)
Find a view object with the specified name. |
protected java.util.Set<ApplicationModuleImpl> |
getActiveApplicationModuleImpls()
|
int |
getBatchPostExceptionThreshold()
In case of batch mode post operation, try to post the batched set of entities for each entity type and post operation (Insert/Update/Delete) for this many number of exceptions. |
ConnectionMetadata |
getConnectionMetadata()
Returns a metdata structure that describes the transaction's JDBC connection. |
java.sql.Timestamp |
getCurrentDbTime()
|
int |
getDMLOperationTimeOut()
Returns the current Entity Object DML operation time out value. |
EntityCache |
getEntityCache(EntityDefImpl source)
|
protected java.sql.Connection |
getJdbcConnection()
Returns the JDBC connection for this transaction. |
int |
getLockingMode()
Returns the preferred locking mode for this Transaction. |
java.sql.Connection |
getPersistManagerConnection()
Internal: Applications should not use this api. Returns the connection used by PersistentCollection apis. |
int |
getPostChangesFlag()
Internal: Applications should not use this method. |
int |
getPostThreshold()
Gets the threshold value for the commit-cycle's post phase. |
ApplicationModule |
getRootApplicationModule()
Returns the root appmodule that owns this transaction. |
Session |
getSession()
Gets the session information. |
SQLBuilder |
getSQLBuilder()
Internal: Applications should not use this method. |
java.lang.Object |
getSyncLock()
|
TransactionHandler |
getTransactionHandler()
Internal: Applications should not use this method. |
protected java.util.ArrayList |
getTransactionListenersList()
|
protected java.util.ArrayList |
getTransactionPostListenersList()
|
protected int |
getTransactionState()
|
java.util.ArrayList |
getTransAttrValidationList()
|
JboTransAttrValidationManager |
getTransAttrValidationManager()
|
java.util.HashMap |
getTransAttrValidations()
|
java.util.ArrayList |
getTransValidationList()
|
JboTransValidationManager |
getTransValidationManager()
|
java.util.HashMap |
getTransValidations()
|
protected ApplicationModuleImpl |
getTxnApplicationModuleImpl()
Gets the root Application Module to which this transaction belongs. |
protected java.util.ArrayList |
getValidationListenersList()
|
int |
getValidationThreshold()
Gets the threshold value for the commit-cycle's validation phase. |
protected boolean |
hasRollbackSavePoint()
|
boolean |
isBundledExceptionMode()
|
boolean |
isClearCacheOnCommit()
Returns the flag indicating whether all Entity Object caches will be cleared after the transaction is committed. |
boolean |
isClearCacheOnRollback()
Returns the flag indicating whether all Entity Object caches will be cleared after the transaction is rolled back. |
boolean |
isConnected()
Checks if the transaction is connected to the database. |
boolean |
isConnected(boolean pingDatabase)
|
boolean |
isDirty()
This method is typically called before an attempt is made to post the data. |
boolean |
isForceDeferValidation()
|
boolean |
isLockOptimistic()
Returns true if the lock mode for this transaction is optimistic. |
boolean |
isTrackNewAndModifiedRowsOnly()
Deprecated. since 9.0.5.1 |
EntityCache |
lookupEntityCache(EntityDefImpl source)
|
void |
postChanges()
Synchronizes the changes in the middle-tier transaction-cache with the database. |
protected void |
postChanges(TransactionEvent te)
Internal: Applications should not use this method. |
void |
putTransAttrValEntry(JboTransValidatorInterface validator,
JboValidatorContext valCtx)
|
void |
putTransValEntry(JboTransValidatorInterface validator,
JboValidatorContext valCtx)
|
void |
reconnect()
Reconnect the ApplicationModule to the database, using previously supplied database credentials. |
void |
reconnect(boolean force)
Reconnect the Application Module to the database, if necessary, using previously supplied database credentials. |
void |
removeChangeSet(int id)
Removes the change set that defines the changes to EntityImpls within a transaction. |
void |
removeEntityCache(EntityDefImpl source)
|
void |
removeEntityCacheByName(java.lang.String name)
|
void |
removeLongRunningDMLOperationHandle(LongRunningStatementHandle handle)
|
void |
removeTransactionListener(TransactionListener listener)
Removes a subscriber from the transaction's events list. |
void |
removeTransactionPostListener(TransactionPostListener listener)
Removes a subscriber from the transaction's post-events list. |
void |
removeTransactionStateListener(TransactionStateListener target)
Remove this transaction listener (if it exists) from this transaction. |
void |
removeViewClearCacheListener(ViewClearCacheListener target)
|
void |
rollback()
Discards all modifications made in this transaction. |
void |
setBatchModeForEntity(EntityDefImpl def,
boolean mode)
Sets the updatebatching (Batch post operations) mode on or off for a given entity type in this transaction. |
void |
setBatchPostExceptionThreshold(int count)
Set this value to 0 to let all the modified entities be posted for each entity type and entity-DML operation to collect possible exceptions for all such entities. |
void |
setBundledExceptionMode(boolean flag)
Set this transaction into bundled exception mode. |
void |
setClearCacheOnCommit(boolean val)
Sets the value of the flag indicating whether all Entity Object caches will be cleared after the transaction is committed. |
void |
setClearCacheOnRollback(boolean val)
Sets the value of the flag indicating whether all Entity Object caches will be cleared after the transaction is rolled back. |
void |
setDMLOperationTimeOut(int timeOutMills)
Sets the query time out value for the Entity Object's DML operations. |
void |
setForceDeferValidation(boolean bForceDefer)
|
void |
setLockingMode(int mode)
Sets the preferred locking mode for this Transaction. |
void |
setPostChangesFlag(int flag)
The given flag modifies the behavior of postChanges method. |
void |
setPostThreshold(int count)
Sets the threshold value for the commit-cycle's post phase. |
void |
setTrackNewAndModifiedRowsOnly(boolean flag)
Deprecated. since 9.0.5.1. This behavior is not optional anymore. |
void |
setTransactionHandler(TransactionHandler txnHandler)
Internal: Applications should not use this method. |
void |
setValidationThreshold(int count)
Sets the threshold value for the commit-cycle's validation phase. |
void |
showCursorUsage(java.io.Writer out)
Internal: Applications should not use this method. |
void |
validate()
Starts the validation cycle and validates all subscribers in the ValidationListener list. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
public static final int MAX_CURSORS_UNINITIALIZED
protected SQLBuilder mSQLBuilder
protected ConnectionCredentials mConnectionCredentials
protected ConnectionCredentials mInternalCredentials
protected java.util.ArrayList mTxnListeners
public static int POST_ALL_NO_RESET_ON_EXCEPTION
public static int POST_ALL_RESET_ON_EXCEPTION
public static int POST_ABORT_ON_FIRST_EXCEPTION
protected int mDMLOperationTimeOut
protected java.util.List mLongRunningDMLOperationHandles
Constructor Detail |
---|
public DBTransactionImpl(javax.sql.DataSource ds)
public DBTransactionImpl(javax.sql.DataSource ds, java.lang.String user, java.lang.String passwd)
public DBTransactionImpl(java.sql.Connection connection)
connection
- an existing connection.public DBTransactionImpl(java.lang.String url)
create()
, migrates from
disconnected to connected state.
url
- a database URL of the form JDBC:subprotocol:subname.DBTransactionImpl2
public DBTransactionImpl(java.lang.String url, java.util.Properties info)
create()
, migrates from
disconnected to connected state.
url
- a database URL of the form JDBC:subprotocol:subname.info
- a list of arbitrary string tag/value pairs as
connection arguments; normally at least "user" and
"password" tags should be included.DBTransactionImpl2
public DBTransactionImpl(java.lang.String url, java.lang.String user, java.lang.String password)
create()
, migrates from
disconnected to connected state.
url
- a database URL of the form JDBC:subprotocol:subname.user
- the database user on whose behalf the connection is being made.password
- the user's password.DBTransactionImpl2
public DBTransactionImpl(java.lang.String url, java.lang.String user, java.lang.String password, java.util.Properties info)
create()
, migrates from
disconnected to connected state.
Attempts to establish a connection to the given database URL. The DriverManager attempts to select an appropriate driver from the set of registered JDBC drivers.
url
- a database url of the form jdbc:subprotocol:subnameuser
- the database user on whose behalf the Connection is being madepassword
- the user's passwordinfo
- a list of arbitrary string tag/value pairs as
connection arguments; normally at least a "user" and
"password" property should be includedDBTransactionImpl2
Method Detail |
---|
public final java.lang.Object getSyncLock()
public static java.lang.String diagCleanURL(java.lang.String url)
public boolean isLockOptimistic()
isLockOptimistic
in interface DBTransaction
true
if the locking mode is LOCK_OPTIMISTIC
or LOCK_OPTUPDATE
.public java.sql.Connection getPersistManagerConnection()
getPersistManagerConnection
in interface PCollManagerHelper
public void closeTransaction()
Closes this transaction's JDBC connection.
Performs rollback on the current transaction to reset all the data in the cache
to their initial states and then drops the JDBC connection.
This method is invoked by disconnect
to
terminate the JDBC connection. Applications should use
disconnect()
instead of closeTransaction()
to properly release JDBC resources.
closeTransaction
in interface DBTransaction
public void setBundledExceptionMode(boolean flag)
Transaction
setBundledExceptionMode
in interface Transaction
public final boolean isBundledExceptionMode()
isBundledExceptionMode
in interface Transaction
public SQLBuilder getSQLBuilder()
Identifies the SQLBuilder that is used by this driver. In the runtime, the SQLBuilder that is used depends on whether the JDBC driver is Oracle-specific or non-Oracle-specific.
getSQLBuilder
in interface DBTransaction
public boolean isClearCacheOnCommit()
After the transaction is committed, the value of this flag is
used to determine whether the Entity Object caches are cleared or
not. If this flag value is false
, the cache contents
are kept. In this case, the cache may contain data that is stale
in that it does not match the newest data (changes made by another
user and committed).
If this flag is true
, the caches are cleared after
the transaction is committed. When the user brings in data
by traversing row collection, the latest data from the database
will be brought into Entity caches.
isClearCacheOnCommit
in interface Transaction
RowSet.executeQuery()
,
setClearCacheOnCommit(boolean val)
,
Transaction.isClearCacheOnCommit()
,
Transaction.setClearCacheOnCommit(boolean val)
public void setClearCacheOnCommit(boolean val)
The initial value of this flag is retrieved from the Application
Module definition of the root Application Module (an XML attribute
value named "ClearCacheOnCommit" in the Application Module definition's
XML file). If the Application Module definition does not contain
the initial value, the default value is false
, i.e.,
the caches are kept after commit.
The user can override the value of this flag for this Transaction by calling this method. Calling this method does not affect the initial value in the Application Module definition.
setClearCacheOnCommit
in interface Transaction
val
- the new value of the clear-cache-on-commit flag.
true indicates that the Entity Object caches
will be cleared after commit.isClearCacheOnCommit()
,
Transaction.isClearCacheOnCommit()
,
Transaction.setClearCacheOnCommit(boolean)
public boolean isClearCacheOnRollback()
After the transaction is rolled back, the value of this flag is
used to determine whether the Entity Object caches are cleared or
not. If this flag value is false
, the cache contents
are kept. In this case, the cache may contain data that is not in
sync with database in that uncommitted changes made this by user
(before the transaction was rolled back) will be kept.
If this flag is true
, the caches are cleared after
the transaction is rolled back. When the user brings in data
by traversing row collection, the latest data from the database
will be brought into Entity caches.
isClearCacheOnRollback
in interface Transaction
RowSet.executeQuery()
,
setClearCacheOnRollback(boolean val)
,
Transaction.isClearCacheOnCommit()
,
Transaction.setClearCacheOnCommit(boolean val)
public void setClearCacheOnRollback(boolean val)
The initial value of this flag is retrieved from the Application
Module definition of the root Application Module (an XML attribute
value named "ClearCacheOnRollback" in the Application Module definition's
XML file). If the Application Module definition does not contain
the initial value, the default value is true
, i.e.,
the caches are cleared after rollback.
The user can override the value of this flag for this Transaction by calling this method. Calling this method does not affect the initial value in the Application Module definition.
setClearCacheOnRollback
in interface Transaction
val
- the new value of the clear-cache-on-roll-back flag.
true indicates that the Entity Object caches
will be cleared after rollback, and will be
refreshed with new data from the database.isClearCacheOnRollback()
,
Transaction.setClearCacheOnRollback(boolean)
,
Transaction.isClearCacheOnRollback()
public void doValidatePostChanges()
public void doBeforeCommit()
public void doAfterCommit()
public void commit()
appMod.getTransaction().commit();When the commit process begins multiple attempts are made to validate all objects in the list of validation listeners, depending on the setting of the validation threshold. After each attempt, top-level entities that are still invalid will remain in the list. If any remain after the last attempt, a failure exception is thrown.
Each listed TransactionPostListener
is notified to post any changes to the database using the
postChanges
method. Non-transient listeners are notified first,
followed by transient listeners.
The post phase is repeated, the number of repetitions depending on the setting
of the validation threshold.
If any invalid objects remain after the last repetition, a failure exception is thrown.
Following validation, no further changes to data should be made until the commit operation is completed.
Finally,
beforeCommit
events are posted to the listeners, the data is committed,
afterCommit
events are posted, and transient listeners are deleted from the transaction.
For both beforeCommit and afterCommit events,
non-transient listeners preceed transient listeners.
Note, if your Application Module is an EJB session bean, a new transaction is started for you automatically after calling commit. You do not have to explicitly start a new transaction.
commit
in interface Transaction
TransactionListener.beforeCommit(TransactionEvent)
,
TransactionListener.afterCommit(TransactionEvent)
,
DBTransaction
,
postChanges()
public int commitAndSaveChangeSet()
Transaction
This method (along with applyChangeSet
and removeChangeSet
is used to
synchronize the cache between root Application
Module instances in an Application Module pool.
commitAndSaveChangeSet commits the transaction, but during the commit process, writes out "changed" EntityImpls to the persistent store. These changes are stored as a "change set". The change set can then be applied to other transactions (that is, to the Entity caches of other root Application Modules).
The integer value returned by this method identifies the change set that is stored in persistent store.
To apply the changes to another transaction (or Application
Module cache),
call Transaction.applyChangeSet(int)
where int
is the integer value returned by commitAndSaveChangeSet
that represents the change set.
For example, assume you have two root Application Modules, named am1 and am2, in an Application Module pool.
// The line below commits the transaction in am1 and writes the change // set to persistent store (database table). The returning snapId // identifies the (persistent) change set. int snapId = am1.getTransaction().commitAndSaveChangeSet(); // Use that change set and apply the changes to the other Application // Module, am2. That is, apply changes from am1 to am2. am2.getTransaction().applyChangeSet(snapId); // When you are done with the change set, remove (free) it. am1.getTransaction().removeChangeSet(snapId);
commitAndSaveChangeSet
in interface Transaction
EntityImpl
change set in persistent store.Transaction.applyChangeSet(int)
,
Transaction.removeChangeSet(int)
public void applyChangeSet(int id)
Transaction
This method (along with commitAndSaveChangeSet
and removeChangeSet
is used to
synchronize the cache between root Application
Module instances in an Application Module pool.
Call applyChangeSet to apply changes commited by another
transaction. The integer id parameter (returned by
commitAndSaveChangeSet
) identifies the
change set to be found in the persistent store.
After this call, this transaction's cache is synchronized with the changes from the change set.
For an example of how to use applyChangeSet, see
commitAndSaveChangeSet
.
applyChangeSet
in interface Transaction
id
- an integer representing the change set to apply to the
transaction.Transaction.commitAndSaveChangeSet()
,
Transaction.removeChangeSet(int)
public void removeChangeSet(int id)
Transaction
This method (along with commitAndSaveChangeSet
and applyChangeSet
is used to
synchronize the cache between root Application
Module instances in an Application Module pool.
For an example of how to use removeChangeSet, see
commitAndSaveChangeSet
.
removeChangeSet
in interface Transaction
id
- an integer representing the change set to remove from the
persistent store.Transaction.commitAndSaveChangeSet()
,
Transaction.applyChangeSet(int)
public void rollback()
appMod.getTransaction().rollback();When this method is invoked,
beforeRollback
events are posted to the listeners, the changes
are discarded,
afterRollback
events are posted, and transient listeners are deleted from the transaction.
For both events, non-transient listeners preceed transient listeners.
In the following example, a method named updateAttr has been implemented to update a row of a View Object vo with the value newAttrVal. If updateAttr succeeds (returns true), the code commits the transaction; otherwise, it rolls the transaction back:
// Assume that appMod has been declared and initialized elsewhere. try { if (updateAttr(vo, newAttrVal)) { // Commit changes to the database, making // updated data available to other Application Modules. appMod.getTransaction().commit(); System.out.println("\n Transaction committed. \n"); } else { appMod.getTransaction().rollback(); System.out.println("\n Transaction rolled back. \n"); } } catch (Exception e) { e.printStackTrace(); }
Note, if your Application Module is an EJB session bean, a new transaction is started for you automatically after calling rollback. You do not have to explicitly start a new transaction.
rollback
in interface Transaction
DBTransaction
,
TransactionListener.afterRollback(TransactionEvent)
,
TransactionListener.beforeRollback(TransactionEvent)
public void addTransactionListener(TransactionListener listener)
Listeners are notified of the commit and rollback events
generated by the commit
and rollback
methods.
The framework adds modified top-level Entity Objects to this list.
This method is available only on the middle tier; it is not available on the client.
This method should not be overridden.
addTransactionListener
in interface DBTransaction
listener
- the subscriber to be added.commit()
,
rollback()
public void addTransactionListenerNoCheck(TransactionListener listener)
Adds a listener to the transaction's list, without checking whether the listener was present.
Listeners are notified of the commit and rollback events
generated by the commit
and rollback
methods.
The framework adds modified top-level Entity Objects to this list.
addTransactionListenerNoCheck
in interface DBTransaction
listener
- the subscriber to be added.public void removeTransactionListener(TransactionListener listener)
removeTransactionListener
in interface DBTransaction
listener
- the subscriber to be removed.protected java.util.ArrayList getTransactionListenersList()
protected java.util.ArrayList getTransactionPostListenersList()
protected java.util.ArrayList getValidationListenersList()
public void addTransactionPostListener(TransactionPostListener listener)
When postChanges
is invoked,
each listed TransactionPostListener
is notified to post any changes to the database.
addTransactionPostListener
in interface DBTransaction
listener
- the subscriber to be added.postChanges()
public void addTransactionPostListenerNoCheck(TransactionPostListener listener)
Adds a subscriber to the transaction's post-events list, without checking if it is already present.
When postChanges()
is invoked,
each listed TransactionPostListener
is notified to post any changes to the database.
addTransactionPostListenerNoCheck
in interface DBTransaction
listener
- the subscriber to be added.postChanges()
public void removeTransactionPostListener(TransactionPostListener listener)
removeTransactionPostListener
in interface DBTransaction
listener
- the subscriber to be removed.public void postChanges()
This method bypasses the validation cycle and can allow invalid data to be posted to the database. As a side effect of this method, database triggers or other constraints might be fired as a result of posting data. However, invalid changes cannot be committed, as the commit() method validates all changes before committing them.
Typically, applications should call this method if they must execute SQL operations or queries with the current cached-state of data, before validating the changes.
postChanges
in interface Transaction
commit()
public void setBatchModeForEntity(EntityDefImpl def, boolean mode)
def
- - Def for the desired entity typemode
- - whether to turn batch updates on or off. if false rest of the arguments are ignored.
If attribute list is null or has no elements, then Def is consulted for any default setting
in the def for AttributeLists for these purposes. If Def does not have an attribute list
then ALL attributes participate in the concerned operation.protected void postChanges(TransactionEvent te)
Synchronizes all the changes in this transaction-cache with the database. These changes are still not visible to other users/transaction.
Executes a savepoint before starting to post any changes. Then, all non-transient and transient TransactionPostListeners are notified to post their changes, in that order. In case of any exception, rollsback the transaction to the savepoint. and throws DMLException.
For Entity types that are marked to use batch update in case of oracle jdbc, first a maximal-attribute-changed-set is collected for each entity-type so that batch statements could be created for all changes. Then postChanges() is called on all the entities in the transaction just like in the normal case, but entity does not execute the dml, instead simply adds the DML to a batched statement which is executed after all entities are done adding their changes to the batch. Then for each entity type that has batched statements executes the batches (deletes first, followed by inserts and then updates). On any eror during the batch operations, the entire transaction is rolled back to the savepoint as described earlier.
protected boolean hasRollbackSavePoint()
public java.sql.Statement createStatement(int noRowsPrefetch)
DBTransaction
Applications may use this method to create a JDBC statement object to execute application specific SQL statements directly, so that the modifications are committed to the database in a single transaction through this object.
createStatement
in interface DBTransaction
noRowsPrefetch
- the number of rows to prefetch when executing
this statement's query.
public java.sql.CallableStatement createCallableStatement(java.lang.String str, int noRowsPrefetch)
DBTransaction
Applications may use this method to create a JDBC callable statement object to execute application-specific SQL statements directly, so that the modifications are committed to the database in a single transaction through this object.
createCallableStatement
in interface DBTransaction
str
- the CallableStatement instance's SQL statement.noRowsPrefetch
- the number of rows to prefetch when executing
this statement's query. If this parameter is set to DBTransaction.DEFAULT,
then the default value from the jdbc driver is used.
public java.sql.PreparedStatement createPreparedStatement(java.lang.String str, int noRowsPrefetch)
DBTransaction
Applications may use this method to create a JDBC callable statement object to execute application specific SQL statements directly, so that the modifications are committed to the database in a single transaction through this object.
createPreparedStatement
in interface DBTransaction
str
- the PreparedStatement instance's SQL statement.noRowsPrefetch
- the number of rows to prefetch when executing
this statement's query. If this parameter is set to DBTransaction.DEFAULT,
then the default value from the jdbc driver is used.
public int executeCommand(java.lang.String command)
This method provides a way of bypassing the framework to query the database directly. Internally, the method passes the specified SQL command to a statement on the JDBC connection and executes it.
The following code example uses executeCommand. The SQL string is designed to update the EMP table. This example passes the string to executeCommand, then prints a message to report how many rows were actually updated.
public static void demoUpdateColumn(ApplicationModule appMod) { String sqlStr = "UPDATE EMP " + "SET MGR=7007 " + "WHERE MGR=7698 "; int n = appMod.getTransaction().executeCommand(sqlStr); System.out.println("Updated " + n + " rows."); }
Be careful when using executeCommand, because it will execute any valid SQL statement. For example, you could perform an operation like the following DDL command:
appMod.getTransaction().executeCommand("DROP TABLE MYTEMPTABLE");
A pending database transaction could be committed inadvertently due to the implicit commit performed by DDL operations, as well as having any row locks released.
executeCommand
in interface Transaction
command
- a valid SQL statement.
InvalidParamException
- if command is empty.
SQLStmtException
- if command fails.public java.lang.String dumpQueryResult(java.lang.String query, java.lang.String dumpClassName, java.lang.String[] data)
The following code example uses dumpQueryResult.
public static void demoSimpleFetch(ApplicationModule appMod) { // Define and execute a simple SQL statement. String sqlStr = "SELECT Emp.ename FROM EMP Emp "; // dumpQueryResult is a utility method for testing queries. String result = appMod.getTransaction().dumpQueryResult(sqlStr, "oracle.jbo.server.QueryDumpTab", null); System.out.println(sqlStr); System.out.println(result); }
dumpQueryResult
in interface Transaction
query
- the SQL query statement.dumpClassName
- the class that dumps the result to a string.data
- an array of data items.public int getLockingMode()
am.getTransaction().getLockingMode();The possible return values are:
If not set by setLockingMode()
,
the locking mode defaults to LOCK_PESSIMISTIC
.
getLockingMode
in interface Transaction
public void setLockingMode(int mode)
Changing the locking mode affects only subsequent locks. Current locks are not affected.
setLockingMode
in interface Transaction
mode
- one of LOCK_PESSIMISTIC, LOCK_OPTIMISTIC
or LOCK_NONE.public EntityCache lookupEntityCache(EntityDefImpl source)
public EntityCache findEntityCache(EntityDefImpl source)
public EntityCache getEntityCache(EntityDefImpl source)
public void removeEntityCache(EntityDefImpl source)
public void removeEntityCacheByName(java.lang.String name)
public void clearEntityCache(java.lang.String entityName)
Transaction
clearEntityCache
in interface Transaction
entityName
- the name of the entity whose cache is to
be cleared. If null
, caches
for all entities are cleared.public void addToValidationListeners(ValidationListener entity)
The entity listener will be notified to perform its own validation when this validation manager is validated.
This method overrides the
ValidationManager.addToValidationListeners(ValidationListener)
method.
addToValidationListeners
in interface ValidationManager
entity
- an entity validation listener.public JboTransValidationManager getTransValidationManager()
public java.util.HashMap getTransValidations()
getTransValidations
in interface JboTransValidationManager
public java.util.ArrayList getTransValidationList()
getTransValidationList
in interface JboTransValidationManager
public JboTransAttrValidationManager getTransAttrValidationManager()
public java.util.HashMap getTransAttrValidations()
getTransAttrValidations
in interface JboTransAttrValidationManager
public java.util.ArrayList getTransAttrValidationList()
getTransAttrValidationList
in interface JboTransAttrValidationManager
public void putTransValEntry(JboTransValidatorInterface validator, JboValidatorContext valCtx)
putTransValEntry
in interface JboTransValidationManager
public void putTransAttrValEntry(JboTransValidatorInterface validator, JboValidatorContext valCtx)
putTransAttrValEntry
in interface JboTransAttrValidationManager
public void validate()
ValidationListener
list.
Typically
all top-level entities which were invalidated through the framework will
be in this list. Listeners are removed as they are validated.
The advantage of calling validate() is that the data stays in the middle tier. Data is not posted to the database, thus avoiding the possible firing of database triggers or constraints.
validate
in interface ValidationManager
validate
in interface Transaction
public void setValidationThreshold(int count)
DBTransaction
When commit()
is invoked the framework attempts to validate
the transaction's modifications, making count attempts before
failing with an exception. This mechanism allows applications to update
data in the cache within the validation phase, and validate them
before they are posted.
setValidationThreshold
in interface DBTransaction
count
- the new threshold value.public int getValidationThreshold()
DBTransaction
getValidationThreshold
in interface DBTransaction
public void setPostThreshold(int count)
DBTransaction
When commit()
is invoked the framework attempts to post
the transaction's modifications, making count attempts before
failing with an exception. This mechanism allows applications to update
data in the cache within the post phase, and commit all changes.
setPostThreshold
in interface DBTransaction
count
- the new threshold value.public int getPostThreshold()
DBTransaction
getPostThreshold
in interface DBTransaction
public int getBatchPostExceptionThreshold()
getBatchPostExceptionThreshold
in interface DBTransaction
setBatchPostExceptionThreshold(int)
public void setBatchPostExceptionThreshold(int count)
setBatchPostExceptionThreshold
in interface DBTransaction
public boolean isDirty()
isDirty
in interface Transaction
public void dumpEntityCaches(java.io.Writer out)
public void showCursorUsage(java.io.Writer out)
protected void doCommit()
commit
method to issue the commit call.
This method is called just
before the transaction is committed on the JDBC connection. Override this
method to provide your own handler for the commit operation.
protected void doRollback()
rollback
method to issue the rollback call.
This method is called just
before the transaction is rolled back on the JDBC connection. Override this
method to provide your own handler for the rollback operation.
public void connect(java.sql.Connection sqlConnection)
connect
in interface DBTransaction
public void connect(java.lang.String url)
Use the connect
method on the Transaction
interface instead.
connect
in interface Transaction
url
- a database url of the form jdbc:subprotocol:subname.public void connect(java.lang.String url, java.util.Properties info)
Use the connect
method on the Transaction
interface instead.
connect
in interface Transaction
url
- a database url of the form jdbc:subprotocol:subname.info
- a list of arbitrary string tag/value pairs to be used as
connection arguments. Normally, at least "user" and
"password" properties should be included.public void connect(java.lang.String url, java.lang.String user, java.lang.String password)
Use the connect
method on the Transaction
interface instead.
connect
in interface Transaction
url
- a database url of the form jdbc:subprotocol:subname.user
- the database user on whose behalf the connection is being made.password
- the user's password.public void connectToDataSource(java.lang.String nsUrl, java.lang.String nsUser, java.lang.String nsPasswd, java.lang.String dsUrl)
Transaction
connectToDataSource
in interface Transaction
nsUrl
- Url to the jndi namespace where the datasource is boundnsUser
- User name that is used to access the namespace.nsPasswd
- nsUsers' passwddsUrl
- Datasource name as bound in the namespace.
Name can be the fully qaultified url such as
jdbc_access://test/ds/db1 otherwise the
the url prefix jdbc_acess:// is prepended to the
datasource name for lookup.public void connectToDataSource(java.lang.String nsUrl, java.lang.String nsUser, java.lang.String nsPasswd, java.lang.String dsUrl, java.lang.String user, java.lang.String passwd)
Transaction
connectToDataSource
in interface Transaction
nsUrl
- Url to the jndi namespace where the datasource is boundnsUser
- User name that is used to access the namespace.nsPasswd
- nsUsers' passwddsUrl
- Datasource name as bound in the namespace.
Name can be the fully qaultified url such as
jdbc_access://test/ds/db1 otherwise the
the url prefix jdbc_acess:// is prepended to the
datasource name for lookup.user
- Username for which the connection is acquired from the datasourcepasswd
- User's password.public void connectToDataSource(javax.sql.DataSource ds, boolean isJTAbased)
connectToDataSource
in interface DBTransaction
public void connectToDataSource(javax.sql.DataSource ds, java.lang.String user, java.lang.String passwd, boolean isJTAbased)
connectToDataSource
in interface DBTransaction
public void connectToDataSource(java.util.Hashtable env, java.lang.String dsName, java.lang.String user, java.lang.String passwd, boolean isJTABased)
Transaction
connectToDataSource
in interface Transaction
env
- Envirionment used the create initial context.
May be null.dsName
- Datasource name as bound in the namespace.user
- Username for which the connection is acquired from the datasourcepasswd
- User's password.isJTABased
- True if datasource is XADataSource implementation.
If true, the tranasction is assumed to be controlled
by an external transaction manager.public void connectToDataSource(java.util.Hashtable env, java.lang.String dsName, boolean isJTABased)
Transaction
connectToDataSource
in interface Transaction
env
- Envirionment used the create initial context.
May be null.dsName
- Datasource name as bound in the namespace.isJTABased
- True if datasource is XADataSource implementation.
If true, the tranasction is assumed to be controlled
by an external transaction manager.public ConnectionMetadata getConnectionMetadata()
Transaction
getConnectionMetadata
in interface Transaction
public boolean isConnected()
isConnected
in interface Transaction
public void disconnect(boolean retainState)
If disconnect is invoked with retainState equal to true then this
transaction's JDBC connection will be closed but, the root application
module will continue to reference this transaction and its state. The
transaction state may include unposted database changes and cached result
sets. In the middle tier, reconnect
on the DBTransaction
interface
may be invoked to re-establish a JDBC connection for this transaction. If
connection pooling is enabled for this middle tier instance this
connection may represent a recycled connection.
The developer should take measures to ensure that the following requirements are met before attempting to disconnect a JDBC connection and retain application module state. All of these validations are not currently performed by the disconnection implementation because of performance considerations:
All non-forward only view objects should have fetched in all data
If pessimistic locking is enabled, all pending changes should be commited/rolled back.
All changes that have been posted to the database should be commited/rolled back>/p>
disconnect
in interface DBTransaction
disconnect
in interface Transaction
public void reconnect()
disconnect(boolean)
with
the retainState parameter equal to true or, if a previous isConnected()
request had discovered a stale JDBC connection. If it is invoked
otherwise the method will do nothing.
reconnect
in interface DBTransaction
reconnect
in interface Transaction
disconnect(boolean)
public void reconnect(boolean force)
reconnect
in interface Transaction
force
- force a reconnect, should usually be false.public void disconnect()
As an alternative, you can also use the disconnect
method on the Transaction
interface.
disconnect
in interface Transaction
public TransactionHandler getTransactionHandler()
getTransactionHandler
in interface DBTransaction
public void setTransactionHandler(TransactionHandler txnHandler)
setTransactionHandler
in interface DBTransaction
protected ApplicationModuleImpl getTxnApplicationModuleImpl()
protected java.util.Set<ApplicationModuleImpl> getActiveApplicationModuleImpls()
public ApplicationModule getRootApplicationModule()
getRootApplicationModule
in interface DBTransaction
public EntityImpl createEntityInstance(EntityDefImpl entityDef, AttributeList al)
EntityImpl
object based on the given defintion, in the context
of the root Application Module. Passes the
attribute list, al, to the
create
method on the EntityImpl.
createEntityInstance
in interface DBTransaction
entityDef
- the EntityDef defintion to use to create the EntityImpl.al
- attribute list to pass to the create() method on the
EntityImpl.
public EntityImpl createEntityInstance(java.lang.String entityDefName, AttributeList al)
EntityImpl
object based on the given defintion, in the context
of the root Application Module. Passes the
attribute list, al, to the
create
method on the EntityImpl.
createEntityInstance
in interface DBTransaction
entityDefName
- the String name of entity defintion to use to create the EntityImpl.al
- attribute list to pass to the create method on the
EntityImpl.
public EntityImpl findByPrimaryKey(EntityDefImpl entityDef, Key key)
Given the EntityDef object and the table's primary key, this method returns the associated Entity Object. If the Entity has not already been brought into the cache by any of the View Objects, this method will cause the Entity to be fetched from the database. This method returns null if the Entity Object is not found.
For example, use this method to create a set of Entity Objects based on a relational schema without the need to create any Application Modules or View Objects. To do this, use findByPrimaryKey to locate a specific object and then traverse association accessors to get to all the other objects.
findByPrimaryKey
in interface DBTransaction
entityDef
- the Entity Def object to to be used to find the instance.key
- the Primary Key.
public EntityImpl findByPrimaryKey(java.lang.String entityDefName, Key key)
Given the String name of the EntityDef and the table's primary key, this method returns the associated Entity Object. If the Entity has not already been brought into the cache by any of the View Objects, this method will cause the Entity to be fetched from the database.
This method returns null if the Entity Object is not found.
For example, use this method to create a set of Entity Objects based on a relational schema without the need to create any Application Modules or View Objects. To do this, use findByPrimaryKey to locate a specific object and then traverse association accessors to get to all the other objects.
findByPrimaryKey
in interface DBTransaction
entityDefName
- the name of the defintion to to be used to find the instance.key
- the Primary Key.
public ApplicationModule createApplicationModule(java.lang.String amName, java.lang.String defName)
oracle.jbo.ApplicationModule nestedAM = dbtxn.createApplicationModule("subAppMod", "PackageName.AppModuleName");
This application module can control the namespace of objects that are contained within it.
createApplicationModule
in interface DBTransaction
amName
- the name to be given to the Application Module.
If amName
is empty, a name is generated.defName
- the name of the Application Module definition to be used.
If null
a default definition is used.
public ApplicationModule findApplicationModule(java.lang.String amName)
oracle.jbo.ApplicationModule am = dbTxn.findApplicationModule("KpiAM");
findApplicationModule
in interface DBTransaction
amName
- the name of the Application Module.
InvalidObjNameException
- if the name cannot be found.public ViewObject createViewObject(java.lang.String voDefName)
ViewObject
class. For more information on anonymous
View Objects, see Using Anonymous View Objects
Calling method should also call remove() for the View Object to be properly garbage-collected.
createViewObject
in interface DBTransaction
voDefName
- the name of the ViewObject
class.
public ViewObject createViewObjectFromQueryClauses(java.lang.String eoName, java.lang.String selectClause, java.lang.String fromClause, java.lang.String whereClause, java.lang.String orderByClause)
Creates an anonymous query definition from an Entity Object and parts of a SQL statement. For more information on anonymous View Objects, see Using Anonymous View Objects
Calling method should also call remove() for the View Object to be properly garbage-collected.
createViewObjectFromQueryClauses
in interface DBTransaction
eoName
- the name of a EntityObject
beaninfo class.selectClause
- an SQL statement SELECT clause.fromClause
- an SQL statement FROM clause.whereClause
- an SQL statement WHERE clause.orderByClause
- an SQL statement ORDERBY clause.public ViewObject createViewObjectFromQueryStmt(java.lang.String sqlStatement)
Calling method should also call remove() for the View Object to be properly garbage-collected.
The following example creates a View Object that queries for the system date:
ViewObject vo = tx.createViewObjectFromQueryStmt("select sysdate from dual"); Row row = vo.first(); Date now = (Date) row.getAttribute(0); System.out.println("The date/time is now: "+now); oracle.sql.DATE nextMonth = now.addMonths(1); System.out.println("The date/time is now: "+nextMonth);
createViewObjectFromQueryStmt
in interface DBTransaction
sqlStatement
- a SQL statement.public ViewObject createViewObjectFromQueryStmt(java.lang.String sqlStatement, java.lang.String voImplClassName)
oracle.jbo.server.ViewObjectImpl
class.
createViewObjectFromQueryStmt
in interface DBTransaction
sqlStatement
- a SQL statement.voImplClassName
- the name of a subclass of oracle.jbo.server.ViewObjectImpl
public ViewObject findViewObject(java.lang.String voName)
findViewObject
in interface DBTransaction
voName
- the name of the view object.
null
if the view object
is not found.
NoObjException
- if an AM-qualified name was specified and the
containing application module could not be found.
InvalidObjNameException
- if voName
is an invalid name.
voName
must be a vaild Java name.public ApplicationModule createApplicationModule(java.lang.String defName)
getDbTransaction().createApplicationModule()
then use that Application Module as its local scratchpad. The routine can pass that Application Module around to others. The anonymous Application Module provides a temporary namespace and can be discarded with one .remove() call to clean-up just the things that the Entity Object needed temporarily.
createApplicationModule
in interface DBTransaction
defName
- the name of the Application Module definition to be used.
If null
a default definition is used.
public ViewLink createViewLink(java.lang.String viewLinkDefName, ViewObject master, ViewObject detail)
createViewLink
in interface DBTransaction
viewLinkDefName
- the name of the definition to be used to create the link.
If empty a default definition will be used.master
- the link's source.detail
- the link's destination.
InvalidParamException
- if master
or detail
are invalid.
InvalidObjNameException
- if viewLinkName
is invalid.
NameClashException
- if viewLinkName
already exists.public ViewLink createViewLinkFromEntityAssocName(java.lang.String entityAssocName, ViewObject master, ViewObject detail)
createViewLinkFromEntityAssocName
in interface DBTransaction
entityAssocName
- the entity association that the View Link will represent.master
- the link's source.detail
- the link's destination.
InvalidParamException
- if master
,
detail
, or entityAssocName
are invalid.
InvalidObjNameException
- if viewLinkName
is invalid.
NameClashException
- if viewLinkName
already exists.public ViewLink createViewLinkBetweenViewObjects(java.lang.String accessorName, ViewObject master, AttributeDef[] srcAttrs, ViewObject detail, AttributeDef[] destAttrs, java.lang.String assocClause)
createViewLinkBetweenViewObjects
in interface DBTransaction
accessorName
- the name to be given to the View Link's accessor.master
- the link's source.srcAttrs
- link attributes taken from the master View Object.detail
- the link's destination.destAttrs
- link attributes taken from the detail View Object.assocClause
-
InvalidParamException
- if master
or detail
are invalid.
InvalidObjNameException
- if viewLinkName
or accessorName
are invalid.
NameClashException
- if viewLinkName
or accessorName
already exist.public void addWarning(JboWarning warn)
addWarning
in interface DBTransaction
warn
- a warning message.public Session getSession()
getSession
in interface DBTransaction
java.lang.IllegalStateException
- if the session information cannot be found.protected java.sql.Connection getJdbcConnection()
public java.lang.Object createRef(java.lang.String structName, byte[] data)
createRef
in interface Transaction
public void addTransactionStateListener(TransactionStateListener target)
addTransactionStateListener
in interface Transaction
public void removeTransactionStateListener(TransactionStateListener target)
removeTransactionStateListener
in interface Transaction
public void addViewClearCacheListener(ViewClearCacheListener target)
addViewClearCacheListener
in interface Transaction
public void removeViewClearCacheListener(ViewClearCacheListener target)
removeViewClearCacheListener
in interface Transaction
public java.sql.Timestamp getCurrentDbTime()
public void setTrackNewAndModifiedRowsOnly(boolean flag)
setTrackNewAndModifiedRowsOnly
in interface DBTransaction
public boolean isTrackNewAndModifiedRowsOnly()
isTrackNewAndModifiedRowsOnly
in interface DBTransaction
public final void setPostChangesFlag(int flag)
POST_ALL_NO_RESET_ON_EXCEPTION
- Attempt to post all entities
that are in the transaction's post list and do not reset the entites on exception.
POST_ALL_RESET_ON_EXCEPTION
- Attempt to post all entities
that are in the transaction's post list and reset the entity state to state before
post started.
POST_ABORT_ON_FIRST_EXCEPTION
- Abort the post cycle on the
first exception.
public final int getPostChangesFlag()
protected void checkConnected() throws NotConnectedException
NotConnectedException
public boolean isConnected(boolean pingDatabase)
isConnected
in interface DBTransaction
protected int getTransactionState()
public int getDMLOperationTimeOut()
Transaction
DML_OPERATION_TIMEOUT_WAIT_FOREVER
.
getDMLOperationTimeOut
in interface Transaction
public void setDMLOperationTimeOut(int timeOutMills)
Transaction
DML_OPERATION_TIMEOUT_WAIT_FOREVER
(-1),
which means that the DML operations will not time out. The user will be able to
cancel the long running operations by calling cancelDMLOperations()
started by this Transaction
during postChanges
.
If a positive value of timeout is specified the operation is monitored by a
global monitor thread. The monitor thread waits the specified amount of time
(approximately) in milli-seconds, and cancels the operation by
calling JDBC's Statement.cancel()
.
setDMLOperationTimeOut
in interface Transaction
timeOutMills
- if non-negative, number of milli-seconds before the
DML operation is timed out.public void addLongRunningDMLOperationHandle(LongRunningStatementHandle handle)
public void removeLongRunningDMLOperationHandle(LongRunningStatementHandle handle)
public boolean cancelDMLOperations()
Transaction
cancelDMLOperations
in interface Transaction
false
is returned if a DML cancel fails.public void setForceDeferValidation(boolean bForceDefer)
public boolean isForceDeferValidation()
|
Oracle Fusion Middleware Java API Reference for Oracle ADF Model 11g Release 2 (11.1.2.0.0) E17483-01 |
||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |