/* 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package java.sql;

import java.util.Map;

/**
 * A connection represents a link from a Java application to a database. All SQL
 * statements and results are returned within the context of a connection.
 * Database statements that are executed within this context form a
 * database session which forms one or more closed transactions. Especially in
 * distributed applications, multiple concurrent connections may exist accessing
 * the same values of the database. which may lead to the following phenomena
 * (referred to as <i>transaction isolation levels</i>):
 * <ul>
 * <li><i>dirty reads</i>:<br>
 * reading values from table rows that are not committed.</br></li>
 * <li><i>non-repeatable reads</i>:<br>
 * reading table rows more than once in a transaction but getting back different
 * data because other transactions have altered the rows between the reads.</br></li>
 * <li><i>phantom reads</i>:<br>
 * retrieving additional "phantom" rows in the course of repeated table reads
 * because other transactions have inserted additional rows that satisfy an
 * SQL {@code WHERE} clause</br></li>
 * </ul>
 */
public interface Connection {

    /**
     * A constant indicating that transactions are not supported.
     */
    public static final int TRANSACTION_NONE = 0;

    /**
     * No <i>dirty reads</i> are permitted, therefore transactions may not read
     * a row containing uncommitted values - but does not prevent an application
     * from <i>non-repeatable reads</i> and <i>phantom reads</i>.
     */
    public static final int TRANSACTION_READ_COMMITTED = 2;

    /**
     * In the case that reading uncommitted values is allowed, the following
     * incidents may happen which may lead to an invalid results:
     * <ul>
     * <li><i>dirty reads</i></li>
     * <li><i>non-repeatable reads</i></li>
     * <li><i>phantom reads</i></li>
     * </ul>
     */
    public static final int TRANSACTION_READ_UNCOMMITTED = 1;

    /**
     * A constant indicating that <i>dirty reads</i> and <i>non-repeatable
     * reads</i> are <b>prevented</b> but <i>phantom reads</i> can occur.
     */
    public static final int TRANSACTION_REPEATABLE_READ = 4;

    /**
     * The constant that indicates that the following incidents are <b>all
     * prevented</b> (the opposite of {@link #TRANSACTION_READ_UNCOMMITTED}):
     * <ul>
     * <li><i>dirty reads</i></li>
     * <li><i>non-repeatable reads</i></li>
     * <li><i>phantom reads</i></li>
     * </ul>
     */
    public static final int TRANSACTION_SERIALIZABLE = 8;

    /**
     * Discards all warnings that may have arisen for this connection.
     * Subsequent calls to {@link #getWarnings()} will return {@code null}
     * up until a new warning condition occurs.
     * 
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public void clearWarnings() throws SQLException;

    /**
     * Causes the instant release of all database and driver connection
     * resources associated with this object. Any subsequent invocations of this
     * method have no effect.
     * <p>
     * It is strongly recommended that all connections are closed before they
     * are dereferenced by the application ready for garbage collection.
     * Although the {@code finalize} method of the connection closes the
     * connection before garbage collection takes place, it is not advisable to
     * leave the {@code close} operation to take place in this way. Mainly
     * because undesired side-effects may appear.
     *
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public void close() throws SQLException;

    /**
     * Commits all of the changes made since the last {@code commit} or
     * {@code rollback} of the associated transaction. All locks in the database
     * held by this connection are also relinquished. Calling this operation on
     * connection objects in {@code auto-commit} mode leads to an error.
     * 
     * @throws SQLException
     *             if there is a problem accessing the database or if the target
     *             connection instance is in auto-commit mode.
     */
    public void commit() throws SQLException;

    /**
     * Returns a new instance of {@code Statement} for issuing SQL commands to
     * the remote database.
     * <p>
     * {@code ResultSets} generated by the returned statement will default to
     * type {@code ResultSet.TYPE_FORWARD_ONLY} and concurrency level {@code
     * ResultSet.CONCUR_READ_ONLY}.
     * 
     * @return a {@code Statement} object with default settings.
     * @throws SQLException
     *             if there is a problem accessing the database.
     * @see ResultSet
     */
    public Statement createStatement() throws SQLException;

