src-main.org.awakefw.commons.jdbc.abstracts.AbstractStatement 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.BatchUpdateException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Statement;
/**
* Statement Wrapper.
* Implements all the Statement methods. Usage is exactly the same as a
* Statement.
*
*/
public class AbstractStatement implements Statement {
/** The Statement */
private Statement statement = null;
/** Flag that says the caller is ConnectionHttp */
private boolean isConnectionHttp = false;
/**
* Set to true if the user has closed the connection by a explicit call to
* close()
*/
private boolean isClosed = false;
/**
* Void Constructor
*
* Needed for HTTP usage because there is no real JDBC Connection
*/
public AbstractStatement() {
isConnectionHttp = true;
}
/**
* Constructor
*
* @param statement
* actual statement in use to wrap
*/
public AbstractStatement(Statement statement) throws SQLException {
this.statement = statement;
}
/**
* Will throw a SQL Exception if calling method is not authorized
**/
private void verifyCallAuthorization(String methodName) throws SQLException {
if (isClosed) {
throw new SQLException("Statement is closed.");
}
if (isConnectionHttp) {
throw new SQLException(
AbstractConnection.FEATURE_NOT_SUPPORTED_IN_THIS_VERSION
+ methodName);
}
}
/**
* Executes the given SQL statement, which returns a single
* ResultSet object.
*
* @param sql
* an SQL statement to be sent to the database, typically a
* static SQL SELECT statement
* @return a ResultSet object that contains the data produced
* by the given query; never null
* @exception SQLException
* if a database access error occurs or the given SQL
* statement produces anything other than a single
* ResultSet object
*/
public ResultSet executeQuery(String sql) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.executeQuery(sql);
}
/**
* Executes the given SQL statement, which may be an INSERT,
* UPDATE, or DELETE statement or an SQL statement
* that returns nothing, such as an SQL DDL statement.
*
* @param sql
* an SQL INSERT, UPDATE or
* DELETE statement or an SQL statement that returns
* nothing
* @return either the row count for INSERT, UPDATE
* or DELETE statements, or 0 for SQL
* statements that return nothing
* @exception SQLException
* if a database access error occurs or the given SQL
* statement produces a ResultSet object
*/
public int executeUpdate(String sql) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.executeUpdate(sql);
}
/**
* Releases this Statement object's database and JDBC resources
* immediately instead of waiting for this to happen when it is
* automatically closed. It is generally good practice to release resources
* as soon as you are finished with them to avoid tying up database
* resources.
*
* Calling the method close on a Statement object
* that is already closed has no effect.
*
* Note: A Statement object is automatically closed when
* it is garbage collected. When a Statement object is closed,
* its current ResultSet object, if one exists, is also closed.
*
* @exception SQLException
* if a database access error occurs
*/
public void close() throws SQLException {
isClosed = true;
}
// ----------------------------------------------------------------------
/**
* Retrieves the maximum number of bytes that can be returned for character
* and binary column values in a ResultSet object produced by
* this Statement object. This limit applies only to
* BINARY, VARBINARY, LONGVARBINARY,
* CHAR, VARCHAR, and LONGVARCHAR
* columns. If the limit is exceeded, the excess data is silently discarded.
*
* @return the current column size limit for columns storing character and
* binary values; zero means there is no limit
* @exception SQLException
* if a database access error occurs
* @see #setMaxFieldSize
*/
public int getMaxFieldSize() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getMaxFieldSize();
}
/**
* Sets the limit for the maximum number of bytes in a
* ResultSet column storing character or binary values to the
* given number of bytes. This limit applies only to BINARY,
* VARBINARY, LONGVARBINARY, CHAR,
* VARCHAR, and LONGVARCHAR fields. If the limit
* is exceeded, the excess data is silently discarded. For maximum
* portability, use values greater than 256.
*
* @param max
* the new column size limit in bytes; zero means there is no
* limit
* @exception SQLException
* if a database access error occurs or the condition max >=
* 0 is not satisfied
* @see #getMaxFieldSize
*/
public void setMaxFieldSize(int max) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.statement.setMaxFieldSize(max);
}
/**
* Retrieves the maximum number of rows that a ResultSet object
* produced by this Statement object can contain. If this limit
* is exceeded, the excess rows are silently dropped.
*
* @return the current maximum number of rows for a ResultSet
* object produced by this Statement object; zero means
* there is no limit
* @exception SQLException
* if a database access error occurs
* @see #setMaxRows
*/
public int getMaxRows() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getMaxRows();
}
/**
* Sets the limit for the maximum number of rows that any
* ResultSet object can contain to the given number. If the
* limit is exceeded, the excess rows are silently dropped.
*
* @param max
* the new max rows limit; zero means there is no limit
* @exception SQLException
* if a database access error occurs or the condition max >=
* 0 is not satisfied
* @see #getMaxRows
*/
public void setMaxRows(int max) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.statement.setMaxRows(max);
}
/**
* Sets escape processing on or off. If escape scanning is on (the default),
* the driver will do escape substitution before sending the SQL statement
* to the database.
*
* Note: Since prepared statements have usually been parsed prior to making
* this call, disabling escape processing for
* PreparedStatements objects will have no effect.
*
* @param enable
* true to enable escape processing;
* false to disable it
* @exception SQLException
* if a database access error occurs
*/
public void setEscapeProcessing(boolean enable) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.statement.setEscapeProcessing(enable);
}
/**
* Retrieves the number of seconds the driver will wait for a
* Statement object to execute. If the limit is exceeded, a
* SQLException is thrown.
*
* @return the current query timeout limit in seconds; zero means there is
* no limit
* @exception SQLException
* if a database access error occurs
* @see #setQueryTimeout
*/
public int getQueryTimeout() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getQueryTimeout();
}
/**
* Sets the number of seconds the driver will wait for a
* Statement object to execute to the given number of seconds.
* If the limit is exceeded, an SQLException is thrown.
*
* @param seconds
* the new query timeout limit in seconds; zero means there is no
* limit
* @exception SQLException
* if a database access error occurs or the condition seconds
* >= 0 is not satisfied
* @see #getQueryTimeout
*/
public void setQueryTimeout(int seconds) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.statement.setQueryTimeout(seconds);
}
/**
* Cancels this Statement object if both the DBMS and driver
* support aborting an SQL statement. This method can be used by one thread
* to cancel a statement that is being executed by another thread.
*
* @exception SQLException
* if a database access error occurs
*/
public void cancel() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.statement.cancel();
}
/**
* Retrieves the first warning reported by calls on this
* Statement object. Subsequent Statement object
* warnings will be chained to this SQLWarning object.
*
*
* The warning chain is automatically cleared each time a statement is
* (re)executed. This method may not be called on a closed
* Statement object; doing so will cause an
* SQLException to be thrown.
*
*
* Note: If you are processing a ResultSet object, any
* warnings associated with reads on that ResultSet object will
* be chained on it rather than on the Statement object that
* produced it.
*
* @return the first SQLWarning object or null if
* there are no warnings
* @exception SQLException
* if a database access error occurs or this method is called
* on a closed statement
*/
public SQLWarning getWarnings() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getWarnings();
}
/**
* Clears all the warnings reported on this Statement object.
* After a call to this method, the method getWarnings will
* return null until a new warning is reported for this
* Statement object.
*
* @exception SQLException
* if a database access error occurs
*/
public void clearWarnings() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.statement.clearWarnings();
}
/**
* Sets the SQL cursor name to the given String, which will be
* used by subsequent Statement object execute
* methods. This name can then be used in SQL positioned update or delete
* statements to identify the current row in the ResultSet
* object generated by this statement. If the database does not support
* positioned update/delete, this method is a noop. To insure that a cursor
* has the proper isolation level to support updates, the cursor's
* SELECT statement should have the form
* SELECT FOR UPDATE. If FOR UPDATE is not
* present, positioned updates may fail.
*
*
* Note: By definition, the execution of positioned updates and
* deletes must be done by a different Statement object than
* the one that generated the ResultSet object being used for
* positioning. Also, cursor names must be unique within a connection.
*
* @param name
* the new cursor name, which must be unique within a connection
* @exception SQLException
* if a database access error occurs
*/
public void setCursorName(String name) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.statement.setCursorName(name);
}
// ----------------------- Multiple Results --------------------------
/**
* Executes the given SQL statement, which may return multiple results. In
* some (uncommon) situations, a single SQL statement may return multiple
* result sets and/or update counts. Normally you can ignore this unless you
* are (1) executing a stored procedure that you know may return multiple
* results or (2) you are dynamically executing an unknown SQL string.
*
* The execute method executes an SQL statement and indicates
* the form of the first result. You must then use the methods
* getResultSet or getUpdateCount to retrieve the
* result, and getMoreResults to move to any subsequent
* result(s).
*
* @param sql
* any SQL statement
* @return true if the first result is a ResultSet
* object; false if it is an update count or there are
* no results
* @exception SQLException
* if a database access error occurs
* @see #getResultSet
* @see #getUpdateCount
* @see #getMoreResults
*/
public boolean execute(String sql) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.execute(sql);
}
/**
* Retrieves the current result as a ResultSet object. This
* method should be called only once per result.
*
* @return the current result as a ResultSet object or
* null if the result is an update count or there are
* no more results
* @exception SQLException
* if a database access error occurs
* @see #execute
*/
public ResultSet getResultSet() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getResultSet();
}
/**
* Retrieves the current result as an update count; if the result is a
* ResultSet object or there are no more results, -1 is
* returned. This method should be called only once per result.
*
* @return the current result as an update count; -1 if the current result
* is a ResultSet object or there are no more results
* @exception SQLException
* if a database access error occurs
* @see #execute
*/
public int getUpdateCount() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getUpdateCount();
}
/**
* Moves to this Statement object's next result, returns
* true if it is a ResultSet object, and
* implicitly closes any current ResultSet object(s) obtained
* with the method getResultSet.
*
*
* There are no more results when the following is true:
*
*
* (!getMoreResults() && (getUpdateCount() == -1)
*
*
* @return true if the next result is a ResultSet
* object; false if it is an update count or there are
* no more results
* @exception SQLException
* if a database access error occurs
* @see #execute
*/
public boolean getMoreResults() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getMoreResults();
}
// --------------------------JDBC 2.0-----------------------------
/**
* Gives the driver a hint as to the direction in which rows will be
* processed in ResultSet objects created using this
* Statement object. The default value is
* ResultSet.FETCH_FORWARD.
*
* Note that this method sets the default fetch direction for result sets
* generated by this Statement object. Each result set has its
* own methods for getting and setting its own fetch direction.
*
* @param direction
* the initial direction for processing rows
* @exception SQLException
* if a database access error occurs or the given direction
* is not one of ResultSet.FETCH_FORWARD,
* ResultSet.FETCH_REVERSE, or
* ResultSet.FETCH_UNKNOWN
* @since 1.2
* @see #getFetchDirection
*/
public void setFetchDirection(int direction) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.statement.setFetchDirection(direction);
}
/**
* Retrieves the direction for fetching rows from database tables that is
* the default for result sets generated from this Statement
* object. If this Statement object has not set a fetch
* direction by calling the method setFetchDirection, the
* return value is implementation-specific.
*
* @return the default fetch direction for result sets generated from this
* Statement object
* @exception SQLException
* if a database access error occurs
* @since 1.2
* @see #setFetchDirection
*/
public int getFetchDirection() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getFetchDirection();
}
/**
* Gives the JDBC driver a hint as to the number of rows that should be
* fetched from the database when more rows are needed. The number of rows
* specified affects only result sets created using this statement. If the
* value specified is zero, then the hint is ignored. The default value is
* zero.
*
* @param rows
* the number of rows to fetch
* @exception SQLException
* if a database access error occurs, or the condition 0 <=
* rows <= this.getMaxRows() is not
* satisfied.
* @since 1.2
* @see #getFetchSize
*/
public void setFetchSize(int rows) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.statement.setFetchSize(rows);
}
/**
* Retrieves the number of result set rows that is the default fetch size
* for ResultSet objects generated from this
* Statement object. If this Statement object has
* not set a fetch size by calling the method setFetchSize, the
* return value is implementation-specific.
*
* @return the default fetch size for result sets generated from this
* Statement object
* @exception SQLException
* if a database access error occurs
* @since 1.2
* @see #setFetchSize
*/
public int getFetchSize() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getFetchSize();
}
/**
* Retrieves the result set concurrency for ResultSet objects
* generated by this Statement object.
*
* @return either ResultSet.CONCUR_READ_ONLY or
* ResultSet.CONCUR_UPDATABLE
* @exception SQLException
* if a database access error occurs
* @since 1.2
*/
public int getResultSetConcurrency() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getResultSetConcurrency();
}
/**
* Retrieves the result set type for ResultSet objects
* generated by this Statement object.
*
* @return one of ResultSet.TYPE_FORWARD_ONLY,
* ResultSet.TYPE_SCROLL_INSENSITIVE, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @exception SQLException
* if a database access error occurs
* @since 1.2
*/
public int getResultSetType() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getResultSetType();
}
/**
* Adds the given SQL command to the current list of commmands for this
* Statement object. The commands in this list can be executed
* as a batch by calling the method executeBatch.
*
* NOTE: This method is optional.
*
* @param sql
* typically this is a static SQL INSERT or
* UPDATE statement
* @exception SQLException
* if a database access error occurs, or the driver does not
* support batch updates
* @see #executeBatch
* @since 1.2
*/
public void addBatch(String sql) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.statement.addBatch(sql);
}
/**
* Empties this Statement object's current list of SQL
* commands.
*
* NOTE: This method is optional.
*
* @exception SQLException
* if a database access error occurs or the driver does not
* support batch updates
* @see #addBatch
* @since 1.2
*/
public void clearBatch() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
this.statement.clearBatch();
}
/**
* Submits a batch of commands to the database for execution and if all
* commands execute successfully, returns an array of update counts. The
* int elements of the array that is returned are ordered to
* correspond to the commands in the batch, which are ordered according to
* the order in which they were added to the batch. The elements in the
* array returned by the method executeBatch may be one of the
* following:
*
* - A number greater than or equal to zero -- indicates that the command
* was processed successfully and is an update count giving the number of
* rows in the database that were affected by the command's execution
*
- A value of
SUCCESS_NO_INFO -- indicates that the command
* was processed successfully but that the number of rows affected is
* unknown
*
* If one of the commands in a batch update fails to execute properly, this
* method throws a BatchUpdateException, and a JDBC driver may
* or may not continue to process the remaining commands in the batch.
* However, the driver's behavior must be consistent with a particular DBMS,
* either always continuing to process commands or never continuing to
* process commands. If the driver continues processing after a failure, the
* array returned by the method
* BatchUpdateException.getUpdateCounts will contain as many
* elements as there are commands in the batch, and at least one of the
* elements will be the following:
*
*
- A value of
EXECUTE_FAILED -- indicates that the command
* failed to execute successfully and occurs only if a driver continues to
* process commands after a command fails
*
*
* A driver is not required to implement this method. The possible
* implementations and return values have been modified in the Java 2 SDK,
* Standard Edition, version 1.3 to accommodate the option of continuing to
* proccess commands in a batch update after a
* BatchUpdateException obejct has been thrown.
*
* @return an array of update counts containing one element for each command
* in the batch. The elements of the array are ordered according to
* the order in which commands were added to the batch.
* @exception SQLException
* if a database access error occurs or the driver does not
* support batch statements. Throws
* {@link BatchUpdateException} (a subclass of
* SQLException) if one of the commands sent to
* the database fails to execute properly or attempts to
* return a result set.
* @since 1.3
*/
public int[] executeBatch() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.executeBatch();
}
/**
* Retrieves the Connection object that produced this
* Statement object.
*
* @return the connection that produced this statement
* @exception SQLException
* if a database access error occurs
* @since 1.2
*/
public Connection getConnection() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getConnection();
}
// --------------------------JDBC 3.0-----------------------------
/**
* The constant indicating that the current ResultSet object
* should be closed when calling getMoreResults.
*
* @since 1.4
*/
public int CLOSE_CURRENT_RESULT = 1;
/**
* The constant indicating that the current ResultSet object
* should not be closed when calling getMoreResults.
*
* @since 1.4
*/
public int KEEP_CURRENT_RESULT = 2;
/**
* The constant indicating that all ResultSet objects that have
* previously been kept open should be closed when calling
* getMoreResults.
*
* @since 1.4
*/
public int CLOSE_ALL_RESULTS = 3;
/**
* The constant indicating that a batch statement executed successfully but
* that no count of the number of rows it affected is available.
*
* @since 1.4
*/
public int SUCCESS_NO_INFO = -2;
/**
* The constant indicating that an error occured while executing a batch
* statement.
*
* @since 1.4
*/
public int EXECUTE_FAILED = -3;
/**
* The constant indicating that generated keys should be made available for
* retrieval.
*
* @since 1.4
*/
public int RETURN_GENERATED_KEYS = 1;
/**
* The constant indicating that generated keys should not be made available
* for retrieval.
*
* @since 1.4
*/
public int NO_GENERATED_KEYS = 2;
/**
* Moves to this Statement object's next result, deals with any
* current ResultSet object(s) according to the instructions
* specified by the given flag, and returns true if the next
* result is a ResultSet object.
*
*
* There are no more results when the following is true:
*
*
* (!getMoreResults() && (getUpdateCount() == -1)
*
*
* @param current
* one of the following Statement constants
* indicating what should happen to current
* ResultSet objects obtained using the method
* getResultSetCLOSE_CURRENT_RESULT,
* KEEP_CURRENT_RESULT, or
* CLOSE_ALL_RESULTS
* @return true if the next result is a ResultSet
* object; false if it is an update count or there are
* no more results
* @exception SQLException
* if a database access error occurs
* @since 1.4
* @see #execute
*/
public boolean getMoreResults(int current) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getMoreResults(current);
}
/**
* Retrieves any auto-generated keys created as a result of executing this
* Statement object. If this Statement object did
* not generate any keys, an empty ResultSet object is
* returned.
*
* @return a ResultSet object containing the auto-generated
* key(s) generated by the execution of this Statement
* object
* @exception SQLException
* if a database access error occurs
* @since 1.4
*/
public ResultSet getGeneratedKeys() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getGeneratedKeys();
}
/**
* Executes the given SQL statement and signals the driver with the given
* flag about whether the auto-generated keys produced by this
* Statement object should be made available for retrieval.
*
* @param sql
* must be an SQL INSERT, UPDATE or
* DELETE statement or an SQL statement that returns
* nothing
* @param autoGeneratedKeys
* a flag indicating whether auto-generated keys should be made
* available for retrieval; one of the following constants:
* Statement.RETURN_GENERATED_KEYS
* Statement.NO_GENERATED_KEYS
* @return either the row count for INSERT, UPDATE
* or DELETE statements, or 0 for SQL
* statements that return nothing
* @exception SQLException
* if a database access error occurs, the given SQL statement
* returns a ResultSet object, or the given
* constant is not one of those allowed
* @since 1.4
*/
public int executeUpdate(String sql, int autoGeneratedKeys)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.executeUpdate(sql, autoGeneratedKeys);
}
/**
* Executes the given SQL statement and signals the driver that the
* auto-generated keys indicated in the given array should be made available
* for retrieval. The driver will ignore the array if the SQL statement is
* not an INSERT statement.
*
* @param sql
* an SQL INSERT, UPDATE or
* DELETE statement or an SQL statement that returns
* nothing, such as an SQL DDL statement
* @param columnIndexes
* an array of column indexes indicating the columns that should
* be returned from the inserted row
* @return either the row count for INSERT, UPDATE
* , or DELETE statements, or 0 for SQL statements that
* return nothing
* @exception SQLException
* if a database access error occurs or the SQL statement
* returns a ResultSet object
* @since 1.4
*/
public int executeUpdate(String sql, int[] columnIndexes)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.executeUpdate(sql, columnIndexes);
}
/**
* Executes the given SQL statement and signals the driver that the
* auto-generated keys indicated in the given array should be made available
* for retrieval. The driver will ignore the array if the SQL statement is
* not an INSERT statement.
*
* @param sql
* an SQL INSERT, UPDATE or
* DELETE statement or an SQL statement that returns
* nothing
* @param columnNames
* an array of the names of the columns that should be returned
* from the inserted row
* @return either the row count for INSERT, UPDATE
* , or DELETE statements, or 0 for SQL statements that
* return nothing
* @exception SQLException
* if a database access error occurs
*
* @since 1.4
*/
public int executeUpdate(String sql, String[] columnNames)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.executeUpdate(sql, columnNames);
}
/**
* Executes the given SQL statement, which may return multiple results, and
* signals the driver that any auto-generated keys should be made available
* for retrieval. The driver will ignore this signal if the SQL statement is
* not an INSERT statement.
*
* In some (uncommon) situations, a single SQL statement may return multiple
* result sets and/or update counts. Normally you can ignore this unless you
* are (1) executing a stored procedure that you know may return multiple
* results or (2) you are dynamically executing an unknown SQL string.
*
* The execute method executes an SQL statement and indicates
* the form of the first result. You must then use the methods
* getResultSet or getUpdateCount to retrieve the
* result, and getMoreResults to move to any subsequent
* result(s).
*
* @param sql
* any SQL statement
* @param autoGeneratedKeys
* a constant indicating whether auto-generated keys should be
* made available for retrieval using the method
* getGeneratedKeys; one of the following constants:
* Statement.RETURN_GENERATED_KEYS or
* Statement.NO_GENERATED_KEYS
* @return true if the first result is a ResultSet
* object; false if it is an update count or there are
* no results
* @exception SQLException
* if a database access error occurs
* @see #getResultSet
* @see #getUpdateCount
* @see #getMoreResults
* @see #getGeneratedKeys
*
* @since 1.4
*/
public boolean execute(String sql, int autoGeneratedKeys)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.execute(sql, autoGeneratedKeys);
}
/**
* Executes the given SQL statement, which may return multiple results, and
* signals the driver that the auto-generated keys indicated in the given
* array should be made available for retrieval. This array contains the
* indexes of the columns in the target table that contain the
* auto-generated keys that should be made available. The driver will ignore
* the array if the given SQL statement is not an INSERT
* statement.
*
* Under some (uncommon) situations, a single SQL statement may return
* multiple result sets and/or update counts. Normally you can ignore this
* unless you are (1) executing a stored procedure that you know may return
* multiple results or (2) you are dynamically executing an unknown SQL
* string.
*
* The execute method executes an SQL statement and indicates
* the form of the first result. You must then use the methods
* getResultSet or getUpdateCount to retrieve the
* result, and getMoreResults to move to any subsequent
* result(s).
*
* @param sql
* any SQL statement
* @param columnIndexes
* an array of the indexes of the columns in the inserted row
* that should be made available for retrieval by a call to the
* method getGeneratedKeys
* @return true if the first result is a ResultSet
* object; false if it is an update count or there are
* no results
* @exception SQLException
* if a database access error occurs
* @see #getResultSet
* @see #getUpdateCount
* @see #getMoreResults
*
* @since 1.4
*/
public boolean execute(String sql, int[] columnIndexes) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.execute(sql, columnIndexes);
}
/**
* Executes the given SQL statement, which may return multiple results, and
* signals the driver that the auto-generated keys indicated in the given
* array should be made available for retrieval. This array contains the
* names of the columns in the target table that contain the auto-generated
* keys that should be made available. The driver will ignore the array if
* the given SQL statement is not an INSERT statement.
*
* In some (uncommon) situations, a single SQL statement may return multiple
* result sets and/or update counts. Normally you can ignore this unless you
* are (1) executing a stored procedure that you know may return multiple
* results or (2) you are dynamically executing an unknown SQL string.
*
* The execute method executes an SQL statement and indicates
* the form of the first result. You must then use the methods
* getResultSet or getUpdateCount to retrieve the
* result, and getMoreResults to move to any subsequent
* result(s).
*
* @param sql
* any SQL statement
* @param columnNames
* an array of the names of the columns in the inserted row that
* should be made available for retrieval by a call to the method
* getGeneratedKeys
* @return true if the next result is a ResultSet
* object; false if it is an update count or there are
* no more results
* @exception SQLException
* if a database access error occurs
* @see #getResultSet
* @see #getUpdateCount
* @see #getMoreResults
* @see #getGeneratedKeys
*
* @since 1.4
*/
public boolean execute(String sql, String[] columnNames)
throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.execute(sql, columnNames);
}
/**
* Retrieves the result set holdability for ResultSet objects
* generated by this Statement object.
*
* @return either ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @exception SQLException
* if a database access error occurs
*
* @since 1.4
*/
public int getResultSetHoldability() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return this.statement.getResultSetHoldability();
}
/**
* @return
* @throws SQLException
* @see java.sql.Statement#isClosed()
*/
public boolean isClosed() throws SQLException {
return isClosed;
}
/**
* @return
* @throws SQLException
* @see java.sql.Statement#isPoolable()
*/
public boolean isPoolable() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return statement.isPoolable();
}
/**
* @param arg0
* @return
* @throws SQLException
* @see java.sql.Wrapper#isWrapperFor(java.lang.Class)
*/
public boolean isWrapperFor(Class arg0) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return statement.isWrapperFor(arg0);
}
/**
* @param arg0
* @throws SQLException
* @see java.sql.Statement#setPoolable(boolean)
*/
public void setPoolable(boolean arg0) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
statement.setPoolable(arg0);
}
/**
* @param
* @param arg0
* @return
* @throws SQLException
* @see java.sql.Wrapper#unwrap(java.lang.Class)
*/
public T unwrap(Class arg0) throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return statement.unwrap(arg0);
}
///////////////////////////////////////////////////////////
// JAVA 7 METHOD EMULATION //
///////////////////////////////////////////////////////////
//@Override do not not override for Java 6 compatibility
public void closeOnCompletion() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
}
//@Override do not not override for Java 6 compatibility
public boolean isCloseOnCompletion() throws SQLException {
String methodName = new Object() {
}.getClass().getEnclosingMethod().getName();
verifyCallAuthorization(methodName);
return false;
}
}