|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
public interface Connection
A connection (session) with a specific database. SQL statements are executed and results are returned within the context of a connection.
A Connection object'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 obtained with the getMetaData method.
Note: By default a Connection object is in
auto-commit mode, which means that it automatically commits changes
after executing each statement. If auto-commit mode has been
disabled, the method commit must be called explicitly in
order to commit changes; otherwise, database changes will not be saved.
A new Connection object created using the JDBC 2.1 core API
has an initially empty type map associated with it. A user may enter a
custom mapping for a UDT in this type map.
When a UDT is retrieved from a data source with the
method ResultSet.getObject, the getObject method
will check the connection's type map to see if there is an entry for that
UDT. If so, the getObject method will map the UDT to the
class indicated. If there is no entry, the UDT will be mapped using the
standard mapping.
A user may create a new type map, which is a java.util.Map
object, make an entry in it, and pass it to the java.sql
methods that can perform custom mapping. In this case, the method
will use the given type map instead of the one associated with
the connection.
For example, the following code fragment specifies that the SQL
type ATHLETES will be mapped to the class
Athletes in the Java programming language.
The code fragment retrieves the type map for the Connection
object con, inserts the entry into it, and then sets
the type map with the new entry as the connection's type map.
java.util.Map map = con.getTypeMap();
map.put("mySchemaName.ATHLETES", Class.forName("Athletes"));
con.setTypeMap(map);
DriverManager.getConnection(java.lang.String, java.util.Properties)
,
Statement
,
ResultSet
,
DatabaseMetaData

| Field Summary | |
|---|---|
static int |
TRANSACTION_NONE
A constant indicating that transactions are not supported. |
static int |
TRANSACTION_READ_COMMITTED
A constant indicating that dirty reads are prevented; non-repeatable reads and phantom reads can occur. |
static int |
TRANSACTION_READ_UNCOMMITTED
A constant indicating that dirty reads, non-repeatable reads and phantom reads can occur. |
static int |
TRANSACTION_REPEATABLE_READ
A constant indicating that dirty reads and non-repeatable reads are prevented; phantom reads can occur. |
static int |
TRANSACTION_SERIALIZABLE
A constant indicating that dirty reads, non-repeatable reads and phantom reads are prevented. |
| Method Summary | |
|---|---|
void |
clearWarnings
Clears all warnings reported for this Connection object. |
void |
close
Releases this Connection object's database and JDBC resources
immediately instead of waiting for them to be automatically released. |
void |
commit
Makes all changes made since the previous commit/rollback permanent and releases any database locks currently held by this Connection object. |
Statement |
createStatement
Creates a Statement object for sending
SQL statements to the database. |
Statement |
createStatement
Creates a Statement object that will generate
ResultSet objects with the given type and concurrency. |
Statement |
createStatement
Creates a Statement object that will generate
ResultSet objects with the given type, concurrency,
and holdability. |
boolean |
getAutoCommit
Retrieves the current auto-commit mode for this Connection
object. |
String |
getCatalog
Retrieves this Connection object's current catalog name. |
int |
getHoldability
Retrieves the current holdability of ResultSet objects
created using this Connection object. |
DatabaseMetaData |
getMetaData
Retrieves a DatabaseMetaData object that contains
metadata about the database to which this
Connection object represents a connection. |
int |
getTransactionIsolation
Retrieves this Connection object's current
transaction isolation level. |
Map |
getTypeMap
Retrieves the Map object associated with this
Connection object. |
SQLWarning |
getWarnings
Retrieves the first warning reported by calls on this Connection object. |
boolean |
isClosed
Retrieves whether this Connection object has been
closed. |
boolean |
isReadOnly
Retrieves whether this Connection
object is in read-only mode. |
String |
nativeSQL
Converts the given SQL statement into the system's native SQL grammar. |
CallableStatement |
prepareCall
Creates a CallableStatement object for calling
database stored procedures. |
CallableStatement |
prepareCall
Creates a CallableStatement object that will generate
ResultSet objects with the given type and concurrency. |
CallableStatement |
prepareCall
Creates a CallableStatement object that will generate
ResultSet objects with the given type and concurrency. |
PreparedStatement |
prepareStatement
Creates a PreparedStatement object for sending
parameterized SQL statements to the database. |
PreparedStatement |
prepareStatement
Creates a default PreparedStatement object that has
the capability to retrieve auto-generated keys. |
PreparedStatement |
prepareStatement
Creates a default PreparedStatement object capable
of returning the auto-generated keys designated by the given array. |
PreparedStatement |
prepareStatement
Creates a PreparedStatement object that will generate
ResultSet objects with the given type and concurrency. |
PreparedStatement |
prepareStatement
Creates a PreparedStatement object that will generate
ResultSet objects with the given type, concurrency,
and holdability. |
PreparedStatement |
prepareStatement
Creates a default PreparedStatement object capable
of returning the auto-generated keys designated by the given array. |
void |
releaseSavepoint
Removes the given Savepoint object from the current
transaction. |
void |
rollback
Undoes all changes made in the current transaction and releases any database locks currently held by this Connection object. |
void |
rollback
Undoes all changes made after the given Savepoint object
was set. |
void |
setAutoCommit
Sets this connection's auto-commit mode to the given state. |
void |
setCatalog
Sets the given catalog name in order to select a subspace of this Connection object's database
in which to work. |
void |
setHoldability
Changes the holdability of ResultSet objects
created using this Connection object to the given
holdability. |
void |
setReadOnly
Puts this connection in read-only mode as a hint to the driver to enable database optimizations. |
Savepoint |
setSavepoint
Creates an unnamed savepoint in the current transaction and returns the new Savepoint object that represents it. |
Savepoint |
setSavepoint
Creates a savepoint with the given name in the current transaction and returns the new Savepoint object that represents it. |
void |
setTransactionIsolation
Attempts to change the transaction isolation level for this Connection object to the one given. |
void |
setTypeMap
Installs the given TypeMap object as the type map for
this Connection object. |
| Field Detail |
|---|