    /**
     * Returns a new instance of {@code Statement} whose associated {@code
     * ResultSet}s have the characteristics specified in the type and
     * concurrency arguments.
     * 
     * @param resultSetType
     *            one of the following type specifiers:
     *            <ul>
     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE} </li> <li>
     *            {@link ResultSet#TYPE_SCROLL_INSENSITIVE} </li> <li>
     *            {@link ResultSet#TYPE_FORWARD_ONLY}</li>
     *            </ul>
     * @param resultSetConcurrency
     *            one of the following concurrency mode specifiers:
     *            <ul>
     *            <li>{@link ResultSet#CONCUR_UPDATABLE}</li> <li>
     *            {@link ResultSet#CONCUR_READ_ONLY}</li>
     *            </ul>
     * @return a new instance of {@code Statement} capable of manufacturing
     *         {@code ResultSet}s that satisfy the specified {@code
     *         resultSetType} and {@code resultSetConcurrency} values.
     * @throws SQLException
     *             if there is a problem accessing the database
     */
    public Statement createStatement(int resultSetType, int resultSetConcurrency)
            throws SQLException;

    /**
     * Returns a new instance of {@code Statement} whose associated
     * {@code ResultSet}s will have the characteristics specified in the
     * type, concurrency and holdability arguments.
     * 
     * @param resultSetType
     *            one of the following type specifiers:
     *            <ul>
     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}</li>
     *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}</li>
     *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}</li>
     *            </ul>
     * @param resultSetConcurrency
     *            one of the following concurrency mode specifiers:
     *            <ul>
     *            <li>{@link ResultSet#CONCUR_UPDATABLE}</li>
     *            <li>{@link ResultSet#CONCUR_READ_ONLY}</li>
     *            </ul>
     * @param resultSetHoldability
     *            one of the following holdability mode specifiers:
     *            <ul>
     *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}</li>
     *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}</li>
     *            </ul>
     * @return a new instance of {@code Statement} capable of
     *         manufacturing {@code ResultSet}s that satisfy the
     *         specified {@code resultSetType},
     *         {@code resultSetConcurrency} and
     *         {@code resultSetHoldability} values.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public Statement createStatement(int resultSetType,
            int resultSetConcurrency, int resultSetHoldability)
            throws SQLException;

    /**
     * Returns a {@code boolean} indicating whether or not this connection is in
     * the {@code auto-commit} operating mode.
     * 
     * @return {@code true} if {@code auto-commit} is on, otherwise {@code
     *         false}.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public boolean getAutoCommit() throws SQLException;

    /**
     * Gets this {@code Connection} object's current catalog name.
     * 
     * @return the catalog name. {@code null} if there is no catalog
     *         name.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public String getCatalog() throws SQLException;

    /**
     * Returns the holdability property that any {@code ResultSet} produced by
     * this instance will have.
     * 
     * @return one of the following holdability mode specifiers:
     *         <ul>
     *         <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}</li> <li>
     *         {@link ResultSet#CLOSE_CURSORS_AT_COMMIT}</li>
     *         </ul>
     * @throws SQLException
     *             if there is a problem accessing the a database.
     */
    public int getHoldability() throws SQLException;

    /**
     * Gets the metadata about the database referenced by this connection. The
     * returned {@code DatabaseMetaData} describes the database topography,
     * available stored procedures, SQL syntax and so on.
     * 
     * @return a {@code DatabaseMetaData} object containing the database
     *         description.
     * @throws SQLException
     *             if there is a problem accessing the a database.
     */
    public DatabaseMetaData getMetaData() throws SQLException;

    /**
     * Returns the transaction isolation level for this connection.
     * 
     * @return the transaction isolation value.
     * @throws SQLException
     *             if there is a problem accessing the database.
     * @see #TRANSACTION_NONE
     * @see #TRANSACTION_READ_COMMITTED
     * @see #TRANSACTION_READ_UNCOMMITTED
     * @see #TRANSACTION_REPEATABLE_READ
     * @see #TRANSACTION_SERIALIZABLE
     */
    public int getTransactionIsolation() throws SQLException;

