zoukankan html css js c++ java

ResultSet详解(转)

ResultSet用法集锦

结果集(ResultSet)是数据中查询结果返回的一种对象，可以说结果集是一个存储查询结果的对象，但是结果集并不仅仅具有存储的功能，他同时还具有操纵数据的功能，可能完成对数据的更新等.

结果集读取数据的方法主要是getXXX()，他的参数可以是整型表示第几列（是从1开始的），还可以是列名。返回的是对应的XXX类型的值。如果对应那列是空值，XXX是对象的话返回XXX型的空值，如果XXX是数字类型，如Float等则返回0,boolean返回false.使用getString()可以返回所有的列的值，不过返回的都是字符串类型的。XXX可以代表的类型有: 基本的数据类型如整型(int)，布尔型(Boolean)，浮点型(Float,Double)等，比特型(byte)，还包括一些特殊的类型，如：日期类型（java.sql.Date），时间类型(java.sql.Time)，时间戳类型(java.sql.Timestamp)，大数型 (BigDecimal和BigInteger等)等。还可以使用getArray(intcolindex/String columnname)，通过这个方法获得当前行中，colindex所在列的元素组成的对象的数组。使用 getAsciiStream(intcolindex/String colname)可以获得该列对应的当前行的ascii流。也就是说所有的getXXX方法都是对当前行进行操作。

结果集从其使用的特点上可以分为四类，这四类的结果集的所具备的特点都是和Statement语句的创建有关，因为结果集是通过Statement语句执行后产生的，所以可以说，结果集具备何种特点，完全决定于Statement，当然我是说下面要将的四个特点，在Statement创建时包括三种类型。首先是无参数类型的，它对应的就是下面要介绍的基本的ResultSet对应的Statement。下面的代码中用到的Connection并没有对其初始化，变量conn代表的就是Connection对应的对象。SqlStr代表的是响应的SQL语句.

1、最基本的ResultSet。
之所以说是最基本的ResultSet是因为这个ResultSet它起到的作用就是完成了查询结果的存储功能，而且只能读取一次，不能够来回的滚动读取。这种结果集的创建方式如下:

Statement st = conn.CreateStatement()
ResultSet rs = Statement.excuteQuery(sqlStr);

由于这种结果集不支持滚动的读取功能,所以如果获得这样一个结果集，只能使用它里面的next()方法，逐个的读去数据.

2、可滚动的ResultSet类型。
这个类型支持前后滚动取得纪录next()、previous()，回到第一行first()，同时还支持要取的ResultSet中的第几行 absolute(int n)，以及移动到相对当前行的第几行relative(int n)，要实现这样的ResultSet在创建Statement时用如下的方法。

Statement st =conn.createStatement(int resultSetType, int resultSetConcurrency)
ResultSet rs = st.executeQuery(sqlStr)

其中两个参数的意义是：
resultSetType是设置ResultSet对象的类型标示可滚动，或者是不可滚动。取值如下:

ResultSet.TYPE_FORWARD_ONLY

只能向前滚动(这是默认值)

ResultSet.TYPE_SCROLL_INSENSITIVE

这两个方法都能够实现任意的前后滚动，使用各种移动的ResultSet指针的方法。二者的区别在于前者对于修改不敏感，而后者对于修改敏感。

Result.TYPE_SCROLL_SENSITIVE

resultSetConcurency是设置ResultSet对象能够修改的，取值如下：

ResultSet.CONCUR_READ_ONLY	设置为只读类型的参数。
ResultSet.CONCUR_UPDATABLE	设置为可修改类型的参数。

所以如果只是想要可以滚动的类型的Result只要把Statement如下赋值就行了。

Statement st =conn.createStatement(Result.TYPE_SCROLL_INSENITIVE, ResultSet.CONCUR_READ_ONLY);
ResultSet rs = st.excuteQuery(sqlStr)；

用这个Statement执行的查询语句得到的就是可滚动的ResultSet。

3、可更新的ResultSet
这样的ResultSet对象可以完成对数据库中表的修改，但是我知道ResultSet只是相当于数据库中表的视图，所以并不是所有的ResultSet只要设置了可更新就能够完成更新的，能够完成更新的ResultSet的SQL语句必须要具备如下的属性：
    a、只引用了单个表。
    b、不含有join或者group by子句。
    c、那些列中要包含主关键字。
    具有上述条件的，可更新的ResultSet可以完成对数据的修改，可更新的结果集的创建方法是：
Statement st =createstatement(Result.TYPE_SCROLL_INSENSITIVE,Result.CONCUR_UPDATABLE)
这样的Statement的执行结果得到的就是可更新的结果集。更新的方法是，把ResultSet的游标移动到你要更新的行，然后调用 updateXXX()，这个方法XXX的含义和getXXX()是相同的。updateXXX（）方法有两个参数，第一个是要更新的列，可以是列名或者序号。第二个是要更新的数据，这个数据类型要和XXX相同。每完成对一行的update要调用updateRow()完成对数据库的写入，而且是在 ResultSet的游标没有离开该修改行之前，否则修改将不会被提交。
    使用updateXXX方法还可以完成插入操作。但是首先要介绍两个方法：
    moveToInsertRow()是把ResultSet移动到插入行，这个插入行是表中特殊的一行，不需要指定具体那一行，只要调用这个方法系统会自动移动到那一行的。
    moveToCurrentRow() 这是把ResultSet移动到记忆中的某个行，通常当前行。如果没有使用insert操作，这个方法没有什么效果，如果使用了insert操作，这个方法用于返回到insert操作之前的那一行，离开插入行，当然也可以通过next(),previous()等方法离开插入行。
    要完成对数据库的插入，首先调用moveToInsertRow()移动到插入行，然后调用updateXXX的方法完成对各列数据的更新，完成更新后和更新操作一样，要写到数据库，不过这里使用的是insertRow()，也要保证在该方法执行之前ResultSet没有离开插入列，否则插入不被执行，并且对插入行的更新将丢失.

4、可保持的ResultSet
正常情况下如果使用Statement执行完一个查询，又去执行另一个查询时这时候第一个查询的结果集就会被关闭，也就是说，所有的Statement的查询对应的结果集是一个，如果调用Connection的commit()方法也会关闭结果集。可保持性就是指当ResultSet的结果被提交时，是被关闭还是不被关闭。JDBC2.0和1.0提供的都是提交后ResultSet 就会被关闭。不过在JDBC3.0中，我们可以设置ResultSet是否关闭。要完成这样的ResultSet的对象的创建，要使用的 Statement的创建要具有三个参数，这个Statement的创建方式也就是，我所说的Statement的第三种创建方式。如下：

Statementst=createStatement(int resultsetscrollable,int resultsetupdateable,intresultsetSetHoldability)
ResultSet rs = st.excuteQuery(sqlStr);

前两个参数和createStatement方法中的参数是完全相同的，这里只介绍第三个参数:
resultSetHoldability表示在结果集提交后结果集是否打开，取值有两个:

ResultSet.HOLD_CURSORS_OVER_COMMIT	表示修改提交时ResultSet不关闭.
ResultSet.CLOSE_CURSORS_AT_COMMIT	表示修改提交时ResultSet关闭.

不过这种功能只是在JDBC3.0的驱动下才能成立。

总结:

JDBCAPI 2.0/3.0中ResultSet记录集的
JDBC API 2.0/3.0中ResultSet记录集的简便实用的新特性

1 新定义了若干个常数,这些常数用于指定ResultSet的类型游标移动的方向等性质，如下所示：

FETCH_FORWARD	该常数的作用是指定处理记录集中行的顺序，是由前到后即从第一行开始处理一直到最后一行.
FETCH_REVERSE	该常数的作用是指定处理记录集中行的顺序，是由后到前即从最后一行开始处理一直到第一行.
FETCH_UNKNOWN	该常数的作用是不指定处理记录集中行的顺序，由JDBC 驱动程序和数据库系统决定.
TYPE_FORWARD_ONLY	该常数的作用是指定数据库游标的移动方向是向前，不允许向后移动即只能使ResultSet 接口的next()方法而不能使用previous()方法否则会产生错误.
TYPE_SCROLL_INSENSITIVE	该常数的作用是指定数据库游标可以在记录集中前后移动，并且当前数据库用户获取的记录集对其他用户的操作不敏感；就是说，当前用户正在浏览记录集中的数据，与此同时，其他用户更新了数据库中的数据，但是当前用户所获取的记录集中的数据不会受到任何影响。
TYPE_SCROLL_SENSITIVE	该常数的作用是指定数据库游标可以在记录集中前后移动，并且当前数据库用户获取的记录集对其他用户的操作敏感，就是说，当前用户正在浏览记录集，但是其它用户的操作使数据库中的数据发生了变化，当前用户所获取的记录集中的数据也会同步发生变化，这样有可能会导致非常严重的错误产生建议慎重使用该常数。
CONCUR_READ_ONLY	该常数的作用是指定当前记录集的协作方式(concurrencymode)为只读；一旦使用了这个常数，那么用户就不可以更新记录集中的数据。
CONCUR_UPDATABLE	该常数的作用是指定当前记录集的协作方式(concurrencymode)为可以更新；一旦使用了这个常数，那么用户就可以使用updateXXX()等方法更新记。
CLOSE_CURSORS_AT_COMMIT	表示修改提交时ResultSet关闭.
HOLD_CURSORS_OVER_COMMIT	表示修改提交时ResultSet不关闭.

2 ResultSet 接口提供了一整套的定位方法

这些可以在记录集中定位到任意一行：

public boolean absolute(int row): 该方法的作用是将记录集中的某一行设定为当前行，亦即将数据库游标移动到指定的行，参数row 指定了目标行的行号，这是绝对的行号，由记录集的第一行开始计算不是相对的行号.

public boolean relative(int rows): 该方法的作用也是将记录集中的某一行设定为当前行，但是它的参数rows 表示目标行相对于当前行的行号。

public boolean first(); 该方法的作用是将当前行定位到数据库记录集的第一行。

public boolean last(); 该方法的作用刚好和first()方法相反。

public boolean isFirst(); 该方法的作用是检查当前行是否记录集的第一行，如果是返回true，否则返回false.

public boolean isLast(); 该方法的作用是检查当前行是否记录集的最后一行，如果是返回true ，否则返回false。

public void afterLast(); 该方法的作用是将数据库游标移到记录集的最后，位于记录集最后一行的后面，如果该记录集不包含任何的行该方法不产生作用。

public void beforeFirst(); 该方法的作用是将数据库游标移到记录集的最前面，位于记录集第一行的前面，如果记录集不包含任何的行该方法不产生作用。

public boolean isAfterLast(); 该方法检查数据库游标是否处于记录集的最后面，如果是返回true ，否则返回false。

public boolean isBeforeFirst(); 该方法检查数据库游标是否处于记录集的最前面，如果是返回true ，否则返回false。

public boolean next(); 该方法的作用是将数据库游标向前移动一位，使得下一行成为当前行，当刚刚打开记录集对象时，数据库游标的位置在记录集的最前面，第一次使用next()方法将会使数据库游标定位到记录集的第一行，第二次使用next()方法将会使数据库游标定位到记录集的第二行，以此类推。

public boolean previous(); 该方法的作用是将数据库游标向后移动一位，使得上一行成为当前行.

3ResultSet 接口添加了对行操作的支持(最令人心动之处)

修改了的记录集接口(ResultSet 接口)的方法，使它支持可以滚动的记录集，即数据库游标可以在返回的记录集对象中自由地向前或向后滚动，或者定位到某个特殊的行。利用ResultSet 接口中定义的新方法，JSP/Servlet 程序员可以用Java语言来更新记录集，比如插入记录，更新某行的数据，而不是靠执行SQL 语句，这样就大大方便了程序员的开发工作，享受Java编程的乐趣了。
ResultSet 接口中新添加的部分方法如下所示：

public boolean rowDeleted(); 如果当前记录集的某行被删除了，那么记录集中将会留出一个空位；调用rowDeleted()方法，如果探测到空位的存在，那么就返回true；如果没有探测到空位的存在，就返回false 值.

public boolean rowInserted(); 如果当前记录集中插入了一个新行，该方法将返回true ，否则返回false。

public boolean rowUpdated(); 如果当前记录集的当前行的数据被更新，该方法返回true ，否则返回false。

public void insertRow(); 该方法将执行插入一个新行到当前记录集的操作。

public void updateRow(); 该方法将更新当前记录集当前行的数据。

public void deleteRow(); 该方法将删除当前记录集的当前行。

public void updateString(int columnIndex ,String x); 该方法更新当前记录集当前行某列的值，该列的数据类型是String(指Java 数据类型是String,与之对应的JDBC 数据类型是VARCHAR 或NVARCHAR 等数据类型) 。该方法的参数columnIndex 指定所要更新的列的列索引，第一列的列索引是1 ，以此类推，第二个参数x 代表新的值，这个方法并不执行数据库操作，需要执行insertRow()方法或者updateRow()方法以后，记录集和数据库中的数据才能够真正更新。

public void updateString(String columnName ,String x); 该方法和上面介绍的同名方法差不多，不过该方法的第一个参数是columnName ，代表需要更新的列的列名，而不是columnIndex。

4.基本操作:
往数据库当前记录集插入新行的操作流程如下：
1 调用moveToInsertRow()方法；
2 调用updateXXX()方法指定插入行各列的值；
3 调用insertRow()方法往数据库中插入新的行。

更新数据库中某个记录的值(某行的值)的方法是：
1 定位到需要修改的行(使用absolute()relative()等方法定位)；
2 使用相应updateXXX()方法设定某行某列的新值；XXX 所代表的Java数据类型，必须可以映射为某列的JDBC数据类型，如果希望rollback 该项操作，请在调用updateRow()方法以前，使用cancelRowUpdates()方法，这个方法可以将某行某列的值复原；
3 使用updateRow()方法完成UPDATE的操作。

删除记录集中某行(亦即删除某个记录)的方法：
1 定位到需要修改的行(使用absolute()relative()等方法定位)；
2 使用deleteRow()

删除记录集中某行(亦即删除某个记录)的方法：
1 定位到需要修改的行(使用absolute()relative()等方法定位)；
2 使用deleteRow()方法.

JDBC的ResultSet接口（查询操作）、PreparedStatement接口重构增删改查（含SQL注入的解释）

首先需要回顾一下上一篇文章中的内容：MySQL数据库学习笔记（八）----JDBC入门及简单增删改数据库的操作

一、ResultSet接口的介绍：

对数据库的查询操作，一般需要返回查询结果，在程序中，JDBC为我们提供了ResultSet接口来专门处理查询结果集。

Statement通过以下方法执行一个查询操作：

ResultSet executeQuery(String sql) throws SQLException

单词Query就是查询的意思。函数的返回类型是ResultSet，实际上查询的数据并不在ResultSet里面，依然是在数据库里，ResultSet中的next()方法类似于一个指针，指向查询的结果，然后不断遍历。所以这就要求连接不能断开。

ResultSet接口常用方法：

boolean next() 遍历时，判断是否有下一个结果
int getInt(String columnLabel)
int getInt(int columnIndex)
Date getDate(String columnLabel)
Date getDate(int columnIndex)
String getString(String columnLabel)
String getString(int columnIndex)

二、ResultSet接口实现查询操作：

步骤如下：（和上一篇博文中的增删改的步骤类似哦）

1、加载数据库驱动程序：Class.forName(驱动程序类)
2、通过用户名密码和连接地址获取数据库连接对象：DriverManager.getConnection(连接地址,用户名,密码)
3、构造查询SQL语句
4、创建Statement实例：Statement stmt = conn.createStatement()
5、执行查询SQL语句，并返回结果：ResultSet rs = stmt.executeQuery(sql)
6、处理结果
7、关闭连接：rs.close()、stmt.close()、conn.close()

我们来举个例子吧，来查询下面的这个表：

55ceaaf2-b1f8-420a-89a6-37f502b48192

新建工程JDBC02，依旧先导入jar包。然后新建类，完整版代码如下：

 1 package com.vae.jdbc;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 import java.sql.Statement;
 8 
 9 public class JdbcQuey {
10 
11 
12     //数据库连接地址
13     private final static String URL = "jdbc:mysql://localhost:3306/JDBCdb";
14     //用户名
15     public final static String USERNAME = "root";
16     //密码
17     public final static String PASSWORD = "smyh";
18     //加载的驱动程序类（这个类就在我们导入的jar包中）
19     public final static String DRIVER = "com.mysql.jdbc.Driver";
20     
21     public static void main(String[] args) {
22         // TODO Auto-generated method stub
23         query();
24 
25     }
26     
27     
28     //方法：查询操作
29     public static void query(){
30         try {
31             Class.forName(DRIVER);
32             Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
33             String sql = "select id,name,age,description from person";
34             Statement state = conn.createStatement();
35             //执行查询并返回结果集
36             ResultSet rs = state.executeQuery(sql);
37             while(rs.next()){  //通过next来索引：判断是否有下一个记录
38                 //rs.getInt("id"); //方法：int java.sql.ResultSet.getInt(String columnLabel) throws SQLException
39                 int id = rs.getInt(1);  //方法：int java.sql.ResultSet.getInt(int columnIndex) throws SQLException
40 
41                 String name = rs.getString(2);
42                 int age = rs.getInt(3);
43                 String description = rs.getString(4);
44                 System.out.println("id="+id+",name="+name+",age="+age+",description="+description);
45             }
46             rs.close();
47             state.close();
48             conn.close();            
49             
50         } catch (ClassNotFoundException e) {
51             e.printStackTrace();
52         } catch (SQLException e) {
53             e.printStackTrace();
54         }
55     }
56 }

关于代码的解释，可以看上一篇博客。上方代码的核心部分是37至45行。

37行：next()函数：通过next来索引，判断是否有下一个记录。一开始就指向内存的首地址，即第一条记录，如果返回值为true，指针会自动指向下一条记录。

38、39行：getInt(String columnLabel)或者getInt(int columnIndex)代表的是列的索引，参数可以是列的名字，也可以用编号来表示，我们一般采用后者。编号的顺序是按照33行sql语句中列的顺序来定的。

程序运行后，后台输出如下：

a9422041-b446-4dd1-9972-25c10304a4d6

上一篇博客+以上部分，实现了对数据库的简单增删改查的操作。其实这种拼接的方式很不好：既麻烦又不安全。我们接下来进行改进。

三、使用PreparedStatement重构增删改查（推荐）

概念：表示预编译的SQL语句的对象。SQL语句被预编译并存储在PreparedStatement对象中。然后可以使用此对象多次高效地执行该语句。PreparedStatement是Statement的一个接口。

作用：灵活处理sql语句中的变量。

举例：

以下面的这张数据库表为例：

d0d81c8d-285b-45a7-8c4b-3bb2beb00b69

新建Java工程文件JDBC3。新建一个Person类，方便在主方法里进行操作。Person类的代码如下：

package com.vae.jdbc;

public class Person {

    private int id;
    private String name;
    private int age;
    private String description;
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    
    public Person(int id, String name, int age, String description) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
        this.description = description;
    }    
    
    public Person(String name, int age, String description) {
        super();
        this.name = name;
        this.age = age;
        this.description = description;
    }
    public Person() {
        super();
    }
    
    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", age=" + age
                + ", description=" + description + "]";
    }
    
    
}

上方是一个简单的Person类，并添加set和get方法以及构造方法，无需多解释。

插入操作：

现在在主类JDBCtest中实现插入操作，完整代码如下：

 1 package com.vae.jdbc;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.PreparedStatement;
 6 import java.sql.SQLException;
 7 
 8 public class JDBCtest {
 9 
10 
11     //数据库连接地址
12     public final static String URL = "jdbc:mysql://localhost:3306/JDBCdb";
13     //用户名
14     public final static String USERNAME = "root";
15     //密码
16     public final static String PASSWORD = "smyh";
17     //驱动类
18     public final static String DRIVER = "com.mysql.jdbc.Driver";
19     
20     
21     public static void main(String[] args) {
22         // TODO Auto-generated method stub
23         Person p = new Person("smyhvae",22,"我是在Java代码中插入的数据");
24         insert(p);
25     }
26     
27 
28 
29     //方法：使用PreparedStatement插入数据
30     public static void insert(Person p){
31         
32         try {
33             Class.forName(DRIVER);
34             Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
35             String sql = "insert into person(name,age,description)values(?,?,?)";
36             PreparedStatement ps = conn.prepareStatement(sql);
37             //设置占位符对应的值
38             ps.setString(1, p.getName());
39             ps.setInt(2, p.getAge());
40             ps.setString(3, p.getDescription());
41             
42             ps.executeUpdate();
43             
44             ps.close();
45             conn.close();
46             
47             
48         } catch (ClassNotFoundException e) {
49             e.printStackTrace();
50         } catch (SQLException e) {
51             e.printStackTrace();
52         }        
53     }
54 }

我们来看一下上面的代码是怎么实现代码的优化的：

30行：将整个person对象进去，代表的是数据库中的一条记录。

35行：问号可以理解为占位符，有几个问号就代表要插入几个列，这样看来sql代码就比较简洁。

