概述  软件包  类   使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 6
 上一个   下一个 框架    无框架    

类 java.sql.SQLException
的使用

使用 SQLException 的软件包
java.sql 提供使用 JavaTM 编程语言访问并处理存储在数据源（通常是一个关系数据库）中的数据的 API。 
javax.sql 为通过 JavaTM 编程语言进行服务器端数据源访问和处理提供 API。 
javax.sql.rowset JDBC RowSet 实现的标准接口和基类。 
javax.sql.rowset.serial 提供实用工具类，允许 SQL 类型与 Java 编程语言数据类型之间的可序列化映射关系。 
javax.sql.rowset.spi 第三方供应商在其同步提供者的实现中必须使用的标准类和接口。 
 

java.sql 中 SQLException 的使用
 

java.sql 中 SQLException 的子类
 class BatchUpdateException
          进行批量更新操作期间发生错误时抛出的 SQLException 子类。
 class DataTruncation
          以 DataTruncation 异常形式抛出的异常（写入时），或者由于除数据值超出 MaxFieldSize 之外的某种原因意外地截断该数据值时以 DataTruncation 警告形式报告的异常（读取时）。
 class SQLClientInfoException
          当无法在 Connection 上设置一个或多个客户端信息属性时，抛出此 SQLException 的子类。
 class SQLDataException
          当 SQLState 类值为“22”时抛出的 SQLException 子类。
 class SQLFeatureNotSupportedException
          当 SQLState 类值为“0A”（值为“零”A）时抛出的 SQLException 子类。
 class SQLIntegrityConstraintViolationException
          当 SQLState 类值为“23”时抛出的 SQLException 子类。
 class SQLInvalidAuthorizationSpecException
          当 SQLState 类值为“28”时抛出的 SQLException 子类。
 class SQLNonTransientConnectionException
           SQLState 类值为“08”时抛出的 SQLException 子类，表示在失败原因没有纠正的情况下重试操作时，失败的连接操作不会成功。
 class SQLNonTransientException
          重试相同操作将失败（除非纠正了 SQLException 的 cause）的情况下抛出的 SQLException 子类。
 class SQLRecoverableException
          应用程序执行某些恢复步骤并重试整个事务或事务分支（在分布式事务中）后，可以成功执行先前失败操作的情况下抛出的 SQLException 子类。
 class SQLSyntaxErrorException
          当 SQLState 类值为“42”时抛出的 SQLException 子类。
 class SQLTimeoutException
          Statement 指定的超时已到期时抛出的 SQLException 子类。
 class SQLTransactionRollbackException
          当 SQLState 类值为“40”时，抛出此 SQLException 的子类。
 class SQLTransientConnectionException
          SQLState 类值为“08”时抛出的 SQLException 子类，表示在没有进行任何应用程序级更改的情况下重试操作时，失败的连接操作可以成功。
 class SQLTransientException
          没有任何应用程序级功能干预时，重试先前失败操作可以成功的情况下抛出的 SQLException 子类。
 class SQLWarning
          提供关于数据库访问警告信息的异常。
 

返回 SQLException 的 java.sql 中的方法
 SQLException SQLException.getNextException()
          通过 setNextException(SQLException ex) 获取链接到此 SQLException 对象的异常。
 

参数类型为 SQLException 的 java.sql 中的方法
 void SQLException.setNextException(SQLException ex)
          将 SQLException 对象添加到链接的末尾。
 

抛出 SQLException 的 java.sql 中的方法
 boolean ResultSet.absolute(int row)
          将光标移动到此 ResultSet 对象的给定行编号。
 boolean Driver.acceptsURL(String url)
          查询驱动程序是否认为它可以打开到给定 URL 的连接。
 void PreparedStatement.addBatch()
          将一组参数添加到此 PreparedStatement 对象的批处理命令中。
 void Statement.addBatch(String sql)
          将给定的 SQL 命令添加到此 Statement 对象的当前命令列表中。
 void ResultSet.afterLast()
          将光标移动到此 ResultSet 对象的末尾，正好位于最后一行之后。
 boolean DatabaseMetaData.allProceduresAreCallable()
          获取当前用户是否可以调用 getProcedures 方法返回的所有过程。
 boolean DatabaseMetaData.allTablesAreSelectable()
          获取当前用户是否可以使用 SELECT 语句中的 getTables 方法返回的所有表。
 boolean DatabaseMetaData.autoCommitFailureClosesAllResultSets()
          当 autoCommit 为 true 时，获取 SQLException 是否指示所有打开的 ResultSets 已关闭（包括那些可保持的）。
 void ResultSet.beforeFirst()
          将光标移动到此 ResultSet 对象的开头，正好位于第一行之前。
 void Statement.cancel()
          如果 DBMS 和驱动程序都支持中止 SQL 语句，则取消此 Statement 对象。
 void ResultSet.cancelRowUpdates()
          取消对 ResultSet 对象中的当前行所作的更新。
 void Statement.clearBatch()
          清空此 Statement 对象的当前 SQL 命令列表。
 void PreparedStatement.clearParameters()
          立即清除当前参数值。
 void Connection.clearWarnings()
          清除为此 Connection 对象报告的所有警告。
 void ResultSet.clearWarnings()
          清除在此 ResultSet 对象上报告的所有警告。
 void Statement.clearWarnings()
          清除在此 Statement 对象上报告的所有警告。
 void Connection.close()
          立即释放此 Connection 对象的数据库和 JDBC 资源，而不是等待它们被自动释放。
 void ResultSet.close()
          立即释放此 ResultSet 对象的数据库和 JDBC 资源，而不是等待该对象自动关闭时发生此操作。
 void Statement.close()
          立即释放此 Statement 对象的数据库和 JDBC 资源，而不是等待该对象自动关闭时发生此操作。
 void Connection.commit()
          使所有上一次提交/回滚后进行的更改成为持久更改，并释放此 Connection 对象当前持有的所有数据库锁。
 Connection Driver.connect(String url, Properties info)
          试图创建一个到给定 URL 的数据库连接。
 Array Connection.createArrayOf(String typeName, Object[] elements)
          创建 Array 对象的工厂方法。
 Blob Connection.createBlob()
          构造实现 Blob 接口的对象。
 Clob Connection.createClob()
          构造实现 Clob 接口的对象。
 NClob Connection.createNClob()
          构造实现 NClob 接口的对象。
 SQLXML Connection.createSQLXML()
          构造实现 SQLXML 接口的对象。
 Statement Connection.createStatement()
          创建一个 Statement 对象来将 SQL 语句发送到数据库。
 Statement Connection.createStatement(int resultSetType, int resultSetConcurrency)
          创建一个 Statement 对象，该对象将生成具有给定类型和并发性的 ResultSet 对象。
 Statement Connection.createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
          创建一个 Statement 对象，该对象将生成具有给定类型、并发性和可保存性的 ResultSet 对象。
 Struct Connection.createStruct(String typeName, Object[] attributes)
          创建 Struct 对象的工厂方法。
 boolean DatabaseMetaData.dataDefinitionCausesTransactionCommit()
          获取事务中的数据定义语句是否强迫该事务进行提交。
 boolean DatabaseMetaData.dataDefinitionIgnoredInTransactions()
          获取此数据库是否忽略事务中的数据定义语句。
 void ResultSet.deleteRow()
          从此 ResultSet 对象和底层数据库中删除当前行。
 boolean DatabaseMetaData.deletesAreDetected(int type)
          获取是否可以通过调用 ResultSet.rowDeleted 方法检测可见行的删除。
static void DriverManager.deregisterDriver(Driver driver)
          从 DriverManager 的列表中删除一个驱动程序。
 boolean DatabaseMetaData.doesMaxRowSizeIncludeBlobs()
          获取 getMaxRowSize 方法的返回值是否包括 SQL 数据类型 LONGVARCHAR 和 LONGVARBINARY。
 boolean PreparedStatement.execute()
          在此 PreparedStatement 对象中执行 SQL 语句，该语句可以是任何种类的 SQL 语句。
 boolean Statement.execute(String sql)
          执行给定的 SQL 语句，该语句可能返回多个结果。
 boolean Statement.execute(String sql, int autoGeneratedKeys)
          执行给定的 SQL 语句（该语句可能返回多个结果），并通知驱动程序所有自动生成的键都应该可用于获取。
 boolean Statement.execute(String sql, int[] columnIndexes)
          执行给定的 SQL 语句（该语句可能返回多个结果），并通知驱动程序在给定数组中指示的自动生成的键应该可用于获取。
 boolean Statement.execute(String sql, String[] columnNames)
          执行给定的 SQL 语句（该语句可能返回多个结果），并通知驱动程序在给定数组中指示的自动生成的键应该可用于获取。
 int[] Statement.executeBatch()
          将一批命令提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组。
 ResultSet PreparedStatement.executeQuery()
          在此 PreparedStatement 对象中执行 SQL 查询，并返回该查询生成的 ResultSet 对象。
 ResultSet Statement.executeQuery(String sql)
          执行给定的 SQL 语句，该语句返回单个 ResultSet 对象。
 int PreparedStatement.executeUpdate()
          在此 PreparedStatement 对象中执行 SQL 语句，该语句必须是一个 SQL 数据操作语言（Data Manipulation Language，DML）语句，比如 INSERT、UPDATE 或 DELETE 语句；或者是无返回内容的 SQL 语句，比如 DDL 语句。
 int Statement.executeUpdate(String sql)
          执行给定 SQL 语句，该语句可能为 INSERT、UPDATE 或 DELETE 语句，或者不返回任何内容的 SQL 语句（如 SQL DDL 语句）。
 int Statement.executeUpdate(String sql, int autoGeneratedKeys)
          执行给定的 SQL 语句，并用给定标志通知驱动程序由此 Statement 生成的自动生成键是否可用于获取。
 int Statement.executeUpdate(String sql, int[] columnIndexes)
          执行给定的 SQL 语句，并通知驱动程序在给定数组中指示的自动生成的键应该可用于获取。
 int Statement.executeUpdate(String sql, String[] columnNames)
          执行给定的 SQL 语句，并通知驱动程序在给定数组中指示的自动生成的键应该可用于获取。
 int ResultSet.findColumn(String columnLabel)
          将给定的 ResultSet 列标签映射到其 ResultSet 列索引。
 boolean ResultSet.first()
          将光标移动到此 ResultSet 对象的第一行。
 void Array.free()
          此方法释放 Array 对象以及它占用的资源。
 void Blob.free()
          此方法释放 Blob 对象以及它所占用的资源。
 void Clob.free()
          此方法释放 Clob 对象以及它所占用的资源。
 void SQLXML.free()
          此方法关闭此对象并释放其持有的资源。
 Object Array.getArray()
          以 Java 编程语言数组的形式获取由此 Array 对象指定的 SQL ARRAY 值的内容。
 Array CallableStatement.getArray(int parameterIndex)
          以 Java 编程语言中 Array 对象的形式获取指定的 JDBC ARRAY 参数的值。
 Array ResultSet.getArray(int columnIndex)
          以 Java 编程语言中 Array 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Object Array.getArray(long index, int count)
          获取由此 Array 对象指定的 SQL ARRAY 值的一部分，从指定 index 开始，包含 SQL 数组中 count 个连续元素。
 Object Array.getArray(long index, int count, Map<String,Class<?>> map)
          获取由此 ARRAY 对象指定的 SQL Array 值的一部分，从指定 index 开始，包含 SQL 数组中 count 个连续元素。
 Object Array.getArray(Map<String,Class<?>> map)
          获取由此 Array 对象指定的 SQL ARRAY 值的内容。
 Array CallableStatement.getArray(String parameterName)
          以 Java 编程语言中 java.sql.ARRAY 对象的形式获取 JDBC ARRAY 参数的值。
 Array ResultSet.getArray(String columnLabel)
          以 Java 编程语言中 Array 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 InputStream Clob.getAsciiStream()
          以 ascii 流形式获取此 Clob 对象指定的 CLOB 值。
 InputStream ResultSet.getAsciiStream(int columnIndex)
          以 ASCII 字符流的形式获取此 ResultSet 对象的当前行中指定列的值。
 InputStream ResultSet.getAsciiStream(String columnLabel)
          以 ASCII 字符流的形式获取此 ResultSet 对象的当前行中指定列的值。
 Object[] Struct.getAttributes()
          生成此 Struct 对象所表示的 SQL 结构类型属性的有序值。
 Object[] Struct.getAttributes(Map<String,Class<?>> map)
          生成此 Struct 对象所表示的 SQL 结构类型的属性的有序值。
 ResultSet DatabaseMetaData.getAttributes(String catalog, String schemaPattern, String typeNamePattern, String attributeNamePattern)
          获取可在给定模式和类别中使用的用户定义类型 (UDT) 的给定类型的给定属性的描述。
 boolean Connection.getAutoCommit()
          获取此 Connection 对象的当前自动提交模式。
 int Array.getBaseType()
          在由此 Array 对象指定的数组中获取元素的 JDBC 类型。
 String Array.getBaseTypeName()
          在由此 Array 对象指定的数组中获取元素的 SQL 类型名称。
 String Ref.getBaseTypeName()
          获取此 Ref 对象所引用 SQL 结构类型的完全限定的 SQL 名称。
 ResultSet DatabaseMetaData.getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable)
          获取唯一标识行的表的最佳列集合的描述。
 BigDecimal CallableStatement.getBigDecimal(int parameterIndex)
          以 java.math.BigDecimal 对象的形式获取指定 JDBC NUMERIC 参数的值，小数点右边的位数与该参数值所包含的位数相同。
 BigDecimal ResultSet.getBigDecimal(int columnIndex)
          以具有全精度的 java.math.BigDecimal 的形式获取此 ResultSet 对象的当前行中指定列的值。
 BigDecimal CallableStatement.getBigDecimal(int parameterIndex, int scale)
          已过时。 使用 getBigDecimal(int parameterIndex) 或 getBigDecimal(String parameterName)
 BigDecimal ResultSet.getBigDecimal(int columnIndex, int scale)
          已过时。  
 BigDecimal CallableStatement.getBigDecimal(String parameterName)
          以 java.math.BigDecimal 对象的形式获取 JDBC NUMERIC 参数的值，小数点右边的位数与该参数值所包含的位数相同。
 BigDecimal ResultSet.getBigDecimal(String columnLabel)
          以具有全精度的 java.math.BigDecimal 的形式获取此 ResultSet 对象的当前行中指定列的值。
 BigDecimal ResultSet.getBigDecimal(String columnLabel, int scale)
          已过时。  
 InputStream Blob.getBinaryStream()
          以流的形式获取此 Blob 实例指定的 BLOB 值。
 InputStream SQLXML.getBinaryStream()
          以流的形式获取此 SQLXML 实例指定的 XML 值。
 InputStream ResultSet.getBinaryStream(int columnIndex)
          以未解释字节的流的形式获取此 ResultSet 对象的当前行中指定列的值。
 InputStream Blob.getBinaryStream(long pos, long length)
          返回包含部分 Blob 值的 InputStream 对象，该值从 pos 指定的字节开始，长度为 length 个字节。
 InputStream ResultSet.getBinaryStream(String columnLabel)
          以未解释的 byte 流的形式获取此 ResultSet 对象的当前行中指定列的值。
 Blob CallableStatement.getBlob(int parameterIndex)
          以 Java 编程语言中 java.sql.Clob 对象的形式获取指定的 JDBC CLOB 参数的值。
 Blob ResultSet.getBlob(int columnIndex)
          以 Java 编程语言中 Blob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Blob CallableStatement.getBlob(String parameterName)
          以 Java 编程语言中 Blob 对象的形式获取 JDBC BLOB 参数的值。
 Blob ResultSet.getBlob(String columnLabel)
          以 Java 编程语言中 Blob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 boolean CallableStatement.getBoolean(int parameterIndex)
          以 Java 编程语言中 boolean 值的形式获取指定的 JDBC BIT 或 BOOLEAN 参数的值。
 boolean ResultSet.getBoolean(int columnIndex)
          以 Java 编程语言中 boolean 的形式获取此 ResultSet 对象的当前行中指定列的值。
 boolean CallableStatement.getBoolean(String parameterName)
          以 Java 编程语言中 boolean 值的形式获取 JDBC BIT 或 BOOLEAN 参数的值。
 boolean ResultSet.getBoolean(String columnLabel)
          以 Java 编程语言中 boolean 的形式获取此 ResultSet 对象的当前行中指定列的值。
 byte CallableStatement.getByte(int parameterIndex)
          以 Java 编程语言中 byte 的形式获取指定的 JDBC TINYINT 参数的值。
 byte ResultSet.getByte(int columnIndex)
          以 Java 编程语言中 byte 的形式获取此 ResultSet 对象的当前行中指定列的值。
 byte CallableStatement.getByte(String parameterName)
          以 Java 编程语言中 byte 值的形式获取 JDBC TINYINT 参数的值。
 byte ResultSet.getByte(String columnLabel)
          以 Java 编程语言中 byte 的形式获取此 ResultSet 对象的当前行中指定列的值。
 byte[] CallableStatement.getBytes(int parameterIndex)
          以 Java 编程语言中 byte 数组值的形式获取指定的 JDBC BINARY 或 VARBINARY 参数的值。
 byte[] ResultSet.getBytes(int columnIndex)
          以 Java 编程语言中 byte 数组的形式获取此 ResultSet 对象的当前行中指定列的值。
 byte[] Blob.getBytes(long pos, int length)
          以 byte 数组的形式获取此 Blob 对象表示的全部或部分 BLOB 值。
 byte[] CallableStatement.getBytes(String parameterName)
          以 Java 编程语言中 byte 数组值的形式获取 JDBC BINARY 或 VARBINARY 参数的值。
 byte[] ResultSet.getBytes(String columnLabel)
          以 Java 编程语言中 byte 数组的形式获取此 ResultSet 对象的当前行中指定列的值。
 String Connection.getCatalog()
          获取此 Connection 对象的当前目录名称。
 String ResultSetMetaData.getCatalogName(int column)
          获取指定列的表目录名称。
 ResultSet DatabaseMetaData.getCatalogs()
          获取可在此数据库中使用的类别名称。
 String DatabaseMetaData.getCatalogSeparator()
          获取此数据库用作类别和表名之间的分隔符的 String。
 String DatabaseMetaData.getCatalogTerm()
          获取数据库供应商用于 "catalog" 的首选术语。
 Reader Clob.getCharacterStream()
          以 java.io.Reader 对象形式（或字符流形式）获取此 Clob 对象指定的 CLOB 值。
 Reader SQLXML.getCharacterStream()
          以 java.io.Reader 对象的形式获取此 SQLXML 实例指定的 XML 值。
 Reader CallableStatement.getCharacterStream(int parameterIndex)
          以 Java 编程语言中 java.io.Reader 对象的形式获取指定参数的值。
 Reader ResultSet.getCharacterStream(int columnIndex)
          以 java.io.Reader 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Reader Clob.getCharacterStream(long pos, long length)
          返回包含部分 Clob 值的 Reader 对象，该值从 pos 指定的字符开始，长度为 length 个字符。
 Reader CallableStatement.getCharacterStream(String parameterName)
          以 Java 编程语言中 java.io.Reader 对象的形式获取指定参数的值。
 Reader ResultSet.getCharacterStream(String columnLabel)
          以 java.io.Reader 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Properties Connection.getClientInfo()
          返回一个列表，它包含驱动程序支持的每个客户端信息属性的名称和当前值。
 String Connection.getClientInfo(String name)
          返回通过名称指定的客户端信息属性的值。
 ResultSet DatabaseMetaData.getClientInfoProperties()
          获取驱动程序支持的客户端信息属性的列表。
 Clob CallableStatement.getClob(int parameterIndex)
          以 Java 编程语言中 java.sql.Clob 对象的形式获取指定的 JDBC CLOB 参数的值。
 Clob ResultSet.getClob(int columnIndex)
          以 Java 编程语言中 Clob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Clob CallableStatement.getClob(String parameterName)
          以 Java 编程语言中 java.sql.CLOB 对象的形式获取 JDBC CLOB 参数的值。
 Clob ResultSet.getClob(String columnLabel)
          以 Java 编程语言中 Clob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 String ResultSetMetaData.getColumnClassName(int column)
          如果调用方法 ResultSet.getObject 从列中获取值，则返回构造其实例的 Java 类的完全限定名称。
 int ResultSetMetaData.getColumnCount()
          返回此 ResultSet 对象中的列数。
 int ResultSetMetaData.getColumnDisplaySize(int column)
          指示指定列的最大标准宽度，以字符为单位。
 String ResultSetMetaData.getColumnLabel(int column)
          获取用于打印输出和显示的指定列的建议标题。
 String ResultSetMetaData.getColumnName(int column)
          获取指定列的名称。
 ResultSet DatabaseMetaData.getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern)
          获取用于表列的访问权的描述。
 ResultSet DatabaseMetaData.getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern)
          获取可在指定类别中使用的表列的描述。
 int ResultSetMetaData.getColumnType(int column)
          获取指定列的 SQL 类型。
 String ResultSetMetaData.getColumnTypeName(int column)
          获取指定列的数据库特定的类型名称。
 int ResultSet.getConcurrency()
          获取此 ResultSet 对象的并发模式。
 Connection DatabaseMetaData.getConnection()
          获取此元数据对象所产生的连接。
 Connection Statement.getConnection()
          获取生成此 Statement 对象的 Connection 对象。
