javax.sql.RowSetgroup of interfaces, can be customized to use and update data from a spread sheet, flat file, or any other tabular data source.
What the JDBC™ 4.3 API IncludesThe JDBC™ 4.3 API includes both the
java.sqlpackage, referred to as the JDBC core API, and the
javax.sqlpackage, referred to as the JDBC Optional Package API. This complete JDBC API is included in the Java™ Standard Edition (Java SE™), version 7. The
javax.sqlpackage extends the functionality of the JDBC API from a client-side API to a server-side API, and it is an essential part of the Java™ Enterprise Edition (Java EE™) technology.
VersionsThe JDBC 4.3 API incorporates all of the previous JDBC API versions:
- The JDBC 4.2 API
- The JDBC 4.1 API
- The JDBC 4.0 API
- The JDBC 3.0 API
- The JDBC 2.1 core API
- The JDBC 2.0 Optional Package API
(Note that the JDBC 2.1 core API and the JDBC 2.0 Optional Package API together are referred to as the JDBC 2.0 API.)
- The JDBC 1.2 API
- The JDBC 1.0 API
Classes, interfaces, methods, fields, constructors, and exceptions have the following "since" tags that indicate when they were introduced into the Java platform. When these "since" tags are used in Javadoc™ comments for the JDBC API, they indicate the following:
- Since 9 -- new in the JDBC 4.3 API and part of the Java SE platform, version 9
- Since 1.8 -- new in the JDBC 4.2 API and part of the Java SE platform, version 8
- Since 1.7 -- new in the JDBC 4.1 API and part of the Java SE platform, version 7
- Since 1.6 -- new in the JDBC 4.0 API and part of the Java SE platform, version 6
- Since 1.4 -- new in the JDBC 3.0 API and part of the J2SE platform, version 1.4
- Since 1.2 -- new in the JDBC 2.0 API and part of the J2SE platform, version 1.2
- Since 1.1 or no "since" tag -- in the original JDBC 1.0 API and part of the JDK™, version 1.1
NOTE: Many of the new features are optional; consequently, there is some variation in drivers and the features they support. Always check your driver's documentation to see whether it supports a feature before you try to use it.
NOTE: The class
SQLPermission was added in the Java™ 2 SDK, Standard Edition, version 1.3 release. This class is used to prevent unauthorized access to the logging stream associated with the
DriverManager, which may contain information such as table names, column data, and so on.
What the The
java.sql Package Contains
java.sqlpackage contains API for the following:
- Making a connection with a database via the
DriverManagerclass -- makes a connection with a driver
SQLPermissionclass -- provides permission when code running within a Security Manager, such as an applet, attempts to set up a logging stream through the
Driverinterface -- provides the API for registering and connecting drivers based on JDBC technology ("JDBC drivers"); generally used only by the
DriverPropertyInfoclass -- provides properties for a JDBC driver; not used by the general user
- Sending SQL statements to a database
Statement-- used to send basic SQL statements
PreparedStatement-- used to send prepared statements or basic SQL statements (derived from
CallableStatement-- used to call database stored procedures (derived from
Connectioninterface -- provides methods for creating statements and managing connections and their properties
Savepoint-- provides savepoints in a transaction
- Retrieving and updating the results of a query
- Standard mappings for SQL types to classes and interfaces in the Java programming language
Arrayinterface -- mapping for SQL
Blobinterface -- mapping for SQL
Clobinterface -- mapping for SQL
Dateclass -- mapping for SQL
NClobinterface -- mapping for SQL
Refinterface -- mapping for SQL
RowIdinterface -- mapping for SQL
Structinterface -- mapping for SQL
SQLXMLinterface -- mapping for SQL
Timeclass -- mapping for SQL
Timestampclass -- mapping for SQL
Typesclass -- provides constants for SQL types
- Custom mapping an SQL user-defined type (UDT) to a class in the Java programming language
SQLDatainterface -- specifies the mapping of a UDT to an instance of this class
SQLInputinterface -- provides methods for reading UDT attributes from a stream
SQLOutputinterface -- provides methods for writing UDT attributes back to a stream
DatabaseMetaDatainterface -- provides information about the database
ResultSetMetaDatainterface -- provides information about the columns of a
ParameterMetaDatainterface -- provides information about the parameters to
SQLException-- thrown by most methods when there is a problem accessing data and by some methods for other reasons
SQLWarning-- thrown to indicate a warning
DataTruncation-- thrown to indicate that data may have been truncated
BatchUpdateException-- thrown to indicate that not all commands in a batch update executed successfully
javax.sql Features Introduced in the JDBC 4.3 API
Connectionto be able to provide hints to the driver that a request, an independent unit of work, is beginning or ending
DatabaseMetaDatato determine if Sharding is supported
- Added the method
DriverManagerto return a Stream of the currently loaded and available JDBC drivers
- Added support to
Statementfor enquoting literals and simple identifiers
- Clarified the Java SE version that methods were deprecated
javax.sql Features Introduced in the JDBC 4.2 API
- Support for
DatabaseMetaDatamethods to return maximum Logical LOB size and if Ref Cursors are supported
- Added support for large update counts
javax.sql Features Introduced in the JDBC 4.1 API
Statementobjects to be used with the try-with-resources statement
- Support added to
ResultSetto specify the Java type to convert to via the
DatabaseMetaDatamethods to return PseudoColumns and if a generated key is always returned
- Added support to
Connectionto specify a database schema, abort and timeout a physical connection.
- Added support to close a
Statementobject when its dependent objects have been closed
- Support for obtaining the parent logger for a
javax.sql Features Introduced in the JDBC 4.0 API
- auto java.sql.Driver discovery -- no longer need to load a
- National Character Set support added
- Support added for the SQL:2003 XML data type
- SQLException enhancements -- Added support for cause chaining; New SQLExceptions added for common SQLState class value codes
- Enhanced Blob/Clob functionality -- Support provided to create and free a Blob/Clob instance as well as additional methods added to improve accessibility
- Support added for accessing a SQL ROWID
- Support added to allow a JDBC application to access an instance of a JDBC resource that has been wrapped by a vendor, usually in an application server or connection pooling environment.
- Availability to be notified when a
PreparedStatementthat is associated with a
PooledConnectionhas been closed or the driver determines is invalid
javax.sql Features Introduced in the JDBC 3.0 API
- Pooled statements -- reuse of statements associated with a pooled connection
- Savepoints -- allow a transaction to be rolled back to a designated savepoint
- Properties defined for
ConnectionPoolDataSource-- specify how connections are to be pooled
- Metadata for parameters of a
- Ability to retrieve values from automatically generated columns
- Ability to have multiple
ResultSetobjects returned from
CallableStatementobjects open at the same time
- Ability to identify parameters to
CallableStatementobjects by name as well as by index
ResultSetholdability -- ability to specify whether cursors should be held open or closed at the end of a transaction
- Ability to retrieve and update the SQL structured type instance that a
- Ability to programmatically update
- Addition of the
java.sql.Types.DATALINKdata type -- allows JDBC drivers access to objects stored outside a data source
- Addition of metadata for retrieving SQL type hierarchies
java.sql Features Introduced in the JDBC 2.1 Core API
- Scrollable result sets--using new methods in the
ResultSetinterface that allow the cursor to be moved to a particular row or to a position relative to its current position
- Batch updates
- Programmatic updates--using
- New data types--interfaces mapping the SQL3 data types
- Custom mapping of user-defined types (UDTs)
- Miscellaneous features, including performance hints, the use of character streams, full precision for
java.math.BigDecimalvalues, additional security, and support for time zones in date, time, and timestamp values.
javax.sql Features Introduced in the JDBC 2.0 Optional Package API
DataSourceinterface as a means of making a connection. The Java Naming and Directory Interface™ (JNDI) is used for registering a
DataSourceobject with a naming service and also for retrieving it.
- Pooled connections -- allowing connections to be used and reused
- Distributed transactions -- allowing a transaction to span diverse DBMS servers
RowSettechnology -- providing a convenient means of handling and passing data
Custom Mapping of UDTsA user-defined type (UDT) defined in SQL can be mapped to a class in the Java programming language. An SQL structured type or an SQL
DISTINCTtype are the UDTs that may be custom mapped. The following three steps set up a custom mapping:
- Defining the SQL structured type or
DISTINCTtype in SQL
- Defining the class in the Java programming language to which the SQL UDT will be mapped. This class must implement the
- Making an entry in a
Connectionobject's type map that contains two things:
- the fully-qualified SQL name of the UDT
Classobject for the class that implements the
When these are in place for a UDT, calling the methods
CallableStatement.getObject on that UDT will automatically retrieve the custom mapping for it. Also, the
PreparedStatement.setObject method will automatically map the object back to its SQL type to store it in the data source.
Interface Summary Interface Description ArrayThe mapping in the Java programming language for the SQL type
BlobThe representation (mapping) in the Java™ programming language of an SQL
CallableStatementThe interface used to execute SQL stored procedures. ClobThe mapping in the Java™ programming language for the SQL
ConnectionA connection (session) with a specific database. ConnectionBuilderA builder created from a
DataSourceobject, used to establish a connection to the database that the
data sourceobject represents.
DatabaseMetaDataComprehensive information about the database as a whole. DriverThe interface that every driver class must implement. DriverActionAn interface that must be implemented when a Driver wants to be notified by
NClobThe mapping in the Java™ programming language for the SQL
ParameterMetaDataAn object that can be used to get information about the types and properties for each parameter marker in a
PreparedStatementAn object that represents a precompiled SQL statement. RefThe mapping in the Java programming language of an SQL
REFvalue, which is a reference to an SQL structured type value in the database.
ResultSetA table of data representing a database result set, which is usually generated by executing a statement that queries the database. ResultSetMetaDataAn object that can be used to get information about the types and properties of the columns in a
RowIdThe representation (mapping) in the Java programming language of an SQL ROWID value. SavepointThe representation of a savepoint, which is a point within the current transaction that can be referenced from the
ShardingKeyInterface used to indicate that this object represents a Sharding Key. ShardingKeyBuilderA builder created from a
XADataSourceobject, used to create a
ShardingKeywith sub-keys of supported data types.
SQLDataThe interface used for the custom mapping of an SQL user-defined type (UDT) to a class in the Java programming language. SQLInputAn input stream that contains a stream of values representing an instance of an SQL structured type or an SQL distinct type. SQLOutputThe output stream for writing the attributes of a user-defined type back to the database. SQLTypeAn object that is used to identify a generic SQL type, called a JDBC type or a vendor specific data type. SQLXMLThe mapping in the JavaTM programming language for the SQL XML type. StatementThe object used for executing a static SQL statement and returning the results it produces. StructThe standard mapping in the Java programming language for an SQL structured type. WrapperInterface for JDBC classes which provide the ability to retrieve the delegate instance when the instance in question is in fact a proxy class.
Class Summary Class Description DateA thin wrapper around a millisecond value that allows JDBC to identify this as an SQL
DriverManagerThe basic service for managing a set of JDBC drivers. DriverPropertyInfoDriver properties for making a connection. SQLPermissionThe permission for which the
SecurityManagerwill check when code that is running an application with a
SecurityManagerenabled, calls the
Connection.setNetworkTimeoutmethod, or the
TimeA thin wrapper around the
java.util.Dateclass that allows the JDBC API to identify this as an SQL
TimestampA thin wrapper around
java.util.Datethat allows the JDBC API to identify this as an SQL
TypesThe class that defines the constants that are used to identify generic SQL types, called JDBC types.
Enum Summary Enum Description ClientInfoStatusEnumeration for status of the reason that a property could not be set via a call to
JDBCTypeDefines the constants that are used to identify generic SQL types, called JDBC types. PseudoColumnUsageEnumeration for pseudo/hidden column usage. RowIdLifetimeEnumeration for RowId life-time values.
Exception Summary Exception Description BatchUpdateExceptionThe subclass of
SQLExceptionthrown when an error occurs during a batch update operation.
DataTruncationAn exception thrown as a
DataTruncationexception (on writes) or reported as a
DataTruncationwarning (on reads) when a data values is unexpectedly truncated for reasons other than its having exceeded
SQLClientInfoExceptionThe subclass of
SQLExceptionis thrown when one or more client info properties could not be set on a
SQLDataExceptionThe subclass of
SQLExceptionthrown when the SQLState class value is '22', or under vendor-specified conditions.
SQLExceptionAn exception that provides information on a database access error or other errors. SQLFeatureNotSupportedExceptionThe subclass of
SQLExceptionthrown when the SQLState class value is '0A' ( the value is 'zero' A).
SQLIntegrityConstraintViolationExceptionThe subclass of
SQLExceptionthrown when the SQLState class value is '23', or under vendor-specified conditions.
SQLInvalidAuthorizationSpecExceptionThe subclass of
SQLExceptionthrown when the SQLState class value is '28', or under vendor-specified conditions.
SQLNonTransientConnectionExceptionThe subclass of
SQLExceptionthrown for the SQLState class value '08', or under vendor-specified conditions.
SQLNonTransientExceptionThe subclass of
SQLExceptionthrown when an instance where a retry of the same operation would fail unless the cause of the
SQLRecoverableExceptionThe subclass of
SQLExceptionthrown in situations where a previously failed operation might be able to succeed if the application performs some recovery steps and retries the entire transaction or in the case of a distributed transaction, the transaction branch.
SQLSyntaxErrorExceptionThe subclass of
SQLExceptionthrown when the SQLState class value is '42', or under vendor-specified conditions.
SQLTimeoutExceptionThe subclass of
SQLExceptionthrown when the timeout specified by
SQLTransactionRollbackExceptionThe subclass of
SQLExceptionthrown when the SQLState class value is '40', or under vendor-specified conditions.
SQLTransientConnectionExceptionThe subclass of
SQLExceptionfor the SQLState class value '08', or under vendor-specified conditions.
SQLTransientExceptionThe subclass of
SQLExceptionis thrown in situations where a previously failed operation might be able to succeed when the operation is retried without any intervention by application-level functionality.
SQLWarningAn exception that provides information on database access warnings.