org.apache.derby.impl.jdbc
Class EmbedConnection

java.lang.Object
  extended by org.apache.derby.impl.jdbc.EmbedConnection
All Implemented Interfaces:
java.sql.Connection, java.sql.Wrapper, EngineConnection
Direct Known Subclasses:
EmbedConnection30

public abstract class EmbedConnection
extends java.lang.Object
implements EngineConnection

Local implementation of Connection for a JDBC driver in the same process as the database.

There is always a single root (parent) connection. The initial JDBC connection is the root connection. A call to getCurrentConnection() or with the URL jdbc:default:connection yields a nested connection that shares the same root connection as the parent. A nested connection is implemented using this class. The nested connection copies the state of the parent connection and shares some of the same objects (e.g. ContextManager) that are shared across all nesting levels. The proxy also maintains its own state that is distinct from its parent connection (e.g. autocommit or warnings).

SYNCHRONIZATION: Just about all JDBC actions are synchronized across all connections stemming from the same root connection. The synchronization is upon the a synchronized object return by the rootConnection.

Supports

See Also:
TransactionResourceImpl

Field Summary
private  boolean active
           
private  java.sql.Connection applicationConnection
          The Connection object the application is using when accessing the database through this connection.
(package private)  boolean autoCommit
           
private  int connectionHoldAbility
           
private  java.lang.String connString
          Cached string representation of the connection id
(package private)  java.sql.DatabaseMetaData dbMetadata
           
private static StandardException exceptionClose
           
private  InternalDriver factory
          Factory for JDBC objects to be created.
private  java.util.HashSet lobFiles
           
private  java.util.HashMap lobHashMap
           
private  int lobHMKey
           
private  java.util.WeakHashMap lobReferences
          Map to keep track of all the lobs associated with this connection.
static LowMemory memoryState
          Low memory state object for connection requests.
(package private)  boolean needCommit
           
static java.sql.SQLException NO_MEM
          Static exception to be thrown when a Connection request can not be fulfilled due to lack of memory.
private static int OP_ENCRYPT
           
private static int OP_HARD_UPGRADE
           
private static int OP_REPLICATION
           
private static int OP_SHUTDOWN
           
private  int resultSetId
          An increasing counter to assign to a ResultSet on its creation.
(package private)  EmbedConnection rootConnection
           
private  java.sql.SQLWarning topWarning
           
(package private)  TransactionResourceImpl tr
           
private  boolean usingNoneAuth
           
 
Fields inherited from interface java.sql.Connection
TRANSACTION_NONE, TRANSACTION_READ_COMMITTED, TRANSACTION_READ_UNCOMMITTED, TRANSACTION_REPEATABLE_READ, TRANSACTION_SERIALIZABLE
 
Constructor Summary
EmbedConnection(EmbedConnection inputConnection)
          Create a new connection based off of the connection passed in.
EmbedConnection(InternalDriver driver, java.lang.String url, java.util.Properties info)
           
 
Method Summary
(package private)  void addLobFile(LOBFile lobFile)
          Add a temporary lob file to the lobFiles set.
 int addLOBMapping(java.lang.Object LOBReference)
          Add the locator and the corresponding LOB object into the HashMap
(package private)  void addLOBReference(java.lang.Object lobReference)
          Adds an entry of the lob in WeakHashMap.
 void addWarning(java.sql.SQLWarning newWarning)
          Add a warning to the current list of warnings, to follow this note from Connection.getWarnings.
private  boolean bootDatabase(java.util.Properties info, boolean softAuthenticationBoot)
          Boot database.
 void cancelRunningStatement()
          Cancels the current running statement.
private  void checkDatabaseBooted(Database database, java.lang.String operation, java.lang.String dbname)
          Check that a database has already been booted.
private  void checkDatabaseCreatePrivileges(java.lang.String user, java.lang.String dbname)
          Checks that a user has the system privileges to create a database.
 void checkForTransactionInProgress()
          Check if the transaction is active so that we cannot close down the connection.
protected  void checkIfClosed()
          Raises an exception if the connection is closed.
private  void checkIsDBOwner(int operation)
          Check if actual authenticationId is equal to the database owner's.
private  void checkUserCredentials(java.lang.String dbname, java.util.Properties userInfo)
           
private  void checkUserIsNotARole()
          If applicable, check that we don't connect with a user name that equals a role.
 void clearLOBMapping()
          Clear the HashMap of all entries.
 void clearWarnings()
          After this call, getWarnings returns null until a new warning is reported for this Connection.
 void close()
          In some cases, it is desirable to immediately release a Connection's database and JDBC resources instead of waiting for them to be automatically released; the close method provides this immediate release.
private  void close(StandardException e)
           
 void commit()
          Commit makes all changes made since the previous commit/rollback permanent and releases any database locks currently held by the Connection.
protected  void commitIfAutoCommit()
          If in autocommit, then commit.
protected  void commitIfNeeded()
          if a commit is needed, perform it.
 java.sql.Blob createBlob()
          Constructs an object that implements the Blob interface.
private  boolean createBoot(java.util.Properties p)
          Examine the attributes set provided for illegal boot combinations and determine if this is a create boot.
 java.sql.Clob createClob()
          Constructs an object that implements the Clob interface.
private  Database createDatabase(java.lang.String dbname, java.util.Properties info)
          Create a new database.
 java.sql.Statement createStatement()
          SQL statements without parameters are normally executed using Statement objects.
 java.sql.Statement createStatement(int resultSetType, int resultSetConcurrency)
          JDBC 2.0 Same as createStatement() above, but allows the default result set type and result set concurrency type to be overridden.
 java.sql.Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
          JDBC 3.0 Same as createStatement() above, but allows the default result set type, result set concurrency type and result set holdability type to be overridden.
private  java.util.Properties filterProperties(java.util.Properties inputSet)
          Filter out properties from the passed in set of JDBC attributes to remove any derby.* properties.
protected  void finalize()
           
 java.sql.Connection getApplicationConnection()
           
 boolean getAutoCommit()
          Get the current auto-commit state.
 java.lang.String getCatalog()
          Return the Connection's current catalog name.
protected  java.lang.Object getConnectionSynchronization()
           
 ContextManager getContextManager()
          Return the context manager for this connection.
 java.lang.String getCurrentSchemaName()
          Obtain the name of the current schema.
protected  Database getDatabase()
           
 java.lang.String getDBName()
          Return the dbname for this connection.
 int getEngineType()
          Gets the EngineType of the connected database.
 int getHoldability()
          JDBC 3.0 Retrieves the current holdability of ResultSet objects created using this Connection object.
private  int getIncLOBKey()
          Return the current locator value/ 0x800x values are not valid values as they are used to indicate the BLOB is being sent by value, so we skip those values (DERBY-3243)
 LanguageConnectionContext getLanguageConnection()
           
 java.util.HashMap getlobHMObj()
          Return the Hash Map in the root connection
 java.lang.Object getLOBMapping(int key)
          Get the LOB reference corresponding to the locator.
 InternalDriver getLocalDriver()
           
 java.sql.DatabaseMetaData getMetaData()
          A Connection's database is able to provide information describing its tables, its supported SQL grammar, its stored procedures, the capabilities of this connection, etc.
 int getPrepareIsolation()
          Return prepare isolation
