/*
Copyright (c) 2002, 2013, 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 java.util.concurrent.Executor;
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
*/
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.
*/
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
*/
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()
*/
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()
*/
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
*/
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()
*/
public boolean isClosed() throws SQLException {
return (this.closed || this.mc.isClosed());
}
public boolean isMasterConnection() {
return this.mc.isMasterConnection();
}
/**
* @see Connection#setHoldability(int)
*/
public void setHoldability(int arg0) throws SQLException {
checkClosed();
try {
this.mc.setHoldability(arg0);
} catch (SQLException sqlException) {
checkAndFireConnectionError(sqlException);
}
}
/**
* @see Connection#getHoldability()
*/
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.
*/
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
*/
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()
*/
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()
*/
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()
*/
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)
*/
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()
*/
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()
*/
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()
*/
public java.util.Map<String, Class<?>> 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
*/
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
*/
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
*/
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
*/
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()
*/
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()
*/
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)
*/
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()
*/
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()
*/
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()
*/
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)
*/
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()
*/
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()
*/
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)
*/
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)
*/
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[])
*/
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[])
*/
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)
*/
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()
*/
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)
*/
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);
}
}
public boolean isSameResource(com.mysql.jdbc.Connection c) {
if (c instanceof ConnectionWrapper) {
return this.mc.isSameResource(((ConnectionWrapper) c).mc);
}
return this.mc.isSameResource(c);
}
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;
}
}
public void checkClosed() throws SQLException {
if (this.closed) {
throw SQLError.createSQLException(this.invalidHandleStr, this.exceptionInterceptor);
}
}
public boolean isInGlobalTx() {
return this.mc.isInGlobalTx();
}
public void setInGlobalTx(boolean flag) {
this.mc.setInGlobalTx(flag);
}
public void ping() throws SQLException {
if (this.mc != null) {
this.mc.ping();
}
}
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();
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
public int getActiveStatementCount() {
return this.mc.getActiveStatementCount();
}
public Log getLog() throws SQLException {
return this.mc.getLog();
}
public String getServerCharacterEncoding() {
return this.mc.getServerCharacterEncoding();
}
public TimeZone getServerTimezoneTZ() {
return this.mc.getServerTimezoneTZ();
}
public String getStatementComment() {
return this.mc.getStatementComment();
}
public boolean hasTriedMaster() {
return this.mc.hasTriedMaster();
}
public boolean isAbonormallyLongQuery(long millisOrNanos) {
return this.mc.isAbonormallyLongQuery(millisOrNanos);
}
public boolean isNoBackslashEscapesSet() {
return this.mc.isNoBackslashEscapesSet();
}
public boolean lowerCaseTableNames() {
return this.mc.lowerCaseTableNames();
}
public boolean parserKnowsUnicode() {
return this.mc.parserKnowsUnicode();
}
public void reportQueryTime(long millisOrNanos) {
this.mc.reportQueryTime(millisOrNanos);
}
public void resetServerState() throws SQLException {
checkClosed();
try {
this.mc.resetServerState();
} catch (SQLException sqlException) {
checkAndFireConnectionError(sqlException);
}
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
public void setFailedOver(boolean flag) {
this.mc.setFailedOver(flag);
}
public void setPreferSlaveDuringFailover(boolean flag) {
this.mc.setPreferSlaveDuringFailover(flag);
}
public void setStatementComment(String comment) {
this.mc.setStatementComment(comment);
}
public void shutdownServer() throws SQLException {
checkClosed();
try {
this.mc.shutdownServer();
} catch (SQLException sqlException) {
checkAndFireConnectionError(sqlException);
}
}
public boolean supportsIsolationLevel() {
return this.mc.supportsIsolationLevel();
}
public boolean supportsQuotedIdentifiers() {
return this.mc.supportsQuotedIdentifiers();
}
public boolean supportsTransactions() {
return this.mc.supportsTransactions();
}
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;
}
public String exposeAsXml() throws SQLException {
checkClosed();
try {
return this.mc.exposeAsXml();
} catch (SQLException sqlException) {
checkAndFireConnectionError(sqlException);
}
return null;
}
public boolean getAllowLoadLocalInfile() {
return this.mc.getAllowLoadLocalInfile();
}
public boolean getAllowMultiQueries() {
return this.mc.getAllowMultiQueries();
}
public boolean getAllowNanAndInf() {
return this.mc.getAllowNanAndInf();
}
public boolean getAllowUrlInLocalInfile() {
return this.mc.getAllowUrlInLocalInfile();
}
public boolean getAlwaysSendSetIsolation() {
return this.mc.getAlwaysSendSetIsolation();
}
public boolean getAutoClosePStmtStreams() {
return this.mc.getAutoClosePStmtStreams();
}
public boolean getAutoDeserialize() {
return this.mc.getAutoDeserialize();
}
public boolean getAutoGenerateTestcaseScript() {
return this.mc.getAutoGenerateTestcaseScript();
}
public boolean getAutoReconnectForPools() {
return this.mc.getAutoReconnectForPools();
}
public boolean getAutoSlowLog() {
return this.mc.getAutoSlowLog();
}
public int getBlobSendChunkSize() {
return this.mc.getBlobSendChunkSize();
}
public boolean getBlobsAreStrings() {
return this.mc.getBlobsAreStrings();
}
public boolean getCacheCallableStatements() {
return this.mc.getCacheCallableStatements();
}
public boolean getCacheCallableStmts() {
return this.mc.getCacheCallableStmts();
}
public boolean getCachePrepStmts() {
return this.mc.getCachePrepStmts();
}
public boolean getCachePreparedStatements() {
return this.mc.getCachePreparedStatements();
}
public boolean getCacheResultSetMetadata() {
return this.mc.getCacheResultSetMetadata();
}
public boolean getCacheServerConfiguration() {
return this.mc.getCacheServerConfiguration();
}
public int getCallableStatementCacheSize() {
return this.mc.getCallableStatementCacheSize();
}
public int getCallableStmtCacheSize() {
return this.mc.getCallableStmtCacheSize();
}
public boolean getCapitalizeTypeNames() {
return this.mc.getCapitalizeTypeNames();
}
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();
}
public boolean getClobberStreamingResults() {
return this.mc.getClobberStreamingResults();
}
public int getConnectTimeout() {
return this.mc.getConnectTimeout();
}
public String getConnectionCollation() {
return this.mc.getConnectionCollation();
}
public String getConnectionLifecycleInterceptors() {
return this.mc.getConnectionLifecycleInterceptors();
}
public boolean getContinueBatchOnError() {
return this.mc.getContinueBatchOnError();
}
public boolean getCreateDatabaseIfNotExist() {
return this.mc.getCreateDatabaseIfNotExist();
}
public int getDefaultFetchSize() {
return this.mc.getDefaultFetchSize();
}
public boolean getDontTrackOpenResources() {
return this.mc.getDontTrackOpenResources();
}
public boolean getDumpMetadataOnColumnNotFound() {
return this.mc.getDumpMetadataOnColumnNotFound();
}
public boolean getDumpQueriesOnException() {
return this.mc.getDumpQueriesOnException();
}
public boolean getDynamicCalendars() {
return this.mc.getDynamicCalendars();
}
public boolean getElideSetAutoCommits() {
return this.mc.getElideSetAutoCommits();
}
public boolean getEmptyStringsConvertToZero() {
return this.mc.getEmptyStringsConvertToZero();
}
public boolean getEmulateLocators() {
return this.mc.getEmulateLocators();
}
public boolean getEmulateUnsupportedPstmts() {
return this.mc.getEmulateUnsupportedPstmts();
}
public boolean getEnablePacketDebug() {
return this.mc.getEnablePacketDebug();
}
public boolean getEnableQueryTimeouts() {
return this.mc.getEnableQueryTimeouts();
}
public String getEncoding() {
return this.mc.getEncoding();
}
public boolean getExplainSlowQueries() {
return this.mc.getExplainSlowQueries();
}
public boolean getFailOverReadOnly() {
return this.mc.getFailOverReadOnly();
}
public boolean getFunctionsNeverReturnBlobs() {
return this.mc.getFunctionsNeverReturnBlobs();
}
public boolean getGatherPerfMetrics() {
return this.mc.getGatherPerfMetrics();
}
public boolean getGatherPerformanceMetrics() {
return this.mc.getGatherPerformanceMetrics();
}
public boolean getGenerateSimpleParameterMetadata() {
return this.mc.getGenerateSimpleParameterMetadata();
}
public boolean getHoldResultsOpenOverStatementClose() {
return this.mc.getHoldResultsOpenOverStatementClose();
}
public boolean getIgnoreNonTxTables() {
return this.mc.getIgnoreNonTxTables();
}
public boolean getIncludeInnodbStatusInDeadlockExceptions() {
return this.mc.getIncludeInnodbStatusInDeadlockExceptions();
}
public int getInitialTimeout() {
return this.mc.getInitialTimeout();
}
public boolean getInteractiveClient() {
return this.mc.getInteractiveClient();
}
public boolean getIsInteractiveClient() {
return this.mc.getIsInteractiveClient();
}
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();
}
public int getLocatorFetchBufferSize() {
return this.mc.getLocatorFetchBufferSize();
}
public boolean getLogSlowQueries() {
return this.mc.getLogSlowQueries();
}
public boolean getLogXaCommands() {
return this.mc.getLogXaCommands();
}
public String getLogger() {
return this.mc.getLogger();
}
public String getLoggerClassName() {
return this.mc.getLoggerClassName();
}
public boolean getMaintainTimeStats() {
return this.mc.getMaintainTimeStats();
}
public int getMaxQuerySizeToLog() {
return this.mc.getMaxQuerySizeToLog();
}
public int getMaxReconnects() {
return this.mc.getMaxReconnects();
}
public int getMaxRows() {
return this.mc.getMaxRows();
}
public int getMetadataCacheSize() {
return this.mc.getMetadataCacheSize();
}
public int getNetTimeoutForStreamingResults() {
return this.mc.getNetTimeoutForStreamingResults();
}
public boolean getNoAccessToProcedureBodies() {
return this.mc.getNoAccessToProcedureBodies();
}
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();
}
public int getPacketDebugBufferSize() {
return this.mc.getPacketDebugBufferSize();
}
public boolean getPadCharsWithSpace() {
return this.mc.getPadCharsWithSpace();
}
public boolean getParanoid() {
return this.mc.getParanoid();
}
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();
}
public int getPreparedStatementCacheSize() {
return this.mc.getPreparedStatementCacheSize();
}
public int getPreparedStatementCacheSqlLimit() {
return this.mc.getPreparedStatementCacheSqlLimit();
}
public boolean getProcessEscapeCodesForPrepStmts() {
return this.mc.getProcessEscapeCodesForPrepStmts();
}
public boolean getProfileSQL() {
return this.mc.getProfileSQL();
}
public boolean getProfileSql() {
return this.mc.getProfileSql();
}
public String getPropertiesTransform() {
return this.mc.getPropertiesTransform();
}
public int getQueriesBeforeRetryMaster() {
return this.mc.getQueriesBeforeRetryMaster();
}
public boolean getReconnectAtTxEnd() {
return this.mc.getReconnectAtTxEnd();
}
public boolean getRelaxAutoCommit() {
return this.mc.getRelaxAutoCommit();
}
public int getReportMetricsIntervalMillis() {
return this.mc.getReportMetricsIntervalMillis();
}
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();
}
public boolean getRollbackOnPooledClose() {
return this.mc.getRollbackOnPooledClose();
}
public boolean getRoundRobinLoadBalance() {
return this.mc.getRoundRobinLoadBalance();
}
public boolean getRunningCTS13() {
return this.mc.getRunningCTS13();
}
public int getSecondsBeforeRetryMaster() {
return this.mc.getSecondsBeforeRetryMaster();
}
public String getServerTimezone() {
return this.mc.getServerTimezone();
}
public String getSessionVariables() {
return this.mc.getSessionVariables();
}
public int getSlowQueryThresholdMillis() {
return this.mc.getSlowQueryThresholdMillis();
}
public long getSlowQueryThresholdNanos() {
return this.mc.getSlowQueryThresholdNanos();
}
public String getSocketFactory() {
return this.mc.getSocketFactory();
}
public String getSocketFactoryClassName() {
return this.mc.getSocketFactoryClassName();
}
public int getSocketTimeout() {
return this.mc.getSocketTimeout();
}
public String getStatementInterceptors() {
return this.mc.getStatementInterceptors();
}
public boolean getStrictFloatingPoint() {
return this.mc.getStrictFloatingPoint();
}
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();
}
public boolean getTinyInt1isBit() {
return this.mc.getTinyInt1isBit();
}
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();
}
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();
}
public boolean getUseFastIntParsing() {
return this.mc.getUseFastIntParsing();
}
public boolean getUseGmtMillisForDatetimes() {
return this.mc.getUseGmtMillisForDatetimes();
}
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();
}
public boolean getUseLocalSessionState() {
return this.mc.getUseLocalSessionState();
}
public boolean getUseNanosForElapsedTime() {
return this.mc.getUseNanosForElapsedTime();
}
public boolean getUseOldAliasMetadataBehavior() {
return this.mc.getUseOldAliasMetadataBehavior();
}
public boolean getUseOldUTF8Behavior() {
return this.mc.getUseOldUTF8Behavior();
}
public boolean getUseOnlyServerErrorMessages() {
return this.mc.getUseOnlyServerErrorMessages();
}
public boolean getUseReadAheadInput() {
return this.mc.getUseReadAheadInput();
}
public boolean getUseSSL() {
return this.mc.getUseSSL();
}
public boolean getUseSSPSCompatibleTimezoneShift() {
return this.mc.getUseSSPSCompatibleTimezoneShift();
}
public boolean getUseServerPrepStmts() {
return this.mc.getUseServerPrepStmts();
}
public boolean getUseServerPreparedStmts() {
return this.mc.getUseServerPreparedStmts();
}
public boolean getUseSqlStateCodes() {
return this.mc.getUseSqlStateCodes();
}
public boolean getUseStreamLengthsInPrepStmts() {
return this.mc.getUseStreamLengthsInPrepStmts();
}
public boolean getUseTimezone() {
return this.mc.getUseTimezone();
}
public boolean getUseUltraDevWorkAround() {
return this.mc.getUseUltraDevWorkAround();
}
public boolean getUseUnbufferedInput() {
return this.mc.getUseUnbufferedInput();
}
public boolean getUseUnicode() {
return this.mc.getUseUnicode();
}
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();
}
public String getZeroDateTimeBehavior() {
return this.mc.getZeroDateTimeBehavior();
}
public void setAllowLoadLocalInfile(boolean property) {
this.mc.setAllowLoadLocalInfile(property);
}
public void setAllowMultiQueries(boolean property) {
this.mc.setAllowMultiQueries(property);
}
public void setAllowNanAndInf(boolean flag) {
this.mc.setAllowNanAndInf(flag);
}
public void setAllowUrlInLocalInfile(boolean flag) {
this.mc.setAllowUrlInLocalInfile(flag);
}
public void setAlwaysSendSetIsolation(boolean flag) {
this.mc.setAlwaysSendSetIsolation(flag);
}
public void setAutoClosePStmtStreams(boolean flag) {
this.mc.setAutoClosePStmtStreams(flag);
}
public void setAutoDeserialize(boolean flag) {
this.mc.setAutoDeserialize(flag);
}
public void setAutoGenerateTestcaseScript(boolean flag) {
this.mc.setAutoGenerateTestcaseScript(flag);
}
public void setAutoReconnect(boolean flag) {
this.mc.setAutoReconnect(flag);
}
public void setAutoReconnectForConnectionPools(boolean property) {
this.mc.setAutoReconnectForConnectionPools(property);
}
public void setAutoReconnectForPools(boolean flag) {
this.mc.setAutoReconnectForPools(flag);
}
public void setAutoSlowLog(boolean flag) {
this.mc.setAutoSlowLog(flag);
}
public void setBlobSendChunkSize(String value) throws SQLException {
this.mc.setBlobSendChunkSize(value);
}
public void setBlobsAreStrings(boolean flag) {
this.mc.setBlobsAreStrings(flag);
}
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);
}
public void setCachePreparedStatements(boolean flag) {
this.mc.setCachePreparedStatements(flag);
}
public void setCacheResultSetMetadata(boolean property) {
this.mc.setCacheResultSetMetadata(property);
}
public void setCacheServerConfiguration(boolean flag) {
this.mc.setCacheServerConfiguration(flag);
}
public void setCallableStatementCacheSize(int size) {
this.mc.setCallableStatementCacheSize(size);
}
public void setCallableStmtCacheSize(int cacheSize) {
this.mc.setCallableStmtCacheSize(cacheSize);
}
public void setCapitalizeDBMDTypes(boolean property) {
this.mc.setCapitalizeDBMDTypes(property);
}
public void setCapitalizeTypeNames(boolean flag) {
this.mc.setCapitalizeTypeNames(flag);
}
public void setCharacterEncoding(String encoding) {
this.mc.setCharacterEncoding(encoding);
}
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);
}
public void setClobberStreamingResults(boolean flag) {
this.mc.setClobberStreamingResults(flag);
}
public void setConnectTimeout(int timeoutMs) {
this.mc.setConnectTimeout(timeoutMs);
}
public void setConnectionCollation(String collation) {
this.mc.setConnectionCollation(collation);
}
public void setConnectionLifecycleInterceptors(String interceptors) {
this.mc.setConnectionLifecycleInterceptors(interceptors);
}
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);
}
public void setDetectServerPreparedStmts(boolean property) {
this.mc.setDetectServerPreparedStmts(property);
}
public void setDontTrackOpenResources(boolean flag) {
this.mc.setDontTrackOpenResources(flag);
}
public void setDumpMetadataOnColumnNotFound(boolean flag) {
this.mc.setDumpMetadataOnColumnNotFound(flag);
}
public void setDumpQueriesOnException(boolean flag) {
this.mc.setDumpQueriesOnException(flag);
}
public void setDynamicCalendars(boolean flag) {
this.mc.setDynamicCalendars(flag);
}
public void setElideSetAutoCommits(boolean flag) {
this.mc.setElideSetAutoCommits(flag);
}
public void setEmptyStringsConvertToZero(boolean flag) {
this.mc.setEmptyStringsConvertToZero(flag);
}
public void setEmulateLocators(boolean property) {
this.mc.setEmulateLocators(property);
}
public void setEmulateUnsupportedPstmts(boolean flag) {
this.mc.setEmulateUnsupportedPstmts(flag);
}
public void setEnablePacketDebug(boolean flag) {
this.mc.setEnablePacketDebug(flag);
}
public void setEnableQueryTimeouts(boolean flag) {
this.mc.setEnableQueryTimeouts(flag);
}
public void setEncoding(String property) {
this.mc.setEncoding(property);
}
public void setExplainSlowQueries(boolean flag) {
this.mc.setExplainSlowQueries(flag);
}
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);
}
public void setGatherPerformanceMetrics(boolean flag) {
this.mc.setGatherPerformanceMetrics(flag);
}
public void setGenerateSimpleParameterMetadata(boolean flag) {
this.mc.setGenerateSimpleParameterMetadata(flag);
}
public void setHoldResultsOpenOverStatementClose(boolean flag) {
this.mc.setHoldResultsOpenOverStatementClose(flag);
}
public void setIgnoreNonTxTables(boolean property) {
this.mc.setIgnoreNonTxTables(property);
}
public void setIncludeInnodbStatusInDeadlockExceptions(boolean flag) {
this.mc.setIncludeInnodbStatusInDeadlockExceptions(flag);
}
public void setInitialTimeout(int property) {
this.mc.setInitialTimeout(property);
}
public void setInteractiveClient(boolean property) {
this.mc.setInteractiveClient(property);
}
public void setIsInteractiveClient(boolean property) {
this.mc.setIsInteractiveClient(property);
}
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);
}
public void setLocatorFetchBufferSize(String value) throws SQLException {
this.mc.setLocatorFetchBufferSize(value);
}
public void setLogSlowQueries(boolean flag) {
this.mc.setLogSlowQueries(flag);
}
public void setLogXaCommands(boolean flag) {
this.mc.setLogXaCommands(flag);
}
public void setLogger(String property) {
this.mc.setLogger(property);
}
public void setLoggerClassName(String className) {
this.mc.setLoggerClassName(className);
}
public void setMaintainTimeStats(boolean flag) {
this.mc.setMaintainTimeStats(flag);
}
public void setMaxQuerySizeToLog(int sizeInBytes) {
this.mc.setMaxQuerySizeToLog(sizeInBytes);
}
public void setMaxReconnects(int property) {
this.mc.setMaxReconnects(property);
}
public void setMaxRows(int property) {
this.mc.setMaxRows(property);
}
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);
}
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);
}
public void setPacketDebugBufferSize(int size) {
this.mc.setPacketDebugBufferSize(size);
}
public void setPadCharsWithSpace(boolean flag) {
this.mc.setPadCharsWithSpace(flag);
}
public void setParanoid(boolean property) {
this.mc.setParanoid(property);
}
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);
}
public void setPreparedStatementCacheSize(int cacheSize) {
this.mc.setPreparedStatementCacheSize(cacheSize);
}
public void setPreparedStatementCacheSqlLimit(int cacheSqlLimit) {
this.mc.setPreparedStatementCacheSqlLimit(cacheSqlLimit);
}
public void setProcessEscapeCodesForPrepStmts(boolean flag) {
this.mc.setProcessEscapeCodesForPrepStmts(flag);
}
public void setProfileSQL(boolean flag) {
this.mc.setProfileSQL(flag);
}
public void setProfileSql(boolean property) {
this.mc.setProfileSql(property);
}
public void setPropertiesTransform(String value) {
this.mc.setPropertiesTransform(value);
}
public void setQueriesBeforeRetryMaster(int property) {
this.mc.setQueriesBeforeRetryMaster(property);
}
public void setReconnectAtTxEnd(boolean property) {
this.mc.setReconnectAtTxEnd(property);
}
public void setRelaxAutoCommit(boolean property) {
this.mc.setRelaxAutoCommit(property);
}
public void setReportMetricsIntervalMillis(int millis) {
this.mc.setReportMetricsIntervalMillis(millis);
}
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);
}
public void setRollbackOnPooledClose(boolean flag) {
this.mc.setRollbackOnPooledClose(flag);
}
public void setRoundRobinLoadBalance(boolean flag) {
this.mc.setRoundRobinLoadBalance(flag);
}
public void setRunningCTS13(boolean flag) {
this.mc.setRunningCTS13(flag);
}
public void setSecondsBeforeRetryMaster(int property) {
this.mc.setSecondsBeforeRetryMaster(property);
}
public void setServerTimezone(String property) {
this.mc.setServerTimezone(property);
}
public void setSessionVariables(String variables) {
this.mc.setSessionVariables(variables);
}
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);
}
public void setSocketFactoryClassName(String property) {
this.mc.setSocketFactoryClassName(property);
}
public void setSocketTimeout(int property) {
this.mc.setSocketTimeout(property);
}
public void setStatementInterceptors(String value) {
this.mc.setStatementInterceptors(value);
}
public void setStrictFloatingPoint(boolean property) {
this.mc.setStrictFloatingPoint(property);
}
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);
}
public void setTinyInt1isBit(boolean flag) {
this.mc.setTinyInt1isBit(flag);
}
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);
}
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);
}
public void setUseFastIntParsing(boolean flag) {
this.mc.setUseFastIntParsing(flag);
}
public void setUseGmtMillisForDatetimes(boolean flag) {
this.mc.setUseGmtMillisForDatetimes(flag);
}
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);
}
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);
}
public void setUseOldUTF8Behavior(boolean flag) {
this.mc.setUseOldUTF8Behavior(flag);
}
public void setUseOnlyServerErrorMessages(boolean flag) {
this.mc.setUseOnlyServerErrorMessages(flag);
}
public void setUseReadAheadInput(boolean flag) {
this.mc.setUseReadAheadInput(flag);
}
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);
}
public void setUseServerPreparedStmts(boolean flag) {
this.mc.setUseServerPreparedStmts(flag);
}
public void setUseSqlStateCodes(boolean flag) {
this.mc.setUseSqlStateCodes(flag);
}
public void setUseStreamLengthsInPrepStmts(boolean property) {
this.mc.setUseStreamLengthsInPrepStmts(property);
}
public void setUseTimezone(boolean property) {
this.mc.setUseTimezone(property);
}
public void setUseUltraDevWorkAround(boolean property) {
this.mc.setUseUltraDevWorkAround(property);
}
public void setUseUnbufferedInput(boolean flag) {
this.mc.setUseUnbufferedInput(flag);
}
public void setUseUnicode(boolean flag) {
this.mc.setUseUnicode(flag);
}
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);
}
public void setZeroDateTimeBehavior(String behavior) {
this.mc.setZeroDateTimeBehavior(behavior);
}
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);
}
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);
}
public boolean hasSameProperties(Connection c) {
return this.mc.hasSameProperties(c);
}
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);
}
public boolean isServerLocal() throws SQLException {
return this.mc.isServerLocal();
}
public void setAuthenticationPlugins(String authenticationPlugins) {
this.mc.setAuthenticationPlugins(authenticationPlugins);
}
public String getAuthenticationPlugins() {
return this.mc.getAuthenticationPlugins();
}
public void setDisabledAuthenticationPlugins(
String disabledAuthenticationPlugins) {
this.mc.setDisabledAuthenticationPlugins(disabledAuthenticationPlugins);
}
public String getDisabledAuthenticationPlugins() {
return this.mc.getDisabledAuthenticationPlugins();
}
public void setDefaultAuthenticationPlugin(
String defaultAuthenticationPlugin) {
this.mc.setDefaultAuthenticationPlugin(defaultAuthenticationPlugin);
}
public String getDefaultAuthenticationPlugin() {
return this.mc.getDefaultAuthenticationPlugin();
}
public void setParseInfoCacheFactory(String factoryClassname) {
this.mc.setParseInfoCacheFactory(factoryClassname);
}
public String getParseInfoCacheFactory() {
return this.mc.getParseInfoCacheFactory();
}
public void setSchema(String schema) throws SQLException {
this.mc.setSchema(schema);
}
public String getSchema() throws SQLException {
return this.mc.getSchema();
}
public void abort(Executor executor) throws SQLException {
this.mc.abort(executor);
}
public void setNetworkTimeout(Executor executor, int milliseconds)
throws SQLException {
this.mc.setNetworkTimeout(executor, milliseconds);
}
public int getNetworkTimeout() throws SQLException {
return this.mc.getNetworkTimeout();
}
public void setServerConfigCacheFactory(String factoryClassname) {
this.mc.setServerConfigCacheFactory(factoryClassname);
}
public String getServerConfigCacheFactory() {
return this.mc.getServerConfigCacheFactory();
}
public void setDisconnectOnExpiredPasswords(boolean disconnectOnExpiredPasswords) {
this.mc.setDisconnectOnExpiredPasswords(disconnectOnExpiredPasswords);
}
public boolean getDisconnectOnExpiredPasswords() {
return this.mc.getDisconnectOnExpiredPasswords();
}
public void abortInternal() throws SQLException {
this.mc.abortInternal();
}
public Object getConnectionMutex() {
return this.mc.getConnectionMutex();
}
}