38至40行：给35行的问号设值，参数1代表第一个问号的位置，以此类推。

然后我们在main主方法中给Person设具体的值（23行），通过insert()方法就插入到数据库中去了。数据库中就多了一条记录：

868b266f-4a7c-4018-998d-85befb15bbc0

更新操作：

代码和上方类似，修改操作的方法如下：

 1     //方法：使用PreparedStatement更新数据
 2     public static void update(Person p){
 3         try {
 4             Class.forName(DRIVER);
 5             Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
 6             String sql = "update person set name=?,age=?,description=? where id=?";
 7             PreparedStatement ps = conn.prepareStatement(sql);
 8             //设置占位符对应的值
 9             ps.setString(1, p.getName());
10             ps.setInt(2, p.getAge());
11             ps.setString(3, p.getDescription());
12             ps.setInt(4, p.getId());
13             
14             ps.executeUpdate();
15             
16             ps.close();
17             conn.close();
18             
19             
20         } catch (ClassNotFoundException e) {
21             e.printStackTrace();
22         } catch (SQLException e) {
23             e.printStackTrace();
24         }
25     }

因为在这里有四个问号的占位符，所以稍后再main方法中记得使用四个参数的Person构造方法，传递四个参数。

删除操作：

代码和上方类似，方法如下：

 1     //方法：使用PreparedStatement删除数据
 2     public static void delete(int id){
 3         try {
 4             Class.forName(DRIVER);
 5             Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
 6             String sql = "delete from person where id=?";
 7             PreparedStatement ps = conn.prepareStatement(sql);
 8             //设置占位符对应的值
 9             ps.setInt(1, id);
10             
11             ps.executeUpdate();
12             
13             ps.close();
14             conn.close();
15             
16             
17         } catch (ClassNotFoundException e) {
18             e.printStackTrace();
19         } catch (SQLException e) {
20             e.printStackTrace();
21         }
22     }

这里的方法中，传入的参数是是一个id。

查询操作：

 1     // 使用PreparedStatement查询数据
 2     public static Person findById(int id){
 3         Person p = null;
 4         try {
 5             Class.forName(DRIVER);
 6             Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
 7             String sql = "select name,age,description from person where id=?";
 8             PreparedStatement ps = conn.prepareStatement(sql);
 9             //设置占位符对应的值
10             ps.setInt(1, id);
11             
12             ResultSet rs = ps.executeQuery();
13             if(rs.next()){
14                 p = new Person();
15                 p.setId(id);
16                 p.setName(rs.getString(1));
17                 p.setAge(rs.getInt(2));
18                 p.setDescription(rs.getString(3));
19                 //把 java.sql.Date 与 java.util.Date之间的转换
20 //                java.util.Date date = rs.getDate(4);
21 //                ps.setDate(4, new java.sql.Date(date.getTime()));
22                 
23             }
24             rs.close();
25             ps.close();
26             conn.close();
27             
28             
29         } catch (ClassNotFoundException e) {
30             e.printStackTrace();
31         } catch (SQLException e) {
32             e.printStackTrace();
33         }
34         return p;
35     }

查询操作稍微麻烦一点，在方法中传入的参数是id，方法的返回值是查询的结果，即Person类。

五、PreparedStatement小结：

在JDBC应用中，如果你已经是稍有水平开发者，你就应该始终以PreparedStatement代替Statement。也就是说，在任何时候都不要使用Statement。

基于以下的原因：

一、代码的可读性和可维护性
二、PreparedStatement可以尽最大可能提高性能
三、最重要的一点是极大地提高了安全性

如果使用Statement而不使用PreparedStatement，则会造成一个安全性问题：SQL注入

来看一下SQL注入是怎么回事。现在有如下的一张用户名密码表user：

1cbad809-eef2-43f7-9044-631c7b94838d

我们在执行如下sql语句进行查询：

select id,name,pwd from user where name='xxx' and pwd = 'x' or '1'='1'

竟能出奇地查到所有的用户名、密码信息：

9bde5b94-960e-4894-bc99-eec64b1f3ee8

因为1=1永远是成立的，所以这句话永远都成立。所以在Java代码中，可以利用这个漏洞，将上方的蓝框部分内容当做pwd的变量的内容。来举个反例：使用Statement写一个登陆的操作：

 1     //登 录(Statement：会造成SQL注入的安全性问题)
 2     public static void login(String name,String pwd){
 3         Person p = null;
 4         try {
 5             Class.forName(DRIVER);
 6             Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
 7 //            String sql = "select id,name,pwd from user where name='' and pwd=''";
 8             
 9             StringBuffer sql = new StringBuffer("select id,name,pwd from user where name='");
10             sql.append(name).append("' and pwd='").append(pwd).append("'");
11             Statement ps = conn.createStatement();
12             
13             ResultSet rs = ps.executeQuery(sql.toString());
14             if(rs.next()){
15             }
16             rs.close();
17             ps.close();
18             conn.close();
19             
20             
21         } catch (ClassNotFoundException e) {
22             e.printStackTrace();
23         } catch (SQLException e) {
24             e.printStackTrace();
25         }
26     }

上方代码中的第10行就是采用字符串拼接的方式，就会造成SQL注入的安全性问题。

而如果使用PreparedStatement中包含问号的sql语句，程序就会先对这句sql语句进行判断，就不会出现字符串拼接的现象了。

最后附上本文中，PreparedStatement接口重构增删改查的完整版代码：

  1 package com.vae.jdbc;
  2 
  3 import java.sql.Connection;
  4 import java.sql.DriverManager;
  5 import java.sql.PreparedStatement;
  6 import java.sql.ResultSet;
  7 import java.sql.SQLException;
  8 
  9 public class JDBCtest {
 10 
 11 
 12     //数据库连接地址
 13     public final static String URL = "jdbc:mysql://localhost:3306/JDBCdb";
 14     //用户名
 15     public final static String USERNAME = "root";
 16     //密码
 17     public final static String PASSWORD = "smyh";
 18     //驱动类
 19     public final static String DRIVER = "com.mysql.jdbc.Driver";
 20     
 21     
 22     public static void main(String[] args) {
 23         // TODO Auto-generated method stub
 24         Person p = new Person();
 25         //insert(p);
 26         //update(p);
 27         //delete(3);
 28         p = findById(2);
 29         System.out.println(p);
 30     }
 31     
 32     
 33     //方法：使用PreparedStatement插入数据
 34     public static void insert(Person p){
 35         
 36         try {
 37             Class.forName(DRIVER);
 38             Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
 39             String sql = "insert into person(name,age,description)values(?,?,?)";
 40             PreparedStatement ps = conn.prepareStatement(sql);
 41             //设置占位符对应的值
 42             ps.setString(1, p.getName());
 43             ps.setInt(2, p.getAge());
 44             ps.setString(3, p.getDescription());
 45             
 46             ps.executeUpdate();
 47             
 48             ps.close();
 49             conn.close();
 50             
 51             
 52         } catch (ClassNotFoundException e) {
 53             e.printStackTrace();
 54         } catch (SQLException e) {
 55             e.printStackTrace();
 56         }        
 57     }
 58     
 59     
 60     //方法：使用PreparedStatement更新数据
 61     public static void update(Person p){
 62         try {
 63             Class.forName(DRIVER);
 64             Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
 65             String sql = "update person set name=?,age=?,description=? where id=?";
 66             PreparedStatement ps = conn.prepareStatement(sql);
 67             //设置占位符对应的值
 68             ps.setString(1, p.getName());
 69             ps.setInt(2, p.getAge());
 70             ps.setString(3, p.getDescription());
 71             ps.setInt(4, p.getId());
 72             
 73             ps.executeUpdate();
 74             
 75             ps.close();
 76             conn.close();
 77             
 78             
 79         } catch (ClassNotFoundException e) {
 80             e.printStackTrace();
 81         } catch (SQLException e) {
 82             e.printStackTrace();
 83         }
 84     }
 85     
 86     
 87     //方法：使用PreparedStatement删除数据
 88     public static void delete(int id){
 89         try {
 90             Class.forName(DRIVER);
 91             Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
 92             String sql = "delete from person where id=?";
 93             PreparedStatement ps = conn.prepareStatement(sql);
 94             //设置占位符对应的值
 95             ps.setInt(1, id);
 96             
 97             ps.executeUpdate();
 98             
 99             ps.close();
100             conn.close();
101             
102             
103         } catch (ClassNotFoundException e) {
104             e.printStackTrace();
105         } catch (SQLException e) {
106             e.printStackTrace();
107         }
108     }
109     
110     
111     // 使用PreparedStatement查询数据
112     public static Person findById(int id){
113         Person p = null;
114         try {
115             Class.forName(DRIVER);
116             Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
117             String sql = "select name,age,description from person where id=?";
118             PreparedStatement ps = conn.prepareStatement(sql);
119             //设置占位符对应的值
120             ps.setInt(1, id);
121             
122             ResultSet rs = ps.executeQuery();
123             if(rs.next()){
124                 p = new Person();
125                 p.setId(id);
126                 p.setName(rs.getString(1));
127                 p.setAge(rs.getInt(2));
128                 p.setDescription(rs.getString(3));
129                 //把 java.sql.Date 与 java.util.Date之间的转换
130 //                java.util.Date date = rs.getDate(4);
131 //                ps.setDate(4, new java.sql.Date(date.getTime()));
132                 
133             }
134             rs.close();
135             ps.close();
136             conn.close();
137             
138             
139         } catch (ClassNotFoundException e) {
140             e.printStackTrace();
141         } catch (SQLException e) {
142             e.printStackTrace();
143         }
144         return p;
145     }
146     
147 
148 }

java.sql.resultset方法与使用技巧

public interface ResultSet

表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。

ResultSet 对象具有指向其当前数据行的指针。最初，指针被置于第一行之前。next 方法将指针移动到下一行；因为该方法在 ResultSet 对象中没有下一行时返回 false，所以可以在 while 循环中使用它来迭代结果集。

默认的 ResultSet 对象不可更新，仅有一个向前移动的指针。因此，只能迭代它一次，并且只能按从第一行到最后一行的顺序进行。可以生成可滚动和/或可更新的 ResultSet 对象。以下代码片段（其中 con 为有效的 Connection 对象）演示了如何生成可滚动且不受其他更新影响的、可更新的结果集。请参阅 ResultSet 字段以了解其他选项。

       Statement stmt = con.createStatement(
                                      ResultSet.TYPE_SCROLL_INSENSITIVE,
                                      ResultSet.CONCUR_UPDATABLE);
       ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2");
       // rs will be scrollable, will not show changes made by others,
       // and will be updatable

ResultSet 接口提供用于从当前行检索列值的获取方法（getBoolean、getLong 等）。可以使用列的索引编号或列的名称检索值。一般情况下，使用列索引较为高效。列从 1 开始编号。为了获得最大的可移植性，应该按从左到右的顺序读取每行中的结果集列，而且每列只能读取一次。

对于获取方法，JDBC 驱动程序尝试将基础数据转换为在获取方法中指定的 Java 类型，并返回适当的 Java 值。JDBC 规范有一个表，显示允许的从 SQL 类型到供 ResultSet 获取方法使用的 Java 类型的映射关系。

用作获取方法的输入的列名称不区分大小写。用列名称调用获取方法时，如果多个列具有这一名称，则返回第一个匹配列的值。列名称选项在生成结果集的 SQL 查询中使用列名称时使用。对于没有在查询中显式命名的列，最好使用列编号。如果使用列名称，程序员无法保证名称实际所指的就是预期的列。

在 JDBC 2.0 API (JDK 1.2) 中，此接口添加了一组更新方法。关于获取方法参数的注释同样适用于更新方法的参数。

可以用以下两种方式使用更新方法：

更新当前行中的列值。在可滚动的 ResultSet 对象中，可以向前和向后移动指针，将其置于绝对位置或相对于当前行的位置。以下代码片段更新 ResultSet 对象 rs 的第五行中的 NAME 列，然后使用方法 updateRow 更新用于派生 rs 的数据源表。
```
       rs.absolute(5); // moves the cursor to the fifth row of rs
       rs.updateString("NAME", "AINSWORTH"); // updates the 
          // NAME column of row 5 to be AINSWORTH
       rs.updateRow(); // updates the row in the data source

 
```

将列值插入到插入行中。可更新的 ResultSet 对象具有一个与其关联的特殊行，该行用作构建要插入的行的暂存区域 (staging area)。以下代码片段将指针移动到插入行，构建一个三列的行，并使用方法 insertRow 将其插入到 rs 和数据源表中。

       rs.moveToInsertRow(); // moves cursor to the insert row
       rs.updateString(1, "AINSWORTH"); // updates the 
          // first column of the insert row to be AINSWORTH
       rs.updateInt(2,35); // updates the second column to be 35
       rs.updateBoolean(3, true); // updates the third column to true
       rs.insertRow();
       rs.moveToCurrentRow();

当生成 ResultSet 对象的 Statement 对象关闭、重新执行或用来从多个结果的序列检索下一个结果时，ResultSet 对象会自动关闭。

ResultSet 对象的列的编号、类型和属性由 ResultSet.getMetaData 方法返回的 ResulSetMetaData 对象提供。

另请参见：: Statement.executeQuery(java.lang.String), Statement.getResultSet(), ResultSetMetaData

字段摘要
`static int`	`CLOSE_CURSORS_AT_COMMIT` 该常量指示调用 `Connection.commit` 方法时应该关闭 `ResultSet` 对象。
`static int`	`CONCUR_READ_ONLY` 该常量指示不可以更新的 `ResultSet` 对象的并发模式。
`static int`	`CONCUR_UPDATABLE` 该常量指示可以更新的 `ResultSet` 对象的并发模式。
`static int`	`FETCH_FORWARD` 该常量指示将按正向（即从第一个到最后一个）处理结果集中的行。
`static int`	`FETCH_REVERSE` 该常量指示将按反向（即从最后一个到第一个）处理结果集中的行处理。
`static int`	`FETCH_UNKNOWN` 该常量指示结果集中的行的处理顺序未知。
`static int`	`HOLD_CURSORS_OVER_COMMIT` 该常量指示调用 `Connection.commit` 方法时不应关闭 `ResultSet` 对象。
`static int`	`TYPE_FORWARD_ONLY` 该常量指示指针只能向前移动的 `ResultSet` 对象的类型。
`static int`	`TYPE_SCROLL_INSENSITIVE` 该常量指示可滚动但通常不受其他的更改影响的 `ResultSet` 对象的类型。
`static int`	`TYPE_SCROLL_SENSITIVE` 该常量指示可滚动并且通常受其他的更改影响的 `ResultSet` 对象的类型。