private  java.lang.String getReplicationOperation(java.util.Properties p)
           
(package private)  int getResultSetOrderId()
          Return a unique order number for a result set.
protected  TransactionResourceImpl getTR()
           
 int getTransactionIsolation()
          Get this Connection's current transaction isolation mode.
 java.util.Map getTypeMap()
          Get the type-map object associated with this connection.
 java.sql.SQLWarning getWarnings()
          The first warning reported by calls on this Connection is returned.
private  void handleDBNotFound()
           
(package private)  java.sql.SQLException handleException(java.lang.Throwable thrownException)
           
(package private)  java.sql.SQLException handleException(java.lang.Throwable thrownException, boolean rollbackOnAutoCommit)
          Handle any type of Exception.
private  void handleFailoverMaster(TransactionResourceImpl tr)
          Used to authorize and verify the privileges of the user and initiate failover.
private  void handleFailoverSlave(Database database)
          Used to perform failover on a database in slave replication mode.
private  void handleStartReplicationMaster(TransactionResourceImpl tr, java.util.Properties p)
           
private  void handleStopReplicationMaster(TransactionResourceImpl tr, java.util.Properties p)
           
private  void handleStopReplicationSlave(Database database, java.util.Properties p)
          Stop replication slave when called from a client.
private  void internalStopReplicationSlave(Database database, java.util.Properties p)
          Stop replication slave when called from SlaveDatabase.
 boolean isClosed()
          Tests to see if a Connection is closed.
private  boolean isDropDatabase(java.util.Properties p)
          Examines the boot properties and determines if the given attributes would entail dropping the database.
private  boolean isEncryptionBoot(java.util.Properties p)
          Examine boot properties and determine if a boot with the given attributes would entail an encryption operation.
private  boolean isHardUpgradeBoot(java.util.Properties p)
          Examine boot properties and determine if a boot with the given attributes would entail a hard upgrade.
 boolean isInGlobalTransaction()
          Is this a global transaction
private  boolean isInternalShutdownSlaveDatabase(java.util.Properties p)
          Examine the boot properties and determine if a boot with the given attributes should stop slave replication mode.
 boolean isReadOnly()
          Tests to see if the connection is in read-only mode.
private  boolean isReplicationFailover(java.util.Properties p)
          used to verify if the failover attribute has been set.
private  boolean isStartReplicationMasterBoot(java.util.Properties p)
           
private  boolean isStartReplicationSlaveBoot(java.util.Properties p)
           
private  boolean isStopReplicationMasterBoot(java.util.Properties p)
           
private  boolean isStopReplicationSlaveBoot(java.util.Properties p)
          Examine the boot properties and determine if a boot with the given attributes should stop slave replication mode.
 java.lang.String nativeSQL(java.lang.String sql)
          A driver may convert the JDBC sql grammar into its system's native SQL grammar prior to sending it; nativeSQL returns the native form of the statement that the driver would have sent.
protected  void needCommit()
          if auto commit is on, remember that we need to commit the current statement.
protected  java.sql.SQLException newSQLException(java.lang.String messageId)
           
protected  java.sql.SQLException newSQLException(java.lang.String messageId, java.lang.Object arg1)
           
