Coverage Report

Coverage Report - net.sf.sapjcosupport.jdbc.SapQLStatement

Classes in this File
 package net.sf.sapjcosupport.jdbc;
 
 import java.sql.Connection;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.SQLWarning;
 
 /**
  * Created by IntelliJ IDEA.
  * User: NDE1677
  * Date: Jul 5, 2006
  * Time: 12:40:14 PM
  * To change this template use File | Settings | File Templates.
  */
 public class SapQLStatement implements java.sql.Statement {
     private SapConnection connection;
 
     public SapQLStatement(SapConnection connection) {
         this.connection = connection;
     }
 
     /**
      * Executes an SQL statement that returns a single <code>ResultSet</code> object.
      *
      * @param sql typically this is a static SQL <code>SELECT</code> statement
      * @return a <code>ResultSet</code> object that contains the data produced by the
      *         given query; never <code>null</code>
      * @throws java.sql.SQLException if a database access error occurs
      */
     public ResultSet executeQuery(String sql) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Executes an SQL <code>INSERT</code>, <code>UPDATE</code> or
      * <code>DELETE</code> statement. In addition,
      * SQL statements that return nothing, such as SQL DDL statements,
      * can be executed.
      *
      * @param sql an SQL <code>INSERT</code>, <code>UPDATE</code> or
      *            <code>DELETE</code> statement or an SQL statement that returns nothing
      * @return either the row count for <code>INSERT</code>, <code>UPDATE</code>
      *         or <code>DELETE</code> statements, or 0 for SQL statements that return nothing
      * @throws java.sql.SQLException if a database access error occurs
      */
     public int executeUpdate(String sql) throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Releases this <code>SapQLStatement</code> 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.
      * <P><B>Note:</B> A <code>SapQLStatement</code> object is automatically closed when it is
      * garbage collected. When a <code>SapQLStatement</code> object is closed, its current
      * <code>ResultSet</code> object, if one exists, is also closed.
      *
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void close() throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Returns the maximum number of bytes allowed
      * for any column value.
      * This limit is the maximum number of bytes that can be
      * returned for any column value.
      * The limit applies only to <code>BINARY</code>,
      * <code>VARBINARY</code>, <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>, and <code>LONGVARCHAR</code>
      * columns.  If the limit is exceeded, the excess data is silently
      * discarded.
      *
      * @return the current max column size limit; zero means unlimited
      * @throws java.sql.SQLException if a database access error occurs
      */
     public int getMaxFieldSize() throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Sets the limit for the maximum number of bytes in a column to
      * the given number of bytes.  This is the maximum number of bytes
      * that can be returned for any column value.  This limit applies
      * only to <code>BINARY</code>, <code>VARBINARY</code>,
      * <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>, and
      * <code>LONGVARCHAR</code> fields.  If the limit is exceeded, the excess data
      * is silently discarded. For maximum portability, use values
      * greater than 256.
      *
      * @param max the new max column size limit; zero means unlimited
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void setMaxFieldSize(int max) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Retrieves the maximum number of rows that a
      * <code>ResultSet</code> object can contain.  If the limit is exceeded, the excess
      * rows are silently dropped.
      *
      * @return the current max row limit; zero means unlimited
      * @throws java.sql.SQLException if a database access error occurs
      */
     public int getMaxRows() throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Sets the limit for the maximum number of rows that any
      * <code>ResultSet</code> 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 unlimited
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void setMaxRows(int max) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Sets escape processing on or off.
      * If escape scanning is on (the default), the driver will do
      * escape substitution before sending the SQL to the database.
      * <p/>
      * Note: Since prepared statements have usually been parsed prior
      * to making this call, disabling escape processing for prepared
      * statements will have no effect.
      *
      * @param enable <code>true</code> to enable; <code>false</code> to disable
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void setEscapeProcessing(boolean enable) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Retrieves the number of seconds the driver will
      * wait for a <code>SapQLStatement</code> object to execute. If the limit is exceeded, a
      * <code>SQLException</code> is thrown.
      *
      * @return the current query timeout limit in seconds; zero means unlimited
      * @throws java.sql.SQLException if a database access error occurs
      */
     public int getQueryTimeout() throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Sets the number of seconds the driver will
      * wait for a <code>SapQLStatement</code> object to execute to the given number of seconds.
      * If the limit is exceeded, an <code>SQLException</code> is thrown.
      *
      * @param seconds the new query timeout limit in seconds; zero means
      *                unlimited
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void setQueryTimeout(int seconds) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Cancels this <code>SapQLStatement</code> 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.
      *
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void cancel() throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Retrieves the first warning reported by calls on this <code>SapQLStatement</code> object.
      * Subsequent <code>SapQLStatement</code> object warnings will be chained to this
      * <code>SQLWarning</code> object.
      * <p/>
      * <p>The warning chain is automatically cleared each time
      * a statement is (re)executed.
      * <p/>
      * <P><B>Note:</B> If you are processing a <code>ResultSet</code> object, any
      * warnings associated with reads on that <code>ResultSet</code> object
      * will be chained on it.
      *
      * @return the first <code>SQLWarning</code> object or <code>null</code>
      * @throws java.sql.SQLException if a database access error occurs
      */
     public SQLWarning getWarnings() throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Clears all the warnings reported on this <code>SapQLStatement</code>
      * object. After a call to this method,
      * the method <code>getWarnings</code> will return
      * <code>null</code> until a new warning is reported for this
      * <code>SapQLStatement</code> object.
      *
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void clearWarnings() throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Defines the SQL cursor name that will be used by
      * subsequent <code>SapQLStatement</code> object <code>execute</code> methods.
      * This name can then be
      * used in SQL positioned update/delete statements to identify the
      * current row in the <code>ResultSet</code> object generated by this statement.  If
      * the database doesn't 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 <code>SELECT</code> statement should be
      * of the form 'select for update ...'. If the 'for update' phrase is
      * omitted, positioned updates may fail.
      * <p/>
      * <P><B>Note:</B> By definition, positioned update/delete
      * execution must be done by a different <code>SapQLStatement</code> object than the one
      * which generated the <code>ResultSet</code> 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
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void setCursorName(String name) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Executes an SQL statement that may return multiple results.
      * 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  methods <code>execute</code>,
      * <code>getMoreResults</code>, <code>getResultSet</code>,
      * and <code>getUpdateCount</code> let you navigate through multiple results.
      * <p/>
      * The <code>execute</code> method executes an SQL statement and indicates the
      * form of the first result.  You can then use the methods
      * <code>getResultSet</code> or <code>getUpdateCount</code>
      * to retrieve the result, and <code>getMoreResults</code> to
      * move to any subsequent result(s).
      *
      * @param sql any SQL statement
      * @return <code>true</code> if the next result is a <code>ResultSet</code> object;
      *         <code>false</code> if it is an update count or there are no more results
      * @throws java.sql.SQLException if a database access error occurs
      * @see #getResultSet
      * @see #getUpdateCount
      * @see #getMoreResults
      */
     public boolean execute(String sql) throws SQLException {
         return false;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Returns the current result as a <code>ResultSet</code> object.
      * This method should be called only once per result.
      *
      * @return the current result as a <code>ResultSet</code> object;
      *         <code>null</code> if the result is an update count or there are no more results
      * @throws java.sql.SQLException if a database access error occurs
      * @see #execute
      */
     public ResultSet getResultSet() throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Returns the current result as an update count;
      * if the result is a <code>ResultSet</code> 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
      *         <code>ResultSet</code> object or there are no more results
      * @throws java.sql.SQLException if a database access error occurs
      * @see #execute
      */
     public int getUpdateCount() throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Moves to a <code>SapQLStatement</code> object's next result.  It returns
      * <code>true</code> if this result is a <code>ResultSet</code> object.
      * This method also implicitly closes any current <code>ResultSet</code>
      * object obtained with the method <code>getResultSet</code>.
      * <p/>
      * <P>There are no more results when the following is true:
      * <PRE>
      * <code>(!getMoreResults() && (getUpdateCount() == -1)</code>
      * </PRE>
      *
      * @return <code>true</code> if the next result is a <code>ResultSet</code> object;
      *         <code>false</code> if it is an update count or there are no more results
      * @throws java.sql.SQLException if a database access error occurs
      * @see #execute
      */
     public boolean getMoreResults() throws SQLException {
         return false;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Gives the driver a hint as to the direction in which
      * the rows in a result set
      * will be processed. The hint applies only to result sets created
      * using this <code>SapQLStatement</code> object.  The default value is
      * <code>ResultSet.FETCH_FORWARD</code>.
      * <p>Note that this method sets the default fetch direction for
      * result sets generated by this <code>SapQLStatement</code> object.
      * Each result set has its own methods for getting and setting
      * its own fetch direction.
      *
      * @param direction the initial direction for processing rows
      * @throws java.sql.SQLException if a database access error occurs
      *                               or the given direction
      *                               is not one of <code>ResultSet.FETCH_FORWARD</code>,
      *                               <code>ResultSet.FETCH_REVERSE</code>, or <code>ResultSet.FETCH_UNKNOWN</code>
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
      *      2.0 API</a>
      * @since 1.2
      */
     public void setFetchDirection(int direction) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Retrieves the direction for fetching rows from
      * database tables that is the default for result sets
      * generated from this <code>SapQLStatement</code> object.
      * If this <code>SapQLStatement</code> object has not set
      * a fetch direction by calling the method <code>setFetchDirection</code>,
      * the return value is implementation-specific.
      *
      * @return the default fetch direction for result sets generated
      *         from this <code>SapQLStatement</code> object
      * @throws java.sql.SQLException if a database access error occurs
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
      *      2.0 API</a>
      * @since 1.2
      */
     public int getFetchDirection() throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * 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
      * @throws java.sql.SQLException if a database access error occurs, or the
      *                               condition 0 <= rows <= this.getMaxRows() is not satisfied.
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
      *      2.0 API</a>
      * @since 1.2
      */
     public void setFetchSize(int rows) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Retrieves the number of result set rows that is the default
      * fetch size for result sets
      * generated from this <code>SapQLStatement</code> object.
      * If this <code>SapQLStatement</code> object has not set
      * a fetch size by calling the method <code>setFetchSize</code>,
      * the return value is implementation-specific.
      *
      * @return the default fetch size for result sets generated
      *         from this <code>SapQLStatement</code> object
      * @throws java.sql.SQLException if a database access error occurs
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
      *      2.0 API</a>
      * @since 1.2
      */
     public int getFetchSize() throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Retrieves the result set concurrency for <code>ResultSet</code> objects
      * generated by this <code>SapQLStatement</code> object.
      *
      * @return either <code>ResultSet.CONCUR_READ_ONLY</code> or
      *         <code>ResultSet.CONCUR_UPDATABLE</code>
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
      *      2.0 API</a>
      * @since 1.2
      */
     public int getResultSetConcurrency() throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Retrieves the result set type for <code>ResultSet</code> objects
      * generated by this <code>SapQLStatement</code> object.
      *
      * @return one of <code>ResultSet.TYPE_FORWARD_ONLY</code>,
      *         <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
      *         <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
      *      2.0 API</a>
      * @since 1.2
      */
     public int getResultSetType() throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Adds an SQL command to the current batch of commmands for this
      * <code>SapQLStatement</code> object. This method is optional.
      *
      * @param sql typically this is a static SQL <code>INSERT</code> or
      *            <code>UPDATE</code> statement
      * @throws java.sql.SQLException if a database access error occurs, or the
      *                               driver does not support batch statements
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
      *      2.0 API</a>
      * @since 1.2
      */
     public void addBatch(String sql) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Makes the set of commands in the current batch empty.
      * This method is optional.
      *
      * @throws java.sql.SQLException if a database access error occurs or the
      *                               driver does not support batch statements
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
      *      2.0 API</a>
      * @since 1.2
      */
     public void clearBatch() throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Submits a batch of commands to the database for execution and
      * if all commands execute successfully, returns an array of update counts.
      * The <code>int</code> 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 <code>executeBatch</code>
      * may be one of the following:
      * <OL>
      * <LI>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
      * <LI>A value of <code>-2</code> -- indicates that the command was
      * processed successfully but that the number of rows affected is
      * unknown
      * <p/>
      * If one of the commands in a batch update fails to execute properly,
      * this method throws a <code>BatchUpdateException</code>, 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
      * <code>BatchUpdateException.getUpdateCounts</code>
      * will contain as many elements as there are commands in the batch, and
      * at least one of the elements will be the following:
      * <p/>
      * <LI>A value of <code>-3</code> -- indicates that the command failed
      * to execute successfully and occurs only if a driver continues to
      * process commands after a command fails
      * </OL>
      * <p/>
      * 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 <code>BatchUpdateException</code> 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.
      * @throws java.sql.SQLException if a database access error occurs or the
      *                               driver does not support batch statements. Throws {@link java.sql.BatchUpdateException}
      *                               (a subclass of <code>SQLException</code>) if one of the commands sent to the
      *                               database fails to execute properly or attempts to return a result set.
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
      *      2.0 API</a>
      * @since 1.3
      */
     public int[] executeBatch() throws SQLException {
         return new int[0];  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Returns the <code>SapConnection</code> object
      * that produced this <code>SapQLStatement</code> object.
      *
      * @return the connection that produced this statement
      * @throws java.sql.SQLException if a database access error occurs
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
      *      2.0 API</a>
      * @since 1.2
      */
     public Connection getConnection() throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Retrieves the result set holdability for <code>ResultSet</code> objects
      * generated by this <code>Statement</code> object.
      *
      * @return either <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
      *         <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
      * @throws java.sql.SQLException if a database access error occurs
      * @since 1.4
      */
     public int getResultSetHoldability() throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Moves to this <code>Statement</code> object's next result, deals with
      * any current <code>ResultSet</code> object(s) according  to the instructions
      * specified by the given flag, and returns
      * <code>true</code> if the next result is a <code>ResultSet</code> object.
      * <p/>
      * <P>There are no more results when the following is true:
      * <PRE>
      * // stmt is a Statement object
      * ((stmt.getMoreResults() == false) && (stmt.getUpdateCount() == -1))
      * </PRE>
      *
      * @param current one of the following <code>Statement</code>
      *                constants indicating what should happen to current
      *                <code>ResultSet</code> objects obtained using the method
      *                <code>getResultSet</code>:
      *                <code>Statement.CLOSE_CURRENT_RESULT</code>,
      *                <code>Statement.KEEP_CURRENT_RESULT</code>, or
      *                <code>Statement.CLOSE_ALL_RESULTS</code>
      * @return <code>true</code> if the next result is a <code>ResultSet</code>
      *         object; <code>false</code> if it is an update count or there are no
      *         more results
      * @throws java.sql.SQLException if a database access error occurs or the argument
      *                               supplied is not one of the following:
      *                               <code>Statement.CLOSE_CURRENT_RESULT</code>,
      *                               <code>Statement.KEEP_CURRENT_RESULT</code>, or
      *                               <code>Statement.CLOSE_ALL_RESULTS</code>
      * @see #execute
      * @since 1.4
      */
     public boolean getMoreResults(int current) throws SQLException {
         return false;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Executes the given SQL statement and signals the driver with the
      * given flag about whether the
      * auto-generated keys produced by this <code>Statement</code> object
      * should be made available for retrieval.
      *
      * @param sql               must be an SQL <code>INSERT</code>, <code>UPDATE</code> or
      *                          <code>DELETE</code> 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:
      *                          <code>Statement.RETURN_GENERATED_KEYS</code>
      *                          <code>Statement.NO_GENERATED_KEYS</code>
      * @return either the row count for <code>INSERT</code>, <code>UPDATE</code>
      *         or <code>DELETE</code> statements, or <code>0</code> for SQL
      *         statements that return nothing
      * @throws java.sql.SQLException if a database access error occurs, the given
      *                               SQL statement returns a <code>ResultSet</code> object, or
      *                               the given constant is not one of those allowed
      * @since 1.4
      */
     public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * 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 <code>INSERT</code> statement.
      * <p/>
      * 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.
      * <p/>
      * The <code>execute</code> method executes an SQL statement and indicates the
      * form of the first result.  You must then use the methods
      * <code>getResultSet</code> or <code>getUpdateCount</code>
      * to retrieve the result, and <code>getMoreResults</code> 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
      *                          <code>getGeneratedKeys</code>; one of the following constants:
      *                          <code>Statement.RETURN_GENERATED_KEYS</code> or
      *                          <code>Statement.NO_GENERATED_KEYS</code>
      * @return <code>true</code> if the first result is a <code>ResultSet</code>
      *         object; <code>false</code> if it is an update count or there are
      *         no results
      * @throws java.sql.SQLException if a database access error occurs or the second
      *                               parameter supplied to this method is not
      *                               <code>Statement.RETURN_GENERATED_KEYS</code> or
      *                               <code>Statement.NO_GENERATED_KEYS</code>.
      * @see #getResultSet
      * @see #getUpdateCount
      * @see #getMoreResults
      * @see #getGeneratedKeys
      * @since 1.4
      */
     public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
         return false;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * 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 <code>INSERT</code> statement.
      *
      * @param sql           an SQL <code>INSERT</code>, <code>UPDATE</code> or
      *                      <code>DELETE</code> 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 <code>INSERT</code>, <code>UPDATE</code>,
      *         or <code>DELETE</code> statements, or 0 for SQL statements
      *         that return nothing
      * @throws java.sql.SQLException if a database access error occurs, the SQL
      *                               statement returns a <code>ResultSet</code> object, or the
      *                               second argument supplied to this method is not an <code>int</code> array
      *                               whose elements are valid column indexes
      * @since 1.4
      */
     public int executeUpdate(String sql, int columnIndexes[]) throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * 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 <code>INSERT</code> statement.
      * <p/>
      * 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.
      * <p/>
      * The <code>execute</code> method executes an SQL statement and indicates the
      * form of the first result.  You must then use the methods
      * <code>getResultSet</code> or <code>getUpdateCount</code>
      * to retrieve the result, and <code>getMoreResults</code> 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 <code>getGeneratedKeys</code>
      * @return <code>true</code> if the first result is a <code>ResultSet</code>
      *         object; <code>false</code> if it is an update count or there
      *         are no results
      * @throws java.sql.SQLException if a database access error occurs or the
      *                               elements in the <code>int</code> array passed to this method
      *                               are not valid column indexes
      * @see #getResultSet
      * @see #getUpdateCount
      * @see #getMoreResults
      * @since 1.4
      */
     public boolean execute(String sql, int columnIndexes[]) throws SQLException {
         return false;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Retrieves any auto-generated keys created as a result of executing this
      * <code>Statement</code> object. If this <code>Statement</code> object did
      * not generate any keys, an empty <code>ResultSet</code>
      * object is returned.
      *
      * @return a <code>ResultSet</code> object containing the auto-generated key(s)
      *         generated by the execution of this <code>Statement</code> object
      * @throws java.sql.SQLException if a database access error occurs
      * @since 1.4
      */
     public ResultSet getGeneratedKeys() throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * 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 <code>INSERT</code> statement.
      *
      * @param sql         an SQL <code>INSERT</code>, <code>UPDATE</code> or
      *                    <code>DELETE</code> 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 <code>INSERT</code>, <code>UPDATE</code>,
      *         or <code>DELETE</code> statements, or 0 for SQL statements
      *         that return nothing
      * @throws java.sql.SQLException if a database access error occurs, the SQL
      *                               statement returns a <code>ResultSet</code> object, or the
      *                               second argument supplied to this method is not a <code>String</code> array
      *                               whose elements are valid column names
      * @since 1.4
      */
     public int executeUpdate(String sql, String columnNames[]) throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * 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 <code>INSERT</code> statement.
      * <p/>
      * 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.
      * <p/>
      * The <code>execute</code> method executes an SQL statement and indicates the
      * form of the first result.  You must then use the methods
      * <code>getResultSet</code> or <code>getUpdateCount</code>
      * to retrieve the result, and <code>getMoreResults</code> 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 <code>getGeneratedKeys</code>
      * @return <code>true</code> if the next result is a <code>ResultSet</code>
      *         object; <code>false</code> if it is an update count or there
      *         are no more results
      * @throws java.sql.SQLException if a database access error occurs or the
      *                               elements of the <code>String</code> array passed to this
      *                               method are not valid column names
      * @see #getResultSet
      * @see #getUpdateCount
      * @see #getMoreResults
      * @see #getGeneratedKeys
      * @since 1.4
      */
     public boolean execute(String sql, String columnNames[]) throws SQLException {
         return false;  //To change body of implemented methods use File | Settings | File Templates.
     }
 }