方法摘要
`boolean`	`absolute(int row)` 将指针移动到此 `ResultSet` 对象的给定行编号。
`void`	`afterLast()` 将指针移动到此 `ResultSet` 对象的末尾，正好位于最后一行之后。
`void`	`beforeFirst()` 将指针移动到此 `ResultSet` 对象的开头，正好位于第一行之前。
`void`	`cancelRowUpdates()` 取消对 `ResultSet` 对象中的当前行所作的更新。
`void`	`clearWarnings()` 清除在此 `ResultSet` 对象上报告的所有警告。
`void`	`close()` 立即释放此 `ResultSet` 对象的数据库和 JDBC 资源，而不是等待该对象自动关闭时发生此操作。
`void`	`deleteRow()` 从此 `ResultSet` 对象和底层数据库中删除当前行。
`int`	`findColumn(String columnName)` 将给定的 `ResultSet` 列名称映射到其 `ResultSet` 列索引。
`boolean`	`first()` 将指针移动到此 `ResultSet` 对象的第一行。
`Array`	`getArray(int i)` 以 Java 编程语言中 `Array` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Array`	`getArray(String colName)` 以 Java 编程语言中 `Array` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`InputStream`	`getAsciiStream(int columnIndex)` 以 ASCII 字符流的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`InputStream`	`getAsciiStream(String columnName)` 以 ASCII 字符流的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`BigDecimal`	`getBigDecimal(int columnIndex)` 以具有全精度的 `java.math.BigDecimal` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`BigDecimal`	`getBigDecimal(int columnIndex, int scale)` 已过时。
`BigDecimal`	`getBigDecimal(String columnName)` 以具有全精度的 `java.math.BigDecimal` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`BigDecimal`	`getBigDecimal(String columnName, int scale)` 已过时。
`InputStream`	`getBinaryStream(int columnIndex)` 以未解释字节的二进制流的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`InputStream`	`getBinaryStream(String columnName)` 以未解释的 `byte` 流的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Blob`	`getBlob(int i)` 以 Java 编程语言中 `Blob` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Blob`	`getBlob(String colName)` 以 Java 编程语言中 `Blob` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`boolean`	`getBoolean(int columnIndex)` 以 Java 编程语言中 `boolean` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`boolean`	`getBoolean(String columnName)` 以 Java 编程语言中 `boolean` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`byte`	`getByte(int columnIndex)` 以 Java 编程语言中 `byte` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`byte`	`getByte(String columnName)` 以 Java 编程语言中 `byte` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`byte[]`	`getBytes(int columnIndex)` 以 Java 编程语言中 `byte` 数组的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`byte[]`	`getBytes(String columnName)` 以 Java 编程语言中 `byte` 数组的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Reader`	`getCharacterStream(int columnIndex)` 以 `java.io.Reader` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Reader`	`getCharacterStream(String columnName)` 以 `java.io.Reader` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Clob`	`getClob(int i)` 以 Java 编程语言中 `Clob` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Clob`	`getClob(String colName)` 以 Java 编程语言中 `Clob` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`int`	`getConcurrency()` 检索此 `ResultSet` 对象的并发模式。
`String`	`getCursorName()` 检索此 `ResultSet` 对象使用的 SQL 指针的名称。
`Date`	`getDate(int columnIndex)` 以 Java 编程语言中 `java.sql.Date` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Date`	`getDate(int columnIndex, Calendar cal)` 以 Java 编程语言中 `java.sql.Date` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Date`	`getDate(String columnName)` 以 Java 编程语言中的 `java.sql.Date` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Date`	`getDate(String columnName, Calendar cal)` 以 Java 编程语言中 `java.sql.Date` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`double`	`getDouble(int columnIndex)` 以 Java 编程语言中 `double` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`double`	`getDouble(String columnName)` 以 Java 编程语言中 `double` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`int`	`getFetchDirection()` 检索此 `ResultSet` 对象的获取方向。
`int`	`getFetchSize()` 检索此 `ResultSet` 对象的获取大小。
`float`	`getFloat(int columnIndex)` 以 Java 编程语言中 `float` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`float`	`getFloat(String columnName)` 以 Java 编程语言中 `float` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`int`	`getInt(int columnIndex)` 以 Java 编程语言中 `int` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`int`	`getInt(String columnName)` 以 Java 编程语言中 `int` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`long`	`getLong(int columnIndex)` 以 Java 编程语言中 `long` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`long`	`getLong(String columnName)` 以 Java 编程语言中 `long` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`ResultSetMetaData`	`getMetaData()` 检索此 `ResultSet` 对象的列的编号、类型和属性。
`Object`	`getObject(int columnIndex)` 以 Java 编程语言中 `Object` 的形式获取此 `ResultSet` 对象的当前行中指定列的值。
`Object`	`getObject(int i, Map<String,Class<?>> map)` 以 Java 编程语言中 `Object` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Object`	`getObject(String columnName)` 以 Java 编程语言中 `Object` 的形式获取此 `ResultSet` 对象的当前行中指定列的值。
`Object`	`getObject(String colName, Map<String,Class<?>> map)` 以 Java 编程语言中 `Object` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Ref`	`getRef(int i)` 以 Java 编程语言中 `Ref` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Ref`	`getRef(String colName)` 以 Java 编程语言中 `Ref` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`int`	`getRow()` 检索当前行编号。
`short`	`getShort(int columnIndex)` 以 Java 编程语言中 `short` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`short`	`getShort(String columnName)` 以 Java 编程语言中 `short` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Statement`	`getStatement()` 检索生成此 `ResultSet` 对象的 `Statement` 对象。
`String`	`getString(int columnIndex)` 以 Java 编程语言中 `String` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`String`	`getString(String columnName)` 以 Java 编程语言中 `String` 的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Time`	`getTime(int columnIndex)` 以 Java 编程语言中 `java.sql.Time` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Time`	`getTime(int columnIndex, Calendar cal)` 以 Java 编程语言中 `java.sql.Time` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Time`	`getTime(String columnName)` 以 Java 编程语言中 `java.sql.Time` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Time`	`getTime(String columnName, Calendar cal)` 以 Java 编程语言中 `java.sql.Time` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Timestamp`	`getTimestamp(int columnIndex)` 以 Java 编程语言中 `java.sql.Timestamp` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Timestamp`	`getTimestamp(int columnIndex, Calendar cal)` 以 Java 编程语言中 `java.sql.Timestamp` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Timestamp`	`getTimestamp(String columnName)` 以 `java.sql.Timestamp` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`Timestamp`	`getTimestamp(String columnName, Calendar cal)` 以 Java 编程语言中 `java.sql.Timestamp` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`int`	`getType()` 检索此 `ResultSet` 对象的类型。
`InputStream`	`getUnicodeStream(int columnIndex)` 已过时。使用 `getCharacterStream` 取代 `getUnicodeStream`
`InputStream`	`getUnicodeStream(String columnName)` 已过时。使用 `getCharacterStream` 代替
`URL`	`getURL(int columnIndex)` 以 Java 编程语言中 `java.net.URL` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`URL`	`getURL(String columnName)` 以 Java 编程语言中 `java.net.URL` 对象的形式检索此 `ResultSet` 对象的当前行中指定列的值。
`SQLWarning`	`getWarnings()` 检索此 `ResultSet` 对象上的调用报告的第一个警告。
`void`	`insertRow()` 将插入行的内容插入到此 `ResultSet` 对象和数据库中。
`boolean`	`isAfterLast()` 检索指针是否位于此 `ResultSet` 对象的最后一行之后。
`boolean`	`isBeforeFirst()` 检索指针是否位于此 `ResultSet` 对象的第一行之前。
`boolean`	`isFirst()` 检索指针是否位于此 `ResultSet` 对象的第一行。
`boolean`	`isLast()` 检索指针是否位于此 `ResultSet` 对象的最后一行。
`boolean`	`last()` 将指针移动到此 `ResultSet` 对象的最后一行。
`void`	`moveToCurrentRow()` 将指针移动到记住的指针位置，通常为当前行。
`void`	`moveToInsertRow()` 将指针移动到插入行。
`boolean`	`next()` 将指针从当前位置下移一行。
`boolean`	`previous()` 将指针移动到此 `ResultSet` 对象的上一行。
`void`	`refreshRow()` 用数据库中的最近值刷新当前行。
`boolean`	`relative(int rows)` 按相对行数（或正或负）移动指针。
`boolean`	`rowDeleted()` 检索是否已删除某行。
`boolean`	`rowInserted()` 检索当前行是否已有插入。
`boolean`	`rowUpdated()` 检索是否已更新当前行。
`void`	`setFetchDirection(int direction)` 设置此 `ResultSet` 对象中行的处理方向。
`void`	`setFetchSize(int rows)` 为 JDBC 驱动程序设置此 `ResultSet` 对象需要更多行时应该从数据库获取的行数。
`void`	`updateArray(int columnIndex, Array x)` 用 `java.sql.Array` 值更新指定列。
`void`	`updateArray(String columnName, Array x)` 用 `java.sql.Array` 值更新指定列。
`void`	`updateAsciiStream(int columnIndex, InputStream x, int length)` 用 ascii 流值更新指定列。
`void`	`updateAsciiStream(String columnName, InputStream x, int length)` 用 ascii 流值更新指定列。
`void`	`updateBigDecimal(int columnIndex, BigDecimal x)` 用 `java.math.BigDecimal` 值更新指定列。
`void`	`updateBigDecimal(String columnName, BigDecimal x)` 用 `java.sql.BigDecimal` 值更新指定列。
`void`	`updateBinaryStream(int columnIndex, InputStream x, int length)` 用二进制流值更新指定列。
`void`	`updateBinaryStream(String columnName, InputStream x, int length)` 用二进制流值更新指定列。
`void`	`updateBlob(int columnIndex, Blob x)` 用 `java.sql.Blob` 值更新指定列。
`void`	`updateBlob(String columnName, Blob x)` 用 `java.sql.Blob` 值更新指定列。
`void`	`updateBoolean(int columnIndex, boolean x)` 用 `boolean` 值更新指定列。
`void`	`updateBoolean(String columnName, boolean x)` 用 `boolean` 值更新指定列。
`void`	`updateByte(int columnIndex, byte x)` 用 `byte` 值更新指定列。
`void`	`updateByte(String columnName, byte x)` 用 `byte` 值更新指定列。
`void`	`updateBytes(int columnIndex, byte[] x)` 用 `byte` 数组值更新指定列。
`void`	`updateBytes(String columnName, byte[] x)` 用字节数组值更新指定列。
`void`	`updateCharacterStream(int columnIndex, Reader x, int length)` 用字符流值更新指定列。
`void`	`updateCharacterStream(String columnName, Reader reader, int length)` 用字符流值更新指定列。
`void`	`updateClob(int columnIndex, Clob x)` 用 `java.sql.Clob` 值更新指定列。
`void`	`updateClob(String columnName, Clob x)` 用 `java.sql.Clob` 值更新指定列。
`void`	`updateDate(int columnIndex, Date x)` 用 `java.sql.Date` 值更新指定列。
`void`	`updateDate(String columnName, Date x)` 用 `java.sql.Date` 值更新指定列。
`void`	`updateDouble(int columnIndex, double x)` 用 `double` 值更新指定列。
`void`	`updateDouble(String columnName, double x)` 用 `double` 值更新指定列。
`void`	`updateFloat(int columnIndex, float x)` 用 `float` 值更新指定列。
`void`	`updateFloat(String columnName, float x)` 用 `float` 值更新指定列。
`void`	`updateInt(int columnIndex, int x)` 用 `int` 值更新指定列。
`void`	`updateInt(String columnName, int x)` 用 `int` 值更新指定列。
`void`	`updateLong(int columnIndex, long x)` 用 `long` 值更新指定列。
`void`	`updateLong(String columnName, long x)` 用 `long` 值更新指定列。
`void`	`updateNull(int columnIndex)` 为可以为 null 的列提供 null 值。
`void`	`updateNull(String columnName)` 用 `null` 值更新指定列。
`void`	`updateObject(int columnIndex, Object x)` 用 `Object` 值更新指定列。
`void`	`updateObject(int columnIndex, Object x, int scale)` 用 `Object` 值更新指定列。
`void`	`updateObject(String columnName, Object x)` 用 `Object` 值更新指定列。
`void`	`updateObject(String columnName, Object x, int scale)` 用 `Object` 值更新指定列。
`void`	`updateRef(int columnIndex, Ref x)` 用 `java.sql.Ref` 值更新指定列。
`void`	`updateRef(String columnName, Ref x)` 用 `java.sql.Ref` 值更新指定列。
`void`	`updateRow()` 用此 `ResultSet` 对象的当前行的新内容更新底层数据库。
`void`	`updateShort(int columnIndex, short x)` 用 `short` 值更新指定列。
`void`	`updateShort(String columnName, short x)` 用 `short` 值更新指定列。
`void`	`updateString(int columnIndex, String x)` 用 `String` 值更新指定列。
`void`	`updateString(String columnName, String x)` 用 `String` 值更新指定列。
`void`	`updateTime(int columnIndex, Time x)` 用 `java.sql.Time` 值更新指定列。
`void`	`updateTime(String columnName, Time x)` 用 `java.sql.Time` 值更新指定列。
`void`	`updateTimestamp(int columnIndex, Timestamp x)` 用 `java.sql.Timestamp` 值更新指定列。
`void`	`updateTimestamp(String columnName, Timestamp x)` 用 `java.sql.Timestamp` 值更新指定列。
`boolean`	`wasNull()` 报告最后一个读取的列是否具有值 SQL `NULL`。

字段详细信息

FETCH_FORWARD

static final int FETCH_FORWARD

该常量指示将按正向（即从第一个到最后一个）处理结果集中的行。setFetchDirection 方法将此常量用作驱动程序的提示，驱动程序可能忽略它。

从以下版本开始：: 1.2
另请参见：: 常量字段值

FETCH_REVERSE

static final int FETCH_REVERSE

该常量指示将按反向（即从最后一个到第一个）处理结果集中的行处理。setFetchDirection 方法将此常量用作驱动程序的提示，驱动程序可能忽略它。

从以下版本开始：: 1.2
另请参见：: 常量字段值

FETCH_UNKNOWN

static final int FETCH_UNKNOWN

该常量指示结果集中的行的处理顺序未知。setFetchDirection 方法将此常量用作驱动程序的提示，驱动程序可能忽略它。

另请参见：: 常量字段值

TYPE_FORWARD_ONLY

static final int TYPE_FORWARD_ONLY

该常量指示指针只能向前移动的 ResultSet 对象的类型。

从以下版本开始：: 1.2
另请参见：: 常量字段值

TYPE_SCROLL_INSENSITIVE

static final int TYPE_SCROLL_INSENSITIVE

该常量指示可滚动但通常不受其他的更改影响的 ResultSet 对象的类型。

从以下版本开始：: 1.2
另请参见：: 常量字段值

TYPE_SCROLL_SENSITIVE

static final int TYPE_SCROLL_SENSITIVE

该常量指示可滚动并且通常受其他的更改影响的 ResultSet 对象的类型。

从以下版本开始：: 1.2
另请参见：: 常量字段值

CONCUR_READ_ONLY

static final int CONCUR_READ_ONLY

该常量指示不可以更新的 ResultSet 对象的并发模式。

从以下版本开始：: 1.2
另请参见：: 常量字段值

CONCUR_UPDATABLE

static final int CONCUR_UPDATABLE

该常量指示可以更新的 ResultSet 对象的并发模式。

从以下版本开始：: 1.2
另请参见：: 常量字段值

HOLD_CURSORS_OVER_COMMIT

static final int HOLD_CURSORS_OVER_COMMIT

该常量指示调用 Connection.commit 方法时不应关闭 ResultSet 对象。

从以下版本开始：: 1.4
另请参见：: 常量字段值

CLOSE_CURSORS_AT_COMMIT

static final int CLOSE_CURSORS_AT_COMMIT

该常量指示调用 Connection.commit 方法时应该关闭 ResultSet 对象。

从以下版本开始：: 1.4
另请参见：: 常量字段值

方法详细信息

boolean next()
             throws SQLException

将指针从当前位置下移一行。ResultSet 指针最初位于第一行之前；第一次调用 next 方法使第一行成为当前行；第二次调用使第二行成为当前行，依此类推。

如果开启了对当前行的输入流，则调用 next 方法将隐式关闭它。读取新行时，将清除 ResultSet 对象的警告链。

返回：: 如果新的当前行有效，则返回 true；如果不存在下一行，则返回 false
抛出：: SQLException - 如果发生数据库访问错误

close

void close()
           throws SQLException

立即释放此 ResultSet 对象的数据库和 JDBC 资源，而不是等待该对象自动关闭时发生此操作。

注：当生成 ResultSet 对象的 Statement 对象关闭、重新执行或用来从多个结果的序列检索下一个结果时，该 Statement 对象会自动关闭 ResultSet 对象。垃圾回收 ResultSet 对象时它也会自动关闭。

抛出：: SQLException - 如果发生数据库访问错误

wasNull

boolean wasNull()
                throws SQLException

报告最后一个读取的列是否具有值 SQL NULL。注意，必须首先对列调用一个获取方法来尝试读取其值，然后调用 wasNull 方法查看读取的值是否为 SQL NULL。

返回：: 如果最后一个读取的列值为 SQL NULL，则返回 true；否则返回 false
抛出：: SQLException - 如果发生数据库访问错误

getString

String getString(int columnIndex)
                 throws SQLException

以 Java 编程语言中 String 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getBoolean

boolean getBoolean(int columnIndex)
                   throws SQLException

以 Java 编程语言中 boolean 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 false
抛出：: SQLException - 如果发生数据库访问错误

getByte

byte getByte(int columnIndex)
             throws SQLException

以 Java 编程语言中 byte 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getShort

short getShort(int columnIndex)
               throws SQLException

以 Java 编程语言中 short 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getInt

int getInt(int columnIndex)
           throws SQLException

以 Java 编程语言中 int 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getLong

long getLong(int columnIndex)
             throws SQLException

以 Java 编程语言中 long 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getFloat

float getFloat(int columnIndex)
               throws SQLException

以 Java 编程语言中 float 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getDouble

double getDouble(int columnIndex)
                 throws SQLException

以 Java 编程语言中 double 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getBigDecimal

@Deprecated
BigDecimal getBigDecimal(int columnIndex,
                                    int scale)
                         throws SQLException

已过时。

以 Java 编程语言中 java.sql.BigDecimal 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; scale - 小数点右边的位数
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getBytes

byte[] getBytes(int columnIndex)
                throws SQLException

以 Java 编程语言中 byte 数组的形式检索此 ResultSet 对象的当前行中指定列的值。这些字节表示驱动程序返回的原始值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getDate

Date getDate(int columnIndex)
             throws SQLException

以 Java 编程语言中 java.sql.Date 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getTime

Time getTime(int columnIndex)
             throws SQLException

以 Java 编程语言中 java.sql.Time 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getTimestamp

Timestamp getTimestamp(int columnIndex)
                       throws SQLException

以 Java 编程语言中 java.sql.Timestamp 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getAsciiStream

InputStream getAsciiStream(int columnIndex)
                           throws SQLException

以 ASCII 字符流的形式检索此 ResultSet 对象的当前行中指定列的值。然后，可以按块从流中读取值。此方法尤其适合于检索很大的 LONGVARCHAR 值。JDBC 驱动程序将执行从数据库格式到 ASCII 的任何必要转换。

注：在获取任何其他列的值之前必须读取返回流中的所有数据。下一次调用获取方法将隐式关闭该流。此外，当调用 InputStream.available 方法时，不管是否存在可用数据，流都可能返回 0。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 以一字节 ASCII 字符流的形式返回传递数据库列值的 Java 输入流；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getUnicodeStream

@Deprecated
InputStream getUnicodeStream(int columnIndex)
                             throws SQLException

已过时。 使用 getCharacterStream 取代 getUnicodeStream

以两字节 Unicode 字符流的形式检索此 ResultSet 对象的当前行中指定列的值。第一个字节是高字节；第二个字节是低字节。然后，可以按块从流中读取值。此方法尤其适合于检索很大的 LONGVARCHAR 值。JDBC 驱动程序将执行从数据库格式到 Unicode 的任何必要转换。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 以两字节 Unicode 字符流的形式返回传递数据库列值的 Java 输入流；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getBinaryStream

InputStream getBinaryStream(int columnIndex)
                            throws SQLException

以未解释字节的二进制流的形式检索此 ResultSet 对象的当前行中指定列的值。然后，可以按块从流中读取值。此方法尤其适合于检索很大的 LONGVARBINARY 值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 以未解释字节的流的形式返回传递数据库列值的 Java 输入流；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getString

String getString(String columnName)
                 throws SQLException

以 Java 编程语言中 String 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getBoolean

boolean getBoolean(String columnName)
                   throws SQLException

以 Java 编程语言中 boolean 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 false
抛出：: SQLException - 如果发生数据库访问错误

getByte

byte getByte(String columnName)
             throws SQLException

以 Java 编程语言中 byte 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getShort

short getShort(String columnName)
               throws SQLException

以 Java 编程语言中 short 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getInt

int getInt(String columnName)
           throws SQLException

以 Java 编程语言中 int 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getLong

long getLong(String columnName)
             throws SQLException

以 Java 编程语言中 long 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getFloat

float getFloat(String columnName)
               throws SQLException

以 Java 编程语言中 float 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getDouble

double getDouble(String columnName)
                 throws SQLException

以 Java 编程语言中 double 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 0
抛出：: SQLException - 如果发生数据库访问错误

getBigDecimal

@Deprecated
BigDecimal getBigDecimal(String columnName,
                                    int scale)
                         throws SQLException

已过时。

以 Java 编程语言中 java.math.BigDecimal 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称; scale - 小数点右边的位数
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getBytes

byte[] getBytes(String columnName)
                throws SQLException

以 Java 编程语言中 byte 数组的形式检索此 ResultSet 对象的当前行中指定列的值。这些字节表示驱动程序返回的原始值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getDate

Date getDate(String columnName)
             throws SQLException

以 Java 编程语言中的 java.sql.Date 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getTime

Time getTime(String columnName)
             throws SQLException

以 Java 编程语言中 java.sql.Time 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getTimestamp

Timestamp getTimestamp(String columnName)
                       throws SQLException

以 java.sql.Timestamp 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: 列值；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getAsciiStream

InputStream getAsciiStream(String columnName)
                           throws SQLException

以 ASCII 字符流的形式检索此 ResultSet 对象的当前行中指定列的值。然后，可以按块从流中读取值。此方法尤其适合于检索很大的 LONGVARCHAR 值。JDBC 驱动程序将执行从数据库格式到 ASCII 的任何必要转换。

注：在获取任何其他列的值之前必须读取返回流中的所有数据。下一次调用获取方法将隐式关闭该流。此外，当调用 available 方法时，不管是否存在可用数据，流都可能返回 0。

参数：: columnName - 列的 SQL 名称
返回：: 以一字节 ASCII 字符流的形式返回传递数据库列值的 Java 输入流。如果值为 SQL NULL，则返回值为 null。
抛出：: SQLException - 如果发生数据库访问错误

getUnicodeStream

@Deprecated
InputStream getUnicodeStream(String columnName)
                             throws SQLException

已过时。 使用 getCharacterStream 代替

以两字节 Unicode 字符流的形式检索此 ResultSet 对象的当前行中指定列的值。第一个字节是高字节；第二个字节是低字节。然后，可以按块从流中读取值。此方法尤其适合于检索很大的 LONGVARCHAR 值。采用 JDBC 技术的驱动程序将执行从数据库格式到 Unicode 的任何必要转换。

参数：: columnName - 列的 SQL 名称
返回：: 以两字节 Unicode 字符流的形式返回传递数据库列值的 Java 输入流。如果值为 SQL NULL，则返回值为 null。
抛出：: SQLException - 如果发生数据库访问错误

getBinaryStream

InputStream getBinaryStream(String columnName)
                            throws SQLException

以未解释的 byte 流的形式检索此 ResultSet 对象的当前行中指定列的值。然后可以按块从流中读取该值。此方法尤其适合于检索很大的 LONGVARBINARY 值。

参数：: columnName - 列的 SQL 名称
返回：: 以未解释字节流的形式返回传递数据库列值的 Java 输入流；如果值为 SQL NULL，则返回值为 null
抛出：: SQLException - 如果发生数据库访问错误

getWarnings

SQLWarning getWarnings()
                       throws SQLException

检索此 ResultSet 对象上的调用报告的第一个警告。此 ResultSet 对象上的后续警告会被链接到此方法返回的 SQLWarning 对象。

每次读取新行时，都会自动清除警告链。不可以在已经关闭的 ResultSet 对象上调用此方法；这样做将导致抛出 SQLException。

注：此警告链仅包含 ResultSet 方法产生的警告。Statement 方法（如读取 OUT 参数）产生的任何警告都将链接在 Statement 对象上。

返回：: 报告的第一个 SQLWarning 对象；如果不存在，则返回 null
抛出：: SQLException - 如果发生数据库访问错误或者在关闭的结果集上调用此方法

clearWarnings

void clearWarnings()
                   throws SQLException

清除在此 ResultSet 对象上报告的所有警告。调用此方法后，在为此 ResultSet 对象报告新的警告之前，getWarnings 方法将返回 null。

抛出：: SQLException - 如果发生数据库访问错误

getCursorName

String getCursorName()
                     throws SQLException

检索此 ResultSet 对象使用的 SQL 指针的名称。

在 SQL 中，通过命名的指针检索结果表。通过一个引用指针名称来确定位置的更新/删除语句，可以更新或删除结果集的当前行。为了确保指针具有支持更新的适当隔离级别，指针的 SELECT 语句的形式应该为 SELECT FOR UPDATE。如果省略 FOR UPDATE，则定位更新可能失败。

JDBC API 通过提供 ResultSet 对象使用的 SQL 指针的名称支持此 SQL 功能。ResultSet 对象的当前行也是此 SQL 指针的当前行。

注：如果不支持定位更新，则抛出 SQLException。

返回：: 此 ResultSet 对象的指针的 SQL 名称
抛出：: SQLException - 如果发生数据库访问错误

getMetaData

ResultSetMetaData getMetaData()
                              throws SQLException

检索此 ResultSet 对象的列的编号、类型和属性。

返回：: 此 ResultSet 对象的列的描述
抛出：: SQLException - 如果发生数据库访问错误

getObject

Object getObject(int columnIndex)
                 throws SQLException

以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。

此方法将以 Java 对象的形式返回给定列的值。Java 对象的类型将为与该列的 SQL 类型相对应的默认 Java 对象类型，它遵守在 JDBC 规范中指定的内置类型的映射关系。如果值为 SQL NULL，则驱动程序返回一个 Java null。

此方法还可用于读取特定于数据库的抽象数据类型。在 JDBC 2.0 API 中，可以扩展 getObject 方法的行为来实现 SQL 自定义类型的数据。当列包含结构化的或独特的值时，此方法的行为类似于调用：getObject(columnIndex, this.getStatement().getConnection().getTypeMap())。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 保存列值的 java.lang.Object
抛出：: SQLException - 如果发生数据库访问错误

getObject

Object getObject(String columnName)
                 throws SQLException

以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。

此方法还可用于读取特定于数据库的抽象数据类型。

在 JDBC 2.0 API 中，可以扩展 getObject 方法的行为来实现 SQL 自定义类型的数据。当列包含结构化的或独特的值时，此方法的行为类似于调用：getObject(columnIndex, this.getStatement().getConnection().getTypeMap())。

参数：: columnName - 列的 SQL 名称
返回：: 保存列值的 java.lang.Object
抛出：: SQLException - 如果发生数据库访问错误

findColumn

int findColumn(String columnName)
               throws SQLException

将给定的 ResultSet 列名称映射到其 ResultSet 列索引。

参数：: columnName - 列的名称
返回：: 给定列名称的列索引
抛出：: SQLException - 如果 ResultSet 对象不包含 columnName 或者发生数据库访问错误

getCharacterStream

Reader getCharacterStream(int columnIndex)
                          throws SQLException

以 java.io.Reader 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 包含列值的 java.io.Reader 对象；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null。
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getCharacterStream

Reader getCharacterStream(String columnName)
                          throws SQLException

以 java.io.Reader 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的名称
返回：: 包含列值的 java.io.Reader 对象；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getBigDecimal

BigDecimal getBigDecimal(int columnIndex)
                         throws SQLException

以具有全精度的 java.math.BigDecimal 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
返回：: 列值（全精度）；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null。
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getBigDecimal

BigDecimal getBigDecimal(String columnName)
                         throws SQLException

以具有全精度的 java.math.BigDecimal 的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列名称
返回：: 列值（全精度）；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null。
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

isBeforeFirst

boolean isBeforeFirst()
                      throws SQLException

检索指针是否位于此 ResultSet 对象的第一行之前。

返回：: 如果指针位于第一行之前，则返回 true；如果指针位于任何其他位置或者结果集不包含任何行，则返回 false
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

isAfterLast

boolean isAfterLast()
                    throws SQLException

检索指针是否位于此 ResultSet 对象的最后一行之后。

返回：: 如果指针位于最后一行之后，则返回 true；如果指针位于任何其他位置或者结果集不包含任何行，则返回 false
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

isFirst

boolean isFirst()
                throws SQLException

检索指针是否位于此 ResultSet 对象的第一行。

返回：: 如果指针位于第一行，则返回 true；否则返回 false
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

isLast

boolean isLast()
               throws SQLException

检索指针是否位于此 ResultSet 对象的最后一行。注：调用 isLast 方法可能开销很大，因为 JDBC 驱动程序可能需要再往后获取一行，以确定当前行是否为结果集中的最后一行。

返回：: 如果指针位于最后一行上，则返回 true；否则返回 false
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

beforeFirst

void beforeFirst()
                 throws SQLException

将指针移动到此 ResultSet 对象的开头，正好位于第一行之前。如果结果集中不包含任何行，则此方法无效。

抛出：: SQLException - 如果发生数据库访问错误或者结果集类型为 TYPE_FORWARD_ONLY
从以下版本开始：: 1.2

afterLast

void afterLast()
               throws SQLException

将指针移动到此 ResultSet 对象的末尾，正好位于最后一行之后。如果结果集中不包含任何行，则此方法无效。

抛出：: SQLException - 如果发生数据库访问错误或者结果集类型为 TYPE_FORWARD_ONLY
从以下版本开始：: 1.2

first

boolean first()
              throws SQLException

将指针移动到此 ResultSet 对象的第一行。

返回：: 如果指针位于有效行，则返回 true；如果结果集中不存在任何行，则返回 false
抛出：: SQLException - 如果发生数据库访问错误或者结果集类型为 TYPE_FORWARD_ONLY
从以下版本开始：: 1.2

last

boolean last()
             throws SQLException

将指针移动到此 ResultSet 对象的最后一行。

返回：: 如果指针位于有效行，则返回 true；如果结果集中不存在任何行，则返回 false
抛出：: SQLException - 如果发生数据库访问错误或者结果集类型为 TYPE_FORWARD_ONLY
从以下版本开始：: 1.2

getRow

int getRow()
           throws SQLException

检索当前行编号。第一行为 1 号，第二行为 2 号，依此类推。

返回：: 当前行的编号；如果不存在当前行，则返回 0
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

absolute

boolean absolute(int row)
                 throws SQLException

将指针移动到此 ResultSet 对象的给定行编号。

如果行编号为正，则将指针移动到相对于结果集开头的给定行编号。第一行为行 1，第二行为行 2，依此类推。

如果给定行编号为负，则将指针移动到相对于结果集末尾的绝对行位置。例如，调用方法 absolute(-1) 将指针置于最后一行；调用方法 absolute(-2) 将指针移动到倒数第二行，依此类推。

试图将指针置于结果集的第一行/最后一行之外将导致指针位于第一行之前或最后一行之后。

注：调用 absolute(1) 等效于调用 first()。调用 absolute(-1) 等效于调用 last()。

参数：: row - 指针应该移动到的行的编号。正的编号指示从结果集开头开始计数的行编号；负的编号指示从结果集末尾开始计数的行编号
返回：: 如果指针位于结果集上，则返回 true；否则返回 false
抛出：: SQLException - 如果发生数据库访问错误或者结果集类型为 TYPE_FORWARD_ONLY
从以下版本开始：: 1.2

relative

boolean relative(int rows)
                 throws SQLException

按相对行数（或正或负）移动指针。试图移动到结果集的第一行/最后一行之外，会将指针置于第一行之前或最后一行之后。调用 relative(0) 有效，但是不更改指针位置。

注：调用方法 relative(1) 等效于调用方法 next()，而调用方法 relative(-1) 等效于调用方法 previous()。

参数：: rows - 指定从当前行开始移动的行数的 int；正数表示指针向前移动；负数表示指针向后移动
返回：: 如果指针位于行上，则返回 true；否则返回 false
抛出：: SQLException - 如果发生数据库访问错误、不存在当前行或者结果集类型为 TYPE_FORWARD_ONLY
从以下版本开始：: 1.2

boolean previous()
                 throws SQLException

将指针移动到此 ResultSet 对象的上一行。

返回：: 如果指针位于有效行上，则返回 true；如果它不在结果集中，则返回 false
抛出：: SQLException - 如果发生数据库访问错误或者结果集类型为 TYPE_FORWARD_ONLY
从以下版本开始：: 1.2

setFetchDirection

void setFetchDirection(int direction)
                       throws SQLException

设置此 ResultSet 对象中行的处理方向。初始值由生成此 ResultSet 对象的 Statement 对象确定。获取方向可以在任何时间更改。

参数：: direction - 指定建议获取方向的 int；ResultSet.FETCH_FORWARD、ResultSet.FETCH_REVERSE 或 ResultSet.FETCH_UNKNOWN 之一
抛出：: SQLException - 如果发生数据库访问错误，或者结果集类型为 TYPE_FORWARD_ONLY 但获取方向不是 FETCH_FORWARD
从以下版本开始：: 1.2
另请参见：: Statement.setFetchDirection(int), getFetchDirection()

getFetchDirection

int getFetchDirection()
                      throws SQLException

检索此 ResultSet 对象的获取方向。

返回：: 此 ResultSet 对象的当前获取方向
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2
另请参见：: setFetchDirection(int)

setFetchSize

void setFetchSize(int rows)
                  throws SQLException

为 JDBC 驱动程序设置此 ResultSet 对象需要更多行时应该从数据库获取的行数。如果指定的获取大小为零，则 JDBC 驱动程序忽略该值，随意对获取大小作出它自己的最佳猜测。默认值由创建结果集的 Statement 对象设置。获取大小可以在任何时间更改。

参数：: rows - 要获取的行数
抛出：: SQLException - 如果发生数据库访问错误或者不满足条件 0 <= rows <= Statement.getMaxRows()
从以下版本开始：: 1.2
另请参见：: getFetchSize()

getFetchSize

int getFetchSize()
                 throws SQLException

检索此 ResultSet 对象的获取大小。

返回：: 此 ResultSet 对象的当前获取大小
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2
另请参见：: setFetchSize(int)

getType

int getType()
            throws SQLException

检索此 ResultSet 对象的类型。类型由创建结果集的 Statement 对象确定。

返回：: ResultSet.TYPE_FORWARD_ONLY、ResultSet.TYPE_SCROLL_INSENSITIVE 或 ResultSet.TYPE_SCROLL_SENSITIVE
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getConcurrency

int getConcurrency()
                   throws SQLException

检索此 ResultSet 对象的并发模式。使用的并发由创建结果集的 Statement 对象确定。

返回：: 并发类型，ResultSet.CONCUR_READ_ONLY 或 ResultSet.CONCUR_UPDATABLE
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

rowUpdated

boolean rowUpdated()
                   throws SQLException

检索是否已更新当前行。返回值取决于结果集是否可以检测到更新。

返回：: 如果 (1) 所有者或其他人已对行进行可见更新 (2) 可以检测到更新都成立，则返回 true
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2
另请参见：: DatabaseMetaData.updatesAreDetected(int)

rowInserted

boolean rowInserted()
                    throws SQLException

检索当前行是否已有插入。返回值取决于此 ResultSet 对象是否可以检测到可见插入。

返回：: 如果行已有插入并且检测到插入，则返回 true；否则返回 false
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2
另请参见：: DatabaseMetaData.insertsAreDetected(int)

rowDeleted

boolean rowDeleted()
                   throws SQLException

检索是否已删除某行。删除的行可能在结果集中留下一个可见的“洞”。此方法可用于检测结果集中的洞。返回值取决于此 ResultSet 对象是否可以检测到删除。

返回：: 如果删除了行并且检测到删除，则返回 true；否则返回 false
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2
另请参见：: DatabaseMetaData.deletesAreDetected(int)

updateNull

void updateNull(int columnIndex)
                throws SQLException

为可以为 null 的列提供 null 值。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateBoolean

void updateBoolean(int columnIndex,
                   boolean x)
                   throws SQLException

用 boolean 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateByte

void updateByte(int columnIndex,
                byte x)
                throws SQLException

用 byte 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateShort

void updateShort(int columnIndex,
                 short x)
                 throws SQLException

用 short 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateInt

void updateInt(int columnIndex,
               int x)
               throws SQLException

用 int 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateLong

void updateLong(int columnIndex,
                long x)
                throws SQLException

用 long 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会不更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateFloat

void updateFloat(int columnIndex,
                 float x)
                 throws SQLException

用 float 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateDouble

void updateDouble(int columnIndex,
                  double x)
                  throws SQLException

用 double 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateBigDecimal

void updateBigDecimal(int columnIndex,
                      BigDecimal x)
                      throws SQLException

用 java.math.BigDecimal 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateString

void updateString(int columnIndex,
                  String x)
                  throws SQLException

用 String 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateBytes

void updateBytes(int columnIndex,
                 byte[] x)
                 throws SQLException

用 byte 数组值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateDate

void updateDate(int columnIndex,
                Date x)
                throws SQLException

用 java.sql.Date 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateTime

void updateTime(int columnIndex,
                Time x)
                throws SQLException

用 java.sql.Time 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateTimestamp

void updateTimestamp(int columnIndex,
                     Timestamp x)
                     throws SQLException

用 java.sql.Timestamp 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateAsciiStream

void updateAsciiStream(int columnIndex,
                       InputStream x,
                       int length)
                       throws SQLException

用 ascii 流值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值; length - 流的长度
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateBinaryStream

void updateBinaryStream(int columnIndex,
                        InputStream x,
                        int length)
                        throws SQLException

用二进制流值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值; length - 流的长度
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateCharacterStream

void updateCharacterStream(int columnIndex,
                           Reader x,
                           int length)
                           throws SQLException

用字符流值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值; length - 流的长度
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateObject

void updateObject(int columnIndex,
                  Object x,
                  int scale)
                  throws SQLException

用 Object 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值; scale - 对于 java.sql.Types.DECIMA 或 java.sql.Types.NUMERIC 类型，此参数是小数点后面的位数。对于其他所有类型，将忽略此值。
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateObject

void updateObject(int columnIndex,
                  Object x)
                  throws SQLException

用 Object 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateNull

void updateNull(String columnName)
                throws SQLException

用 null 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateBoolean

void updateBoolean(String columnName,
                   boolean x)
                   throws SQLException

用 boolean 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateByte

void updateByte(String columnName,
                byte x)
                throws SQLException

用 byte 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateShort

void updateShort(String columnName,
                 short x)
                 throws SQLException

用 short 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateInt

void updateInt(String columnName,
               int x)
               throws SQLException

用 int 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateLong

void updateLong(String columnName,
                long x)
                throws SQLException

用 long 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateFloat

void updateFloat(String columnName,
                 float x)
                 throws SQLException

用 float 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateDouble

void updateDouble(String columnName,
                  double x)
                  throws SQLException

用 double 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateBigDecimal

void updateBigDecimal(String columnName,
                      BigDecimal x)
                      throws SQLException

用 java.sql.BigDecimal 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateString

void updateString(String columnName,
                  String x)
                  throws SQLException

用 String 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateBytes

void updateBytes(String columnName,
                 byte[] x)
                 throws SQLException

用字节数组值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateDate

void updateDate(String columnName,
                Date x)
                throws SQLException

用 java.sql.Date 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateTime

void updateTime(String columnName,
                Time x)
                throws SQLException

用 java.sql.Time 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateTimestamp

void updateTimestamp(String columnName,
                     Timestamp x)
                     throws SQLException

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateAsciiStream

void updateAsciiStream(String columnName,
                       InputStream x,
                       int length)
                       throws SQLException

用 ascii 流值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值; length - 流的长度
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateBinaryStream

void updateBinaryStream(String columnName,
                        InputStream x,
                        int length)
                        throws SQLException

用二进制流值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值; length - 流的长度
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateCharacterStream

void updateCharacterStream(String columnName,
                           Reader reader,
                           int length)
                           throws SQLException

用字符流值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; reader - 包含新列值的 java.io.Reader 对象; length - 流的长度
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateObject

void updateObject(String columnName,
                  Object x,
                  int scale)
                  throws SQLException

用 Object 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值; scale - 对于 java.sql.Types.DECIMAL 或 java.sql.Types.NUMERIC 类型，此参数是小数点后面的位数。对于其他所有类型，将忽略此值。
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

updateObject

void updateObject(String columnName,
                  Object x)
                  throws SQLException

用 Object 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

insertRow

void insertRow()
               throws SQLException

将插入行的内容插入到此 ResultSet 对象和数据库中。调用此方法时，指针必须位于插入行上。

抛出：: SQLException - 如果发生数据库访问错误，如果在指针不位于插入行上时调用此方法，或者插入行中所有不可为 null 的列中还存在未分配值的列
从以下版本开始：: 1.2

updateRow

void updateRow()
               throws SQLException

用此 ResultSet 对象的当前行的新内容更新底层数据库。指针不位于插入行上时不能调用此方法。

抛出：: SQLException - 如果发生数据库访问错误或者在指针不位于插入行上时调用了此方法
从以下版本开始：: 1.2

deleteRow

void deleteRow()
               throws SQLException

从此 ResultSet 对象和底层数据库中删除当前行。指针不位于插入行上时不能调用此方法。

抛出：: SQLException - 如果发生数据库访问错误或者在指针不位于插入行上时调用了此方法
从以下版本开始：: 1.2

refreshRow

void refreshRow()
                throws SQLException

用数据库中的最近值刷新当前行。指针不位于插入行上时不能调用此方法。

refreshRow 方法提供一种让应用程序显式告知 JDBC 驱动程序从数据库重新获取行的方式。应用程序可能需要在 JDBC 驱动程序完成缓存或预获取操作后调用 refreshRow，以便从数据库获取行的最新值。如果获取大小大于 1，则 JDBC 驱动程序可以一次实际刷新多行。

应根据事务隔离级别和指针敏感度确定是否重新获取所有值。如果在调用更新方法之后，但在调用 updateRow 方法之前调用 refreshRow，则会丢失对行所作的更新。频繁调用方法 refreshRow 可能导致性能下降。

抛出：: SQLException - 如果发生数据库访问错误或者在指针不位于插入行上时调用了此方法
从以下版本开始：: 1.2

cancelRowUpdates

void cancelRowUpdates()
                      throws SQLException

取消对 ResultSet 对象中的当前行所作的更新。此方法在调用更新方法之后，但在调用 updateRow 方法之前调用才可以回滚对行所作的更新。如果没有进行任何更新或者已经调用 updateRow 方法，则此方法无效。

抛出：: SQLException - 如果发生数据库访问错误或者在指针不位于插入行上时调用了此方法
从以下版本开始：: 1.2

moveToInsertRow

void moveToInsertRow()
                     throws SQLException

将指针移动到插入行。将指针置于插入行上时，当前的指针位置会被记住。插入行是一个与可更新结果集相关联的特殊行。它实际上是一个缓冲区，在将行插入到结果集前可以通过调用更新方法在其中构造新行。当指针位于插入行上时，仅能调用更新方法、获取方法以及 insertRow 方法。每次在调用 insertRow 之前调用此方法时，必须为结果集中的所有列分配值。在对列值调用获取方法之前，必须调用更新方法。

抛出：: SQLException - 如果发生数据库访问错误或者结果集不可更新
从以下版本开始：: 1.2

moveToCurrentRow

void moveToCurrentRow()
                      throws SQLException

将指针移动到记住的指针位置，通常为当前行。如果指针不位于插入行上，则此方法无效。

抛出：: SQLException - 如果发生数据库访问错误或者结果集不可更新
从以下版本开始：: 1.2

getStatement

Statement getStatement()
                       throws SQLException

检索生成此 ResultSet 对象的 Statement 对象。如果结果集是以其他方式生成的（如通过 DatabaseMetaData 方法），则此方法返回 null。

返回：: 生成此 ResultSet 对象的 Statment 对象；如果结果集是以其他方法生成的，则返回 null
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getObject

Object getObject(int i,
                 Map<String,Class<?>> map)
                 throws SQLException

以 Java 编程语言中 Object 的形式检索此 ResultSet 对象的当前行中指定列的值。如果值为 SQL NULL，则驱动程序返回一个 Java null。此方法使用给定的 Map 对象作为正在检索的 SQL 结构化或独特类型的自定义映射关系。

参数：: i - 第一个列是 1，第二个列是 2，……; map - 一个 java.util.Map 对象，包含从 SQL 类型名称到 Java 编程语言中类的映射关系
返回：: 表示 SQL 值的 Java 编程语言中的 Object
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getRef

Ref getRef(int i)
           throws SQLException

以 Java 编程语言中 Ref 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: i - 第一个列是 1，第二个列是 2，……
返回：: 表示 SQL REF 值的 Ref 对象
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getBlob

Blob getBlob(int i)
             throws SQLException

以 Java 编程语言中 Blob 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: i - 第一个列是 1，第二个列是 2，……
返回：: 表示指定列中的 SQL BLOB 值的 BLOB 对象
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getClob

Clob getClob(int i)
             throws SQLException

以 Java 编程语言中 Clob 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: i - 第一个列是 1，第二个列是 2，……
返回：: 表示指定列中的 SQL Clob 值的 Clob 对象
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getArray

Array getArray(int i)
               throws SQLException

以 Java 编程语言中 Array 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: i - 第一个列是 1，第二个列是 2，……
返回：: 表示指定列中的 SQL Array 值的 Array 对象
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getObject

Object getObject(String colName,
                 Map<String,Class<?>> map)
                 throws SQLException

以 Java 编程语言中 Object 的形式检索此 ResultSet 对象的当前行中指定列的值。如果值为 SQL NULL，则驱动程序返回一个 Java null。此方法使用指定的 Map 对象自定义映射关系（如果合适）。

参数：: colName - 列的名称，根据它来检索值; map - 包含从 SQL 类型名称到 Java 编程语言中类的映射关系的 java.util.Map 对象
返回：: 表示指定列中的 SQL 值的 Object
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getRef

Ref getRef(String colName)
           throws SQLException

以 Java 编程语言中 Ref 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: colName - 列名称
返回：: 表示指定列中 SQL Ref 值的 Ref 对象
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getBlob

Blob getBlob(String colName)
             throws SQLException

以 Java 编程语言中 Blob 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: colName - 列的名称，根据它检索值
返回：: 表示指定列中 SQL Blob 值的 Blob 对象
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getClob

Clob getClob(String colName)
             throws SQLException

以 Java 编程语言中 Clob 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: colName - 列的名称，根据它检索值
返回：: 表示指定列中 SQL CLOB 值的 Clob 对象
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getArray

Array getArray(String colName)
               throws SQLException

以 Java 编程语言中 Array 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: colName - 列的名称，根据它检索值
返回：: 表示指定列中 SQL ARRAY 值的 ARRAY 对象
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getDate

Date getDate(int columnIndex,
             Calendar cal)
             throws SQLException

以 Java 编程语言中 java.sql.Date 对象的形式检索此 ResultSet 对象的当前行中指定列的值。如果底层数据库未存储时区信息，则此方法使用给定日历构造日期的适当毫秒值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; cal - 在构造日期时使用的 java.util.Calendar 对象
返回：: java.sql.Date 对象形式的列值；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getDate

Date getDate(String columnName,
             Calendar cal)
             throws SQLException

参数：: columnName - 列的 SQL 名称，根据它检索值; cal - 在构造日期时使用的 java.util.Calendar 对象
返回：: java.sql.Date 对象形式的列值；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getTime

Time getTime(int columnIndex,
             Calendar cal)
             throws SQLException

以 Java 编程语言中 java.sql.Time 对象的形式检索此 ResultSet 对象的当前行中指定列的值。如果底层数据库未存储时区信息，则此方法使用给定日历构造时间的适当毫秒值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; cal - 在构造时间时使用的 java.util.Calendar 对象
返回：: java.sql.Time 对象形式的列值；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getTime

Time getTime(String columnName,
             Calendar cal)
             throws SQLException

参数：: columnName - 列的 SQL 名称; cal - 在构造时间时使用的 java.util.Calendar 对象
返回：: java.sql.Time 对象形式的列值；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getTimestamp

Timestamp getTimestamp(int columnIndex,
                       Calendar cal)
                       throws SQLException

以 Java 编程语言中 java.sql.Timestamp 对象的形式检索此 ResultSet 对象的当前行中指定列的值。如果底层数据库未存储时区信息，则此方法使用给定日历构造时间戳的适当毫秒值。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; cal - 在构造时间戳时使用的 java.util.Calendar 对象
返回：: java.sql.Timestamp 对象形式的列值；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getTimestamp

Timestamp getTimestamp(String columnName,
                       Calendar cal)
                       throws SQLException

参数：: columnName - 列的 SQL 名称; cal - 在构造日期时使用的 java.util.Calendar 对象
返回：: java.sql.Timestamp 对象形式的列值；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.2

getURL

URL getURL(int columnIndex)
           throws SQLException

以 Java 编程语言中 java.net.URL 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnIndex - 索引，其中第一个列是 1、第二个列是 2，……
返回：: java.net.URL 对象形式的列值；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null
抛出：: SQLException - 如果发生数据库访问错误或者 URL 是错误的
从以下版本开始：: 1.4

getURL

URL getURL(String columnName)
           throws SQLException

以 Java 编程语言中 java.net.URL 对象的形式检索此 ResultSet 对象的当前行中指定列的值。

参数：: columnName - 列的 SQL 名称
返回：: java.net.URL 对象形式的列值；如果值为 SQL NULL，则返回值为 Java 编程语言中的 null
抛出：: SQLException - 如果发生数据库访问错误或者 URL 是错误的
从以下版本开始：: 1.4

updateRef

void updateRef(int columnIndex,
               Ref x)
               throws SQLException

用 java.sql.Ref 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.4

updateRef

void updateRef(String columnName,
               Ref x)
               throws SQLException

用 java.sql.Ref 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.4

updateBlob

void updateBlob(int columnIndex,
                Blob x)
                throws SQLException

用 java.sql.Blob 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.4

updateBlob

void updateBlob(String columnName,
                Blob x)
                throws SQLException

用 java.sql.Blob 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.4

updateClob

void updateClob(int columnIndex,
                Clob x)
                throws SQLException

用 java.sql.Clob 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.4

updateClob

void updateClob(String columnName,
                Clob x)
                throws SQLException

用 java.sql.Clob 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.4

updateArray

void updateArray(int columnIndex,
                 Array x)
                 throws SQLException

用 java.sql.Array 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnIndex - 第一个列是 1，第二个列是 2，……; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误
从以下版本开始：: 1.4

updateArray

void updateArray(String columnName,
                 Array x)
                 throws SQLException

用 java.sql.Array 值更新指定列。更新方法用于更新当前行或插入行中的列值，并不会更新底层数据库；更新数据库要调用 updateRow 或 insertRow 方法。

参数：: columnName - 列的名称; x - 新列值
抛出：: SQLException - 如果发生数据库访问错误

Interface ResultSet

All Superinterfaces:
AutoCloseable, Wrapper
All Known Subinterfaces:
CachedRowSet, FilteredRowSet, JdbcRowSet, JoinRowSet, RowSet, SyncResolver, WebRowSet
```
public interface ResultSet
extends Wrapper, AutoCloseable
```
A table of data representing a database result set, which is usually generated by executing a statement that queries the database.
A ResultSet object maintains a cursor pointing to its current row of data. Initially the cursor is positioned before the first row. The next method moves the cursor to the next row, and because it returns false when there are no more rows in the ResultSet object, it can be used in a while loop to iterate through the result set.

A default ResultSet object is not updatable and has a cursor that moves forward only. Thus, you can iterate through it only once and only from the first row to the last row. It is possible to produce ResultSet objects that are scrollable and/or updatable. The following code fragment, in which con is a valid Connection object, illustrates how to make a result set that is scrollable and insensitive to updates by others, and that is updatable. See ResultSet fields for other options.
```
       Statement stmt = con.createStatement(
                                      ResultSet.TYPE_SCROLL_INSENSITIVE,
                                      ResultSet.CONCUR_UPDATABLE);
       ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2");
       // rs will be scrollable, will not show changes made by others,
       // and will be updatable

 