protected  java.sql.SQLException newSQLException(java.lang.String messageId, java.lang.Object arg1, java.lang.Object arg2)
           
 java.sql.CallableStatement prepareCall(java.lang.String sql)
          A SQL stored procedure call statement is handled by creating a CallableStatement for it.
 java.sql.CallableStatement prepareCall(java.lang.String sql, int resultSetType, int resultSetConcurrency)
          JDBC 2.0 Same as prepareCall() above, but allows the default result set type and result set concurrency type to be overridden.
 java.sql.CallableStatement prepareCall(java.lang.String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
          JDBC 3.0 Same as prepareCall() above, but allows the default result set type, result set concurrency type and result set holdability to be overridden.
(package private)  java.sql.PreparedStatement prepareMetaDataStatement(java.lang.String sql)
           
 java.sql.PreparedStatement prepareStatement(java.lang.String sql)
          A SQL statement with or without IN parameters can be pre-compiled and stored in a PreparedStatement object.
 java.sql.PreparedStatement prepareStatement(java.lang.String sql, int autoGeneratedKeys)
          Creates a default PreparedStatement object that has the capability to retieve auto-generated keys.
 java.sql.PreparedStatement prepareStatement(java.lang.String sql, int[] columnIndexes)
          Creates a default PreparedStatement object capable of returning the auto-generated keys designated by the given array.
 java.sql.PreparedStatement prepareStatement(java.lang.String sql, int resultSetType, int resultSetConcurrency)
          JDBC 2.0 Same as prepareStatement() above, but allows the default result set type and result set concurrency type to be overridden.
 java.sql.PreparedStatement prepareStatement(java.lang.String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
          JDBC 3.0 Same as prepareStatement() above, but allows the default result set type, result set concurrency type and result set holdability to be overridden.
private  java.sql.PreparedStatement prepareStatement(java.lang.String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability, int autoGeneratedKeys, int[] columnIndexes, java.lang.String[] columnNames)
           
 java.sql.PreparedStatement prepareStatement(java.lang.String sql, java.lang.String[] columnNames)
          Creates a default PreparedStatement object capable of returning the auto-generated keys designated by the given array.
private  EmbedConnectionContext pushConnectionContext(ContextManager cm)
           
(package private)  void removeLobFile(LOBFile lobFile)
          Remove LOBFile from the lobFiles set.
 void removeLOBMapping(int key)
          Remove the key(LOCATOR) from the hash table.
private  java.util.Properties removePhaseTwoProps(java.util.Properties p)
          Remove any encryption or upgarde properties from the given properties
 void resetFromPool()
          Reset the connection before it is returned from a PooledConnection to a new application request (wrapped by a BrokeredConnection).
protected  void restoreContextStack()
           
 void rollback()
          Rollback drops all changes made since the previous commit/rollback and releases any database locks currently held by the Connection.
 void setApplicationConnection(java.sql.Connection applicationConnection)
           
 void setAutoCommit(boolean autoCommit)
          If a connection is in auto-commit mode, then all its SQL statements will be executed and committed as individual transactions.
 void setCatalog(java.lang.String catalog)
          A sub-space of this Connection's database may be selected by setting a catalog name.
 void setDrdaID(java.lang.String drdaID)
          Set the DRDA identifier for this connection.
 void setHoldability(int holdability)
          JDBC 3.0 Changes the holdability of ResultSet objects created using this Connection object to the given holdability.
 void setInactive()
          Close the connection when processing errors, or when closing a nested connection.
 void setPrepareIsolation(int level)
          Set the transaction isolation level that will be used for the next prepare.
 void setReadOnly(boolean readOnly)
          You can put a connection in read-only mode as a hint to enable database optimizations.
private  int setResultSetType(int resultSetType)
           
 void setTransactionIsolation(int level)
          You can call this method to try to change the transaction isolation level using one of the TRANSACTION_* values.
 void setTypeMap(java.util.Map map)
          Install a type-map object as the default type-map for this connection.
protected  void setupContextStack()
          Install the context manager for this thread.
private static void sleep(long millis)
          Puts the current thread to sleep and sets the interrupt flag of the thread if an InterruptedException is thrown while sleeping.
static java.lang.String stripSubSubProtocolPrefix(java.lang.String dbname)
          Strips any sub-sub-protocol prefix from a database name.
 java.lang.String toString()
          Get a String representation that uniquely identifies this connection.
 boolean transactionIsIdle()
          returns false if there is an underlying transaction and that transaction has done work.
 void xa_commit(boolean onePhase)
          Do not use this method directly use XATransactionState.xa_commit instead because it also maintains/cancels the timout task which is scheduled to cancel/rollback the global transaction.
 int xa_prepare()
          Do not use this method directly use XATransactionState.xa_prepare instead because it also maintains/cancels the timout task which is scheduled to cancel/rollback the global transaction.
 void xa_rollback()
          Do not use this method directly use XATransactionState.xa_rollback instead because it also maintains/cancels the timout task which is scheduled to cancel/rollback the global transaction.
 
Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
 
Methods inherited from interface java.sql.Connection
createArrayOf, createNClob, createSQLXML, createStruct, getClientInfo, getClientInfo, isValid, releaseSavepoint, rollback, setClientInfo, setClientInfo, setSavepoint, setSavepoint
 
Methods inherited from interface java.sql.Wrapper
isWrapperFor, unwrap
 

Field Detail

exceptionClose

private static final StandardException exceptionClose

NO_MEM

public static final java.sql.SQLException NO_MEM
Static exception to be thrown when a Connection request can not be fulfilled due to lack of memory. A static exception as the lack of memory would most likely cause another OutOfMemoryException and if there is not enough memory to create the OOME exception then something like the VM dying could occur. Simpler just to throw a static.


memoryState

public static final LowMemory memoryState
Low memory state object for connection requests.


dbMetadata

java.sql.DatabaseMetaData dbMetadata

tr

TransactionResourceImpl tr

lobHashMap

private java.util.HashMap lobHashMap

lobHMKey

private int lobHMKey

lobReferences

private java.util.WeakHashMap lobReferences
Map to keep track of all the lobs associated with this connection. These lobs will be cleared after the transaction is no longer valid or when connection is closed


lobFiles

private java.util.HashSet lobFiles

active

private boolean active

autoCommit

boolean autoCommit

needCommit

boolean needCommit

usingNoneAuth

private boolean usingNoneAuth

connectionHoldAbility

private int connectionHoldAbility

rootConnection

final EmbedConnection rootConnection

topWarning

private java.sql.SQLWarning topWarning

factory

private InternalDriver factory
Factory for JDBC objects to be created.


applicationConnection

private java.sql.Connection applicationConnection
The Connection object the application is using when accessing the database through this connection. In most cases this will be equal to this. When Connection pooling is being used, then it will be set to the Connection object handed to the application. It is used for the getConnection() methods of various JDBC objects.


resultSetId

private int resultSetId
An increasing counter to assign to a ResultSet on its creation. Used for ordering ResultSets returned from a procedure, always returned in order of their creation. Is maintained at the root connection.


connString

private java.lang.String connString
Cached string representation of the connection id


OP_ENCRYPT

private static final int OP_ENCRYPT
See Also:
Constant Field Values

OP_SHUTDOWN

private static final int OP_SHUTDOWN
See Also:
Constant Field Values

OP_HARD_UPGRADE

private static final int OP_HARD_UPGRADE
See Also:
Constant Field Values

OP_REPLICATION

private static final int OP_REPLICATION
See Also:
Constant Field Values
Constructor Detail

EmbedConnection

public EmbedConnection(InternalDriver driver,
                       java.lang.String url,
                       java.util.Properties info)
                throws java.sql.SQLException
Throws:
java.sql.SQLException

EmbedConnection

public EmbedConnection(EmbedConnection inputConnection)
Create a new connection based off of the connection passed in. Initializes state based on input connection, and copies appropriate object pointers. This is only used for nested connections.

Parameters:
inputConnection - the input connection
Method Detail

checkDatabaseBooted

private void checkDatabaseBooted(Database database,
                                 java.lang.String operation,
                                 java.lang.String dbname)
                          throws java.sql.SQLException
Check that a database has already been booted. Throws an exception otherwise

Parameters:
database - The database that should have been booted
operation - The operation that requires that the database has already been booted, used in the exception message if not booted
dbname - The name of the database that should have been booted, used in the exception message if not booted
Throws:
java.sql.SQLException - thrown if database is not booted

createBoot

private boolean createBoot(java.util.Properties p)
                    throws java.sql.SQLException
Examine the attributes set provided for illegal boot combinations and determine if this is a create boot.

Parameters:
p - the attribute set.
Returns:
true iff the attribute create=true is provided. This means create a standard database. In other cases, returns false.
Throws:
java.sql.SQLException - Throw if more than one of create, createFrom, restoreFrom and rollForwardRecoveryFrom is used simultaneously.
Also, throw if (re)encryption is attempted with one of createFrom, restoreFrom and rollForwardRecoveryFrom.

handleDBNotFound

private void handleDBNotFound()
                       throws java.sql.SQLException
Throws:
java.sql.SQLException

isDropDatabase

private boolean isDropDatabase(java.util.Properties p)
Examines the boot properties and determines if the given attributes would entail dropping the database.

Parameters:
p - the attribute set
Returns:
true if the drop database operation is requested, false if not.

isEncryptionBoot

private boolean isEncryptionBoot(java.util.Properties p)
Examine boot properties and determine if a boot with the given attributes would entail an encryption operation.

Parameters:
p - the attribute set
Returns:
true if a boot will encrypt or re-encrypt the database

isHardUpgradeBoot

private boolean isHardUpgradeBoot(java.util.Properties p)
Examine boot properties and determine if a boot with the given attributes would entail a hard upgrade.

Parameters:
p - the attribute set
Returns:
true if a boot will hard upgrade the database

isStartReplicationSlaveBoot

private boolean isStartReplicationSlaveBoot(java.util.Properties p)

isStartReplicationMasterBoot

private boolean isStartReplicationMasterBoot(java.util.Properties p)

isReplicationFailover

private boolean isReplicationFailover(java.util.Properties p)
used to verify if the failover attribute has been set.

Parameters:
p - The attribute set.
Returns:
true if the failover attribute has been set. false otherwise.

isStopReplicationMasterBoot

private boolean isStopReplicationMasterBoot(java.util.Properties p)

isStopReplicationSlaveBoot

private boolean isStopReplicationSlaveBoot(java.util.Properties p)
Examine the boot properties and determine if a boot with the given attributes should stop slave replication mode.

Parameters:
p - The attribute set.
Returns:
true if the stopSlave attribute has been set, false otherwise.

isInternalShutdownSlaveDatabase

private boolean isInternalShutdownSlaveDatabase(java.util.Properties p)
Examine the boot properties and determine if a boot with the given attributes should stop slave replication mode. A connection with this property should only be made from SlaveDatabase. Make sure to call SlaveDatabase.verifyShutdownSlave() to verify that this connection is not made from a client.

Parameters:
p - The attribute set.
Returns:
true if the shutdownslave attribute has been set, false otherwise.

getReplicationOperation

private java.lang.String getReplicationOperation(java.util.Properties p)
                                          throws StandardException
Throws:
StandardException

handleStartReplicationMaster

private void handleStartReplicationMaster(TransactionResourceImpl tr,
                                          java.util.Properties p)
                                   throws java.sql.SQLException
Throws:
java.sql.SQLException

handleStopReplicationMaster

private void handleStopReplicationMaster(TransactionResourceImpl tr,
                                         java.util.Properties p)
                                  throws java.sql.SQLException
Throws:
java.sql.SQLException

handleStopReplicationSlave

private void handleStopReplicationSlave(Database database,
                                        java.util.Properties p)
                                 throws StandardException,
                                        java.sql.SQLException
Stop replication slave when called from a client. Stops replication slave mode, provided that the database is in replication slave mode and has lost connection with the master database. If the connection with the master is up, the call to this method will be refused by raising an exception. The reason for refusing the stop command if the slave is connected with the master is that we cannot authenticate the user on the slave side (because the slave database has not been fully booted) whereas authentication is not a problem on the master side. If not refused, this operation will cause SlaveDatabase to call internalStopReplicationSlave

Parameters:
database - The database the stop slave operation will be performed on
p - The Attribute set.
Throws:
StandardException - Thrown on error, if not in replication slave mode or if the network connection with the master is not down
java.sql.SQLException - Thrown if the database has not been booted or if stopSlave is performed successfully

internalStopReplicationSlave

private void internalStopReplicationSlave(Database database,
                                          java.util.Properties p)
                                   throws StandardException,
                                          java.sql.SQLException
Stop replication slave when called from SlaveDatabase. Called when slave replication mode has been stopped, and all that remains is to shutdown the database. This happens if handleStopReplicationSlave has successfully requested the slave to stop, if the replication master has requested the slave to stop using the replication network, or if a fatal exception has occurred in the database.

Parameters:
database - The database the internal stop slave operation will be performed on
p - The Attribute set.
Throws:
StandardException - Thrown on error or if not in replication slave mode
java.sql.SQLException - Thrown if the database has not been booted or if this connection was not made internally from SlaveDatabase

handleFailoverMaster

private void handleFailoverMaster(TransactionResourceImpl tr)
                           throws java.sql.SQLException,
                                  StandardException
Used to authorize and verify the privileges of the user and initiate failover.

Parameters:
tr - an instance of TransactionResourceImpl Links the connection to the database.
Throws:
StandardException - 1) If the failover succeeds, an exception is thrown to indicate that the master database was shutdown after a successful failover 2) If a failure occurs during network communication with slave.
java.sql.SQLException - 1) Thrown upon a authorization failure.

