/*
* Copyright (c) 1998, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
*
* Provides the API for accessing and processing data stored in a
* data source (usually a relational database) using the
* Java™ programming language.
* This API includes a framework whereby different
* drivers can be installed dynamically to access different data sources.
* Although the JDBC™ API is mainly geared
* to passing SQL statements to a database, it provides for reading and
* writing data from any data source with a tabular format.
* The reader/writer facility, available through the
* 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 Java™ Standard Edition (Java SE™), 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 Java™ Enterprise Edition
* (Java EE™) 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 * Javadoc™ 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
* 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.
*
*
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.3 APISharding
supportConnection
to be able to provide hints
* to the driver that a request, an independent unit of work,
* is beginning or endingDatabaseMetaData
to determine if Sharding is
* supporteddrivers
to DriverManager
* to return a Stream of the currently loaded and
* available JDBC driversStatement
for enquoting literals
* and simple identifiersjava.sql
and javax.sql
Features Introduced in the JDBC 4.2 APIJDBCType
enum and SQLType
interfaceREF CURSORS
in CallableStatement
* DatabaseMetaData
methods to return maximum Logical LOB size
* and if Ref Cursors are supportedjava.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
* XADataSource
java.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 Interface™
* (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.
*
*