static Connection DriverManager.getConnection(String url)
          试图建立到给定数据库 URL 的连接。
static Connection DriverManager.getConnection(String url, Properties info)
          试图建立到给定数据库 URL 的连接。
static Connection DriverManager.getConnection(String url, String user, String password)
          试图建立到给定数据库 URL 的连接。
 ResultSet DatabaseMetaData.getCrossReference(String parentCatalog, String parentSchema, String parentTable, String foreignCatalog, String foreignSchema, String foreignTable)
          获取给定外键列表中外键列的描述，这些列引用主键或表示父表（可能是相同的表，也可能是不同的表）唯一约束的列。
 String ResultSet.getCursorName()
          获取此 ResultSet 对象使用的 SQL 光标的名称。
 int DatabaseMetaData.getDatabaseMajorVersion()
          获取底层数据库的主版本号。
 int DatabaseMetaData.getDatabaseMinorVersion()
          底层数据库的次版本号。
 String DatabaseMetaData.getDatabaseProductName()
          获取此数据库产品的名称。
 String DatabaseMetaData.getDatabaseProductVersion()
          获取此数据库产品的版本号。
 Date CallableStatement.getDate(int parameterIndex)
          以 java.sql.Date 对象的形式获取指定 JDBC DATE 参数的值。
 Date ResultSet.getDate(int columnIndex)
          以 Java 编程语言中 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Date CallableStatement.getDate(int parameterIndex, Calendar cal)
          以 java.sql.Date 对象的形式获取指定 JDBC DATE 参数的值，使用给定 Calendar 对象构造日期。
 Date ResultSet.getDate(int columnIndex, Calendar cal)
          以 Java 编程语言中 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Date CallableStatement.getDate(String parameterName)
          以 java.sql.Date 对象的形式获取 JDBC DATE 参数的值。
 Date ResultSet.getDate(String columnLabel)
          以 Java 编程语言中的 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Date CallableStatement.getDate(String parameterName, Calendar cal)
          以 java.sql.Date 对象的形式获取 JDBC DATE 参数的值，使用给定 Calendar 对象构造日期。
 Date ResultSet.getDate(String columnLabel, Calendar cal)
          以 Java 编程语言中 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 int DatabaseMetaData.getDefaultTransactionIsolation()
          获取此数据库的默认事务隔离级别。
 double CallableStatement.getDouble(int parameterIndex)
          以 Java 编程语言中 double 值的形式获取指定的 JDBC DOUBLE 参数的值。
 double ResultSet.getDouble(int columnIndex)
          以 Java 编程语言中 double 的形式获取此 ResultSet 对象的当前行中指定列的值。
 double CallableStatement.getDouble(String parameterName)
          以 Java 编程语言中 double 值的形式获取 JDBC DOUBLE 参数的值。
 double ResultSet.getDouble(String columnLabel)
          以 Java 编程语言中 double 的形式获取此 ResultSet 对象的当前行中指定列的值。
static Driver DriverManager.getDriver(String url)
          试图查找能理解给定 URL 的驱动程序。
 String DatabaseMetaData.getDriverName()
          获取此 JDBC 驱动程序的名称。
 String DatabaseMetaData.getDriverVersion()
          获取此 JDBC 驱动程序的 String 形式的版本号。
 ResultSet DatabaseMetaData.getExportedKeys(String catalog, String schema, String table)
          获取引用给定表的主键列（表导入的外键）的外键列的描述。
 String DatabaseMetaData.getExtraNameCharacters()
          获取可以在不带引号的标识符名称中使用的所有“额外”字符（除了 a-z、A-Z、0-9 和 _ 以外的字符）。
 int ResultSet.getFetchDirection()
          获取此 ResultSet 对象的获取方向。
 int Statement.getFetchDirection()
          获取从数据库表获取行的方向，该方向是根据此 Statement 对象生成的结果集合的默认值。
 int ResultSet.getFetchSize()
          获取此 ResultSet 对象的获取大小。
 int Statement.getFetchSize()
          获取结果集合的行数，该数是根据此 Statement 对象生成的 ResultSet 对象的默认获取大小。
 float CallableStatement.getFloat(int parameterIndex)
          以 Java 编程语言中 float 值的形式获取指定的 JDBC FLOAT 参数的值。
 float ResultSet.getFloat(int columnIndex)
          以 Java 编程语言中 float 的形式获取此 ResultSet 对象的当前行中指定列的值。
 float CallableStatement.getFloat(String parameterName)
          以 Java 编程语言中 float 值的形式获取 JDBC FLOAT 参数的值。
 float ResultSet.getFloat(String columnLabel)
          以 Java 编程语言中 float 的形式获取此 ResultSet 对象的当前行中指定列的值。
 ResultSet DatabaseMetaData.getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern)
          获取给定类别的系统或用户函数参数和返回类型的描述。
 ResultSet DatabaseMetaData.getFunctions(String catalog, String schemaPattern, String functionNamePattern)
          获取给定类别中可用的系统和用户函数的描述。
 ResultSet Statement.getGeneratedKeys()
          获取由于执行此 Statement 对象而创建的所有自动生成的键。
 int Connection.getHoldability()
          获取使用此 Connection 对象创建的 ResultSet 对象的当前可保存性。
 int ResultSet.getHoldability()
          获取此 ResultSet 对象的可保存性
 String DatabaseMetaData.getIdentifierQuoteString()
          获取用于引用 SQL 标识符的字符串。
 ResultSet DatabaseMetaData.getImportedKeys(String catalog, String schema, String table)
          获取由给定表的外键列（表导入的主键）引用的主键列的描述。
 ResultSet DatabaseMetaData.getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate)
          获取给定表的索引和统计信息的描述。
 int CallableStatement.getInt(int parameterIndex)
          以 Java 编程语言中 int 值的形式获取指定的 JDBC INTEGER 参数的值。
 int ResultSet.getInt(int columnIndex)
          以 Java 编程语言中 int 的形式获取此 ResultSet 对象的当前行中指定列的值。
 int CallableStatement.getInt(String parameterName)
          以 Java 编程语言中 int 值的形式获取 JDBC INTEGER 参数的值。
 int ResultSet.getInt(String columnLabel)
          以 Java 编程语言中 int 的形式获取此 ResultSet 对象的当前行中指定列的值。
 int DatabaseMetaData.getJDBCMajorVersion()
          获取此驱动程序的主 JDBC 版本号。
 int DatabaseMetaData.getJDBCMinorVersion()
          获取此驱动程序的次 JDBC 版本号。
 long CallableStatement.getLong(int parameterIndex)
          以 Java 编程语言中 long 值的形式获取指定的 JDBC BIGINT 参数的值。
 long ResultSet.getLong(int columnIndex)
          以 Java 编程语言中 long 的形式获取此 ResultSet 对象的当前行中指定列的值。
 long CallableStatement.getLong(String parameterName)
          以 Java 编程语言中 long 值的形式获取 JDBC BIGINT 参数的值。
 long ResultSet.getLong(String columnLabel)
          以 Java 编程语言中 long 的形式获取此 ResultSet 对象的当前行中指定列的值。
 int DatabaseMetaData.getMaxBinaryLiteralLength()
          获取此数据库允许在内嵌二进制字面值中使用的最大十六进制字符数。
 int DatabaseMetaData.getMaxCatalogNameLength()
          获取此数据库允许用于类别名称的最大字符数。
 int DatabaseMetaData.getMaxCharLiteralLength()
          获取此数据库允许用于字符字面值的最大字符数。
 int DatabaseMetaData.getMaxColumnNameLength()
          获取此数据库允许用于列名称的最大字符数。
 int DatabaseMetaData.getMaxColumnsInGroupBy()
          获取此数据库允许在 GROUP BY 子句中使用的最大列数。
 int DatabaseMetaData.getMaxColumnsInIndex()
          获取此数据库允许在索引中使用的最大列数。
 int DatabaseMetaData.getMaxColumnsInOrderBy()
          获取此数据库允许在 ORDER BY 子句中使用的最大列数。
 int DatabaseMetaData.getMaxColumnsInSelect()
          获取此数据库允许在 SELECT 列表中使用的最大列数。
 int DatabaseMetaData.getMaxColumnsInTable()
          获取此数据库允许在表中使用的最大列数。
 int DatabaseMetaData.getMaxConnections()
          获取连接到此数据库的并发连接的可能最大数。
 int DatabaseMetaData.getMaxCursorNameLength()
          获取此数据库允许用于游标名称的最大字符数。
 int Statement.getMaxFieldSize()
          获取可以为此 Statement 对象所生成 ResultSet 对象中的字符和二进制列值返回的最大字节数。
 int DatabaseMetaData.getMaxIndexLength()
          获取此数据库允许用于索引（包括索引的所有部分）的最大字节数。
 int DatabaseMetaData.getMaxProcedureNameLength()
          获取此数据库允许用于过程名称的最大字符数。
 int Statement.getMaxRows()
          获取由此 Statement 对象生成的 ResultSet 对象可以包含的最大行数。
 int DatabaseMetaData.getMaxRowSize()
          获取此数据库允许在单行中使用的最大字节数。
 int DatabaseMetaData.getMaxSchemaNameLength()
          获取此数据库允许在模式名称中使用的最大字符数。
 int DatabaseMetaData.getMaxStatementLength()
          获取此数据库允许在 SQL 语句中使用的最大字符数。
 int DatabaseMetaData.getMaxStatements()
          获取在此数据库中在同一时间内可处于开放状态的最大活动语句数。
 int DatabaseMetaData.getMaxTableNameLength()
          获取此数据库允许在表名称中使用的最大字符数。
 int DatabaseMetaData.getMaxTablesInSelect()
          获取此数据库允许在 SELECT 语句中使用的表的最大数量。
 int DatabaseMetaData.getMaxUserNameLength()
          获取此数据库允许在用户名称中使用的最大字符数。
 DatabaseMetaData Connection.getMetaData()
          获取一个 DatabaseMetaData 对象，该对象包含关于此 Connection 对象所连接的数据库的元数据。
 ResultSetMetaData PreparedStatement.getMetaData()
          获取包含有关 ResultSet 对象列信息的 ResultSetMetaData 对象，ResultSet 对象将在执行此 PreparedStatement 对象时返回。
 ResultSetMetaData ResultSet.getMetaData()
          获取此 ResultSet 对象的列的编号、类型和属性。
 boolean Statement.getMoreResults()
          移动到此 Statement 对象的下一个结果，如果其为 ResultSet 对象，则返回 true，并隐式关闭利用方法 getResultSet 获取的所有当前 ResultSet 对象。
 boolean Statement.getMoreResults(int current)
          将此 Statement 对象移动到下一个结果，根据给定标志指定的指令处理所有当前 ResultSet 对象；如果下一个结果为 ResultSet 对象，则返回 true。
 Reader CallableStatement.getNCharacterStream(int parameterIndex)
          以 Java 编程语言中 java.io.Reader 对象的形式获取指定参数的值。
 Reader ResultSet.getNCharacterStream(int columnIndex)
          以 java.io.Reader 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Reader CallableStatement.getNCharacterStream(String parameterName)
          以 Java 编程语言中 java.io.Reader 对象的形式获取指定参数的值。
 Reader ResultSet.getNCharacterStream(String columnLabel)
          以 java.io.Reader 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 NClob CallableStatement.getNClob(int parameterIndex)
          以 Java 编程语言中 java.sql.NClob 对象的形式获取指定的 JDBC NCLOB 参数的值。
 NClob ResultSet.getNClob(int columnIndex)
          以 Java 编程语言中 NClob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 NClob CallableStatement.getNClob(String parameterName)
          以 Java 编程语言中 java.sql.NClob 对象的形式获取 JDBC NCLOB 参数的值。
 NClob ResultSet.getNClob(String columnLabel)
          以 Java 编程语言中 NClob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 String CallableStatement.getNString(int parameterIndex)
          以 Java 编程语言中 String 的形式获取指定的 NCHAR、NVARCHAR 或 LONGNVARCHAR 参数的值。
 String ResultSet.getNString(int columnIndex)
          以 Java 编程语言中 String 的形式获取此 ResultSet 对象的当前行中指定列的值。
 String CallableStatement.getNString(String parameterName)
          以 Java 编程语言中 String 的形式获取指定的 NCHAR、NVARCHAR 或 LONGNVARCHAR 参数的值。
 String ResultSet.getNString(String columnLabel)
          以 Java 编程语言中 String 的形式获取此 ResultSet 对象的当前行中指定列的值。
 String DatabaseMetaData.getNumericFunctions()
          获取可用于此数据库的数学函数的逗号分隔列表。
 Object Ref.getObject()
          获取此 Ref 对象引用的 SQL 结构类型实例。
 Object CallableStatement.getObject(int parameterIndex)
          以 Java 编程语言中 Object 的形式获取指定参数的值。
 Object ResultSet.getObject(int columnIndex)
          以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
 Object CallableStatement.getObject(int parameterIndex, Map<String,Class<?>> map)
          返回一个表示 OUT 参数 parameterIndex 值的对象，并将 map 用于该参数值的自定义映射关系。
 Object ResultSet.getObject(int columnIndex, Map<String,Class<?>> map)
          以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
 Object Ref.getObject(Map<String,Class<?>> map)
          获取引用对象并使用给定类型映射表将其映射到 Java 类型。
 Object CallableStatement.getObject(String parameterName)
          以 Java 编程语言中 Object 的形式获取参数的值。
 Object ResultSet.getObject(String columnLabel)
          以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
 Object CallableStatement.getObject(String parameterName, Map<String,Class<?>> map)
          返回一个表示 OUT 参数 parameterName 值的对象，并将 map 用于该参数值的自定义映射关系。
 Object ResultSet.getObject(String columnLabel, Map<String,Class<?>> map)
          以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
 String ParameterMetaData.getParameterClassName(int param)
          获取 Java 类的完全限定名称，该类的实例应该传递给 PreparedStatement.setObject 方法。
 int ParameterMetaData.getParameterCount()
          获取 PreparedStatement 对象中的参数的数量，此 ParameterMetaData 对象包含了该对象的信息。
 ParameterMetaData PreparedStatement.getParameterMetaData()
          获取此 PreparedStatement 对象的参数的编号、类型和属性。
 int ParameterMetaData.getParameterMode(int param)
          获取指定参数的模式。
 int ParameterMetaData.getParameterType(int param)
          获取指定参数的 SQL 类型。
 String ParameterMetaData.getParameterTypeName(int param)
          获取指定参数的特定于数据库的类型名称。
 int ParameterMetaData.getPrecision(int param)
          获取指定参数的指定列大小。
 int ResultSetMetaData.getPrecision(int column)
          获取指定列的指定列宽。
 ResultSet DatabaseMetaData.getPrimaryKeys(String catalog, String schema, String table)
          获取对给定表的主键列的描述。
 ResultSet DatabaseMetaData.getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern)
          获取给定类别的存储过程参数和结果列的描述。
 ResultSet DatabaseMetaData.getProcedures(String catalog, String schemaPattern, String procedureNamePattern)
          获取可在给定类别中使用的存储过程的描述。
 String DatabaseMetaData.getProcedureTerm()
          获取数据库供应商用于 "procedure" 的首选术语。
 DriverPropertyInfo[] Driver.getPropertyInfo(String url, Properties info)
          获得此驱动程序的可能属性信息。
 int Statement.getQueryTimeout()
          获取驱动程序等待 Statement 对象执行的秒数。
 Ref CallableStatement.getRef(int parameterIndex)
          以 Java 编程语言中 Ref 对象的形式获取指定的 JDBC REF(<structured-type>) 参数的值。
 Ref ResultSet.getRef(int columnIndex)
          以 Java 编程语言中 Ref 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Ref CallableStatement.getRef(String parameterName)
          以 Java 编程语言中 Ref 对象的形式获取 JDBC REF(<structured-type>) 参数的值。
 Ref ResultSet.getRef(String columnLabel)
          以 Java 编程语言中 Ref 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 ResultSet Array.getResultSet()
          获取包含此 Array 对象指定的 SQL ARRAY 值的元素的结果集合。
 ResultSet Statement.getResultSet()
          以 ResultSet 对象的形式获取当前结果。
 ResultSet Array.getResultSet(long index, int count)
          获取保存子数组的元素的结果集合，从索引 index 开始，包含 count 个连续元素。
 ResultSet Array.getResultSet(long index, int count, Map<String,Class<?>> map)
          获取保存子数组的元素的结果集合，从索引 index 开始，包含 count 个连续元素。
 ResultSet Array.getResultSet(Map<String,Class<?>> map)
          获取包含由此 Array 对象指定的 SQL ARRAY 值的元素的结果集合。
 int Statement.getResultSetConcurrency()
          获取此 Statement 对象生成的 ResultSet 对象的结果集合并发性。
 int DatabaseMetaData.getResultSetHoldability()
          针对 ResultSet 对象获取此数据库的默认可保存性。
 int Statement.getResultSetHoldability()
          获取此 Statement 对象生成的 ResultSet 对象的结果集合可保存性。
 int Statement.getResultSetType()
          获取此 Statement 对象生成的 ResultSet 对象的结果集合类型。
 int ResultSet.getRow()
          获取当前行编号。
 RowId CallableStatement.getRowId(int parameterIndex)
          以 java.sql.RowId 对象的形式获取指定 JDBC ROWID 参数的值。
 RowId ResultSet.getRowId(int columnIndex)
          以 Java 编程语言中 java.sql.RowId 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 RowId CallableStatement.getRowId(String parameterName)
          以 java.sql.RowId 对象的形式获取指定 JDBC ROWID 参数的值。
 RowId ResultSet.getRowId(String columnLabel)
          以 Java 编程语言中 java.sql.RowId 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 RowIdLifetime DatabaseMetaData.getRowIdLifetime()
          指示此数据源是否支持 SQL ROWID 类型，如果支持，则 RowId 对象在该类型的生存期内持续有效。
 int Savepoint.getSavepointId()
          获取此 Savepoint 对象表示的保存点的生成 ID。
 String Savepoint.getSavepointName()
          获取此 Savepoint 对象表示的保存点的名称。
 int ParameterMetaData.getScale(int param)
          获取指定参数的小数点右边的位数。
 int ResultSetMetaData.getScale(int column)
          获取指定列的小数点右边的位数。
 String ResultSetMetaData.getSchemaName(int column)
          获取指定列的表模式。
 ResultSet DatabaseMetaData.getSchemas()
          获取可在此数据库中使用的模式名称。
 ResultSet DatabaseMetaData.getSchemas(String catalog, String schemaPattern)
          获取此数据库中可用的模式名称。
 String DatabaseMetaData.getSchemaTerm()
          获取数据库供应商用于 "schema" 的首选术语。
 String DatabaseMetaData.getSearchStringEscape()
          获取可用于转义通配符的字符串。
 short CallableStatement.getShort(int parameterIndex)
          以 Java 编程语言中 short 值的形式获取指定的 JDBC SMALLINT 参数的值。
 short ResultSet.getShort(int columnIndex)
          以 Java 编程语言中 short 的形式获取此 ResultSet 对象的当前行中指定列的值。
 short CallableStatement.getShort(String parameterName)
          以 Java 编程语言中 short 值的形式获取 JDBC SMALLINT 参数的值。
 short ResultSet.getShort(String columnLabel)
          以 Java 编程语言中 short 的形式获取此 ResultSet 对象的当前行中指定列的值。