handleFailoverSlave

private void handleFailoverSlave(Database database)
                          throws java.sql.SQLException
Used to perform failover on a database in slave replication mode. Performs failover, provided that the database is in replication slave mode and has lost connection with the master database. If the connection with the master is up, the call to this method will be refused by raising an exception. The reason for refusing the failover command if the slave is connected with the master is that we cannot authenticate the user on the slave side (because the slave database has not been fully booted) whereas authentication is not a problem on the master side. If not refused, this method will apply all operations received from the master and complete the booting of the database so that it can be connected to.

Parameters:
database - The database the failover operation will be performed on
Throws:
java.sql.SQLException - Thrown on error, if not in replication slave mode or if the network connection with the master is not down

removePhaseTwoProps

private java.util.Properties removePhaseTwoProps(java.util.Properties p)
Remove any encryption or upgarde properties from the given properties

Parameters:
p - the attribute set
Returns:
clone sans encryption properties

checkUserCredentials

private void checkUserCredentials(java.lang.String dbname,
                                  java.util.Properties userInfo)
                           throws java.sql.SQLException
Throws:
java.sql.SQLException

checkUserIsNotARole

private void checkUserIsNotARole()
                          throws java.sql.SQLException
If applicable, check that we don't connect with a user name that equals a role.

Throws:
java.sql.SQLException - Will throw if the current authorization id in lcc (which is already normalized to case normal form - CNF) equals an existing role name (which is also stored in CNF).

checkIsDBOwner

private void checkIsDBOwner(int operation)
                     throws java.sql.SQLException
Check if actual authenticationId is equal to the database owner's.

Parameters:
operation - attempted operation which needs database owner powers
Throws:
java.sql.SQLException - if actual authenticationId is different from authenticationId of database owner.

getEngineType

public int getEngineType()
Gets the EngineType of the connected database.

Returns:
0 if there is no database, the engine type otherwise. @see org.apache.derby.iapi.reference.EngineType

createStatement

public final java.sql.Statement createStatement()
                                         throws java.sql.SQLException
SQL statements without parameters are normally executed using Statement objects. If the same SQL statement is executed many times, it is more efficient to use a PreparedStatement JDBC 2.0 Result sets created using the returned Statement will have forward-only type, and read-only concurrency, by default.

Specified by:
createStatement in interface java.sql.Connection
Returns:
a new Statement object
Throws:
java.sql.SQLException - if a database-access error occurs.

createStatement

public final java.sql.Statement createStatement(int resultSetType,
                                                int resultSetConcurrency)
                                         throws java.sql.SQLException
JDBC 2.0 Same as createStatement() above, but allows the default result set type and result set concurrency type to be overridden.

Specified by:
createStatement in interface java.sql.Connection
Parameters:
resultSetType - a result set type, see ResultSet.TYPE_XXX
resultSetConcurrency - a concurrency type, see ResultSet.CONCUR_XXX
Returns:
a new Statement object
Throws:
java.sql.SQLException - if a database-access error occurs.

createStatement

public final java.sql.Statement createStatement(int resultSetType,
                                                int resultSetConcurrency,
                                                int resultSetHoldability)
                                         throws java.sql.SQLException
JDBC 3.0 Same as createStatement() above, but allows the default result set type, result set concurrency type and result set holdability type to be overridden.

Specified by:
createStatement in interface java.sql.Connection
Parameters:
resultSetType - a result set type, see ResultSet.TYPE_XXX
resultSetConcurrency - a concurrency type, see ResultSet.CONCUR_XXX
resultSetHoldability - a holdability type, ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
Returns:
a new Statement object
Throws:
java.sql.SQLException - if a database-access error occurs.

prepareStatement

public final java.sql.PreparedStatement prepareStatement(java.lang.String sql)
                                                  throws java.sql.SQLException
A SQL statement with or without IN parameters can be pre-compiled and stored in a PreparedStatement object. This object can then be used to efficiently execute this statement multiple times.

Note: This method is optimized for handling parametric SQL statements that benefit from precompilation. If the driver supports precompilation, prepareStatement will send the statement to the database for precompilation. Some drivers may not support precompilation. In this case, the statement may not be sent to the database until the PreparedStatement is executed. This has no direct affect on users; however, it does affect which method throws certain SQLExceptions. JDBC 2.0 Result sets created using the returned PreparedStatement will have forward-only type, and read-only concurrency, by default.