```
The ResultSet interface provides getter methods (getBoolean, getLong, and so on) for retrieving column values from the current row. Values can be retrieved using either the index number of the column or the name of the column. In general, using the column index will be more efficient. Columns are numbered from 1. For maximum portability, result set columns within each row should be read in left-to-right order, and each column should be read only once.
For the getter methods, a JDBC driver attempts to convert the underlying data to the Java type specified in the getter method and returns a suitable Java value. The JDBC specification has a table showing the allowable mappings from SQL types to Java types that can be used by the ResultSet getter methods.

Column names used as input to getter methods are case insensitive. When a getter method is called with a column name and several columns have the same name, the value of the first matching column will be returned. The column name option is designed to be used when column names are used in the SQL query that generated the result set. For columns that are NOT explicitly named in the query, it is best to use column numbers. If column names are used, the programmer should take care to guarantee that they uniquely refer to the intended columns, which can be assured with the SQL AS clause.

A set of updater methods were added to this interface in the JDBC 2.0 API (Java^TM 2 SDK, Standard Edition, version 1.2). The comments regarding parameters to the getter methods also apply to parameters to the updater methods.

The updater methods may be used in two ways:
1. to update a column value in the current row. In a scrollable ResultSet object, the cursor can be moved backwards and forwards, to an absolute position, or to a position relative to the current row. The following code fragment updates the NAME column in the fifth row of the ResultSet object rs and then uses the method updateRow to update the data source table from which rs was derived.
```
       rs.absolute(5); // moves the cursor to the fifth row of rs
       rs.updateString("NAME", "AINSWORTH"); // updates the
          // NAME column of row 5 to be AINSWORTH
       rs.updateRow(); // updates the row in the data source

 
