Derby - Class org.apache.derby.impl.jdbc.EmbedConnection

   Licensed to the Apache Software Foundation (ASF) under one or more

   contributor license agreements.  See the NOTICE file distributed with

   this work for additional information regarding copyright ownership.

   The ASF licenses this file to you under the Apache License, Version 2.0

   (the "License"); you may not use this file except in compliance with

   the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software

   distributed under the License is distributed on an "AS IS" BASIS,

   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

   See the License for the specific language governing permissions and

   limitations under the License.

*/

import java.sql.Connection;

import java.sql.ResultSet;

*/

* Local implementation of Connection for a JDBC driver in

* the same process as the database.

* <p>

* There is always a single root (parent) connection.  The

* initial JDBC connection is the root connection. A

* call to <I>getCurrentConnection()</I> or with the URL

* <I>jdbc:default:connection</I> 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).

* <p>

* <B>SYNCHRONIZATION</B>: 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.

   <P><B>Supports</B>

   <UL>

  <LI> JDBC 2.0

   </UL>

*

*

* @see TransactionResourceImpl

*

*/

  protected static final StandardException exceptionClose = StandardException.closeException();

   

    /**

     * 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.

     */

    public static final SQLException NO_MEM =

        Util.generateCsSQLException(SQLState.LOGIN_FAILED, "java.lang.OutOfMemoryError");

   

    /**

     * Low memory state object for connection requests.

     */

    public static final LowMemory memoryState = new LowMemory();

  //////////////////////////////////////////////////////////

  // OBJECTS SHARED ACROSS CONNECTION NESTING

  //////////////////////////////////////////////////////////

  DatabaseMetaData dbMetadata;

  TransactionResourceImpl tr; // always access tr thru getTR()

  private HashMap lobHashMap = null;

  private int lobHMKey = 0;

    /**

     * 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

     */

    private WeakHashMap lobReferences = null;

    // Set to keep track of the open LOBFiles, so they can be closed at the end of

    // the transaction. This would normally happen as lobReferences are freed as they

    // get garbage collected after being removed from the WeakHashMap, but it is

    // possible that finalization will not have occurred before the user tries to

    // remove the database (DERBY-3655).  Therefore we keep this set so that we can

    // explicitly close the files.

    private HashSet lobFiles;

   

  //////////////////////////////////////////////////////////

  // STATE (copied to new nested connections, but nesting

  // specific)

  //////////////////////////////////////////////////////////

  private boolean  active;

    private boolean aborting = false;

  boolean  autoCommit = true;

  boolean  needCommit;

  // Set to true if NONE authentication is being used

  private boolean usingNoneAuth;

  /*

     following is a new feature in JDBC3.0 where you can specify the holdability

     of a resultset at the end of the transaction. This gets set by the

   new method setHoldability(int) in JDBC3.0

     *

   */

  private int  connectionHoldAbility = ResultSet.HOLD_CURSORS_OVER_COMMIT;

  //////////////////////////////////////////////////////////

  // NESTING SPECIFIC OBJECTS

  //////////////////////////////////////////////////////////

  /*

  ** The root connection is the base connection upon

  ** which all actions are synchronized.  By default,

  ** we are the root connection unless we are created

  ** by copying the state from another connection.

  */

  final EmbedConnection rootConnection;

  private SQLWarning     topWarning;

  /** 

    Factory for JDBC objects to be created.

  */

  private InternalDriver factory;

  /**

    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.

  */

  private java.sql.Connection applicationConnection;

  /**

    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.

  */

  private int resultSetId;

   

    /** Cached string representation of the connection id */

    private String connString;

  //////////////////////////////////////////////////////////

  // CONSTRUCTORS

  //////////////////////////////////////////////////////////

  // create a new Local Connection, using a new context manager

  //

  public EmbedConnection(InternalDriver driver, String url, Properties info)

     throws SQLException

  {

    // Create a root connection.

    applicationConnection = rootConnection = this;

    factory = driver;

    tr = new TransactionResourceImpl(driver, url, info);

    active = true;

    // register this thread and its context manager with

    // the global context service

    setupContextStack();

    try {

      // stick my context into the context manager

      EmbedConnectionContext context = pushConnectionContext(tr.getContextManager());

      // if we are shutting down don't attempt to boot or create the database

      boolean shutdown = Boolean.valueOf(info.getProperty(Attribute.SHUTDOWN_ATTR)).booleanValue();

      // see if database is already booted

      Database database = (Database) Monitor.findService(Property.DATABASE_MODULE, tr.getDBName());

      // See if user wants to create a new database.

      boolean  createBoot = createBoot(info); 

      // DERBY-2264: keeps track of whether we do a plain boot before an

      // (re)encryption or hard upgrade boot to (possibly) authenticate

      // first. We can not authenticate before we have booted, so in

      // order to enforce data base owner powers over encryption or

      // upgrade, we need a plain boot, then authenticate, then, if all

      // is well, boot with (re)encryption or upgrade.  Encryption at

      // create time is not checked.

      boolean isTwoPhaseEncryptionBoot = (!createBoot &&

                        isEncryptionBoot(info));

      boolean isTwoPhaseUpgradeBoot = (!createBoot &&

                       isHardUpgradeBoot(info));

      boolean isStartSlaveBoot = isStartReplicationSlaveBoot(info);

            // Set to true if startSlave command is attempted on an

            // already booted database. Will raise an exception when

            // credentials have been verified

            boolean slaveDBAlreadyBooted = false;

            boolean isFailoverMasterBoot = false;

            boolean isFailoverSlaveBoot = false;

            final boolean dropDatabase = isDropDatabase(info);

            // Don't allow both the shutdown and the drop attribute.

            if (shutdown && dropDatabase) {

                throw newSQLException(

                        SQLState.CONFLICTING_BOOT_ATTRIBUTES,

                        Attribute.SHUTDOWN_ATTR + ", " + Attribute.DROP_ATTR);

            }

            // check that a replication operation is not combined with

            // other operations

            String replicationOp = getReplicationOperation(info);

            if (replicationOp!= null) {

                if (createBoot ||

                    shutdown ||

                    dropDatabase ||

                    isTwoPhaseEncryptionBoot ||

                    isTwoPhaseUpgradeBoot) {

                    throw StandardException.

                        newException(SQLState.

                                     REPLICATION_CONFLICTING_ATTRIBUTES,

                                     replicationOp);

                }

            }

            if (isReplicationFailover(info)) {

                // Check that the database has been booted - otherwise throw

                // exception.

                checkDatabaseBooted(database,

                                    Attribute.REPLICATION_FAILOVER,

                                    tr.getDBName());

                // The failover command is the same for master and slave

                // databases. If the db is not in slave replication mode, we

                // assume that it is in master mode. If not in any replication

                // mode, the connection attempt will fail with an exception

                if (database.isInSlaveMode()) {

                    isFailoverSlaveBoot = true;

                } else {

                    isFailoverMasterBoot = true;

                }

            }

      // Save original properties if we modified them for

      // two phase encryption or upgrade boot.

      Properties savedInfo = null;

            if (isStartSlaveBoot) {

                if (database != null) {

                    // If the slave database has already been booted,

                    // the command should fail. Setting

                    // slaveDBAlreadyBooted to true will cause an

                    // exception to be thrown, but not until after

                    // credentials have been verified so that db boot

                    // information is not exposed to unauthorized

                    // users

                    slaveDBAlreadyBooted = true;

                } else {

                    // We need to boot the slave database two times. The

                    // first boot will check authentication and

                    // authorization. The second boot will put the

                    // database in replication slave mode. SLAVE_PRE_MODE

                    // ensures that log records are not written to disk

                    // during the first boot. This is necessary because

                    // the second boot needs a log that is exactly equal

                    // to the log at the master.

                    info.setProperty(SlaveFactory.REPLICATION_MODE,

                                     SlaveFactory.SLAVE_PRE_MODE);

                }

            }

            if (isStopReplicationSlaveBoot(info)) {

                // DERBY-3383: stopSlave must be performed before

                // bootDatabase so that we don't accidentally boot the db

                // if stopSlave is requested on an unbooted db.

                // An exception is always thrown from this method. If

                // stopSlave is requested, we never get past this point

                handleStopReplicationSlave(database, info);

            } else if (isInternalShutdownSlaveDatabase(info)) {

                internalStopReplicationSlave(database, info);

                return;

            } else if (isFailoverSlaveBoot) {

                // For slave side failover, we perform failover before

                // connecting to the db (tr.startTransaction further down sets

                // up the connection). If a connection had been

                // established first, the connection attempt would throw an

                // exception saying that a database in slave mode cannot be

                // connected to

                handleFailoverSlave(database);

                // db is no longer in slave mode - proceed with normal

                // connection attempt

            }

      if (database != null)

      {

        // database already booted by someone else

        tr.setDatabase(database);

        isTwoPhaseEncryptionBoot = false;

        isTwoPhaseUpgradeBoot = false;

      }

      else if (!shutdown)

      {

        if (isTwoPhaseEncryptionBoot || isTwoPhaseUpgradeBoot) {

          savedInfo = info;

          info = removePhaseTwoProps((Properties)info.clone());

        }

        // Return false iff the monitor cannot handle a service of the

        // type indicated by the proptocol within the name.  If that's

        // the case then we are the wrong driver.

        if (!bootDatabase(info, isTwoPhaseUpgradeBoot))

        {

          tr.clearContextInError();

          setInactive();

          return;

        }

      }

           if (createBoot && !shutdown && !dropDatabase)

      {

        // if we are shutting down don't attempt to boot or create the

        // database

        if (tr.getDatabase() != null) {

          addWarning(SQLWarningFactory.newSQLWarning(SQLState.DATABASE_EXISTS, getDBName()));

        } else {

                    //

          // Check for user's credential and authenticate the user

          // with the system level authentication service.

                    //

                    checkUserCredentials( true, null, info );

         

          // Process with database creation

          database = createDatabase(tr.getDBName(), info);

          tr.setDatabase(database);

        }

      }

      if (tr.getDatabase() == null) {

        handleDBNotFound();

      }

      // Check User's credentials and if it is a valid user of

      // the database

      //

            try {

                checkUserCredentials( false, tr.getDBName(), info );