Specified by:
prepareStatement in interface java.sql.Connection
Parameters:
sql - a SQL statement that may contain one or more '?' IN parameter placeholders
Returns:
a new PreparedStatement object containing the pre-compiled statement
Throws:
java.sql.SQLException - if a database-access error occurs.

prepareStatement

public final java.sql.PreparedStatement prepareStatement(java.lang.String sql,
                                                         int resultSetType,
                                                         int resultSetConcurrency)
                                                  throws java.sql.SQLException
JDBC 2.0 Same as prepareStatement() above, but allows the default result set type and result set concurrency type to be overridden.

Specified by:
prepareStatement in interface java.sql.Connection
Parameters:
resultSetType - a result set type, see ResultSet.TYPE_XXX
resultSetConcurrency - a concurrency type, see ResultSet.CONCUR_XXX
Returns:
a new PreparedStatement object containing the pre-compiled SQL statement
Throws:
java.sql.SQLException - if a database-access error occurs.

prepareStatement

public final java.sql.PreparedStatement prepareStatement(java.lang.String sql,
                                                         int resultSetType,
                                                         int resultSetConcurrency,
                                                         int resultSetHoldability)
                                                  throws java.sql.SQLException
JDBC 3.0 Same as prepareStatement() above, but allows the default result set type, result set concurrency type and result set holdability to be overridden.

Specified by:
prepareStatement in interface java.sql.Connection
Parameters:
resultSetType - a result set type, see ResultSet.TYPE_XXX
resultSetConcurrency - a concurrency type, see ResultSet.CONCUR_XXX
resultSetHoldability - - one of the following ResultSet constants: ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
Returns:
a new PreparedStatement object containing the pre-compiled SQL statement
Throws:
java.sql.SQLException - if a database-access error occurs.

prepareStatement

public final java.sql.PreparedStatement prepareStatement(java.lang.String sql,
                                                         int[] columnIndexes)
                                                  throws java.sql.SQLException
Creates a default PreparedStatement object capable of returning the auto-generated keys designated by the given array. This array contains the indexes of the columns in the target table that contain the auto-generated keys that should be made available. This array is ignored if the SQL statement is not an INSERT statement JDBC 3.0

Specified by:
prepareStatement in interface java.sql.Connection
Parameters:
sql - An SQL statement that may contain one or more ? IN parameter placeholders
columnIndexes - An array of column indexes indicating the columns that should be returned from the inserted row or rows
Returns:
A new PreparedStatement object, containing the pre-compiled SQL statement, that will have the capability of returning auto-generated keys designated by the given array of column indexes
Throws:
java.sql.SQLException - Thrown on error.

prepareStatement

public final java.sql.PreparedStatement prepareStatement(java.lang.String sql,
                                                         java.lang.String[] columnNames)
                                                  throws java.sql.SQLException
Creates a default PreparedStatement object capable of returning the auto-generated keys designated by the given array. This array contains the names of the columns in the target table that contain the auto-generated keys that should be returned. This array is ignored if the SQL statement is not an INSERT statement JDBC 3.0

Specified by:
prepareStatement in interface java.sql.Connection
Parameters:
sql - An SQL statement that may contain one or more ? IN parameter placeholders
columnNames - An array of column names indicating the columns that should be returned from the inserted row or rows
Returns:
A new PreparedStatement object, containing the pre-compiled SQL statement, that will have the capability of returning auto-generated keys designated by the given array of column names
Throws:
java.sql.SQLException - Thrown on error.

prepareStatement

public final java.sql.PreparedStatement prepareStatement(java.lang.String sql,
                                                         int autoGeneratedKeys)
                                                  throws java.sql.SQLException
Creates a default PreparedStatement object that has the capability to retieve auto-generated keys. The given constant tells the driver whether it should make auto-generated keys available for retrieval. This parameter is ignored if the SQL statement is not an INSERT statement. JDBC 3.0

Specified by:
prepareStatement in interface java.sql.Connection
Parameters:
sql - A SQL statement that may contain one or more ? IN parameter placeholders
autoGeneratedKeys - A flag indicating whether auto-generated keys should be returned
Returns:
A new PreparedStatement object, containing the pre-compiled SQL statement, that will have the capability of returning auto-generated keys
Throws:
java.sql.SQLException - Feature not implemented for now.

prepareStatement

private java.sql.PreparedStatement prepareStatement(java.lang.String sql,
                                                    int resultSetType,
                                                    int resultSetConcurrency,
                                                    int resultSetHoldability,
                                                    int autoGeneratedKeys,
                                                    int[] columnIndexes,
                                                    java.lang.String[] columnNames)
                                             throws java.sql.SQLException
Throws:
java.sql.SQLException

prepareCall

public final java.sql.CallableStatement prepareCall(java.lang.String sql)
                                             throws java.sql.SQLException
A SQL stored procedure call statement is handled by creating a CallableStatement for it. The CallableStatement provides methods for setting up its IN and OUT parameters, and methods for executing it.

Note: This method is optimized for handling stored procedure call statements. Some drivers may send the call statement to the database when the prepareCall is done; others may wait until the CallableStatement is executed. This has no direct affect on users; however, it does affect which method throws certain SQLExceptions. JDBC 2.0 Result sets created using the returned CallableStatement will have forward-only type, and read-only concurrency, by default.

Specified by:
prepareCall in interface java.sql.Connection
Parameters:
sql - a SQL statement that may contain one or more '?' parameter placeholders. Typically this statement is a JDBC function call escape string.
Returns:
a new CallableStatement object containing the pre-compiled SQL statement
Throws:
java.sql.SQLException - if a database-access error occurs.

prepareCall

public final java.sql.CallableStatement prepareCall(java.lang.String sql,
                                                    int resultSetType,
                                                    int resultSetConcurrency)
                                             throws java.sql.SQLException
JDBC 2.0 Same as prepareCall() above, but allows the default result set type and result set concurrency type to be overridden.

Specified by:
prepareCall in interface java.sql.Connection
Parameters:
resultSetType - a result set type, see ResultSet.TYPE_XXX
resultSetConcurrency - a concurrency type, see ResultSet.CONCUR_XXX
Returns:
a new CallableStatement object containing the pre-compiled SQL statement
Throws:
java.sql.SQLException - if a database-access error occurs.

prepareCall

public final java.sql.CallableStatement prepareCall(java.lang.String sql,
                                                    int resultSetType,
                                                    int resultSetConcurrency,
                                                    int resultSetHoldability)
                                             throws java.sql.SQLException
JDBC 3.0 Same as prepareCall() above, but allows the default result set type, result set concurrency type and result set holdability to be overridden.

Specified by:
prepareCall in interface java.sql.Connection
Parameters:
resultSetType - a result set type, see ResultSet.TYPE_XXX
resultSetConcurrency - a concurrency type, see ResultSet.CONCUR_XXX
resultSetHoldability - - one of the following ResultSet constants: ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
Returns:
a new CallableStatement object containing the pre-compiled SQL statement
Throws:
java.sql.SQLException - if a database-access error occurs.

nativeSQL

public java.lang.String nativeSQL(java.lang.String sql)
                           throws java.sql.SQLException
A driver may convert the JDBC sql grammar into its system's native SQL grammar prior to sending it; nativeSQL returns the native form of the statement that the driver would have sent.

