Note that one must still set OPENMODE_FORUPDATE to be able to change rows in the scan. So to enable update locks for an updating scan one provides (OPENMODE_FORUPDATE | OPENMODE_USE_UPDATE_LOCKS) 

The request to get the table lock (any table lock including intent or "real" table level lock), will not wait if it can't be granted. A lock timeout will be returned. Note that subsequent row locks will wait if the application has not set a 0 timeout and if the call does not have a wait parameter (like OpenConglomerate.fetch(). 

 public  void abort() throws StandardException
Abort all changes made by this transaction since the last commit, abort
or the point the transaction was started, whichever is the most recent.
All savepoints within this transaction are released, and all resources
are released (held or non-held).

 public  void addColumnToConglomerate(long conglomId,
    int column_id,
    Storable template_column,
    int collation_id) throws StandardException
Add a column to a conglomerate.  

The Storage system will block this action until it can get an exclusive
container level lock on the conglomerate.  The conglomerate must not be
open in the current transaction, this means that within the current 
transaction there must be no open ConglomerateController's or 
ScanControllers.  It may not be possible in some implementations of the
system to catch this error in the store, so it is up to the caller to 
insure this.

The column can only be added at the spot just after the current set of
columns.  

The template_column must be nullable.  

After this call has been made, all fetches of this column from rows that
existed in the table prior to this call will return "null".

 public boolean anyoneBlocked()
Return true if any transaction is blocked (even if not by this one).

 public  void commit() throws StandardException
Commit this transaction.  All savepoints within this transaction are 
released.  All non-held conglomerates and scans are closed.

 public DatabaseInstant commitNoSync(int commitflag) throws StandardException
"Commit" this transaction without sync'ing the log.  Everything else is
identical to commit(), use this at your own risk.


bits in the commitflag can turn on to fine tuned the "commit":
KEEP_LOCKS                          - no locks will be released by the 
commit and no post commit processing 
will be initiated.  If, for some 
reasons, the locks cannot be kept 
even if this flag is set, then the 
commit will sync the log, i.e., it 
will revert to the normal commit.

READONLY_TRANSACTION_INITIALIZATION - Special case used for processing
while creating the transaction.  
Should only be used by the system
while creating the transaction to
commit readonly work that may have
been done using the transaction
while getting it setup to be used
by the user.  In the future we should
instead use a separate tranaction to
do this initialization.  Will fail
if called on a transaction which
has done any updates.

 public  void compressConglomerate(long conglomId) throws StandardException
Return free space from the conglomerate back to the OS.

Returns free space from the conglomerate back to the OS.  Currently
only the sequential free pages at the "end" of the conglomerate can
be returned to the OS.

 public boolean conglomerateExists(long conglomId) throws StandardException
Check whether a conglomerate exists.

 public int countOpens(int which_to_count) throws StandardException
Report on the number of open conglomerates in the transaction.

There are 4 types of open "conglomerates" that can be tracked, those
opened by each of the following: openConglomerate(), openScan(), 
createSort(),  and openSort().  Scans opened by openSortScan() are 
tracked the same as those opened by openScan().  This routine can be
used to either report on the number of all opens, or may be used to
track one particular type of open.

This routine is expected to be used for debugging only.  An 
implementation may only track this info under SanityManager.DEBUG mode.
If the implementation does not track the info it will return -1 (so
code using this call to verify that no congloms are open should check
for return <= 0 rather than == 0).

The return value depends on the "which_to_count" parameter as follows:


OPEN_CONGLOMERATE  - return # of openConglomerate() calls not close()'d.

OPEN_SCAN          - return # of openScan() + openSortScan() calls not
                     close()'d.

OPEN_CREATED_SORTS - return # of sorts created (createSort()) in 
                     current xact.  There is currently no way to get
                     rid of these sorts before end of transaction.

OPEN_SORT          - return # of openSort() calls not close()'d.

OPEN_TOTAL         - return total # of all above calls not close()'d.

    - note an implementation may return -1 if it does not track the
      above information.

 public long createAndLoadConglomerate(String implementation,
    DataValueDescriptor[] template,
    ColumnOrdering[] columnOrder,
    int[] collationIds,
    Properties properties,
    int temporaryFlag,
    RowLocationRetRowSource rowSource,
    long[] rowCount) throws StandardException
Create a conglomerate and load (filled) it with rows that comes from the
row source without loggging.  

