Logo Search packages:      
Sourcecode: mysql-connector-java version File versions  Download package

ConnectionWrapper.java

/*
 Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
 

  The MySQL Connector/J is licensed under the terms of the GPLv2
  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most MySQL Connectors.
  There are special exceptions to the terms and conditions of the GPLv2 as it is applied to
  this software, see the FLOSS License Exception
  <http://www.mysql.com/about/legal/licensing/foss-exception.html>.

  This program is free software; you can redistribute it and/or modify it under the terms
  of the GNU General Public License as published by the Free Software Foundation; version 2
  of the License.

  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along with this
  program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth
  Floor, Boston, MA 02110-1301  USA



 */
package com.mysql.jdbc.jdbc2.optional;

import java.lang.reflect.Constructor;
import java.sql.SQLException;
import java.sql.Savepoint;
import java.sql.Statement;
import java.util.Map;
import java.util.Properties;
import java.util.TimeZone;

import com.mysql.jdbc.Connection;
import com.mysql.jdbc.ExceptionInterceptor;
import com.mysql.jdbc.Extension;
import com.mysql.jdbc.MySQLConnection;
import com.mysql.jdbc.MysqlErrorNumbers;
import com.mysql.jdbc.SQLError;
import com.mysql.jdbc.Util;
import com.mysql.jdbc.log.Log;

/**
 * This class serves as a wrapper for the org.gjt.mm.mysql.jdbc2.Connection
 * class. It is returned to the application server which may wrap it again and
 * then return it to the application client in response to
 * dataSource.getConnection().
 * 
 * <p>
 * All method invocations are forwarded to org.gjt.mm.mysql.jdbc2.Connection
 * unless the close method was previously called, in which case a sqlException
 * is thrown. The close method performs a 'logical close' on the connection.
 * </p>
 * 
 * <p>
 * All sqlExceptions thrown by the physical connection are intercepted and sent
 * to connectionEvent listeners before being thrown to client.
 * </p>
 * 
 * @author Todd Wolff todd.wolff_at_prodigy.net
 * 
 * @see org.gjt.mm.mysql.jdbc2.Connection
 * @see org.gjt.mm.mysql.jdbc2.optional.MysqlPooledConnection
 */