Specified by:
nativeSQL in interface java.sql.Connection
Parameters:
sql - a SQL statement that may contain one or more '?' parameter placeholders
Returns:
the native form of this statement
Throws:
java.sql.SQLException

setAutoCommit

public void setAutoCommit(boolean autoCommit)
                   throws java.sql.SQLException
If a connection is in auto-commit mode, then all its SQL statements will be executed and committed as individual transactions. Otherwise, its SQL statements are grouped into transactions that are terminated by either commit() or rollback(). By default, new connections are in auto-commit mode. The commit occurs when the statement completes or the next execute occurs, whichever comes first. In the case of statements returning a ResultSet, the statement completes when the last row of the ResultSet has been retrieved or the ResultSet has been closed. In advanced cases, a single statement may return multiple results as well as output parameter values. Here the commit occurs when all results and output param values have been retrieved.

Specified by:
setAutoCommit in interface java.sql.Connection
Parameters:
autoCommit - true enables auto-commit; false disables auto-commit.
Throws:
java.sql.SQLException - if a database-access error occurs.

getAutoCommit

public boolean getAutoCommit()
                      throws java.sql.SQLException
Get the current auto-commit state.

Specified by:
getAutoCommit in interface java.sql.Connection
Returns:
Current state of auto-commit mode.
Throws:
java.sql.SQLException
See Also:
setAutoCommit(boolean)

commit

public void commit()
            throws java.sql.SQLException
Commit makes all changes made since the previous commit/rollback permanent and releases any database locks currently held by the Connection. This method should only be used when auto commit has been disabled.

Specified by:
commit in interface java.sql.Connection
Throws:
java.sql.SQLException - if a database-access error occurs.
See Also:
setAutoCommit(boolean)

rollback

public void rollback()
              throws java.sql.SQLException
Rollback drops all changes made since the previous commit/rollback and releases any database locks currently held by the Connection. This method should only be used when auto commit has been disabled.

Specified by:
rollback in interface java.sql.Connection
Throws:
java.sql.SQLException - if a database-access error occurs.
See Also:
setAutoCommit(boolean)

close

public void close()
           throws java.sql.SQLException
In some cases, it is desirable to immediately release a Connection's database and JDBC resources instead of waiting for them to be automatically released; the close method provides this immediate release.

Note: A Connection is automatically closed when it is garbage collected. Certain fatal errors also result in a closed Connection.

Specified by:
close in interface java.sql.Connection
Throws:
java.sql.SQLException - if a database-access error occurs.

checkForTransactionInProgress

public void checkForTransactionInProgress()
                                   throws java.sql.SQLException
Check if the transaction is active so that we cannot close down the connection. If auto-commit is on, the transaction is committed when the connection is closed, so it is always OK to close the connection in that case. Otherwise, throw an exception if a transaction is in progress.

Throws:
java.sql.SQLException - if this transaction is active and the connection cannot be closed

close

private void close(StandardException e)
            throws java.sql.SQLException
Throws:
java.sql.SQLException

isClosed

public final boolean isClosed()
Tests to see if a Connection is closed.

Specified by:
isClosed in interface java.sql.Connection
Returns:
true if the connection is closed; false if it's still open

getMetaData

public java.sql.DatabaseMetaData getMetaData()
                                      throws java.sql.SQLException
A Connection's database is able to provide information describing its tables, its supported SQL grammar, its stored procedures, the capabilities of this connection, etc. This information is made available through a DatabaseMetaData object.

Specified by:
getMetaData in interface java.sql.Connection
Returns:
a DatabaseMetaData object for this Connection
Throws:
java.sql.SQLException - if a database-access error occurs.

getHoldability

public final int getHoldability()
                         throws java.sql.SQLException
JDBC 3.0 Retrieves the current holdability of ResultSet objects created using this Connection object.

Specified by:
getHoldability in interface java.sql.Connection
Specified by:
getHoldability in interface EngineConnection
Returns:
The holdability, one of ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
Throws:
java.sql.SQLException

setHoldability

public final void setHoldability(int holdability)
                          throws java.sql.SQLException
JDBC 3.0 Changes the holdability of ResultSet objects created using this Connection object to the given holdability.

Specified by:
setHoldability in interface java.sql.Connection
Parameters:
holdability - A ResultSet holdability constant, one of ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
Throws:
java.sql.SQLException

setReadOnly

public final void setReadOnly(boolean readOnly)
                       throws java.sql.SQLException
You can put a connection in read-only mode as a hint to enable database optimizations.

Note: setReadOnly cannot be called while in the middle of a transaction.

Specified by:
setReadOnly in interface java.sql.Connection
Parameters:
readOnly - true enables read-only mode; false disables read-only mode.
Throws:
java.sql.SQLException - if a database-access error occurs.

isReadOnly

public final boolean isReadOnly()
                         throws java.sql.SQLException
Tests to see if the connection is in read-only mode.

Specified by:
isReadOnly in interface java.sql.Connection
Returns:
true if connection is read-only
Throws:
java.sql.SQLException - if a database-access error occurs.

setCatalog

public void setCatalog(java.lang.String catalog)
                throws java.sql.SQLException
A sub-space of this Connection's database may be selected by setting a catalog name. If the driver does not support catalogs it will silently ignore this request.

Specified by:
setCatalog in interface java.sql.Connection
Throws:
java.sql.SQLException - if a database-access error occurs.

getCatalog

public java.lang.String getCatalog()
                            throws java.sql.SQLException
Return the Connection's current catalog name.

Specified by:
getCatalog in interface java.sql.Connection
Returns:
the current catalog name or null
Throws:
java.sql.SQLException - if a database-access error occurs.

setTransactionIsolation

public void setTransactionIsolation(int level)
                             throws java.sql.SQLException
You can call this method to try to change the transaction isolation level using one of the TRANSACTION_* values.

Note: setTransactionIsolation causes the current transaction to commit if the isolation level is changed. Otherwise, if the requested isolation level is the same as the current isolation level, this method is a no-op.

Specified by:
setTransactionIsolation in interface java.sql.Connection
Parameters:
level - one of the TRANSACTION_* isolation values with the exception of TRANSACTION_NONE; some databases may not support other values
Throws:
java.sql.SQLException - if a database-access error occurs.
See Also:
DatabaseMetaData.supportsTransactionIsolationLevel(int)

getTransactionIsolation

public final int getTransactionIsolation()
                                  throws java.sql.SQLException
Get this Connection's current transaction isolation mode.

Specified by:
getTransactionIsolation in interface java.sql.Connection
Returns:
the current TRANSACTION_* mode value
Throws:
java.sql.SQLException - if a database-access error occurs.

getWarnings

public final java.sql.SQLWarning getWarnings()
                                      throws java.sql.SQLException
The first warning reported by calls on this Connection is returned.

Note: Subsequent warnings will be chained to this SQLWarning.

Specified by:
getWarnings in interface java.sql.Connection
Returns:
the first SQLWarning or null Synchronization note: Warnings are synchronized on nesting level
Throws:
java.sql.SQLException

clearWarnings

public final void clearWarnings()
                         throws java.sql.SQLException
After this call, getWarnings returns null until a new warning is reported for this Connection. Synchronization node: Warnings are synchonized on nesting level

