|
JavaTM Platform Standard Ed. 6 |
|||||||||
上一个 下一个 | 框架 无框架 |
使用 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 对象的当前行中指定列的值。 |
|
|
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>) 值。 |
|
|
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 个字符。 |
|
|
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 对象的匹配列。 |
|
|
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 Platform Standard Ed. 6 |
|||||||||
上一个 下一个 | 框架 无框架 |
版权所有 2007 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。