    /**
     * Returns the type mapping associated with this {@code Connection} object.
     * The type mapping must be set on the application level.
     * 
     * @return the Type Map as a {@code java.util.Map}.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public Map<String, Class<?>> getTypeMap() throws SQLException;

    /**
     * Gets the first instance of any {@code SQLWarning} objects that may have
     * been created in the use of this connection. If at least one warning has
     * occurred then this operation returns the first one reported. A {@code
     * null} indicates that no warnings have occurred.
     * <p>
     * By invoking the {@link SQLWarning#getNextWarning()} method of the
     * returned {@code SQLWarning} object it is possible to obtain all of
     * this connection's warning objects.
     *
     * @return the first warning as an SQLWarning object (may be {@code null}).
     * @throws SQLException
     *             if there is a problem accessing the database or if the call
     *             has been made on a connection which has been previously
     *             closed.
     */
    public SQLWarning getWarnings() throws SQLException;

    /**
     * Returns a {@code boolean} indicating whether or not this connection is in
     * the {@code closed} state. The {@code closed} state may be entered into as
     * a consequence of a successful invocation of the {@link #close()} method
     * or else if an error has occurred that prevents the connection from
     * functioning normally.
     * 
     * @return {@code true} if closed, otherwise {@code false}.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public boolean isClosed() throws SQLException;

    /**
     * Returns a {@code boolean} indicating whether or not this connection is
     * currently in the {@code read-only} state.
     * 
     * @return {@code true} if in read-only state, otherwise {@code false}.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public boolean isReadOnly() throws SQLException;

    /**
     * Returns a string representation of the input SQL statement
     * {@code sql} expressed in the underlying system's native SQL
     * syntax.
     * 
     * @param sql
     *            the JDBC form of an SQL statement.
     * @return the SQL statement in native database format.
     * @throws SQLException
     *             if there is a problem accessing the database
     */
    public String nativeSQL(String sql) throws SQLException;

    /**
     * Returns a new instance of {@code CallableStatement} that may be used for
     * making stored procedure calls to the database.
     * 
     * @param sql
     *            the SQL statement that calls the stored function
     * @return a new instance of {@code CallableStatement} representing the SQL
     *         statement. {@code ResultSet}s emitted from this {@code
     *         CallableStatement} will default to type
     *         {@link ResultSet#TYPE_FORWARD_ONLY} and concurrency
     *         {@link ResultSet#CONCUR_READ_ONLY}.
     * @throws SQLException
     *             if a problem occurs accessing the database.
     */
    public CallableStatement prepareCall(String sql) throws SQLException;

    /**
     * Returns a new instance of {@code CallableStatement} that may be used for
     * making stored procedure calls to the database. {@code ResultSet}s emitted
     * from this {@code CallableStatement} will satisfy the specified {@code
     * resultSetType} and {@code resultSetConcurrency} values.
     * 
     * @param sql
     *            the SQL statement
     * @param resultSetType
     *            one of the following type specifiers:
     *            <ul>
     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}</li>
     *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}</li>
     *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}</li>
     *            </ul>
     * @param resultSetConcurrency
     *            one of the following concurrency mode specifiers:
     *            <ul>
     *            <li>{@link ResultSet#CONCUR_READ_ONLY}</li>
     *            <li>{@link ResultSet#CONCUR_UPDATABLE}</li>
     *            </ul>
     * @return a new instance of {@code CallableStatement} representing the
     *         precompiled SQL statement. {@code ResultSet}s emitted from this
     *         {@code CallableStatement} will satisfy the specified {@code
     *         resultSetType} and {@code resultSetConcurrency} values.
     * @throws SQLException
     *             if a problem occurs accessing the database
     */
    public CallableStatement prepareCall(String sql, int resultSetType,
            int resultSetConcurrency) throws SQLException;

    /**
     * Returns a new instance of {@code CallableStatement} that may be used for
     * making stored procedure calls to the database. {@code ResultSet}s created
     * from this {@code CallableStatement} will have characteristics determined
     * by the specified type, concurrency and holdability arguments.
     * 
     * @param sql
     *            the SQL statement
     * @param resultSetType
     *            one of the following type specifiers:
     *            <ul>
     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}</li>
     *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}</li>
     *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}</li>
     *            </ul>
     * @param resultSetConcurrency
     *            one of the following concurrency mode specifiers:
     *            <ul>
     *            <li>{@link ResultSet#CONCUR_READ_ONLY}</li>
     *            <li>{@link ResultSet#CONCUR_UPDATABLE}</li>
     *            </ul>
     * @param resultSetHoldability
     *            one of the following holdability mode specifiers:
     *            <ul>
     *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}</li>
     *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}</li>
     *            </ul>
     * @return a new instance of {@code CallableStatement} representing the
     *         precompiled SQL statement. {@code ResultSet}s emitted from this
     *         {@code CallableStatement} will satisfy the specified {@code
     *         resultSetType}, {@code resultSetConcurrency} and {@code
     *         resultSetHoldability} values.
     * @throws SQLException
     *             if a problem occurs accessing the database.
     */
    public CallableStatement prepareCall(String sql, int resultSetType,
            int resultSetConcurrency, int resultSetHoldability)
            throws SQLException;