Specified by:
clearWarnings in interface java.sql.Connection
Throws:
java.sql.SQLException

getTypeMap

public java.util.Map getTypeMap()
                         throws java.sql.SQLException
Get the type-map object associated with this connection. By default, the map returned is empty. JDBC 2.0 - java.util.Map requires JDK 1

Specified by:
getTypeMap in interface java.sql.Connection
Throws:
java.sql.SQLException

setTypeMap

public final void setTypeMap(java.util.Map map)
                      throws java.sql.SQLException
Install a type-map object as the default type-map for this connection. JDBC 2.0 - java.util.Map requires JDK 1

Specified by:
setTypeMap in interface java.sql.Connection
Throws:
java.sql.SQLException - Feature not implemented for now.

addWarning

public final void addWarning(java.sql.SQLWarning newWarning)
Add a warning to the current list of warnings, to follow this note from Connection.getWarnings. Note: Subsequent warnings will be chained to this SQLWarning.

Specified by:
addWarning in interface EngineConnection
Parameters:
newWarning - Warning to be added, will be chained to any existing warnings.
See Also:
Connection.getWarnings()

getDBName

public java.lang.String getDBName()
Return the dbname for this connection.

Returns:
String The dbname for this connection.

getLanguageConnection

public final LanguageConnectionContext getLanguageConnection()

checkIfClosed

protected final void checkIfClosed()
                            throws java.sql.SQLException
Raises an exception if the connection is closed.

Throws:
java.sql.SQLException - if the connection is closed

handleException

java.sql.SQLException handleException(java.lang.Throwable thrownException)
                                throws java.sql.SQLException
Throws:
java.sql.SQLException

handleException

final java.sql.SQLException handleException(java.lang.Throwable thrownException,
                                            boolean rollbackOnAutoCommit)
                                     throws java.sql.SQLException
Handle any type of Exception. REMIND: now that we know all the exceptions from our driver are Utils, would it make sense to shut down the system for unknown SQLExceptions? At present, we do not. Because this is the last stop for exceptions, it will catch anything that occurs in it and try to cleanup before re-throwing them.

Parameters:
thrownException - the exception
rollbackOnAutoCommit - rollback the xact on if autocommit is on, otherwise rollback stmt but leave xact open (and continue to hold on to locks). Most of the time, this will be true, excepting operations on result sets, like getInt().
Throws:
java.sql.SQLException

setInactive

public final void setInactive()
Close the connection when processing errors, or when closing a nested connection.

This only marks it as closed and frees up its resources; any closing of the underlying connection or commit work is assumed to be done elsewhere. Called from EmbedConnectionContext's cleanup routine, and by proxy.close().


finalize

protected void finalize()
                 throws java.lang.Throwable
Overrides:
finalize in class java.lang.Object
Throws:
java.lang.Throwable - standard error policy

needCommit

protected void needCommit()
if auto commit is on, remember that we need to commit the current statement.


commitIfNeeded

protected void commitIfNeeded()
                       throws java.sql.SQLException
if a commit is needed, perform it. Must have connection synchonization and context set up already.

Throws:
java.sql.SQLException - if commit returns error

commitIfAutoCommit

protected void commitIfAutoCommit()
                           throws java.sql.SQLException
If in autocommit, then commit. Used to force a commit after a result set closes in autocommit mode. The needCommit mechanism does not work correctly as there are times with cursors (like a commit, followed by a next, followed by a close) where the system does not think it needs a commit but we need to force the commit on close. It seemed safer to just force a commit on close rather than count on keeping the needCommit flag correct for all cursor cases. Must have connection synchonization and context set up already.

Throws:
java.sql.SQLException - if commit returns error

getConnectionSynchronization

protected final java.lang.Object getConnectionSynchronization()

setupContextStack

protected final void setupContextStack()
                                throws java.sql.SQLException
Install the context manager for this thread. Check connection status here.

Throws:
java.sql.SQLException - if fails

restoreContextStack

protected final void restoreContextStack()
                                  throws java.sql.SQLException
Throws:
java.sql.SQLException

createDatabase

private Database createDatabase(java.lang.String dbname,
                                java.util.Properties info)
                         throws java.sql.SQLException
Create a new database.

Parameters:
dbname - the database name
info - the properties
Returns:
Database The newly created database or null.
Throws:
java.sql.SQLException - if fails to create database

checkDatabaseCreatePrivileges

private void checkDatabaseCreatePrivileges(java.lang.String user,
                                           java.lang.String dbname)
                                    throws java.sql.SQLException
Checks that a user has the system privileges to create a database. To perform this check the following policy grants are required or a SQLException will be raised detailing the cause.

In addition, for the test to succeed

or it will fail with a SQLException detailing the cause.

Parameters:
user - The user to be checked for database create privileges
dbname - the name of the database to create
Throws:
java.sql.SQLException - if the privileges check fails

sleep

private static void sleep(long millis)
Puts the current thread to sleep and sets the interrupt flag of the thread if an InterruptedException is thrown while sleeping.

NOTE: This method does not guarantee that the thread sleeps at least millis milliseconds.

Parameters:
millis - milliseconds to sleep

stripSubSubProtocolPrefix

public static java.lang.String stripSubSubProtocolPrefix(java.lang.String dbname)
Strips any sub-sub-protocol prefix from a database name.

Parameters:
dbname - a database name
Returns:
the database name without any sub-sub-protocol prefixes
Throws:
java.lang.NullPointerException - if dbname is null

bootDatabase

private boolean bootDatabase(java.util.Properties info,
                             boolean softAuthenticationBoot)
                      throws java.lang.Throwable
Boot database.

Parameters:
info - boot properties
softAuthenticationBoot - If true, don't fail soft upgrade due to missing features (phase one of two phased hard upgrade boot).
Returns:
false iff the monitor cannot handle a service of the type indicated by the protocol within the name. If that's the case then we are the wrong driver.
Throws:
java.lang.Throwable - if anything else is wrong.

prepareMetaDataStatement

java.sql.PreparedStatement prepareMetaDataStatement(java.lang.String sql)
                                              throws java.sql.SQLException
Throws:
java.sql.SQLException

getLocalDriver

public final InternalDriver getLocalDriver()

getContextManager

public final ContextManager getContextManager()
Return the context manager for this connection.


filterProperties

private java.util.Properties filterProperties(java.util.Properties inputSet)
Filter out properties from the passed in set of JDBC attributes to remove any derby.* properties. This is to ensure that setting derby.* properties does not work this way, it's not a defined way to set such properties and could be a secuirty hole in allowing remote connections to override system, application or database settings.

Returns:
a new Properties set copied from the parameter but with no derby.* properties.

getDatabase

protected Database getDatabase()

getTR

protected final TransactionResourceImpl getTR()

pushConnectionContext

private EmbedConnectionContext pushConnectionContext(ContextManager cm)

setApplicationConnection

public final void setApplicationConnection(java.sql.Connection applicationConnection)

getApplicationConnection

public final java.sql.Connection getApplicationConnection()

setDrdaID

public void setDrdaID(java.lang.String drdaID)
Description copied from interface: EngineConnection
Set the DRDA identifier for this connection.

