src-main.org.awakefw.commons.jdbc.abstracts.AbstractConnection Maven / Gradle / Ivy
Show all versions of awake-file Show documentation
/*
* This file is part of Awake FILE.
* Awake FILE: Easy file upload & download over HTTP with Java.
* Copyright (C) 2014, KawanSoft SAS
* (http://www.kawansoft.com). All rights reserved.
*
* Awake FILE is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Awake FILE 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301 USA
*
* Any modifications to this file must keep this entire header
* intact.
*/
package org.awakefw.commons.jdbc.abstracts;
import java.sql.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLClientInfoException;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Struct;
import java.util.Properties;
import java.util.concurrent.Executor;
import org.awakefw.file.util.Tag;
/**
* Connection Wrapper.
* Implements all the Connection methods. Usage is exactly the same as a
* Connection.
*/
public class AbstractConnection implements Connection {
static final String FEATURE_NOT_SUPPORTED_IN_THIS_VERSION = Tag.AWAKE
+ "Method is not yet implemented in Awake SQL: ";
/** SQL JDBC connection */
private Connection connection;
/** Flag that says the caller is ConnectionHttp */
private boolean isConnectionHttp = false;
/**
* Void Constructor Needed for HTTP usage because there is no Connection
*/
public AbstractConnection() {
isConnectionHttp = true;
}
/**
* Constructor
*
* @param connection
* actual SQL/JDBC Connection in use to wrap
*/
public AbstractConnection(Connection connection) {
this.connection = connection;
}
/**
* Will throw a SQL Exception if calling method is not authorized
**/
private void verifyCallAuthorization(String methodName) throws SQLException {
if (isConnectionHttp) {
throw new SQLException(
AbstractConnection.FEATURE_NOT_SUPPORTED_IN_THIS_VERSION
+ methodName);
}
}
/**
* Creates a Statement object for sending SQL statements to the
* database. SQL statements without parameters are normally executed using
* Statement objects. If the same SQL statement is executed
* many times, it may be more efficient to use a
* PreparedStatement object.
*
* Result sets created using the returned Statement object will
* by default be type TYPE_FORWARD_ONLY and have a concurrency
* level of CONCUR_READ_ONLY.
*
* @return a new default Statement object
* @exception SQLException
* if a database access error occurs
*/
public Statement createStatement() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.createStatement();
}
/**
* Creates a PreparedStatement object for sending parameterized
* SQL statements to the database.
*
* A SQL statement with or without IN parameters can be pre-compiled and
* stored in a PreparedStatement object. This object can then
* be used to efficiently execute this statement multiple times.
*
*
* Note: This method is optimized for handling parametric SQL
* statements that benefit from precompilation. If the driver supports
* precompilation, the method prepareStatement will send the
* statement to the database for precompilation. Some drivers may not
* support precompilation. In this case, the statement may not be sent to
* the database until the PreparedStatement object is executed.
* This has no direct effect on users; however, it does affect which methods
* throw certain SQLException objects.
*
* Result sets created using the returned PreparedStatement
* object will by default be type TYPE_FORWARD_ONLY and have a
* concurrency level of CONCUR_READ_ONLY.
*
* @param sql
* an SQL statement that may contain one or more '?' IN parameter
* placeholders
* @return a new default PreparedStatement object containing
* the pre-compiled SQL statement
* @exception SQLException
* if a database access error occurs
*/
public PreparedStatement prepareStatement(String sql) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.prepareStatement(sql);
}
/**
* Creates a CallableStatement object for calling database
* stored procedures. The CallableStatement object provides
* methods for setting up its IN and OUT parameters, and methods for
* executing the call to a stored procedure.
*
*
* Note: This method is optimized for handling stored procedure call
* statements. Some drivers may send the call statement to the database when
* the method prepareCall is done; others may wait until the
* CallableStatement object is executed. This has no direct
* effect on users; however, it does affect which method throws certain
* SQLExceptions.
*
* Result sets created using the returned CallableStatement
* object will by default be type TYPE_FORWARD_ONLY and have a
* concurrency level of CONCUR_READ_ONLY.
*
* @param sql
* an SQL statement that may contain one or more '?' parameter
* placeholders. Typically this statement is a JDBC function call
* escape string.
* @return a new default CallableStatement object containing
* the pre-compiled SQL statement
* @exception SQLException
* if a database access error occurs
*/
public CallableStatement prepareCall(String sql) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.prepareCall(sql);
}
/**
* Converts the given SQL statement into the system's native SQL grammar. A
* driver may convert the JDBC SQL grammar into its system's native SQL
* grammar prior to sending it. This method returns the native form of the
* statement that the driver would have sent.
*
* @param sql
* an SQL statement that may contain one or more '?' parameter
* placeholders
* @return the native form of this statement
* @exception SQLException
* if a database access error occurs
*/
public String nativeSQL(String sql) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.nativeSQL(sql);
}
/**
* Sets this connection's auto-commit mode to the given state. If a
* connection is in auto-commit mode, then all its SQL statements will be
* executed and committed as individual transactions. Otherwise, its SQL
* statements are grouped into transactions that are terminated by a call to
* either the method commit or the method rollback
* . By default, new connections are in auto-commit mode.
*
* The commit occurs when the statement completes or the next execute
* occurs, whichever comes first. In the case of statements returning a
* ResultSet object, the statement completes when the last row
* of the ResultSet object has been retrieved or the
* ResultSet object has been closed. In advanced cases, a
* single statement may return multiple results as well as output parameter
* values. In these cases, the commit occurs when all results and output
* parameter values have been retrieved.
*
* NOTE: If this method is called during a transaction, the
* transaction is committed.
*
* @param autoCommit
* true to enable auto-commit mode;
* false to disable it
* @exception SQLException
* if a database access error occurs
* @see #getAutoCommit
*/
public void setAutoCommit(boolean autoCommit) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.connection.setAutoCommit(autoCommit);
}
/**
* Retrieves the current auto-commit mode for this Connection
* object.
*
* @return the current state of this Connection object's
* auto-commit mode
* @exception SQLException
* if a database access error occurs
* @see #setAutoCommit
*/
public boolean getAutoCommit() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.getAutoCommit();
}
/**
* Makes all changes made since the previous commit/rollback permanent and
* releases any database locks currently held by this
* Connection object. This method should be used only when
* auto-commit mode has been disabled.
*
* @exception SQLException
* if a database access error occurs or this
* Connection object is in auto-commit mode
* @see #setAutoCommit
*/
public void commit() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.connection.commit();
}
/**
* Undoes all changes made in the current transaction and releases any
* database locks currently held by this Connection object.
* This method should be used only when auto-commit mode has been disabled.
*
* @exception SQLException
* if a database access error occurs or this
* Connection object is in auto-commit mode
* @see #setAutoCommit
*/
public void rollback() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.connection.rollback();
}
/**
* Releases this Connection object's database and JDBC
* resources immediately instead of waiting for them to be automatically
* released.
*
* Calling the method close on a Connection object
* that is already closed is a no-op.
*
* Note: A Connection object is automatically closed
* when it is garbage collected. Certain fatal errors also close a
* Connection object.
*
* @exception SQLException
* if a database access error occurs
*/
public void close() throws SQLException {
this.connection.close();
}
/**
* Retrieves whether this Connection object has been closed. A
* connection is closed if the method close has been called on
* it or if certain fatal errors have occurred. This method is guaranteed to
* return true only when it is called after the method
* Connection.close has been called.
*
* This method generally cannot be called to determine whether a connection
* to a database is valid or invalid. A typical client can determine that a
* connection is invalid by catching any exceptions that might be thrown
* when an operation is attempted.
*
* @return true if this Connection object is
* closed; false if it is still open
* @exception SQLException
* if a database access error occurs
*/
public boolean isClosed() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.isClosed();
}
// ======================================================================
// Advanced features:
/**
* Retrieves a DatabaseMetaData object that contains metadata
* about the database to which this Connection object
* represents a connection. The metadata includes information about the
* database's tables, its supported SQL grammar, its stored procedures, the
* capabilities of this connection, and so on.
*
* @return a DatabaseMetaData object for this
* Connection object
* @exception SQLException
* if a database access error occurs
*/
public DatabaseMetaData getMetaData() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.getMetaData();
}
/**
* Puts this connection in read-only mode as a hint to the driver to enable
* database optimizations.
*
*
* Note: This method cannot be called during a transaction.
*
* @param readOnly
* true enables read-only mode; false
* disables it
* @exception SQLException
* if a database access error occurs or this method is called
* during a transaction
*/
public void setReadOnly(boolean readOnly) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.connection.setReadOnly(readOnly);
}
/**
* Retrieves whether this Connection object is in read-only
* mode.
*
* @return true if this Connection object is
* read-only; false otherwise
* @exception SQLException
* if a database access error occurs
*/
public boolean isReadOnly() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.isReadOnly();
}
/**
* Sets the given catalog name in order to select a subspace of this
* Connection object's database in which to work.
*
* If the driver does not support catalogs, it will silently ignore this
* request.
*
* @param catalog
* the name of a catalog (subspace in this
* Connection object's database) in which to work
* @exception SQLException
* if a database access error occurs
* @see #getCatalog
*/
public void setCatalog(String catalog) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.connection.setCatalog(catalog);
}
/**
* Retrieves this Connection object's current catalog name.
*
* @return the current catalog name or null if there is none
* @exception SQLException
* if a database access error occurs
* @see #setCatalog
*/
public String getCatalog() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.getCatalog();
}
/**
* A constant indicating that transactions are not supported.
*/
protected int TRANSACTION_NONE = 0;
/**
* A constant indicating that dirty reads, non-repeatable reads and phantom
* reads can occur. This level allows a row changed by one transaction to be
* read by another transaction before any changes in that row have been
* committed (a "dirty read"). If any of the changes are rolled back, the
* second transaction will have retrieved an invalid row.
*/
protected int TRANSACTION_READ_UNCOMMITTED = 1;
/**
* A constant indicating that dirty reads are prevented; non-repeatable
* reads and phantom reads can occur. This level only prohibits a
* transaction from reading a row with uncommitted changes in it.
*/
protected int TRANSACTION_READ_COMMITTED = 2;
/**
* A constant indicating that dirty reads and non-repeatable reads are
* prevented; phantom reads can occur. This level prohibits a transaction
* from reading a row with uncommitted changes in it, and it also prohibits
* the situation where one transaction reads a row, a second transaction
* alters the row, and the first transaction rereads the row, getting
* different values the second time (a "non-repeatable read").
*/
protected int TRANSACTION_REPEATABLE_READ = 4;
/**
* A constant indicating that dirty reads, non-repeatable reads and phantom
* reads are prevented. This level includes the prohibitions in
* TRANSACTION_REPEATABLE_READ and further prohibits the
* situation where one transaction reads all rows that satisfy a
* WHERE condition, a second transaction inserts a row that
* satisfies that WHERE condition, and the first transaction
* rereads for the same condition, retrieving the additional "phantom" row
* in the second read.
*/
protected int TRANSACTION_SERIALIZABLE = 8;
/**
* Attempts to change the transaction isolation level for this
* Connection object to the one given. The constants defined in
* the interface Connection are the possible transaction
* isolation levels.
*
* Note: If this method is called during a transaction, the result is
* implementation-defined.
*
* @param level
* one of the following Connection constants:
* Connection.TRANSACTION_READ_UNCOMMITTED,
* Connection.TRANSACTION_READ_COMMITTED,
* Connection.TRANSACTION_REPEATABLE_READ, or
* Connection.TRANSACTION_SERIALIZABLE. (Note that
* Connection.TRANSACTION_NONE cannot be used
* because it specifies that transactions are not supported.)
* @exception SQLException
* if a database access error occurs or the given parameter
* is not one of the Connection constants
* @see DatabaseMetaData#supportsTransactionIsolationLevel
* @see #getTransactionIsolation
*/
public void setTransactionIsolation(int level) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.connection.setTransactionIsolation(level);
}
/**
* Retrieves this Connection object's current transaction
* isolation level.
*
* @return the current transaction isolation level, which will be one of the
* following constants:
* Connection.TRANSACTION_READ_UNCOMMITTED,
* Connection.TRANSACTION_READ_COMMITTED,
* Connection.TRANSACTION_REPEATABLE_READ,
* Connection.TRANSACTION_SERIALIZABLE, or
* Connection.TRANSACTION_NONE.
* @exception SQLException
* if a database access error occurs
* @see #setTransactionIsolation
*/
public int getTransactionIsolation() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.getTransactionIsolation();
}
/**
* Retrieves the first warning reported by calls on this
* Connection object. If there is more than one warning,
* subsequent warnings will be chained to the first one and can be retrieved
* by calling the method SQLWarning.getNextWarning on the
* warning that was retrieved previously.
*
* This method may not be called on a closed connection; doing so will cause
* an SQLException to be thrown.
*
*
* Note: Subsequent warnings will be chained to this SQLWarning.
*
* @return the first SQLWarning object or null if
* there are none
* @exception SQLException
* if a database access error occurs or this method is called
* on a closed connection
* @see SQLWarning
*/
public SQLWarning getWarnings() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.getWarnings();
}
/**
* Clears all warnings reported for this Connection object.
* After a call to this method, the method getWarnings returns
* null until a new warning is reported for this
* Connection object.
*
* @exception SQLException
* if a database access error occurs
*/
public void clearWarnings() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.connection.clearWarnings();
}
// --------------------------JDBC 2.0-----------------------------
/**
* Creates a Statement object that will generate
* ResultSet objects with the given type and concurrency. This
* method is the same as the createStatement method above, but
* it allows the default result set type and concurrency to be overridden.
*
* @param resultSetType
* a result set type; one of
* ResultSet.TYPE_FORWARD_ONLY,
* ResultSet.TYPE_SCROLL_INSENSITIVE, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @param resultSetConcurrency
* a concurrency type; one of
* ResultSet.CONCUR_READ_ONLY or
* ResultSet.CONCUR_UPDATABLE
* @return a new Statement object that will generate
* ResultSet objects with the given type and
* concurrency
* @exception SQLException
* if a database access error occurs or the given parameters
* are not ResultSet constants indicating type
* and concurrency
* @since 1.2
*/
public Statement createStatement(int resultSetType, int resultSetConcurrency)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.createStatement(resultSetType,
resultSetConcurrency);
}
/**
*
* Creates a PreparedStatement object that will generate
* ResultSet objects with the given type and concurrency. This
* method is the same as the prepareStatement method above, but
* it allows the default result set type and concurrency to be overridden.
*
* @param sql
* a String object that is the SQL statement to be
* sent to the database; may contain one or more ? IN parameters
* @param resultSetType
* a result set type; one of
* ResultSet.TYPE_FORWARD_ONLY,
* ResultSet.TYPE_SCROLL_INSENSITIVE, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @param resultSetConcurrency
* a concurrency type; one of
* ResultSet.CONCUR_READ_ONLY or
* ResultSet.CONCUR_UPDATABLE
* @return a new PreparedStatement object containing the pre-compiled SQL
* statement that will produce ResultSet objects with
* the given type and concurrency
* @exception SQLException
* if a database access error occurs or the given parameters
* are not ResultSet constants indicating type
* and concurrency
* @since 1.2
*/
public PreparedStatement prepareStatement(String sql, int resultSetType,
int resultSetConcurrency) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.prepareStatement(sql, resultSetType,
resultSetConcurrency);
}
/**
* Creates a CallableStatement object that will generate
* ResultSet objects with the given type and concurrency. This
* method is the same as the prepareCall method above, but it
* allows the default result set type and concurrency to be overridden.
*
* @param sql
* a String object that is the SQL statement to be
* sent to the database; may contain on or more ? parameters
* @param resultSetType
* a result set type; one of
* ResultSet.TYPE_FORWARD_ONLY,
* ResultSet.TYPE_SCROLL_INSENSITIVE, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @param resultSetConcurrency
* a concurrency type; one of
* ResultSet.CONCUR_READ_ONLY or
* ResultSet.CONCUR_UPDATABLE
* @return a new CallableStatement object containing the
* pre-compiled SQL statement that will produce
* ResultSet objects with the given type and
* concurrency
* @exception SQLException
* if a database access error occurs or the given parameters
* are not ResultSet constants indicating type
* and concurrency
* @since 1.2
*/
public CallableStatement prepareCall(String sql, int resultSetType,
int resultSetConcurrency) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.prepareCall(sql, resultSetType,
resultSetConcurrency);
}
/**
* Retrieves the Map object associated with this
* Connection object. Unless the application has added an
* entry, the type map returned will be empty.
*
* @return the java.util.Map object associated with this
* Connection object
* @exception SQLException
* if a database access error occurs
* @since 1.2
* @see #setTypeMap
*/
public java.util.Map> getTypeMap() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.getTypeMap();
}
/**
* Installs the given TypeMap object as the type map for this
* Connection object. The type map will be used for the custom
* mapping of SQL structured types and distinct types.
*
* @param map
* the java.util.Map object to install as the
* replacement for this Connection object's default
* type map
* @exception SQLException
* if a database access error occurs or the given parameter
* is not a java.util.Map object
* @since 1.2
* @see #getTypeMap
*/
public void setTypeMap(java.util.Map> map)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.connection.setTypeMap(map);
}
// --------------------------JDBC 3.0-----------------------------
/**
* Changes the holdability of ResultSet objects created using
* this Connection object to the given holdability.
*
* @param holdability
* a ResultSet holdability constant; one of
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @throws SQLException
* if a database access occurs, the given parameter is not a
* ResultSet constant indicating holdability, or
* the given holdability is not supported
* @see #getHoldability
* @see ResultSet
* @since 1.4
*/
public void setHoldability(int holdability) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.connection.setHoldability(holdability);
}
/**
* Retrieves the current holdability of ResultSet objects
* created using this Connection object.
*
* @return the holdability, one of
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @throws SQLException
* if a database access occurs
* @see #setHoldability
* @see ResultSet
* @since 1.4
*/
public int getHoldability() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.getHoldability();
}
/**
* Creates an unnamed savepoint in the current transaction and returns the
* new Savepoint object that represents it.
*
* @return the new Savepoint object
* @exception SQLException
* if a database access error occurs or this
* Connection object is currently in auto-commit
* mode
* @see Savepoint
* @since 1.4
*/
public Savepoint setSavepoint() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.setSavepoint();
}
/**
* Creates a savepoint with the given name in the current transaction and
* returns the new Savepoint object that represents it.
*
* @param name
* a String containing the name of the savepoint
* @return the new Savepoint object
* @exception SQLException
* if a database access error occurs or this
* Connection object is currently in auto-commit
* mode
* @see Savepoint
* @since 1.4
*/
public Savepoint setSavepoint(String name) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.setSavepoint(name);
}
/**
* Undoes all changes made after the given Savepoint object was
* set.
*
* This method should be used only when auto-commit has been disabled.
*
* @param savepoint
* the Savepoint object to roll back to
* @exception SQLException
* if a database access error occurs, the
* Savepoint object is no longer valid, or this
* Connection object is currently in auto-commit
* mode
* @see Savepoint
* @see #rollback
* @since 1.4
*/
public void rollback(Savepoint savepoint) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.connection.rollback(savepoint);
}
/**
* Removes the given Savepoint object from the current
* transaction. Any reference to the savepoint after it have been removed
* will cause an SQLException to be thrown.
*
* @param savepoint
* the Savepoint object to be removed
* @exception SQLException
* if a database access error occurs or the given
* Savepoint object is not a valid savepoint in
* the current transaction
* @since 1.4
*/
public void releaseSavepoint(Savepoint savepoint) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.connection.releaseSavepoint(savepoint);
}
/**
* Creates a Statement object that will generate
* ResultSet objects with the given type, concurrency, and
* holdability. This method is the same as the createStatement
* method above, but it allows the default result set type, concurrency, and
* holdability to be overridden.
*
* @param resultSetType
* one of the following ResultSet constants:
* ResultSet.TYPE_FORWARD_ONLY,
* ResultSet.TYPE_SCROLL_INSENSITIVE, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @param resultSetConcurrency
* one of the following ResultSet constants:
* ResultSet.CONCUR_READ_ONLY or
* ResultSet.CONCUR_UPDATABLE
* @param resultSetHoldability
* one of the following ResultSet constants:
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @return a new Statement object that will generate
* ResultSet objects with the given type, concurrency,
* and holdability
* @exception SQLException
* if a database access error occurs or the given parameters
* are not ResultSet constants indicating type,
* concurrency, and holdability
* @see ResultSet
* @since 1.4
*/
public Statement createStatement(int resultSetType,
int resultSetConcurrency, int resultSetHoldability)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.createStatement(resultSetType,
resultSetConcurrency, resultSetHoldability);
}
/**
* Creates a PreparedStatement object that will generate
* ResultSet objects with the given type, concurrency, and
* holdability.
*
* This method is the same as the prepareStatement method
* above, but it allows the default result set type, concurrency, and
* holdability to be overridden.
*
* @param sql
* a String object that is the SQL statement to be
* sent to the database; may contain one or more ? IN parameters
* @param resultSetType
* one of the following ResultSet constants:
* ResultSet.TYPE_FORWARD_ONLY,
* ResultSet.TYPE_SCROLL_INSENSITIVE, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @param resultSetConcurrency
* one of the following ResultSet constants:
* ResultSet.CONCUR_READ_ONLY or
* ResultSet.CONCUR_UPDATABLE
* @param resultSetHoldability
* one of the following ResultSet constants:
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @return a new PreparedStatement object, containing the
* pre-compiled SQL statement, that will generate
* ResultSet objects with the given type, concurrency,
* and holdability
* @exception SQLException
* if a database access error occurs or the given parameters
* are not ResultSet constants indicating type,
* concurrency, and holdability
* @see ResultSet
* @since 1.4
*/
public PreparedStatement prepareStatement(String sql, int resultSetType,
int resultSetConcurrency, int resultSetHoldability)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.prepareStatement(sql, resultSetType,
resultSetConcurrency, resultSetHoldability);
}
/**
* Creates a CallableStatement object that will generate
* ResultSet objects with the given type and concurrency. This
* method is the same as the prepareCall method above, but it
* allows the default result set type, result set concurrency type and
* holdability to be overridden.
*
* @param sql
* a String object that is the SQL statement to be
* sent to the database; may contain on or more ? parameters
* @param resultSetType
* one of the following ResultSet constants:
* ResultSet.TYPE_FORWARD_ONLY,
* ResultSet.TYPE_SCROLL_INSENSITIVE, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @param resultSetConcurrency
* one of the following ResultSet constants:
* ResultSet.CONCUR_READ_ONLY or
* ResultSet.CONCUR_UPDATABLE
* @param resultSetHoldability
* one of the following ResultSet constants:
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @return a new CallableStatement object, containing the
* pre-compiled SQL statement, that will generate
* ResultSet objects with the given type, concurrency,
* and holdability
* @exception SQLException
* if a database access error occurs or the given parameters
* are not ResultSet constants indicating type,
* concurrency, and holdability
* @see ResultSet
* @since 1.4
*/
public CallableStatement prepareCall(String sql, int resultSetType,
int resultSetConcurrency, int resultSetHoldability)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.prepareCall(sql, resultSetType,
resultSetConcurrency, resultSetHoldability);
}
/**
* Creates a default PreparedStatement object that has
* the capability to retrieve auto-generated keys. The given constant
* tells the driver whether it should make auto-generated keys
* available for retrieval. This parameter is ignored if the SQL statement
* is not an INSERT statement, or an SQL statement able to return
* auto-generated keys (the list of such statements is vendor-specific).
*
* Note: This method is optimized for handling
* parametric SQL statements that benefit from precompilation. If
* the driver supports precompilation,
* the method prepareStatement will send
* the statement to the database for precompilation. Some drivers
* may not support precompilation. In this case, the statement may
* not be sent to the database until the PreparedStatement
* object is executed. This has no direct effect on users; however, it does
* affect which methods throw certain SQLExceptions.
*
* Result sets created using the returned PreparedStatement
* object will by default be type TYPE_FORWARD_ONLY
* and have a concurrency level of CONCUR_READ_ONLY.
* The holdability of the created result sets can be determined by
* calling {@link #getHoldability}.
*
* @param sql an SQL statement that may contain one or more '?' IN
* parameter placeholders
* @param autoGeneratedKeys a flag indicating whether auto-generated keys
* should be returned; one of
* Statement.RETURN_GENERATED_KEYS or
* Statement.NO_GENERATED_KEYS
* @return a new PreparedStatement object, containing the
* pre-compiled SQL statement, that will have the capability of
* returning auto-generated keys
* @exception SQLException if a database access error occurs, this
* method is called on a closed connection
* or the given parameter is not a Statement
* constant indicating whether auto-generated keys should be
* returned
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this method with a constant of Statement.RETURN_GENERATED_KEYS
* @since 1.4
*/
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.prepareStatement(sql, autoGeneratedKeys);
}
/**
* Creates a default PreparedStatement object capable of
* returning the auto-generated keys designated by the given array. This
* array contains the indexes of the columns in the target table that
* contain the auto-generated keys that should be made available. This array
* is ignored if the SQL statement is not an INSERT statement.
*
* An SQL statement with or without IN parameters can be pre-compiled and
* stored in a PreparedStatement object. This object can then
* be used to efficiently execute this statement multiple times.
*
* Note: This method is optimized for handling parametric SQL
* statements that benefit from precompilation. If the driver supports
* precompilation, the method prepareStatement will send the
* statement to the database for precompilation. Some drivers may not
* support precompilation. In this case, the statement may not be sent to
* the database until the PreparedStatement object is executed.
* This has no direct effect on users; however, it does affect which methods
* throw certain SQLExceptions.
*
* Result sets created using the returned PreparedStatement
* object will by default be type TYPE_FORWARD_ONLY and have a
* concurrency level of CONCUR_READ_ONLY.
*
* @param sql
* an SQL statement that may contain one or more '?' IN parameter
* placeholders
* @param columnIndexes
* an array of column indexes indicating the columns that should
* be returned from the inserted row or rows
* @return a new PreparedStatement object, containing the
* pre-compiled statement, that is capable of returning the
* auto-generated keys designated by the given array of column
* indexes
* @exception SQLException
* if a database access error occurs
*
* @since 1.4
*/
public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.prepareStatement(sql, columnIndexes);
}
/**
* Creates a default PreparedStatement object capable of
* returning the auto-generated keys designated by the given array. This
* array contains the names of the columns in the target table that contain
* the auto-generated keys that should be returned. This array is ignored if
* the SQL statement is not an INSERT statement.
*
* An SQL statement with or without IN parameters can be pre-compiled and
* stored in a PreparedStatement object. This object can then
* be used to efficiently execute this statement multiple times.
*
* Note: This method is optimized for handling parametric SQL
* statements that benefit from precompilation. If the driver supports
* precompilation, the method prepareStatement will send the
* statement to the database for precompilation. Some drivers may not
* support precompilation. In this case, the statement may not be sent to
* the database until the PreparedStatement object is executed.
* This has no direct effect on users; however, it does affect which methods
* throw certain SQLExceptions.
*
* Result sets created using the returned PreparedStatement
* object will by default be type TYPE_FORWARD_ONLY and have a
* concurrency level of CONCUR_READ_ONLY.
*
* @param sql
* an SQL statement that may contain one or more '?' IN parameter
* placeholders
* @param columnNames
* an array of column names indicating the columns that should be
* returned from the inserted row or rows
* @return a new PreparedStatement object, containing the
* pre-compiled statement, that is capable of returning the
* auto-generated keys designated by the given array of column names
* @exception SQLException
* if a database access error occurs
*
* @since 1.4
*/
public PreparedStatement prepareStatement(String sql, String[] columnNames)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.connection.prepareStatement(sql, columnNames);
}
/**
* Factory method for creating Array objects.
*
* Note: When createArrayOf is used to create an array object
* that maps to a primitive data type, then it is implementation-defined
* whether the Array object is an array of that primitive
* data type or an array of Object.
*
* Note: The JDBC driver is responsible for mapping the elements
* Object array to the default JDBC SQL type defined in
* java.sql.Types for the given class of Object. The default
* mapping is specified in Appendix B of the JDBC specification. If the
* resulting JDBC type is not the appropriate type for the given typeName then
* it is implementation defined whether an SQLException is
* thrown or the driver supports the resulting conversion.
*
* @param typeName the SQL name of the type the elements of the array map to. The typeName is a
* database-specific name which may be the name of a built-in type, a user-defined type or a standard SQL type supported by this database. This
* is the value returned by Array.getBaseTypeName
* @param elements the elements that populate the returned object
* @return an Array object whose elements map to the specified SQL type
* @throws SQLException if a database error occurs, the JDBC type is not
* appropriate for the typeName and the conversion is not supported, the typeName is null or this method is called on a closed connection
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this data type
* @since 1.6
*/
public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return connection.createArrayOf(typeName, elements);
}
/**
* Constructs an object that implements the Blob interface. The object
* returned initially contains no data. The setBinaryStream and
* setBytes methods of the Blob interface may be used to add data to
* the Blob.
* @return An object that implements the Blob interface
* @throws SQLException if an object that implements the
* Blob interface can not be constructed, this method is
* called on a closed connection or a database access error occurs.
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this data type
*
* @since 1.6
*/
public Blob createBlob() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return connection.createBlob();
}
/**
* Constructs an object that implements the Clob interface. The object
* returned initially contains no data. The setAsciiStream,
* setCharacterStream and setString methods of
* the Clob interface may be used to add data to the Clob.
* @return An object that implements the Clob interface
* @throws SQLException if an object that implements the
* Clob interface can not be constructed, this method is
* called on a closed connection or a database access error occurs.
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this data type
*
* @since 1.6
*/
public Clob createClob() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return connection.createClob();
}
/**
* Constructs an object that implements the NClob interface. The object
* returned initially contains no data. The setAsciiStream,
* setCharacterStream and setString methods of the NClob interface may
* be used to add data to the NClob.
* @return An object that implements the NClob interface
* @throws SQLException if an object that implements the
* NClob interface can not be constructed, this method is
* called on a closed connection or a database access error occurs.
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this data type
*
* @since 1.6
*/
public NClob createNClob() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return connection.createNClob();
}
/**
* Constructs an object that implements the SQLXML interface. The object
* returned initially contains no data. The createXmlStreamWriter object and
* setString method of the SQLXML interface may be used to add data to the SQLXML
* object.
* @return An object that implements the SQLXML interface
* @throws SQLException if an object that implements the SQLXML interface can not
* be constructed, this method is
* called on a closed connection or a database access error occurs.
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support
* this data type
* @since 1.6
*/
public SQLXML createSQLXML() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return connection.createSQLXML();
}
/**
* Factory method for creating Struct objects.
*
* @param typeName the SQL type name of the SQL structured type that this Struct
* object maps to. The typeName is the name of a user-defined type that
* has been defined for this database. It is the value returned by
* Struct.getSQLTypeName.
* @param attributes the attributes that populate the returned object
* @return a Struct object that maps to the given SQL type and is populated with the given attributes
* @throws SQLException if a database error occurs, the typeName is null or this method is called on a closed connection
* @throws SQLFeatureNotSupportedException if the JDBC driver does not support this data type
* @since 1.6
*/
public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return connection.createStruct(typeName, attributes);
}
/**
* Returns a list containing the name and current value of each client info
* property supported by the driver. The value of a client info property
* may be null if the property has not been set and does not have a
* default value.
*
* @return A Properties object that contains the name and current value of
* each of the client info properties supported by the driver.
*
* @throws SQLException if the database server returns an error when
* fetching the client info values from the database
* or this method is called on a closed connection
*
* @since 1.6
*/
public Properties getClientInfo() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return connection.getClientInfo();
}
/**
* Returns the value of the client info property specified by name. This
* method may return null if the specified client info property has not
* been set and does not have a default value. This method will also
* return null if the specified client info property name is not supported
* by the driver.
*
* Applications may use the DatabaseMetaData.getClientInfoProperties
* method to determine the client info properties supported by the driver.
*
* @param name The name of the client info property to retrieve
*
* @return The value of the client info property specified
*
* @throws SQLException if the database server returns an error when
* fetching the client info value from the database
* or this method is called on a closed connection
*
* @since 1.6
*
* @see java.sql.DatabaseMetaData#getClientInfoProperties
*/
public String getClientInfo(String name) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return connection.getClientInfo(name);
}
/**
* Returns true if the connection has not been closed and is still valid.
* The driver shall submit a query on the connection or use some other
* mechanism that positively verifies the connection is still valid when
* this method is called.
*
* The query submitted by the driver to validate the connection shall be
* executed in the context of the current transaction.
*
* @param timeout - The time in seconds to wait for the database operation
* used to validate the connection to complete. If
* the timeout period expires before the operation
* completes, this method returns false. A value of
* 0 indicates a timeout is not applied to the
* database operation.
*
* @return true if the connection is valid, false otherwise
* @exception SQLException if the value supplied for timeout
* is less then 0
* @since 1.6
*
* @see java.sql.DatabaseMetaData#getClientInfoProperties
*/
public boolean isValid(int timeout) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return connection.isValid(timeout);
}
/**
* Returns true if this either implements the interface argument or is directly or indirectly a wrapper
* for an object that does. Returns false otherwise. If this implements the interface then return true,
* else if this is a wrapper then return the result of recursively calling isWrapperFor on the wrapped
* object. If this does not implement the interface and is not a wrapper, return false.
* This method should be implemented as a low-cost operation compared to unwrap so that
* callers can use this method to avoid expensive unwrap calls that may fail. If this method
* returns true then calling unwrap with the same argument should succeed.
*
* @param iface a Class defining an interface.
* @return true if this implements the interface or directly or indirectly wraps an object that does.
* @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper
* for an object with the given interface.
* @since 1.6
*/
public boolean isWrapperFor(Class iface) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return connection.isWrapperFor(iface);
}
/**
* Sets the value of the connection's client info properties. The
* Properties object contains the names and values of the client info
* properties to be set. The set of client info properties contained in
* the properties list replaces the current set of client info properties
* on the connection. If a property that is currently set on the
* connection is not present in the properties list, that property is
* cleared. Specifying an empty properties list will clear all of the
* properties on the connection. See setClientInfo (String, String) for
* more information.
*
* If an error occurs in setting any of the client info properties, a
* SQLClientInfoException is thrown. The SQLClientInfoException
* contains information indicating which client info properties were not set.
* The state of the client information is unknown because
* some databases do not allow multiple client info properties to be set
* atomically. For those databases, one or more properties may have been
* set before the error occurred.
*
*
* @param properties the list of client info properties to set
*
* @see java.sql.Connection#setClientInfo(String, String) setClientInfo(String, String)
* @since 1.6
*
* @throws SQLClientInfoException if the database server returns an error while
* setting the clientInfo values on the database server or this method
* is called on a closed connection
*
*/
public void setClientInfo(Properties properties) throws SQLClientInfoException {
if (isConnectionHttp) {
throw new SQLClientInfoException();
}
connection.setClientInfo(properties);
}
/**
* Sets the value of the client info property specified by name to the
* value specified by value.
*
* Applications may use the DatabaseMetaData.getClientInfoProperties
* method to determine the client info properties supported by the driver
* and the maximum length that may be specified for each property.
*
* The driver stores the value specified in a suitable location in the
* database. For example in a special register, session parameter, or
* system table column. For efficiency the driver may defer setting the
* value in the database until the next time a statement is executed or
* prepared. Other than storing the client information in the appropriate
* place in the database, these methods shall not alter the behavior of
* the connection in anyway. The values supplied to these methods are
* used for accounting, diagnostics and debugging purposes only.
*
* The driver shall generate a warning if the client info name specified
* is not recognized by the driver.
*
* If the value specified to this method is greater than the maximum
* length for the property the driver may either truncate the value and
* generate a warning or generate a SQLClientInfoException. If the driver
* generates a SQLClientInfoException, the value specified was not set on the
* connection.
*
* The following are standard client info properties. Drivers are not
* required to support these properties however if the driver supports a
* client info property that can be described by one of the standard
* properties, the standard property name should be used.
*
*
* - ApplicationName - The name of the application currently utilizing
* the connection
* - ClientUser - The name of the user that the application using
* the connection is performing work for. This may
* not be the same as the user name that was used
* in establishing the connection.
* - ClientHostname - The hostname of the computer the application
* using the connection is running on.
*
*
* @param name The name of the client info property to set
* @param value The value to set the client info property to. If the
* value is null, the current value of the specified
* property is cleared.
*
* @throws SQLClientInfoException if the database server returns an error while
* setting the client info value on the database server or this method
* is called on a closed connection
*
* @since 1.6
*/
public void setClientInfo(String name, String value)
throws SQLClientInfoException {
if (isConnectionHttp) {
throw new SQLClientInfoException();
}
connection.setClientInfo(name, value);
}
/**
* Returns an object that implements the given interface to allow access to
* non-standard methods, or standard methods not exposed by the proxy.
*
* If the receiver implements the interface then the result is the receiver
* or a proxy for the receiver. If the receiver is a wrapper
* and the wrapped object implements the interface then the result is the
* wrapped object or a proxy for the wrapped object. Otherwise return the
* the result of calling unwrap recursively on the wrapped object
* or a proxy for that result. If the receiver is not a
* wrapper and does not implement the interface, then an SQLException is thrown.
*
* @param iface A Class defining an interface that the result must implement.
* @return an object that implements the interface. May be a proxy for the actual implementing object.
* @throws java.sql.SQLException If no object found that implements the interface
* @since 1.6
*/
public T unwrap(Class iface) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return connection.unwrap(iface);
}
///////////////////////////////////////////////////////////
// JAVA 7 METHOD EMULATION //
///////////////////////////////////////////////////////////
//@Override do not not override for Java 6 compatibility
public void abort(Executor arg0) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
}
//@Override do not not override for Java 6 compatibility
public int getNetworkTimeout() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return 0;
}
//@Override do not not override for Java 6 compatibility
public String getSchema() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return null;
}
//@Override do not not override for Java 6 compatibility
public void setNetworkTimeout(Executor arg0, int arg1) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
}
//@Override do not not override for Java 6 compatibility
public void setSchema(String arg0) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
}
}