    /**
     * Returns a new instance of {@code PreparedStatement} that may be used any
     * number of times to execute parameterized requests on the database server.
     * <p>
     * Subject to JDBC driver support, this operation will attempt to send the
     * precompiled version of the statement to the database. If
     * the driver does not support precompiled statements, the statement will
     * not reach the database server until it is executed. This distinction
     * determines the moment when {@code SQLException}s get raised.
     * <p>
     * By default, {@code ResultSet}s from the returned object will be
     * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
     * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency.
     * 
     * @param sql
     *            the SQL statement.
     * @return the {@code PreparedStatement} containing the supplied SQL
     *         statement.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public PreparedStatement prepareStatement(String sql) throws SQLException;

    /**
     * Creates a default {@code PreparedStatement} that can retrieve
     * automatically generated keys. Parameter {@code autoGeneratedKeys} may be
     * used to tell the driver whether such keys should be made accessible.
     * This is only relevant when the {@code sql} statement is an {@code insert}
     * statement.
     * <p>
     * An SQL statement which may have {@code IN} parameters can be stored and
     * precompiled in a {@code PreparedStatement}. The {@code PreparedStatement}
     * can then be then be used to execute the statement multiple times in an
     * efficient way.
     * <p>
     * Subject to JDBC driver support, this operation will attempt to send the
     * precompiled version of the statement to the database. If
     * the driver does not support precompiled statements, the statement will
     * not reach the database server until it is executed. This distinction
     * determines the moment when {@code SQLException}s get raised.
     * <p>
     * By default, {@code ResultSet}s from the returned object will be
     * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
     * {@link ResultSet#CONCUR_READ_ONLY} mode of concurrency.
     *
     * @param sql
     *            the SQL statement.
     * @param autoGeneratedKeys
     *            one of the following generated key options:
     *            <ul>
     *            <li>{@link Statement#RETURN_GENERATED_KEYS}</li>
     *            <li>{@link Statement#NO_GENERATED_KEYS}</li>
     *            </ul>
     * @return a new {@code PreparedStatement} instance representing the input
     *         SQL statement.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
            throws SQLException;

    /**
     * Creates a default {@code PreparedStatement} that can retrieve the
     * auto-generated keys designated by a supplied array. If {@code sql} is an
     * SQL {@code INSERT} statement, the parameter {@code columnIndexes} is expected
     * to hold the index values for each column in the statement's intended
     * database table containing the autogenerated-keys of interest. Otherwise
     * {@code columnIndexes} is ignored.
     * <p>
     * Subject to JDBC driver support, this operation will attempt to send the
     * precompiled version of the statement to the database. If
     * the driver does not support precompiled statements, the statement will
     * not reach the database server until it is executed. This distinction
     * determines the moment when {@code SQLException}s get raised.
     * <p>
     * By default, {@code ResultSet}s from the returned object will be
     * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
     * {@link ResultSet#CONCUR_READ_ONLY} concurrency mode.
     *
     * @param sql
     *            the SQL statement.
     * @param columnIndexes
     *            the indexes of the columns for which auto-generated keys
     *            should be made available.
     * @return the PreparedStatement containing the supplied SQL statement.
     * @throws SQLException
     *             if a problem occurs accessing the database.
     */
    public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
            throws SQLException;