Specified by:
setDrdaID in interface EngineConnection

isInGlobalTransaction

public boolean isInGlobalTransaction()
Description copied from interface: EngineConnection
Is this a global transaction

Specified by:
isInGlobalTransaction in interface EngineConnection
Returns:
true if this is a global XA transaction
See Also:
EngineConnection.isInGlobalTransaction()

resetFromPool

public void resetFromPool()
                   throws java.sql.SQLException
Reset the connection before it is returned from a PooledConnection to a new application request (wrapped by a BrokeredConnection). Examples of reset covered here is dropping session temporary tables and reseting IDENTITY_VAL_LOCAL. Most JDBC level reset is handled by calling standard java.sql.Connection methods from EmbedPooledConnection.

Specified by:
resetFromPool in interface EngineConnection
Throws:
java.sql.SQLException

xa_prepare

public final int xa_prepare()
                     throws java.sql.SQLException
Do not use this method directly use XATransactionState.xa_prepare instead because it also maintains/cancels the timout task which is scheduled to cancel/rollback the global transaction.

Throws:
java.sql.SQLException

xa_commit

public final void xa_commit(boolean onePhase)
                     throws java.sql.SQLException
Do not use this method directly use XATransactionState.xa_commit instead because it also maintains/cancels the timout task which is scheduled to cancel/rollback the global transaction.

Throws:
java.sql.SQLException

xa_rollback

public final void xa_rollback()
                       throws java.sql.SQLException
Do not use this method directly use XATransactionState.xa_rollback instead because it also maintains/cancels the timout task which is scheduled to cancel/rollback the global transaction.

Throws:
java.sql.SQLException

transactionIsIdle

public final boolean transactionIsIdle()
returns false if there is an underlying transaction and that transaction has done work. True if there is no underlying transaction or that underlying transaction is idle


setResultSetType

private int setResultSetType(int resultSetType)

setPrepareIsolation

public void setPrepareIsolation(int level)
                         throws java.sql.SQLException
Set the transaction isolation level that will be used for the next prepare. Used by network server to implement DB2 style isolation levels.

Specified by:
setPrepareIsolation in interface EngineConnection
Parameters:
level - Isolation level to change to. level is the DB2 level specified in the package names which happen to correspond to our internal levels. If level == ExecutionContext.UNSPECIFIED_ISOLATION, the statement won't be prepared with an isolation level.
Throws:
java.sql.SQLException

getPrepareIsolation

public int getPrepareIsolation()
Return prepare isolation

Specified by:
getPrepareIsolation in interface EngineConnection

getResultSetOrderId

final int getResultSetOrderId()
Return a unique order number for a result set. A unique value is only needed if the result set is being created within procedure and thus must be using a nested connection.


newSQLException

protected java.sql.SQLException newSQLException(java.lang.String messageId)

newSQLException

protected java.sql.SQLException newSQLException(java.lang.String messageId,
                                                java.lang.Object arg1)

newSQLException

protected java.sql.SQLException newSQLException(java.lang.String messageId,
                                                java.lang.Object arg1,
                                                java.lang.Object arg2)

toString

public java.lang.String toString()
Get a String representation that uniquely identifies this connection. Include the same information that is printed in the log for various trace and error messages. In Derby the "physical" connection is a LanguageConnectionContext, or LCC. The JDBC Connection is an JDBC-specific layer on top of this. Rather than create a new id here, we simply use the id of the underlying LCC. Note that this is a big aid in debugging, because much of the engine trace and log code prints the LCC id.

Overrides:
toString in class java.lang.Object
Returns:
a string representation for this connection

createClob

public java.sql.Clob createClob()
                         throws java.sql.SQLException
Constructs an object that implements the Clob interface. The object returned initially contains no data. The setAsciiStream, setCharacterStream and setString methods of the Clob interface may be used to add data to the Clob.

Specified by:
createClob in interface java.sql.Connection
Returns:
An object that implements the Clob interface
Throws:
java.sql.SQLException - if an object that implements the Clob interface can not be constructed, this method is called on a closed connection or a database access error occurs.

createBlob

public java.sql.Blob createBlob()
                         throws java.sql.SQLException
Constructs an object that implements the Blob interface. The object returned initially contains no data. The setBinaryStream and setBytes methods of the Blob interface may be used to add data to the Blob.

Specified by:
createBlob in interface java.sql.Connection
Returns:
An object that implements the Blob interface
Throws:
java.sql.SQLException - if an object that implements the Blob interface can not be constructed, this method is called on a closed connection or a database access error occurs.

addLOBMapping

public int addLOBMapping(java.lang.Object LOBReference)
Add the locator and the corresponding LOB object into the HashMap

Parameters:
LOBReference - The object which contains the LOB object that that is added to the HashMap.
Returns:
an integer that represents the locator that has been allocated to this LOB.

removeLOBMapping

public void removeLOBMapping(int key)
Remove the key(LOCATOR) from the hash table.

Parameters:
key - an integer that represents the locator that needs to be removed from the table.

getLOBMapping

public java.lang.Object getLOBMapping(int key)
Get the LOB reference corresponding to the locator.

Specified by:
getLOBMapping in interface EngineConnection
Parameters:
key - the integer that represents the LOB locator value.
Returns:
the LOB Object corresponding to this locator.

clearLOBMapping

public void clearLOBMapping()
                     throws java.sql.SQLException
Clear the HashMap of all entries. Called when a commit or rollback of the transaction happens.

Specified by:
clearLOBMapping in interface EngineConnection
Throws:
java.sql.SQLException

getIncLOBKey

private int getIncLOBKey()
Return the current locator value/ 0x800x values are not valid values as they are used to indicate the BLOB is being sent by value, so we skip those values (DERBY-3243)

Returns:
an integer that represents the most recent locator value.

addLOBReference

void addLOBReference(java.lang.Object lobReference)
Adds an entry of the lob in WeakHashMap. These entries are used for cleanup during commit/rollback or close.

Parameters:
lobReference - LOB Object

getlobHMObj

public java.util.HashMap getlobHMObj()
Return the Hash Map in the root connection

Returns:
the HashMap that contains the locator to LOB object mapping

cancelRunningStatement

public void cancelRunningStatement()
Cancels the current running statement.


getCurrentSchemaName

public java.lang.String getCurrentSchemaName()
Obtain the name of the current schema. Not part of the java.sql.Connection interface, but is accessible through the EngineConnection interface, so that the NetworkServer can get at the current schema for piggy-backing

Specified by:
getCurrentSchemaName in interface EngineConnection
Returns:
the current schema name

addLobFile

void addLobFile(LOBFile lobFile)
Add a temporary lob file to the lobFiles set. This will get closed at transaction end or removed as the lob is freed.

Parameters:
lobFile - LOBFile to add

removeLobFile

void removeLobFile(LOBFile lobFile)
Remove LOBFile from the lobFiles set. This will occur when the lob is freed or at transaction end if the lobFile was removed from the WeakHashMap but not finalized.

Parameters:
lobFile - LOBFile to remove.

Built on Thu 2012-03-29 21:53:33+0000, from revision ???

Apache Derby V10.6 Internals - Copyright © 2004,2007 The Apache Software Foundation. All Rights Reserved.