org.kawanfw.sql.api.client.RemoteConnection Maven / Gradle / Ivy
/*
* This file is part of AceQL.
* AceQL: Remote JDBC access over HTTP.
* Copyright (C) 2015, KawanSoft SAS
* (http://www.kawansoft.com). All rights reserved.
*
* AceQL 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.
*
* AceQL 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.kawanfw.sql.api.client;
import java.net.PasswordAuthentication;
import java.net.Proxy;
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.Map;
import java.util.Properties;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import org.kawanfw.commons.api.client.RemoteException;
import org.kawanfw.commons.api.client.SessionParameters;
import org.kawanfw.file.api.client.RemoteSession;
import org.kawanfw.sql.jdbc.ConnectionHttp;
/**
* Provides a Connection implementation that enable to use a
* virtual JDBC Connection that is mapped to a Server JDBC
* Connection in order to access a remote SQL database through
* HTTP.
*
* This Connection implementation supports:
*
* - Main JDBC data formats.
* Blob/Clob updates with clean streaming behavior when
* uploading.Blob/Clob reads with clean streaming behavior when
* downloading.- Transaction through
commit and rollback orders.
*
*
*
* Supplementary specific methods that are not of instance of Connection are
* also added.
*
* After creating the RemoteConnection, just use it like a regular
* Connection to execute your PreparedStatement and
* Statement, and to navigate through your ResultSet.
*
* All thrown exceptions are of type {@link SQLException}. Use
* {@link SQLException#getCause()} to get the original wrapped Exception.
* If an Exception is thrown by the remote server, the original Exception will
* be a {@link RemoteException}. The cause will be available with
* {@link RemoteException#getCause()} and the remote stack trace as a string
* available with {@link RemoteException#getRemoteStackTrace()}
*
* The SQL Exceptions specific to a product failure all start with the
* "[KAWANSOFT FRAMEWORK FAILURE]" string.
*
* Example:
*
*
* // Define URL of the path to the ServerSqlManager Servlet and prefix
* // it with with "jdbc:aceql:"
* // We will use a secure SSL/TLS session. All uploads/downloads of SQL
* // commands & data will be encrypted.
* String url = "jdbc:aceql:https://www.acme.org:9443/ServerSqlManager";
*
* // The login info for strong authentication on server side.
* // These are *not* the username/password of the remote JDBC Driver,
* // but are the auth info checked by remote
* // CommonsConfigurator.login(username, password) method.
* String username = "MyUsername";
* String password = "MyPsassword";
*
* // Required for Android, optional for others environments:
* Class.forName("org.kawanfw.sql.api.client.RemoteDriver");
*
* // Attempts to establish a connection to the remote database:
* Connection connection = DriverManager.getConnection(url, username, password);
*
* // We can now use our remote JDBC Connection as a regular JDBC
* // Connection for our queries and updates:
* String sql = "SELECT CUSTOMER_ID, FNAME, LNAME FROM CUSTOMER "
* + "WHERE CUSTOMER_ID = ?";
* PreparedStatement prepStatement = connection.prepareStatement(sql);
* prepStatement.setInt(1, 1);
*
* ResultSet rs = prepStatement.executeQuery();
* while (rs.next()) {
* String customerId = rs.getString("customer_id");
* String fname = rs.getString("fname");
* String lname = rs.getString("lname");
*
* System.out.println("customer_id: " + customerId);
* System.out.println("fname : " + fname);
* System.out.println("lname : " + lname);
* // Etc.
* }
*
*
*
*
* The following dedicated RemoteConnection methods are specific to
* the software and may be accessed with a cast:
*
* - {@link #clone}
* - {@link #getRemoteSession}
* - {@link #getSessionParameters}
* - {@link #getProxy}
* - {@link #getHttpStatusCode}
* - {@link #getMaxStatementsForMemoryTransport}
* - {@link #getUrl}
* - {@link #getUsername}
* - {@link #getVersion}
* - {@link #isEncryptStatementParameters}
* - {@link #isStatelessMode()}
* - {@link #setCancelled(AtomicBoolean)}
* - {@link #setEncryptStatementParameters}
* - {@link #setMaxStatementsForMemoryTransport}
* - {@link #setProgress(AtomicInteger)}
*
*
*
* All long Blobs update/reading that need to be run on a separated thread may
* be followed in Swing using a JProgressBar,
* ProgressMonitor or Android using a {@code ProgressDialog}
*
* This is done by sharing two atomic variables that will be declared as fields:
*
* - An {@code AtomicInteger} that represents the Blob/Clob transfer progress
* between 0 and 100.
* - An {@code AtomicBoolean} that says if the end user has cancelled the
* Blob/Clob transfer.
*
*
* The atomic variables values will be shared by AceQL download/upload processes
* and by the Progress Monitor used for the Progress Bar. The values are to be
* initialized and passed to {@code RemoteConnection} before the JDBC actions
* with the setters:
* {@link RemoteConnection#setProgress(AtomicInteger)}
* {@link RemoteConnection#setCancelled(AtomicBoolean)}
*
*
* Example:
*
*
* // Attempts to establish a connection to the remote database:
* Connection connection = DriverManager.getConnection(url, username, password);
*
* // Pass the mutable & sharable progress and canceled to the
* // underlying RemoteConnection.
* // - progress value will be updated by the RemoteConnection and
* // retrieved by progress monitors to increment the progress.
* // - cancelled value will be updated to true if user cancels the
* // task and RemoteConnection will interrupt the blob(s) transfer.
*
* ((RemoteConnection) connection).setProgress(progress);
* ((RemoteConnection) connection).setCancelled(cancelled);
*
* // Execute JDBC statement
*
*
*
See the source code of SqlProgressMonitorDemo.java that demonstrates the use of atomic
* variables when inserting a Blob.
*
* @author Nicolas de Pomereu
* @since 1.0
*
*/
public class RemoteConnection implements Connection {
/** The ConnectionHttp to wrap as clean as possible */
private ConnectionHttp connectionHttp = null;
/**
* Package protected class to be used only by
* {@link RemoteDriver#connect(String, Properties)}
*
* Creates a remote Connection with a proxy, http protocol
* parameters, and boolean to say if session is in Stateless Mode.
*
* @param url
* the URL of the path to the ServerSqlManager Servlet
* @param username
* the user username for authentication
* @param password
* the authentication password
* @param proxy
* the proxy to use, null for direct access
* @param passwordAuthentication
* the proxy credentials, null if no proxy or if the proxy does
* not require authentication
*
* @param sessionParameters
* the http protocol parameters to set (maybe null if none)
* @param statelessMode
* if true, session will be stateless.
* @param joinResultSetMetaData
* if true, ResultSet.getMetaData() will be downloaded along with
* ResultSet when a SELECT is sent to the server
* @throws IllegalArgumentException
* if url, username, password is null
*
* @throws SQLException
* if any Exception occurs. The
* SQLException wraps the original
* Exception that may be accessed using
* getCause()
*/
RemoteConnection(String url, String username, char[] password, Proxy proxy,
PasswordAuthentication passwordAuthentication,
SessionParameters sessionParameters, boolean statelessMode,
boolean joinResultSetMetaData) throws SQLException {
connectionHttp = new ConnectionHttp(url, username, password, proxy,
passwordAuthentication, sessionParameters, statelessMode,
joinResultSetMetaData);
}
// /**
// * Creates a remote Connection with a proxy, http protocol
// * parameters, and boolean to say if session is in Stateless Mode.
// *
// * @param url
// * the URL of the path to the ServerSqlManager Servlet
// * @param username
// * the user username for authentication
// * @param password
// * the authentication password
// * @param httpProxy
// * the proxy parameters (maybe null if none)
// * @param sessionParameters
// * the http protocol parameters to set (maybe null if none)
// * @param statelessMode
// * if true, session will be stateless.
// *
// * @throws IllegalArgumentException
// * if url, username, password is null
// *
// * @throws SQLException
// * if any Exception occurs. The
// * SQLException wraps the original
// * Exception that may be accessed using
// * getCause()
// * @deprecated As of version 2.7, replaced by
// * {@code DriverManager.getConnection(url, info)}.
// */
//
// public RemoteConnection(String url, String username, char[] password,
// HttpProxy httpProxy, SessionParameters sessionParameters,
// boolean statelessMode) throws SQLException {
//
// connectionHttp = new ConnectionHttp(url, username, password, httpProxy,
// sessionParameters, statelessMode, false);
// }
// /**
// * Creates a remote Connection with a proxy and http protocol
// * parameters.
// *
// * @param url
// * the URL of the path to the ServerSqlManager Servlet
// * @param username
// * the user username for authentication
// * @param password
// * the authentication password
// * @param httpProxy
// * the proxy parameters (maybe null if none)
// * @param sessionParameters
// * the http protocol parameters to set (maybe null if none)
// *
// * @throws IllegalArgumentException
// * if url, username, password is null
// *
// * @throws SQLException
// * if any Exception occurs. The
// * SQLException wraps the original
// * Exception that may be accessed using
// * getCause()
// * @deprecated As of version 2.7, replaced by
// * {@code DriverManager.getConnection(url, info)}.
// */
//
// @Deprecated
// public RemoteConnection(String url, String username, char[] password,
// HttpProxy httpProxy, SessionParameters sessionParameters)
// throws SQLException {
// this(url, username, password, httpProxy, sessionParameters, false);
//
// }
// /**
// * Creates a remote Connection with a proxy.
// *
// * @param url
// * the URL of the path to the ServerSqlManager Servlet
// * @param username
// * the user username for authentication
// * @param password
// * the authentication password
// * @param httpProxy
// * the proxy parameters (maybe null if none)
// *
// * @throws SQLException
// * if any Exception occurs. The
// * SQLException wraps the original
// * Exception that may be accessed using
// * getCause()
// * @deprecated As of version 2.7, replaced by
// * {@code DriverManager.getConnection(url, info)}.
// */
// @Deprecated
// public RemoteConnection(String url, String username, char[] password,
// HttpProxy httpProxy) throws SQLException {
// this(url, username, password, httpProxy, null);
// }
// /**
// * Creates a remote Connection.
// *
// * @param url
// * the URL of the path to the ServerSqlManager Servlet
// * @param username
// * the user username for authentication
// * @param password
// * the authentication password
// *
// * @throws SQLException
// * if any Exception occurs. The
// * SQLException wraps the original
// * Exception that may be accessed using
// * getCause()
// *
// * @deprecated As of version 2.7, replaced by
// * {@code DriverManager.getConnection(url, user, password)}.
// */
// @Deprecated
// public RemoteConnection(String url, String username, char[] password)
// throws SQLException {
// this(url, username, password, null, null);
// }
/**
* Private constructor for clone().
*
* @param url
* the URL of the path to the ServerSqlManager Servlet
* @param username
* the user username
* @param proxy
* the proxy to use, null for direct access
* @param passwordAuthentication
* the proxy credentials, null if no proxy or if the proxy does
* not require authentication
* @param sessionParameters
* the http protocol parameters to set (maybe null if none)
* @param statelessMode
* says if server is stateless
* @param joinResultSetMetaData
* if true, ResultSet.getMetaData() will be downloaded along with
* ResultSet when a SELECT is sent to the server
* @param fileSession
* the actual AceQL FILE Session
*/
private RemoteConnection(String url, String username, Proxy proxy,
PasswordAuthentication passwordAuthentication,
SessionParameters sessionParameters, RemoteSession remoteSession,
boolean statelessMode, boolean joinResultSetMetaData) {
connectionHttp = new ConnectionHttp(url, username, proxy,
passwordAuthentication, sessionParameters, remoteSession,
statelessMode, joinResultSetMetaData);
}
/**
* Sets the shareable canceled variable that will be used by the progress
* indicator to notify this instance that the end user has cancelled the
* current Blob/Clob upload or download.
*
* @param cancelled
* the shareable variable that will be used by the progress
* indicator to notify this instance that the end user has
* cancelled the current Blob/Clob upload or download
*
* @since 1.8
*/
public void setCancelled(AtomicBoolean cancelled) {
connectionHttp.setCancelled(cancelled);
}
/**
* Sets the shareable progress variable that will store Blob/Clob upload or
* download progress between 0 and 100. Will be used by progress indicators
* to display the progress.
*
* @param progress
* the shareable progress variable
*
* @since 1.8
*/
public void setProgress(AtomicInteger progress) {
connectionHttp.setProgress(progress);
}
/**
* 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 {
return this.connectionHttp.prepareCall(sql);
}
/**
* Method not implemented.
*
* 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 {
return this.connectionHttp.nativeSQL(sql);
}
/**
* 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
*/
@Override
public Statement createStatement() throws SQLException {
return this.connectionHttp.createStatement();
}
/**
* 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.
* The holdability of the created result sets can be determined by calling
* {@link #getHoldability}.
*
* @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, this method is called
* on a closed connection or the given parameters are not
* ResultSet constants indicating type and
* concurrency
* @exception SQLFeatureNotSupportedException
* if the JDBC driver does not support this method or this
* method is not supported for the specified result set type
* and result set concurrency.
* @since 1.2
*/
public Statement createStatement(int resultSetType, int resultSetConcurrency)
throws SQLException {
return this.connectionHttp.createStatement(resultSetType,
resultSetConcurrency);
}
/**
* 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, this method is called
* on a closed connection or the given parameters are not
* ResultSet constants indicating type,
* concurrency, and holdability
* @exception SQLFeatureNotSupportedException
* if the JDBC driver does not support this method or this
* method is not supported for the specified result set type,
* result set holdability and result set concurrency.
* @see ResultSet
* @since 1.4
*/
public Statement createStatement(int resultSetType,
int resultSetConcurrency, int resultSetHoldability)
throws SQLException {
return this.connectionHttp.createStatement(resultSetType,
resultSetConcurrency, resultSetHoldability);
}
/**
* 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 {
return this.connectionHttp.prepareStatement(sql);
}
/**
*
* 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.
* The holdability of the created result sets can be determined by calling
* {@link #getHoldability}.
*
* @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, this method is called
* on a closed connection or the given parameters are not
* ResultSet constants indicating type and
* concurrency
* @exception SQLFeatureNotSupportedException
* if the JDBC driver does not support this method or this
* method is not supported for the specified result set type
* and result set concurrency.
* @since 1.2
*/
public PreparedStatement prepareStatement(String sql, int resultSetType,
int resultSetConcurrency) throws SQLException {
return this.connectionHttp.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 {
return this.connectionHttp.prepareCall(sql, resultSetType,
resultSetConcurrency);
}
/**
* Method not implemented.
*
* 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 Map> getTypeMap() throws SQLException {
return this.connectionHttp.getTypeMap();
}
/**
* 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, this method is called
* on a closed connection or the given parameters are not
* ResultSet constants indicating type,
* concurrency, and holdability
* @exception SQLFeatureNotSupportedException
* if the JDBC driver does not support this method or this
* method is not supported for the specified result set type,
* result set holdability and result set concurrency.
* @see ResultSet
* @since 1.4
*/
public PreparedStatement prepareStatement(String sql, int resultSetType,
int resultSetConcurrency, int resultSetHoldability)
throws SQLException {
return this.connectionHttp.prepareStatement(sql, resultSetType,
resultSetConcurrency, resultSetHoldability);
}
/**
* Method not implemented.
*
* 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(Map> map) throws SQLException {
this.connectionHttp.setTypeMap(map);
}
/**
* 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 {
return this.connectionHttp.getAutoCommit();
}
/**
* 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 {
return this.connectionHttp.setSavepoint();
}
/**
* 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 {
this.connectionHttp.setAutoCommit(autoCommit);
}
/**
* 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 {
return this.connectionHttp.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 {
this.connectionHttp.rollback(savepoint);
}
/**
* 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 {
this.connectionHttp.commit();
}
/**
* 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 {
this.connectionHttp.releaseSavepoint(savepoint);
}
/**
* 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 {
this.connectionHttp.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.connectionHttp.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 {
return this.connectionHttp.isClosed();
}
/**
* 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 {
this.connectionHttp.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 {
return this.connectionHttp.isReadOnly();
}
/**
* 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 {
return this.connectionHttp.getMetaData();
}
/**
* 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 {
return this.connectionHttp.prepareCall(sql, resultSetType,
resultSetConcurrency, resultSetHoldability);
}
/**
* Sets the given catalog name in order to select a subspace of this
* Connection object's database in which to work.
*
* This version 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 {
this.connectionHttp.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 {
return this.connectionHttp.getCatalog();
}
/**
* 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, this method is called
* on a closed connection or the given parameter is not one
* of the Connection constants
* @see DatabaseMetaData#supportsTransactionIsolationLevel
* @see #getTransactionIsolation
*/
public void setTransactionIsolation(int level) throws SQLException {
this.connectionHttp.setTransactionIsolation(level);
}
/**
* Creates a default PreparedStatement object that has the
* capability to retrieve auto-generated keys. Method not implemented .
* 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 {
return this.connectionHttp.prepareStatement(sql, autoGeneratedKeys);
}
/**
* Returns null.
*
* @return null
* @exception SQLException
* if a database access error occurs or this method is called
* on a closed connection
* @see SQLWarning
*/
public SQLWarning getWarnings() throws SQLException {
return this.connectionHttp.getWarnings();
}
/**
* 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 {
return this.connectionHttp.prepareStatement(sql, columnIndexes);
}
/**
* Does nothing.
*
* @exception SQLException
* if a database access error occurs
*/
public void clearWarnings() throws SQLException {
this.connectionHttp.clearWarnings();
}
/**
* 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 or this method is called
* on a closed connection
* @see #setTransactionIsolation
*/
public int getTransactionIsolation() throws SQLException {
return this.connectionHttp.getTransactionIsolation();
}
/**
* Changes the default holdability of ResultSet objects created
* using this Connection object to the given holdability. The
* default holdability of ResultSet objects can be be
* determined by invoking {@link DatabaseMetaData#getResultSetHoldability}.
*
* @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, this method is called on a
* closed connection, or the given parameter is not a
* ResultSet constant indicating holdability
* @exception SQLFeatureNotSupportedException
* if the given holdability is not supported
* @see #getHoldability
* @see DatabaseMetaData#getResultSetHoldability
* @see ResultSet
* @since 1.4
*/
public void setHoldability(int holdability) throws SQLException {
this.connectionHttp.setHoldability(holdability);
}
/**
* 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 {
return this.connectionHttp.prepareStatement(sql, columnNames);
}
/**
* 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 error occurs or this method is called on
* a closed connection
* @see #setHoldability
* @see DatabaseMetaData#getResultSetHoldability
* @see ResultSet
* @since 1.4
*/
public int getHoldability() throws SQLException {
return this.connectionHttp.getHoldability();
}
/**
* 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 {
return this.connectionHttp.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 {
return this.connectionHttp.createClob();
}
/**
* Method not implemented.
*
* 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 {
return this.connectionHttp.createNClob();
}
/**
* Method not implemented.
*
* 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 {
return this.connectionHttp.createSQLXML();
}
/**
* Method not implemented.
*
* 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 {
return this.connectionHttp.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 {
return this.connectionHttp.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 {
return this.connectionHttp.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 {
return this.connectionHttp.isValid(timeout);
}
/**
* Method not implemented.
*
* 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 {
return this.connectionHttp.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 {
this.connectionHttp.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 {
this.connectionHttp.setClientInfo(name, value);
}
/**
* Method not implemented.
*
* 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 {
return this.connectionHttp.unwrap(iface);
}
/**
* 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 {
return this.connectionHttp.createArrayOf(typeName, elements);
}
//
// Utility dedicated methods for raw ConnectionHttp class that are not
// Connection
//
/**
* Returns the current Version.
*
* @return the current Version
*/
public String getVersion() {
return this.connectionHttp.getVersion();
}
/**
* Allows to get a copy of the current RemoteConnection: use it
* to do some simultaneous operations in a different thread (in order to
* avoid conflicts).
*/
@Override
public Connection clone() {
Connection connection = new RemoteConnection(this.getUrl(),
this.getUsername(), this.getProxy(),
this.getPasswordAuthentication(), this.getSessionParameters(),
this.getRemoteSession(), this.connectionHttp.isStatelessMode(),
this.connectionHttp.isJoinResultSetMetaData());
return connection;
}
/**
* Returns the http status code of the last executed JDBC command that
* called the remote Server SQL Manager.
*
* @return the http status code of the last executed JDBC command that
* called the remote Server SQL Manager. 0 means the status could
* not be returned.
*/
public int getHttpStatusCode() {
return this.connectionHttp.getHttpStatusCode();
}
/**
* Returns the URL of the path to the ServerSqlManager Servlet.
*
* @return the URL of the path to the ServerSqlManager Servlet
*/
public String getUrl() {
return this.connectionHttp.getUrl();
}
/**
* Returns the username in use.
*
* @return the username in use
*/
public String getUsername() {
return this.connectionHttp.getUsername();
}
/**
* Gets the current RemoteSession instance (used for file
* transfers of Clobs and Blobs).
*
*
* @return the fileSession instance (to be used for file transfers, per
* example)
*/
public RemoteSession getRemoteSession() {
return this.connectionHttp.getRemoteSession();
}
/**
* Returns true if the statement parameters are to be encrypted.
*
* @return true if the statement parameters are to be encrypted. (Default to
* false).
*/
public boolean isEncryptStatementParameters() {
return this.connectionHttp.isEncryptStatementParameters();
}
/**
* Set if the statement parameters are to be encrypted
*
* @param encryptStatementParameters
* true if the statement parameters are to be encrypted, else
* false
*/
public void setEncryptStatementParameters(boolean encryptStatementParameters) {
this.connectionHttp
.setEncryptStatementParameters(encryptStatementParameters);
}
/**
* Returns the SessionParameters instance in use for the
* session.
*
* @return the SessionParameters instance in use for the
* session
*/
public SessionParameters getSessionParameters() {
return this.connectionHttp.getSessionParameters();
}
/**
* Returns the {@code Proxy} instance in use for this File Session.
*
* @return the {@code Proxy} instance in use for this File Session
*/
public Proxy getProxy() {
return this.connectionHttp.getProxy();
}
/**
* Returns the proxy credentials
*
* @return the proxy credentials
*/
public PasswordAuthentication getPasswordAuthentication() {
return this.connectionHttp.getPasswordAuthentication();
}
/**
* Returns the maximum Number Of Statements that may be transported in
* memory. If maximum is reached, transport is done using a file.
*
* @return the maximum Number Of Statements that may be transported in
* memory.
*/
public int getMaxStatementsForMemoryTransport() {
return this.connectionHttp.getMaxStatementsForMemoryTransport();
}
/**
* Sets the maximum Number Of Statements that may be transported in memory
* from client to server. if maximum is reached, transport is done using a
* file.
*
* @param maxStatementsForMemoryTransport
* the maximum Number Of Statements that may be transported in
* memory.
*
*/
public void setMaxStatementsForMemoryTransport(
int maxStatementsForMemoryTransport) {
this.connectionHttp
.setMaxStatementsForMemoryTransport(maxStatementsForMemoryTransport);
}
/**
* Says if session is in stateless mode when connecting to the server.
*
* @return true if session is in stateless mode when connecting to the
* server
*/
public boolean isStatelessMode() {
return connectionHttp.isStatelessMode();
}
// /////////////////////////////////////////////////////////
// JAVA 7 METHOD EMULATION //
// /////////////////////////////////////////////////////////
/**
* Method not implemented.
*
* Terminates an open connection. Calling abort results in:
*
* - The connection marked as closed
*
- Closes any physical connection to the database
*
- Releases resources used by the connection
*
- Insures that any thread that is currently accessing the connection
* will either progress to completion or throw an
SQLException.
*
*
* Calling abort marks the connection closed and releases any
* resources. Calling abort on a closed connection is a no-op.
*
* It is possible that the aborting and releasing of the resources that are
* held by the connection can take an extended period of time. When the
* abort method returns, the connection will have been marked
* as closed and the Executor that was passed as a parameter to
* abort may still be executing tasks to release resources.
*
* This method checks to see that there is an SQLPermission
* object before allowing the method to proceed. If a
* SecurityManager exists and its checkPermission
* method denies calling abort, this method throws a
* java.lang.SecurityException.
*
* @param executor
* The Executor implementation which will be used by
* abort.
* @throws java.sql.SQLException
* if a database access error occurs or the {@code executor} is
* {@code null},
* @throws java.lang.SecurityException
* if a security manager exists and its
* checkPermission method denies calling
* abort
* @see SecurityManager#checkPermission
* @see Executor
* @since 1.7
*/
public void abort(Executor executor) throws SQLException {
this.connectionHttp.abort(executor);
}
/**
* Method not implemented.
*
* Retrieves the number of milliseconds the driver will wait for a database
* request to complete. If the limit is exceeded, a
* SQLException is thrown.
*
* @return the current timeout limit in milliseconds; zero means there is no
* limit
* @throws SQLException
* if a database access error occurs or this method is called on
* a closed Connection
* @exception SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @see #setNetworkTimeout
* @since 1.7
*/
public int getNetworkTimeout() throws SQLException {
return this.connectionHttp.getNetworkTimeout();
}
/**
* Method not implemented.
*
* Retrieves this Connection object's current schema name.
*
* @return the current schema name or null if there is none
* @exception SQLException
* if a database access error occurs or this method is called
* on a closed connection
* @see #setSchema
* @since 1.7
*/
public String getSchema() throws SQLException {
return this.connectionHttp.getSchema();
}
/**
* Method not implemented.
*
* Sets the maximum period a Connection or objects created from
* the Connection will wait for the database to reply to any
* one request. If any request remains unanswered, the waiting method will
* return with a SQLException, and the Connection
* or objects created from the Connection will be marked as
* closed. Any subsequent use of the objects, with the exception of the
* close, isClosed or
* Connection.isValid methods, will result in a
* SQLException.
*
* Note: This method is intended to address a rare but serious
* condition where network partitions can cause threads issuing JDBC calls
* to hang uninterruptedly in socket reads, until the OS TCP-TIMEOUT
* (typically 10 minutes). This method is related to the {@link #abort
* abort() } method which provides an administrator thread a means to free
* any such threads in cases where the JDBC connection is accessible to the
* administrator thread. The setNetworkTimeout method will
* cover cases where there is no administrator thread, or it has no access
* to the connection. This method is severe in it's effects, and should be
* given a high enough value so it is never triggered before any more normal
* timeouts, such as transaction timeouts.
*
* JDBC driver implementations may also choose to support the
* {@code setNetworkTimeout} method to impose a limit on database response
* time, in environments where no network is present.
*
* Drivers may internally implement some or all of their API calls with
* multiple internal driver-database transmissions, and it is left to the
* driver implementation to determine whether the limit will be applied
* always to the response to the API call, or to any single request made
* during the API call.
*
*
* This method can be invoked more than once, such as to set a limit for an
* area of JDBC code, and to reset to the default on exit from this area.
* Invocation of this method has no impact on already outstanding requests.
*
* The {@code Statement.setQueryTimeout()} timeout value is independent of
* the timeout value specified in {@code setNetworkTimeout}. If the query
* timeout expires before the network timeout then the statement execution
* will be canceled. If the network is still active the result will be that
* both the statement and connection are still usable. However if the
* network timeout expires before the query timeout or if the statement
* timeout fails due to network problems, the connection will be marked as
* closed, any resources held by the connection will be released and both
* the connection and statement will be unusable.
*
* When the driver determines that the {@code setNetworkTimeout} timeout
* value has expired, the JDBC driver marks the connection closed and
* releases any resources held by the connection.
*
*
* This method checks to see that there is an SQLPermission
* object before allowing the method to proceed. If a
* SecurityManager exists and its checkPermission
* method denies calling setNetworkTimeout, this method throws
* a java.lang.SecurityException.
*
* @param executor
* The Executor implementation which will be used by
* setNetworkTimeout.
* @param milliseconds
* The time in milliseconds to wait for the database operation to
* complete. If the JDBC driver does not support milliseconds,
* the JDBC driver will round the value up to the nearest second.
* If the timeout period expires before the operation completes,
* a SQLException will be thrown. A value of 0 indicates that
* there is not timeout for database operations.
* @throws java.sql.SQLException
* if a database access error occurs, this method is called on a
* closed connection, the {@code executor} is {@code null}, or
* the value specified for seconds is less than 0.
* @throws java.lang.SecurityException
* if a security manager exists and its
* checkPermission method denies calling
* setNetworkTimeout.
* @exception SQLFeatureNotSupportedException
* if the JDBC driver does not support this method
* @see SecurityManager#checkPermission
* @see Statement#setQueryTimeout
* @see #getNetworkTimeout
* @see #abort
* @see Executor
* @since 1.7
*/
public void setNetworkTimeout(Executor executor, int milliseconds)
throws SQLException {
this.connectionHttp.setNetworkTimeout(executor, milliseconds);
}
/**
* Method not implemented.
*
* Sets the given schema name to access.
*
* If the driver does not support schemas, it will silently ignore this
* request.
*
* Calling {@code setSchema} has no effect on previously created or prepared
* {@code Statement} objects. It is implementation defined whether a DBMS
* prepare operation takes place immediately when the {@code Connection}
* method {@code prepareStatement} or {@code prepareCall} is invoked. For
* maximum portability, {@code setSchema} should be called before a
* {@code Statement} is created or prepared.
*
* @param schema
* the name of a schema in which to work
* @exception SQLException
* if a database access error occurs or this method is called
* on a closed connection
* @see #getSchema
* @since 1.7
*/
public void setSchema(String schema) throws SQLException {
this.connectionHttp.setSchema(schema);
}
}