00067 public class ConnectionWrapper extends WrapperBase implements Connection {
      protected Connection mc = null;

      private String invalidHandleStr = "Logical handle no longer valid";

      private boolean closed;

      private boolean isForXa;

      private static final Constructor JDBC_4_CONNECTION_WRAPPER_CTOR;

      static {
            if (Util.isJdbc4()) {
                  try {
                        JDBC_4_CONNECTION_WRAPPER_CTOR = Class.forName(
                                    "com.mysql.jdbc.jdbc2.optional.JDBC4ConnectionWrapper")
                                    .getConstructor(
                                                new Class[] { MysqlPooledConnection.class,
                                                            Connection.class, Boolean.TYPE });
                  } catch (SecurityException e) {
                        throw new RuntimeException(e);
                  } catch (NoSuchMethodException e) {
                        throw new RuntimeException(e);
                  } catch (ClassNotFoundException e) {
                        throw new RuntimeException(e);
                  }
            } else {
                  JDBC_4_CONNECTION_WRAPPER_CTOR = null;
            }
      }

      protected static ConnectionWrapper getInstance(
                  MysqlPooledConnection mysqlPooledConnection,
                  Connection mysqlConnection, boolean forXa) throws SQLException {
            if (!Util.isJdbc4()) {
                  return new ConnectionWrapper(mysqlPooledConnection,
                              mysqlConnection, forXa);
            }

            return (ConnectionWrapper) Util.handleNewInstance(
                        JDBC_4_CONNECTION_WRAPPER_CTOR, new Object[] {
                                    mysqlPooledConnection, mysqlConnection,
                                    Boolean.valueOf(forXa) }, mysqlPooledConnection.getExceptionInterceptor());
      }

      /**
       * Construct a new LogicalHandle and set instance variables
       * 
       * @param mysqlPooledConnection
       *            reference to object that instantiated this object
       * @param mysqlConnection
       *            physical connection to db
       * 
       * @throws SQLException
       *             if an error occurs.
       */
00123       public ConnectionWrapper(MysqlPooledConnection mysqlPooledConnection,
                  Connection mysqlConnection, boolean forXa) throws SQLException {
            super(mysqlPooledConnection);
            
            this.mc = mysqlConnection;
            this.closed = false;
            this.isForXa = forXa;

            if (this.isForXa) {
                  setInGlobalTx(false);
            }
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#setAutoCommit
       */
00142       public void setAutoCommit(boolean autoCommit) throws SQLException {
            checkClosed();

            if (autoCommit && isInGlobalTx()) {
                  throw SQLError.createSQLException(
                              "Can't set autocommit to 'true' on an XAConnection",
                              SQLError.SQL_STATE_INVALID_TRANSACTION_TERMINATION,
                              MysqlErrorNumbers.ER_XA_RMERR, this.exceptionInterceptor);
            }

            try {
                  this.mc.setAutoCommit(autoCommit);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#getAutoCommit()
       */
00165       public boolean getAutoCommit() throws SQLException {
            checkClosed();

            try {
                  return this.mc.getAutoCommit();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return false; // we don't reach this code, compiler can't tell
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#setCatalog()
       */
00183       public void setCatalog(String catalog) throws SQLException {
            checkClosed();

            try {
                  this.mc.setCatalog(catalog);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @return the current catalog
       * 
       * @throws SQLException
       *             if an error occurs
       */
00202       public String getCatalog() throws SQLException {
            checkClosed();

            try {
                  return this.mc.getCatalog();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#isClosed()
       */
00220       public boolean isClosed() throws SQLException {
            return (this.closed || this.mc.isClosed());
      }

00224       public boolean isMasterConnection() {
            return this.mc.isMasterConnection();
      }

      /**
       * @see Connection#setHoldability(int)
       */
00231       public void setHoldability(int arg0) throws SQLException {
            checkClosed();

            try {
                  this.mc.setHoldability(arg0);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

      /**
       * @see Connection#getHoldability()
       */
00244       public int getHoldability() throws SQLException {
            checkClosed();

            try {
                  return this.mc.getHoldability();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return Statement.CLOSE_CURRENT_RESULT; // we don't reach this code,
            // compiler can't tell
      }

      /**
       * Allows clients to determine how long this connection has been idle.
       * 
       * @return how long the connection has been idle.
       */
00262       public long getIdleFor() {
            return this.mc.getIdleFor();
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @return a metadata instance
       * 
       * @throws SQLException
       *             if an error occurs
       */
00275       public java.sql.DatabaseMetaData getMetaData() throws SQLException {
            checkClosed();

            try {
                  return this.mc.getMetaData();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#setReadOnly()
       */
00293       public void setReadOnly(boolean readOnly) throws SQLException {
            checkClosed();

            try {
                  this.mc.setReadOnly(readOnly);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#isReadOnly()
       */
00309       public boolean isReadOnly() throws SQLException {
            checkClosed();

            try {
                  return this.mc.isReadOnly();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return false; // we don't reach this code, compiler can't tell
      }

      /**
       * @see Connection#setSavepoint()
       */
00324       public java.sql.Savepoint setSavepoint() throws SQLException {
            checkClosed();

            if (isInGlobalTx()) {
                  throw SQLError.createSQLException(
                              "Can't set autocommit to 'true' on an XAConnection",
                              SQLError.SQL_STATE_INVALID_TRANSACTION_TERMINATION,
                              MysqlErrorNumbers.ER_XA_RMERR, this.exceptionInterceptor);
            }

            try {
                  return this.mc.setSavepoint();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * @see Connection#setSavepoint(String)
       */
00346       public java.sql.Savepoint setSavepoint(String arg0) throws SQLException {
            checkClosed();

            if (isInGlobalTx()) {
                  throw SQLError.createSQLException(
                              "Can't set autocommit to 'true' on an XAConnection",
                              SQLError.SQL_STATE_INVALID_TRANSACTION_TERMINATION,
                              MysqlErrorNumbers.ER_XA_RMERR, this.exceptionInterceptor);
            }

            try {
                  return this.mc.setSavepoint(arg0);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#setTransactionIsolation()
       */
00371       public void setTransactionIsolation(int level) throws SQLException {
            checkClosed();

            try {
                  this.mc.setTransactionIsolation(level);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#getTransactionIsolation()
       */
00387       public int getTransactionIsolation() throws SQLException {
            checkClosed();

            try {
                  return this.mc.getTransactionIsolation();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return TRANSACTION_REPEATABLE_READ; // we don't reach this code,
            // compiler can't tell
      }


      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#getTypeMap()
       */
00407       public java.util.Map getTypeMap() throws SQLException {
            checkClosed();

            try {
                  return this.mc.getTypeMap();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#getWarnings
       */
00425       public java.sql.SQLWarning getWarnings() throws SQLException {
            checkClosed();

            try {
                  return this.mc.getWarnings();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @throws SQLException
       *             if an error occurs
       */
00444       public void clearWarnings() throws SQLException {
            checkClosed();

            try {
                  this.mc.clearWarnings();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

      /**
       * The physical connection is not actually closed. the physical connection
       * is closed when the application server calls
       * mysqlPooledConnection.close(). this object is de-referenced by the pooled
       * connection each time mysqlPooledConnection.getConnection() is called by
       * app server.
       * 
       * @throws SQLException
       *             if an error occurs
       */
00464       public void close() throws SQLException {
            close(true);
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @throws SQLException
       *             if an error occurs
       */
00475       public void commit() throws SQLException {
            checkClosed();

            if (isInGlobalTx()) {
                  throw SQLError
                              .createSQLException(
                                          "Can't call commit() on an XAConnection associated with a global transaction",
                                          SQLError.SQL_STATE_INVALID_TRANSACTION_TERMINATION,
                                          MysqlErrorNumbers.ER_XA_RMERR, this.exceptionInterceptor);
            }

            try {
                  this.mc.commit();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#createStatement()
       */
00499       public java.sql.Statement createStatement() throws SQLException {
            checkClosed();

            try {
                  return StatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .createStatement());
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#createStatement()
       */
00518       public java.sql.Statement createStatement(int resultSetType,
                  int resultSetConcurrency) throws SQLException {
            checkClosed();

            try {
                  return StatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .createStatement(resultSetType, resultSetConcurrency));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * @see Connection#createStatement(int, int, int)
       */
00535       public java.sql.Statement createStatement(int arg0, int arg1, int arg2)
                  throws SQLException {
            checkClosed();

            try {
                  return StatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .createStatement(arg0, arg1, arg2));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#nativeSQL()
       */
00555       public String nativeSQL(String sql) throws SQLException {
            checkClosed();

            try {
                  return this.mc.nativeSQL(sql);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#prepareCall()
       */
00573       public java.sql.CallableStatement prepareCall(String sql)
                  throws SQLException {
            checkClosed();

            try {
                  return CallableStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .prepareCall(sql));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#prepareCall()
       */
00593       public java.sql.CallableStatement prepareCall(String sql,
                  int resultSetType, int resultSetConcurrency) throws SQLException {
            checkClosed();

            try {
                  return CallableStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .prepareCall(sql, resultSetType, resultSetConcurrency));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * @see Connection#prepareCall(String, int, int, int)
       */
00610       public java.sql.CallableStatement prepareCall(String arg0, int arg1,
                  int arg2, int arg3) throws SQLException {
            checkClosed();

            try {
                  return CallableStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .prepareCall(arg0, arg1, arg2, arg3));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      public java.sql.PreparedStatement clientPrepare(String sql)
                  throws SQLException {
            checkClosed();

            try {
                  return new PreparedStatementWrapper(this, this.pooledConnection, this.mc
                              .clientPrepareStatement(sql));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

      public java.sql.PreparedStatement clientPrepare(String sql,
                  int resultSetType, int resultSetConcurrency) throws SQLException {
            checkClosed();

            try {
                  return new PreparedStatementWrapper(this, this.pooledConnection, this.mc
                              .clientPrepareStatement(sql, resultSetType,
                                          resultSetConcurrency));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#prepareStatement()
       */
00659       public java.sql.PreparedStatement prepareStatement(String sql)
                  throws SQLException {
            checkClosed();

            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .prepareStatement(sql));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#prepareStatement()
       */
00679       public java.sql.PreparedStatement prepareStatement(String sql,
                  int resultSetType, int resultSetConcurrency) throws SQLException {
            checkClosed();

            try {
                  return PreparedStatementWrapper
                              .getInstance(this, this.pooledConnection, this.mc.prepareStatement(sql,
                                          resultSetType, resultSetConcurrency));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * @see Connection#prepareStatement(String, int, int, int)
       */
00697       public java.sql.PreparedStatement prepareStatement(String arg0, int arg1,
                  int arg2, int arg3) throws SQLException {
            checkClosed();

            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .prepareStatement(arg0, arg1, arg2, arg3));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * @see Connection#prepareStatement(String, int)
       */
00714       public java.sql.PreparedStatement prepareStatement(String arg0, int arg1)
                  throws SQLException {
            checkClosed();

            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .prepareStatement(arg0, arg1));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * @see Connection#prepareStatement(String, int[])
       */
00731       public java.sql.PreparedStatement prepareStatement(String arg0, int[] arg1)
                  throws SQLException {
            checkClosed();

            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .prepareStatement(arg0, arg1));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * @see Connection#prepareStatement(String, String[])
       */
00748       public java.sql.PreparedStatement prepareStatement(String arg0,
                  String[] arg1) throws SQLException {
            checkClosed();

            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .prepareStatement(arg0, arg1));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null; // we don't reach this code, compiler can't tell
      }

      /**
       * @see Connection#releaseSavepoint(Savepoint)
       */
00765       public void releaseSavepoint(Savepoint arg0) throws SQLException {
            checkClosed();

            try {
                  this.mc.releaseSavepoint(arg0);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

      /**
       * Passes call to method on physical connection instance. Notifies listeners
       * of any caught exceptions before re-throwing to client.
       * 
       * @see java.sql.Connection#rollback()
       */
00781       public void rollback() throws SQLException {
            checkClosed();

            if (isInGlobalTx()) {
                  throw SQLError
                              .createSQLException(
                                          "Can't call rollback() on an XAConnection associated with a global transaction",
                                          SQLError.SQL_STATE_INVALID_TRANSACTION_TERMINATION,
                                          MysqlErrorNumbers.ER_XA_RMERR, this.exceptionInterceptor);
            }

            try {
                  this.mc.rollback();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

      /**
       * @see Connection#rollback(Savepoint)
       */
00802       public void rollback(Savepoint arg0) throws SQLException {
            checkClosed();

            if (isInGlobalTx()) {
                  throw SQLError
                              .createSQLException(
                                          "Can't call rollback() on an XAConnection associated with a global transaction",
                                          SQLError.SQL_STATE_INVALID_TRANSACTION_TERMINATION,
                                          MysqlErrorNumbers.ER_XA_RMERR, this.exceptionInterceptor);
            }

            try {
                  this.mc.rollback(arg0);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

00820       public boolean isSameResource(Connection c) {
            if (c instanceof ConnectionWrapper) {
                  return this.mc.isSameResource(((ConnectionWrapper) c).mc);
            } else if (c instanceof com.mysql.jdbc.Connection) {
                  return this.mc.isSameResource((com.mysql.jdbc.Connection) c);
            }

            return false;
      }

      protected void close(boolean fireClosedEvent) throws SQLException {
            synchronized (this.pooledConnection) {
                  if (this.closed) {
                        return;
                  }

                  if (!isInGlobalTx() && this.mc.getRollbackOnPooledClose()
                              && !this.getAutoCommit()) {
                        rollback();
                  }

                  if (fireClosedEvent) {
                        this.pooledConnection.callConnectionEventListeners(
                                    MysqlPooledConnection.CONNECTION_CLOSED_EVENT, null);
                  }

                  // set closed status to true so that if application client tries to
                  // make additional
                  // calls a sqlException will be thrown. The physical connection is
                  // re-used by the pooled connection each time getConnection is
                  // called.
                  this.closed = true;
            }
      }

      protected void checkClosed() throws SQLException {
            if (this.closed) {
                  throw SQLError.createSQLException(this.invalidHandleStr, this.exceptionInterceptor);
            }
      }

00861       public boolean isInGlobalTx() {
            return this.mc.isInGlobalTx();
      }

00865       public void setInGlobalTx(boolean flag) {
            this.mc.setInGlobalTx(flag);
      }

00869       public void ping() throws SQLException {
            if (this.mc != null) {
                  this.mc.ping();
            }
      }

00875       public void changeUser(String userName, String newPassword)
                  throws SQLException {
            checkClosed();

            try {
                  this.mc.changeUser(userName, newPassword);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

      public void clearHasTriedMaster() {
            this.mc.clearHasTriedMaster();
      }

00890       public java.sql.PreparedStatement clientPrepareStatement(String sql)
                  throws SQLException {
            checkClosed();

            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .clientPrepareStatement(sql));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

00904       public java.sql.PreparedStatement clientPrepareStatement(String sql,
                  int autoGenKeyIndex) throws SQLException {
            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .clientPrepareStatement(sql, autoGenKeyIndex));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

00916       public java.sql.PreparedStatement clientPrepareStatement(String sql,
                  int resultSetType, int resultSetConcurrency) throws SQLException {
            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .clientPrepareStatement(sql, resultSetType,
                                          resultSetConcurrency));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

00929       public java.sql.PreparedStatement clientPrepareStatement(String sql,
                  int resultSetType, int resultSetConcurrency,
                  int resultSetHoldability) throws SQLException {
            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .clientPrepareStatement(sql, resultSetType,
                                          resultSetConcurrency, resultSetHoldability));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

00943       public java.sql.PreparedStatement clientPrepareStatement(String sql,
                  int[] autoGenKeyIndexes) throws SQLException {
            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .clientPrepareStatement(sql, autoGenKeyIndexes));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

00955       public java.sql.PreparedStatement clientPrepareStatement(String sql,
                  String[] autoGenKeyColNames) throws SQLException {
            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .clientPrepareStatement(sql, autoGenKeyColNames));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

00967       public int getActiveStatementCount() {
            return this.mc.getActiveStatementCount();
      }

00971       public Log getLog() throws SQLException {
            return this.mc.getLog();
      }

00975       public String getServerCharacterEncoding() {
            return this.mc.getServerCharacterEncoding();
      }

00979       public TimeZone getServerTimezoneTZ() {
            return this.mc.getServerTimezoneTZ();
      }

00983       public String getStatementComment() {
            return this.mc.getStatementComment();
      }

00987       public boolean hasTriedMaster() {
            return this.mc.hasTriedMaster();
      }

      public boolean isAbonormallyLongQuery(long millisOrNanos) {
            return this.mc.isAbonormallyLongQuery(millisOrNanos);
      }

00995       public boolean isNoBackslashEscapesSet() {
            return this.mc.isNoBackslashEscapesSet();
      }

00999       public boolean lowerCaseTableNames() {
            return this.mc.lowerCaseTableNames();
      }

01003       public boolean parserKnowsUnicode() {
            return this.mc.parserKnowsUnicode();
      }

      public void reportQueryTime(long millisOrNanos) {
            this.mc.reportQueryTime(millisOrNanos);
      }

01011       public void resetServerState() throws SQLException {
            checkClosed();

            try {
                  this.mc.resetServerState();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

01021       public java.sql.PreparedStatement serverPrepareStatement(String sql)
                  throws SQLException {
            checkClosed();

            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .serverPrepareStatement(sql));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

01035       public java.sql.PreparedStatement serverPrepareStatement(String sql,
                  int autoGenKeyIndex) throws SQLException {
            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .serverPrepareStatement(sql, autoGenKeyIndex));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

01047       public java.sql.PreparedStatement serverPrepareStatement(String sql,
                  int resultSetType, int resultSetConcurrency) throws SQLException {
            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .serverPrepareStatement(sql, resultSetType,
                                          resultSetConcurrency));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

01060       public java.sql.PreparedStatement serverPrepareStatement(String sql,
                  int resultSetType, int resultSetConcurrency,
                  int resultSetHoldability) throws SQLException {
            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .serverPrepareStatement(sql, resultSetType,
                                          resultSetConcurrency, resultSetHoldability));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

01074       public java.sql.PreparedStatement serverPrepareStatement(String sql,
                  int[] autoGenKeyIndexes) throws SQLException {
            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .serverPrepareStatement(sql, autoGenKeyIndexes));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

01086       public java.sql.PreparedStatement serverPrepareStatement(String sql,
                  String[] autoGenKeyColNames) throws SQLException {
            try {
                  return PreparedStatementWrapper.getInstance(this, this.pooledConnection, this.mc
                              .serverPrepareStatement(sql, autoGenKeyColNames));
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

01098       public void setFailedOver(boolean flag) {
            this.mc.setFailedOver(flag);

      }

01103       public void setPreferSlaveDuringFailover(boolean flag) {
            this.mc.setPreferSlaveDuringFailover(flag);
      }

01107       public void setStatementComment(String comment) {
            this.mc.setStatementComment(comment);

      }

01112       public void shutdownServer() throws SQLException {
            checkClosed();

            try {
                  this.mc.shutdownServer();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

      }

01123       public boolean supportsIsolationLevel() {
            return this.mc.supportsIsolationLevel();
      }

01127       public boolean supportsQuotedIdentifiers() {
            return this.mc.supportsQuotedIdentifiers();
      }

01131       public boolean supportsTransactions() {
            return this.mc.supportsTransactions();
      }

01135       public boolean versionMeetsMinimum(int major, int minor, int subminor)
                  throws SQLException {
            checkClosed();

            try {
                  return this.mc.versionMeetsMinimum(major, minor, subminor);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return false;
      }

01148       public String exposeAsXml() throws SQLException {
            checkClosed();

            try {
                  return this.mc.exposeAsXml();
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }

            return null;
      }

01160       public boolean getAllowLoadLocalInfile() {
            return this.mc.getAllowLoadLocalInfile();
      }

01164       public boolean getAllowMultiQueries() {
            return this.mc.getAllowMultiQueries();
      }

01168       public boolean getAllowNanAndInf() {
            return this.mc.getAllowNanAndInf();
      }

01172       public boolean getAllowUrlInLocalInfile() {
            return this.mc.getAllowUrlInLocalInfile();
      }

01176       public boolean getAlwaysSendSetIsolation() {
            return this.mc.getAlwaysSendSetIsolation();
      }

      public boolean getAutoClosePStmtStreams() {
            return this.mc.getAutoClosePStmtStreams();
      }

01184       public boolean getAutoDeserialize() {
            return this.mc.getAutoDeserialize();
      }

      public boolean getAutoGenerateTestcaseScript() {
            return this.mc.getAutoGenerateTestcaseScript();
      }

01192       public boolean getAutoReconnectForPools() {
            return this.mc.getAutoReconnectForPools();
      }

      public boolean getAutoSlowLog() {
            return this.mc.getAutoSlowLog();
      }

01200       public int getBlobSendChunkSize() {
            return this.mc.getBlobSendChunkSize();
      }

      public boolean getBlobsAreStrings() {
            return this.mc.getBlobsAreStrings();
      }

01208       public boolean getCacheCallableStatements() {
            return this.mc.getCacheCallableStatements();
      }

      public boolean getCacheCallableStmts() {
            return this.mc.getCacheCallableStmts();
      }

      public boolean getCachePrepStmts() {
            return this.mc.getCachePrepStmts();
      }

01220       public boolean getCachePreparedStatements() {
            return this.mc.getCachePreparedStatements();
      }

01224       public boolean getCacheResultSetMetadata() {
            return this.mc.getCacheResultSetMetadata();
      }

01228       public boolean getCacheServerConfiguration() {
            return this.mc.getCacheServerConfiguration();
      }

01232       public int getCallableStatementCacheSize() {
            return this.mc.getCallableStatementCacheSize();
      }

      public int getCallableStmtCacheSize() {
            return this.mc.getCallableStmtCacheSize();
      }

01240       public boolean getCapitalizeTypeNames() {
            return this.mc.getCapitalizeTypeNames();
      }

01244       public String getCharacterSetResults() {
            return this.mc.getCharacterSetResults();
      }

      public String getClientCertificateKeyStorePassword() {
            return this.mc.getClientCertificateKeyStorePassword();
      }

      public String getClientCertificateKeyStoreType() {
            return this.mc.getClientCertificateKeyStoreType();
      }

      public String getClientCertificateKeyStoreUrl() {
            return this.mc.getClientCertificateKeyStoreUrl();
      }

      public String getClientInfoProvider() {
            return this.mc.getClientInfoProvider();
      }

      public String getClobCharacterEncoding() {
            return this.mc.getClobCharacterEncoding();
      }

01268       public boolean getClobberStreamingResults() {
            return this.mc.getClobberStreamingResults();
      }

01272       public int getConnectTimeout() {
            return this.mc.getConnectTimeout();
      }

01276       public String getConnectionCollation() {
            return this.mc.getConnectionCollation();
      }

      public String getConnectionLifecycleInterceptors() {
            return this.mc.getConnectionLifecycleInterceptors();
      }

01284       public boolean getContinueBatchOnError() {
            return this.mc.getContinueBatchOnError();
      }

      public boolean getCreateDatabaseIfNotExist() {
            return this.mc.getCreateDatabaseIfNotExist();
      }

      public int getDefaultFetchSize() {
            return this.mc.getDefaultFetchSize();
      }

01296       public boolean getDontTrackOpenResources() {
            return this.mc.getDontTrackOpenResources();
      }

      public boolean getDumpMetadataOnColumnNotFound() {
            return this.mc.getDumpMetadataOnColumnNotFound();
      }

01304       public boolean getDumpQueriesOnException() {
            return this.mc.getDumpQueriesOnException();
      }

01308       public boolean getDynamicCalendars() {
            return this.mc.getDynamicCalendars();
      }

01312       public boolean getElideSetAutoCommits() {
            return this.mc.getElideSetAutoCommits();
      }

      public boolean getEmptyStringsConvertToZero() {
            return this.mc.getEmptyStringsConvertToZero();
      }

01320       public boolean getEmulateLocators() {
            return this.mc.getEmulateLocators();
      }

01324       public boolean getEmulateUnsupportedPstmts() {
            return this.mc.getEmulateUnsupportedPstmts();
      }

01328       public boolean getEnablePacketDebug() {
            return this.mc.getEnablePacketDebug();
      }

      public boolean getEnableQueryTimeouts() {
            return this.mc.getEnableQueryTimeouts();
      }

01336       public String getEncoding() {
            return this.mc.getEncoding();
      }

01340       public boolean getExplainSlowQueries() {
            return this.mc.getExplainSlowQueries();
      }

01344       public boolean getFailOverReadOnly() {
            return this.mc.getFailOverReadOnly();
      }

      public boolean getFunctionsNeverReturnBlobs() {
            return this.mc.getFunctionsNeverReturnBlobs();
      }

      public boolean getGatherPerfMetrics() {
            return this.mc.getGatherPerfMetrics();
      }

01356       public boolean getGatherPerformanceMetrics() {
            return this.mc.getGatherPerformanceMetrics();
      }

      public boolean getGenerateSimpleParameterMetadata() {
            return this.mc.getGenerateSimpleParameterMetadata();
      }

01364       public boolean getHoldResultsOpenOverStatementClose() {
            return this.mc.getHoldResultsOpenOverStatementClose();
      }

01368       public boolean getIgnoreNonTxTables() {
            return this.mc.getIgnoreNonTxTables();
      }

      public boolean getIncludeInnodbStatusInDeadlockExceptions() {
            return this.mc.getIncludeInnodbStatusInDeadlockExceptions();
      }

01376       public int getInitialTimeout() {
            return this.mc.getInitialTimeout();
      }

01380       public boolean getInteractiveClient() {
            return this.mc.getInteractiveClient();
      }

01384       public boolean getIsInteractiveClient() {
            return this.mc.getIsInteractiveClient();
      }

01388       public boolean getJdbcCompliantTruncation() {
            return this.mc.getJdbcCompliantTruncation();
      }

      public boolean getJdbcCompliantTruncationForReads() {
            return this.mc.getJdbcCompliantTruncationForReads();
      }

      public String getLargeRowSizeThreshold() {
            return this.mc.getLargeRowSizeThreshold();
      }

      public String getLoadBalanceStrategy() {
            return this.mc.getLoadBalanceStrategy();
      }

      public String getLocalSocketAddress() {
            return this.mc.getLocalSocketAddress();
      }

01408       public int getLocatorFetchBufferSize() {
            return this.mc.getLocatorFetchBufferSize();
      }

01412       public boolean getLogSlowQueries() {
            return this.mc.getLogSlowQueries();
      }

      public boolean getLogXaCommands() {
            return this.mc.getLogXaCommands();
      }

01420       public String getLogger() {
            return this.mc.getLogger();
      }

01424       public String getLoggerClassName() {
            return this.mc.getLoggerClassName();
      }

      public boolean getMaintainTimeStats() {
            return this.mc.getMaintainTimeStats();
      }

01432       public int getMaxQuerySizeToLog() {
            return this.mc.getMaxQuerySizeToLog();
      }

01436       public int getMaxReconnects() {
            return this.mc.getMaxReconnects();
      }

01440       public int getMaxRows() {
            return this.mc.getMaxRows();
      }

01444       public int getMetadataCacheSize() {
            return this.mc.getMetadataCacheSize();
      }

      public int getNetTimeoutForStreamingResults() {
            return this.mc.getNetTimeoutForStreamingResults();
      }

      public boolean getNoAccessToProcedureBodies() {
            return this.mc.getNoAccessToProcedureBodies();
      }

01456       public boolean getNoDatetimeStringSync() {
            return this.mc.getNoDatetimeStringSync();
      }

      public boolean getNoTimezoneConversionForTimeType() {
            return this.mc.getNoTimezoneConversionForTimeType();
      }

      public boolean getNullCatalogMeansCurrent() {
            return this.mc.getNullCatalogMeansCurrent();
      }

      public boolean getNullNamePatternMatchesAll() {
            return this.mc.getNullNamePatternMatchesAll();
      }

      public boolean getOverrideSupportsIntegrityEnhancementFacility() {
            return this.mc.getOverrideSupportsIntegrityEnhancementFacility();
      }

01476       public int getPacketDebugBufferSize() {
            return this.mc.getPacketDebugBufferSize();
      }

      public boolean getPadCharsWithSpace() {
            return this.mc.getPadCharsWithSpace();
      }

01484       public boolean getParanoid() {
            return this.mc.getParanoid();
      }

01488       public boolean getPedantic() {
            return this.mc.getPedantic();
      }

      public boolean getPinGlobalTxToPhysicalConnection() {
            return this.mc.getPinGlobalTxToPhysicalConnection();
      }

      public boolean getPopulateInsertRowWithDefaultValues() {
            return this.mc.getPopulateInsertRowWithDefaultValues();
      }

      public int getPrepStmtCacheSize() {
            return this.mc.getPrepStmtCacheSize();
      }

      public int getPrepStmtCacheSqlLimit() {
            return this.mc.getPrepStmtCacheSqlLimit();
      }

01508       public int getPreparedStatementCacheSize() {
            return this.mc.getPreparedStatementCacheSize();
      }

01512       public int getPreparedStatementCacheSqlLimit() {
            return this.mc.getPreparedStatementCacheSqlLimit();
      }

      public boolean getProcessEscapeCodesForPrepStmts() {
            return this.mc.getProcessEscapeCodesForPrepStmts();
      }

01520       public boolean getProfileSQL() {
            return this.mc.getProfileSQL();
      }

01524       public boolean getProfileSql() {
            return this.mc.getProfileSql();
      }

01528       public String getPropertiesTransform() {
            return this.mc.getPropertiesTransform();
      }

01532       public int getQueriesBeforeRetryMaster() {
            return this.mc.getQueriesBeforeRetryMaster();
      }

01536       public boolean getReconnectAtTxEnd() {
            return this.mc.getReconnectAtTxEnd();
      }

01540       public boolean getRelaxAutoCommit() {
            return this.mc.getRelaxAutoCommit();
      }

01544       public int getReportMetricsIntervalMillis() {
            return this.mc.getReportMetricsIntervalMillis();
      }

01548       public boolean getRequireSSL() {
            return this.mc.getRequireSSL();
      }

      public String getResourceId() {
            return this.mc.getResourceId();
      }

      public int getResultSetSizeThreshold() {
            return this.mc.getResultSetSizeThreshold();
      }

      public boolean getRewriteBatchedStatements() {
            return this.mc.getRewriteBatchedStatements();
      }

01564       public boolean getRollbackOnPooledClose() {
            return this.mc.getRollbackOnPooledClose();
      }

01568       public boolean getRoundRobinLoadBalance() {
            return this.mc.getRoundRobinLoadBalance();
      }

01572       public boolean getRunningCTS13() {
            return this.mc.getRunningCTS13();
      }

01576       public int getSecondsBeforeRetryMaster() {
            return this.mc.getSecondsBeforeRetryMaster();
      }

01580       public String getServerTimezone() {
            return this.mc.getServerTimezone();
      }

01584       public String getSessionVariables() {
            return this.mc.getSessionVariables();
      }

01588       public int getSlowQueryThresholdMillis() {
            return this.mc.getSlowQueryThresholdMillis();
      }

      public long getSlowQueryThresholdNanos() {
            return this.mc.getSlowQueryThresholdNanos();
      }

      public String getSocketFactory() {
            return this.mc.getSocketFactory();
      }

01600       public String getSocketFactoryClassName() {
            return this.mc.getSocketFactoryClassName();
      }

01604       public int getSocketTimeout() {
            return this.mc.getSocketTimeout();
      }

      public String getStatementInterceptors() {
            return this.mc.getStatementInterceptors();
      }

01612       public boolean getStrictFloatingPoint() {
            return this.mc.getStrictFloatingPoint();
      }

01616       public boolean getStrictUpdates() {
            return this.mc.getStrictUpdates();
      }

      public boolean getTcpKeepAlive() {
            return this.mc.getTcpKeepAlive();
      }

      public boolean getTcpNoDelay() {
            return this.mc.getTcpNoDelay();
      }

      public int getTcpRcvBuf() {
            return this.mc.getTcpRcvBuf();
      }

      public int getTcpSndBuf() {
            return this.mc.getTcpSndBuf();
      }

      public int getTcpTrafficClass() {
            return this.mc.getTcpTrafficClass();
      }

01640       public boolean getTinyInt1isBit() {
            return this.mc.getTinyInt1isBit();
      }

01644       public boolean getTraceProtocol() {
            return this.mc.getTraceProtocol();
      }

      public boolean getTransformedBitIsBoolean() {
            return this.mc.getTransformedBitIsBoolean();
      }

      public boolean getTreatUtilDateAsTimestamp() {
            return this.mc.getTreatUtilDateAsTimestamp();
      }

      public String getTrustCertificateKeyStorePassword() {
            return this.mc.getTrustCertificateKeyStorePassword();
      }

      public String getTrustCertificateKeyStoreType() {
            return this.mc.getTrustCertificateKeyStoreType();
      }

      public String getTrustCertificateKeyStoreUrl() {
            return this.mc.getTrustCertificateKeyStoreUrl();
      }

      public boolean getUltraDevHack() {
            return this.mc.getUltraDevHack();
      }

      public boolean getUseBlobToStoreUTF8OutsideBMP() {
            return this.mc.getUseBlobToStoreUTF8OutsideBMP();
      }

01676       public boolean getUseCompression() {
            return this.mc.getUseCompression();
      }

      public String getUseConfigs() {
            return this.mc.getUseConfigs();
      }

      public boolean getUseCursorFetch() {
            return this.mc.getUseCursorFetch();
      }

      public boolean getUseDirectRowUnpack() {
            return this.mc.getUseDirectRowUnpack();
      }

      public boolean getUseDynamicCharsetInfo() {
            return this.mc.getUseDynamicCharsetInfo();
      }

      public boolean getUseFastDateParsing() {
            return this.mc.getUseFastDateParsing();
      }

01700       public boolean getUseFastIntParsing() {
            return this.mc.getUseFastIntParsing();
      }

      public boolean getUseGmtMillisForDatetimes() {
            return this.mc.getUseGmtMillisForDatetimes();
      }

01708       public boolean getUseHostsInPrivileges() {
            return this.mc.getUseHostsInPrivileges();
      }

      public boolean getUseInformationSchema() {
            return this.mc.getUseInformationSchema();
      }

      public boolean getUseJDBCCompliantTimezoneShift() {
            return this.mc.getUseJDBCCompliantTimezoneShift();
      }

      public boolean getUseJvmCharsetConverters() {
            return this.mc.getUseJvmCharsetConverters();
      }

01724       public boolean getUseLocalSessionState() {
            return this.mc.getUseLocalSessionState();
      }

      public boolean getUseNanosForElapsedTime() {
            return this.mc.getUseNanosForElapsedTime();
      }

      public boolean getUseOldAliasMetadataBehavior() {
            return this.mc.getUseOldAliasMetadataBehavior();
      }

01736       public boolean getUseOldUTF8Behavior() {
            return this.mc.getUseOldUTF8Behavior();
      }

01740       public boolean getUseOnlyServerErrorMessages() {
            return this.mc.getUseOnlyServerErrorMessages();
      }

01744       public boolean getUseReadAheadInput() {
            return this.mc.getUseReadAheadInput();
      }

01748       public boolean getUseSSL() {
            return this.mc.getUseSSL();
      }

      public boolean getUseSSPSCompatibleTimezoneShift() {
            return this.mc.getUseSSPSCompatibleTimezoneShift();
      }

      public boolean getUseServerPrepStmts() {
            return this.mc.getUseServerPrepStmts();
      }

01760       public boolean getUseServerPreparedStmts() {
            return this.mc.getUseServerPreparedStmts();
      }

01764       public boolean getUseSqlStateCodes() {
            return this.mc.getUseSqlStateCodes();
      }

01768       public boolean getUseStreamLengthsInPrepStmts() {
            return this.mc.getUseStreamLengthsInPrepStmts();
      }

01772       public boolean getUseTimezone() {
            return this.mc.getUseTimezone();
      }

01776       public boolean getUseUltraDevWorkAround() {
            return this.mc.getUseUltraDevWorkAround();
      }

01780       public boolean getUseUnbufferedInput() {
            return this.mc.getUseUnbufferedInput();
      }

01784       public boolean getUseUnicode() {
            return this.mc.getUseUnicode();
      }

01788       public boolean getUseUsageAdvisor() {
            return this.mc.getUseUsageAdvisor();
      }

      public String getUtf8OutsideBmpExcludedColumnNamePattern() {
            return this.mc.getUtf8OutsideBmpExcludedColumnNamePattern();
      }

      public String getUtf8OutsideBmpIncludedColumnNamePattern() {
            return this.mc.getUtf8OutsideBmpIncludedColumnNamePattern();
      }

      public boolean getYearIsDateType() {
            return this.mc.getYearIsDateType();
      }

01804       public String getZeroDateTimeBehavior() {
            return this.mc.getZeroDateTimeBehavior();
      }

01808       public void setAllowLoadLocalInfile(boolean property) {
            this.mc.setAllowLoadLocalInfile(property);
      }

01812       public void setAllowMultiQueries(boolean property) {
            this.mc.setAllowMultiQueries(property);
      }

01816       public void setAllowNanAndInf(boolean flag) {
            this.mc.setAllowNanAndInf(flag);
      }

01820       public void setAllowUrlInLocalInfile(boolean flag) {
            this.mc.setAllowUrlInLocalInfile(flag);
      }

01824       public void setAlwaysSendSetIsolation(boolean flag) {
            this.mc.setAlwaysSendSetIsolation(flag);
      }

      public void setAutoClosePStmtStreams(boolean flag) {
            this.mc.setAutoClosePStmtStreams(flag);
      }

01832       public void setAutoDeserialize(boolean flag) {
            this.mc.setAutoDeserialize(flag);
      }

      public void setAutoGenerateTestcaseScript(boolean flag) {
            this.mc.setAutoGenerateTestcaseScript(flag);
      }

01840       public void setAutoReconnect(boolean flag) {
            this.mc.setAutoReconnect(flag);
      }

01844       public void setAutoReconnectForConnectionPools(boolean property) {
            this.mc.setAutoReconnectForConnectionPools(property);
      }

01848       public void setAutoReconnectForPools(boolean flag) {
            this.mc.setAutoReconnectForPools(flag);
      }

      public void setAutoSlowLog(boolean flag) {
            this.mc.setAutoSlowLog(flag);
      }

01856       public void setBlobSendChunkSize(String value) throws SQLException {
            this.mc.setBlobSendChunkSize(value);
      }

      public void setBlobsAreStrings(boolean flag) {
            this.mc.setBlobsAreStrings(flag);
      }

01864       public void setCacheCallableStatements(boolean flag) {
            this.mc.setCacheCallableStatements(flag);
      }

      public void setCacheCallableStmts(boolean flag) {
            this.mc.setCacheCallableStmts(flag);
      }

      public void setCachePrepStmts(boolean flag) {
            this.mc.setCachePrepStmts(flag);
      }

01876       public void setCachePreparedStatements(boolean flag) {
            this.mc.setCachePreparedStatements(flag);
      }

01880       public void setCacheResultSetMetadata(boolean property) {
            this.mc.setCacheResultSetMetadata(property);
      }

01884       public void setCacheServerConfiguration(boolean flag) {
            this.mc.setCacheServerConfiguration(flag);
      }

01888       public void setCallableStatementCacheSize(int size) {
            this.mc.setCallableStatementCacheSize(size);
      }

      public void setCallableStmtCacheSize(int cacheSize) {
            this.mc.setCallableStmtCacheSize(cacheSize);
      }

01896       public void setCapitalizeDBMDTypes(boolean property) {
            this.mc.setCapitalizeDBMDTypes(property);
      }

01900       public void setCapitalizeTypeNames(boolean flag) {
            this.mc.setCapitalizeTypeNames(flag);
      }

01904       public void setCharacterEncoding(String encoding) {
            this.mc.setCharacterEncoding(encoding);
      }

01908       public void setCharacterSetResults(String characterSet) {
            this.mc.setCharacterSetResults(characterSet);
      }

      public void setClientCertificateKeyStorePassword(String value) {
            this.mc.setClientCertificateKeyStorePassword(value);
      }

      public void setClientCertificateKeyStoreType(String value) {
            this.mc.setClientCertificateKeyStoreType(value);
      }

      public void setClientCertificateKeyStoreUrl(String value) {
            this.mc.setClientCertificateKeyStoreUrl(value);
      }

      public void setClientInfoProvider(String classname) {
            this.mc.setClientInfoProvider(classname);
      }

      public void setClobCharacterEncoding(String encoding) {
            this.mc.setClobCharacterEncoding(encoding);
      }

01932       public void setClobberStreamingResults(boolean flag) {
            this.mc.setClobberStreamingResults(flag);
      }

01936       public void setConnectTimeout(int timeoutMs) {
            this.mc.setConnectTimeout(timeoutMs);
      }

01940       public void setConnectionCollation(String collation) {
            this.mc.setConnectionCollation(collation);
      }

      public void setConnectionLifecycleInterceptors(String interceptors) {
            this.mc.setConnectionLifecycleInterceptors(interceptors);
      }

01948       public void setContinueBatchOnError(boolean property) {
            this.mc.setContinueBatchOnError(property);
      }

      public void setCreateDatabaseIfNotExist(boolean flag) {
            this.mc.setCreateDatabaseIfNotExist(flag);
      }

      public void setDefaultFetchSize(int n) {
            this.mc.setDefaultFetchSize(n);
      }

01960       public void setDetectServerPreparedStmts(boolean property) {
            this.mc.setDetectServerPreparedStmts(property);
      }

01964       public void setDontTrackOpenResources(boolean flag) {
            this.mc.setDontTrackOpenResources(flag);
      }

      public void setDumpMetadataOnColumnNotFound(boolean flag) {
            this.mc.setDumpMetadataOnColumnNotFound(flag);
      }

01972       public void setDumpQueriesOnException(boolean flag) {
            this.mc.setDumpQueriesOnException(flag);
      }

01976       public void setDynamicCalendars(boolean flag) {
            this.mc.setDynamicCalendars(flag);
      }

01980       public void setElideSetAutoCommits(boolean flag) {
            this.mc.setElideSetAutoCommits(flag);
      }

      public void setEmptyStringsConvertToZero(boolean flag) {
            this.mc.setEmptyStringsConvertToZero(flag);
      }

01988       public void setEmulateLocators(boolean property) {
            this.mc.setEmulateLocators(property);
      }

01992       public void setEmulateUnsupportedPstmts(boolean flag) {
            this.mc.setEmulateUnsupportedPstmts(flag);
      }

01996       public void setEnablePacketDebug(boolean flag) {
            this.mc.setEnablePacketDebug(flag);
      }

      public void setEnableQueryTimeouts(boolean flag) {
            this.mc.setEnableQueryTimeouts(flag);
      }

02004       public void setEncoding(String property) {
            this.mc.setEncoding(property);
      }

02008       public void setExplainSlowQueries(boolean flag) {
            this.mc.setExplainSlowQueries(flag);
      }

02012       public void setFailOverReadOnly(boolean flag) {
            this.mc.setFailOverReadOnly(flag);
      }

      public void setFunctionsNeverReturnBlobs(boolean flag) {
            this.mc.setFunctionsNeverReturnBlobs(flag);
      }

      public void setGatherPerfMetrics(boolean flag) {
            this.mc.setGatherPerfMetrics(flag);
      }

02024       public void setGatherPerformanceMetrics(boolean flag) {
            this.mc.setGatherPerformanceMetrics(flag);
      }

      public void setGenerateSimpleParameterMetadata(boolean flag) {
            this.mc.setGenerateSimpleParameterMetadata(flag);
      }

02032       public void setHoldResultsOpenOverStatementClose(boolean flag) {
            this.mc.setHoldResultsOpenOverStatementClose(flag);
      }

02036       public void setIgnoreNonTxTables(boolean property) {
            this.mc.setIgnoreNonTxTables(property);
      }

      public void setIncludeInnodbStatusInDeadlockExceptions(boolean flag) {
            this.mc.setIncludeInnodbStatusInDeadlockExceptions(flag);
      }

02044       public void setInitialTimeout(int property) {
            this.mc.setInitialTimeout(property);
      }

      public void setInteractiveClient(boolean property) {
            this.mc.setInteractiveClient(property);
      }

02052       public void setIsInteractiveClient(boolean property) {
            this.mc.setIsInteractiveClient(property);
      }

02056       public void setJdbcCompliantTruncation(boolean flag) {
            this.mc.setJdbcCompliantTruncation(flag);
      }

      public void setJdbcCompliantTruncationForReads(
                  boolean jdbcCompliantTruncationForReads) {
            this.mc
                        .setJdbcCompliantTruncationForReads(jdbcCompliantTruncationForReads);
      }

      public void setLargeRowSizeThreshold(String value) {
            this.mc.setLargeRowSizeThreshold(value);
      }

      public void setLoadBalanceStrategy(String strategy) {
            this.mc.setLoadBalanceStrategy(strategy);
      }

      public void setLocalSocketAddress(String address) {
            this.mc.setLocalSocketAddress(address);
      }

02078       public void setLocatorFetchBufferSize(String value) throws SQLException {
            this.mc.setLocatorFetchBufferSize(value);
      }

02082       public void setLogSlowQueries(boolean flag) {
            this.mc.setLogSlowQueries(flag);
      }

      public void setLogXaCommands(boolean flag) {
            this.mc.setLogXaCommands(flag);
      }

02090       public void setLogger(String property) {
            this.mc.setLogger(property);
      }

02094       public void setLoggerClassName(String className) {
            this.mc.setLoggerClassName(className);
      }

      public void setMaintainTimeStats(boolean flag) {
            this.mc.setMaintainTimeStats(flag);
      }

02102       public void setMaxQuerySizeToLog(int sizeInBytes) {
            this.mc.setMaxQuerySizeToLog(sizeInBytes);
      }

02106       public void setMaxReconnects(int property) {
            this.mc.setMaxReconnects(property);
      }

02110       public void setMaxRows(int property) {
            this.mc.setMaxRows(property);
      }

02114       public void setMetadataCacheSize(int value) {
            this.mc.setMetadataCacheSize(value);
      }

      public void setNetTimeoutForStreamingResults(int value) {
            this.mc.setNetTimeoutForStreamingResults(value);
      }

      public void setNoAccessToProcedureBodies(boolean flag) {
            this.mc.setNoAccessToProcedureBodies(flag);
      }

02126       public void setNoDatetimeStringSync(boolean flag) {
            this.mc.setNoDatetimeStringSync(flag);
      }

      public void setNoTimezoneConversionForTimeType(boolean flag) {
            this.mc.setNoTimezoneConversionForTimeType(flag);
      }

      public void setNullCatalogMeansCurrent(boolean value) {
            this.mc.setNullCatalogMeansCurrent(value);
      }

      public void setNullNamePatternMatchesAll(boolean value) {
            this.mc.setNullNamePatternMatchesAll(value);
      }

      public void setOverrideSupportsIntegrityEnhancementFacility(boolean flag) {
            this.mc.setOverrideSupportsIntegrityEnhancementFacility(flag);
      }

02146       public void setPacketDebugBufferSize(int size) {
            this.mc.setPacketDebugBufferSize(size);
      }

      public void setPadCharsWithSpace(boolean flag) {
            this.mc.setPadCharsWithSpace(flag);
      }

02154       public void setParanoid(boolean property) {
            this.mc.setParanoid(property);
      }

02158       public void setPedantic(boolean property) {
            this.mc.setPedantic(property);
      }

      public void setPinGlobalTxToPhysicalConnection(boolean flag) {
            this.mc.setPinGlobalTxToPhysicalConnection(flag);
      }

      public void setPopulateInsertRowWithDefaultValues(boolean flag) {
            this.mc.setPopulateInsertRowWithDefaultValues(flag);
      }

      public void setPrepStmtCacheSize(int cacheSize) {
            this.mc.setPrepStmtCacheSize(cacheSize);
      }

      public void setPrepStmtCacheSqlLimit(int sqlLimit) {
            this.mc.setPrepStmtCacheSqlLimit(sqlLimit);
      }

02178       public void setPreparedStatementCacheSize(int cacheSize) {
            this.mc.setPreparedStatementCacheSize(cacheSize);
      }

02182       public void setPreparedStatementCacheSqlLimit(int cacheSqlLimit) {
            this.mc.setPreparedStatementCacheSqlLimit(cacheSqlLimit);
      }

      public void setProcessEscapeCodesForPrepStmts(boolean flag) {
            this.mc.setProcessEscapeCodesForPrepStmts(flag);
      }

02190       public void setProfileSQL(boolean flag) {
            this.mc.setProfileSQL(flag);
      }

02194       public void setProfileSql(boolean property) {
            this.mc.setProfileSql(property);
      }

02198       public void setPropertiesTransform(String value) {
            this.mc.setPropertiesTransform(value);
      }

02202       public void setQueriesBeforeRetryMaster(int property) {
            this.mc.setQueriesBeforeRetryMaster(property);
      }

02206       public void setReconnectAtTxEnd(boolean property) {
            this.mc.setReconnectAtTxEnd(property);
      }

02210       public void setRelaxAutoCommit(boolean property) {
            this.mc.setRelaxAutoCommit(property);
      }

02214       public void setReportMetricsIntervalMillis(int millis) {
            this.mc.setReportMetricsIntervalMillis(millis);
      }

02218       public void setRequireSSL(boolean property) {
            this.mc.setRequireSSL(property);
      }

      public void setResourceId(String resourceId) {
            this.mc.setResourceId(resourceId);
      }

      public void setResultSetSizeThreshold(int threshold) {
            this.mc.setResultSetSizeThreshold(threshold);
      }

      public void setRetainStatementAfterResultSetClose(boolean flag) {
            this.mc.setRetainStatementAfterResultSetClose(flag);
      }

      public void setRewriteBatchedStatements(boolean flag) {
            this.mc.setRewriteBatchedStatements(flag);
      }

02238       public void setRollbackOnPooledClose(boolean flag) {
            this.mc.setRollbackOnPooledClose(flag);
      }

02242       public void setRoundRobinLoadBalance(boolean flag) {
            this.mc.setRoundRobinLoadBalance(flag);
      }

02246       public void setRunningCTS13(boolean flag) {
            this.mc.setRunningCTS13(flag);
      }

02250       public void setSecondsBeforeRetryMaster(int property) {
            this.mc.setSecondsBeforeRetryMaster(property);
      }

02254       public void setServerTimezone(String property) {
            this.mc.setServerTimezone(property);
      }

02258       public void setSessionVariables(String variables) {
            this.mc.setSessionVariables(variables);
      }

02262       public void setSlowQueryThresholdMillis(int millis) {
            this.mc.setSlowQueryThresholdMillis(millis);
      }

      public void setSlowQueryThresholdNanos(long nanos) {
            this.mc.setSlowQueryThresholdNanos(nanos);
      }

      public void setSocketFactory(String name) {
            this.mc.setSocketFactory(name);
      }

02274       public void setSocketFactoryClassName(String property) {
            this.mc.setSocketFactoryClassName(property);
      }

02278       public void setSocketTimeout(int property) {
            this.mc.setSocketTimeout(property);
      }

      public void setStatementInterceptors(String value) {
            this.mc.setStatementInterceptors(value);
      }

02286       public void setStrictFloatingPoint(boolean property) {
            this.mc.setStrictFloatingPoint(property);
      }

02290       public void setStrictUpdates(boolean property) {
            this.mc.setStrictUpdates(property);
      }

      public void setTcpKeepAlive(boolean flag) {
            this.mc.setTcpKeepAlive(flag);
      }

      public void setTcpNoDelay(boolean flag) {
            this.mc.setTcpNoDelay(flag);
      }

      public void setTcpRcvBuf(int bufSize) {
            this.mc.setTcpRcvBuf(bufSize);
      }

      public void setTcpSndBuf(int bufSize) {
            this.mc.setTcpSndBuf(bufSize);
      }

      public void setTcpTrafficClass(int classFlags) {
            this.mc.setTcpTrafficClass(classFlags);
      }

02314       public void setTinyInt1isBit(boolean flag) {
            this.mc.setTinyInt1isBit(flag);
      }

02318       public void setTraceProtocol(boolean flag) {
            this.mc.setTraceProtocol(flag);
      }

      public void setTransformedBitIsBoolean(boolean flag) {
            this.mc.setTransformedBitIsBoolean(flag);
      }

      public void setTreatUtilDateAsTimestamp(boolean flag) {
            this.mc.setTreatUtilDateAsTimestamp(flag);
      }

      public void setTrustCertificateKeyStorePassword(String value) {
            this.mc.setTrustCertificateKeyStorePassword(value);
      }

      public void setTrustCertificateKeyStoreType(String value) {
            this.mc.setTrustCertificateKeyStoreType(value);
      }

      public void setTrustCertificateKeyStoreUrl(String value) {
            this.mc.setTrustCertificateKeyStoreUrl(value);
      }

      public void setUltraDevHack(boolean flag) {
            this.mc.setUltraDevHack(flag);
      }

      public void setUseBlobToStoreUTF8OutsideBMP(boolean flag) {
            this.mc.setUseBlobToStoreUTF8OutsideBMP(flag);
      }

02350       public void setUseCompression(boolean property) {
            this.mc.setUseCompression(property);
      }

      public void setUseConfigs(String configs) {
            this.mc.setUseConfigs(configs);
      }

      public void setUseCursorFetch(boolean flag) {
            this.mc.setUseCursorFetch(flag);
      }

      public void setUseDirectRowUnpack(boolean flag) {
            this.mc.setUseDirectRowUnpack(flag);
      }

      public void setUseDynamicCharsetInfo(boolean flag) {
            this.mc.setUseDynamicCharsetInfo(flag);
      }

      public void setUseFastDateParsing(boolean flag) {
            this.mc.setUseFastDateParsing(flag);
      }

02374       public void setUseFastIntParsing(boolean flag) {
            this.mc.setUseFastIntParsing(flag);
      }

      public void setUseGmtMillisForDatetimes(boolean flag) {
            this.mc.setUseGmtMillisForDatetimes(flag);
      }

02382       public void setUseHostsInPrivileges(boolean property) {
            this.mc.setUseHostsInPrivileges(property);
      }

      public void setUseInformationSchema(boolean flag) {
            this.mc.setUseInformationSchema(flag);
      }

      public void setUseJDBCCompliantTimezoneShift(boolean flag) {
            this.mc.setUseJDBCCompliantTimezoneShift(flag);
      }

      public void setUseJvmCharsetConverters(boolean flag) {
            this.mc.setUseJvmCharsetConverters(flag);
      }

02398       public void setUseLocalSessionState(boolean flag) {
            this.mc.setUseLocalSessionState(flag);
      }

      public void setUseNanosForElapsedTime(boolean flag) {
            this.mc.setUseNanosForElapsedTime(flag);
      }

      public void setUseOldAliasMetadataBehavior(boolean flag) {
            this.mc.setUseOldAliasMetadataBehavior(flag);
      }

02410       public void setUseOldUTF8Behavior(boolean flag) {
            this.mc.setUseOldUTF8Behavior(flag);
      }

02414       public void setUseOnlyServerErrorMessages(boolean flag) {
            this.mc.setUseOnlyServerErrorMessages(flag);
      }

02418       public void setUseReadAheadInput(boolean flag) {
            this.mc.setUseReadAheadInput(flag);
      }

02422       public void setUseSSL(boolean property) {
            this.mc.setUseSSL(property);
      }

      public void setUseSSPSCompatibleTimezoneShift(boolean flag) {
            this.mc.setUseSSPSCompatibleTimezoneShift(flag);
      }

      public void setUseServerPrepStmts(boolean flag) {
            this.mc.setUseServerPrepStmts(flag);
      }

02434       public void setUseServerPreparedStmts(boolean flag) {
            this.mc.setUseServerPreparedStmts(flag);
      }

02438       public void setUseSqlStateCodes(boolean flag) {
            this.mc.setUseSqlStateCodes(flag);
      }

02442       public void setUseStreamLengthsInPrepStmts(boolean property) {
            this.mc.setUseStreamLengthsInPrepStmts(property);
      }

02446       public void setUseTimezone(boolean property) {
            this.mc.setUseTimezone(property);
      }

02450       public void setUseUltraDevWorkAround(boolean property) {
            this.mc.setUseUltraDevWorkAround(property);
      }

02454       public void setUseUnbufferedInput(boolean flag) {
            this.mc.setUseUnbufferedInput(flag);
      }

02458       public void setUseUnicode(boolean flag) {
            this.mc.setUseUnicode(flag);
      }

02462       public void setUseUsageAdvisor(boolean useUsageAdvisorFlag) {
            this.mc.setUseUsageAdvisor(useUsageAdvisorFlag);
      }

      public void setUtf8OutsideBmpExcludedColumnNamePattern(String regexPattern) {
            this.mc.setUtf8OutsideBmpExcludedColumnNamePattern(regexPattern);
      }

      public void setUtf8OutsideBmpIncludedColumnNamePattern(String regexPattern) {
            this.mc.setUtf8OutsideBmpIncludedColumnNamePattern(regexPattern);
      }

      public void setYearIsDateType(boolean flag) {
            this.mc.setYearIsDateType(flag);
      }

02478       public void setZeroDateTimeBehavior(String behavior) {
            this.mc.setZeroDateTimeBehavior(behavior);
      }

02482       public boolean useUnbufferedInput() {
            return this.mc.useUnbufferedInput();
      }

      public void initializeExtension(Extension ex) throws SQLException {
            this.mc.initializeExtension(ex);
      }

      public String getProfilerEventHandler() {
            return this.mc.getProfilerEventHandler();
      }

      public void setProfilerEventHandler(String handler) {
            this.mc.setProfilerEventHandler(handler);
      }

      public boolean getVerifyServerCertificate() {
            return this.mc.getVerifyServerCertificate();
      }

      public void setVerifyServerCertificate(boolean flag) {
            this.mc.setVerifyServerCertificate(flag);
      }

      public boolean getUseLegacyDatetimeCode() {
            return this.mc.getUseLegacyDatetimeCode();
      }

      public void setUseLegacyDatetimeCode(boolean flag) {
            this.mc.setUseLegacyDatetimeCode(flag);
      }

      public int getSelfDestructOnPingMaxOperations() {
            return this.mc.getSelfDestructOnPingMaxOperations();
      }

      public int getSelfDestructOnPingSecondsLifetime() {
            return this.mc.getSelfDestructOnPingSecondsLifetime();
      }

      public void setSelfDestructOnPingMaxOperations(int maxOperations) {
            this.mc.setSelfDestructOnPingMaxOperations(maxOperations);
      }

      public void setSelfDestructOnPingSecondsLifetime(int seconds) {
            this.mc.setSelfDestructOnPingSecondsLifetime(seconds);
      }

      public boolean getUseColumnNamesInFindColumn() {
            return this.mc.getUseColumnNamesInFindColumn();
      }

      public void setUseColumnNamesInFindColumn(boolean flag) {
            this.mc.setUseColumnNamesInFindColumn(flag);
      }

      public boolean getUseLocalTransactionState() {
            return this.mc.getUseLocalTransactionState();
      }

      public void setUseLocalTransactionState(boolean flag) {
            this.mc.setUseLocalTransactionState(flag);
      }
      
      public boolean getCompensateOnDuplicateKeyUpdateCounts() {
            return this.mc.getCompensateOnDuplicateKeyUpdateCounts();
      }

      public void setCompensateOnDuplicateKeyUpdateCounts(boolean flag) {
            this.mc.setCompensateOnDuplicateKeyUpdateCounts(flag);
      }

      public boolean getUseAffectedRows() {
            return this.mc.getUseAffectedRows();
      }

      public void setUseAffectedRows(boolean flag) {
            this.mc.setUseAffectedRows(flag);
      }

      public String getPasswordCharacterEncoding() {
            return this.mc.getPasswordCharacterEncoding();
      }

      public void setPasswordCharacterEncoding(String characterSet) {
            this.mc.setPasswordCharacterEncoding(characterSet);
      }

02570       public int getAutoIncrementIncrement() {
            return this.mc.getAutoIncrementIncrement();
      }

      public int getLoadBalanceBlacklistTimeout() {
            return this.mc.getLoadBalanceBlacklistTimeout();
      }

      public void setLoadBalanceBlacklistTimeout(int loadBalanceBlacklistTimeout) {
            this.mc.setLoadBalanceBlacklistTimeout(loadBalanceBlacklistTimeout);
      }
      public int getLoadBalancePingTimeout() {
            return this.mc.getLoadBalancePingTimeout();
      }

      public void setLoadBalancePingTimeout(int loadBalancePingTimeout) {
            this.mc.setLoadBalancePingTimeout(loadBalancePingTimeout);
      }
      
      public boolean getLoadBalanceValidateConnectionOnSwapServer() {
            return this.mc.getLoadBalanceValidateConnectionOnSwapServer();
      }

      public void setLoadBalanceValidateConnectionOnSwapServer(
                  boolean loadBalanceValidateConnectionOnSwapServer) {
            this.mc.setLoadBalanceValidateConnectionOnSwapServer(loadBalanceValidateConnectionOnSwapServer);
      }
      
      public void setRetriesAllDown(int retriesAllDown) {
            this.mc.setRetriesAllDown(retriesAllDown);
      }
      
      public int getRetriesAllDown() {
            return this.mc.getRetriesAllDown();
      }

      public ExceptionInterceptor getExceptionInterceptor() {
            return this.pooledConnection.getExceptionInterceptor();
      }

      public String getExceptionInterceptors() {
            return this.mc.getExceptionInterceptors();
      }

      public void setExceptionInterceptors(String exceptionInterceptors) {
            this.mc.setExceptionInterceptors(exceptionInterceptors);
      }

      public boolean getQueryTimeoutKillsConnection() {
            return this.mc.getQueryTimeoutKillsConnection();
      }

      public void setQueryTimeoutKillsConnection(
                  boolean queryTimeoutKillsConnection) {
            this.mc.setQueryTimeoutKillsConnection(queryTimeoutKillsConnection);
      }

02627       public boolean hasSameProperties(Connection c) {
            return this.mc.hasSameProperties(c);
      }
      
02631       public Properties getProperties() {
            return this.mc.getProperties();
      }

   public String getHost() {
      return this.mc.getHost();
   }

   public void setProxy(MySQLConnection conn) {
      this.mc.setProxy(conn);
   }

      public boolean getRetainStatementAfterResultSetClose() {
            return this.mc.getRetainStatementAfterResultSetClose();
      }

   public int getMaxAllowedPacket() {
            return this.mc.getMaxAllowedPacket();
      }
   
      public String getLoadBalanceConnectionGroup() {
            return this.mc.getLoadBalanceConnectionGroup();
      }

      public boolean getLoadBalanceEnableJMX() {
            return this.mc.getLoadBalanceEnableJMX();
      }

      public String getLoadBalanceExceptionChecker() {
            return this.mc
                        .getLoadBalanceExceptionChecker();
      }

      public String getLoadBalanceSQLExceptionSubclassFailover() {
            return this.mc
                        .getLoadBalanceSQLExceptionSubclassFailover();
      }

      public String getLoadBalanceSQLStateFailover() {
            return this.mc
                        .getLoadBalanceSQLStateFailover();
      }

      public void setLoadBalanceConnectionGroup(String loadBalanceConnectionGroup) {
            this.mc
                        .setLoadBalanceConnectionGroup(loadBalanceConnectionGroup);
            
      }

      public void setLoadBalanceEnableJMX(boolean loadBalanceEnableJMX) {
            this.mc
                        .setLoadBalanceEnableJMX(loadBalanceEnableJMX);
            
      }

      public void setLoadBalanceExceptionChecker(
                  String loadBalanceExceptionChecker) {
            this.mc
                        .setLoadBalanceExceptionChecker(loadBalanceExceptionChecker);
            
      }

      public void setLoadBalanceSQLExceptionSubclassFailover(
                  String loadBalanceSQLExceptionSubclassFailover) {
            this.mc
                        .setLoadBalanceSQLExceptionSubclassFailover(loadBalanceSQLExceptionSubclassFailover);
            
      }

      public void setLoadBalanceSQLStateFailover(
                  String loadBalanceSQLStateFailover) {
            this.mc
                        .setLoadBalanceSQLStateFailover(loadBalanceSQLStateFailover);
            
      }


      public String getLoadBalanceAutoCommitStatementRegex() {
            return this.mc.getLoadBalanceAutoCommitStatementRegex();
      }

      public int getLoadBalanceAutoCommitStatementThreshold() {
            return this.mc.getLoadBalanceAutoCommitStatementThreshold();
      }

      public void setLoadBalanceAutoCommitStatementRegex(
                  String loadBalanceAutoCommitStatementRegex) {
            this.mc.setLoadBalanceAutoCommitStatementRegex(loadBalanceAutoCommitStatementRegex);
            
      }

      public void setLoadBalanceAutoCommitStatementThreshold(
                  int loadBalanceAutoCommitStatementThreshold) {
            this.mc.setLoadBalanceAutoCommitStatementThreshold(loadBalanceAutoCommitStatementThreshold);
            
      }

      public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
            checkClosed();

            try {
                  this.mc.setTypeMap(map);
            } catch (SQLException sqlException) {
                  checkAndFireConnectionError(sqlException);
            }
      }

      public boolean getIncludeThreadDumpInDeadlockExceptions() {
            return this.mc.getIncludeThreadDumpInDeadlockExceptions();
      }

      public void setIncludeThreadDumpInDeadlockExceptions(boolean flag) {
            this.mc.setIncludeThreadDumpInDeadlockExceptions(flag);
            
      }

      public boolean getIncludeThreadNamesAsStatementComment() {
            return this.mc.getIncludeThreadNamesAsStatementComment();
      }

      public void setIncludeThreadNamesAsStatementComment(boolean flag) {
            this.mc.setIncludeThreadNamesAsStatementComment(flag);
      }

02755       public boolean isServerLocal() throws SQLException {
            return this.mc.isServerLocal();
      }
}

Generated by  Doxygen 1.6.0   Back to index