static final int TRANSACTION_NONE

static final int TRANSACTION_READ_UNCOMMITTED

static final int TRANSACTION_READ_COMMITTED

static final int TRANSACTION_REPEATABLE_READ

static final int TRANSACTION_SERIALIZABLE
TRANSACTION_REPEATABLE_READ and further prohibits the
situation where one transaction reads all rows that satisfy
a WHERE condition, a second transaction inserts a row that
satisfies that WHERE condition, and the first transaction
rereads for the same condition, retrieving the additional
"phantom" row in the second read.
| Method Detail |
|---|

Statement![]()
![]()
createStatement() throws SQLException
![]()
![]()
Statement object for sending
SQL statements to the database.
SQL statements without parameters are normally
executed using Statement objects. If the same SQL statement
is executed many times, it may be more efficient to use a
PreparedStatement object.
Result sets created using the returned Statement
object will by default be type TYPE_FORWARD_ONLY
and have a concurrency level of CONCUR_READ_ONLY.
Statement object
SQLException

- if a database access error occurs

PreparedStatement![]()
![]()
prepareStatement(String
![]()
![]()
sql) throws SQLException
![]()
![]()
PreparedStatement object for sending
parameterized SQL statements to the database.
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.
Note: This method is optimized for handling
parametric SQL statements that benefit from precompilation. If
the driver supports precompilation,
the method prepareStatement 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 PreparedStatement
object is executed. This has no direct effect on users; however, it does
affect which methods throw certain SQLException objects.
Result sets created using the returned PreparedStatement
object will by default be type TYPE_FORWARD_ONLY
and have a concurrency level of CONCUR_READ_ONLY.
sql - an SQL statement that may contain one or more '?' IN
parameter placeholders
PreparedStatement object containing the
pre-compiled SQL statement
SQLException

- if a database access error occurs

CallableStatement![]()
![]()
prepareCall(String
![]()
![]()
sql) throws SQLException
![]()
![]()
CallableStatement object for calling
database stored procedures.
The CallableStatement object provides
methods for setting up its IN and OUT parameters, and
methods for executing the call to a stored procedure.
Note: This method is optimized for handling stored
procedure call statements. Some drivers may send the call
statement to the database when the method prepareCall
is done; others
may wait until the CallableStatement object
is executed. This has no
direct effect on users; however, it does affect which method
throws certain SQLExceptions.
Result sets created using the returned CallableStatement
object will by default be type TYPE_FORWARD_ONLY
and have a concurrency level of CONCUR_READ_ONLY.
sql - an SQL statement that may contain one or more '?'
parameter placeholders. Typically this statement is a JDBC
function call escape string.
CallableStatement object containing the
pre-compiled SQL statement
SQLException

