javax.sql.RowSet group of interfaces, can be customized to
use and update data from a spread sheet, flat file, or any other tabular 
data source.
java.sql package, referred to as the JDBC core API,
and the javax.sql package, referred to as the JDBC Optional
Package API. This complete JDBC API
is included in the JavaTM  
Standard Edition (Java SETM), version 7.
The javax.sql package 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 JavaTM  Enterprise Edition
(Java EETM) technology. 
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 JavadocTM comments for the JDBC API, they indicate the following:
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
JavaTM 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.
java.sql Package Containsjava.sql package contains API for the following:
DriverManager facility
  DriverManager class -- makes a connection with a driver
	 SQLPermission class -- provides permission when code
                  running within a Security Manager, such as an applet,
                  attempts to set up a logging stream through the
                  DriverManager
	 Driver interface -- provides the API for registering
             and connecting drivers based on JDBC technology ("JDBC drivers"); 
             generally used only by the DriverManager class
	 DriverPropertyInfo class -- provides properties for a
             JDBC driver; not used by the general user
  Statement --  used to send basic SQL statements
	 PreparedStatement --  used to send prepared statements or 
              basic SQL statements (derived from Statement)
	 CallableStatement --  used to call database stored 
              procedures (derived from PreparedStatement)
	 Connection interface --  provides methods for creating
             statements and managing connections and their properties
	 Savepoint --  provides savepoints in a transaction
  ResultSet interface
  Array interface -- mapping for SQL ARRAY 
	 Blob interface -- mapping for SQL BLOB 
	 Clob interface -- mapping for SQL CLOB
	 Date class -- mapping for SQL DATE 
	  NClob interface -- mapping for SQL NCLOB
	 Ref interface -- mapping for SQL REF 
	  RowId interface -- mapping for SQL ROWID
	 Struct interface -- mapping for SQL STRUCT 
	  SQLXML interface -- mapping for SQL XML
	 Time class -- mapping for SQL TIME 
	 Timestamp class -- mapping for SQL TIMESTAMP 
	 Types class -- provides constants for SQL types
  SQLData interface -- specifies the mapping of
              a UDT to an instance of this class
	 SQLInput interface -- provides methods for reading
              UDT attributes from a stream
	 SQLOutput interface -- provides methods for writing
              UDT attributes back to a stream
  DatabaseMetaData interface -- provides information
              about the database
	 ResultSetMetaData interface -- provides information
              about the columns of a ResultSet object
	 ParameterMetaData interface -- provides information
              about the parameters to PreparedStatement commands
  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
	
java.sql and javax.sql Features Introduced in the JDBC 4.1 APIConnection,
        ResultSet and Statement objects to be
        used with the try-with-resources statementCallableStatement and
        ResultSet to specify the Java type to convert to via the
        getObject methodDatabaseMetaData methods to return PseudoColumns and if a
        generated key is always returnedConnection to specify a database schema,
    abort and timeout a physical connection.Statement object when its dependent
    objects have been closedDriver,
     DataSource, ConnectionPoolDataSource and
     XADataSourcejava.sql and javax.sql Features Introduced in the JDBC 4.0 APIjava.sql.Driver class via Class.forName
 PreparedStatement that is associated
 with a PooledConnection has been closed or the driver determines is invalid
 
 
java.sql and javax.sql Features Introduced in the JDBC 3.0 APIConnectionPoolDataSource -- specify
      how connections are to be pooled
  PreparedStatement object
  ResultSet objects 
       returned from CallableStatement objects open at the
      same time
  CallableStatement
      objects by name as well as by index
  ResultSet holdability -- ability to specify whether cursors
      should be held open or closed at the end of a transaction
  Ref object references
  BLOB,
      CLOB, ARRAY, and REF values.
  java.sql.Types.DATALINK data type -- 
      allows JDBC drivers access to objects stored outside a data source
  
java.sql Features Introduced in the JDBC 2.1 Core APIResultSet
	  interface that allow the cursor to be moved to a particular row or to a
	  position relative to its current position
  ResultSet updater methods
  java.math.BigDecimal values,
	  additional security, and
	  support for time zones in date, time, and timestamp values. 
javax.sql Features Introduced in the JDBC 2.0 Optional
Package APIDataSource interface as a means of making a connection.  The
      Java Naming and Directory InterfaceTM
      (JNDI) is used for registering a DataSource object with a 
      naming service and also for  retrieving it.
  RowSet technology -- providing a convenient means of
       handling and passing data
DISTINCT
type are the UDTs that may be custom mapped.  The following three
steps set up a custom mapping:
DISTINCT type in SQL
  SQLData interface.
  Connection object's type map
      that contains two things:
   Class object for the class that implements the 
           SQLData interface
   
When these are in place for a UDT, calling the methods
ResultSet.getObject or 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.
@since 1.1