IT. Expert System.

Android Reference

Connection


java.sql

Interface Connection

  • All Superinterfaces:
    AutoCloseable, Wrapper


    public interface Connection
    extends Wrapper, AutoCloseable
    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 transaction isolation levels):
    • dirty reads:
      reading values from table rows that are not committed.
    • non-repeatable reads:
      reading table rows more than once in a transaction but getting back different data because other transactions have altered the rows between the reads.
    • phantom reads:
      retrieving additional "phantom" rows in the course of repeated table reads because other transactions have inserted additional rows that satisfy an SQL WHERE clause
    • Field Summary

      Fields
      Modifier and Type Field and Description
      static int TRANSACTION_NONE
      A constant indicating that transactions are not supported.
      static int TRANSACTION_READ_COMMITTED
      No dirty reads are permitted, therefore transactions may not read a row containing uncommitted values - but does not prevent an application from non-repeatable reads and phantom reads.
      static int TRANSACTION_READ_UNCOMMITTED
      In the case that reading uncommitted values is allowed, the following incidents may happen which may lead to an invalid results: dirty reads non-repeatable reads phantom reads
      static int TRANSACTION_REPEATABLE_READ
      A constant indicating that dirty reads and non-repeatable reads are prevented but phantom reads can occur.
      static int TRANSACTION_SERIALIZABLE
      The constant that indicates that the following incidents are all prevented (the opposite of TRANSACTION_READ_UNCOMMITTED): dirty reads non-repeatable reads phantom reads
    • Method Summary

      Methods
      Modifier and Type Method and Description
      void clearWarnings()
      Discards all warnings that may have arisen for this connection.
      void close()
      Causes the instant release of all database and driver connection resources associated with this object.
      void commit()
      Commits all of the changes made since the last commit or rollback of the associated transaction.
      Array createArrayOf(String typeName, Object[] elements)
      Returns a new Array containing the given elements.
      Blob createBlob()
      Returns a new empty Blob.
      Clob createClob()
      Returns a new empty Clob.
      NClob createNClob()
      Returns a new empty NClob.
      SQLXML createSQLXML()
      Returns a new empty SQLXML.
      Statement createStatement()
      Returns a new instance of Statement for issuing SQL commands to the remote database.
      Statement createStatement(int resultSetType, int resultSetConcurrency)
      Returns a new instance of Statement whose associated ResultSets have the characteristics specified in the type and concurrency arguments.
      Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
      Returns a new instance of Statement whose associated ResultSets will have the characteristics specified in the type, concurrency and holdability arguments.
      Struct createStruct(String typeName, Object[] attributes)
      Returns a new Struct containing the given attributes.
      boolean getAutoCommit()
      Returns a boolean indicating whether or not this connection is in the auto-commit operating mode.
      String getCatalog()
      Gets this Connection object's current catalog name.
      Properties getClientInfo()
      Returns a Properties object containing all client info properties.
      String getClientInfo(String name)
      Returns the value corresponding to the given client info property, or null if unset.
      int getHoldability()
      Returns the holdability property that any ResultSet produced by this instance will have.
      DatabaseMetaData getMetaData()
      Gets the metadata about the database referenced by this connection.
      int getTransactionIsolation()
      Returns the transaction isolation level for this connection.
      Map<String,Class<?>> getTypeMap()
      Returns the type mapping associated with this Connection object.
      SQLWarning getWarnings()
      Gets the first instance of any SQLWarning objects that may have been created in the use of this connection.
      boolean isClosed()
      Returns a boolean indicating whether or not this connection is in the closed state.
      boolean isReadOnly()
      Returns a boolean indicating whether or not this connection is currently in the read-only state.
      boolean isValid(int timeout)
      Returns true if this connection is still open and valid, false otherwise.
      String nativeSQL(String sql)
      Returns a string representation of the input SQL statement sql expressed in the underlying system's native SQL syntax.
      CallableStatement prepareCall(String sql)
      Returns a new instance of CallableStatement that may be used for making stored procedure calls to the database.
      CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency)
      Returns a new instance of CallableStatement that may be used for making stored procedure calls to the database.
      CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
      Returns a new instance of CallableStatement that may be used for making stored procedure calls to the database.
      PreparedStatement prepareStatement(String sql)
      Returns a new instance of PreparedStatement that may be used any number of times to execute parameterized requests on the database server.
      PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
      Creates a default PreparedStatement that can retrieve automatically generated keys.
      PreparedStatement prepareStatement(String sql, int[] columnIndexes)
      Creates a default PreparedStatement that can retrieve the auto-generated keys designated by a supplied array.
      PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
      Creates a PreparedStatement that generates ResultSets with the specified values of resultSetType and resultSetConcurrency.
      PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
      Creates a PreparedStatement that generates ResultSets with the specified type, concurrency and holdability
      PreparedStatement prepareStatement(String sql, String[] columnNames)
      Creates a default PreparedStatement that can retrieve the auto-generated keys designated by a supplied array.
      void releaseSavepoint(Savepoint savepoint)
      Releases the specified savepoint from the present transaction.
      void rollback()
      Rolls back all updates made so far in this transaction and relinquishes all acquired database locks.
      void rollback(Savepoint savepoint)
      Undoes all changes made after the supplied Savepoint object was set.
      void setAutoCommit(boolean autoCommit)
      Sets this connection's auto-commit mode on or off.
      void setCatalog(String catalog)
      Sets the catalog name for this connection.
      void setClientInfo(Properties properties)
      Replaces all client info properties with the name/value pairs from properties.
      void setClientInfo(String name, String value)
      Sets the client info property name to value.
      void setHoldability(int holdability)
      Sets the holdability of the ResultSets created by this Connection.
      void setReadOnly(boolean readOnly)
      Sets this connection to read-only mode.
      Savepoint setSavepoint()
      Creates an unnamed Savepoint in the current transaction.
      Savepoint setSavepoint(String name)
      Creates a named Savepoint in the current transaction.
      void setTransactionIsolation(int level)
      Sets the transaction isolation level for this Connection.
      void setTypeMap(Map<String,Class<?>> map)
      Sets the TypeMap for this connection.
    • Field Detail

      • TRANSACTION_NONE

        static final int TRANSACTION_NONE
        A constant indicating that transactions are not supported.
        See Also:
        Constant Field Values
      • TRANSACTION_READ_COMMITTED

        static final int TRANSACTION_READ_COMMITTED
        No dirty reads are permitted, therefore transactions may not read a row containing uncommitted values - but does not prevent an application from non-repeatable reads and phantom reads.
        See Also:
        Constant Field Values
      • TRANSACTION_READ_UNCOMMITTED

        static final int TRANSACTION_READ_UNCOMMITTED
        In the case that reading uncommitted values is allowed, the following incidents may happen which may lead to an invalid results:
        • dirty reads
        • non-repeatable reads
        • phantom reads
        See Also:
        Constant Field Values
      • TRANSACTION_REPEATABLE_READ

        static final int TRANSACTION_REPEATABLE_READ
        A constant indicating that dirty reads and non-repeatable reads are prevented but phantom reads can occur.
        See Also:
        Constant Field Values
      • TRANSACTION_SERIALIZABLE

        static final int TRANSACTION_SERIALIZABLE
        The constant that indicates that the following incidents are all prevented (the opposite of TRANSACTION_READ_UNCOMMITTED):
        • dirty reads
        • non-repeatable reads
        • phantom reads
        See Also:
        Constant Field Values
    • Method Detail

      • clearWarnings

        void clearWarnings()
                           throws SQLException
        Discards all warnings that may have arisen for this connection. Subsequent calls to getWarnings() will return null up until a new warning condition occurs.
        Throws:
        SQLException - if there is a problem accessing the database.
      • close

        void close()
                   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.

        It is strongly recommended that all connections are closed before they are dereferenced by the application ready for garbage collection. Although the finalize method of the connection closes the connection before garbage collection takes place, it is not advisable to leave the close operation to take place in this way. Mainly because undesired side-effects may appear.

        Specified by:
        close in interface AutoCloseable
        Throws:
        SQLException - if there is a problem accessing the database.
      • commit

        void commit()
                    throws SQLException
        Commits all of the changes made since the last commit or rollback of the associated transaction. All locks in the database held by this connection are also relinquished. Calling this operation on connection objects in 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.
      • createStatement

        Statement createStatement()
                                  throws SQLException
        Returns a new instance of Statement for issuing SQL commands to the remote database.

        ResultSets generated by the returned statement will default to type ResultSet.TYPE_FORWARD_ONLY and concurrency level ResultSet.CONCUR_READ_ONLY.

        Returns:
        a Statement object with default settings.
        Throws:
        SQLException - if there is a problem accessing the database.
        See Also:
        ResultSet
      • getAutoCommit

        boolean getAutoCommit()
                              throws SQLException
        Returns a boolean indicating whether or not this connection is in the auto-commit operating mode.
        Returns:
        true if auto-commit is on, otherwise false.
        Throws:
        SQLException - if there is a problem accessing the database.
      • getCatalog

        String getCatalog()
                          throws SQLException
        Gets this Connection object's current catalog name.
        Returns:
        the catalog name. null if there is no catalog name.
        Throws:
        SQLException - if there is a problem accessing the database.
      • getMetaData

        DatabaseMetaData getMetaData()
                                     throws SQLException
        Gets the metadata about the database referenced by this connection. The returned DatabaseMetaData describes the database topography, available stored procedures, SQL syntax and so on.
        Returns:
        a DatabaseMetaData object containing the database description.
        Throws:
        SQLException - if there is a problem accessing the a database.
      • getTypeMap

        Map<String,Class<?>> getTypeMap()
                                        throws SQLException
        Returns the type mapping associated with this Connection object. The type mapping must be set on the application level.
        Returns:
        the Type Map as a java.util.Map.
        Throws:
        SQLException - if there is a problem accessing the database.
      • getWarnings

        SQLWarning getWarnings()
                               throws SQLException
        Gets the first instance of any 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 null indicates that no warnings have occurred.

        By invoking the SQLWarning.getNextWarning() method of the returned SQLWarning object it is possible to obtain all of this connection's warning objects.

        Returns:
        the first warning as an SQLWarning object (may be 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.
      • isClosed

        boolean isClosed()
                         throws SQLException
        Returns a boolean indicating whether or not this connection is in the closed state. The closed state may be entered into as a consequence of a successful invocation of the close() method or else if an error has occurred that prevents the connection from functioning normally.
        Returns:
        true if closed, otherwise false.
        Throws:
        SQLException - if there is a problem accessing the database.
      • isReadOnly

        boolean isReadOnly()
                           throws SQLException
        Returns a boolean indicating whether or not this connection is currently in the read-only state.
        Returns:
        true if in read-only state, otherwise false.
        Throws:
        SQLException - if there is a problem accessing the database.
      • nativeSQL

        String nativeSQL(String sql)
                         throws SQLException
        Returns a string representation of the input SQL statement sql expressed in the underlying system's native SQL syntax.
        Parameters:
        sql - the JDBC form of an SQL statement.
        Returns:
        the SQL statement in native database format.
        Throws:
        SQLException - if there is a problem accessing the database
      • prepareCall

        CallableStatement prepareCall(String sql)
                                      throws SQLException
        Returns a new instance of CallableStatement that may be used for making stored procedure calls to the database.
        Parameters:
        sql - the SQL statement that calls the stored function
        Returns:
        a new instance of CallableStatement representing the SQL statement. ResultSets emitted from this CallableStatement will default to type ResultSet.TYPE_FORWARD_ONLY and concurrency ResultSet.CONCUR_READ_ONLY.
        Throws:
        SQLException - if a problem occurs accessing the database.
      • prepareStatement

        PreparedStatement prepareStatement(String sql)
                                           throws SQLException
        Returns a new instance of PreparedStatement that may be used any number of times to execute parameterized requests on the database server.

        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 SQLExceptions get raised.

        By default, ResultSets from the returned object will be ResultSet.TYPE_FORWARD_ONLY type with a ResultSet.CONCUR_READ_ONLY mode of concurrency.

        Parameters:
        sql - the SQL statement.
        Returns:
        the PreparedStatement containing the supplied SQL statement.
        Throws:
        SQLException - if there is a problem accessing the database.
      • prepareStatement

        PreparedStatement prepareStatement(String sql,
                                         int autoGeneratedKeys)
                                           throws SQLException
        Creates a default PreparedStatement that can retrieve automatically generated keys. Parameter autoGeneratedKeys may be used to tell the driver whether such keys should be made accessible. This is only relevant when the sql statement is an insert statement.

        An SQL statement which may have IN parameters can be stored and precompiled in a PreparedStatement. The PreparedStatement can then be then be used to execute the statement multiple times in an efficient way.

        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 SQLExceptions get raised.

        By default, ResultSets from the returned object will be ResultSet.TYPE_FORWARD_ONLY type with a ResultSet.CONCUR_READ_ONLY mode of concurrency.

        Parameters:
        sql - the SQL statement.
        autoGeneratedKeys - one of the following generated key options:
        Returns:
        a new PreparedStatement instance representing the input SQL statement.
        Throws:
        SQLException - if there is a problem accessing the database.
      • prepareStatement

        PreparedStatement prepareStatement(String sql,
                                         int[] columnIndexes)
                                           throws SQLException
        Creates a default PreparedStatement that can retrieve the auto-generated keys designated by a supplied array. If sql is an SQL INSERT statement, the parameter 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 columnIndexes is ignored.

        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 SQLExceptions get raised.

        By default, ResultSets from the returned object will be ResultSet.TYPE_FORWARD_ONLY type with a ResultSet.CONCUR_READ_ONLY concurrency mode.

        Parameters:
        sql - the SQL statement.
        columnIndexes - the indexes of the columns for which auto-generated keys should be made available.
        Returns:
        the PreparedStatement containing the supplied SQL statement.
        Throws:
        SQLException - if a problem occurs accessing the database.
      • prepareStatement

        PreparedStatement prepareStatement(String sql,
                                         String[] columnNames)
                                           throws SQLException
        Creates a default PreparedStatement that can retrieve the auto-generated keys designated by a supplied array. If sql is an SQL INSERT statement, columnNames is expected to hold the names of each column in the statement's associated database table containing the autogenerated-keys of interest. Otherwise columnNames is ignored.

        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 when SQLException instances get raised.

        By default, ResultSets from the returned object will be ResultSet.TYPE_FORWARD_ONLY type with a ResultSet.CONCUR_READ_ONLY concurrency mode.

        Parameters:
        sql - the SQL statement.
        columnNames - the names of the columns for which auto-generated keys should be made available.
        Returns:
        the PreparedStatement containing the supplied SQL statement.
        Throws:
        SQLException - if a problem occurs accessing the database.
      • releaseSavepoint

        void releaseSavepoint(Savepoint savepoint)
                              throws SQLException
        Releases the specified savepoint from the present transaction. Once removed, the Savepoint is considered invalid and should not be referenced further.
        Parameters:
        savepoint - the object targeted for removal.
        Throws:
        SQLException - if there is a problem with accessing the database or if savepoint is considered not valid in this transaction.
      • rollback

        void rollback()
                      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.
      • rollback

        void rollback(Savepoint savepoint)
                      throws SQLException
        Undoes all changes made after the supplied Savepoint object was set. This method should only be used when auto-commit mode is disabled.
        Parameters:
        savepoint - the Savepoint to roll back to
        Throws:
        SQLException - if there is a problem accessing the database.
      • setAutoCommit

        void setAutoCommit(boolean autoCommit)
                           throws SQLException
        Sets this connection's auto-commit mode on or off.

        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 off means that associated SQL statements get grouped into transactions that need to be completed by explicit calls to either the commit() or rollback() methods.

        Auto-commit is the default mode for new connection instances.

        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 ResultSets and output parameters have been obtained or closed.

        Calling this operation during an uncommitted transaction will result in it being committed.

        Parameters:
        autoCommit - boolean indication of whether to put the target connection into auto-commit mode (true) or not ( false).
        Throws:
        SQLException - if there is a problem accessing the database.
      • setCatalog

        void setCatalog(String catalog)
                        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.
        Parameters:
        catalog - the catalog name to use.
        Throws:
        SQLException - if there is a problem accessing the database.
      • setReadOnly

        void setReadOnly(boolean readOnly)
                         throws SQLException
        Sets this connection to read-only mode.

        This serves as a hint to the driver, which can enable database optimizations.

        Parameters:
        readOnly - true to set the Connection to read only mode. false disables read-only mode.
        Throws:
        SQLException - if there is a problem accessing the database.
      • setSavepoint

        Savepoint setSavepoint()
                               throws SQLException
        Creates an unnamed Savepoint in the current transaction.
        Returns:
        a Savepoint object for this savepoint.
        Throws:
        SQLException - if there is a problem accessing the database.
      • setSavepoint

        Savepoint setSavepoint(String name)
                               throws SQLException
        Creates a named Savepoint in the current transaction.
        Parameters:
        name - the name to use for the new Savepoint.
        Returns:
        a Savepoint object for this savepoint.
        Throws:
        SQLException - if there is a problem accessing the database.
      • setTypeMap

        void setTypeMap(Map<String,Class<?>> map)
                        throws SQLException
        Sets the TypeMap for this connection. The input map should contain mappings between complex Java and SQL types.
        Parameters:
        map - the new type map.
        Throws:
        SQLException - if there is a problem accessing the database or if map is not an instance of Map.
      • createClob

        Clob createClob()
                        throws SQLException
        Returns a new empty Clob.
        Throws:
        SQLException - if this connection is closed, or there's a problem creating a new clob.
      • createBlob

        Blob createBlob()
                        throws SQLException
        Returns a new empty Blob.
        Throws:
        SQLException - if this connection is closed, or there's a problem creating a new blob.
      • createNClob

        NClob createNClob()
                          throws SQLException
        Returns a new empty NClob.
        Throws:
        SQLException - if this connection is closed, or there's a problem creating a new nclob.
      • createSQLXML

        SQLXML createSQLXML()
                            throws SQLException
        Returns a new empty SQLXML.
        Throws:
        SQLException - if this connection is closed, or there's a problem creating a new XML.
      • isValid

        boolean isValid(int timeout)
                        throws SQLException
        Returns true if this connection is still open and valid, false otherwise.
        Parameters:
        timeout - number of seconds to wait for a response before giving up and returning false, 0 to wait forever
        Throws:
        SQLException - if timeout < 0
      • setClientInfo

        void setClientInfo(String name,
                         String value)
                           throws SQLClientInfoException
        Sets the client info property name to value. A value of null clears the client info property.
        Throws:
        SQLClientInfoException - if this connection is closed, or there's a problem setting the property.
      • setClientInfo

        void setClientInfo(Properties properties)
                           throws SQLClientInfoException
        Replaces all client info properties with the name/value pairs from properties. All existing properties are removed. If an exception is thrown, the resulting state of this connection's client info properties is undefined.
        Throws:
        SQLClientInfoException - if this connection is closed, or there's a problem setting a property.


Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 16302 / 248376946. Delta: 0.07048 с