- if a database access error occurs

String![]()
![]()
nativeSQL(String
![]()
![]()
sql) throws SQLException
![]()
![]()
sql - an SQL statement that may contain one or more '?'
parameter placeholders
SQLException

- if a database access error occurs

void setAutoCommit(boolean autoCommit)
throws SQLException

commit or the method rollback.
By default, new connections are in auto-commit
mode.
The commit occurs when the statement completes or the next
execute occurs, whichever comes first. In the case of
statements returning a ResultSet object,
the statement completes when the last row of the
ResultSet object has been retrieved or the
ResultSet object 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.
NOTE: If this method is called during a transaction, the transaction is committed.
autoCommit - true to enable auto-commit mode;
false to disable it
SQLException

- if a database access error occursgetAutoCommit()


boolean getAutoCommit()
throws SQLException

Connection
object.
Connection object's
auto-commit mode
SQLException

- if a database access error occurssetAutoCommit(boolean)


void commit()
throws SQLException

Connection object.
This method should be
used only when auto-commit mode has been disabled.
SQLException

- if a database access error occurs or this
Connection object is in auto-commit modesetAutoCommit(boolean)


void rollback()
throws SQLException

Connection object. This method should be
used only when auto-commit mode has been disabled.
SQLException

- if a database access error occurs or this
Connection object is in auto-commit modesetAutoCommit(boolean)


void close()
throws SQLException

Connection object's database and JDBC resources
immediately instead of waiting for them to be automatically released.
Calling the method close on a Connection
object that is already closed is a no-op.
Note: A Connection object is automatically
closed when it is garbage collected. Certain fatal errors also
close a Connection object.
SQLException

- if a database access error occurs

boolean isClosed()
throws SQLException

Connection object has been
closed. A connection is closed if the method close
has been called on it or if certain fatal errors have occurred.
This method is guaranteed to return true only when
it is called after the method Connection.close has
been called.
This method generally cannot be called to determine whether a connection to a database is valid or invalid. A typical client can determine that a connection is invalid by catching any exceptions that might be thrown when an operation is attempted.
true if this Connection object
is closed; false if it is still open
SQLException

- if a database access error occurs

DatabaseMetaData![]()
![]()
getMetaData() throws SQLException
![]()
![]()
DatabaseMetaData object that contains
metadata about the database to which this
Connection object represents a connection.
The metadata includes information about the database's
tables, its supported SQL grammar, its stored
procedures, the capabilities of this connection, and so on.
DatabaseMetaData object for this
Connection object
SQLException

- if a database access error occurs

void setReadOnly(boolean readOnly)
throws SQLException

Note: This method cannot be called during a transaction.
readOnly - true enables read-only mode;
false disables it
SQLException

- if a database access error occurs or this
method is called during a transaction

boolean isReadOnly()
throws SQLException

Connection
object is in read-only mode.
true if this Connection object
is read-only; false otherwise
SQLException

- if a database access error occurs

void setCatalog(String![]()
![]()
catalog) throws SQLException
![]()
![]()
Connection object's database
in which to work.
If the driver does not support catalogs, it will silently ignore this request.
catalog - the name of a catalog (subspace in this
Connection object's database) in which to work
SQLException

- if a database access error occursgetCatalog()


String![]()
![]()
getCatalog() throws SQLException
![]()
![]()
Connection object's current catalog name.
null if there is none
SQLException

- if a database access error occurssetCatalog(java.lang.String)


void setTransactionIsolation(int level)
throws SQLException

Connection object to the one given.
The constants defined in the interface Connection
are the possible transaction isolation levels.
Note: If this method is called during a transaction, the result is implementation-defined.
level - one of the following Connection constants:
Connection.TRANSACTION_READ_UNCOMMITTED,
Connection.TRANSACTION_READ_COMMITTED,
Connection.TRANSACTION_REPEATABLE_READ, or
Connection.TRANSACTION_SERIALIZABLE.
(Note that Connection.TRANSACTION_NONE cannot be used
because it specifies that transactions are not supported.)
SQLException