/*
* 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>
*
* @since Android 1.0
*/
public interface Connection {
/**
* A constant indicating that transactions are not supported.
*
* @since Android 1.0
*/
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>.
*
* @since Android 1.0
*/
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>
*
* @since Android 1.0
*/
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.
*
* @since Android 1.0
*/
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>
*
* @since Android 1.0
*/
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.
* </p>
*
* @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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* </p>
*
* @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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* </p>
*
* @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.
* @since Android 1.0
*/
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>
* <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.
* </p>
*
* @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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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>
* <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.
* </p>
*
* @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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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>
* <p>
* Calling this operation during an uncommitted transaction will result in
* it being committed.
* </p>
*
* @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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* </p>
*
* @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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* @since Android 1.0
*/
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.
* </p>
*
* @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.
* @since Android 1.0
*/
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}.
* @since Android 1.0
*/
public void setTypeMap(Map<String, Class<?>> map) throws SQLException;
}
|