<T extends Source>
T
SQLXML.getSource(Class<T> sourceClass)
          返回读取此 SQLXML 实例指定的 XML 值的 Source。
 String DatabaseMetaData.getSQLKeywords()
          获取此数据库的还“不”是 SQL:2003 关键字的所有 SQL 关键字的逗号分隔列表。
 int DatabaseMetaData.getSQLStateType()
          指示由 SQLException.getSQLState 返回的 SQLSTATE 是 X/Open（现在称为 Open Group）SQL CLI 还是 SQL:2003。
 String SQLData.getSQLTypeName()
          返回此对象表示的 SQL 用户定义类型的完全限定名。
 String Struct.getSQLTypeName()
          获取此 Struct 对象所表示 SQL 结构的完全限定的 SQL 名称。
 SQLXML CallableStatement.getSQLXML(int parameterIndex)
          以 Java 编程语言中 java.sql.SQLXML 对象的形式获取指定的 SQL XML 参数的值。
 SQLXML ResultSet.getSQLXML(int columnIndex)
          以 Java 编程语言中 java.sql.SQLXML 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 SQLXML CallableStatement.getSQLXML(String parameterName)
          以 Java 编程语言中 java.sql.SQLXML 对象的形式获取指定的 SQL XML 参数的值。
 SQLXML ResultSet.getSQLXML(String columnLabel)
          以 Java 编程语言中 java.sql.SQLXML 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Statement ResultSet.getStatement()
          获取生成此 ResultSet 对象的 Statement 对象。
 String SQLXML.getString()
          返回此 SQLXML 实例指定的 XML 值的字符串表示形式。
 String CallableStatement.getString(int parameterIndex)
          以 Java 编程语言中 String 的形式获取指定的 JDBC CHAR、VARCHAR 或 LONGVARCHAR 参数的值。
 String ResultSet.getString(int columnIndex)
          以 Java 编程语言中 String 的形式获取此 ResultSet 对象的当前行中指定列的值。
 String CallableStatement.getString(String parameterName)
          以 Java 编程语言中 String 的形式获取 JDBC CHAR、VARCHAR 或 LONGVARCHAR 参数的值。
 String ResultSet.getString(String columnLabel)
          以 Java 编程语言中 String 的形式获取此 ResultSet 对象的当前行中指定列的值。
 String DatabaseMetaData.getStringFunctions()
          获取可用于此数据库的字符串函数的逗号分隔列表。
 String Clob.getSubString(long pos, int length)
          获取此 Clob 对象指定的 CLOB 值中指定子字符串的副本。
 ResultSet DatabaseMetaData.getSuperTables(String catalog, String schemaPattern, String tableNamePattern)
          获取在此数据库的特定模式中定义的表分层结构的描述。
 ResultSet DatabaseMetaData.getSuperTypes(String catalog, String schemaPattern, String typeNamePattern)
          获取在此数据库的特定模式中定义的用户定义类型 (UDT) 分层结构的描述。
 String DatabaseMetaData.getSystemFunctions()
          获取可用于此数据库的系统函数的逗号分隔列表。
 String ResultSetMetaData.getTableName(int column)
          获取指定列的名称。
 ResultSet DatabaseMetaData.getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern)
          获取可在类别中使用的每个表的访问权的描述。
 ResultSet DatabaseMetaData.getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types)
          获取可在给定类别中使用的表的描述。
 ResultSet DatabaseMetaData.getTableTypes()
          获取可在此数据库中使用的表类型。
 Time CallableStatement.getTime(int parameterIndex)
          以 java.sql.Time 对象的形式获取指定 JDBC TIME 参数的值。
 Time ResultSet.getTime(int columnIndex)
          以 Java 编程语言中 java.sql.Time 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Time CallableStatement.getTime(int parameterIndex, Calendar cal)
          以 java.sql.Time 对象的形式获取指定 JDBC TIME 参数的值，使用给定 Calendar 对象构造时间。
 Time ResultSet.getTime(int columnIndex, Calendar cal)
          以 Java 编程语言中 java.sql.Time 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Time CallableStatement.getTime(String parameterName)
          以 java.sql.Time 对象的形式获取 JDBC TIME 参数的值。
 Time ResultSet.getTime(String columnLabel)
          以 Java 编程语言中 java.sql.Time 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Time CallableStatement.getTime(String parameterName, Calendar cal)
          以 java.sql.Time 对象的形式获取 JDBC TIME 参数的值，使用给定 Calendar 对象构造时间。
 Time ResultSet.getTime(String columnLabel, Calendar cal)
          以 Java 编程语言中 java.sql.Time 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 String DatabaseMetaData.getTimeDateFunctions()
          获取可用于此数据库的时间和日期函数的逗号分隔列表。
 Timestamp CallableStatement.getTimestamp(int parameterIndex)
          以 java.sql.Timestamp 对象的形式获取指定 JDBC TIMESTAMP 参数的值。
 Timestamp ResultSet.getTimestamp(int columnIndex)
          以 Java 编程语言中 java.sql.Timestamp 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Timestamp CallableStatement.getTimestamp(int parameterIndex, Calendar cal)
          以 java.sql.Timestamp 对象的形式获取指定 JDBC TIMESTAMP 参数的值，使用给定 Calendar 对象构造 Timestamp 对象。
 Timestamp ResultSet.getTimestamp(int columnIndex, Calendar cal)
          以 Java 编程语言中 java.sql.Timestamp 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Timestamp CallableStatement.getTimestamp(String parameterName)
          以 java.sql.Timestamp 对象的形式获取 JDBC TIMESTAMP 参数的值。
 Timestamp ResultSet.getTimestamp(String columnLabel)
          以 Java 编程语言中 java.sql.Timestamp 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 Timestamp CallableStatement.getTimestamp(String parameterName, Calendar cal)
          以 java.sql.Timestamp 对象的形式获取 JDBC TIMESTAMP 参数的值，使用给定 Calendar 对象构造 Timestamp 对象。
 Timestamp ResultSet.getTimestamp(String columnLabel, Calendar cal)
          以 Java 编程语言中 java.sql.Timestamp 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 int Connection.getTransactionIsolation()
          获取此 Connection 对象的当前事务隔离级别。
 int ResultSet.getType()
          获取此 ResultSet 对象的类型。
 ResultSet DatabaseMetaData.getTypeInfo()
          获取此数据库支持的所有数据类型的描述。
 Map<String,Class<?>> Connection.getTypeMap()
          获取与此 Connection 对象关联的 Map 对象。
 ResultSet DatabaseMetaData.getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types)
          获取在特定模式中定义的用户定义类型 (UDT) 的描述。
 InputStream ResultSet.getUnicodeStream(int columnIndex)
          已过时。 使用 getCharacterStream 取代 getUnicodeStream
 InputStream ResultSet.getUnicodeStream(String columnLabel)
          已过时。 使用 getCharacterStream 代替
 int Statement.getUpdateCount()
          以更新计数的形式获取当前结果；如果结果为 ResultSet 对象或没有更多结果，则返回 -1。
 String DatabaseMetaData.getURL()
          获取此 DBMS 的 URL。
 URL CallableStatement.getURL(int parameterIndex)
          以 java.sql.URL 对象的形式获取指定 JDBC DATALINK 参数的值。
 URL ResultSet.getURL(int columnIndex)
          以 Java 编程语言中 java.net.URL 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 URL CallableStatement.getURL(String parameterName)
          以 java.net.URL 对象的形式获取 JDBC DATALINK 参数的值。
 URL ResultSet.getURL(String columnLabel)
          以 Java 编程语言中 java.net.URL 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
 String DatabaseMetaData.getUserName()
          获取此数据库的已知的用户名称。
 ResultSet DatabaseMetaData.getVersionColumns(String catalog, String schema, String table)
          获取在更新行中的任意值时自动更新的表列的描述。
 SQLWarning Connection.getWarnings()
          获取此 Connection 对象上的调用报告的第一个警告。
 SQLWarning ResultSet.getWarnings()
          获取此 ResultSet 对象上的调用报告的第一个警告。
 SQLWarning Statement.getWarnings()
          获取此 Statement 对象上的调用报告的第一个警告。
 void ResultSet.insertRow()
          将插入行的内容插入到此 ResultSet 对象和数据库中。
 boolean DatabaseMetaData.insertsAreDetected(int type)
          获取是否可以通过调用 ResultSet.rowInserted 方法检测可见行的插入。
 boolean ResultSet.isAfterLast()
          获取光标是否位于此 ResultSet 对象的最后一行之后。
 boolean ResultSetMetaData.isAutoIncrement(int column)
          指示是否自动为指定列进行编号。
 boolean ResultSet.isBeforeFirst()
          获取光标是否位于此 ResultSet 对象的第一行之前。
 boolean ResultSetMetaData.isCaseSensitive(int column)
          指示列的大小写是否有关系。
 boolean DatabaseMetaData.isCatalogAtStart()
          获取某个类别是否出现在完全限定表名的开头。
 boolean Connection.isClosed()
          查询此 Connection 对象是否已经被关闭。
 boolean ResultSet.isClosed()
          获取此 ResultSet 对象是否已关闭。
 boolean Statement.isClosed()
          获取是否已关闭了此 Statement 对象。
 boolean ResultSetMetaData.isCurrency(int column)
          指示指定的列是否是一个哈希代码值。
 boolean ResultSetMetaData.isDefinitelyWritable(int column)
          指示在指定的列上进行写操作是否明确可以获得成功。
 boolean ResultSet.isFirst()
          获取光标是否位于此 ResultSet 对象的第一行。
 boolean ResultSet.isLast()
          获取光标是否位于此 ResultSet 对象的最后一行。
 int ParameterMetaData.isNullable(int param)
          获取是否允许在指定参数中使用 null 值。
 int ResultSetMetaData.isNullable(int column)
          指示指定列中的值是否可以为 null。
 boolean Statement.isPoolable()
          返回指示 Statement 是否是可池化的值。
 boolean Connection.isReadOnly()
          查询此 Connection 对象是否处于只读模式。
 boolean DatabaseMetaData.isReadOnly()
          获取此数据库是否处于只读模式。
 boolean ResultSetMetaData.isReadOnly(int column)
          指示指定的列是否明确不可写入。
 boolean ResultSetMetaData.isSearchable(int column)
          指示是否可以在 where 子句中使用指定的列。
 boolean ParameterMetaData.isSigned(int param)
          获取指定参数的值是否可以是带符号的数字。
 boolean ResultSetMetaData.isSigned(int column)
          指示指定列中的值是否带正负号。
 boolean Connection.isValid(int timeout)
          如果连接尚未关闭并且仍然有效，则返回 true。
 boolean Wrapper.isWrapperFor(Class<?> iface)
          如果调用此方法的对象实现接口参数，或者是实现接口参数的对象的直接或间接包装器，则返回 true。
 boolean ResultSetMetaData.isWritable(int column)
          指示在指定的列上进行写操作是否可以获得成功。
 boolean ResultSet.last()
          将光标移动到此 ResultSet 对象的最后一行。
 long Blob.length()
          返回此 Blob 对象指定的 BLOB 值中的字节数。
 long Clob.length()
          获取此 Clob 对象指定的 CLOB 值中的字符数。
 boolean DatabaseMetaData.locatorsUpdateCopy()
          指示对 LOB 的更新是在副本上进行还是直接更新到 LOB。
 void ResultSet.moveToCurrentRow()
          将光标移动到记住的光标位置，通常为当前行。
 void ResultSet.moveToInsertRow()
          将光标移动到插入行。
 String Connection.nativeSQL(String sql)
          将给定的 SQL 语句转换成系统本机 SQL 语法。
 boolean ResultSet.next()
          将光标从当前位置向前移一行。
 boolean DatabaseMetaData.nullPlusNonNullIsNull()
          获取此数据库是否支持 NULL 值与等于 NULL 的非 NULL 值之间的连接。
 boolean DatabaseMetaData.nullsAreSortedAtEnd()
          获取 NULL 值是否始终排在末尾，不管排序顺序如何。
 boolean DatabaseMetaData.nullsAreSortedAtStart()
          获取 NULL 值是否始终排在开头，不管排序顺序如何。
 boolean DatabaseMetaData.nullsAreSortedHigh()
          获取 NULL 值是否被高排序。
 boolean DatabaseMetaData.nullsAreSortedLow()
          获取 NULL 值是否被低排序。
 boolean DatabaseMetaData.othersDeletesAreVisible(int type)
          获取由其他结果集类型进行的删除是否可见。
 boolean DatabaseMetaData.othersInsertsAreVisible(int type)
          获取由其他结果集类型进行的插入是否可见。
 boolean DatabaseMetaData.othersUpdatesAreVisible(int type)
          获取由其他结果集类型进行的更新是否可见。
 boolean DatabaseMetaData.ownDeletesAreVisible(int type)
          获取结果集自身的删除是否可见。
 boolean DatabaseMetaData.ownInsertsAreVisible(int type)
          获取结果集自身的插入是否可见。
 boolean DatabaseMetaData.ownUpdatesAreVisible(int type)
          获取对于给定类型的 ResultSet 对象，结果集自身的更新是否可见。
 long Blob.position(Blob pattern, long start)
          获取此 Blob 对象指定的 BLOB 值中 pattern 开始处的字节位置。
 long Blob.position(byte[] pattern, long start)
          获取此 Blob 对象表示的 BLOB 值中指定 byte 数组 pattern 开始处的字节位置。
 long Clob.position(Clob searchstr, long start)
          获取此 Clob 对象中指定的 Clob 对象 searchstr 出现的字符位置。
 long Clob.position(String searchstr, long start)
          获取此 Clob 对象表示的 SQL CLOB 值中指定子字符串 searchstr 出现的字符位置。
 CallableStatement Connection.prepareCall(String sql)
          创建一个 CallableStatement 对象来调用数据库存储过程。
 CallableStatement Connection.prepareCall(String sql, int resultSetType, int resultSetConcurrency)
          创建一个 CallableStatement 对象，该对象将生成具有给定类型和并发性的 ResultSet 对象。
 CallableStatement Connection.prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
          创建一个 CallableStatement 对象，该对象将生成具有给定类型和并发性的 ResultSet 对象。
 PreparedStatement Connection.prepareStatement(String sql)
          创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库。
 PreparedStatement Connection.prepareStatement(String sql, int autoGeneratedKeys)
          创建一个默认 PreparedStatement 对象，该对象能获取自动生成的键。
 PreparedStatement Connection.prepareStatement(String sql, int[] columnIndexes)
          创建一个能返回由给定数组指定的自动生成键的默认 PreparedStatement 对象。
 PreparedStatement Connection.prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
          创建一个 PreparedStatement 对象，该对象将生成具有给定类型和并发性的 ResultSet 对象。
 PreparedStatement Connection.prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
          创建一个 PreparedStatement 对象，该对象将生成具有给定类型、并发性和可保存性的 ResultSet 对象。
 PreparedStatement Connection.prepareStatement(String sql, String[] columnNames)
          创建一个能返回由给定数组指定的自动生成键的默认 PreparedStatement 对象。
 boolean ResultSet.previous()
          将光标移动到此 ResultSet 对象的上一行。
 Array SQLInput.readArray()
          从流中读取 SQL ARRAY 值并将其作为 Java 编程语言中的 Array 对象返回。
 InputStream SQLInput.readAsciiStream()
          读取流中的下一个属性并将其作为 ASCII 字符流返回。
 BigDecimal SQLInput.readBigDecimal()
          读取流中的下一个属性并将其作为 Java 编程语言中的 java.math.BigDecimal 对象返回。
 InputStream SQLInput.readBinaryStream()
          读取流中的下一个属性并将其作为未解释的字节流返回。
 Blob SQLInput.readBlob()
          从流中读取 SQL BLOB 值并将其作为 Java 编程语言中的 Blob 对象返回。
 boolean SQLInput.readBoolean()
          读取流中的下一个属性并将其作为 Java 编程语言中的 boolean 返回。
 byte SQLInput.readByte()
          读取流中的下一个属性并将其作为 Java 编程语言中的 byte 返回。
 byte[] SQLInput.readBytes()
          读取流中的下一个属性并将其作为 Java 编程语言中的字节数组返回。
 Reader SQLInput.readCharacterStream()
          读取流中的下一个属性并将其作为 Unicode 字符流返回。
 Clob SQLInput.readClob()
          从流中读取 SQL CLOB 值并将其作为 Java 编程语言中的 Clob 对象返回。
 Date SQLInput.readDate()
          读取流中的下一个属性并将其作为 java.sql.Date 对象返回。
 double SQLInput.readDouble()
          读取流中的下一个属性并将其作为 Java 编程语言中的 double 返回。
 float SQLInput.readFloat()
          读取流中的下一个属性并将其作为 Java 编程语言中的 float 返回。
 int SQLInput.readInt()
          读取流中的下一个属性并将其作为 Java 编程语言中的 int 返回。
 long SQLInput.readLong()
          读取流中的下一个属性并将其作为 Java 编程语言中的 long 返回。
 NClob SQLInput.readNClob()
          从流中读取一个 SQL NCLOB 值，并以 Java 编程语言中 NCLOB 对象的形式返回。
 String SQLInput.readNString()
          读取流中的下一个属性，并以 Java 编程语言中 String 的形式返回。
 Object SQLInput.readObject()
          读取流头中的下一个属性并将其作为 Java 编程语言中的 Object 返回。
 Ref SQLInput.readRef()
          从流读取 SQL REF 值并将其作为 Java 编程语言中的 Ref 对象返回。
 RowId SQLInput.readRowId()
          从流中读取一个 SQL ROWID 值，并以 Java 编程语言中 RowId 对象的形式返回。
 short SQLInput.readShort()
          读取流中的下一个属性并将其作为 Java 编程语言中的 short 返回。
 void SQLData.readSQL(SQLInput stream, String typeName)
          用从数据库读取的数据填充此对象。
 SQLXML SQLInput.readSQLXML()
          从流中读取一个 SQL XML 值，并以 Java 编程语言中 SQLXML 对象的形式返回。
 String SQLInput.readString()
          读取流中的下一个属性并将其作为 Java 编程语言中的 String 返回。
 Time SQLInput.readTime()
          读取流中的下一个属性并将其作为 java.sql.Time 对象返回。
 Timestamp SQLInput.readTimestamp()
          读取流中的下一个属性并将其作为 java.sql.Timestamp 对象返回。
 URL SQLInput.readURL()
          从流中读取 SQL DATALINK 值并将其作为 Java 编程语言中的 java.net.URL 对象返回。
 void ResultSet.refreshRow()
          用数据库中的最近值刷新当前行。