Individual rows that are loaded into the conglomerate are not
logged. After this operation, the underlying database must be backed up
with a database backup rather than an transaction log backup (when we have
them). This warning is put here for the benefit of future generation.


This function behaves the same as @see createConglomerate except it also
populates the conglomerate with rows from the row source and the rows that
are inserted are not logged.

 public BackingStoreHashtable createBackingStoreHashtableFromScan(long conglomId,
    int open_mode,
    int lock_level,
    int isolation_level,
    FormatableBitSet scanColumnList,
    DataValueDescriptor[] startKeyValue,
    int startSearchOperator,
    Qualifier[][] qualifier,
    DataValueDescriptor[] stopKeyValue,
    int stopSearchOperator,
    long max_rowcnt,
    int[] key_column_numbers,
    boolean remove_duplicates,
    long estimated_rowcnt,
    long max_inmemory_rowcnt,
    int initialCapacity,
    float loadFactor,
    boolean collect_runtimestats,
    boolean skipNullKeyColumns,
    boolean keepAfterCommit) throws StandardException
Create a HashSet which contains all rows that qualify for the 
described scan.

All parameters shared between openScan() and this routine are 
interpreted exactly the same.  Logically this routine calls
openScan() with the passed in set of parameters, and then places
all returned rows into a newly created HashSet and returns, actual
implementations will likely perform better than actually calling
openScan() and doing this.  For documentation of the openScan 
parameters see openScan().

 public long createConglomerate(String implementation,
    DataValueDescriptor[] template,
    ColumnOrdering[] columnOrder,
    int[] collationIds,
    Properties properties,
    int temporaryFlag) throws StandardException
Create a conglomerate.

Currently, only "heap"'s and ""btree secondary index"'s are supported, 
and all the features are not completely implemented.  
For now, create conglomerates like this:

TransactionController tc;
long conglomId = tc.createConglomerate(
"heap", // we're requesting a heap conglomerate
template, // a populated template is required for heap and btree.
null, // no column order
null, // default collation order for all columns
null, // default properties
0); // not temporary

• "baseConglomerateId" (integer). The conglomerate id of the base conglomerate is never actually accessed by the b-tree secondary index implementation, it only serves as a namespace for row locks. This property is required.
• "rowLocationColumn" (integer). The zero-based index into the row which the b-tree secondary index will assume holds a @see RowLocation of the base row in the base conglomerate. This value will be used for acquiring locks. In this implementation RowLocationColumn must be the last key column. This property is required.
• "allowDuplicates" (boolean). If set to true the table will allow rows which are duplicate in key column's 0 through (nUniqueColumns - 1). Currently only supports "false". This property is optional, defaults to false.
• "nKeyFields" (integer) Columns 0 through (nKeyFields - 1) will be included in key of the conglomerate. This implementation requires that "nKeyFields" must be the same as the number of fields in the conglomerate, including the rowLocationColumn. Other implementations may relax this restriction to allow non-key fields in the index. This property is required.
• "nUniqueColumns" (integer) Columns 0 through "nUniqueColumns" will be used to check for uniqueness. So for a standard SQL non-unique index implementation set "nUniqueColumns" to the same value as "nKeyFields"; and for a unique index set "nUniqueColumns" to "nKeyFields - 1 (ie. don't include the rowLocationColumn in the uniqueness check). This property is required.
• "maintainParentLinks" (boolean) Whether the b-tree pages maintain the page number of their parent. Only used for consistency checking. It takes a certain amount more effort to maintain these links, but they're really handy for ensuring that the index is consistent. This property is optional, defaults to true.

 public long createSort(Properties implParameters,
    DataValueDescriptor[] template,
    ColumnOrdering[] columnOrdering,
    SortObserver sortObserver,
    boolean alreadyInOrder,
    long estimatedRows,
    int estimatedRowSize) throws StandardException
Create a sort.  Rows are inserted into the sort with a
sort controller, and subsequently retrieved with a
sort scan controller. The rows come out in the order
specified by the parameters.

Sorts also do aggregation. The input (unaggregated) rows
have the same format as	the aggregated rows, and the
aggregate results are part of the both rows.  The sorter,
when it notices that a row is a duplicate of another,
calls a user-supplied aggregation method (see interface
Aggregator), passing it both rows.  One row is known as
the 'addend' and the other the 'accumulator'. The
aggregation method is assumed to merge the addend
into the accumulator. The sort then discards the addend
row.