    /**
     * Creates a {@code PreparedStatement} that generates {@code ResultSet}s
     * with the specified values of {@code resultSetType} and {@code
     * resultSetConcurrency}.
     * 
     * @param sql
     *            the SQL statement. It can contain one or more {@code '?'}
     *            {@code IN} parameter placeholders.
     * @param resultSetType
     *            one of the following type specifiers:
     *            <ul>
     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}</li>
     *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}</li>
     *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}</li>
     *            </ul>
     * @param resultSetConcurrency
     *            one of the following concurrency mode specifiers:
     *            <ul>
     *            <li>{@link ResultSet#CONCUR_READ_ONLY}</li>
     *            <li>{@link ResultSet#CONCUR_UPDATABLE}</li>
     *            </ul>
     * @return a new instance of {@code PreparedStatement} containing the SQL
     *         statement {@code sql}. {@code ResultSet}s emitted from this
     *         {@code PreparedStatement} will satisfy the specified {@code
     *         resultSetType} and {@code resultSetConcurrency} values.
     * @throws SQLException
     *             if a problem occurs accessing the database.
     */
    public PreparedStatement prepareStatement(String sql, int resultSetType,
            int resultSetConcurrency) throws SQLException;

    /**
     * Creates a {@code PreparedStatement} that generates {@code ResultSet}s
     * with the specified type, concurrency and holdability
     * 
     * @param sql
     *            the SQL statement. It can contain one or more {@code '?' IN}
     *            parameter placeholders.
     * @param resultSetType
     *            one of the following type specifiers:
     *            <ul>
     *            <li>{@link ResultSet#TYPE_SCROLL_SENSITIVE}</li>
     *            <li>{@link ResultSet#TYPE_SCROLL_INSENSITIVE}</li>
     *            <li>{@link ResultSet#TYPE_FORWARD_ONLY}</li>
     *            </ul>
     * @param resultSetConcurrency
     *            one of the following concurrency mode specifiers:
     *            <ul>
     *            <li>{@link ResultSet#CONCUR_READ_ONLY}</li>
     *            <li>{@link ResultSet#CONCUR_UPDATABLE}</li>
     *            </ul>
     * @param resultSetHoldability
     *            one of the following holdability mode specifiers:
     *            <ul>
     *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}</li>
     *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}</li>
     *            </ul>
     * @return a new instance of {@code PreparedStatement} containing the SQL
     *         statement {@code sql}. {@code ResultSet}s emitted from this
     *         {@code PreparedStatement} will satisfy the specified {@code
     *         resultSetType}, {@code resultSetConcurrency} and {@code
     *         resultSetHoldability} values.
     * @throws SQLException
     *             if a problem occurs accessing the database.
     */
    public PreparedStatement prepareStatement(String sql, int resultSetType,
            int resultSetConcurrency, int resultSetHoldability)
            throws SQLException;

    /**
     * Creates a default {@code PreparedStatement} that can retrieve the
     * auto-generated keys designated by a supplied array. If {@code sql} is an
     * SQL {@code INSERT} statement, {@code columnNames} is expected to hold the
     * names of each column in the statement's associated database table
     * containing the autogenerated-keys of interest. Otherwise {@code
     * columnNames} is ignored.
     * <p>
     * Subject to JDBC driver support, this operation will attempt to send the
     * precompiled version of the statement to the database. Alternatively, if
     * the driver is not capable of handling precompiled statements, the
     * statement will not reach the database server until it is executed. This
     * will have a bearing on precisely <i>when</i> {@code SQLException}
     * instances get raised.
     * <p>
     * By default, ResultSets from the returned object will be
     * {@link ResultSet#TYPE_FORWARD_ONLY} type with a
     * {@link ResultSet#CONCUR_READ_ONLY} concurrency mode.
     *
     * @param sql
     *            the SQL statement.
     * @param columnNames
     *            the names of the columns for which auto-generated keys should
     *            be made available.
     * @return the PreparedStatement containing the supplied SQL statement.
     * @throws SQLException
     *             if a problem occurs accessing the database.
     */
    public PreparedStatement prepareStatement(String sql, String[] columnNames)
            throws SQLException;

    /**
     * Releases the specified {@code savepoint} from the present transaction. Once removed,
     * the {@code Savepoint} is considered invalid and should not be referenced
     * further.
     * 
     * @param savepoint
     *            the object targeted for removal.
     * @throws SQLException
     *             if there is a problem with accessing the database or if
     *             {@code savepoint} is considered not valid in this
     *             transaction.
     */
    public void releaseSavepoint(Savepoint savepoint) throws SQLException;

    /**
     * Rolls back all updates made so far in this transaction and
     * relinquishes all acquired database locks. It is an error to invoke this
     * operation when in auto-commit mode.
     * 
     * @throws SQLException
     *             if there is a problem with the database or if the method is
     *             called while in auto-commit mode of operation.
     */
    public void rollback() throws SQLException;