static void DriverManager.registerDriver(Driver driver)
          向 DriverManager 注册给定驱动程序。
 void CallableStatement.registerOutParameter(int parameterIndex, int sqlType)
          按顺序位置 parameterIndex 将 OUT 参数注册为 JDBC 类型 sqlType。
 void CallableStatement.registerOutParameter(int parameterIndex, int sqlType, int scale)
          按顺序位置 parameterIndex 将参数注册为 JDBC 类型 sqlType。
 void CallableStatement.registerOutParameter(int parameterIndex, int sqlType, String typeName)
          注册指定的输出参数。
 void CallableStatement.registerOutParameter(String parameterName, int sqlType)
          将名为 parameterName 的 OUT 参数注册为 JDBC 类型 sqlType。
 void CallableStatement.registerOutParameter(String parameterName, int sqlType, int scale)
          将名为 parameterName 的参数注册为 JDBC 类型 sqlType。
 void CallableStatement.registerOutParameter(String parameterName, int sqlType, String typeName)
          注册指定的输出参数。
 boolean ResultSet.relative(int rows)
          按相对行数（或正或负）移动光标。
 void Connection.releaseSavepoint(Savepoint savepoint)
          从当前事务中移除指定的 Savepoint 和后续 Savepoint 对象。
 void Connection.rollback()
          取消在当前事务中进行的所有更改，并释放此 Connection 对象当前持有的所有数据库锁。
 void Connection.rollback(Savepoint savepoint)
          取消所有设置给定 Savepoint 对象之后进行的更改。
 boolean ResultSet.rowDeleted()
          获取是否已删除某行。
 boolean ResultSet.rowInserted()
          获取当前行是否已有插入。
 boolean ResultSet.rowUpdated()
          获取是否已更新当前行。
 void PreparedStatement.setArray(int parameterIndex, Array x)
          将指定参数设置为给定 java.sql.Array 对象。
 void PreparedStatement.setAsciiStream(int parameterIndex, InputStream x)
          将指定参数设置为给定输入流。
 void PreparedStatement.setAsciiStream(int parameterIndex, InputStream x, int length)
          将指定参数设置为给定输入流，该输入流将具有给定字节数。
 void PreparedStatement.setAsciiStream(int parameterIndex, InputStream x, long length)
          将指定参数设置为给定输入流，该输入流将具有指定字节数。
 OutputStream Clob.setAsciiStream(long pos)
          获取用于将 Ascii 字符写入此 Clob 对象表示的 Clob 值中的流，从位置 pos 处开始。
 void CallableStatement.setAsciiStream(String parameterName, InputStream x)
          将指定参数设置为给定输入流。
 void CallableStatement.setAsciiStream(String parameterName, InputStream x, int length)
          将指定参数设置为给定输入流，该输入流将拥有指定的字节数。
 void CallableStatement.setAsciiStream(String parameterName, InputStream x, long length)
          将指定参数设置为给定输入流，该输入流将拥有指定的字节数。
 void Connection.setAutoCommit(boolean autoCommit)
          将此连接的自动提交模式设置为给定状态。
 void PreparedStatement.setBigDecimal(int parameterIndex, BigDecimal x)
          将指定参数设置为给定 java.math.BigDecimal 值。
 void CallableStatement.setBigDecimal(String parameterName, BigDecimal x)
          将指定参数设置为给定 java.math.BigDecimal 值。
 OutputStream SQLXML.setBinaryStream()
          获取可用于写入此 SQLXML 实例表示的 XML 值的流。
 void PreparedStatement.setBinaryStream(int parameterIndex, InputStream x)
          将指定参数设置为给定输入流。
 void PreparedStatement.setBinaryStream(int parameterIndex, InputStream x, int length)
          将指定参数设置为给定输入流，该输入流将具有给定字节数。
 void PreparedStatement.setBinaryStream(int parameterIndex, InputStream x, long length)
          将指定参数设置为给定输入流，该输入流将具有指定字节数。
 OutputStream Blob.setBinaryStream(long pos)
          获取用于写入此 Blob 对象表示的 BLOB 值的流。
 void CallableStatement.setBinaryStream(String parameterName, InputStream x)
          将指定参数设置为给定输入流。
 void CallableStatement.setBinaryStream(String parameterName, InputStream x, int length)
          将指定参数设置为给定输入流，该输入流将拥有指定的字节数。
 void CallableStatement.setBinaryStream(String parameterName, InputStream x, long length)
          将指定参数设置为给定输入流，该输入流将拥有指定字节数。
 void PreparedStatement.setBlob(int parameterIndex, Blob x)
          将指定参数设置为给定 java.sql.Blob 对象。
 void PreparedStatement.setBlob(int parameterIndex, InputStream inputStream)
          将指定参数设置为 InputStream 对象。
 void PreparedStatement.setBlob(int parameterIndex, InputStream inputStream, long length)
          将指定参数设置为 InputStream 对象。
 void CallableStatement.setBlob(String parameterName, Blob x)
          将指定参数设置为给定的 java.sql.Blob 对象。
 void CallableStatement.setBlob(String parameterName, InputStream inputStream)
          将指定参数设置为 InputStream 对象。
 void CallableStatement.setBlob(String parameterName, InputStream inputStream, long length)
          将指定参数设置为 InputStream 对象。
 void PreparedStatement.setBoolean(int parameterIndex, boolean x)
          将指定参数设置为给定 Java boolean 值。
 void CallableStatement.setBoolean(String parameterName, boolean x)
          将指定参数设置为给定 Java boolean 值。
 void PreparedStatement.setByte(int parameterIndex, byte x)
          将指定参数设置为给定 Java byte 值。
 void CallableStatement.setByte(String parameterName, byte x)
          将指定参数设置为给定 Java byte 值。
 void PreparedStatement.setBytes(int parameterIndex, byte[] x)
          将指定参数设置为给定 Java byte 数组。
 int Blob.setBytes(long pos, byte[] bytes)
          从位置 pos 处开始，将给定 byte 数组写入此 Blob 对象表示的 BLOB 值，并返回写入的字节数。
 int Blob.setBytes(long pos, byte[] bytes, int offset, int len)
          将所有或部分给定的 byte 数组写入此 Blob 对象表示的 BLOB 值中，并返回写入的字节数。
 void CallableStatement.setBytes(String parameterName, byte[] x)
          将指定参数设置为给定 Java byte 数组。
 void Connection.setCatalog(String catalog)
          设置给定目录名称，以便选择要在其中进行工作的此 Connection 对象数据库的子空间。
 Writer SQLXML.setCharacterStream()
          获取用于写入此 SQLXML 实例表示的 XML 值的流。
 void PreparedStatement.setCharacterStream(int parameterIndex, Reader reader)
          将指定参数设置为给定 Reader 对象。
 void PreparedStatement.setCharacterStream(int parameterIndex, Reader reader, int length)
          将给定参数设置为给定 Reader 对象，该对象具有给定字符数长度。
 void PreparedStatement.setCharacterStream(int parameterIndex, Reader reader, long length)
          将指定参数设置为给定 Reader 对象，该对象具有给定字符数长度。
 Writer Clob.setCharacterStream(long pos)
          获取用于将 Unicode 字符流写入此 Clob 对象表示的 CLOB 值中（位置 pos 处）的流。
 void CallableStatement.setCharacterStream(String parameterName, Reader reader)
          将指定参数设置为给定 Reader 对象。
 void CallableStatement.setCharacterStream(String parameterName, Reader reader, int length)
          将指定参数设置为给定 Reader 对象，该对象是给定的字符长度数。
 void CallableStatement.setCharacterStream(String parameterName, Reader reader, long length)
          将指定参数设置为给定 Reader 对象，该对象具有给定字符数长度。
 void PreparedStatement.setClob(int parameterIndex, Clob x)
          将指定参数设置为给定 java.sql.Clob 对象。
 void PreparedStatement.setClob(int parameterIndex, Reader reader)
          将指定参数设置为 Reader 对象。
 void PreparedStatement.setClob(int parameterIndex, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void CallableStatement.setClob(String parameterName, Clob x)
          将指定参数设置为给定的 java.sql.Clob 对象。
 void CallableStatement.setClob(String parameterName, Reader reader)
          将指定参数设置为 Reader 对象。
 void CallableStatement.setClob(String parameterName, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void Statement.setCursorName(String name)
          将 SQL 指针名称设置为给定的 String，后续 Statement 对象的 execute 方法将使用此字符串。
 void PreparedStatement.setDate(int parameterIndex, Date x)
          使用运行应用程序的虚拟机的默认时区将指定参数设置为给定 java.sql.Date 值。
 void PreparedStatement.setDate(int parameterIndex, Date x, Calendar cal)
          使用给定的 Calendar 对象将指定参数设置为给定 java.sql.Date 值。
 void CallableStatement.setDate(String parameterName, Date x)
          使用运行应用程序的虚拟机默认时区将指定参数设置为给定 java.sql.Date 值。
 void CallableStatement.setDate(String parameterName, Date x, Calendar cal)
          使用给定的 Calendar 对象将指定参数设置为给定 java.sql.Date 值。
 void PreparedStatement.setDouble(int parameterIndex, double x)
          将指定参数设置为给定 Java double 值。
 void CallableStatement.setDouble(String parameterName, double x)
          将指定参数设置为给定 Java double 值。
 void Statement.setEscapeProcessing(boolean enable)
          将转义处理设置为开或关。
 void ResultSet.setFetchDirection(int direction)
          设置此 ResultSet 对象中行的处理方向。
 void Statement.setFetchDirection(int direction)
          向驱动程序提供关于方向的提示，在使用此 Statement 对象创建的 ResultSet 对象中将按该方向处理行。
 void ResultSet.setFetchSize(int rows)
          为 JDBC 驱动程序设置此 ResultSet 对象需要更多行时应该从数据库获取的行数。
 void Statement.setFetchSize(int rows)
          为 JDBC 驱动程序提供一个提示，它提示此 Statement 生成的 ResultSet 对象需要更多行时应该从数据库获取的行数。
 void PreparedStatement.setFloat(int parameterIndex, float x)
          将指定参数设置为给定 Java REAL 值。
 void CallableStatement.setFloat(String parameterName, float x)
          将指定参数设置为给定 Java float 值。
 void Connection.setHoldability(int holdability)
          将使用此 Connection 对象创建的 ResultSet 对象的默认可保存性 (holdability) 更改为给定可保存性。
 void PreparedStatement.setInt(int parameterIndex, int x)
          将指定参数设置为给定 Java int 值。
 void CallableStatement.setInt(String parameterName, int x)
          将指定参数设置为给定 Java int 值。
 void PreparedStatement.setLong(int parameterIndex, long x)
          将指定参数设置为给定 Java long 值。
 void CallableStatement.setLong(String parameterName, long x)
          将指定参数设置为给定 Java long 值。
 void Statement.setMaxFieldSize(int max)
          设置此 Statement 对象生成的 ResultSet 对象中字符和二进制列值可以返回的最大字节数限制。
 void Statement.setMaxRows(int max)
          将此 Statement 对象生成的所有 ResultSet 对象可以包含的最大行数限制设置为给定数。
 void PreparedStatement.setNCharacterStream(int parameterIndex, Reader value)
          将指定参数设置为 Reader 对象。
 void PreparedStatement.setNCharacterStream(int parameterIndex, Reader value, long length)
          将指定参数设置为 Reader 对象。
 void CallableStatement.setNCharacterStream(String parameterName, Reader value)
          将指定参数设置为 Reader 对象。
 void CallableStatement.setNCharacterStream(String parameterName, Reader value, long length)
          将指定参数设置为 Reader 对象。
 void PreparedStatement.setNClob(int parameterIndex, NClob value)
          将指定参数设置为 java.sql.NClob 对象。
 void PreparedStatement.setNClob(int parameterIndex, Reader reader)
          将指定参数设置为 Reader 对象。
 void PreparedStatement.setNClob(int parameterIndex, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void CallableStatement.setNClob(String parameterName, NClob value)
          将指定参数设置为 java.sql.NClob 对象。
 void CallableStatement.setNClob(String parameterName, Reader reader)
          将指定参数设置为 Reader 对象。
 void CallableStatement.setNClob(String parameterName, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void PreparedStatement.setNString(int parameterIndex, String value)
          将指定参数设置为给定 String 对象。
 void CallableStatement.setNString(String parameterName, String value)
          将指定参数设置为给定 String 对象。
 void PreparedStatement.setNull(int parameterIndex, int sqlType)
          将指定参数设置为 SQL NULL。
 void PreparedStatement.setNull(int parameterIndex, int sqlType, String typeName)
          将指定参数设置为 SQL NULL。
 void CallableStatement.setNull(String parameterName, int sqlType)
          将指定参数设置为 SQL NULL。
 void CallableStatement.setNull(String parameterName, int sqlType, String typeName)
          将指定参数设置为 SQL NULL。
 void PreparedStatement.setObject(int parameterIndex, Object x)
          使用给定对象设置指定参数的值。
 void PreparedStatement.setObject(int parameterIndex, Object x, int targetSqlType)
          使用给定对象设置指定参数的值。
 void PreparedStatement.setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength)
          使用给定对象设置指定参数的值。
 void Ref.setObject(Object value)
          将此 Ref 对象引用的结构类型值设置为给定的 Object 实例。
 void CallableStatement.setObject(String parameterName, Object x)
          使用给定对象设置指定参数的值。
 void CallableStatement.setObject(String parameterName, Object x, int targetSqlType)
          使用给定对象设置指定参数的值。
 void CallableStatement.setObject(String parameterName, Object x, int targetSqlType, int scale)
          使用给定对象设置指定参数的值。
 void Statement.setPoolable(boolean poolable)
          请求将 Statement 池化或非池化。
 void Statement.setQueryTimeout(int seconds)
          将驱动程序等待 Statement 对象执行的秒数设置为给定秒数。
 void Connection.setReadOnly(boolean readOnly)
          将此连接设置为只读模式，作为驱动程序启用数据库优化的提示。
 void PreparedStatement.setRef(int parameterIndex, Ref x)
          将指定参数设置为给定 REF(<structured-type>) 值。
<T extends Result>
T
SQLXML.setResult(Class<T> resultClass)
          返回设置此 SQLXML 实例指定的 XML 值的 Result。
 void PreparedStatement.setRowId(int parameterIndex, RowId x)
          将指定参数设置为给定 java.sql.RowId 对象。
 void CallableStatement.setRowId(String parameterName, RowId x)
          将指定参数设置为给定 java.sql.RowId 对象。
 Savepoint Connection.setSavepoint()
          在当前事务中创建一个未命名的保存点 (savepoint)，并返回表示它的新 Savepoint 对象。
 Savepoint Connection.setSavepoint(String name)
          在当前事务中创建一个具有给定名称的保存点，并返回表示它的新 Savepoint 对象。
 void PreparedStatement.setShort(int parameterIndex, short x)
          将指定参数设置为给定 Java short 值。
 void CallableStatement.setShort(String parameterName, short x)
          将指定参数设置为给定 Java short 值。
 void PreparedStatement.setSQLXML(int parameterIndex, SQLXML xmlObject)
          将指定参数设置为给定 java.sql.SQLXML 对象。
 void CallableStatement.setSQLXML(String parameterName, SQLXML xmlObject)
          将指定参数设置为给定 java.sql.SQLXML 对象。
 void PreparedStatement.setString(int parameterIndex, String x)
          将指定参数设置为给定 Java String 值。
 int Clob.setString(long pos, String str)
          在位置 pos 处将给定 Java String 写入此 Clob 对象指定的 CLOB 值中。
 int Clob.setString(long pos, String str, int offset, int len)
          将 str 的 len 个字符（从字符 offset 开始）写入此 Clob 表示的 CLOB 值中。
 void SQLXML.setString(String value)
          将此 SQLXML 实例指定的 XML 值设置为给定的 String 表示形式。
 void CallableStatement.setString(String parameterName, String x)
          将指定参数设置为给定 Java String 值。
 void PreparedStatement.setTime(int parameterIndex, Time x)
          将指定参数设置为给定 java.sql.Time 值。
 void PreparedStatement.setTime(int parameterIndex, Time x, Calendar cal)
          使用给定的 Calendar 对象将指定参数设置为给定 java.sql.Time 值。
 void CallableStatement.setTime(String parameterName, Time x)
          将指定参数设置为给定 java.sql.Time 值。
 void CallableStatement.setTime(String parameterName, Time x, Calendar cal)
          使用给定的 Calendar 对象将指定参数设置为给定 java.sql.Time 值。
 void PreparedStatement.setTimestamp(int parameterIndex, Timestamp x)
          将指定参数设置为给定 java.sql.Timestamp 值。
 void PreparedStatement.setTimestamp(int parameterIndex, Timestamp x, Calendar cal)
          使用给定的 Calendar 对象将指定参数设置为给定 java.sql.Timestamp 值。
 void CallableStatement.setTimestamp(String parameterName, Timestamp x)
          将指定参数设置为给定 java.sql.Timestamp 值。
 void CallableStatement.setTimestamp(String parameterName, Timestamp x, Calendar cal)
          使用给定的 Calendar 对象将指定参数设置为给定 java.sql.Timestamp 值。
 void Connection.setTransactionIsolation(int level)
          试图将此 Connection 对象的事务隔离级别更改为给定的级别。
 void Connection.setTypeMap(Map<String,Class<?>> map)
          将给定的 TypeMap 对象安装为此 Connection 对象的类型映射。
 void PreparedStatement.setUnicodeStream(int parameterIndex, InputStream x, int length)
          已过时。  
 void PreparedStatement.setURL(int parameterIndex, URL x)
          将指定参数设置为给定 java.net.URL 值。
 void CallableStatement.setURL(String parameterName, URL val)
          将指定参数设置为给定 java.net.URL 对象。
 boolean DatabaseMetaData.storesLowerCaseIdentifiers()
          获取此数据库是否将大小写混写的不带引号的 SQL 标识符作为不区分大小写的形式处理，并以小写形式存储它们。
 boolean DatabaseMetaData.storesLowerCaseQuotedIdentifiers()
          获取此数据库是否将大小写混写的带引号的 SQL 标识符作为不区分大小写的形式处理，并以小写形式存储它们。
 boolean DatabaseMetaData.storesMixedCaseIdentifiers()
          获取此数据库是否将大小写混写的不带引号的 SQL 标识符作为不区分大小写的形式处理，并以大小写混合形式存储它们。
 boolean DatabaseMetaData.storesMixedCaseQuotedIdentifiers()
          获取此数据库是否将大小写混写的带引号的 SQL 标识符作为不区分大小写的形式处理，并以大小写混合形式存储它们。
 boolean DatabaseMetaData.storesUpperCaseIdentifiers()
          获取此数据库是否将大小写混写的不带引号的 SQL 标识符作为不区分大小写的形式处理，并以大写形式存储它们。
 boolean DatabaseMetaData.storesUpperCaseQuotedIdentifiers()
          获取此数据库是否将大小写混写的带引号的 SQL 标识符作为不区分大小写的形式处理，并以大写形式存储它们。
 boolean DatabaseMetaData.supportsAlterTableWithAddColumn()
          获取此数据库是否支持带有 add 列的 ALTER TABLE。
 boolean DatabaseMetaData.supportsAlterTableWithDropColumn()
          获取此数据库是否支持带有 drop 列的 ALTER TABLE。
 boolean DatabaseMetaData.supportsANSI92EntryLevelSQL()
          获取此数据库是否支持 ANSI92 入门级 SQL 语法。
 boolean DatabaseMetaData.supportsANSI92FullSQL()
          获取此数据库是否支持受支持的 ANSI92 完全 SQL 语法。
 boolean DatabaseMetaData.supportsANSI92IntermediateSQL()
          获取此数据库是否支持受支持的 ANSI92 中间 SQL 语法。
 boolean DatabaseMetaData.supportsBatchUpdates()
          获取此数据库是否支持批量更新。
 boolean DatabaseMetaData.supportsCatalogsInDataManipulation()
          获取某个类别名称是否可以在数据操作语句中使用。
 boolean DatabaseMetaData.supportsCatalogsInIndexDefinitions()
          获取某个类别名称是否可以在获取定义语句中使用。
 boolean DatabaseMetaData.supportsCatalogsInPrivilegeDefinitions()
          获取某个类别名称是否可以在特权定义语句中使用。
 boolean DatabaseMetaData.supportsCatalogsInProcedureCalls()
          获取某个类别名称是否可以在过程调用语句中使用。
 boolean DatabaseMetaData.supportsCatalogsInTableDefinitions()
          获取某个类别名称是否可以在表定义语句中使用。
 boolean DatabaseMetaData.supportsColumnAliasing()
          获取此数据库是否支持为列提供别名。
 boolean DatabaseMetaData.supportsConvert()
          获取此数据库是否支持用于 JDBC 类型之间转换的 JDBC 标量函数 CONVERT。
 boolean DatabaseMetaData.supportsConvert(int fromType, int toType)
          获取此数据库是否支持用于 JDBC fromType 和 toType 类型之间转换的 JDBC 标量函数 CONVERT。
 boolean DatabaseMetaData.supportsCoreSQLGrammar()
          获取此数据库是否支持 ODBC Core SQL 语法。
 boolean DatabaseMetaData.supportsCorrelatedSubqueries()
          获取此数据库是否支持相关子查询。
 boolean DatabaseMetaData.supportsDataDefinitionAndDataManipulationTransactions()
          获取此数据库是否同时支持事务中的数据定义和数据操作语句。
 boolean DatabaseMetaData.supportsDataManipulationTransactionsOnly()
          获取此数据库是否仅支持事务中的数据操作语句。
 boolean DatabaseMetaData.supportsDifferentTableCorrelationNames()
          获取在表关联名称受支持时，是否要限制它们与表的名称不同。
 boolean DatabaseMetaData.supportsExpressionsInOrderBy()
          获取此数据库是否支持 ORDER BY 列表中的表达式。
 boolean DatabaseMetaData.supportsExtendedSQLGrammar()
          获取此数据库是否支持 ODBC Extended SQL 语法。
 boolean DatabaseMetaData.supportsFullOuterJoins()
          获取此数据库是否支持完全嵌套的外连接。
 boolean DatabaseMetaData.supportsGetGeneratedKeys()
          获取是否可以在执行语句后获取自动生成的键。
 boolean DatabaseMetaData.supportsGroupBy()
          获取此数据库是否支持某种形式的 GROUP BY 子句。
 boolean DatabaseMetaData.supportsGroupByBeyondSelect()
          获取此数据库是否支持使用不包含在 SELECT 语句中而包含在 GROUP BY 子句中的列，假设 SELECT 语句中的所有列都包含在 GROUP BY 子句中。
 boolean DatabaseMetaData.supportsGroupByUnrelated()
          获取此数据库是否支持使用不在 SELECT 语句中而在 GROUP BY 子句中的列。
 boolean DatabaseMetaData.supportsIntegrityEnhancementFacility()
          获取此数据库是否支持 SQL Integrity Enhancement Facility。
 boolean DatabaseMetaData.supportsLikeEscapeClause()
          获取此数据库是否支持指定 LIKE 转义子句。
 boolean DatabaseMetaData.supportsLimitedOuterJoins()
          获取此数据库是否为外连接提供受限制的支持。
 boolean DatabaseMetaData.supportsMinimumSQLGrammar()
          获取此数据库是否支持 ODBC Minimum SQL 语法。
 boolean DatabaseMetaData.supportsMixedCaseIdentifiers()
          获取此数据库是否将大小写混写的不带引号的 SQL 标识符作为区分大小写的形式处理，并且最后以大小写混合形式存储它们。
 boolean DatabaseMetaData.supportsMixedCaseQuotedIdentifiers()
          获取此数据库是否将大小写混写的带引号的 SQL 标识符作为区分大小写的形式处理，并且最后以大小写混合形式存储它们。
 boolean DatabaseMetaData.supportsMultipleOpenResults()
          获取是否可以同时拥有从 CallableStatement 对象中返回的多个 ResultSet 对象。
 boolean DatabaseMetaData.supportsMultipleResultSets()
          获取此数据库是否支持一次调用 execute 方法获得多个 ResultSet 对象。
 boolean DatabaseMetaData.supportsMultipleTransactions()
          获取此数据库是否允许一次打开多个事务（在不同的 connection 上）。
 boolean DatabaseMetaData.supportsNamedParameters()
          获取此数据库是否支持可调用语句的指定参数。
 boolean DatabaseMetaData.supportsNonNullableColumns()
          获取是否可以将此数据库中的列定义为非 null。
 boolean DatabaseMetaData.supportsOpenCursorsAcrossCommit()
          获取此数据库是否支持在进行提交期间保持游标开放。
 boolean DatabaseMetaData.supportsOpenCursorsAcrossRollback()
          获取此数据库是否支持在回滚期间保持游标开放。
 boolean DatabaseMetaData.supportsOpenStatementsAcrossCommit()
          获取此数据库是否支持在进行提交期间保持语句开放。
 boolean DatabaseMetaData.supportsOpenStatementsAcrossRollback()
          获取此数据库是否支持在回滚期间保持语句开放。
 boolean DatabaseMetaData.supportsOrderByUnrelated()
          获取此数据库是否支持使用不在 SELECT 语句中而在 ORDER BY 子句中的列。
 boolean DatabaseMetaData.supportsOuterJoins()
          获取此数据库是否支持某种形式的外连接。
 boolean DatabaseMetaData.supportsPositionedDelete()
          获取此数据库是否支持位置的 DELETE 语句。
 boolean DatabaseMetaData.supportsPositionedUpdate()
          获取此数据库是否支持位置的 UPDATE 语句。
 boolean DatabaseMetaData.supportsResultSetConcurrency(int type, int concurrency)
          获取此数据库是否支持与给定结果集类型结合在一起的给定并发性类型。
 boolean DatabaseMetaData.supportsResultSetHoldability(int holdability)
          获取此数据库是否支持给定结果集可保存性。
 boolean DatabaseMetaData.supportsResultSetType(int type)
          获取此数据库是否支持给定结果集类型。
 boolean DatabaseMetaData.supportsSavepoints()
          获取此数据库是否支持保存点 (savepoint)。
 boolean DatabaseMetaData.supportsSchemasInDataManipulation()
          获取某个模式名称是否可以数据操作语句中使用。
 boolean DatabaseMetaData.supportsSchemasInIndexDefinitions()
          获取某个模式名称是否可以在获取定义语句中使用。
 boolean DatabaseMetaData.supportsSchemasInPrivilegeDefinitions()
          获取某个模式名称是否可以在特权定义语句中使用。
 boolean DatabaseMetaData.supportsSchemasInProcedureCalls()
          获取某个模式名称是否可以在过程调用语句中使用。
 boolean DatabaseMetaData.supportsSchemasInTableDefinitions()
          获取某个模式名称是否可以在表定义语句中使用。
 boolean DatabaseMetaData.supportsSelectForUpdate()
          获取此数据库是否支持位置的 SELECT FOR UPDATE 语句。
 boolean DatabaseMetaData.supportsStatementPooling()
          获取此数据库是否支持语句合并 (statement pooling)。
 boolean DatabaseMetaData.supportsStoredFunctionsUsingCallSyntax()
          获取此数据库是否支持使用存储过程转义语法调用用户定义的函数或供应商函数。
 boolean DatabaseMetaData.supportsStoredProcedures()
          获取此数据库是否支持使用存储过程转义语法的存储过程调用。
 boolean DatabaseMetaData.supportsSubqueriesInComparisons()
          获取此数据库是否支持比较表达式中的子查询。
 boolean DatabaseMetaData.supportsSubqueriesInExists()
          获取此数据库是否支持 EXISTS 表达式中的子查询。
 boolean DatabaseMetaData.supportsSubqueriesInIns()
          获取此数据库是否支持 IN 表达式中的子查询。
 boolean DatabaseMetaData.supportsSubqueriesInQuantifieds()
          获取此数据库是否支持量化表达式 (quantified expression) 中的子查询。
 boolean DatabaseMetaData.supportsTableCorrelationNames()
          获取此数据库是否支持表关联名称。
 boolean DatabaseMetaData.supportsTransactionIsolationLevel(int level)
          获取此数据库是否支持给定事务隔离级别。
 boolean DatabaseMetaData.supportsTransactions()
          获取此数据库是否支持事务。
 boolean DatabaseMetaData.supportsUnion()
          获取此数据库是否支持 SQL UNION。
 boolean DatabaseMetaData.supportsUnionAll()
          获取此数据库是否支持 SQL UNION ALL。
 void Blob.truncate(long len)
          截取此 Blob 对象表示的 BLOB 值，使其长度为 len 个字节。
 void Clob.truncate(long len)
          截取此 Clob 指定的 CLOB 值，使其长度为 len 个字符。
<T> T
Wrapper.unwrap(Class<T> iface)
          返回一个对象，该对象实现给定接口，以允许访问非标准方法或代理未公开的标准方法。
 void ResultSet.updateArray(int columnIndex, Array x)
          用 java.sql.Array 值更新指定列。
 void ResultSet.updateArray(String columnLabel, Array x)
          用 java.sql.Array 值更新指定列。
 void ResultSet.updateAsciiStream(int columnIndex, InputStream x)
          用 ascii 流值更新指定的列。
 void ResultSet.updateAsciiStream(int columnIndex, InputStream x, int length)
          用 ascii 流值更新指定列，该列将具有指定字节数。
 void ResultSet.updateAsciiStream(int columnIndex, InputStream x, long length)
          用 ascii 流值更新指定的列，该值将具有指定的字节数。
 void ResultSet.updateAsciiStream(String columnLabel, InputStream x)
          用 ascii 流值更新指定列。
 void ResultSet.updateAsciiStream(String columnLabel, InputStream x, int length)
          用 ascii 流值更新指定列，该列具有指定的字节数。
 void ResultSet.updateAsciiStream(String columnLabel, InputStream x, long length)
          用 ascii 流值更新指定的列，该值将具有指定的字节数。
 void ResultSet.updateBigDecimal(int columnIndex, BigDecimal x)
          用 java.math.BigDecimal 值更新指定列。
 void ResultSet.updateBigDecimal(String columnLabel, BigDecimal x)
          用 java.sql.BigDecimal 值更新指定列。
 void ResultSet.updateBinaryStream(int columnIndex, InputStream x)
          用二进制流值更新指定的列。
 void ResultSet.updateBinaryStream(int columnIndex, InputStream x, int length)
          用二进制流值更新指定列，该列将具有指定字节数。
 void ResultSet.updateBinaryStream(int columnIndex, InputStream x, long length)
          用二进制流值更新指定的列，该值将具有指定的字节数。
 void ResultSet.updateBinaryStream(String columnLabel, InputStream x)
          用二进制流值更新指定列。
 void ResultSet.updateBinaryStream(String columnLabel, InputStream x, int length)
          用二进制流值更新指定列，该列具有指定的字节数。
 void ResultSet.updateBinaryStream(String columnLabel, InputStream x, long length)
          用二进制流值更新指定的列，该值将具有指定的字节数。
 void ResultSet.updateBlob(int columnIndex, Blob x)
          用 java.sql.Blob 值更新指定列。
 void ResultSet.updateBlob(int columnIndex, InputStream inputStream)
          使用给定输入流值更新指定列。
 void ResultSet.updateBlob(int columnIndex, InputStream inputStream, long length)
          使用给定输入流更新指定的列，该流将具有指定的字节数。
 void ResultSet.updateBlob(String columnLabel, Blob x)
          用 java.sql.Blob 值更新指定列。
 void ResultSet.updateBlob(String columnLabel, InputStream inputStream)
          使用给定输入流值更新指定列。
 void ResultSet.updateBlob(String columnLabel, InputStream inputStream, long length)
          使用给定输入流更新指定列，该流将具有指定的字节数。
 void ResultSet.updateBoolean(int columnIndex, boolean x)
          用 boolean 值更新指定列。
 void ResultSet.updateBoolean(String columnLabel, boolean x)
          用 boolean 值更新指定列。
 void ResultSet.updateByte(int columnIndex, byte x)
          用 byte 值更新指定列。
 void ResultSet.updateByte(String columnLabel, byte x)
          用 byte 值更新指定列。
 void ResultSet.updateBytes(int columnIndex, byte[] x)
          用 byte 数组值更新指定列。
 void ResultSet.updateBytes(String columnLabel, byte[] x)
          用字节数组值更新指定列。
 void ResultSet.updateCharacterStream(int columnIndex, Reader x)
          用字符流值更新指定的列。
 void ResultSet.updateCharacterStream(int columnIndex, Reader x, int length)
          用字符流值更新指定列，该列将具有指定字节数。
 void ResultSet.updateCharacterStream(int columnIndex, Reader x, long length)
          用字符流值更新指定的列，该值将具有指定的字节数。
 void ResultSet.updateCharacterStream(String columnLabel, Reader reader)
          用字符流值更新指定列。
 void ResultSet.updateCharacterStream(String columnLabel, Reader reader, int length)
          用字符流值更新指定列，该列具有指定的字节数。
 void ResultSet.updateCharacterStream(String columnLabel, Reader reader, long length)
          用字符流值更新指定的列，该值将具有指定的字节数。
 void ResultSet.updateClob(int columnIndex, Clob x)
          用 java.sql.Clob 值更新指定列。
 void ResultSet.updateClob(int columnIndex, Reader reader)
          使用给定的 Reader 对象更新指定列。
 void ResultSet.updateClob(int columnIndex, Reader reader, long length)
          使用给定的 Reader 对象更新指定列，该对象是给定的字符长度数目。
 void ResultSet.updateClob(String columnLabel, Clob x)
          用 java.sql.Clob 值更新指定列。
 void ResultSet.updateClob(String columnLabel, Reader reader)
          使用给定的 Reader 对象更新指定列。
 void ResultSet.updateClob(String columnLabel, Reader reader, long length)
          使用给定的 Reader 对象更新指定列，该对象是给定的字符长度数目。
 void ResultSet.updateDate(int columnIndex, Date x)
          用 java.sql.Date 值更新指定列。
 void ResultSet.updateDate(String columnLabel, Date x)
          用 java.sql.Date 值更新指定列。
 void ResultSet.updateDouble(int columnIndex, double x)
          用 double 值更新指定列。
 void ResultSet.updateDouble(String columnLabel, double x)
          用 double 值更新指定列。
 void ResultSet.updateFloat(int columnIndex, float x)
          用 float 值更新指定列。
 void ResultSet.updateFloat(String columnLabel, float x)
          用 float 值更新指定列。
 void ResultSet.updateInt(int columnIndex, int x)
          用 int 值更新指定列。
 void ResultSet.updateInt(String columnLabel, int x)
          用 int 值更新指定列。
 void ResultSet.updateLong(int columnIndex, long x)
          用 long 值更新指定列。
 void ResultSet.updateLong(String columnLabel, long x)
          用 long 值更新指定列。
 void ResultSet.updateNCharacterStream(int columnIndex, Reader x)
          用字符流值更新指定的列。
 void ResultSet.updateNCharacterStream(int columnIndex, Reader x, long length)
          用字符流值更新指定的列，该值将具有指定的字节数。
 void ResultSet.updateNCharacterStream(String columnLabel, Reader reader)
          用字符流值更新指定的列。
 void ResultSet.updateNCharacterStream(String columnLabel, Reader reader, long length)
          用字符流值更新指定的列，该值将具有指定的字节数。
 void ResultSet.updateNClob(int columnIndex, NClob nClob)
          用 java.sql.NClob 值更新指定的列。
 void ResultSet.updateNClob(int columnIndex, Reader reader)
          使用给定的 Reader 对象更新指定列。
 void ResultSet.updateNClob(int columnIndex, Reader reader, long length)
          使用给定的 Reader 对象更新指定的列，该对象是给定的字符长度数目。
 void ResultSet.updateNClob(String columnLabel, NClob nClob)
          用 java.sql.NClob 值更新指定的列。
 void ResultSet.updateNClob(String columnLabel, Reader reader)
          使用给定的 Reader 对象更新指定列。
 void ResultSet.updateNClob(String columnLabel, Reader reader, long length)
          使用给定的 Reader 对象更新指定的列，该对象是给定的字符长度数目。
 void ResultSet.updateNString(int columnIndex, String nString)
          用 String 值更新指定的列。
 void ResultSet.updateNString(String columnLabel, String nString)
          用 String 值更新指定的列。
 void ResultSet.updateNull(int columnIndex)
          用 null 值更新指定列。
 void ResultSet.updateNull(String columnLabel)
          用 null 值更新指定列。
 void ResultSet.updateObject(int columnIndex, Object x)
          用 Object 值更新指定列。
 void ResultSet.updateObject(int columnIndex, Object x, int scaleOrLength)
          用 Object 值更新指定列。
 void ResultSet.updateObject(String columnLabel, Object x)
          用 Object 值更新指定列。
 void ResultSet.updateObject(String columnLabel, Object x, int scaleOrLength)
          用 Object 值更新指定列。
 void ResultSet.updateRef(int columnIndex, Ref x)
          用 java.sql.Ref 值更新指定列。
 void ResultSet.updateRef(String columnLabel, Ref x)
          用 java.sql.Ref 值更新指定列。
 void ResultSet.updateRow()
          用此 ResultSet 对象的当前行的新内容更新底层数据库。
 void ResultSet.updateRowId(int columnIndex, RowId x)
          用 RowId 值更新指定列。
 void ResultSet.updateRowId(String columnLabel, RowId x)
          用 RowId 值更新指定的列。
 boolean DatabaseMetaData.updatesAreDetected(int type)
          获取是否可以通过调用 ResultSet.rowUpdated 方法检测可见行的更新。
 void ResultSet.updateShort(int columnIndex, short x)
          用 short 值更新指定列。
 void ResultSet.updateShort(String columnLabel, short x)
          用 short 值更新指定列。
 void ResultSet.updateSQLXML(int columnIndex, SQLXML xmlObject)
          用 java.sql.SQLXML 值更新指定列。
 void ResultSet.updateSQLXML(String columnLabel, SQLXML xmlObject)
          用 java.sql.SQLXML 值更新指定的列。
 void ResultSet.updateString(int columnIndex, String x)
          用 String 值更新指定列。
 void ResultSet.updateString(String columnLabel, String x)
          用 String 值更新指定列。
 void ResultSet.updateTime(int columnIndex, Time x)
          用 java.sql.Time 值更新指定列。
 void ResultSet.updateTime(String columnLabel, Time x)
          用 java.sql.Time 值更新指定列。
 void ResultSet.updateTimestamp(int columnIndex, Timestamp x)
          用 java.sql.Timestamp 值更新指定列。
 void ResultSet.updateTimestamp(String columnLabel, Timestamp x)
          用 java.sql.Timestamp 值更新指定列。
 boolean DatabaseMetaData.usesLocalFilePerTable()
          获取此数据库是否为每个表使用一个文件。
 boolean DatabaseMetaData.usesLocalFiles()
          获取此数据库是否将表存储在本地文件中。
 boolean CallableStatement.wasNull()
          查询最后一个读取的 OUT 参数是否为 SQL NULL。
 boolean ResultSet.wasNull()
          报告最后一个读取的列是否具有值 SQL NULL。
 boolean SQLInput.wasNull()
          获取最后一个读取的值是否为 SQL NULL。
 void SQLOutput.writeArray(Array x)
          将 SQL ARRAY 值写入流中。
 void SQLOutput.writeAsciiStream(InputStream x)
          将下一个属性作为 ASCII 字符流写入流中。
 void SQLOutput.writeBigDecimal(BigDecimal x)
          将下一个属性作为 java.math.BigDecimal 对象写入流中。
 void SQLOutput.writeBinaryStream(InputStream x)
          将下一个属性作为未解释字节流写入流中。
 void SQLOutput.writeBlob(Blob x)
          将 SQL BLOB 值写入流中。
 void SQLOutput.writeBoolean(boolean x)
          将下一个属性作为 Java boolean 值写入流。
 void SQLOutput.writeByte(byte x)
          将下一个属性作为 Java byte 值写入流中。
 void SQLOutput.writeBytes(byte[] x)
          将下一个属性作为字节数组写入流中。
 void SQLOutput.writeCharacterStream(Reader x)
          将下一个属性作为 Unicode 字符的流写入流中。
 void SQLOutput.writeClob(Clob x)
          将 SQL CLOB 值写入流中。
 void SQLOutput.writeDate(Date x)
          将下一个属性作为 java.sql.Date 对象写入流中。
 void SQLOutput.writeDouble(double x)
          将下一个属性作为 Java double 值写入流中。
 void SQLOutput.writeFloat(float x)
          将下一个属性作为 Java float 值写入流中。
 void SQLOutput.writeInt(int x)
          将下一个属性作为 Java int 值写入流中。
 void SQLOutput.writeLong(long x)
          将下一个属性作为 Java long 值写入流中。
 void SQLOutput.writeNClob(NClob x)
          将 SQL NCLOB 值写入流中。
 void SQLOutput.writeNString(String x)
          将下一个属性以 Java 编程语言中 String 的形式写入流中。
 void SQLOutput.writeObject(SQLData x)
          将给定 SQLData 对象中包含的数据写入流中。
 void SQLOutput.writeRef(Ref x)
          将 SQL REF 值写入流中。
 void SQLOutput.writeRowId(RowId x)
          将 SQL ROWID 值写入流中。
 void SQLOutput.writeShort(short x)
          将下一个属性作为 Java short 值写入流中。
 void SQLData.writeSQL(SQLOutput stream)
          将此对象写入给定的 SQL 数据流，同时将其转换回数据源中它的 SQL 值。
 void SQLOutput.writeSQLXML(SQLXML x)
          将 SQL XML 值写入流中。
 void SQLOutput.writeString(String x)
          将下一个属性作为 Java 编程语言中的 String 写入流中。
 void SQLOutput.writeStruct(Struct x)
          将 SQL 结构类型值写入流中。
 void SQLOutput.writeTime(Time x)
          将下一个属性作为 java.sql.Time 对象写入流中。
 void SQLOutput.writeTimestamp(Timestamp x)
          将下一个属性作为 java.sql.Timestamp 对象写入流中。
 void SQLOutput.writeURL(URL x)
          将 SQL DATALINK 值写入流中。
 

javax.sql 中 SQLException 的使用
 

返回 SQLException 的 javax.sql 中的方法
 SQLException ConnectionEvent.getSQLException()
          获取此 ConnectionEvent 对象的 SQLException。
 SQLException StatementEvent.getSQLException()
          返回驱动程序将要抛出的 SQLException。
 

抛出 SQLException 的 javax.sql 中的方法
 void RowSet.clearParameters()
          清除为此 RowSet 对象命令设置的参数。
 void PooledConnection.close()
          关闭此 PooledConnection 对象表示的物理连接。
 void RowSet.execute()
          使用数据填充此 RowSet 对象。
 Connection DataSource.getConnection()
          尝试建立与此 DataSource 对象所表示的数据源的连接。
 Connection PooledConnection.getConnection()
          创建并返回一个 Connection 对象，它是此 PooledConnection 对象表示的物理连接的句柄。
 Connection RowSetInternal.getConnection()
          获取传递给此 RowSet 对象的 Connection 对象。
 Connection DataSource.getConnection(String username, String password)
          尝试建立与此 DataSource 对象所表示的数据源的连接。
 boolean RowSet.getEscapeProcessing()
          获取是否为此 RowSet 对象启用转义处理。
 int CommonDataSource.getLoginTimeout()
          获取此数据源试图连接到某一数据库时可以等待的最长时间，以秒为单位。
 PrintWriter CommonDataSource.getLogWriter()
          获取此 DataSource 对象的日志 writer。
 int RowSet.getMaxFieldSize()
          获取可以对某些列值返回的最大字节数。
 int RowSet.getMaxRows()
          获取此 RowSet 对象可以包含的最大行数。
 ResultSet RowSetInternal.getOriginal()
          获取包含此 RowSet 对象原始值的 ResultSet 对象。
 ResultSet RowSetInternal.getOriginalRow()
          获取仅包含当前行原始值的 ResultSet 对象。
 Object[] RowSetInternal.getParams()
          获取已为此 RowSet 对象的命令设置的参数。
 PooledConnection ConnectionPoolDataSource.getPooledConnection()
          尝试建立可用作入池连接的物理数据库连接。
 PooledConnection ConnectionPoolDataSource.getPooledConnection(String user, String password)
          尝试建立可用作入池连接的物理数据库连接。
 int RowSet.getQueryTimeout()
          获取驱动程序等待语句执行的最大秒数。
 Map<String,Class<?>> RowSet.getTypeMap()
          获取与此 RowSet 对象关联的 Map 对象，该对象指定 SQL 用户定义类型的自定义映射关系（如果有）。
 String RowSet.getUrl()
          如果此 RowSet 对象使用 DriverManager 而非 DataSource 对象建立连接，则获取创建连接时将使用的 url 属性。
 XAConnection XADataSource.getXAConnection()
          尝试建立可在分布式事务中使用的物理数据库连接。
 XAConnection XADataSource.getXAConnection(String user, String password)
          使用给定的用户名和密码，尝试建立一个物理数据库连接。
 XAResource XAConnection.getXAResource()
          获取 XAResource 对象，事务管理器将使用该对象管理此 XAConnection 对象如何参与到分布式事务中。
 void RowSetReader.readData(RowSetInternal caller)
          读取调用 RowSet 对象的新内容。
 void RowSet.setArray(int i, Array x)
          使用给定 Array 值设置此 RowSet 对象命令中的指定参数。
 void RowSet.setAsciiStream(int parameterIndex, InputStream x)
          将此 RowSet 对象命令中的指定参数设置为给定输入流。
 void RowSet.setAsciiStream(int parameterIndex, InputStream x, int length)
          将此 RowSet 对象命令中的指定参数设置为给定的 java.io.InputStream 值。
 void RowSet.setAsciiStream(String parameterName, InputStream x)
          将指定参数设置为给定输入流。
 void RowSet.setAsciiStream(String parameterName, InputStream x, int length)
          将指定参数设置为给定输入流，该输入流将拥有指定字节数。
 void RowSetMetaData.setAutoIncrement(int columnIndex, boolean property)
          设置是否为指定列自动编号。
 void RowSet.setBigDecimal(int parameterIndex, BigDecimal x)
          将此 RowSet 对象命令中的指定参数设置为给定的 java.math.BigDeciaml 值。
 void RowSet.setBigDecimal(String parameterName, BigDecimal x)
          将指定参数设置为给定的 java.math.BigDecimal 值。
 void RowSet.setBinaryStream(int parameterIndex, InputStream x)
          将此 RowSet 对象命令中的指定参数设置为给定输入流。
 void RowSet.setBinaryStream(int parameterIndex, InputStream x, int length)
          将此 RowSet 对象命令中的指定参数设置为给定的 java.io.InputStream 值。
 void RowSet.setBinaryStream(String parameterName, InputStream x)
          将指定参数设置为给定输入流。
 void RowSet.setBinaryStream(String parameterName, InputStream x, int length)
          将指定参数设置为给定输入流，该输入流将拥有给定字节数。
 void RowSet.setBlob(int i, Blob x)
          使用给定 Blob 值设置此 RowSet 对象命令中的指定参数。
 void RowSet.setBlob(int parameterIndex, InputStream inputStream)
          将指定参数设置为 InputStream 对象。
 void RowSet.setBlob(int parameterIndex, InputStream inputStream, long length)
          将指定参数设置为 InputStream 对象。
 void RowSet.setBlob(String parameterName, Blob x)
          将指定参数设置为给定的 java.sql.Blob 对象。
 void RowSet.setBlob(String parameterName, InputStream inputStream)
          将指定参数设置为 InputStream 对象。
 void RowSet.setBlob(String parameterName, InputStream inputStream, long length)
          将指定参数设置为 InputStream 对象。
 void RowSet.setBoolean(int parameterIndex, boolean x)
          将此 RowSet 对象命令中的指定参数设置为给定的 Java boolean 值。
 void RowSet.setBoolean(String parameterName, boolean x)
          将指定参数设置为给定的 Java boolean 值。
 void RowSet.setByte(int parameterIndex, byte x)
          将此 RowSet 对象命令中的指定参数设置为给定的 Java byte 值。
 void RowSet.setByte(String parameterName, byte x)
          将指定参数设置为给定的 Java byte 值。
 void RowSet.setBytes(int parameterIndex, byte[] x)
          将此 RowSet 对象命令中的指定参数设置为给定的 Java byte 值数组。
 void RowSet.setBytes(String parameterName, byte[] x)
          将指定参数设置为给定的 Java byte 数组。
 void RowSetMetaData.setCaseSensitive(int columnIndex, boolean property)
          设置指定列是否区分大小写。
 void RowSetMetaData.setCatalogName(int columnIndex, String catalogName)
          将指定列的表的类别名称（如果有）设置为给定的 String。
 void RowSet.setCharacterStream(int parameterIndex, Reader reader)
          将此 RowSet 对象命令中的指定参数设置为给定 Reader 对象。
 void RowSet.setCharacterStream(int parameterIndex, Reader reader, int length)
          将此 RowSet 对象命令中的指定参数设置为给定的 java.io.Reader 值。
 void RowSet.setCharacterStream(String parameterName, Reader reader)
          将指定参数设置为给定 Reader 对象。
 void RowSet.setCharacterStream(String parameterName, Reader reader, int length)
          将指定参数设置为给定 Reader 对象，该对象是给定的字符长度数目。
 void RowSet.setClob(int i, Clob x)
          使用给定 Clob 值设置此 RowSet 对象命令中的指定参数。
 void RowSet.setClob(int parameterIndex, Reader reader)
          将指定参数设置为 Reader 对象。
 void RowSet.setClob(int parameterIndex, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void RowSet.setClob(String parameterName, Clob x)
          将指定参数设置为给定的 java.sql.Clob 对象。
 void RowSet.setClob(String parameterName, Reader reader)
          将指定参数设置为 Reader 对象。
 void RowSet.setClob(String parameterName, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void RowSetMetaData.setColumnCount(int columnCount)
          将 RowSet 对象中的列数设置为给定数。
 void RowSetMetaData.setColumnDisplaySize(int columnIndex, int size)
          将指定列的正常最大宽度（以 char 表示）设置为给定的 int。
 void RowSetMetaData.setColumnLabel(int columnIndex, String label)
          将建议用于打印输出和显示的列标题（如果有）设置为给定的 String。
 void RowSetMetaData.setColumnName(int columnIndex, String columnName)
          将指定列的名称设置为给定的 String。
 void RowSetMetaData.setColumnType(int columnIndex, int SQLType)
          将指定列的 SQL 类型设置为给定的类型。
 void RowSetMetaData.setColumnTypeName(int columnIndex, String typeName)
          将指定列的特定于数据源的类型名称（如果有）设置为给定的 String。
 void RowSet.setCommand(String cmd)
          将此 RowSet 对象的命令属性设置为给定的 SQL 查询。
 void RowSet.setConcurrency(int concurrency)
          将此 RowSet 对象的并发性设置为给定的并发级别。
 void RowSetMetaData.setCurrency(int columnIndex, boolean property)
          设置指定的列是否是现金值。
 void RowSet.setDataSourceName(String name)
          将此 RowSet 对象的数据源名称属性设置为给定的 String。
 void RowSet.setDate(int parameterIndex, Date x)
          将此 RowSet 对象命令中的指定参数设置为给定的 java.sql.Date 值。
 void RowSet.setDate(int parameterIndex, Date x, Calendar cal)
          使用给定 java.sql.Date 值设置此 RowSet 对象命令中的指定参数。
 void RowSet.setDate(String parameterName, Date x)
          使用运行应用程序的虚拟机所在的默认时区将指定参数设置为给定的 java.sql.Date 值。
 void RowSet.setDate(String parameterName, Date x, Calendar cal)
          使用给定 Calendar 对象将指定参数设置为给定的 java.sql.Date 值。
 void RowSet.setDouble(int parameterIndex, double x)
          将此 RowSet 对象命令中的指定参数设置为给定的 Java double 值。
 void RowSet.setDouble(String parameterName, double x)
          将指定参数设置为给定的 Java double 值。
 void RowSet.setEscapeProcessing(boolean enable)
          将此 RowSet 对象的转义处理设置为开或关。
 void RowSet.setFloat(int parameterIndex, float x)
          将此 RowSet 对象命令中的指定参数设置为给定的 Java float 值。
 void RowSet.setFloat(String parameterName, float x)
          将指定参数设置为给定的 Java float 值。
 void RowSet.setInt(int parameterIndex, int x)
          将此 RowSet 对象命令中的指定参数设置为给定的 Java int 值。
 void RowSet.setInt(String parameterName, int x)
          将指定参数设置为给定的 Java int 值。
 void CommonDataSource.setLoginTimeout(int seconds)
          设置此数据源试图连接到某一数据库时将等待的最长时间，以秒为单位。
 void CommonDataSource.setLogWriter(PrintWriter out)
          将此 DataSource 对象的日志 writer 设置为给定的 java.io.PrintWriter 对象。
 void RowSet.setLong(int parameterIndex, long x)
          将此 RowSet 对象命令中的指定参数设置为给定的 Java long 值。
 void RowSet.setLong(String parameterName, long x)
          将指定参数设置为给定的 Java long 值。
 void RowSet.setMaxFieldSize(int max)
          将可以对列值返回的最大字节数设置为给定的字节数。
 void RowSet.setMaxRows(int max)
          将此 RowSet 对象可以包含的最大行数设置为指定数。
 void RowSetInternal.setMetaData(RowSetMetaData md)
          将给定的 RowSetMetaData 对象设置为此 RowSet 对象的 RowSetMetaData 对象。
 void RowSet.setNCharacterStream(int parameterIndex, Reader value)
          将此 RowSet 对象命令中的指定参数设置为 Reader 对象。
 void RowSet.setNCharacterStream(int parameterIndex, Reader value, long length)
          将指定参数设置为 Reader 对象。
 void RowSet.setNCharacterStream(String parameterName, Reader value)
          将指定参数设置为 Reader 对象。
 void RowSet.setNCharacterStream(String parameterName, Reader value, long length)
          将指定参数设置为 Reader 对象。
 void RowSet.setNClob(int parameterIndex, NClob value)
          将指定参数设置为 java.sql.NClob 对象。
 void RowSet.setNClob(int parameterIndex, Reader reader)
          将指定参数设置为 Reader 对象。
 void RowSet.setNClob(int parameterIndex, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void RowSet.setNClob(String parameterName, NClob value)
          将指定参数设置为 java.sql.NClob 对象。
 void RowSet.setNClob(String parameterName, Reader reader)
          将指定参数设置为 Reader 对象。
 void RowSet.setNClob(String parameterName, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void RowSet.setNString(int parameterIndex, String value)
          将指定参数设置为给定的 String 对象。
 void RowSet.setNString(String parameterName, String value)
          将指定参数设置为给定的 String 对象。
 void RowSet.setNull(int parameterIndex, int sqlType)
          将此 RowSet 对象的 SQL 命令中的指定参数设置为 SQL NULL。
 void RowSet.setNull(int paramIndex, int sqlType, String typeName)
          将此 RowSet 对象的 SQL 命令中的指定参数设置为 SQL NULL。
 void RowSet.setNull(String parameterName, int sqlType)
          将指定参数设置为 SQL NULL。
 void RowSet.setNull(String parameterName, int sqlType, String typeName)
          将指定参数设置为 SQL NULL。
 void RowSetMetaData.setNullable(int columnIndex, int property)
          设置是否可以将指定列的值设置为 NULL。
 void RowSet.setObject(int parameterIndex, Object x)
          使用 Java Object 设置此 RowSet 对象命令中的指定参数。
 void RowSet.setObject(int parameterIndex, Object x, int targetSqlType)
          使用 Java Object 设置此 RowSet 对象命令中的指定参数。
 void RowSet.setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength)
          使用给定 Java Object 设置此 RowSet 对象命令中的指定参数。
 void RowSet.setObject(String parameterName, Object x)
          使用给定对象设置指定参数的值。
 void RowSet.setObject(String parameterName, Object x, int targetSqlType)
          使用给定对象设置指定参数的值。
 void RowSet.setObject(String parameterName, Object x, int targetSqlType, int scale)
          使用给定对象设置指定参数的值。
 void RowSet.setPassword(String password)
          将此 RowSet 对象的数据库密码设置为给定的 String。
 void RowSetMetaData.setPrecision(int columnIndex, int precision)
          将指定列的小数位数设置为给定的 int。
 void RowSet.setQueryTimeout(int seconds)
          将驱动程序等待语句执行的最大秒数设置为给定的秒数。
 void RowSet.setReadOnly(boolean value)
          将此 RowSet 对象的只读性设置为给定的 boolean 值。
 void RowSet.setRef(int i, Ref x)
          使用给定 Ref 值设置此 RowSet 对象命令中的指定参数。
 void RowSet.setRowId(int parameterIndex, RowId x)
          将指定参数设置为给定的 java.sql.RowId 对象。
 void RowSet.setRowId(String parameterName, RowId x)
          将指定参数设置为给定的 java.sql.RowId 对象。
 void RowSetMetaData.setScale(int columnIndex, int scale)
          将指定列的小数点右边的位数设置为给定的 int。
 void RowSetMetaData.setSchemaName(int columnIndex, String schemaName)
          将指定列的表模式的名称（如果有）设置为给定的 String。
 void RowSetMetaData.setSearchable(int columnIndex, boolean property)
          设置是否可以在 where 子句中使用指定的列。
 void RowSet.setShort(int parameterIndex, short x)
          将此 RowSet 对象命令中的指定参数设置为给定的 Java short 值。
 void RowSet.setShort(String parameterName, short x)
          将指定参数设置为给定的 Java short 值。
 void RowSetMetaData.setSigned(int columnIndex, boolean property)
          设置指定列是否是有符号数字。
 void RowSet.setSQLXML(int parameterIndex, SQLXML xmlObject)
          将指定参数设置为给定 java.sql.SQLXML 对象。
 void RowSet.setSQLXML(String parameterName, SQLXML xmlObject)
          将指定参数设置为给定的 java.sql.SQLXML 对象。
 void RowSet.setString(int parameterIndex, String x)
          将此 RowSet 对象命令中的指定参数设置为给定的 Java String 值。
 void RowSet.setString(String parameterName, String x)
          将指定参数设置为给定的 Java String 值。
 void RowSetMetaData.setTableName(int columnIndex, String tableName)
          将指定列的表名称（如果有）设置为给定的 String。
 void RowSet.setTime(int parameterIndex, Time x)
          将此 RowSet 对象命令中的指定参数设置为给定的 java.sql.Time 值。
 void RowSet.setTime(int parameterIndex, Time x, Calendar cal)
          使用给定 java.sql.Time 值设置此 RowSet 对象命令中的指定参数。
 void RowSet.setTime(String parameterName, Time x)
          将指定参数设置为给定的 java.sql.Time 值。
 void RowSet.setTime(String parameterName, Time x, Calendar cal)
          使用给定 Calendar 对象将指定参数设置为给定的 java.sql.Time 值。
 void RowSet.setTimestamp(int parameterIndex, Timestamp x)
          将此 RowSet 对象命令中的指定参数设置为给定的 java.sql.Timestamp 值。
 void RowSet.setTimestamp(int parameterIndex, Timestamp x, Calendar cal)
          使用给定 java.sql.Timestamp 值设置此 RowSet 对象命令中的指定参数。
 void RowSet.setTimestamp(String parameterName, Timestamp x)
          将指定参数设置为给定的 java.sql.Timestamp 值。
 void RowSet.setTimestamp(String parameterName, Timestamp x, Calendar cal)
          使用给定 Calendar 对象将指定参数设置为给定的 java.sql.Timestamp 值。
 void RowSet.setTransactionIsolation(int level)
          设置此 RowSet 对象的事务隔离级别。
 void RowSet.setType(int type)
          将此 RowSet 对象的类型设置为给定的类型。
 void RowSet.setTypeMap(Map<String,Class<?>> map)
          将给定 java.util.Map 对象安装为此 RowSet 对象的默认类型映射表。
 void RowSet.setURL(int parameterIndex, URL x)
          将指定参数设置为给定的 java.net.URL 值。
 void RowSet.setUrl(String url)
          设置此 RowSet 对象在使用 DriverManager 创建连接时将使用的 URL。
 void RowSet.setUsername(String name)
          将此 RowSet 对象的用户名属性设置为给定的 String。
 boolean RowSetWriter.writeData(RowSetInternal caller)
          将此 RowSetWriter 对象的 rowset 中的更改写回它从中获取数据的数据源。
 

参数类型为 SQLException 的 javax.sql 中的构造方法
ConnectionEvent(PooledConnection con, SQLException ex)
          构造一个 ConnectionEvent 对象，使用给定的 PooledConnection 对象和 SQLException 对象进行初始化。
StatementEvent(PooledConnection con, PreparedStatement statement, SQLException exception)
          用指定的 PooledConnection、PreparedStatement 和 SQLException 构造 StatementEvent。
 

javax.sql.rowset 中 SQLException 的使用
 

javax.sql.rowset 中 SQLException 的子类
 class RowSetWarning
          SQLException 的一个扩展，提供关于在 RowSet 对象上设置的数据库警告的信息。
 

抛出 SQLException 的 javax.sql.rowset 中的方法
 void JoinRowSet.addRowSet(Joinable rowset)
          将给定的 RowSet 对象添加到此 JoinRowSet 对象。
 void JoinRowSet.addRowSet(RowSet[] rowset, int[] columnIdx)
          将给定 RowSet 对象数组中包含的一个或多个 RowSet 对象添加到此 JoinRowSet 对象，并且将每个 RowSet 对象的匹配列设置为给定列索引数组中的匹配列。
 void JoinRowSet.addRowSet(RowSet[] rowset, String[] columnName)
          将给定 RowSet 对象数组中包含的一个或多个 RowSet 对象添加到此 JoinRowSet 对象，并且将每个 RowSet 对象的匹配列设置为给定列名数组中的匹配列。
 void JoinRowSet.addRowSet(RowSet rowset, int columnIdx)
          将给定的 RowSet 对象添加到此 JoinRowSet 对象，并将指定的列设置为 RowSet 对象的匹配列。
 void JoinRowSet.addRowSet(RowSet rowset, String columnName)
          将 rowset 添加到此 JoinRowSet 对象，并将指定的列设置为匹配列。
 void BaseRowSet.clearParameters()
          清除所有此 RowSet 对象的内部参数表示形式的当前参数值，这些参数值将在执行此 RowSet 对象的命令时在其中设置这些参数。
 boolean CachedRowSet.columnUpdated(int idx)
          指示此 CachedRowSet 对象当前行中的指定列是否已更新。
 boolean CachedRowSet.columnUpdated(String columnName)
          指示此 CachedRowSet 对象当前行中的指定列是否已更新。
 void CachedRowSet.commit()
          每个 CachedRowSet 对象的 SyncProvider 都包含一个取自 ResultSet 的 Connection 对象或传递到其构造方法的 JDBC 属性。
 void JdbcRowSet.commit()
          每个 JdbcRowSet 都包含一个取自 ResultSet 的 Connection 对象或传递到其构造方法的 JDBC 属性。
 CachedRowSet CachedRowSet.createCopy()
          创建一个 RowSet 对象，它是此 CachedRowSet 对象中数据的深层副本。
 CachedRowSet CachedRowSet.createCopyNoConstraints()
          创建一个 CachedRowSet 对象，它是此 CachedRowSet 对象数据的深层副本，但是独立于此 CachedRowSet 对象。
 CachedRowSet CachedRowSet.createCopySchema()
          创建一个 CachedRowSet 对象，它是此 CachedRowSet 对象的空副本。
 RowSet CachedRowSet.createShared()
          返回一个新的 RowSet 对象，支持该对象的数据与此 CachedRowSet 对象的相同。
 boolean Predicate.evaluate(Object value, int column)
          FilteredRowSet 对象调用此方法来检查值是否位于使用 setFilter() 方法设置的过滤标准（或标准，如果存在多个约束）中。
 boolean Predicate.evaluate(Object value, String columnName)
          FilteredRowSet 对象调用此方法来检查值是否位于使用 setFilter 方法设置的过滤标准中。
 void CachedRowSet.execute(Connection conn)
          用数据填充此 CachedRowSet 对象，使用给定的连接来生成从中读取数据的结果集。
 boolean JdbcRowSet.getAutoCommit()
          每个 JdbcRowSet 都包含一个取自原始 ResultSet 的 Connection 对象或传递给它的 JDBC 属性。
 String RowSetMetaDataImpl.getCatalogName(int columnIndex)
          获取派生指定列中值的表的类别名称。
 String RowSetMetaDataImpl.getColumnClassName(int columnIndex)
          获取 Java 编程语言中一个类的完全限定名，该类是指定列中的值将映射到的那个类。
 int RowSetMetaDataImpl.getColumnCount()
          获取为其创建此 RowSetMetaDataImpl 对象的 RowSet 对象中的列数。
 int RowSetMetaDataImpl.getColumnDisplaySize(int columnIndex)
          获取以 char 为单位的指定列的正常最大宽度。
 String RowSetMetaDataImpl.getColumnLabel(int columnIndex)
          获取用于打印输出和显示的指定列的建议列标题。
 String RowSetMetaDataImpl.getColumnName(int columnIndex)
          获取指定列的名称。
 int RowSetMetaDataImpl.getColumnType(int columnIndex)
          获取存储在指定行中值的 SQL 类型的类型代码（java.sql.Types 常量之一）。
 String RowSetMetaDataImpl.getColumnTypeName(int columnIndex)
          获取存储在指定列中值的特定于 DBMS 的类型名称。
 int BaseRowSet.getConcurrency()
          返回此 RowSet 对象的并发性。
 boolean BaseRowSet.getEscapeProcessing()
          确定是否为此 RowSet 对象启用了转义处理。
 int BaseRowSet.getFetchDirection()
          获取此 RowSet 对象的当前有关获取方向的设置。
 int BaseRowSet.getFetchSize()
          返回此 RowSet 对象的获取大小。
 int JoinRowSet.getJoinType()
          返回一个 int 值，它描述控制此 JoinRowSet 实例的已设置 SQL JOIN 类型。
 int[] CachedRowSet.getKeyColumns()
          返回一个包含一个或多个列号的数组，这些列号指示了形成某个键的列，该键唯一地标识了此 CachedRowSet 对象中的某个行。
 int[] Joinable.getMatchColumnIndexes()
          获取使用方法 setMatchColumn(int[] columnIdxes) 为此 RowSet 对象设置的匹配列的索引。
 String[] Joinable.getMatchColumnNames()
          获取使用方法 setMatchColumn(String [] columnNames) 为此 RowSet 对象设置的匹配列的名称。
 int BaseRowSet.getMaxFieldSize()
          获取可用于此 RowSet 对象列值的最大字节数。
 int BaseRowSet.getMaxRows()
          获取此 RowSet 对象可以包含的最大行数。
 ResultSet CachedRowSet.getOriginal()
          返回一个包含此 CachedRowSet 对象原始值的 ResultSet 对象。
 ResultSet CachedRowSet.getOriginalRow()
          返回一个只包含此 CachedRowSet 对象当前行原始值的 ResultSet 对象。
 Object[] BaseRowSet.getParams()
          获取一个数组，其中包含为此 RowSet 对象命令设置的参数值（包括 Object 和基本类型），如果尚未设置任何参数，则抛出 SQLException 对象。
 int RowSetMetaDataImpl.getPrecision(int columnIndex)
          获取存储在指定列中的值的数字总数。
 int BaseRowSet.getQueryTimeout()
          获取驱动程序等待查询执行的最大秒数。
 String[] JoinRowSet.getRowSetNames()
          返回一个 String 数组，包含添加到此 JoinRowSet 对象的 RowSet 对象的名称。
 Collection<?> JoinRowSet.getRowSets()
          返回一个 Collection 对象，包含已经添加到此 JoinRowSet 对象的 RowSet 对象。
 RowSetWarning CachedRowSet.getRowSetWarnings()
          获取此 RowSet 对象上的调用报告的第一个警告。
 RowSetWarning JdbcRowSet.getRowSetWarnings()
          获取此 JdbcRowSet 对象上的调用报告的第一个警告。
 int RowSetMetaDataImpl.getScale(int columnIndex)
          获取存储在指定列中的值的小数点右边的数字数。
 String RowSetMetaDataImpl.getSchemaName(int columnIndex)
          获取派生指定列中值的表的模式名称。
 boolean BaseRowSet.getShowDeleted()
          获取一个 boolean 值，该值指示标记为删除的行是否会出现在当前行集合中。
 boolean CachedRowSet.getShowDeleted()
          获取一个 boolean 值，该值指示标记为删除的行是否会出现在当前行集合中。
 boolean JdbcRowSet.getShowDeleted()
          获取一个 boolean 值，该值指示标记为删除的行是否会出现在当前行集合中。
 SyncProvider CachedRowSet.getSyncProvider()
          获取此 CachedRowSet 对象的 SyncProvider 实现。
 String CachedRowSet.getTableName()
          返回创建此 CachedRowSet 对象时所用对象（表）的标识符。
 String RowSetMetaDataImpl.getTableName(int columnIndex)
          获取派生指定列中值的表名称。
 int BaseRowSet.getType()
          返回此 RowSet 对象的类型。
 String BaseRowSet.getUrl()
          获取此 RowSet 对象的 javax.sql.Reader 对象用来建立与关系数据库连接（使用启用 JDBC 技术的驱动程序）的 JDBC URL。
 String JoinRowSet.getWhereClause()
          返回在 JoinRowSet 对象中使用的 WHERE 子句的类似 SQL 的描述。
 boolean RowSetMetaDataImpl.isAutoIncrement(int columnIndex)
          获取存储在指定列中的值是否自动编号，因而是只读的。
 boolean RowSetMetaDataImpl.isCaseSensitive(int columnIndex)
          指示指定列的名称是否区分大小写。
 boolean RowSetMetaDataImpl.isCurrency(int columnIndex)
          指示存储在指定列中的值是否为缓存值。
 boolean RowSetMetaDataImpl.isDefinitelyWritable(int columnIndex)
          指示在指定的列上进行写操作是否一定可以获得成功。
 int RowSetMetaDataImpl.isNullable(int columnIndex)
          获取指示是否可以在指定列中存储 NULL 值的常量。
 boolean RowSetMetaDataImpl.isReadOnly(int columnIndex)
          指示指定的列是否一定不可写入，即只读。
 boolean RowSetMetaDataImpl.isSearchable(int columnIndex)
          指示是否可以在 WHERE 子句中使用存储在指定列中的值。
 boolean RowSetMetaDataImpl.isSigned(int columnIndex)
          指示存储在指定列中的值是否为有符号数。
 boolean RowSetMetaDataImpl.isWrapperFor(Class<?> interfaces)
          如果调用者实现接口参数或者是实现接口参数的对象的直接或间接包装器，则返回 true。
 boolean RowSetMetaDataImpl.isWritable(int columnIndex)
          指示在指定的列上进行写操作是否可以获得成功。
 boolean CachedRowSet.nextPage()
          逐个增加 CachedRowSet 的当前页。
protected  void BaseRowSet.notifyCursorMoved()
          通知向此 RowSet 对象注册的所有侦听器其光标已移动。
protected  void BaseRowSet.notifyRowChanged()
          通知向此 RowSet 对象注册的所有侦听器其行已更改。
protected  void BaseRowSet.notifyRowSetChanged()
          通知向此 RowSet 对象注册的所有侦听器其整个内容已更改。
 void CachedRowSet.populate(ResultSet data)
          使用取自给定 ResultSet 对象的数据填充此 CachedRowSet 对象。
 void CachedRowSet.populate(ResultSet rs, int startRow)
          使用取自给定 ResultSet 对象的数据填充此 CachedRowSet 对象。
 boolean CachedRowSet.previousPage()
          逐个减少 CachedRowSet 的当前页。
 void WebRowSet.readXml(InputStream iStream)
          读取基于流的 XML 输入，以填充此 WebRowSet 对象。
 void WebRowSet.readXml(Reader reader)
          从给定的 Reader 对象以其 XML 格式读取 WebRowSet 对象。
 void CachedRowSet.release()
          释放此 CachedRowSet 对象的当前内容并将 rowSetChanged 事件发送到所有已注册侦听器。
 void CachedRowSet.restoreOriginal()
          将此 CachedRowSet 对象还原成其原始值，即执行上一组更改前的值。
 void CachedRowSet.rollback()
          每个 CachedRowSet 对象的 SyncProvider 都包含一个取自原始 ResultSet 的 Connection 对象或传递给它的 JDBC 属性。
 void JdbcRowSet.rollback()
          每个 JdbcRowSet 都包含一个取自原始 ResultSet 的 Connection 对象或传递给它的 JDBC 属性。
 void CachedRowSet.rollback(Savepoint s)
          每个 CachedRowSet 对象的 SyncProvider 都包含一个取自原始 ResultSet 的 Connection 对象或传递给它的 JDBC 属性。
 void JdbcRowSet.rollback(Savepoint s)
          每个 JdbcRowSet 都包含一个取自原始 ResultSet 的 Connection 对象或传递给它的 JDBC 属性。
 void CachedRowSet.rowSetPopulated(RowSetEvent event, int numRows)
          通知已注册侦听器给定 RowSetEvent 对象中的某个 RowSet 对象已经填充了多个附加行。
 void BaseRowSet.setArray(int parameterIndex, Array array)
          将指定参数设置为 Java 编程语言中的 Array 对象。
 void BaseRowSet.setAsciiStream(int parameterIndex, InputStream x)
          将此 RowSet 对象命令中的指定参数设置为给定输入流。
 void BaseRowSet.setAsciiStream(int parameterIndex, InputStream x, int length)
          将指定参数设置为给定的 java.io.InputStream 对象，该对象将具有指定的字节数。
 void BaseRowSet.setAsciiStream(String parameterName, InputStream x)
          将指定参数设置为给定的输入流。
 void BaseRowSet.setAsciiStream(String parameterName, InputStream x, int length)
          将指定参数设置为给定输入流，该输入流将拥有指定字节数。
 void JdbcRowSet.setAutoCommit(boolean autoCommit)
          每个 JdbcRowSet 都包含一个取自原始 ResultSet 的 Connection 对象或传递给它的 JDBC 属性。
 void RowSetMetaDataImpl.setAutoIncrement(int columnIndex, boolean property)
          将指定列设置为给定 boolean 值，以指示是否为该列自动编号，从而变为只读。
 void BaseRowSet.setBigDecimal(int parameterIndex, BigDecimal x)
          将指定参数设置为给定的 java.lang.BigDecimal 值。
 void BaseRowSet.setBigDecimal(String parameterName, BigDecimal x)
          将指定参数设置为给定的 java.math.BigDecimal 值。
 void BaseRowSet.setBinaryStream(int parameterIndex, InputStream x)
          将此 RowSet 对象命令中的指定参数设置为给定输入流。
 void BaseRowSet.setBinaryStream(int parameterIndex, InputStream x, int length)
          将指定参数设置为给定的 java.io.InputStream 对象，该对象具有指定的字节数。
 void BaseRowSet.setBinaryStream(String parameterName, InputStream x)
          将指定参数设置为给定输入流。
 void BaseRowSet.setBinaryStream(String parameterName, InputStream x, int length)
          将指定参数设置为给定的输入流，该输入流将拥有指定的字节数。
 void BaseRowSet.setBlob(int parameterIndex, Blob x)
          将指定参数设置为 Java 编程语言中的给定 Blob 对象。
 void BaseRowSet.setBlob(int parameterIndex, InputStream inputStream)
          将指定参数设置为 InputStream 对象。
 void BaseRowSet.setBlob(int parameterIndex, InputStream inputStream, long length)
          将指定参数设置为 InputStream 对象。
 void BaseRowSet.setBlob(String parameterName, Blob x)
          将指定参数设置为给定的 java.sql.Blob 对象。
 void BaseRowSet.setBlob(String parameterName, InputStream inputStream)
          将指定参数设置为 InputStream 对象。
 void BaseRowSet.setBlob(String parameterName, InputStream inputStream, long length)
          将指定参数设置为 InputStream 对象。
 void BaseRowSet.setBoolean(int parameterIndex, boolean x)
          将指定参数设置为 Java 编程语言中的给定 boolean 值。
 void BaseRowSet.setBoolean(String parameterName, boolean x)
          将指定参数设置为给定的 Java boolean 值。
 void BaseRowSet.setByte(int parameterIndex, byte x)
          将指定参数设置为 Java 编程语言中的给定 byte 值。
 void BaseRowSet.setByte(String parameterName, byte x)
          将指定参数设置为给定的 Java byte 值。
 void BaseRowSet.setBytes(int parameterIndex, byte[] x)
          将指定参数设置为给定的 byte 数组。
 void BaseRowSet.setBytes(String parameterName, byte[] x)
          将指定参数设置为给定的 Java byte 数组。
 void RowSetMetaDataImpl.setCaseSensitive(int columnIndex, boolean property)
          将指定列设置为给定的 boolean 值，以指示该列的名称是否区分大小写。
 void RowSetMetaDataImpl.setCatalogName(int columnIndex, String catalogName)
          将派生指定列的表名称设置为 catalogName。
 void BaseRowSet.setCharacterStream(int parameterIndex, Reader reader)
          将此 RowSet 对象命令中的指定参数设置为给定的 Reader 对象。
 void BaseRowSet.setCharacterStream(int parameterIndex, Reader reader, int length)
          将指定参数设置为给定的 java.io.Reader 对象，该对象具有指定的字符数。
 void BaseRowSet.setCharacterStream(String parameterName, Reader reader)
          将指定参数设置为给定 Reader 对象。
 void BaseRowSet.setCharacterStream(String parameterName, Reader reader, int length)
          将指定参数设置为给定的 Reader 对象，该对象是给定的字符长度数目。
 void BaseRowSet.setClob(int parameterIndex, Clob x)
          将指定参数设置为 Java 编程语言中的给定 Clob 对象。
 void BaseRowSet.setClob(int parameterIndex, Reader reader)
          将指定参数设置为 Reader 对象。
 void BaseRowSet.setClob(int parameterIndex, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void BaseRowSet.setClob(String parameterName, Clob x)
          将指定参数设置为给定的 java.sql.Clob 对象。
 void BaseRowSet.setClob(String parameterName, Reader reader)
          将指定参数设置为 Reader 对象。
 void BaseRowSet.setClob(String parameterName, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void RowSetMetaDataImpl.setColumnCount(int columnCount)
          在为其创建此 RowSetMetaDataImpl 对象的 RowSet 对象中，将列数设置为给定数。
 void RowSetMetaDataImpl.setColumnDisplaySize(int columnIndex, int size)
          将指定列中的正常最大 char 数设置为给定数。
 void RowSetMetaDataImpl.setColumnLabel(int columnIndex, String label)
          将建议用于打印输出和显示的列标签（如果有）设置为给定的 label。
 void RowSetMetaDataImpl.setColumnName(int columnIndex, String columnName)
          将指定列的列名称设置为给定的名称。
 void RowSetMetaDataImpl.setColumnType(int columnIndex, int SQLType)
          将存储在指定列中的值的 SQL 类型代码设置为 java.sql.Types 类中的给定类型代码。
 void RowSetMetaDataImpl.setColumnTypeName(int columnIndex, String typeName)
          将供存储在指定列中的值的数据源使用的类型名称设置为给定类型名称。
 void BaseRowSet.setCommand(String cmd)
          将此 RowSet 对象的 command 属性设置为给定的 String 对象，并清除为前一个命令设置的参数（如果有）。
 void BaseRowSet.setConcurrency(int concurrency)
          将此 RowSet 对象的并发性设置为指定的并发性。
 void RowSetMetaDataImpl.setCurrency(int columnIndex, boolean property)
          将指定列设置为给定的 boolean，以指示存储在该列中的值是否为缓存值。
 void BaseRowSet.setDataSourceName(String name)
          将此 RowSet 对象的 DataSource 名称属性设置为给定的逻辑名，并将此 RowSet 对象的 Url 属性设置为 null。
 void BaseRowSet.setDate(int parameterIndex, Date x)
          将指定参数设置为给定的 java.sql.Date 值。
 void BaseRowSet.setDate(int parameterIndex, Date x, Calendar cal)
          将指定参数设置为给定的 java.sql.Date 对象。
 void BaseRowSet.setDate(String parameterName, Date x)
          使用运行应用程序的虚拟机所在的默认时区将指定参数设置为给定的 java.sql.Date 值。
 void BaseRowSet.setDate(String parameterName, Date x, Calendar cal)
          使用给定 Calendar 对象将指定参数设置为给定的 java.sql.Date 值。
 void BaseRowSet.setDouble(int parameterIndex, double x)
          将指定参数设置为 Java 编程语言中的给定 double 值。
 void BaseRowSet.setDouble(String parameterName, double x)
          将指定参数设置为给定的 Java double 值。
 void BaseRowSet.setEscapeProcessing(boolean enable)
          设置为给定的 boolean 值，指示将 SQL 语句发送到数据库之前，驱动程序是否扫描转义语法并进行转义替换。
 void BaseRowSet.setFetchDirection(int direction)
          为驱动程序提供一个性能提示，该提示指示处理此 RowSet 对象中各行时使用的方向。
 void BaseRowSet.setFetchSize(int rows)
          将此 RowSet 对象的获取大小设置为给定的行数。
 void FilteredRowSet.setFilter(Predicate p)
          将给定的 Predicate 对象应用到此 FilteredRowSet 对象。
 void BaseRowSet.setFloat(int parameterIndex, float x)
          将指定参数设置为 Java 编程语言中的给定 float 值。
 void BaseRowSet.setFloat(String parameterName, float x)
          将指定参数设置为给定的 Java float 值。
 void BaseRowSet.setInt(int parameterIndex, int x)
          将指定参数设置为 Java 编程语言中的 int 值。
 void BaseRowSet.setInt(String parameterName, int x)
          将指定参数设置为给定的 Java int 值。
 void JoinRowSet.setJoinType(int joinType)
          允许应用程序调整在 JoinRowSet 对象实例包含的表上强制应用的 JOIN 类型。
 void CachedRowSet.setKeyColumns(int[] keys)
          使用给定的列号数组设置此 CachedRowSet 对象的 keyCols 字段，它形成了唯一标识此 CachedRowSet 对象中某个行的键。
 void BaseRowSet.setLong(int parameterIndex, long x)
          将指定参数设置为 Java 编程语言中的给定 long 值。
 void BaseRowSet.setLong(String parameterName, long x)
          将指定参数设置为给定的 Java long 值。
 void Joinable.setMatchColumn(int columnIdx)
          将指定的列设置为此 RowSet 对象的匹配列。
 void Joinable.setMatchColumn(int[] columnIdxes)
          将指定的列设置为此 RowSet 对象的匹配列。
 void Joinable.setMatchColumn(String columnName)
          将指定的列设置为此 RowSet 对象的匹配列。
 void Joinable.setMatchColumn(String[] columnNames)
          将指定的列设置为此 RowSet 对象的匹配列。
 void BaseRowSet.setMaxFieldSize(int max)
          将可用于此 RowSet 对象列值的最大字节数设置为给定数。
 void BaseRowSet.setMaxRows(int max)
          将此 RowSet 对象可以包含的最大行数设置为给定数。
 void CachedRowSet.setMetaData(RowSetMetaData md)
          使用给定的 RowSetMetaData 对象设置此 CachedRowSet 对象的元数据。
 void BaseRowSet.setNCharacterStream(int parameterIndex, Reader value)
          将此 RowSet 对象命令中的指定参数设置为 Reader 对象。
 void BaseRowSet.setNCharacterStream(int parameterIndex, Reader value, long length)
          将指定参数设置为 Reader 对象。
 void BaseRowSet.setNCharacterStream(String parameterName, Reader value)
          将指定参数设置为 Reader 对象。
 void BaseRowSet.setNCharacterStream(String parameterName, Reader value, long length)
          将指定参数设置为 Reader 对象。
 void BaseRowSet.setNClob(int parameterIndex, NClob value)
          将指定参数设置为 java.sql.NClob 对象。
 void BaseRowSet.setNClob(int parameterIndex, Reader reader)
          将指定参数设置为 Reader 对象。
 void BaseRowSet.setNClob(int parameterIndex, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void BaseRowSet.setNClob(String parameterName, NClob value)
          将指定参数设置为 java.sql.NClob 对象。
 void BaseRowSet.setNClob(String parameterName, Reader reader)
          将指定参数设置为 Reader 对象。
 void BaseRowSet.setNClob(String parameterName, Reader reader, long length)
          将指定参数设置为 Reader 对象。
 void BaseRowSet.setNString(int parameterIndex, String value)
          将指定参数设置为给定的 String 对象。
 void BaseRowSet.setNString(String parameterName, String value)
          将指定参数设置为给定的 String 对象。
 void BaseRowSet.setNull(int parameterIndex, int sqlType)
          将指定参数设置为 SQL NULL。
 void BaseRowSet.setNull(int parameterIndex, int sqlType, String typeName)
          将指定参数设置为 SQL NULL。
 void BaseRowSet.setNull(String parameterName, int sqlType)
          将指定参数设置为 SQL NULL。
 void BaseRowSet.setNull(String parameterName, int sqlType, String typeName)
          将指定参数设置为 SQL NULL。
 void RowSetMetaDataImpl.setNullable(int columnIndex, int property)
          将指定列设置为 ResultSetMetaData 接口中的给定常量，以指示是否可以将存储在该列中的值设置为 NULL。
 void BaseRowSet.setObject(int parameterIndex, Object x)
          将指定参数设置为 Java 编程语言中的 Object。
 void BaseRowSet.setObject(int parameterIndex, Object x, int targetSqlType)
          使用给定 Object 值设置指定参数的值。
 void BaseRowSet.setObject(int parameterIndex, Object x, int targetSqlType, int scale)
          将指定参数设置为 Java 编程语言中的 Object。
 void BaseRowSet.setObject(String parameterName, Object x)
          使用给定对象设置指定参数的值。
 void BaseRowSet.setObject(String parameterName, Object x, int targetSqlType)
          使用给定对象设置指定参数的值。
 void BaseRowSet.setObject(String parameterName, Object x, int targetSqlType, int scale)
          使用给定对象设置指定参数的值。
 void CachedRowSet.setOriginalRow()
          将此 CachedRowSet 对象中的当前行设置为原始行。
 void CachedRowSet.setPageSize(int size)
          设置 CachedRowSet 对象的页大小。
 void RowSetMetaDataImpl.setPrecision(int columnIndex, int precision)
          将存储在指定列中的值的小数位数的总数设置为给定数。
 void BaseRowSet.setQueryTimeout(int seconds)
          将驱动程序等待查询执行的最大秒数设置为给定的数。
 void BaseRowSet.setRef(int parameterIndex, Ref ref)
          将指定参数设置为 Java 编程语言中的给定 Ref 对象。
 void BaseRowSet.setRowId(int parameterIndex, RowId x)
          将指定参数设置为给定的 java.sql.RowId 对象。
 void BaseRowSet.setRowId(String parameterName, RowId x)
          将指定参数设置为给定的 java.sql.RowId 对象。
 void RowSetMetaDataImpl.setScale(int columnIndex, int scale)
          将存储在指定列中的值的小数点右边的位数设置为给定数。
 void RowSetMetaDataImpl.setSchemaName(int columnIndex, String schemaName)
          将指定列的表的模式名称（如果有）设置为 schemaName。
 void RowSetMetaDataImpl.setSearchable(int columnIndex, boolean property)
          将指定列设置为给定的 boolean 值，以指示存储在该列中的值是否可以在 WHERE 子句中使用。
 void BaseRowSet.setShort(int parameterIndex, short x)
          将指定参数设置为 Java 编程语言中的给定 short 值。
 void BaseRowSet.setShort(String parameterName, short x)
          将指定参数设置为给定的 Java short 值。
 void BaseRowSet.setShowDeleted(boolean value)
          将属性 showDeleted 设置为给定的 boolean 值，该值指示标记为删除的行是否会出现在当前行集合中。
 void CachedRowSet.setShowDeleted(boolean b)
          将属性 showDeleted 设置为给定的 boolean 值，它确定标记为删除的行是否会出现在当前行集合中。
 void JdbcRowSet.setShowDeleted(boolean b)
          将属性 showDeleted 设置为给定的 boolean 值。
 void RowSetMetaDataImpl.setSigned(int columnIndex, boolean property)
          将指定列设置为给定的 boolean 值，以指示存储在该列中的值是否为有符号数。
 void BaseRowSet.setSQLXML(int parameterIndex, SQLXML xmlObject)
          将指定参数设置为给定 java.sql.SQLXML 对象。
 void BaseRowSet.setSQLXML(String parameterName, SQLXML xmlObject)
          将指定参数设置为给定的 java.sql.SQLXML 对象。
 void BaseRowSet.setString(int parameterIndex, String x)
          将指定参数设置为给定的 String 值。
 void BaseRowSet.setString(String parameterName, String x)
          将指定参数设置为给定的 Java String 值。
 void CachedRowSet.setSyncProvider(String provider)
          将此 CachedRowSet 对象的 SyncProvider 对象设置为指定的提供者。
 void RowSetMetaDataImpl.setTableName(int columnIndex, String tableName)
          将派生指定列的表名称设置为给定的表名称。
 void CachedRowSet.setTableName(String tabName)
          将派生此 CachedRowSet 对象的表的标识符设置为给定的表名。
 void BaseRowSet.setTime(int parameterIndex, Time x)
          将指定参数设置为给定的 java.sql.Time 值。
 void BaseRowSet.setTime(int parameterIndex, Time x, Calendar cal)
          将指定参数设置为给定的 java.sql.Time 对象。
 void BaseRowSet.setTime(String parameterName, Time x)
          将指定参数设置为给定的 java.sql.Time 值。
 void BaseRowSet.setTime(String parameterName, Time x, Calendar cal)
          使用给定 Calendar 对象将指定参数设置为给定的 java.sql.Time 值。
 void BaseRowSet.setTimestamp(int parameterIndex, Timestamp x)
          将指定参数设置为给定的 java.sql.Timestamp 值。
 void BaseRowSet.setTimestamp(int parameterIndex, Timestamp x, Calendar cal)
          将指定参数设置为给定的 java.sql.Timestamp 对象。
 void BaseRowSet.setTimestamp(String parameterName, Timestamp x)
          将指定参数设置为给定的 java.sql.Timestamp 值。
 void BaseRowSet.setTimestamp(String parameterName, Timestamp x, Calendar cal)
          使用给定 Calendar 对象将指定参数设置为给定的 java.sql.Timestamp 值。
 void BaseRowSet.setTransactionIsolation(int level)
          将此 JDBC RowSet 对象的事务隔离属性设置为给定的常量。
 void BaseRowSet.setType(int type)
          将此 RowSet 对象的类型设置为指定类型。
 void BaseRowSet.setUnicodeStream(int parameterIndex, InputStream x, int length)
          已过时。 应该使用 getCharacterStream 替代它
 void BaseRowSet.setURL(int parameterIndex, URL x)
          将指定参数设置为给定的 java.net.URL 值。
 void BaseRowSet.setUrl(String url)
          将此 RowSet 对象的 Url 属性设置为给定的 String 对象，并将 dataSource 名称属性设置为 null。
 CachedRowSet JoinRowSet.toCachedRowSet()
          创建一个包含此 JoinRowSet 对象中数据的新 CachedRowSet 对象，可以使用 CachedRowSet 对象的 SyncProvider 对象将此 JoinRowSet 对象保存到数据源。
 Collection<?> CachedRowSet.toCollection()
          将此 CachedRowSet 对象转换成一个 Collection 对象，它包含此 CachedRowSet 对象的所有数据。
 Collection<?> CachedRowSet.toCollection(int column)
          将此 CachedRowSet 对象中的指定列转换成一个 Collection 对象。
 Collection<?> CachedRowSet.toCollection(String column)
          将此 CachedRowSet 对象中的指定列转换成一个 Collection 对象。
 void CachedRowSet.undoDelete()
          取消删除当前行并通知侦听器已更改了某个行。
 void CachedRowSet.undoInsert()
          如果已经插入了当前行，则立即将它从此 CachedRowSet 对象移除，同样要通知侦听器已更改了某个行。
 void CachedRowSet.undoUpdate()
          如果已经修改了行，则立即逆转上一次更新操作。
 void Joinable.unsetMatchColumn(int columnIdx)
          取消将指定的列设置为此 RowSet 对象的匹配列。
 void Joinable.unsetMatchColumn(int[] columnIdxes)
          取消将指定的列设置为此 RowSet 对象的匹配列。
 void Joinable.unsetMatchColumn(String columnName)
          取消将指定的列设置为此 RowSet 对象的匹配列。
 void Joinable.unsetMatchColumn(String[] columnName)
          取消将指定的列设置为此 RowSet 对象的匹配列。
<T> T
RowSetMetaDataImpl.unwrap(Class<T> iface)
          返回实现给定接口以允许访问非标准方法，或者代理未公开标准方法的的对象。
 void WebRowSet.writeXml(OutputStream oStream)
          以 XML 格式将此 WebRowSet 对象的数据、属性和元数据写入给定的 OutputStream 对象。
 void WebRowSet.writeXml(ResultSet rs, OutputStream oStream)
          使用给定 ResultSet 对象的内容填充此 WebRowSet 对象，并以 XML 格式将其数据、属性和元数据写入给定的 OutputStream 对象。
 void WebRowSet.writeXml(ResultSet rs, Writer writer)
          使用给定 ResultSet 对象的内容填充此 WebRowSet 对象，并以 XML 格式将其数据、属性和元数据写入给定的 Writer 对象。
 void WebRowSet.writeXml(Writer writer)
          以 XML 格式将此 WebRowSet 对象的数据、属性和元数据写入给定的 Writer 对象。
 

javax.sql.rowset.serial 中 SQLException 的使用
 

javax.sql.rowset.serial 中 SQLException 的子类
 class SerialException
          指示对 SQL 类型 BLOB、CLOB、STRUCT 或 ARRAY 以及 SQL 类型 DATALINK 和 JAVAOBJECT 进行序列化或反序列化时发生的错误。
 

抛出 SQLException 的 javax.sql.rowset.serial 中的方法
 void SerialArray.free()
          此方法释放 Array 对象及其占有的资源。
 void SerialBlob.free()
          此方法释放 Blob 对象及其占有的资源。
 void SerialClob.free()
           
 InputStream SerialClob.getAsciiStream()
          以 ascii 流的形式获取此 SerialClob 对象指定的 CLOB 值。
 InputStream SerialBlob.getBinaryStream(long pos, long length)
          返回一个包含部分 Blob 值的 InputStream 对象，它从 pos 指定的字节开始，具有 length 个字节长度。
 Reader SerialClob.getCharacterStream(long pos, long length)
           
 long SerialBlob.position(Blob pattern, long start)
          返回此 SerialBlob 对象中给定 Blob 对象开始的位置，搜索从指定位置开始。
 long SerialBlob.position(byte[] pattern, long start)
          返回在此 SerialBlob 对象中给定模式的字节开始的位置，搜索从指定的位置开始。
 long SerialClob.position(Clob searchStr, long start)
          返回此 SerialClob 对象中给定 Clob 签名开始的位置，搜索从指定位置开始。
 long SerialClob.position(String searchStr, long start)
          返回此 SerialClob 对象中给定 String 对象开始的位置，搜索从指定位置开始。
 Array SQLInputImpl.readArray()
          从流中读取 SQL ARRAY 值并以 Java 编程语言中 Array 对象的形式返回。
 InputStream SQLInputImpl.readAsciiStream()
          以 ASCII 字符流的形式返回此 SQLInputImpl 对象中的下一个属性。
 BigDecimal SQLInputImpl.readBigDecimal()
          以 java.math.BigDecimal 的形式获取此 SQLInputImpl 对象中的下一个属性。
 InputStream SQLInputImpl.readBinaryStream()
          以未解释字节流的形式返回此 SQLInputImpl 对象中的下一个属性。
 Blob SQLInputImpl.readBlob()
          以 Java 编程语言中 Blob 对象的形式获取此 SQLInputImpl 对象头部的 BLOB 值。
 boolean SQLInputImpl.readBoolean()
          以 Java 编程语言中 boolean 的形式获取此 SQLInputImpl 对象中的下一个属性。
 byte SQLInputImpl.readByte()
          以 Java 编程语言中 byte 的形式获取此 SQLInputImpl 对象中的下一个属性。
 byte[] SQLInputImpl.readBytes()
          以字节数组的形式获取此 SQLInputImpl 对象中的下一个属性。
 Reader SQLInputImpl.readCharacterStream()
          以 Unicode 字符流的形式获取此 SQLInputImpl 对象中的下一个属性。
 Clob SQLInputImpl.readClob()
          以 Java 编程语言中 Clob 对象的形式获取此 SQLInputImpl 对象头部的 CLOB 值。
 Date SQLInputImpl.readDate()
          以 java.sql.Date 对象的形式获取此 SQLInputImpl 中的下一个属性。
 double SQLInputImpl.readDouble()
          以 Java 编程语言中 double 的形式获取此 SQLInputImpl 对象中的下一个属性。
 float SQLInputImpl.readFloat()
          以 Java 编程语言中 float 的形式获取此 SQLInputImpl 对象中的下一个属性。
 int SQLInputImpl.readInt()
          以 Java 编程语言中 int 的形式获取此 SQLInputImpl 对象中的下一个属性。
 long SQLInputImpl.readLong()
          以 Java 编程语言中 long 的形式获取此 SQLInputImpl 对象中的下一个属性。
 NClob SQLInputImpl.readNClob()
          从流中读取 SQL NCLOB 值并以 Java 编程语言中 Clob 对象的形式返回。
 String SQLInputImpl.readNString()
          读取流中下一个属性并以 Java 编程语言中 String 的形式返回。
 Object SQLInputImpl.readObject()
          以 Java 编程语言中 Object 的形式获取此 SQLInputImpl 对象的头部值。
 Ref SQLInputImpl.readRef()
          以 Java 编程语言中 Ref 对象的形式获取此 SQLInputImpl 对象的头部值。
 RowId SQLInputImpl.readRowId()
          从流中读取 SQL ROWID 值并以 Java 编程语言中 RowId 对象的形式返回。
 short SQLInputImpl.readShort()
          以 Java 编程语言中 short 的形式获取此 SQLInputImpl 对象中的下一个属性。
 SQLXML SQLInputImpl.readSQLXML()
          从流中读取 SQL XML 值并以 Java 编程语言中 SQLXML 对象的形式返回。
 String SQLInputImpl.readString()
          以 Java 编程语言中 String 的形式获取此 SQLInputImpl 对象中的下一个属性。
 Time SQLInputImpl.readTime()
          以 java.sql.Time 对象的形式获取此 SQLInputImpl 对象中的下一个属性。
 Timestamp SQLInputImpl.readTimestamp()
          以 java.sql.Timestamp 对象的形式获取此 SQLInputImpl 对象中的下一个属性。
 URL SQLInputImpl.readURL()
          从流中读取 SQL DATALINK 值并以 Java 编程语言中 URL 对象的形式返回。
 OutputStream SerialClob.setAsciiStream(long pos)
          获取用于将 Ascii 字符写入此 SerialClob 对象所表示的 Clob 值的流，从位置 pos 处开始。
 OutputStream SerialBlob.setBinaryStream(long pos)
          获取用于写入此 Blob 对象所表示的 BLOB 值的流。
 int SerialBlob.setBytes(long pos, byte[] bytes)
          将给定字节数组写入此 Blob 对象表示的 BLOB 值（从位置 pos 处开始），并返回写入的字节数。
 int SerialBlob.setBytes(long pos, byte[] bytes, int offset, int length)
          将所有或部分给定的 byte 数组写入此 Blob 对象表示的 BLOB 值中，并返回写入的字节数。
 Writer SerialClob.setCharacterStream(long pos)
          获取用于将 Unicode 字符流写入此 SerialClob 对象所表示的 CLOB 值（位置 pos 处）的流。
 boolean SQLInputImpl.wasNull()
          确认从此 SQLInputImpl 对象读取的上一个值是否为 null。
 void SQLOutputImpl.writeArray(Array x)
          将 Java 编程语言中的 Array 对象写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeAsciiStream(InputStream x)
          将 ASCII 字符流写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeBigDecimal(BigDecimal x)
          将 Java 编程语言中的 java.math.BigDecimal 对象写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeBinaryStream(InputStream x)
          将未解释字节流写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeBlob(Blob x)
          将 Java 编程语言中的 Blob 对象写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeBoolean(boolean x)
          将 Java 编程语言中的 boolean 写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeByte(byte x)
          将 Java 编程语言中的 byte 写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeBytes(byte[] x)
          将 Java 编程语言中的 byte 数组写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeCharacterStream(Reader x)
          将 Unicode 字符流写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeClob(Clob x)
          将 Java 编程语言中的 Clob 对象写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeDate(Date x)
          将 Java 编程语言中的 java.sql.Date 对象写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeDouble(double x)
          将 Java 编程语言中的 double 写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeFloat(float x)
          将 Java 编程语言中的 float 写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeInt(int x)
          将 Java 编程语言中的 int 写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeLong(long x)
          将 Java 编程语言中的 long 写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeNClob(NClob x)
          将 SQL NCLOB 值写入流中。
 void SQLOutputImpl.writeNString(String x)
          将下一个属性以 Java 编程语言中 String 的形式写入流中。
 void SQLOutputImpl.writeObject(SQLData x)
          将包含在给定 SQLData 对象中的数据写入流中。
 void SQLOutputImpl.writeRef(Ref x)
          将 Java 编程语言中的 Ref 对象写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeRowId(RowId x)
          将 SQL ROWID 值写入流中。
 void SQLOutputImpl.writeShort(short x)
          将 Java 编程语言中的 short 写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeSQLXML(SQLXML x)
          将 SQL XML 值写入流中。
 void SQLOutputImpl.writeString(String x)
          将 Java 编程语言中的 String 写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeStruct(Struct x)
          将 Java 编程语言中的 Struct 对象写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeTime(Time x)
          将 Java 编程语言中的 java.sql.Time 对象写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeTimestamp(Timestamp x)
          将 Java 编程语言中的 java.sql.Timestamp 对象写入此 SQLOutputImpl 对象。
 void SQLOutputImpl.writeURL(URL url)
          将 Java 编程语言中的 java.sql.Type.DATALINK 对象写入此 SQLOutputImpl 对象。
 

抛出 SQLException 的 javax.sql.rowset.serial 中的构造方法
SerialArray(Array array)
          根据给定 Array 对象构造新的 SerialArray 对象。
SerialArray(Array array, Map<String,Class<?>> map)
          根据给定 Array 对象构造新的 SerialArray 对象，当数组元素是 SQL UDT 时对每个元素的自定义映射关系使用给定的类型映射表。
SerialBlob(Blob blob)
          根据给定 Blob 对象的序列化形式构造一个 SerialBlob 对象。
SerialBlob(byte[] b)
          按照给定 byte 数组的序列化形式构造一个 SerialBlob 对象。
SerialClob(char[] ch)
          按照给定 char 数组的序列化形式构造一个 SerialClob 对象。
SerialClob(Clob clob)
          按照给定 Clob 对象的序列化形式构造一个 SerialClob 对象。
SerialRef(Ref ref)
          根据给定 Ref 对象构造 SerialRef 对象。
SQLInputImpl(Object[] attributes, Map<String,Class<?>> map)
          创建一个 SQLInputImpl 对象，并使用给定的属性数组和类型映射表进行初始化。
SQLOutputImpl(Vector<?> attributes, Map<String,?> map)
          创建一个新的 SQLOutputImpl 对象，并使用给定的属性向量和类型映射表进行初始化。
 

javax.sql.rowset.spi 中 SQLException 的使用
 

javax.sql.rowset.spi 中 SQLException 的子类
 class SyncFactoryException
          指示 SyncFactory 机制发生的错误。
 class SyncProviderException
          指示 SyncProvider 机制发生的错误。
 

抛出 SQLException 的 javax.sql.rowset.spi 中的方法
 void TransactionalWriter.commit()
          使最后一次调用 commit 或 rollback 方法以来 acceptChanges 执行的所有更改永久化。
 Object SyncResolver.getConflictValue(int index)
          获取此 SyncResolver 对象的当前行中指定列的值，它是数据源中导致冲突的值。
 Object SyncResolver.getConflictValue(String columnName)
          获取此 SyncResolver 对象的当前行中指定列的值，它是数据源中导致冲突的值。
 boolean SyncResolver.nextConflict()
          将指针从其当前位置移动到下一个包含冲突值的行。
 boolean SyncResolver.previousConflict()
          将指针从其当前位置移动到此 SyncResolver 对象中上一个冲突行。
 void XmlReader.readXML(WebRowSet caller, Reader reader)
          从给定的 XML 格式的输入流读取并解析给定的 WebRowSet 对象。
 void TransactionalWriter.rollback()
          撤消在当前事务中进行的所有更改。
 void TransactionalWriter.rollback(Savepoint s)
          撤消在给定 Savepoint 对象之前所进行的当前事务中的所有更改。
 void SyncResolver.setResolvedValue(int index, Object obj)
          将 obj 设置为将同步的 RowSet 对象当前行中第 index 列的值。
 void SyncResolver.setResolvedValue(String columnName, Object obj)
          将 obj 设置为将同步的 RowSet 对象当前行中列 columnName 的值。
 void XmlWriter.writeXML(WebRowSet caller, Writer writer)
          将给定的 WebRowSet 对象以 XML 文档的形式编写到指定的 java.io.Writer 输出流。
 

概述  软件包  类   使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 6
 上一个   下一个 框架    无框架    
提交错误或意见

版权所有 2008 Sun Microsystems, Inc. 保留所有权利。请遵守GNU General Public License, version 2 only。