Coverage Report

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

Classes in this File
1,075
 package net.sf.sapjcosupport.jdbc;
 
 import com.sap.mw.jco.IRepository;
 import com.sap.mw.jco.JCO;
 import net.sf.sapjcosupport.SapDataSource;
 import org.apache.log4j.Logger;
 
 import java.sql.*;
 import java.util.Map;
 
 /**
  * Implements an SQL connection for SAP.
  *
  * @author Niki Driessen
  */
 public class SapConnection implements java.sql.Connection {
     private static final Logger logger = Logger.getLogger(SapConnection.class);
 
     private JCO.Client nativeConnection;
     private IRepository functionRepository;
 
     public JCO.Client getNativeConnection() {
         return nativeConnection;
     }
 
     public IRepository getFunctionRepository() {
         return functionRepository;
     }
 
     public SapConnection(JCO.Client nativeConnection, IRepository functionRepository) {
         this.nativeConnection = nativeConnection;
         this.functionRepository = functionRepository;
     }
 
     /**
      * Creates a <code>SapQLStatement</code> object for sending
      * SQL statements to the database.
      * SQL statements without parameters are normally
      * executed using SapQLStatement objects. If the same SQL statement
      * is executed many times, it is more efficient to use a
      * <code>PreparedStatement</code> object.
      * <p/>
      * <p/>
      * Result sets created using the returned <code>SapQLStatement</code>
      * object will by default have forward-only type and read-only concurrency.
      *
      * @return a new SapQLStatement object
      * @throws java.sql.SQLException if a database access error occurs
      */
     public Statement createStatement() throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates a <code>PreparedStatement</code> object for sending
      * parameterized SQL statements to the database.
      * <p/>
      * 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.
      * <p/>
      * <P><B>Note:</B> This method is optimized for handling
      * parametric SQL statements that benefit from precompilation. If
      * the driver supports precompilation,
      * the method <code>prepareStatement</code> 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 <code>PreparedStatement</code> is
      * executed.  This has no direct effect on users; however, it does
      * affect which method throws certain SQLExceptions.
      * <p/>
      * <p/>
      * Result sets created using the returned PreparedStatement will have
      * forward-only type and read-only concurrency, by default.
      *
      * @param sql a SQL statement that may contain one or more '?' IN
      *            parameter placeholders
      * @return a new PreparedStatement object containing the
      *         pre-compiled statement
      * @throws java.sql.SQLException if a database access error occurs
      */
     public PreparedStatement prepareStatement(String sql) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates a <code>CallableStatement</code> object for calling
      * database stored procedures.
      * The <code>CallableStatement</code> object provides
      * methods for setting up its IN and OUT parameters, and
      * methods for executing the call to a stored procedure.
      * <p/>
      * <P><B>Note:</B> This method is optimized for handling stored
      * procedure call statements. Some drivers may send the call
      * statement to the database when the method <code>prepareCall</code>
      * is done; others
      * may wait until the <code>CallableStatement</code> object
      * is executed. This has no
      * direct effect on users; however, it does affect which method
      * throws certain SQLExceptions.
      * <p/>
      * <p/>
      * Result sets created using the returned CallableStatement will have
      * forward-only type and read-only concurrency, by default.
      *
      * @param sql a SQL statement that may contain one or more '?'
      *            parameter placeholders. Typically this  statement is a JDBC
      *            function call escape string.
      * @return a new CallableStatement object containing the
      *         pre-compiled SQL statement
      * @throws java.sql.SQLException if a database access error occurs
      */
     public CallableStatement prepareCall(String sql) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * 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 a SQL statement that may contain one or more '?'
      *            parameter placeholders
      * @return the native form of this statement
      * @throws java.sql.SQLException if a database access error occurs
      */
     public String nativeSQL(String sql) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Sets this connection's auto-commit mode.
      * 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 <code>commit</code> or the method <code>rollback</code>.
      * By default, new connections are in auto-commit
      * mode.
      * <p/>
      * The commit occurs when the statement completes or the next
      * execute occurs, whichever comes first. In the case of
      * statements returning a ResultSet, the statement completes when
      * the last row of the ResultSet has been retrieved or the
      * ResultSet 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.
      *
      * @param autoCommit true enables auto-commit; false disables
      *                   auto-commit.
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void setAutoCommit(boolean autoCommit) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Gets the current auto-commit state.
      *
      * @return the current state of auto-commit mode
      * @throws java.sql.SQLException if a database access error occurs
      * @see #setAutoCommit
      */
     public boolean getAutoCommit() throws SQLException {
         return false;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Makes all changes made since the previous
      * commit/rollback permanent and releases any database locks
      * currently held by the SapConnection. This method should be
      * used only when auto-commit mode has been disabled.
      *
      * @throws java.sql.SQLException if a database access error occurs
      * @see #setAutoCommit
      */
     public void commit() throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Drops all changes made since the previous
      * commit/rollback and releases any database locks currently held
      * by this SapConnection. This method should be used only when auto-
      * commit has been disabled.
      *
      * @throws java.sql.SQLException if a database access error occurs
      * @see #setAutoCommit
      */
     public void rollback() throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Releases a SapConnection's database and JDBC resources
      * immediately instead of waiting for
      * them to be automatically released.
      * <p/>
      * <P><B>Note:</B> A Connection is automatically closed when it is
      * garbage collected. Certain fatal errors also result in a closed
      * Connection.
      *
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void close() throws SQLException {
         try {
             JCO.releaseClient(nativeConnection);
         } catch (Exception e) {
             try {
                 nativeConnection.reset();
                 JCO.releaseClient(nativeConnection);
             } catch (Exception e1) {
                 logger.warn("Error closing native SAP connection", e1);
             }
         }
     }
 
     /**
      * Called by the garbage collector on an object when garbage collection
      * determines that there are no more references to the object.
      * A subclass overrides the <code>finalize</code> method to dispose of
      * system resources or to perform other cleanup.
      * <p/>
      * The general contract of <tt>finalize</tt> is that it is invoked
      * if and when the Java<font size="-2"><sup>TM</sup></font> virtual
      * machine has determined that there is no longer any
      * means by which this object can be accessed by any thread that has
      * not yet died, except as a result of an action taken by the
      * finalization of some other object or class which is ready to be
      * finalized. The <tt>finalize</tt> method may take any action, including
      * making this object available again to other threads; the usual purpose
      * of <tt>finalize</tt>, however, is to perform cleanup actions before
      * the object is irrevocably discarded. For example, the finalize method
      * for an object that represents an input/output connection might perform
      * explicit I/O transactions to break the connection before the object is
      * permanently discarded.
      * <p/>
      * The <tt>finalize</tt> method of class <tt>Object</tt> performs no
      * special action; it simply returns normally. Subclasses of
      * <tt>Object</tt> may override this definition.
      * <p/>
      * The Java programming language does not guarantee which thread will
      * invoke the <tt>finalize</tt> method for any given object. It is
      * guaranteed, however, that the thread that invokes finalize will not
      * be holding any user-visible synchronization locks when finalize is
      * invoked. If an uncaught exception is thrown by the finalize method,
      * the exception is ignored and finalization of that object terminates.
      * <p/>
      * After the <tt>finalize</tt> method has been invoked for an object, no
      * further action is taken until the Java virtual machine has again
      * determined that there is no longer any means by which this object can
      * be accessed by any thread that has not yet died, including possible
      * actions by other objects or classes which are ready to be finalized,
      * at which point the object may be discarded.
      * <p/>
      * The <tt>finalize</tt> method is never invoked more than once by a Java
      * virtual machine for any given object.
      * <p/>
      * Any exception thrown by the <code>finalize</code> method causes
      * the finalization of this object to be halted, but is otherwise
      * ignored.
      *
      * @throws Throwable the <code>Exception</code> raised by this method
      */
     protected void finalize() throws Throwable {
         try {
             close();
         } finally {
             super.finalize();
         }
     }
 
     /**
      * Tests to see if a SapConnection is closed.
      *
      * @return true if the connection is closed; false if it's still open
      * @throws java.sql.SQLException if a database access error occurs
      */
     public boolean isClosed() throws SQLException {
         return !(nativeConnection.isAlive() && nativeConnection.isValid());
     }
 
     /**
      * Gets the metadata regarding this connection's database.
      * A SapConnection's database is able to provide information
      * describing its tables, its supported SQL grammar, its stored
      * procedures, the capabilities of this connection, and so on. This
      * information is made available through a DatabaseMetaData
      * object.
      *
      * @return a DatabaseMetaData object for this SapConnection
      * @throws java.sql.SQLException if a database access error occurs
      */
     public DatabaseMetaData getMetaData() throws SQLException {
         throw new JdbcFeatureNotSupportedException();
     }
 
     /**
      * Puts this connection in read-only mode as a hint to enable
      * database optimizations.
      * <p/>
      * <P><B>Note:</B> This method cannot be called while in the
      * middle of a transaction.
      *
      * @param readOnly true enables read-only mode; false disables
      *                 read-only mode.
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void setReadOnly(boolean readOnly) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Tests to see if the connection is in read-only mode.
      *
      * @return true if connection is read-only and false otherwise
      * @throws java.sql.SQLException if a database access error occurs
      */
     public boolean isReadOnly() throws SQLException {
         return false;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Sets a catalog name in order to select
      * a subspace of this SapConnection's database in which to work.
      * If the driver does not support catalogs, it will
      * silently ignore this request.
      *
      * @throws java.sql.SQLException if a database access error occurs
      */
     public void setCatalog(String catalog) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Returns the Connection's current catalog name.
      *
      * @return the current catalog name or null
      * @throws java.sql.SQLException if a database access error occurs
      */
     public String getCatalog() throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Attempts to change the transaction
      * isolation level to the one given.
      * The constants defined in the interface <code>Connection</code>
      * are the possible transaction isolation levels.
      * <p/>
      * <P><B>Note:</B> This method cannot be called while
      * in the middle of a transaction.
      *
      * @param level one of the TRANSACTION_* isolation values with the
      *              exception of TRANSACTION_NONE; some databases may not support
      *              other values
      * @throws java.sql.SQLException if a database access error occurs
      * @see java.sql.DatabaseMetaData#supportsTransactionIsolationLevel
      */
     public void setTransactionIsolation(int level) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Gets this SapConnection's current transaction isolation level.
      *
      * @return the current TRANSACTION_* mode value
      * @throws java.sql.SQLException if a database access error occurs
      */
     public int getTransactionIsolation() throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Returns the first warning reported by calls on this SapConnection.
      * <p/>
      * <P><B>Note:</B> Subsequent warnings will be chained to this
      * SQLWarning.
      *
      * @return the first SQLWarning or null
      * @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 warnings reported for this <code>SapConnection</code> object.
      * After a call to this method, the method <code>getWarnings</code>
      * returns null until a new warning is
      * reported for this SapConnection.
      *
      * @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.
     }
 
     /**
      * Creates a <code>SapQLStatement</code> object that will generate
      * <code>ResultSet</code> objects with the given type and concurrency.
      * This method is the same as the <code>createStatement</code> method
      * above, but it allows the default result set
      * type and result set concurrency type to be overridden.
      *
      * @param resultSetType        a result set type; see ResultSet.TYPE_XXX
      * @param resultSetConcurrency a concurrency type; see ResultSet.CONCUR_XXX
      * @return a new SapQLStatement 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 Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates a <code>PreparedStatement</code> object that will generate
      * <code>ResultSet</code> objects with the given type and concurrency.
      * This method is the same as the <code>prepareStatement</code> method
      * above, but it allows the default result set
      * type and result set concurrency type to be overridden.
      *
      * @param resultSetType        a result set type; see ResultSet.TYPE_XXX
      * @param resultSetConcurrency a concurrency type; see ResultSet.CONCUR_XXX
      * @return a new PreparedStatement object containing the
      *         pre-compiled SQL 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 PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws
                                                                                                        SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates a <code>CallableStatement</code> object that will generate
      * <code>ResultSet</code> objects with the given type and concurrency.
      * This method is the same as the <code>prepareCall</code> method
      * above, but it allows the default result set
      * type and result set concurrency type to be overridden.
      *
      * @param resultSetType        a result set type; see ResultSet.TYPE_XXX
      * @param resultSetConcurrency a concurrency type; see ResultSet.CONCUR_XXX
      * @return a new CallableStatement object containing the
      *         pre-compiled SQL 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 CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Gets the type map object associated with this connection.
      * Unless the application has added an entry to the type map,
      * the map returned will be empty.
      *
      * @return the <code>java.util.Map</code> object associated
      *         with this <code>SapConnection</code> object
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC 2.0 API</a>
      * @since 1.2
      */
     public Map getTypeMap() throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Installs the given type map as the type map for
      * this connection.  The type map will be used for the
      * custom mapping of SQL structured types and distinct types.
      *
      * @param map the <code>java.util.Map</code> object to install
      *            as the replacement for this <code>SapConnection</code>
      *            object's default type map
      * @see <a href="package-summary.html#2.0 API">What Is in the JDBC 2.0 API</a>
      * @since 1.2
      */
     public void setTypeMap(Map map) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Retrieves the current holdability of <code>ResultSet</code> objects
      * created using this <code>Connection</code> object.
      *
      * @return the holdability, one of
      *         <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
      *         <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
      * @throws java.sql.SQLException if a database access occurs
      * @see #setHoldability
      * @see java.sql.ResultSet
      * @since 1.4
      */
     public int getHoldability() throws SQLException {
         return 0;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Changes the holdability of <code>ResultSet</code> objects
      * created using this <code>Connection</code> object to the given
      * holdability.
      *
      * @param holdability a <code>ResultSet</code> holdability constant; one of
      *                    <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
      *                    <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
      * @throws java.sql.SQLException if a database access occurs, the given parameter
      *                               is not a <code>ResultSet</code> constant indicating holdability,
      *                               or the given holdability is not supported
      * @see #getHoldability
      * @see java.sql.ResultSet
      * @since 1.4
      */
     public void setHoldability(int holdability) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates an unnamed savepoint in the current transaction and
      * returns the new <code>Savepoint</code> object that represents it.
      *
      * @return the new <code>Savepoint</code> object
      * @throws java.sql.SQLException if a database access error occurs
      *                               or this <code>Connection</code> object is currently in
      *                               auto-commit mode
      * @see java.sql.Savepoint
      * @since 1.4
      */
     public Savepoint setSavepoint() throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Removes the given <code>Savepoint</code> object from the current
      * transaction. Any reference to the savepoint after it have been removed
      * will cause an <code>SQLException</code> to be thrown.
      *
      * @param savepoint the <code>Savepoint</code> object to be removed
      * @throws java.sql.SQLException if a database access error occurs or
      *                               the given <code>Savepoint</code> object is not a valid
      *                               savepoint in the current transaction
      * @since 1.4
      */
     public void releaseSavepoint(Savepoint savepoint) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Undoes all changes made after the given <code>Savepoint</code> object
      * was set.
      * <p/>
      * This method should be used only when auto-commit has been disabled.
      *
      * @param savepoint the <code>Savepoint</code> object to roll back to
      * @throws java.sql.SQLException if a database access error occurs,
      *                               the <code>Savepoint</code> object is no longer valid,
      *                               or this <code>Connection</code> object is currently in
      *                               auto-commit mode
      * @see java.sql.Savepoint
      * @see #rollback
      * @since 1.4
      */
     public void rollback(Savepoint savepoint) throws SQLException {
         //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates a <code>Statement</code> object that will generate
      * <code>ResultSet</code> objects with the given type, concurrency,
      * and holdability.
      * This method is the same as the <code>createStatement</code> method
      * above, but it allows the default result set
      * type, concurrency, and holdability to be overridden.
      *
      * @param resultSetType        one of the following <code>ResultSet</code>
      *                             constants:
      *                             <code>ResultSet.TYPE_FORWARD_ONLY</code>,
      *                             <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
      *                             <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
      * @param resultSetConcurrency one of the following <code>ResultSet</code>
      *                             constants:
      *                             <code>ResultSet.CONCUR_READ_ONLY</code> or
      *                             <code>ResultSet.CONCUR_UPDATABLE</code>
      * @param resultSetHoldability one of the following <code>ResultSet</code>
      *                             constants:
      *                             <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
      *                             <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
      * @return a new <code>Statement</code> object that will generate
      *         <code>ResultSet</code> objects with the given type,
      *         concurrency, and holdability
      * @throws java.sql.SQLException if a database access error occurs
      *                               or the given parameters are not <code>ResultSet</code>
      *                               constants indicating type, concurrency, and holdability
      * @see java.sql.ResultSet
      * @since 1.4
      */
     public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws
                                                                                                             SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates a <code>CallableStatement</code> object that will generate
      * <code>ResultSet</code> objects with the given type and concurrency.
      * This method is the same as the <code>prepareCall</code> method
      * above, but it allows the default result set
      * type, result set concurrency type and holdability to be overridden.
      *
      * @param sql                  a <code>String</code> object that is the SQL statement to
      *                             be sent to the database; may contain on or more ? parameters
      * @param resultSetType        one of the following <code>ResultSet</code>
      *                             constants:
      *                             <code>ResultSet.TYPE_FORWARD_ONLY</code>,
      *                             <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
      *                             <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
      * @param resultSetConcurrency one of the following <code>ResultSet</code>
      *                             constants:
      *                             <code>ResultSet.CONCUR_READ_ONLY</code> or
      *                             <code>ResultSet.CONCUR_UPDATABLE</code>
      * @param resultSetHoldability one of the following <code>ResultSet</code>
      *                             constants:
      *                             <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
      *                             <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
      * @return a new <code>CallableStatement</code> object, containing the
      *         pre-compiled SQL statement, that will generate
      *         <code>ResultSet</code> objects with the given type,
      *         concurrency, and holdability
      * @throws java.sql.SQLException if a database access error occurs
      *                               or the given parameters are not <code>ResultSet</code>
      *                               constants indicating type, concurrency, and holdability
      * @see java.sql.ResultSet
      * @since 1.4
      */
     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
                                          int resultSetHoldability) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates a default <code>PreparedStatement</code> object that has
      * the capability to retrieve auto-generated keys. The given constant
      * tells the driver whether it should make auto-generated keys
      * available for retrieval.  This parameter is ignored if the SQL
      * statement is not an <code>INSERT</code> statement.
      * <p/>
      * <B>Note:</B> This method is optimized for handling
      * parametric SQL statements that benefit from precompilation. If
      * the driver supports precompilation,
      * the method <code>prepareStatement</code> 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 <code>PreparedStatement</code>
      * object is executed.  This has no direct effect on users; however, it does
      * affect which methods throw certain SQLExceptions.
      * <p/>
      * Result sets created using the returned <code>PreparedStatement</code>
      * object will by default be type <code>TYPE_FORWARD_ONLY</code>
      * and have a concurrency level of <code>CONCUR_READ_ONLY</code>.
      *
      * @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
      *                          <code>Statement.RETURN_GENERATED_KEYS</code> or
      *                          <code>Statement.NO_GENERATED_KEYS</code>
      * @return a new <code>PreparedStatement</code> object, containing the
      *         pre-compiled SQL statement, that will have the capability of
      *         returning auto-generated keys
      * @throws java.sql.SQLException if a database access error occurs
      *                               or the given parameter is not a <code>Statement</code>
      *                               constant indicating whether auto-generated keys should be
      *                               returned
      * @since 1.4
      */
     public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates a <code>PreparedStatement</code> object that will generate
      * <code>ResultSet</code> objects with the given type, concurrency,
      * and holdability.
      * <p/>
      * This method is the same as the <code>prepareStatement</code> method
      * above, but it allows the default result set
      * type, concurrency, and holdability to be overridden.
      *
      * @param sql                  a <code>String</code> 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 <code>ResultSet</code>
      *                             constants:
      *                             <code>ResultSet.TYPE_FORWARD_ONLY</code>,
      *                             <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
      *                             <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
      * @param resultSetConcurrency one of the following <code>ResultSet</code>
      *                             constants:
      *                             <code>ResultSet.CONCUR_READ_ONLY</code> or
      *                             <code>ResultSet.CONCUR_UPDATABLE</code>
      * @param resultSetHoldability one of the following <code>ResultSet</code>
      *                             constants:
      *                             <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
      *                             <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
      * @return a new <code>PreparedStatement</code> object, containing the
      *         pre-compiled SQL statement, that will generate
      *         <code>ResultSet</code> objects with the given type,
      *         concurrency, and holdability
      * @throws java.sql.SQLException if a database access error occurs
      *                               or the given parameters are not <code>ResultSet</code>
      *                               constants indicating type, concurrency, and holdability
      * @see java.sql.ResultSet
      * @since 1.4
      */
     public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
                                               int resultSetHoldability) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates a default <code>PreparedStatement</code> 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 <code>INSERT</code> statement.
      * <p/>
      * An SQL statement with or without IN parameters can be
      * pre-compiled and stored in a <code>PreparedStatement</code> object. This
      * object can then be used to efficiently execute this statement
      * multiple times.
      * <p/>
      * <B>Note:</B> This method is optimized for handling
      * parametric SQL statements that benefit from precompilation. If
      * the driver supports precompilation,
      * the method <code>prepareStatement</code> 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 <code>PreparedStatement</code>
      * object is executed.  This has no direct effect on users; however, it does
      * affect which methods throw certain SQLExceptions.
      * <p/>
      * Result sets created using the returned <code>PreparedStatement</code>
      * object will by default be type <code>TYPE_FORWARD_ONLY</code>
      * and have a concurrency level of <code>CONCUR_READ_ONLY</code>.
      *
      * @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 <code>PreparedStatement</code> object, containing the
      *         pre-compiled statement, that is capable of returning the
      *         auto-generated keys designated by the given array of column
      *         indexes
      * @throws java.sql.SQLException if a database access error occurs
      * @since 1.4
      */
     public PreparedStatement prepareStatement(String sql, int columnIndexes[]) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates a savepoint with the given name in the current transaction
      * and returns the new <code>Savepoint</code> object that represents it.
      *
      * @param name a <code>String</code> containing the name of the savepoint
      * @return the new <code>Savepoint</code> object
      * @throws java.sql.SQLException if a database access error occurs
      *                               or this <code>Connection</code> object is currently in
      *                               auto-commit mode
      * @see java.sql.Savepoint
      * @since 1.4
      */
     public Savepoint setSavepoint(String name) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     /**
      * Creates a default <code>PreparedStatement</code> 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 <code>INSERT</code> statement.
      * <p/>
      * An SQL statement with or without IN parameters can be
      * pre-compiled and stored in a <code>PreparedStatement</code> object. This
      * object can then be used to efficiently execute this statement
      * multiple times.
      * <p/>
      * <B>Note:</B> This method is optimized for handling
      * parametric SQL statements that benefit from precompilation. If
      * the driver supports precompilation,
      * the method <code>prepareStatement</code> 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 <code>PreparedStatement</code>
      * object is executed.  This has no direct effect on users; however, it does
      * affect which methods throw certain SQLExceptions.
      * <p/>
      * Result sets created using the returned <code>PreparedStatement</code>
      * object will by default be type <code>TYPE_FORWARD_ONLY</code>
      * and have a concurrency level of <code>CONCUR_READ_ONLY</code>.
      *
      * @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 <code>PreparedStatement</code> object, containing the
      *         pre-compiled statement, that is capable of returning the
      *         auto-generated keys designated by the given array of column
      *         names
      * @throws java.sql.SQLException if a database access error occurs
      * @since 1.4
      */
     public PreparedStatement prepareStatement(String sql, String columnNames[]) throws SQLException {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 }