    /**
     * Undoes all changes made after the supplied {@code Savepoint} object was
     * set. This method should only be used when auto-commit mode is disabled.
     * 
     * @param savepoint
     *            the Savepoint to roll back to
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public void rollback(Savepoint savepoint) throws SQLException;

    /**
     * Sets this connection's auto-commit mode {@code on} or {@code off}.
     * <p>
     * Putting a Connection into auto-commit mode means that all associated SQL
     * statements are run and committed as separate transactions.
     * By contrast, setting auto-commit to {@code off} means that associated SQL
     * statements get grouped into transactions that need to be completed by
     * explicit calls to either the {@link #commit()} or {@link #rollback()}
     * methods.
     * <p>
     * Auto-commit is the default mode for new connection instances.
     * <p>
     * When in this mode, commits will automatically occur upon successful SQL
     * statement completion or upon successful completion of an execute.
     * Statements are not considered successfully completed until all associated
     * {@code ResultSet}s and output parameters have been obtained or closed.
     * <p>
     * Calling this operation during an uncommitted transaction will result in
     * it being committed.
     *
     * @param autoCommit
     *            {@code boolean} indication of whether to put the target
     *            connection into auto-commit mode ({@code true}) or not (
     *            {@code false}).
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public void setAutoCommit(boolean autoCommit) throws SQLException;

    /**
     * Sets the catalog name for this connection. This is used to select a
     * subspace of the database for future work. If the driver does not support
     * catalog names, this method is ignored.
     * 
     * @param catalog
     *            the catalog name to use.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public void setCatalog(String catalog) throws SQLException;

    /**
     * Sets the holdability of the {@code ResultSet}s created by this Connection.
     * 
     * @param holdability
     *            one of the following holdability mode specifiers:
     *            <ul>
     *            <li>{@link ResultSet#CLOSE_CURSORS_AT_COMMIT}</li>
     *            <li>{@link ResultSet#HOLD_CURSORS_OVER_COMMIT}</li>
     *            <li>
     *            </ul>
     * @throws SQLException
     *             if there is a problem accessing the database
     */
    public void setHoldability(int holdability) throws SQLException;

    /**
     * Sets this connection to read-only mode.
     * <p>
     * This serves as a hint to the driver, which can enable database
     * optimizations.
     *
     * @param readOnly
     *            {@code true} to set the Connection to read only mode. {@code
     *            false} disables read-only mode.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public void setReadOnly(boolean readOnly) throws SQLException;

    /**
     * Creates an unnamed {@code Savepoint} in the current transaction.
     * 
     * @return a {@code Savepoint} object for this savepoint.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public Savepoint setSavepoint() throws SQLException;

    /**
     * Creates a named {@code Savepoint} in the current transaction.
     * 
     * @param name
     *            the name to use for the new {@code Savepoint}.
     * @return a {@code Savepoint} object for this savepoint.
     * @throws SQLException
     *             if there is a problem accessing the database.
     */
    public Savepoint setSavepoint(String name) throws SQLException;

    /**
     * Sets the transaction isolation level for this Connection.
     * <p>
     * If this method is called during a transaction, the results are
     * implementation defined.
     *
     * @param level
     *            the new transaction isolation level to use from the following
     *            list of possible values:
     *            <ul>
     *            <li>{@link #TRANSACTION_READ_COMMITTED}
     *            <li>{@link #TRANSACTION_READ_UNCOMMITTED}
     *            <li>{@link #TRANSACTION_REPEATABLE_READ}
     *            <li>{@link #TRANSACTION_SERIALIZABLE}
     *            </ul>
     * @throws SQLException
     *             if there is a problem with the database or if the value of
     *             {@code level} is not one of the expected constant values.
     */
    public void setTransactionIsolation(int level) throws SQLException;

    /**
     * Sets the {@code TypeMap} for this connection. The input {@code map}
     * should contain mappings between complex Java and SQL types.
     * 
     * @param map
     *            the new type map.
     * @throws SQLException
     *             if there is a problem accessing the database or if {@code
     *             map} is not an instance of {@link Map}.
     */
    public void setTypeMap(Map<String, Class<?>> map) throws SQLException;
}