```
2. to insert column values into the insert row. An updatable ResultSet object has a special row associated with it that serves as a staging area for building a row to be inserted. The following code fragment moves the cursor to the insert row, builds a three-column row, and inserts it into rs and into the data source table using the method insertRow.
```
       rs.moveToInsertRow(); // moves cursor to the insert row
       rs.updateString(1, "AINSWORTH"); // updates the
          // first column of the insert row to be AINSWORTH
       rs.updateInt(2,35); // updates the second column to be 35
       rs.updateBoolean(3, true); // updates the third column to true
       rs.insertRow();
       rs.moveToCurrentRow();

 
```
A ResultSet object is automatically closed when the Statement object that generated it is closed, re-executed, or used to retrieve the next result from a sequence of multiple results.

The number, types and properties of a ResultSet object's columns are provided by the ResultSetMetaData object returned by the ResultSet.getMetaData method.
See Also:
Statement.executeQuery(java.lang.String), Statement.getResultSet(), ResultSetMetaData

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CLOSE_CURSORS_AT_COMMIT` The constant indicating that open `ResultSet` objects with this holdability will be closed when the current transaction is commited.
`static int`	`CONCUR_READ_ONLY` The constant indicating the concurrency mode for a `ResultSet` object that may NOT be updated.
`static int`	`CONCUR_UPDATABLE` The constant indicating the concurrency mode for a `ResultSet` object that may be updated.
`static int`	`FETCH_FORWARD` The constant indicating that the rows in a result set will be processed in a forward direction; first-to-last.
`static int`	`FETCH_REVERSE` The constant indicating that the rows in a result set will be processed in a reverse direction; last-to-first.
`static int`	`FETCH_UNKNOWN` The constant indicating that the order in which rows in a result set will be processed is unknown.
`static int`	`HOLD_CURSORS_OVER_COMMIT` The constant indicating that open `ResultSet` objects with this holdability will remain open when the current transaction is commited.
`static int`	`TYPE_FORWARD_ONLY` The constant indicating the type for a `ResultSet` object whose cursor may move only forward.
`static int`	`TYPE_SCROLL_INSENSITIVE` The constant indicating the type for a `ResultSet` object that is scrollable but generally not sensitive to changes to the data that underlies the `ResultSet`.
`static int`	`TYPE_SCROLL_SENSITIVE` The constant indicating the type for a `ResultSet` object that is scrollable and generally sensitive to changes to the data that underlies the `ResultSet`.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`absolute(int row)` Moves the cursor to the given row number in this `ResultSet` object.
`void`	`afterLast()` Moves the cursor to the end of this `ResultSet` object, just after the last row.
`void`	`beforeFirst()` Moves the cursor to the front of this `ResultSet` object, just before the first row.
`void`	`cancelRowUpdates()` Cancels the updates made to the current row in this `ResultSet` object.
`void`	`clearWarnings()` Clears all warnings reported on this `ResultSet` object.
`void`	`close()` Releases this `ResultSet` object's database and JDBC resources immediately instead of waiting for this to happen when it is automatically closed.
`void`	`deleteRow()` Deletes the current row from this `ResultSet` object and from the underlying database.
`int`	`findColumn(String columnLabel)` Maps the given `ResultSet` column label to its `ResultSet` column index.
`boolean`	`first()` Moves the cursor to the first row in this `ResultSet` object.
`Array`	`getArray(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as an `Array` object in the Java programming language.
`Array`	`getArray(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as an `Array` object in the Java programming language.
`InputStream`	`getAsciiStream(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a stream of ASCII characters.
`InputStream`	`getAsciiStream(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a stream of ASCII characters.
`BigDecimal`	`getBigDecimal(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.math.BigDecimal` with full precision.
`BigDecimal`	`getBigDecimal(int columnIndex, int scale)` Deprecated.
`BigDecimal`	`getBigDecimal(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.math.BigDecimal` with full precision.
`BigDecimal`	`getBigDecimal(String columnLabel, int scale)` Deprecated.
`InputStream`	`getBinaryStream(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a stream of uninterpreted bytes.
`InputStream`	`getBinaryStream(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a stream of uninterpreted `byte`s.
`Blob`	`getBlob(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `Blob` object in the Java programming language.
`Blob`	`getBlob(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `Blob` object in the Java programming language.
`boolean`	`getBoolean(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `boolean` in the Java programming language.
`boolean`	`getBoolean(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `boolean` in the Java programming language.
`byte`	`getByte(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `byte` in the Java programming language.
`byte`	`getByte(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `byte` in the Java programming language.
`byte[]`	`getBytes(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `byte` array in the Java programming language.
`byte[]`	`getBytes(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `byte` array in the Java programming language.
`Reader`	`getCharacterStream(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.io.Reader` object.
`Reader`	`getCharacterStream(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.io.Reader` object.
`Clob`	`getClob(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `Clob` object in the Java programming language.
`Clob`	`getClob(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `Clob` object in the Java programming language.
`int`	`getConcurrency()` Retrieves the concurrency mode of this `ResultSet` object.
`String`	`getCursorName()` Retrieves the name of the SQL cursor used by this `ResultSet` object.
`Date`	`getDate(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Date` object in the Java programming language.
`Date`	`getDate(int columnIndex, Calendar cal)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Date` object in the Java programming language.
`Date`	`getDate(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Date` object in the Java programming language.
`Date`	`getDate(String columnLabel, Calendar cal)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Date` object in the Java programming language.
`double`	`getDouble(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `double` in the Java programming language.
`double`	`getDouble(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `double` in the Java programming language.
`int`	`getFetchDirection()` Retrieves the fetch direction for this `ResultSet` object.
`int`	`getFetchSize()` Retrieves the fetch size for this `ResultSet` object.
`float`	`getFloat(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `float` in the Java programming language.
`float`	`getFloat(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `float` in the Java programming language.
`int`	`getHoldability()` Retrieves the holdability of this `ResultSet` object
`int`	`getInt(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as an `int` in the Java programming language.
`int`	`getInt(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as an `int` in the Java programming language.
`long`	`getLong(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `long` in the Java programming language.
`long`	`getLong(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `long` in the Java programming language.
`ResultSetMetaData`	`getMetaData()` Retrieves the number, types and properties of this `ResultSet` object's columns.
`Reader`	`getNCharacterStream(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.io.Reader` object.
`Reader`	`getNCharacterStream(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.io.Reader` object.
`NClob`	`getNClob(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `NClob` object in the Java programming language.
`NClob`	`getNClob(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `NClob` object in the Java programming language.
`String`	`getNString(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `String` in the Java programming language.
`String`	`getNString(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `String` in the Java programming language.
`Object`	`getObject(int columnIndex)` Gets the value of the designated column in the current row of this `ResultSet` object as an `Object` in the Java programming language.
`<T> T`	`getObject(int columnIndex, Class<T> type)` Retrieves the value of the designated column in the current row of this `ResultSet` object and will convert from the SQL type of the column to the requested Java data type, if the conversion is supported.
`Object`	`getObject(int columnIndex, Map<String,Class<?>> map)` Retrieves the value of the designated column in the current row of this `ResultSet` object as an `Object` in the Java programming language.
`Object`	`getObject(String columnLabel)` Gets the value of the designated column in the current row of this `ResultSet` object as an `Object` in the Java programming language.
`<T> T`	`getObject(String columnLabel, Class<T> type)` Retrieves the value of the designated column in the current row of this `ResultSet` object and will convert from the SQL type of the column to the requested Java data type, if the conversion is supported.
`Object`	`getObject(String columnLabel, Map<String,Class<?>> map)` Retrieves the value of the designated column in the current row of this `ResultSet` object as an `Object` in the Java programming language.
`Ref`	`getRef(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `Ref` object in the Java programming language.
`Ref`	`getRef(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `Ref` object in the Java programming language.
`int`	`getRow()` Retrieves the current row number.
`RowId`	`getRowId(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.RowId` object in the Java programming language.
`RowId`	`getRowId(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.RowId` object in the Java programming language.
`short`	`getShort(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `short` in the Java programming language.
`short`	`getShort(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `short` in the Java programming language.
`SQLXML`	`getSQLXML(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` as a `java.sql.SQLXML` object in the Java programming language.
`SQLXML`	`getSQLXML(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` as a `java.sql.SQLXML` object in the Java programming language.
`Statement`	`getStatement()` Retrieves the `Statement` object that produced this `ResultSet` object.
`String`	`getString(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `String` in the Java programming language.
`String`	`getString(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `String` in the Java programming language.
`Time`	`getTime(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Time` object in the Java programming language.
`Time`	`getTime(int columnIndex, Calendar cal)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Time` object in the Java programming language.
`Time`	`getTime(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Time` object in the Java programming language.
`Time`	`getTime(String columnLabel, Calendar cal)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Time` object in the Java programming language.
`Timestamp`	`getTimestamp(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Timestamp` object in the Java programming language.
`Timestamp`	`getTimestamp(int columnIndex, Calendar cal)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Timestamp` object in the Java programming language.
`Timestamp`	`getTimestamp(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Timestamp` object in the Java programming language.
`Timestamp`	`getTimestamp(String columnLabel, Calendar cal)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.sql.Timestamp` object in the Java programming language.
`int`	`getType()` Retrieves the type of this `ResultSet` object.
`InputStream`	`getUnicodeStream(int columnIndex)` Deprecated. use `getCharacterStream` in place of `getUnicodeStream`
`InputStream`	`getUnicodeStream(String columnLabel)` Deprecated. use `getCharacterStream` instead
`URL`	`getURL(int columnIndex)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.net.URL` object in the Java programming language.
`URL`	`getURL(String columnLabel)` Retrieves the value of the designated column in the current row of this `ResultSet` object as a `java.net.URL` object in the Java programming language.
`SQLWarning`	`getWarnings()` Retrieves the first warning reported by calls on this `ResultSet` object.
`void`	`insertRow()` Inserts the contents of the insert row into this `ResultSet` object and into the database.
`boolean`	`isAfterLast()` Retrieves whether the cursor is after the last row in this `ResultSet` object.
`boolean`	`isBeforeFirst()` Retrieves whether the cursor is before the first row in this `ResultSet` object.
`boolean`	`isClosed()` Retrieves whether this `ResultSet` object has been closed.
`boolean`	`isFirst()` Retrieves whether the cursor is on the first row of this `ResultSet` object.
`boolean`	`isLast()` Retrieves whether the cursor is on the last row of this `ResultSet` object.
`boolean`	`last()` Moves the cursor to the last row in this `ResultSet` object.
`void`	`moveToCurrentRow()` Moves the cursor to the remembered cursor position, usually the current row.
`void`	`moveToInsertRow()` Moves the cursor to the insert row.
`boolean`	`next()` Moves the cursor froward one row from its current position.
`boolean`	`previous()` Moves the cursor to the previous row in this `ResultSet` object.
`void`	`refreshRow()` Refreshes the current row with its most recent value in the database.
`boolean`	`relative(int rows)` Moves the cursor a relative number of rows, either positive or negative.
`boolean`	`rowDeleted()` Retrieves whether a row has been deleted.
`boolean`	`rowInserted()` Retrieves whether the current row has had an insertion.
`boolean`	`rowUpdated()` Retrieves whether the current row has been updated.
`void`	`setFetchDirection(int direction)` Gives a hint as to the direction in which the rows in this `ResultSet` object will be processed.
`void`	`setFetchSize(int rows)` Gives the JDBC driver a hint as to the number of rows that should be fetched from the database when more rows are needed for this `ResultSet` object.
`void`	`updateArray(int columnIndex, Array x)` Updates the designated column with a `java.sql.Array` value.
`void`	`updateArray(String columnLabel, Array x)` Updates the designated column with a `java.sql.Array` value.
`void`	`updateAsciiStream(int columnIndex, InputStream x)` Updates the designated column with an ascii stream value.
`void`	`updateAsciiStream(int columnIndex, InputStream x, int length)` Updates the designated column with an ascii stream value, which will have the specified number of bytes.
`void`	`updateAsciiStream(int columnIndex, InputStream x, long length)` Updates the designated column with an ascii stream value, which will have the specified number of bytes.
`void`	`updateAsciiStream(String columnLabel, InputStream x)` Updates the designated column with an ascii stream value.
`void`	`updateAsciiStream(String columnLabel, InputStream x, int length)` Updates the designated column with an ascii stream value, which will have the specified number of bytes.
`void`	`updateAsciiStream(String columnLabel, InputStream x, long length)` Updates the designated column with an ascii stream value, which will have the specified number of bytes.
`void`	`updateBigDecimal(int columnIndex, BigDecimal x)` Updates the designated column with a `java.math.BigDecimal` value.
`void`	`updateBigDecimal(String columnLabel, BigDecimal x)` Updates the designated column with a `java.sql.BigDecimal` value.
`void`	`updateBinaryStream(int columnIndex, InputStream x)` Updates the designated column with a binary stream value.
`void`	`updateBinaryStream(int columnIndex, InputStream x, int length)` Updates the designated column with a binary stream value, which will have the specified number of bytes.
`void`	`updateBinaryStream(int columnIndex, InputStream x, long length)` Updates the designated column with a binary stream value, which will have the specified number of bytes.
`void`	`updateBinaryStream(String columnLabel, InputStream x)` Updates the designated column with a binary stream value.
`void`	`updateBinaryStream(String columnLabel, InputStream x, int length)` Updates the designated column with a binary stream value, which will have the specified number of bytes.
`void`	`updateBinaryStream(String columnLabel, InputStream x, long length)` Updates the designated column with a binary stream value, which will have the specified number of bytes.
`void`	`updateBlob(int columnIndex, Blob x)` Updates the designated column with a `java.sql.Blob` value.
`void`	`updateBlob(int columnIndex, InputStream inputStream)` Updates the designated column using the given input stream.
`void`	`updateBlob(int columnIndex, InputStream inputStream, long length)` Updates the designated column using the given input stream, which will have the specified number of bytes.
`void`	`updateBlob(String columnLabel, Blob x)` Updates the designated column with a `java.sql.Blob` value.
`void`	`updateBlob(String columnLabel, InputStream inputStream)` Updates the designated column using the given input stream.
`void`	`updateBlob(String columnLabel, InputStream inputStream, long length)` Updates the designated column using the given input stream, which will have the specified number of bytes.
`void`	`updateBoolean(int columnIndex, boolean x)` Updates the designated column with a `boolean` value.
`void`	`updateBoolean(String columnLabel, boolean x)` Updates the designated column with a `boolean` value.
`void`	`updateByte(int columnIndex, byte x)` Updates the designated column with a `byte` value.
`void`	`updateByte(String columnLabel, byte x)` Updates the designated column with a `byte` value.
`void`	`updateBytes(int columnIndex, byte[] x)` Updates the designated column with a `byte` array value.
`void`	`updateBytes(String columnLabel, byte[] x)` Updates the designated column with a byte array value.
`void`	`updateCharacterStream(int columnIndex, Reader x)` Updates the designated column with a character stream value.
`void`	`updateCharacterStream(int columnIndex, Reader x, int length)` Updates the designated column with a character stream value, which will have the specified number of bytes.
`void`	`updateCharacterStream(int columnIndex, Reader x, long length)` Updates the designated column with a character stream value, which will have the specified number of bytes.
`void`	`updateCharacterStream(String columnLabel, Reader reader)` Updates the designated column with a character stream value.
`void`	`updateCharacterStream(String columnLabel, Reader reader, int length)` Updates the designated column with a character stream value, which will have the specified number of bytes.
`void`	`updateCharacterStream(String columnLabel, Reader reader, long length)` Updates the designated column with a character stream value, which will have the specified number of bytes.
`void`	`updateClob(int columnIndex, Clob x)` Updates the designated column with a `java.sql.Clob` value.
`void`	`updateClob(int columnIndex, Reader reader)` Updates the designated column using the given `Reader` object.
`void`	`updateClob(int columnIndex, Reader reader, long length)` Updates the designated column using the given `Reader` object, which is the given number of characters long.
`void`	`updateClob(String columnLabel, Clob x)` Updates the designated column with a `java.sql.Clob` value.
`void`	`updateClob(String columnLabel, Reader reader)` Updates the designated column using the given `Reader` object.
`void`	`updateClob(String columnLabel, Reader reader, long length)` Updates the designated column using the given `Reader` object, which is the given number of characters long.
`void`	`updateDate(int columnIndex, Date x)` Updates the designated column with a `java.sql.Date` value.
`void`	`updateDate(String columnLabel, Date x)` Updates the designated column with a `java.sql.Date` value.
`void`	`updateDouble(int columnIndex, double x)` Updates the designated column with a `double` value.
`void`	`updateDouble(String columnLabel, double x)` Updates the designated column with a `double` value.
`void`	`updateFloat(int columnIndex, float x)` Updates the designated column with a `float` value.
`void`	`updateFloat(String columnLabel, float x)` Updates the designated column with a `float` value.
`void`	`updateInt(int columnIndex, int x)` Updates the designated column with an `int` value.
`void`	`updateInt(String columnLabel, int x)` Updates the designated column with an `int` value.
`void`	`updateLong(int columnIndex, long x)` Updates the designated column with a `long` value.
`void`	`updateLong(String columnLabel, long x)` Updates the designated column with a `long` value.
`void`	`updateNCharacterStream(int columnIndex, Reader x)` Updates the designated column with a character stream value.
`void`	`updateNCharacterStream(int columnIndex, Reader x, long length)` Updates the designated column with a character stream value, which will have the specified number of bytes.
`void`	`updateNCharacterStream(String columnLabel, Reader reader)` Updates the designated column with a character stream value.
`void`	`updateNCharacterStream(String columnLabel, Reader reader, long length)` Updates the designated column with a character stream value, which will have the specified number of bytes.
`void`	`updateNClob(int columnIndex, NClob nClob)` Updates the designated column with a `java.sql.NClob` value.
`void`	`updateNClob(int columnIndex, Reader reader)` Updates the designated column using the given `Reader` The data will be read from the stream as needed until end-of-stream is reached.
`void`	`updateNClob(int columnIndex, Reader reader, long length)` Updates the designated column using the given `Reader` object, which is the given number of characters long.
`void`	`updateNClob(String columnLabel, NClob nClob)` Updates the designated column with a `java.sql.NClob` value.
`void`	`updateNClob(String columnLabel, Reader reader)` Updates the designated column using the given `Reader` object.
`void`	`updateNClob(String columnLabel, Reader reader, long length)` Updates the designated column using the given `Reader` object, which is the given number of characters long.
`void`	`updateNString(int columnIndex, String nString)` Updates the designated column with a `String` value.
`void`	`updateNString(String columnLabel, String nString)` Updates the designated column with a `String` value.
`void`	`updateNull(int columnIndex)` Updates the designated column with a `null` value.
`void`	`updateNull(String columnLabel)` Updates the designated column with a `null` value.
`void`	`updateObject(int columnIndex, Object x)` Updates the designated column with an `Object` value.
`void`	`updateObject(int columnIndex, Object x, int scaleOrLength)` Updates the designated column with an `Object` value.
`void`	`updateObject(String columnLabel, Object x)` Updates the designated column with an `Object` value.
`void`	`updateObject(String columnLabel, Object x, int scaleOrLength)` Updates the designated column with an `Object` value.
`void`	`updateRef(int columnIndex, Ref x)` Updates the designated column with a `java.sql.Ref` value.
`void`	`updateRef(String columnLabel, Ref x)` Updates the designated column with a `java.sql.Ref` value.
`void`	`updateRow()` Updates the underlying database with the new contents of the current row of this `ResultSet` object.
`void`	`updateRowId(int columnIndex, RowId x)` Updates the designated column with a `RowId` value.
`void`	`updateRowId(String columnLabel, RowId x)` Updates the designated column with a `RowId` value.
`void`	`updateShort(int columnIndex, short x)` Updates the designated column with a `short` value.
`void`	`updateShort(String columnLabel, short x)` Updates the designated column with a `short` value.
`void`	`updateSQLXML(int columnIndex, SQLXML xmlObject)` Updates the designated column with a `java.sql.SQLXML` value.
`void`	`updateSQLXML(String columnLabel, SQLXML xmlObject)` Updates the designated column with a `java.sql.SQLXML` value.
`void`	`updateString(int columnIndex, String x)` Updates the designated column with a `String` value.
`void`	`updateString(String columnLabel, String x)` Updates the designated column with a `String` value.
`void`	`updateTime(int columnIndex, Time x)` Updates the designated column with a `java.sql.Time` value.
`void`	`updateTime(String columnLabel, Time x)` Updates the designated column with a `java.sql.Time` value.
`void`	`updateTimestamp(int columnIndex, Timestamp x)` Updates the designated column with a `java.sql.Timestamp` value.
`void`	`updateTimestamp(String columnLabel, Timestamp x)` Updates the designated column with a `java.sql.Timestamp` value.
`boolean`	`wasNull()` Reports whether the last column read had a value of SQL `NULL`.

Methods inherited from interface java.sql.Wrapper
isWrapperFor, unwrap

- Field Detail
  - FETCH_FORWARD
```
static final int FETCH_FORWARD
```
    The constant indicating that the rows in a result set will be processed in a forward direction; first-to-last. This constant is used by the method setFetchDirection as a hint to the driver, which the driver may ignore.
    
    Since:
    1.2
    See Also:
    Constant Field Values
  - FETCH_REVERSE
```
static final int FETCH_REVERSE
```
    The constant indicating that the rows in a result set will be processed in a reverse direction; last-to-first. This constant is used by the method setFetchDirection as a hint to the driver, which the driver may ignore.
    
    Since:
    1.2
    See Also:
    Constant Field Values
  - FETCH_UNKNOWN
```
static final int FETCH_UNKNOWN
```
    The constant indicating that the order in which rows in a result set will be processed is unknown. This constant is used by the method setFetchDirection as a hint to the driver, which the driver may ignore.
    
    See Also:
    Constant Field Values
  - TYPE_FORWARD_ONLY
```
static final int TYPE_FORWARD_ONLY
```
    The constant indicating the type for a ResultSet object whose cursor may move only forward.
    
    Since:
    1.2
    See Also:
    Constant Field Values
  - TYPE_SCROLL_INSENSITIVE
```
static final int TYPE_SCROLL_INSENSITIVE
```
    The constant indicating the type for a ResultSet object that is scrollable but generally not sensitive to changes to the data that underlies the ResultSet.
    
    Since:
    1.2
    See Also:
    Constant Field Values
  - TYPE_SCROLL_SENSITIVE
```
static final int TYPE_SCROLL_SENSITIVE
```
    The constant indicating the type for a ResultSet object that is scrollable and generally sensitive to changes to the data that underlies the ResultSet.
    
    Since:
    1.2
    See Also:
    Constant Field Values
  - CONCUR_READ_ONLY
```
static final int CONCUR_READ_ONLY
```
    The constant indicating the concurrency mode for a ResultSet object that may NOT be updated.
    
    Since:
    1.2
    See Also:
    Constant Field Values
  - CONCUR_UPDATABLE
```
static final int CONCUR_UPDATABLE
```
    The constant indicating the concurrency mode for a ResultSet object that may be updated.
    
    Since:
    1.2
    See Also:
    Constant Field Values
  - HOLD_CURSORS_OVER_COMMIT
```
static final int HOLD_CURSORS_OVER_COMMIT
```
    The constant indicating that open ResultSet objects with this holdability will remain open when the current transaction is commited.
    
    Since:
    1.4
    See Also:
    Constant Field Values
  - CLOSE_CURSORS_AT_COMMIT
```
static final int CLOSE_CURSORS_AT_COMMIT
```
    The constant indicating that open ResultSet objects with this holdability will be closed when the current transaction is commited.
    
    Since:
    1.4
    See Also:
    Constant Field Values
- Method Detail
  - next
```
boolean next()
             throws SQLException
```
    Moves the cursor froward one row from its current position. A ResultSet cursor is initially positioned before the first row; the first call to the method next makes the first row the current row; the second call makes the second row the current row, and so on.
    When a call to the next method returns false, the cursor is positioned after the last row. Any invocation of a ResultSet method which requires a current row will result in a SQLException being thrown. If the result set type is TYPE_FORWARD_ONLY, it is vendor specified whether their JDBC driver implementation will return false or throw an SQLException on a subsequent call to next.
    
    If an input stream is open for the current row, a call to the method next will implicitly close it. A ResultSet object's warning chain is cleared when a new row is read.
    
    Returns:
    true if the new current row is valid; false if there are no more rows
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
  - close
```
void close()
           throws SQLException
```
    Releases this ResultSet object's database and JDBC resources immediately instead of waiting for this to happen when it is automatically closed.
    The closing of a ResultSet object does not close the Blob, Clob or NClob objects created by the ResultSet. Blob, Clob or NClob objects remain valid for at least the duration of the transaction in which they are creataed, unless their free method is invoked.
    
    When a ResultSet is closed, any ResultSetMetaData instances that were created by calling the getMetaData method remain accessible.
    
    Note: A ResultSet object is automatically closed by the Statement object that generated it when that Statement object is closed, re-executed, or is used to retrieve the next result from a sequence of multiple results.
    
    Calling the method close on a ResultSet object that is already closed is a no-op.
    
    Specified by:
    close in interface AutoCloseable
    Throws:
    SQLException - if a database access error occurs
  - wasNull
```
boolean wasNull()
                throws SQLException
```
    Reports whether the last column read had a value of SQL NULL. Note that you must first call one of the getter methods on a column to try to read its value and then call the method wasNull to see if the value read was SQL NULL.
    
    Returns:
    true if the last column value read was SQL NULL and false otherwise
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
  - getString
```
String getString(int columnIndex)
                 throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a String in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getBoolean
```
boolean getBoolean(int columnIndex)
                   throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a boolean in the Java programming language.
    If the designated column has a datatype of CHAR or VARCHAR and contains a "0" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT and contains a 0, a value of false is returned. If the designated column has a datatype of CHAR or VARCHAR and contains a "1" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT and contains a 1, a value of true is returned.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is false
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getByte
```
byte getByte(int columnIndex)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a byte in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getShort
```
short getShort(int columnIndex)
               throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a short in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getInt
```
int getInt(int columnIndex)
           throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as an int in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getLong
```
long getLong(int columnIndex)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a long in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getFloat
```
float getFloat(int columnIndex)
               throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a float in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getDouble
```
double getDouble(int columnIndex)
                 throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a double in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getBigDecimal
```
BigDecimal getBigDecimal(int columnIndex,
                       int scale)
                         throws SQLException
```
    Deprecated.
    
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.BigDecimal in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    scale - the number of digits to the right of the decimal point
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
  - getBytes
```
byte[] getBytes(int columnIndex)
                throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a byte array in the Java programming language. The bytes represent the raw values returned by the driver.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getDate
```
Date getDate(int columnIndex)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getTime
```
Time getTime(int columnIndex)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getTimestamp
```
Timestamp getTimestamp(int columnIndex)
                       throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Timestamp object in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getAsciiStream
```
InputStream getAsciiStream(int columnIndex)
                           throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a stream of ASCII characters. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARCHAR values. The JDBC driver will do any necessary conversion from the database format into ASCII.
    Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method InputStream.available is called whether there is data available or not.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    a Java input stream that delivers the database column value as a stream of one-byte ASCII characters; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getUnicodeStream
```
InputStream getUnicodeStream(int columnIndex)
                             throws SQLException
```
    Deprecated. use getCharacterStream in place of getUnicodeStream
    
    Retrieves the value of the designated column in the current row of this ResultSet object as as a stream of two-byte 3 characters. The first byte is the high byte; the second byte is the low byte. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARCHARvalues. The JDBC driver will do any necessary conversion from the database format into Unicode.
    Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method InputStream.available is called, whether there is data available or not.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    a Java input stream that delivers the database column value as a stream of two-byte Unicode characters; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
  - getBinaryStream
```
InputStream getBinaryStream(int columnIndex)
                            throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a stream of uninterpreted bytes. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARBINARY values.
    Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method InputStream.available is called whether there is data available or not.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    a Java input stream that delivers the database column value as a stream of uninterpreted bytes; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getString
```
String getString(String columnLabel)
                 throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a String in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getBoolean
```
boolean getBoolean(String columnLabel)
                   throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a boolean in the Java programming language.
    If the designated column has a datatype of CHAR or VARCHAR and contains a "0" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT and contains a 0, a value of false is returned. If the designated column has a datatype of CHAR or VARCHAR and contains a "1" or has a datatype of BIT, TINYINT, SMALLINT, INTEGER or BIGINT and contains a 1, a value of true is returned.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is false
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getByte
```
byte getByte(String columnLabel)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a byte in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getShort
```
short getShort(String columnLabel)
               throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a short in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getInt
```
int getInt(String columnLabel)
           throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as an int in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getLong
```
long getLong(String columnLabel)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a long in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getFloat
```
float getFloat(String columnLabel)
               throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a float in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getDouble
```
double getDouble(String columnLabel)
                 throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a double in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is 0
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getBigDecimal
```
BigDecimal getBigDecimal(String columnLabel,
                       int scale)
                         throws SQLException
```
    Deprecated.
    
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.math.BigDecimal in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    scale - the number of digits to the right of the decimal point
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
  - getBytes
```
byte[] getBytes(String columnLabel)
                throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a byte array in the Java programming language. The bytes represent the raw values returned by the driver.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getDate
```
Date getDate(String columnLabel)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getTime
```
Time getTime(String columnLabel)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getTimestamp
```
Timestamp getTimestamp(String columnLabel)
                       throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Timestamp object in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getAsciiStream
```
InputStream getAsciiStream(String columnLabel)
                           throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a stream of ASCII characters. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARCHAR values. The JDBC driver will do any necessary conversion from the database format into ASCII.
    Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method available is called whether there is data available or not.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    a Java input stream that delivers the database column value as a stream of one-byte ASCII characters. If the value is SQL NULL, the value returned is null.
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getUnicodeStream
```
InputStream getUnicodeStream(String columnLabel)
                             throws SQLException
```
    Deprecated. use getCharacterStream instead
    
    Retrieves the value of the designated column in the current row of this ResultSet object as a stream of two-byte Unicode characters. The first byte is the high byte; the second byte is the low byte. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARCHAR values. The JDBC technology-enabled driver will do any necessary conversion from the database format into Unicode.
    Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method InputStream.available is called, whether there is data available or not.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    a Java input stream that delivers the database column value as a stream of two-byte Unicode characters. If the value is SQL NULL, the value returned is null.
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
  - getBinaryStream
```
InputStream getBinaryStream(String columnLabel)
                            throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a stream of uninterpreted bytes. The value can then be read in chunks from the stream. This method is particularly suitable for retrieving large LONGVARBINARY values.
    Note: All the data in the returned stream must be read prior to getting the value of any other column. The next call to a getter method implicitly closes the stream. Also, a stream may return 0 when the method available is called whether there is data available or not.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    a Java input stream that delivers the database column value as a stream of uninterpreted bytes; if the value is SQL NULL, the result is null
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - getWarnings
```
SQLWarning getWarnings()
                       throws SQLException
```
    Retrieves the first warning reported by calls on this ResultSet object. Subsequent warnings on this ResultSet object will be chained to the SQLWarning object that this method returns.
    The warning chain is automatically cleared each time a new row is read. This method may not be called on a ResultSet object that has been closed; doing so will cause an SQLException to be thrown.
    
    Note: This warning chain only covers warnings caused by ResultSet methods. Any warning caused by Statement methods (such as reading OUT parameters) will be chained on the Statement object.
    
    Returns:
    the first SQLWarning object reported or null if there are none
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
  - clearWarnings
```
void clearWarnings()
                   throws SQLException
```
    Clears all warnings reported on this ResultSet object. After this method is called, the method getWarnings returns null until a new warning is reported for this ResultSet object.
    
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
  - getCursorName
```
String getCursorName()
                     throws SQLException
```
    Retrieves the name of the SQL cursor used by this ResultSet object.
    In SQL, a result table is retrieved through a cursor that is named. The current row of a result set can be updated or deleted using a positioned update/delete statement that references the cursor name. To insure that the cursor has the proper isolation level to support update, the cursor's SELECT statement should be of the form SELECT FOR UPDATE. If FOR UPDATE is omitted, the positioned updates may fail.
    
    The JDBC API supports this SQL feature by providing the name of the SQL cursor used by a ResultSet object. The current row of a ResultSet object is also the current row of this SQL cursor.
    
    Returns:
    the SQL name for this ResultSet object's cursor
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
  - getMetaData
```
ResultSetMetaData getMetaData()
                              throws SQLException
```
    Retrieves the number, types and properties of this ResultSet object's columns.
    
    Returns:
    the description of this ResultSet object's columns
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
  - getObject
```
Object getObject(int columnIndex)
                 throws SQLException
```
    Gets the value of the designated column in the current row of this ResultSet object as an Object in the Java programming language.
    
    This method will return the value of the given column as a Java object. The type of the Java object will be the default Java object type corresponding to the column's SQL type, following the mapping for built-in types specified in the JDBC specification. If the value is an SQL NULL, the driver returns a Java null.
    
    This method may also be used to read database-specific abstract data types. In the JDBC 2.0 API, the behavior of method getObject is extended to materialize data of SQL user-defined types.
    
    If Connection.getTypeMap does not throw a SQLFeatureNotSupportedException, then when a column contains a structured or distinct value, the behavior of this method is as if it were a call to: getObject(columnIndex, this.getStatement().getConnection().getTypeMap()). If Connection.getTypeMap does throw a SQLFeatureNotSupportedException, then structured values are not supported, and distinct values are mapped to the default Java class as determined by the underlying SQL type of the DISTINCT type.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    a java.lang.Object holding the column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
  - getObject
```
Object getObject(String columnLabel)
                 throws SQLException
```
    Gets the value of the designated column in the current row of this ResultSet object as an Object in the Java programming language.
    
    This method will return the value of the given column as a Java object. The type of the Java object will be the default Java object type corresponding to the column's SQL type, following the mapping for built-in types specified in the JDBC specification. If the value is an SQL NULL, the driver returns a Java null.
    
    This method may also be used to read database-specific abstract data types.
    
    In the JDBC 2.0 API, the behavior of the method getObject is extended to materialize data of SQL user-defined types. When a column contains a structured or distinct value, the behavior of this method is as if it were a call to: getObject(columnIndex, this.getStatement().getConnection().getTypeMap()).
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    a java.lang.Object holding the column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
  - findColumn
```
int findColumn(String columnLabel)
               throws SQLException
```
    Maps the given ResultSet column label to its ResultSet column index.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column index of the given column name
    Throws:
    SQLException - if the ResultSet object does not contain a column labeled columnLabel, a database access error occurs or this method is called on a closed result set
  - getCharacterStream
```
Reader getCharacterStream(int columnIndex)
                          throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.io.Reader object.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    a java.io.Reader object that contains the column value; if the value is SQL NULL, the value returned is null in the Java programming language.
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - getCharacterStream
```
Reader getCharacterStream(String columnLabel)
                          throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.io.Reader object.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    a java.io.Reader object that contains the column value; if the value is SQL NULL, the value returned is null in the Java programming language
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - getBigDecimal
```
BigDecimal getBigDecimal(int columnIndex)
                         throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.math.BigDecimal with full precision.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value (full precision); if the value is SQL NULL, the value returned is null in the Java programming language.
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - getBigDecimal
```
BigDecimal getBigDecimal(String columnLabel)
                         throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.math.BigDecimal with full precision.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value (full precision); if the value is SQL NULL, the value returned is null in the Java programming language.
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - isBeforeFirst
```
boolean isBeforeFirst()
                      throws SQLException
```
    Retrieves whether the cursor is before the first row in this ResultSet object.
    Note:Support for the isBeforeFirst method is optional for ResultSets with a result set type of TYPE_FORWARD_ONLY
    
    Returns:
    true if the cursor is before the first row; false if the cursor is at any other position or the result set contains no rows
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - isAfterLast
```
boolean isAfterLast()
                    throws SQLException
```
    Retrieves whether the cursor is after the last row in this ResultSet object.
    Note:Support for the isAfterLast method is optional for ResultSets with a result set type of TYPE_FORWARD_ONLY
    
    Returns:
    true if the cursor is after the last row; false if the cursor is at any other position or the result set contains no rows
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - isFirst
```
boolean isFirst()
                throws SQLException
```
    Retrieves whether the cursor is on the first row of this ResultSet object.
    Note:Support for the isFirst method is optional for ResultSets with a result set type of TYPE_FORWARD_ONLY
    
    Returns:
    true if the cursor is on the first row; false otherwise
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - isLast
```
boolean isLast()
               throws SQLException
```
    Retrieves whether the cursor is on the last row of this ResultSet object. Note: Calling the method isLast may be expensive because the JDBC driver might need to fetch ahead one row in order to determine whether the current row is the last row in the result set.
    Note: Support for the isLast method is optional for ResultSets with a result set type of TYPE_FORWARD_ONLY
    
    Returns:
    true if the cursor is on the last row; false otherwise
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - beforeFirst
```
void beforeFirst()
                 throws SQLException
```
    Moves the cursor to the front of this ResultSet object, just before the first row. This method has no effect if the result set contains no rows.
    
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set or the result set type is TYPE_FORWARD_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - afterLast
```
void afterLast()
               throws SQLException
```
    Moves the cursor to the end of this ResultSet object, just after the last row. This method has no effect if the result set contains no rows.
    
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set or the result set type is TYPE_FORWARD_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - first
```
boolean first()
              throws SQLException
```
    Moves the cursor to the first row in this ResultSet object.
    
    Returns:
    true if the cursor is on a valid row; false if there are no rows in the result set
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set or the result set type is TYPE_FORWARD_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - last
```
boolean last()
             throws SQLException
```
    Moves the cursor to the last row in this ResultSet object.
    
    Returns:
    true if the cursor is on a valid row; false if there are no rows in the result set
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set or the result set type is TYPE_FORWARD_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getRow
```
int getRow()
           throws SQLException
```
    Retrieves the current row number. The first row is number 1, the second number 2, and so on.
    Note:Support for the getRow method is optional for ResultSets with a result set type of TYPE_FORWARD_ONLY
    
    Returns:
    the current row number; 0 if there is no current row
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - absolute
```
boolean absolute(int row)
                 throws SQLException
```
    Moves the cursor to the given row number in this ResultSet object.
    If the row number is positive, the cursor moves to the given row number with respect to the beginning of the result set. The first row is row 1, the second is row 2, and so on.
    
    If the given row number is negative, the cursor moves to an absolute row position with respect to the end of the result set. For example, calling the method absolute(-1) positions the cursor on the last row; calling the method absolute(-2) moves the cursor to the next-to-last row, and so on.
    
    If the row number specified is zero, the cursor is moved to before the first row.
    
    An attempt to position the cursor beyond the first/last row in the result set leaves the cursor before the first row or after the last row.
    
    Note: Calling absolute(1) is the same as calling first(). Calling absolute(-1) is the same as calling last().
    
    Parameters:
    row - the number of the row to which the cursor should move. A value of zero indicates that the cursor will be positioned before the first row; a positive number indicates the row number counting from the beginning of the result set; a negative number indicates the row number counting from the end of the result set
    Returns:
    true if the cursor is moved to a position in this ResultSet object; false if the cursor is before the first row or after the last row
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set or the result set type is TYPE_FORWARD_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - relative
```
boolean relative(int rows)
                 throws SQLException
```
    Moves the cursor a relative number of rows, either positive or negative. Attempting to move beyond the first/last row in the result set positions the cursor before/after the the first/last row. Calling relative(0) is valid, but does not change the cursor position.
    Note: Calling the method relative(1) is identical to calling the method next() and calling the method relative(-1) is identical to calling the method previous().
    
    Parameters:
    rows - an int specifying the number of rows to move from the current row; a positive number moves the cursor forward; a negative number moves the cursor backward
    Returns:
    true if the cursor is on a row; false otherwise
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set or the result set type is TYPE_FORWARD_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - previous
```
boolean previous()
                 throws SQLException
```
    Moves the cursor to the previous row in this ResultSet object.
    When a call to the previous method returns false, the cursor is positioned before the first row. Any invocation of a ResultSet method which requires a current row will result in a SQLException being thrown.
    
    If an input stream is open for the current row, a call to the method previous will implicitly close it. A ResultSet object's warning change is cleared when a new row is read.
    
    Returns:
    true if the cursor is now positioned on a valid row; false if the cursor is positioned before the first row
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set or the result set type is TYPE_FORWARD_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - setFetchDirection
```
void setFetchDirection(int direction)
                       throws SQLException
```
    Gives a hint as to the direction in which the rows in this ResultSet object will be processed. The initial value is determined by the Statement object that produced this ResultSet object. The fetch direction may be changed at any time.
    
    Parameters:
    direction - an int specifying the suggested fetch direction; one of ResultSet.FETCH_FORWARD, ResultSet.FETCH_REVERSE, or ResultSet.FETCH_UNKNOWN
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set or the result set type is TYPE_FORWARD_ONLY and the fetch direction is not FETCH_FORWARD
    Since:
    1.2
    See Also:
    Statement.setFetchDirection(int), getFetchDirection()
  - getFetchDirection
```
int getFetchDirection()
                      throws SQLException
```
    Retrieves the fetch direction for this ResultSet object.
    
    Returns:
    the current fetch direction for this ResultSet object
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
    See Also:
    setFetchDirection(int)
  - setFetchSize
```
void setFetchSize(int rows)
                  throws SQLException
```
    Gives the JDBC driver a hint as to the number of rows that should be fetched from the database when more rows are needed for this ResultSet object. If the fetch size specified is zero, the JDBC driver ignores the value and is free to make its own best guess as to what the fetch size should be. The default value is set by the Statement object that created the result set. The fetch size may be changed at any time.
    
    Parameters:
    rows - the number of rows to fetch
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set or the condition rows >= 0 is not satisfied
    Since:
    1.2
    See Also:
    getFetchSize()
  - getFetchSize
```
int getFetchSize()
                 throws SQLException
```
    Retrieves the fetch size for this ResultSet object.
    
    Returns:
    the current fetch size for this ResultSet object
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
    See Also:
    setFetchSize(int)
  - getType
```
int getType()
            throws SQLException
```
    Retrieves the type of this ResultSet object. The type is determined by the Statement object that created the result set.
    
    Returns:
    ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE, or ResultSet.TYPE_SCROLL_SENSITIVE
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - getConcurrency
```
int getConcurrency()
                   throws SQLException
```
    Retrieves the concurrency mode of this ResultSet object. The concurrency used is determined by the Statement object that created the result set.
    
    Returns:
    the concurrency type, either ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - rowUpdated
```
boolean rowUpdated()
                   throws SQLException
```
    Retrieves whether the current row has been updated. The value returned depends on whether or not the result set can detect updates.
    Note: Support for the rowUpdated method is optional with a result set concurrency of CONCUR_READ_ONLY
    
    Returns:
    true if the current row is detected to have been visibly updated by the owner or another; false otherwise
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
    See Also:
    DatabaseMetaData.updatesAreDetected(int)
  - rowInserted
```
boolean rowInserted()
                    throws SQLException
```
    Retrieves whether the current row has had an insertion. The value returned depends on whether or not this ResultSet object can detect visible inserts.
    Note: Support for the rowInserted method is optional with a result set concurrency of CONCUR_READ_ONLY
    
    Returns:
    true if the current row is detected to have been inserted; false otherwise
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
    See Also:
    DatabaseMetaData.insertsAreDetected(int)
  - rowDeleted
```
boolean rowDeleted()
                   throws SQLException
```
    Retrieves whether a row has been deleted. A deleted row may leave a visible "hole" in a result set. This method can be used to detect holes in a result set. The value returned depends on whether or not this ResultSet object can detect deletions.
    Note: Support for the rowDeleted method is optional with a result set concurrency of CONCUR_READ_ONLY
    
    Returns:
    true if the current row is detected to have been deleted by the owner or another; false otherwise
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
    See Also:
    DatabaseMetaData.deletesAreDetected(int)
  - updateNull
```
void updateNull(int columnIndex)
                throws SQLException
```
    Updates the designated column with a null value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateBoolean
```
void updateBoolean(int columnIndex,
                 boolean x)
                   throws SQLException
```
    Updates the designated column with a boolean value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateByte
```
void updateByte(int columnIndex,
              byte x)
                throws SQLException
```
    Updates the designated column with a byte value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateShort
```
void updateShort(int columnIndex,
               short x)
                 throws SQLException
```
    Updates the designated column with a short value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateInt
```
void updateInt(int columnIndex,
             int x)
               throws SQLException
```
    Updates the designated column with an int value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateLong
```
void updateLong(int columnIndex,
              long x)
                throws SQLException
```
    Updates the designated column with a long value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateFloat
```
void updateFloat(int columnIndex,
               float x)
                 throws SQLException
```
    Updates the designated column with a float value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateDouble
```
void updateDouble(int columnIndex,
                double x)
                  throws SQLException
```
    Updates the designated column with a double value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateBigDecimal
```
void updateBigDecimal(int columnIndex,
                    BigDecimal x)
                      throws SQLException
```
    Updates the designated column with a java.math.BigDecimal value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateString
```
void updateString(int columnIndex,
                String x)
                  throws SQLException
```
    Updates the designated column with a String value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateBytes
```
void updateBytes(int columnIndex,
               byte[] x)
                 throws SQLException
```
    Updates the designated column with a byte array value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateDate
```
void updateDate(int columnIndex,
              Date x)
                throws SQLException
```
    Updates the designated column with a java.sql.Date value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateTime
```
void updateTime(int columnIndex,
              Time x)
                throws SQLException
```
    Updates the designated column with a java.sql.Time value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateTimestamp
```
void updateTimestamp(int columnIndex,
                   Timestamp x)
                     throws SQLException
```
    Updates the designated column with a java.sql.Timestamp value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateAsciiStream
```
void updateAsciiStream(int columnIndex,
                     InputStream x,
                     int length)
                       throws SQLException
```
    Updates the designated column with an ascii stream value, which will have the specified number of bytes. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateBinaryStream
```
void updateBinaryStream(int columnIndex,
                      InputStream x,
                      int length)
                        throws SQLException
```
    Updates the designated column with a binary stream value, which will have the specified number of bytes. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateCharacterStream
```
void updateCharacterStream(int columnIndex,
                         Reader x,
                         int length)
                           throws SQLException
```
    Updates the designated column with a character stream value, which will have the specified number of bytes. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateObject
```
void updateObject(int columnIndex,
                Object x,
                int scaleOrLength)
                  throws SQLException
```
    Updates the designated column with an Object value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    If the second argument is an InputStream then the stream must contain the number of bytes specified by scaleOrLength. If the second argument is a Reader then the reader must contain the number of characters specified by scaleOrLength. If these conditions are not true the driver will generate a SQLException when the statement is executed.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    scaleOrLength - for an object of java.math.BigDecimal , this is the number of digits after the decimal point. For Java Object types InputStream and Reader, this is the length of the data in the stream or reader. For all other types, this value will be ignored.
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateObject
```
void updateObject(int columnIndex,
                Object x)
                  throws SQLException
```
    Updates the designated column with an Object value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateNull
```
void updateNull(String columnLabel)
                throws SQLException
```
    Updates the designated column with a null value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateBoolean
```
void updateBoolean(String columnLabel,
                 boolean x)
                   throws SQLException
```
    Updates the designated column with a boolean value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateByte
```
void updateByte(String columnLabel,
              byte x)
                throws SQLException
```
    Updates the designated column with a byte value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateShort
```
void updateShort(String columnLabel,
               short x)
                 throws SQLException
```
    Updates the designated column with a short value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateInt
```
void updateInt(String columnLabel,
             int x)
               throws SQLException
```
    Updates the designated column with an int value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateLong
```
void updateLong(String columnLabel,
              long x)
                throws SQLException
```
    Updates the designated column with a long value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateFloat
```
void updateFloat(String columnLabel,
               float x)
                 throws SQLException
```
    Updates the designated column with a float value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateDouble
```
void updateDouble(String columnLabel,
                double x)
                  throws SQLException
```
    Updates the designated column with a double value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateBigDecimal
```
void updateBigDecimal(String columnLabel,
                    BigDecimal x)
                      throws SQLException
```
    Updates the designated column with a java.sql.BigDecimal value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateString
```
void updateString(String columnLabel,
                String x)
                  throws SQLException
```
    Updates the designated column with a String value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateBytes
```
void updateBytes(String columnLabel,
               byte[] x)
                 throws SQLException
```
    Updates the designated column with a byte array value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateDate
```
void updateDate(String columnLabel,
              Date x)
                throws SQLException
```
    Updates the designated column with a java.sql.Date value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateTime
```
void updateTime(String columnLabel,
              Time x)
                throws SQLException
```
    Updates the designated column with a java.sql.Time value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateTimestamp
```
void updateTimestamp(String columnLabel,
                   Timestamp x)
                     throws SQLException
```
    Updates the designated column with a java.sql.Timestamp value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateAsciiStream
```
void updateAsciiStream(String columnLabel,
                     InputStream x,
                     int length)
                       throws SQLException
```
    Updates the designated column with an ascii stream value, which will have the specified number of bytes. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateBinaryStream
```
void updateBinaryStream(String columnLabel,
                      InputStream x,
                      int length)
                        throws SQLException
```
    Updates the designated column with a binary stream value, which will have the specified number of bytes. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateCharacterStream
```
void updateCharacterStream(String columnLabel,
                         Reader reader,
                         int length)
                           throws SQLException
```
    Updates the designated column with a character stream value, which will have the specified number of bytes. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    reader - the java.io.Reader object containing the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateObject
```
void updateObject(String columnLabel,
                Object x,
                int scaleOrLength)
                  throws SQLException
```
    Updates the designated column with an Object value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    If the second argument is an InputStream then the stream must contain the number of bytes specified by scaleOrLength. If the second argument is a Reader then the reader must contain the number of characters specified by scaleOrLength. If these conditions are not true the driver will generate a SQLException when the statement is executed.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    scaleOrLength - for an object of java.math.BigDecimal , this is the number of digits after the decimal point. For Java Object types InputStream and Reader, this is the length of the data in the stream or reader. For all other types, this value will be ignored.
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateObject
```
void updateObject(String columnLabel,
                Object x)
                  throws SQLException
```
    Updates the designated column with an Object value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - insertRow
```
void insertRow()
               throws SQLException
```
    Inserts the contents of the insert row into this ResultSet object and into the database. The cursor must be on the insert row when this method is called.
    
    Throws:
    SQLException - if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY, this method is called on a closed result set, if this method is called when the cursor is not on the insert row, or if not all of non-nullable columns in the insert row have been given a non-null value
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - updateRow
```
void updateRow()
               throws SQLException
```
    Updates the underlying database with the new contents of the current row of this ResultSet object. This method cannot be called when the cursor is on the insert row.
    
    Throws:
    SQLException - if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY; this method is called on a closed result set or if this method is called when the cursor is on the insert row
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - deleteRow
```
void deleteRow()
               throws SQLException
```
    Deletes the current row from this ResultSet object and from the underlying database. This method cannot be called when the cursor is on the insert row.
    
    Throws:
    SQLException - if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY; this method is called on a closed result set or if this method is called when the cursor is on the insert row
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - refreshRow
```
void refreshRow()
                throws SQLException
```
    Refreshes the current row with its most recent value in the database. This method cannot be called when the cursor is on the insert row.
    The refreshRow method provides a way for an application to explicitly tell the JDBC driver to refetch a row(s) from the database. An application may want to call refreshRow when caching or prefetching is being done by the JDBC driver to fetch the latest value of a row from the database. The JDBC driver may actually refresh multiple rows at once if the fetch size is greater than one.
    
    All values are refetched subject to the transaction isolation level and cursor sensitivity. If refreshRow is called after calling an updater method, but before calling the method updateRow, then the updates made to the row are lost. Calling the method refreshRow frequently will likely slow performance.
    
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set; the result set type is TYPE_FORWARD_ONLY or if this method is called when the cursor is on the insert row
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method or this method is not supported for the specified result set type and result set concurrency.
    Since:
    1.2
  - cancelRowUpdates
```
void cancelRowUpdates()
                      throws SQLException
```
    Cancels the updates made to the current row in this ResultSet object. This method may be called after calling an updater method(s) and before calling the method updateRow to roll back the updates made to a row. If no updates have been made or updateRow has already been called, this method has no effect.
    
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set; the result set concurrency is CONCUR_READ_ONLY or if this method is called when the cursor is on the insert row
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - moveToInsertRow
```
void moveToInsertRow()
                     throws SQLException
```
    Moves the cursor to the insert row. The current cursor position is remembered while the cursor is positioned on the insert row. The insert row is a special row associated with an updatable result set. It is essentially a buffer where a new row may be constructed by calling the updater methods prior to inserting the row into the result set. Only the updater, getter, and insertRow methods may be called when the cursor is on the insert row. All of the columns in a result set must be given a value each time this method is called before calling insertRow. An updater method must be called before a getter method can be called on a column value.
    
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set or the result set concurrency is CONCUR_READ_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - moveToCurrentRow
```
void moveToCurrentRow()
                      throws SQLException
```
    Moves the cursor to the remembered cursor position, usually the current row. This method has no effect if the cursor is not on the insert row.
    
    Throws:
    SQLException - if a database access error occurs; this method is called on a closed result set or the result set concurrency is CONCUR_READ_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getStatement
```
Statement getStatement()
                       throws SQLException
```
    Retrieves the Statement object that produced this ResultSet object. If the result set was generated some other way, such as by a DatabaseMetaData method, this method may return null.
    
    Returns:
    the Statment object that produced this ResultSet object or null if the result set was produced some other way
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - getObject
```
Object getObject(int columnIndex,
               Map<String,Class<?>> map)
                 throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as an Object in the Java programming language. If the value is an SQL NULL, the driver returns a Java null. This method uses the given Map object for the custom mapping of the SQL structured or distinct type that is being retrieved.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    map - a java.util.Map object that contains the mapping from SQL type names to classes in the Java programming language
    Returns:
    an Object in the Java programming language representing the SQL value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getRef
```
Ref getRef(int columnIndex)
           throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a Ref object in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    a Ref object representing an SQL REF value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getBlob
```
Blob getBlob(int columnIndex)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a Blob object in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    a Blob object representing the SQL BLOB value in the specified column
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getClob
```
Clob getClob(int columnIndex)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a Clob object in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    a Clob object representing the SQL CLOB value in the specified column
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getArray
```
Array getArray(int columnIndex)
               throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as an Array object in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    an Array object representing the SQL ARRAY value in the specified column
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getObject
```
Object getObject(String columnLabel,
               Map<String,Class<?>> map)
                 throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as an Object in the Java programming language. If the value is an SQL NULL, the driver returns a Java null. This method uses the specified Map object for custom mapping if appropriate.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    map - a java.util.Map object that contains the mapping from SQL type names to classes in the Java programming language
    Returns:
    an Object representing the SQL value in the specified column
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getRef
```
Ref getRef(String columnLabel)
           throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a Ref object in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    a Ref object representing the SQL REF value in the specified column
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getBlob
```
Blob getBlob(String columnLabel)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a Blob object in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    a Blob object representing the SQL BLOB value in the specified column
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getClob
```
Clob getClob(String columnLabel)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a Clob object in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    a Clob object representing the SQL CLOB value in the specified column
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getArray
```
Array getArray(String columnLabel)
               throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as an Array object in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    an Array object representing the SQL ARRAY value in the specified column
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.2
  - getDate
```
Date getDate(int columnIndex,
           Calendar cal)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language. This method uses the given calendar to construct an appropriate millisecond value for the date if the underlying database does not store timezone information.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    cal - the java.util.Calendar object to use in constructing the date
    Returns:
    the column value as a java.sql.Date object; if the value is SQL NULL, the value returned is null in the Java programming language
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - getDate
```
Date getDate(String columnLabel,
           Calendar cal)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Date object in the Java programming language. This method uses the given calendar to construct an appropriate millisecond value for the date if the underlying database does not store timezone information.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    cal - the java.util.Calendar object to use in constructing the date
    Returns:
    the column value as a java.sql.Date object; if the value is SQL NULL, the value returned is null in the Java programming language
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - getTime
```
Time getTime(int columnIndex,
           Calendar cal)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language. This method uses the given calendar to construct an appropriate millisecond value for the time if the underlying database does not store timezone information.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    cal - the java.util.Calendar object to use in constructing the time
    Returns:
    the column value as a java.sql.Time object; if the value is SQL NULL, the value returned is null in the Java programming language
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - getTime
```
Time getTime(String columnLabel,
           Calendar cal)
             throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Time object in the Java programming language. This method uses the given calendar to construct an appropriate millisecond value for the time if the underlying database does not store timezone information.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    cal - the java.util.Calendar object to use in constructing the time
    Returns:
    the column value as a java.sql.Time object; if the value is SQL NULL, the value returned is null in the Java programming language
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - getTimestamp
```
Timestamp getTimestamp(int columnIndex,
                     Calendar cal)
                       throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Timestamp object in the Java programming language. This method uses the given calendar to construct an appropriate millisecond value for the timestamp if the underlying database does not store timezone information.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    cal - the java.util.Calendar object to use in constructing the timestamp
    Returns:
    the column value as a java.sql.Timestamp object; if the value is SQL NULL, the value returned is null in the Java programming language
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - getTimestamp
```
Timestamp getTimestamp(String columnLabel,
                     Calendar cal)
                       throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.Timestamp object in the Java programming language. This method uses the given calendar to construct an appropriate millisecond value for the timestamp if the underlying database does not store timezone information.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    cal - the java.util.Calendar object to use in constructing the date
    Returns:
    the column value as a java.sql.Timestamp object; if the value is SQL NULL, the value returned is null in the Java programming language
    Throws:
    SQLException - if the columnLabel is not valid or if a database access error occurs or this method is called on a closed result set
    Since:
    1.2
  - getURL
```
URL getURL(int columnIndex)
           throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.net.URL object in the Java programming language.
    
    Parameters:
    columnIndex - the index of the column 1 is the first, 2 is the second,...
    Returns:
    the column value as a java.net.URL object; if the value is SQL NULL, the value returned is null in the Java programming language
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; this method is called on a closed result set or if a URL is malformed
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.4
  - getURL
```
URL getURL(String columnLabel)
           throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.net.URL object in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value as a java.net.URL object; if the value is SQL NULL, the value returned is null in the Java programming language
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; this method is called on a closed result set or if a URL is malformed
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.4
  - updateRef
```
void updateRef(int columnIndex,
             Ref x)
               throws SQLException
```
    Updates the designated column with a java.sql.Ref value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.4
  - updateRef
```
void updateRef(String columnLabel,
             Ref x)
               throws SQLException
```
    Updates the designated column with a java.sql.Ref value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.4
  - updateBlob
```
void updateBlob(int columnIndex,
              Blob x)
                throws SQLException
```
    Updates the designated column with a java.sql.Blob value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.4
  - updateBlob
```
void updateBlob(String columnLabel,
              Blob x)
                throws SQLException
```
    Updates the designated column with a java.sql.Blob value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.4
  - updateClob
```
void updateClob(int columnIndex,
              Clob x)
                throws SQLException
```
    Updates the designated column with a java.sql.Clob value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.4
  - updateClob
```
void updateClob(String columnLabel,
              Clob x)
                throws SQLException
```
    Updates the designated column with a java.sql.Clob value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.4
  - updateArray
```
void updateArray(int columnIndex,
               Array x)
                 throws SQLException
```
    Updates the designated column with a java.sql.Array value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.4
  - updateArray
```
void updateArray(String columnLabel,
               Array x)
                 throws SQLException
```
    Updates the designated column with a java.sql.Array value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.4
  - getRowId
```
RowId getRowId(int columnIndex)
               throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.RowId object in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second 2, ...
    Returns:
    the column value; if the value is a SQL NULL the value returned is null
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - getRowId
```
RowId getRowId(String columnLabel)
               throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.sql.RowId object in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value ; if the value is a SQL NULL the value returned is null
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateRowId
```
void updateRowId(int columnIndex,
               RowId x)
                 throws SQLException
```
    Updates the designated column with a RowId value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second 2, ...
    x - the column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateRowId
```
void updateRowId(String columnLabel,
               RowId x)
                 throws SQLException
```
    Updates the designated column with a RowId value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - getHoldability
```
int getHoldability()
                   throws SQLException
```
    Retrieves the holdability of this ResultSet object
    
    Returns:
    either ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
    Throws:
    SQLException - if a database access error occurs or this method is called on a closed result set
    Since:
    1.6
  - isClosed
```
boolean isClosed()
                 throws SQLException
```
    Retrieves whether this ResultSet object has been closed. A ResultSet is closed if the method close has been called on it, or if it is automatically closed.
    
    Returns:
    true if this ResultSet object is closed; false if it is still open
    Throws:
    SQLException - if a database access error occurs
    Since:
    1.6
  - updateNString
```
void updateNString(int columnIndex,
                 String nString)
                   throws SQLException
```
    Updates the designated column with a String value. It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second 2, ...
    nString - the value for the column to be updated
    Throws:
    SQLException - if the columnIndex is not valid; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; this method is called on a closed result set; the result set concurrency is CONCUR_READ_ONLY or if a database access error occurs
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateNString
```
void updateNString(String columnLabel,
                 String nString)
                   throws SQLException
```
    Updates the designated column with a String value. It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    nString - the value for the column to be updated
    Throws:
    SQLException - if the columnLabel is not valid; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; this method is called on a closed result set; the result set concurrency is CONCUR_READ_ONLY or if a database access error occurs
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateNClob
```
void updateNClob(int columnIndex,
               NClob nClob)
                 throws SQLException
```
    Updates the designated column with a java.sql.NClob value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second 2, ...
    nClob - the value for the column to be updated
    Throws:
    SQLException - if the columnIndex is not valid; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; this method is called on a closed result set; if a database access error occurs or the result set concurrency is CONCUR_READ_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateNClob
```
void updateNClob(String columnLabel,
               NClob nClob)
                 throws SQLException
```
    Updates the designated column with a java.sql.NClob value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    nClob - the value for the column to be updated
    Throws:
    SQLException - if the columnLabel is not valid; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; this method is called on a closed result set; if a database access error occurs or the result set concurrency is CONCUR_READ_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - getNClob
```
NClob getNClob(int columnIndex)
               throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a NClob object in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    a NClob object representing the SQL NCLOB value in the specified column
    Throws:
    SQLException - if the columnIndex is not valid; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; this method is called on a closed result set or if a database access error occurs
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - getNClob
```
NClob getNClob(String columnLabel)
               throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a NClob object in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    a NClob object representing the SQL NCLOB value in the specified column
    Throws:
    SQLException - if the columnLabel is not valid; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; this method is called on a closed result set or if a database access error occurs
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - getSQLXML
```
SQLXML getSQLXML(int columnIndex)
                 throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet as a java.sql.SQLXML object in the Java programming language.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    a SQLXML object that maps an SQL XML value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - getSQLXML
```
SQLXML getSQLXML(String columnLabel)
                 throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet as a java.sql.SQLXML object in the Java programming language.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    a SQLXML object that maps an SQL XML value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateSQLXML
```
void updateSQLXML(int columnIndex,
                SQLXML xmlObject)
                  throws SQLException
```
    Updates the designated column with a java.sql.SQLXML value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second 2, ...
    xmlObject - the value for the column to be updated
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; this method is called on a closed result set; the java.xml.transform.Result, Writer or OutputStream has not been closed for the SQLXML object; if there is an error processing the XML value or the result set concurrency is CONCUR_READ_ONLY. The getCause method of the exception may provide a more detailed exception, for example, if the stream does not contain valid XML.
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateSQLXML
```
void updateSQLXML(String columnLabel,
                SQLXML xmlObject)
                  throws SQLException
```
    Updates the designated column with a java.sql.SQLXML value. The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    xmlObject - the column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; this method is called on a closed result set; the java.xml.transform.Result, Writer or OutputStream has not been closed for the SQLXML object; if there is an error processing the XML value or the result set concurrency is CONCUR_READ_ONLY. The getCause method of the exception may provide a more detailed exception, for example, if the stream does not contain valid XML.
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - getNString
```
String getNString(int columnIndex)
                  throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a String in the Java programming language. It is intended for use when accessing NCHAR,NVARCHAR and LONGNVARCHAR columns.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - getNString
```
String getNString(String columnLabel)
                  throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a String in the Java programming language. It is intended for use when accessing NCHAR,NVARCHAR and LONGNVARCHAR columns.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    the column value; if the value is SQL NULL, the value returned is null
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - getNCharacterStream
```
Reader getNCharacterStream(int columnIndex)
                           throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.io.Reader object. It is intended for use when accessing NCHAR,NVARCHAR and LONGNVARCHAR columns.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    Returns:
    a java.io.Reader object that contains the column value; if the value is SQL NULL, the value returned is null in the Java programming language.
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - getNCharacterStream
```
Reader getNCharacterStream(String columnLabel)
                           throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object as a java.io.Reader object. It is intended for use when accessing NCHAR,NVARCHAR and LONGNVARCHAR columns.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    Returns:
    a java.io.Reader object that contains the column value; if the value is SQL NULL, the value returned is null in the Java programming language
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateNCharacterStream
```
void updateNCharacterStream(int columnIndex,
                          Reader x,
                          long length)
                            throws SQLException
```
    Updates the designated column with a character stream value, which will have the specified number of bytes. The driver does the necessary conversion from Java character format to the national character set in the database. It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateNCharacterStream
```
void updateNCharacterStream(String columnLabel,
                          Reader reader,
                          long length)
                            throws SQLException
```
    Updates the designated column with a character stream value, which will have the specified number of bytes. The driver does the necessary conversion from Java character format to the national character set in the database. It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    reader - the java.io.Reader object containing the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateAsciiStream
```
void updateAsciiStream(int columnIndex,
                     InputStream x,
                     long length)
                       throws SQLException
```
    Updates the designated column with an ascii stream value, which will have the specified number of bytes.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateBinaryStream
```
void updateBinaryStream(int columnIndex,
                      InputStream x,
                      long length)
                        throws SQLException
```
    Updates the designated column with a binary stream value, which will have the specified number of bytes.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateCharacterStream
```
void updateCharacterStream(int columnIndex,
                         Reader x,
                         long length)
                           throws SQLException
```
    Updates the designated column with a character stream value, which will have the specified number of bytes.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateAsciiStream
```
void updateAsciiStream(String columnLabel,
                     InputStream x,
                     long length)
                       throws SQLException
```
    Updates the designated column with an ascii stream value, which will have the specified number of bytes.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateBinaryStream
```
void updateBinaryStream(String columnLabel,
                      InputStream x,
                      long length)
                        throws SQLException
```
    Updates the designated column with a binary stream value, which will have the specified number of bytes.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateCharacterStream
```
void updateCharacterStream(String columnLabel,
                         Reader reader,
                         long length)
                           throws SQLException
```
    Updates the designated column with a character stream value, which will have the specified number of bytes.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    reader - the java.io.Reader object containing the new column value
    length - the length of the stream
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateBlob
```
void updateBlob(int columnIndex,
              InputStream inputStream,
              long length)
                throws SQLException
```
    Updates the designated column using the given input stream, which will have the specified number of bytes.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    inputStream - An object that contains the data to set the parameter value to.
    length - the number of bytes in the parameter data.
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateBlob
```
void updateBlob(String columnLabel,
              InputStream inputStream,
              long length)
                throws SQLException
```
    Updates the designated column using the given input stream, which will have the specified number of bytes.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    inputStream - An object that contains the data to set the parameter value to.
    length - the number of bytes in the parameter data.
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateClob
```
void updateClob(int columnIndex,
              Reader reader,
              long length)
                throws SQLException
```
    Updates the designated column using the given Reader object, which is the given number of characters long. When a very large UNICODE value is input to a LONGVARCHAR parameter, it may be more practical to send it via a java.io.Reader object. The JDBC driver will do any necessary conversion from UNICODE to the database char format.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    reader - An object that contains the data to set the parameter value to.
    length - the number of characters in the parameter data.
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateClob
```
void updateClob(String columnLabel,
              Reader reader,
              long length)
                throws SQLException
```
    Updates the designated column using the given Reader object, which is the given number of characters long. When a very large UNICODE value is input to a LONGVARCHAR parameter, it may be more practical to send it via a java.io.Reader object. The JDBC driver will do any necessary conversion from UNICODE to the database char format.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    reader - An object that contains the data to set the parameter value to.
    length - the number of characters in the parameter data.
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateNClob
```
void updateNClob(int columnIndex,
               Reader reader,
               long length)
                 throws SQLException
```
    Updates the designated column using the given Reader object, which is the given number of characters long. When a very large UNICODE value is input to a LONGVARCHAR parameter, it may be more practical to send it via a java.io.Reader object. The JDBC driver will do any necessary conversion from UNICODE to the database char format.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnIndex - the first column is 1, the second 2, ...
    reader - An object that contains the data to set the parameter value to.
    length - the number of characters in the parameter data.
    Throws:
    SQLException - if the columnIndex is not valid; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; this method is called on a closed result set, if a database access error occurs or the result set concurrency is CONCUR_READ_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateNClob
```
void updateNClob(String columnLabel,
               Reader reader,
               long length)
                 throws SQLException
```
    Updates the designated column using the given Reader object, which is the given number of characters long. When a very large UNICODE value is input to a LONGVARCHAR parameter, it may be more practical to send it via a java.io.Reader object. The JDBC driver will do any necessary conversion from UNICODE to the database char format.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    reader - An object that contains the data to set the parameter value to.
    length - the number of characters in the parameter data.
    Throws:
    SQLException - if the columnLabel is not valid; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; this method is called on a closed result set; if a database access error occurs or the result set concurrency is CONCUR_READ_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateNCharacterStream
```
void updateNCharacterStream(int columnIndex,
                          Reader x)
                            throws SQLException
```
    Updates the designated column with a character stream value. The data will be read from the stream as needed until end-of-stream is reached. The driver does the necessary conversion from Java character format to the national character set in the database. It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateNCharacterStream which takes a length parameter.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateNCharacterStream
```
void updateNCharacterStream(String columnLabel,
                          Reader reader)
                            throws SQLException
```
    Updates the designated column with a character stream value. The data will be read from the stream as needed until end-of-stream is reached. The driver does the necessary conversion from Java character format to the national character set in the database. It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateNCharacterStream which takes a length parameter.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    reader - the java.io.Reader object containing the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateAsciiStream
```
void updateAsciiStream(int columnIndex,
                     InputStream x)
                       throws SQLException
```
    Updates the designated column with an ascii stream value. The data will be read from the stream as needed until end-of-stream is reached.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateAsciiStream which takes a length parameter.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateBinaryStream
```
void updateBinaryStream(int columnIndex,
                      InputStream x)
                        throws SQLException
```
    Updates the designated column with a binary stream value. The data will be read from the stream as needed until end-of-stream is reached.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateBinaryStream which takes a length parameter.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateCharacterStream
```
void updateCharacterStream(int columnIndex,
                         Reader x)
                           throws SQLException
```
    Updates the designated column with a character stream value. The data will be read from the stream as needed until end-of-stream is reached.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateCharacterStream which takes a length parameter.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    x - the new column value
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateAsciiStream
```
void updateAsciiStream(String columnLabel,
                     InputStream x)
                       throws SQLException
```
    Updates the designated column with an ascii stream value. The data will be read from the stream as needed until end-of-stream is reached.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateAsciiStream which takes a length parameter.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateBinaryStream
```
void updateBinaryStream(String columnLabel,
                      InputStream x)
                        throws SQLException
```
    Updates the designated column with a binary stream value. The data will be read from the stream as needed until end-of-stream is reached.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateBinaryStream which takes a length parameter.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    x - the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateCharacterStream
```
void updateCharacterStream(String columnLabel,
                         Reader reader)
                           throws SQLException
```
    Updates the designated column with a character stream value. The data will be read from the stream as needed until end-of-stream is reached.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateCharacterStream which takes a length parameter.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    reader - the java.io.Reader object containing the new column value
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateBlob
```
void updateBlob(int columnIndex,
              InputStream inputStream)
                throws SQLException
```
    Updates the designated column using the given input stream. The data will be read from the stream as needed until end-of-stream is reached.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateBlob which takes a length parameter.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    inputStream - An object that contains the data to set the parameter value to.
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateBlob
```
void updateBlob(String columnLabel,
              InputStream inputStream)
                throws SQLException
```
    Updates the designated column using the given input stream. The data will be read from the stream as needed until end-of-stream is reached.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateBlob which takes a length parameter.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    inputStream - An object that contains the data to set the parameter value to.
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateClob
```
void updateClob(int columnIndex,
              Reader reader)
                throws SQLException
```
    Updates the designated column using the given Reader object. The data will be read from the stream as needed until end-of-stream is reached. The JDBC driver will do any necessary conversion from UNICODE to the database char format.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateClob which takes a length parameter.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    reader - An object that contains the data to set the parameter value to.
    Throws:
    SQLException - if the columnIndex is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateClob
```
void updateClob(String columnLabel,
              Reader reader)
                throws SQLException
```
    Updates the designated column using the given Reader object. The data will be read from the stream as needed until end-of-stream is reached. The JDBC driver will do any necessary conversion from UNICODE to the database char format.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateClob which takes a length parameter.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    reader - An object that contains the data to set the parameter value to.
    Throws:
    SQLException - if the columnLabel is not valid; if a database access error occurs; the result set concurrency is CONCUR_READ_ONLY or this method is called on a closed result set
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateNClob
```
void updateNClob(int columnIndex,
               Reader reader)
                 throws SQLException
```
    Updates the designated column using the given Reader The data will be read from the stream as needed until end-of-stream is reached. The JDBC driver will do any necessary conversion from UNICODE to the database char format.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateNClob which takes a length parameter.
    
    Parameters:
    columnIndex - the first column is 1, the second 2, ...
    reader - An object that contains the data to set the parameter value to.
    Throws:
    SQLException - if the columnIndex is not valid; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; this method is called on a closed result set, if a database access error occurs or the result set concurrency is CONCUR_READ_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - updateNClob
```
void updateNClob(String columnLabel,
               Reader reader)
                 throws SQLException
```
    Updates the designated column using the given Reader object. The data will be read from the stream as needed until end-of-stream is reached. The JDBC driver will do any necessary conversion from UNICODE to the database char format.
    The updater methods are used to update column values in the current row or the insert row. The updater methods do not update the underlying database; instead the updateRow or insertRow methods are called to update the database.
    
    Note: Consult your JDBC driver documentation to determine if it might be more efficient to use a version of updateNClob which takes a length parameter.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    reader - An object that contains the data to set the parameter value to.
    Throws:
    SQLException - if the columnLabel is not valid; if the driver does not support national character sets; if the driver can detect that a data conversion error could occur; this method is called on a closed result set; if a database access error occurs or the result set concurrency is CONCUR_READ_ONLY
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.6
  - getObject
```
<T> T getObject(int columnIndex,
              Class<T> type)
            throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object and will convert from the SQL type of the column to the requested Java data type, if the conversion is supported. If the conversion is not supported or null is specified for the type, a SQLException is thrown.
    
    At a minimum, an implementation must support the conversions defined in Appendix B, Table B-3 and conversion of appropriate user defined SQL types to a Java type which implements SQLData, or Struct. Additional conversions may be supported and are vendor defined.
    
    Parameters:
    columnIndex - the first column is 1, the second is 2, ...
    type - Class representing the Java data type to convert the designated column to.
    Returns:
    an instance of type holding the column value
    Throws:
    SQLException - if conversion is not supported, type is null or another error occurs. The getCause() method of the exception may provide a more detailed exception, for example, if a conversion error occurs
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.7
  - getObject
```
<T> T getObject(String columnLabel,
              Class<T> type)
            throws SQLException
```
    Retrieves the value of the designated column in the current row of this ResultSet object and will convert from the SQL type of the column to the requested Java data type, if the conversion is supported. If the conversion is not supported or null is specified for the type, a SQLException is thrown.
    
    At a minimum, an implementation must support the conversions defined in Appendix B, Table B-3 and conversion of appropriate user defined SQL types to a Java type which implements SQLData, or Struct. Additional conversions may be supported and are vendor defined.
    
    Parameters:
    columnLabel - the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column
    type - Class representing the Java data type to convert the designated column to.
    Returns:
    an instance of type holding the column value
    Throws:
    SQLException - if conversion is not supported, type is null or another error occurs. The getCause() method of the exception may provide a more detailed exception, for example, if a conversion error occurs
    SQLFeatureNotSupportedException - if the JDBC driver does not support this method
    Since:
    1.7

查看全文

相关阅读:
超级钢琴 2010年NOI
vijos P1375 大整数（高精不熟的一定要做！）
COGS 445. [HAOI2010]最长公共子序列
 系统升级
 mariabd mysql升级mariadb
mysql view 视图
 mysql 杂
 mysql主从复制
 DNS迭代查询与递归查询的区别
 Python 中 str 和 repr 的区别

原文地址：https://www.cnblogs.com/timssd/p/4796038.html