So, for the query:

select a, sum(b)
from t
group by a

The input row to the sorter would have one column for
a and another column for sum(b).  It is up to the caller
to get the format of the row correct, and to initialize
the	aggregate values correctly (null for most aggregates,
0 for count).

Nulls are always considered to be ordered in a sort, that is,
null compares equal to null, and less than anything else.

 public Object createXATransactionFromLocalTransaction(int format_id,
    byte[] global_id,
    byte[] branch_id) throws StandardException
Convert a local transaction to a global transaction.

Get a transaction controller with which to manipulate data within
the access manager.  Tbis controller allows one to manipulate a
global XA conforming transaction.

Must only be called a previous local transaction was created and exists
in the context.  Can only be called if the current transaction is in
the idle state.  Upon return from this call the old tc will be unusable,
and all references to it should be dropped (it will have been implicitly
destroy()'d by this call.

The (format_id, global_id, branch_id) triplet is meant to come exactly
from a javax.transaction.xa.Xid.  We don't use Xid so that the system
can be delivered on a non-1.2 vm system and not require the javax classes
in the path.

 public String debugOpened() throws StandardException
Return a string with debug information about opened congloms/scans/sorts.

Return a string with debugging information about current opened
congloms/scans/sorts which have not been close()'d.
Calls to this routine are only valid under code which is conditional
on SanityManager.DEBUG.

 public GroupFetchScanController defragmentConglomerate(long conglomId,
    boolean online,
    boolean hold,
    int open_mode,
    int lock_level,
    int isolation_level) throws StandardException
Compress table in place.

Returns a GroupFetchScanController which can be used to move rows
around in a table, creating a block of free pages at the end of the
table.  The process will move rows from the end of the table toward
the beginning.  The GroupFetchScanController will return the 
old row location, the new row location, and the actual data of any
row moved.  Note that this scan only returns moved rows, not an
entire set of rows, the scan is designed specifically to be
used by either explicit user call of the SYSCS_ONLINE_COMPRESS_TABLE()
procedure, or internal background calls to compress the table.

The old and new row locations are returned so that the caller can
update any indexes necessary.

This scan always returns all collumns of the row.

All inputs work exactly as in openScan().  The return is 
a GroupFetchScanController, which only allows fetches of groups
of rows from the conglomerate.

 public  void destroy()
Abort the current transaction and pop the context.
	*

 public  void dropConglomerate(long conglomId) throws StandardException
Drop a conglomerate.  The conglomerate must not be open in
the current transaction.  This also means that there must
not be any active scans on it.

 public  void dropSort(long sortid) throws StandardException
Drop a sort. 

Drop a sort created by a call to createSort() within the current 
transaction (sorts are automatically "dropped" at the end of a 
transaction.  This call should only be made after all openSortScan()'s
and openSort()'s have been closed.

 public boolean fetchMaxOnBtree(long conglomId,
    int open_mode,
    int lock_level,
    int isolation_level,
    FormatableBitSet scanColumnList,
    DataValueDescriptor[] fetchRow) throws StandardException
Retrieve the maximum value row in an ordered conglomerate.

Returns true and fetches the rightmost non-null row of an ordered 
conglomerate into "fetchRow" if there is at least one non-null row in 
the conglomerate.  If there are no non-null rows in the conglomerate it 
returns false.  Any row with
a first column with a Null is considered a "null" row.

Non-ordered conglomerates will not implement this interface, calls
will generate a StandardException.

RESOLVE - this interface is temporary, long term equivalent (and more) 
functionality will be provided by the openBackwardScan() interface.  

ISOLATION_SERIALIZABLE and MODE_RECORD locking for btree max:
The "BTREE" implementation will at the very least get a shared row lock
on the max key row and the key previous to the max.  
This will be the case where the max row exists in the rightmost page of
the btree.  These locks won't be released.  If the row does not exist in
the last page of the btree then a scan of the entire btree will be
performed, locks acquired in this scan will not be released.

Note that under ISOLATION_READ_COMMITTED, all locks on the table
are released before returning from this call.

 public long findConglomid(long containerid) throws StandardException
For debugging, find the conglomid given the containerid.

 public long findContainerid(long conglomid) throws StandardException
For debugging, find the containerid given the conglomid.

Will have to change if we ever have more than one container in 
a conglomerate.

 public AccessFactory getAccessManager()
Get reference to access factory which started this transaction.

 public String getActiveStateTxIdString()
Get string id of the transaction that would be when the Transaction
is IN active state. This method increments the Tx id of  current Tx
object if it is in idle state. 
Note: Use this method only  getTransactionIdString() is not suitable.

 public ContextManager getContextManager()
Get the context manager that the transaction was created with.

 public DynamicCompiledOpenConglomInfo getDynamicCompiledConglomInfo(long conglomId) throws StandardException
Return dynamic information about the conglomerate to be dynamically 
reused in repeated execution of a statement.

The dynamic info is a set of variables to be used in a given 
ScanController or ConglomerateController.  It can only be used in one 
controller at a time.  It is up to the caller to insure the correct 
thread access to this info.  The type of info in this is a scratch 
template for btree traversal, other scratch variables for qualifier 
evaluation, ...

 public FileResource getFileHandler()
Get an object to handle non-transactional files.

 public CompatibilitySpace getLockSpace()
Return an object that when used as the compatibility space for a lock
request, and the group object is the one returned by a
call to getOwner() on that object, guarantees that the lock
will be removed on a commit or an abort.

 public StaticCompiledOpenConglomInfo getStaticCompiledConglomInfo(long conglomId) throws StandardException
Return static information about the conglomerate to be included in a
a compiled plan.

The static info would be valid until any ddl was executed on the 
conglomid, and would be up to the caller to throw away when that 
happened.  This ties in with what language already does for other 
invalidation of static info.  The type of info in this would be 
containerid and array of format id's from which templates can be created.
The info in this object is read only and can be shared among as many 
threads as necessary.

 public String getTransactionIdString()
Get string id of the transaction.

This transaction "name" will be the same id which is returned in
the TransactionInfo information, used by the lock and transaction
vti's to identify transactions.

Although implementation specific, the transaction id is usually a number
which is bumped every time a commit or abort is issued.

 public Properties getUserCreateConglomPropList()
A superset of properties that "users" can specify.

A superset of properties that "users" (ie. from sql) can specify.  Store
may implement other properties which should not be specified by users.
Layers above access may implement properties which are not known at
all to Access.

This list is a superset, as some properties may not be implemented by
certain types of conglomerates.  For instant an in-memory store may not
implement a pageSize property.  Or some conglomerates may not support
pre-allocation.

This interface is meant to be used by the SQL parser to do validation
of properties passsed to the create table statement, and also by the
various user interfaces which present table information back to the 
user.

Currently this routine returns the following list:
     derby.storage.initialPages
     derby.storage.minimumRecordSize
     derby.storage.pageReservedSpace
     derby.storage.pageSize

 public boolean isGlobal()
Reveals whether the transaction is a global or local transaction.

 public boolean isIdle()
Reveals whether the transaction has ever read or written data.

 public boolean isPristine()
Reveals whether the transaction is read only.

 public  void logAndDo(Loggable operation) throws StandardException
Log an operation and then action it in the context of this
transaction.

This simply passes the operation to the RawStore which logs and
does it.

 public ConglomerateController openCompiledConglomerate(boolean hold,
    int open_mode,
    int lock_level,
    int isolation_level,
    StaticCompiledOpenConglomInfo static_info,
    DynamicCompiledOpenConglomInfo dynamic_info) throws StandardException
Open a conglomerate for use, optionally include "compiled" info.  

Same as openConglomerate(), except that one can optionally provide
"compiled" static_info and/or dynamic_info.  This compiled information
must have be gotten from getDynamicCompiledConglomInfo() and/or
getStaticCompiledConglomInfo() calls on the same conglomid being opened.
It is up to caller that "compiled" information is still valid and
is appropriately multi-threaded protected.

 public ScanController openCompiledScan(boolean hold,
    int open_mode,
    int lock_level,
    int isolation_level,
    FormatableBitSet scanColumnList,
    DataValueDescriptor[] startKeyValue,
    int startSearchOperator,
    Qualifier[][] qualifier,
    DataValueDescriptor[] stopKeyValue,
    int stopSearchOperator,
    StaticCompiledOpenConglomInfo static_info,
    DynamicCompiledOpenConglomInfo dynamic_info) throws StandardException
Open a scan on a conglomerate, optionally providing compiled info.

Same as openScan(), except that one can optionally provide
"compiled" static_info and/or dynamic_info.  This compiled information
must have be gotten from getDynamicCompiledConglomInfo() and/or
getStaticCompiledConglomInfo() calls on the same conglomid being opened.
It is up to caller that "compiled" information is still valid and
is appropriately multi-threaded protected.

 public ConglomerateController openConglomerate(long conglomId,
    boolean hold,
    int open_mode,
    int lock_level,
    int isolation_level) throws StandardException
Open a conglomerate for use.  

The lock level indicates the minimum lock level to get locks at, the
underlying conglomerate implementation may actually lock at a higher
level (ie. caller may request MODE_RECORD, but the table may be locked
at MODE_TABLE instead).

The close method is on the ConglomerateController interface.

 public GroupFetchScanController openGroupFetchScan(long conglomId,
    boolean hold,
    int open_mode,
    int lock_level,
    int isolation_level,
    FormatableBitSet scanColumnList,
    DataValueDescriptor[] startKeyValue,
    int startSearchOperator,
    Qualifier[][] qualifier,
    DataValueDescriptor[] stopKeyValue,
    int stopSearchOperator) throws StandardException
Open a scan which gets copies of multiple rows at a time.

All inputs work exactly as in openScan().  The return is 
a GroupFetchScanController, which only allows fetches of groups
of rows from the conglomerate.

 public ScanController openScan(long conglomId,
    boolean hold,
    int open_mode,
    int lock_level,
    int isolation_level,
    FormatableBitSet scanColumnList,
    DataValueDescriptor[] startKeyValue,
    int startSearchOperator,
    Qualifier[][] qualifier,
    DataValueDescriptor[] stopKeyValue,
    int stopSearchOperator) throws StandardException
Open a scan on a conglomerate.  The scan will return all
rows in the conglomerate which are between the
positions defined by {startKeyValue, startSearchOperator} and
{stopKeyValue, stopSearchOperator}, which also match the qualifier.

The way that starting and stopping keys and operators are used
may best be described by example. Say there's an ordered conglomerate
with two columns, where the 0-th column is named 'x', and the 1st
column is named 'y'.  The values of the columns are as follows:
x: 1 3 4 4 4 5 5 5 6 7 9
y: 1 1 2 4 6 2 4 6 1 1 1

A {start key, search op} pair of {{5.2}, GE} would position on {x=5, y=2}, whereas the pair {{5}, GT} would position on {x=6, y=1}.

Partial keys are used to implement partial key scans in SQL. For example, the SQL "select * from t where x = 5" would open a scan on the conglomerate (or a useful index) of t using a starting position partial key of {{5}, GE} and a stopping position partial key of {{5}, GT}.

Some more examples:

+-------------------+------------+-----------+--------------+--------------+
| predicate         | start key  | stop key  | rows         | rows locked  |
|                   | value | op | value |op | returned     |serialization |
+-------------------+-------+----+-------+---+--------------+--------------+
| x = 5             | {5}   | GE | {5}   |GT |{5,2} .. {5,6}|{4,6} .. {5,6}|
| x > 5             | {5}   | GT | null  |   |{6,1} .. {9,1}|{5,6} .. {9,1}|
| x >= 5            | {5}   | GE | null  |   |{5,2} .. {9,1}|{4,6} .. {9,1}|
| x <= 5            | null  |    | {5}   |GT |{1,1} .. {5,6}|first .. {5,6}|
| x < 5             | null  |    | {5}   |GE |{1,1} .. {4,6}|first .. {4,6}|
| x >= 5 and x <= 7 | {5},  | GE | {7}   |GT |{5,2} .. {7,1}|{4,6} .. {7,1}|
| x = 5  and y > 2  | {5,2} | GT | {5}   |GT |{5,4} .. {5,6}|{5,2} .. {5,6}|
| x = 5  and y >= 2 | {5,2} | GE | {5}   |GT |{5,2} .. {5,6}|{4,6} .. {5,6}|
| x = 5  and y < 5  | {5}   | GE | {5,5} |GE |{5,2} .. {5,4}|{4,6} .. {5,4}|
| x = 2             | {2}   | GE | {2}   |GT | none         |{1,1} .. {1,1}|
+-------------------+-------+----+-------+---+--------------+--------------+

As the above table implies, the underlying scan may lock more rows than it returns in order to guarantee serialization.

For each row which meets the start and stop position, as described above the row is "qualified" to see whether it should be returned. The qualification is a 2 dimensional array of @see Qualifiers, which represents the qualification in conjunctive normal form (CNF). Conjunctive normal form is an "and'd" set of "or'd" Qualifiers.

For example x = 5 would be represented is pseudo code as: qualifier_cnf[][] = new Qualifier[1]; qualifier_cnf[0] = new Qualifier[1]; qualifier_cnr[0][0] = new Qualifer(x = 5)

For example (x = 5) or (y = 6) would be represented is pseudo code as: qualifier_cnf[][] = new Qualifier[1]; qualifier_cnf[0] = new Qualifier[2]; qualifier_cnr[0][0] = new Qualifer(x = 5) qualifier_cnr[0][1] = new Qualifer(y = 6)

For example ((x = 5) or (x = 6)) and ((y = 1) or (y = 2)) would be represented is pseudo code as: qualifier_cnf[][] = new Qualifier[2]; qualifier_cnf[0] = new Qualifier[2]; qualifier_cnr[0][0] = new Qualifer(x = 5) qualifier_cnr[0][1] = new Qualifer(x = 6) qualifier_cnr[0][0] = new Qualifer(y = 5) qualifier_cnr[0][1] = new Qualifer(y = 6)

For each row the CNF qualfier is processed and it is determined whether or not the row should be returned to the caller. The following pseudo-code describes how this is done:

if (qualifier != null)
{
for (int and_clause; and_clause < qualifier.length; and_clause++)
{
boolean or_qualifies = false;

for (int or_clause; or_clause < qualifier[and_clause].length; or_clause++)
{
DataValueDescriptor key     = 
qualifier[and_clause][or_clause].getOrderable();

DataValueDescriptor row_col = 
get row column[qualifier[and_clause][or_clause].getColumnId()];

boolean or_qualifies = 
row_col.compare(qualifier[i].getOperator,
key,
qualifier[i].getOrderedNulls,
qualifier[i].getUnknownRV);


if (or_qualifies)
{
break;
}
}

if (!or_qualifies)
{
don't return this row to the client - proceed to next row;

}

}

 public SortController openSort(long id) throws StandardException
Open a sort controller for a sort previously created in this
transaction.  Sort controllers are used to insert rows into
the sort.

There may (in the future) be multiple sort inserters
for a given sort, the idea being that the various threads of
a parallel query plan can all insert into the sort.  For now,
however, only a single sort controller per sort is supported.

 public SortCostController openSortCostController(Properties implParameters) throws StandardException
Return an open SortCostController.

Return an open SortCostController which can be used to ask about 
the estimated costs of SortController() operations.

 public RowLocationRetRowSource openSortRowSource(long id) throws StandardException
Open a scan for retrieving rows from a sort.  Returns a RowSource for
retrieving rows from the sort.

 public ScanController openSortScan(long id,
    boolean hold) throws StandardException
Open a scan for retrieving rows from a sort.  Returns a
scan controller for retrieving rows from the sort (NOTE:
the only legal methods to use on the returned sort controller
are next() and fetch() - probably there should be scan
controllers and updatable scan controllers).

In the future, multiple sort scans on the same sort will
be supported (for parallel execution across a uniqueness
sort in which the order of the resulting rows is not
important).  Currently, only a single sort scan is allowed
per sort.

In the future, it will be possible to open a sort scan
and start retrieving rows before the last row is inserted.
The sort controller would block till rows were available
to return.  Currently, an attempt to retrieve a row before
the sort controller is closed will cause an exception.

 public StoreCostController openStoreCost(long conglomId) throws StandardException
Return an open StoreCostController for the given conglomid.

Return an open StoreCostController which can be used to ask about 
the estimated row counts and costs of ScanController and 
ConglomerateController operations, on the given conglomerate.

 public  void purgeConglomerate(long conglomId) throws StandardException
Purge all committed deleted rows from the conglomerate.

This call will purge committed deleted rows from the conglomerate,
that space will be available for future inserts into the conglomerate.

 public long recreateAndLoadConglomerate(String implementation,
    boolean recreate_ifempty,
    DataValueDescriptor[] template,
    ColumnOrdering[] columnOrder,
    int[] collationIds,
    Properties properties,
    int temporaryFlag,
    long orig_conglomId,
    RowLocationRetRowSource rowSource,
    long[] rowCount) throws StandardException
Recreate a conglomerate and possibly load it with new rows that come from
the new row source.


This function behaves the same as @see createConglomerate except it also
populates the conglomerate with rows from the row source and the rows that
are inserted are not logged.

Individual rows that are loaded into the conglomerate are not
logged. After this operation, the underlying database must be backed up
with a database backup rather than an transaction log backup (when we have
them). This warning is put here for the benefit of future generation.

 public int releaseSavePoint(String name,
    Object kindOfSavepoint) throws StandardException
Release the save point of the given name. Releasing a savepoint removes all
knowledge from this transaction of the named savepoint and any savepoints
set since the named savepoint was set.

 public int rollbackToSavePoint(String name,
    boolean close_controllers,
    Object kindOfSavepoint) throws StandardException
Rollback all changes made since the named savepoint was set. The named
savepoint is not released, it remains valid within this transaction, and
thus can be named it future rollbackToSavePoint() calls. Any savepoints
set since this named savepoint are released (and their changes rolled back).

if "close_controllers" is true then all conglomerates and scans are closed
(held or non-held).  

If "close_controllers" is false then no cleanup is done by the 
TransactionController.  It is then the responsibility of the caller to
close all resources that may have been affected by the statements 
backed out by the call.  This option is meant to be used by the Language
implementation of statement level backout, where the system "knows" what
could be affected by the scope of the statements executed within the 
statement.

 public  void setNoLockWait(boolean noWait)
Tell this transaction whether it should time out immediately if a lock
cannot be granted without waiting. This mechanism can for instance be
used if an operation is first attempted in a nested transaction to
reduce the lifetime of locks held in the system tables (like when
a stored prepared statement is compiled and stored). In such a case,
the caller must catch timeout exceptions and retry the operation in the
main transaction if a lock timeout occurs.

 public int setSavePoint(String name,
    Object kindOfSavepoint) throws StandardException
Set a save point in the current transaction. A save point defines a point in
time in the transaction that changes can be rolled back to. Savepoints
can be nested and they behave like a stack. Setting save points "one" and
"two" and the rolling back "one" will rollback all the changes made since
"one" (including those made since "two") and release savepoint "two".

 public TransactionController startNestedUserTransaction(boolean readOnly) throws StandardException
Get an nested user transaction.

A nested user transaction can be used exactly as any other 
TransactionController, except as follows.  For this discussion let the 
parent transaction be the transaction used to make the 
startNestedUserTransaction() call, and let the child transaction be the
transaction returned by the startNestedUserTransaction() call.

A parent transaction can nest a single readonly transaction
and a single separate read/write transaction. 
If a subsequent nested transaction creation is attempted
against the parent prior to destroying an existing
nested user transaction of the same type, an exception will be thrown.  

The nesting is limited to one level deep.  An exception will be thrown
if a subsequent getNestedUserTransaction() is called on the child
transaction.

The locks in the child transaction of a readOnly nested user transaction
will be compatible with the locks of the parent transaction.  The
locks in the child transaction of a non-readOnly nested user transaction
will NOT be compatible with those of the parent transaction - this is
necessary for correct recovery behavior.

A commit in the child transaction will release locks associated with
the child transaction only, work can continue in the parent transaction
at this point.  

Any abort of the child transaction will result in an abort of both
the child transaction and parent transaction, either initiated by
an explict abort() call or by an exception that results in an abort.

A TransactionController.destroy() call should be made on the child
transaction once all child work is done, and the caller wishes to 
continue work in the parent transaction.

AccessFactory.getTransaction() will always return the "parent" 
transaction, never the child transaction.  Thus clients using 
nested user transactions must keep track of the transaction, as there
is no interface to query the storage system to get the current
child transaction.  The idea is that a nested user transaction should
be used to for a limited amount of work, committed, and then work
continues in the parent transaction.

Nested User transactions are meant to be used to implement 
system work necessary to commit as part of implementing a user's
request, but where holding the lock for the duration of the user
transaction is not acceptable.  2 examples of this are system catalog
read locks accumulated while compiling a plan, and auto-increment.

Once the first write of a non-readOnly nested transaction is done,
then the nested user transaction must be committed or aborted before
any write operation is attempted in the parent transaction.