精华内容
下载资源
问答
  • 模拟结果集 MockResultSet是由CSV数据支持的的实现。 旨在克服诸如数据库服务器或VPN不可用之类的基础架构限制。 MockResultSet允许程序员即使没有...如果数据库服务器不可访问,则可以使用CSV数据模拟ResultSet ,如
  • 主要介绍了java中ResultSet遍历数据操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 最近在做毕业设计,需要用到数据库,在用结果集ResultSet判断的时候遇到一个郁闷的事情。 一开始我的想法是这么一个框架: ResultSet rs = dao.executeQuery(sql); if(rs不为空){ while(rs.next()){ … } }else{ … ...
  • 主要介绍了JSP获取ResultSet结果集中数据的方法,文后还介绍一种遍历ResultSet中的数据并转化为表格的方法,需要的朋友可以参考下
  • 主要介绍了将ResultSet中得到的一行或多行结果集封装成对象的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 资源所属:https://blog.csdn.net/qq_16773953/article/details/103461172
  • ResultSet

    千次阅读 多人点赞 2018-08-30 19:46:23
    ResultSet 的功能 java.sql.ResultSet接口表示一个数据库查询的结果集。一个ResultSet对象具有一个游标指向当前行的结果集。 最初,光标被置于第一行之前。调用 next() 方法将光标移动到下一行;因为该方法在 ...

    ResultSet 的功能

    java.sql.ResultSet接口表示一个数据库查询的结果集。一个ResultSet对象具有一个游标指向当前行的结果集。 最初,光标被置于第一行之前。调用 next() 方法将光标移动到下一行;因为该方法在 ResultSet 对象没有下一行时返回 false, 所以可以在 while 循环中使用它来迭代结果集,调用getXXX(int fieldIndex)/getXXX(String columnName)方法获取字段值。

    2、ResultSet 接口提供用于从当前行获取列值的获取方法。

    可以使用列的索引编号或列的名称获取值。一般情况下,使用列索引较为高效。列从 1开始编号。为了获得最大的可移植性,应该按从左到右的顺序读取每行中的结果集列, 每列只能读取一次。

    注:用作获取方法的输入的列名称不区分大小写

    获取ResultSet的值

    1 、读取方法1 – 通过索引来遍历读取

    while(rs.next()){
            int id = rs.getInt(1);
            String name = rs.getString(2);
            String gender = rs.getString(3);
            System.out.println("学号:"+id+" 姓名:"+name+" 性别:"+gender);
        }

    2 、读取方法2 – 通过字段名称来读取

    while(rs.next()){
            int id = rs.getInt("id");
            String name = rs.getString("name");
            String gender = rs.getString("gender");
            System.out.println("学号:"+id+" 姓名:"+name+" 性别:"+gender);
        }

    强调一下,这个传入的字段名称可以不区分大小写,因为在mysql中就是不区分的

    这里注意以下,当ResultSet代表的结果集是多列记录时,我们就需要通过两层循环去读取ResultSet里的值了,通过此方法获得列的个数:

    ResultSetMetaData metaData = resultSet.getMetaData();
    int numberOfColumns = metaData.getColumnCount();//获得查询结果的列的个数。

     

    展开全文
  • NULL 博文链接:https://rickgong.iteye.com/blog/2354177
  • ResultSet转List

    2016-03-10 10:36:40
    ResultSet转List
  • ResultSet接口

    2019-08-06 01:28:16
    NULL 博文链接:https://chaoyi.iteye.com/blog/2088077
  • 主要介绍了java sql ResultSet 之getRow()用法说明,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 绍Java中ResultSet转换为List的方法
  • 通过反射从数据库返回集合ResultSet中得到实体对象的list集合
  • ResultSet用法集锦

    2019-04-01 01:27:19
    NULL 博文链接:https://soft-development.iteye.com/blog/1420323
  • Java ResultSet教程

    2020-07-07 03:54:52
    Java ResultSet interface is a part of the java.sql package. It is one of the core components of the JDBC Framework. ResultSet Object is used to access query results retrieved from the relational datab...

    Java ResultSet interface is a part of the java.sql package. It is one of the core components of the JDBC Framework. ResultSet Object is used to access query results retrieved from the relational databases.

    Java ResultSet接口是java.sql包的一部分。 它是JDBC框架的核心组件之一。 ResultSet对象用于访问从关系数据库检索的查询结果。

    ResultSet maintains cursor/pointer which points to a single row of the query results. Using navigational and getter methods provided by ResultSet, we can iterate and access database records one by one. ResultSet can also be used to update data.

    ResultSet维护指向查询结果的单行的光标/指针。 使用ResultSet提供的导航和获取方法,我们可以一个一个地迭代和访问数据库记录。 ResultSet也可以用于更新数据。

    Java ResultSet层次结构 (Java ResultSet Hierarchy)

    Java ResultSet Class Hierarchy
    Java ResultSet Class Hierarchy
    Java ResultSet类层次结构

    The above diagram shows the place of ResultSet in the JDBC Framework. ResultSet can be obtained by executing SQL Query using Statement, PreparedStatement or CallableStatement.

    上图显示了ResultSet在JDBC Framework中的位置。 通过使用StatementPreparedStatementCallableStatement执行SQL查询可以获得ResultSet

    AutoCloseable, Wrapper are super interfaces of ResultSet.  Now we will see how to work with ResultSet in our Java programs.

    AutoCloseableWrapper是ResultSet的超级接口。 现在,我们将看到如何在Java程序中使用ResultSet。

    ResultSet示例 (ResultSet Example)

    We will be using MySQL for our example purpose. Use below DB script to create a database and table along with some records.

    我们将使用MySQL作为示例。 使用下面的DB脚本来创建数据库和表以及一些记录。

    
    create database empdb;
    
    use empdb;
    
    create table tblemployee (empid integer primary key, firstname varchar(32), lastname varchar(32), dob date);
    
    insert into tblemployee values  (1, 'Mike', 'Davis',' 1998-11-11');
    insert into tblemployee values  (2, 'Josh', 'Martin', '1988-10-22');
    insert into tblemployee values  (3, 'Ricky', 'Smith', '1999-05-11');
    

    Let’s have look at the below example program to fetch the records from the table and print them on the console. Please make sure you have the MySQL JDBC driver in the project classpath.

    让我们看下面的示例程序,从表中获取记录并将其打印在控制台上。 请确保在项目类路径中有MySQL JDBC驱动程序。

    
    package com.journaldev.examples;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    import java.util.Date;
    
    /**
     * Java Resultset Example of Retrieving records.
     * 
     * @author pankaj
     *
     */
    
    public class ResultSetDemo {
    
    	public static void main(String[] args) {
    		String query = "select empid, firstname, lastname, dob from tblemployee";
    		Connection conn = null;
    		Statement stmt = null;
    		try {
    			Class.forName("com.mysql.jdbc.Driver");
    			conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/empdb", "root", "root");
    			stmt = conn.createStatement();
    			ResultSet rs = stmt.executeQuery(query);
    			while (rs.next()) {
    				Integer empId = rs.getInt(1);
    				String firstName = rs.getString(2);
    				String lastName = rs.getString(3);
    				Date dob = rs.getDate(4);
    				System.out.println("empId:" + empId);
    				System.out.println("firstName:" + firstName);
    				System.out.println("lastName:" + lastName);
    				System.out.println("dob:" + dob);
    				System.out.println("");
    			}
    			rs.close();
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				stmt.close();
    				conn.close();
    			} catch (Exception e) {}
    		}
    	}
    }
    

    Output:

    输出:

    
    empId:1
    firstName:Mike
    lastName:Davis
    dob:1998-11-11
    
    empId:2
    firstName:Josh
    lastName:Martin
    dob:1988-10-22
    
    empId:3
    firstName:Ricky
    lastName:Smith
    dob:1999-05-11
    

    Explanation:

    说明

    • ResultSet is obtained by calling the executeQuery method on Statement instance. Initially, the cursor of ResultSet points to the position before the first row.

      通过调用Statement实例上的executeQuery方法获得ResultSet。 最初,ResultSet的光标指向第一行之前的位置。
    • The method next of ResultSet moves the cursor to the next row. It returns true if there is further row otherwise it returns false.

      ResultSet的next方法将光标移动到下一行。 如果还有其他行,则返回true,否则返回false。
    • We can obtain data from ResultSet using getter methods provided by it. e.g.  getInt(),  getString(),  getDate()

      我们可以使用它提供的getter方法从ResultSet中获取数据。 例如getInt(),getString(),getDate()
    • All the getter methods have two variants. 1st variant takes column index as Parameter and 2nd variant accepts column name as Parameter.

      所有的getter方法都有两个变体。 第一个变量将列索引作为参数, 第二个变量将列名称作为参数。
    • Finally, we need to call close method on ResultSet instance so that all resources are cleaned up properly.

      最后,我们需要在ResultSet实例上调用close方法,以便正确清理所有资源。

    结果集类型和并发 (ResultSet Types & Concurrency)

    We can specify type and concurrency of  ResultSet while creating an instance of Statement, PreparedStatement or CallableStatement.

    在创建Statement, PreparedStatementCallableStatement的实例时,我们可以指定ResultSet的类型和并发性。

    statement.createStatement(int resultSetType, int resultSetConcurrency)

    statement.createStatement(int resultSetType,int resultSetConcurrency)

    结果集类型 (ResultSet Types)

    1)仅转发(ResultSet。TYPE_FORWARD_ONLY (1) Forward Only (ResultSet.TYPE_FORWARD_ONLY))

    This type of ResultSet instance can move only in the forward direction from the first row to the last row. ResultSet can be moved forward one row by calling the next() method. We can obtain this type of ResultSet while creating Instance of Statement, PreparedStatement or CallableStatement.

    这种类型的ResultSet实例只能从第一行到最后一行向前移动。 可以通过调用next()方法将ResultSet向前移动一行。 在创建Statement,PreparedStatement或CallableStatement的实例时,我们可以获取这种类型的ResultSet。

    
    Statement stmt = connection.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
    ResultSet rs = stmt.executeQuery("select * from tbluser");
    

    2)滚动不敏感(结果集。TYPE_SCROLL_INSENSITIVE) (2) Scroll Insensitive (ResultSet.TYPE_SCROLL_INSENSITIVE))

    Scroll Insensitive ResultSet can scroll in both forward and backward directions. It can also be scrolled to an absolute position by calling the absolute() method. But it is not sensitive to data changes. It will only have data when the query was executed and ResultSet was obtained. It will not reflect the changes made to data after it was obtained.

    滚动不敏感ResultSet可以向前和向后滚动。 也可以通过调用absolute()方法将其滚动到绝对位置。 但是它对数据更改不敏感。 它仅在执行查询并获得ResultSet时才具有数据。 它不会反映获得数据后对数据所做的更改。

    
    Statement stmt = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,  		ResultSet.CONCUR_READ_ONLY);
    ResultSet rs = stmt.executeQuery("select * from tbluser");
    

    3)敏感滚动(ResultSet。TYPE_SCROLL_SENSITIVE (3) Scroll Sensitive (ResultSet.TYPE_SCROLL_SENSITIVE))

    Scroll Sensitive ResultSet can scroll in both forward and backward directions. It can also be scrolled to an absolute position by calling the absolute() method. But it is sensitive to data changes. It will reflect the changes made to data while it is open.

    滚动敏感结果集可以向前和向后滚动。 也可以通过调用absolute()方法将其滚动到绝对位置。 但是它对数据更改很敏感。 它会反映打开时对数据所做的更改。

    
    Statement stmt = connection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,  		ResultSet.CONCUR_READ_ONLY);
    ResultSet rs = stmt.executeQuery("select * from tbluser");
    

    ResultSet 并发 (ResultSet Concurrency)

    1)只读(ResultSet。CONCUR_READ_ONLY (1) Read Only (ResultSet.CONCUR_READ_ONLY))

    It is the default concurrency model.  We can only perform Read-Only operations on ResultSet Instance. No update Operations are allowed.

    它是默认的并发模型。 我们只能对ResultSet实例执行只读操作。 不允许任何更新操作。

    2)可更新(ResultSet。CONCUR_UPDATABLE (2) Updatable (ResultSet.CONCUR_UPDATABLE))

    In this case, we can perform update operations on ResultSet instance.

    在这种情况下,我们可以对ResultSet实例执行更新操作。

    结果集方法 (ResultSet Methods)

    We can divide ResultSet methods into the following categories.

    我们可以将ResultSet方法分为以下几类。

    • Navigational Methods

      导航方法
    • Getter/Reader Methods

      读/写方法
    • Setter/Updater Methods

      设置器/更新器方法
    • Miscellaneous Methods – close() and getMetaData()

      其他方法 – close()和getMetaData()

    1. ResultSet导航方法 (1. ResultSet Navigational Methods)

    • boolean absolute(int row) throws SQLException: This method moves ResultSet cursor to the specified row and returns true if the operation is successful.

      boolean absolute( int row) 引发 SQLException 此方法将ResultSet游标移动到指定的行,如果操作成功,则返回true。
    • void afterLast() throws SQLException: This method moves ResultSet cursor to the position after the last row.

      afterLast() 引发 SQLException 无效 此方法将ResultSet光标移动到最后一行之后的位置。
    • void beforeFirst() throws SQLException: This method moves ResultSet cursor to the position before the first row.

      void beforeFirst() 抛出 SQLException 此方法将ResultSet光标移动到第一行之前的位置。
    • boolean first() throws SQLException: This method moves ResultSet cursor to the first row.

      boolean first() 引发 SQLException:此方法将ResultSet光标移到第一行。
    • boolean last() throws SQLException: This method moves ResultSet cursor to the last row.

      boolean last() 引发 SQLException:此方法将ResultSet光标移到最后一行。
    • boolean next() throws SQLException: This method moves ResultSet cursor to the next row.

      boolean next() 引发 SQLException:此方法将ResultSet光标移到下一行。
    • boolean previous() throws SQLException: This method moves ResultSet cursor to the previous row.

      boolean previous() 抛出 SQLException:此方法将ResultSet光标移到上一行。
    
    package com.journaldev.examples;
    import java.sql.*;
    
    /**
     * Java Resultset Example using navigational methods.
     * 
     * @author pankaj
     *
     */
    public class ResultSetDemo {
    
    	public static void main(String[] args) {
    		String query = "select empid, firstname, lastname, dob from tblemployee";
    		Connection conn = null;
    		Statement stmt = null;
    		try {
    			Class.forName("com.mysql.jdbc.Driver");
    			conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/empdb", "root", "root");
    			stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
    			ResultSet rs = stmt.executeQuery(query);
    			System.out.println("All the rows of table=>");
    			while (rs.next()) { 
    				// Go to next row by calling next() method
    				displayData(rs);
    			}
    			System.out.println("Now go directly to 2nd row=>");
    			rs.absolute(2); // Go directly to 2nd row
    			displayData(rs);
    			System.out.println("Now go to Previous row=>");
    			rs.previous(); 
    			// Go to 1st row which is previous of 2nd row
    			displayData(rs);
    			rs.close();
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				stmt.close();
    				conn.close();
    			} catch (Exception e) {
    			}
    		}
    	}
    
    	public static void displayData(ResultSet rs) throws SQLException {
    		System.out.println("empId:" + rs.getInt(1));
    		System.out.println("firstName:" + rs.getString(2));
    		System.out.println("lastName:" + rs.getString(3));
    		System.out.println("dob:" + rs.getDate(4));
    		System.out.println("");
    	}
    }
    

    Output:

    输出:

    
    All the rows of table=>
    empId:1
    firstName:Mike
    lastName:Davis
    dob:1998-11-11
    
    empId:2
    firstName:Josh
    lastName:Martin
    dob:1988-10-22
    
    empId:3
    firstName:Ricky
    lastName:Smith
    dob:1999-05-11
    
    Now go directly to 2nd row=>
    empId:2
    firstName:Josh
    lastName:Martin
    dob:1988-10-22
    
    Now go to Previous row=>
    empId:1
    firstName:Mike
    lastName:Davis
    dob:1998-11-11
    

    2. ResultSet的Getter / Reader方法 (2. ResultSet Getter/Reader Methods)

    • int getInt(int columnIndex) throws SQLException: This method returns value of specified columnIndex as int.

      int getInt( int columnIndex) 引发 SQLException:此方法将指定columnIndex的值作为int返回。
    • long getLong(int columnIndex) throws SQLException: This method returns value of specified columnIndex as long

      long getLong( int columnIndex) 抛出 SQLException:该方法返回指定columnIndex的值, 只要long
    • String getString(int columnIndex) throws SQLException: This method returns value of specified columnIndex as String

      String getString( int columnIndex) 引发 SQLException:此方法将指定的columnIndex的值作为String返回
    • java.sql.Date getDate(int columnIndex) throws SQLException: This method returns value of specified columnIndex as java.sql.Date

      java.sql.Date getDate( int columnIndex) 抛出 SQLException:此方法将指定columnIndex的值作为java.sql.Date返回
    • int getInt(String columnLabel) throws SQLException: This method returns value of specified column name as int.

      int getInt(String columnLabel) 抛出 SQLException:此方法返回指定列名的值作为int
    • long getLong(String columnLabel) throws SQLException: This method returns value of specified column name as long.

      long getLong(String columnLabel) 抛出 SQLException:此方法返回指定列名的值long
    • String getString(String columnLabel) throws SQLException: This method returns the value of the specified column name as String.

      String getString(String columnLabel) 抛出 SQLException:此方法以String形式返回指定列名称的值。
    • java.sql.Date getDate(String columnLabel) throws SQLException: This method returns the value of the specified column name as java.sql.Date.

      java.sql.Date getDate(String columnLabel)引发SQLException:此方法以java.sql.Date的形式返回指定列名称的值。
    • ResultSet contains getter methods that return other primitive datatypes like boolean, float and double. It also has methods to obtain array and binary data from the database.

      ResultSet包含getter方法,这些方法返回其他原始数据类型,例如boolean,float和double。 它还具有从数据库中获取数组和二进制数据的方法。

    3. ResultSet 设置器/更新器方法 (3. ResultSet Setter/Updater Methods)

    • void updateInt(int columnIndex, int x) throws SQLException: This method updates the value of specified column of current row with int value.

      void updateInt( int columnIndex, int x) 引发 SQLException:此方法使用int值更新当前行的指定列的值。
    • void updateLong(int columnIndex, long x) throws SQLException: This method updates the value of the specified column of the current row with long value.

      void updateLong( int columnIndex, long x) 引发 SQLException:此方法使用long值更新当前行的指定列的值。
    • void updateString(int columnIndex, String x) throws SQLException: This method updates the value of the specified column of the current row with a String value.

      void updateString(int columnIndex,String x)引发SQLException:此方法使用String更新当前行的指定列的值 值。
    • void updateDate(int columnIndex, java.sql.Date x) throws SQLException: This method updates the value of specified column of current row with java.sql.Date value.

      void updateDate( int columnIndex,java.sql.Date x) 引发 SQLException:此方法使用java.sql.Date更新当前行的指定列的值 值。
    • void updateInt(String columnLabel, int x) throws SQLException: This method updates the value of the specified column label of the current row with int value.

      void updateInt(String columnLabel,int x)引发SQLException:此方法使用int值更新当前行的指定列标签的值。
    • void updateLong(String columnLabel, long x) throws SQLException: This method updates the value of the specified column label of the current row with long value.

      void updateLong(String columnLabel,long x)引发SQLException:此方法使用long值更新当前行的指定列标签的值。
    • void updateString(String columnLabel, String x) throws SQLException: This method updates the value of the specified column label of the current row with a String value.

      void updateString(String columnLabel,String x)引发SQLException:此方法使用String更新当前行的指定列标签的值 值。
    • void updateDate(String columnLabel, java.sql.Date x) throws SQLException: This method updates the value of specified columnLabel of current row with java.sql.Date value.

      void updateDate(String columnLabel,java.sql.Date x) 引发 SQLException:此方法使用java.sql.Date值更新当前行的指定columnLabel的值。

    Note: Setter/Updater Methods doesn’t directly update database values. Database values will be inserted/updated after calling the insertRow or updateRow method.

    注意:设置器/更新器方法不会直接更新数据库值。 调用insertRow或updateRow方法后,将插入/更新数据库值

    
    package com.journaldev.examples;
    import java.sql.*;
    
    /**
     * Java Resultset Example using updater methods.
     * 
     * @author pankaj
     *
     */
    
    public class ResultSetUpdateDemo {
    
    	public static void main(String[] args) {
    		String query = "select empid, firstname, lastname, dob from tblemployee";
    		Connection conn = null;
    		Statement stmt = null;
    		try {
    			Class.forName("com.mysql.jdbc.Driver");
    			conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/empdb", "root", "root");
    			stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
    			ResultSet rs = stmt.executeQuery(query);
    			System.out.println("Now go directly to 2nd row for Update");
    			if (rs.absolute(2)) { 
    				// Go directly to 2nd row
    				System.out.println("Existing Name:" + rs.getString("firstName"));
    				rs.updateString("firstname", "Tyson");
    				rs.updateRow();
    			}
    			rs.beforeFirst(); // go to start
    			System.out.println("All the rows of table=>");
    			while (rs.next()) { 
    			// Go to next row by calling next() method
    				displayData(rs);
    			}
    			rs.close();
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				stmt.close();
    				conn.close();
    			} catch (Exception e) {
    			}
    		}
    	}
    
    	public static void displayData(ResultSet rs) throws SQLException {
    		System.out.println("empId:" + rs.getInt(1));
    		System.out.println("firstName:" + rs.getString(2));
    		System.out.println("lastName:" + rs.getString(3));
    		System.out.println("dob:" + rs.getDate(4));
    		System.out.println("");
    	}
    }
    

    Output:

    输出:

    
    Now go directly to 2nd row for Update
    Existing Name:Josh
    All the rows of table=>
    empId:1
    firstName:Mike
    lastName:Davis
    dob:1998-11-11
    
    empId:2
    firstName:Tyson
    lastName:Martin
    dob:1988-10-22
    
    empId:3
    firstName:Ricky
    lastName:Smith
    dob:1999-05-11
    

    4. ResultSet其他方法 (4. ResultSet Miscellaneous Methods)

    • void close() throws SQLException: This method frees up resources associated with ResultSet Instance. It must be called otherwise it will result in resource leakage.

      void close() 抛出 SQLException 此方法释放与ResultSet实例关联的资源。 必须调用它,否则将导致资源泄漏。
    • ResultSetMetaData getMetaData() throws SQLException: This method returns ResultSetMetaData instance. It gives information about the type and property of columns of the query output.

      ResultSetMetaData getMetaData() 引发 SQLException:此方法返回ResultSetMetaData实例。 它提供有关查询输出的列的类型和属性的信息。

    Reference: Java doc

    参考Java文档

    翻译自: https://www.journaldev.com/34720/java-resultset

    展开全文
  • 主要介绍了Java使用PreparedStatement接口及ResultSet结果集的方法,结合实例形式分析了PreparedStatement接口及ResultSet结果集的相关使用方法与操作注意事项,需要的朋友可以参考下
  • JAVA 版本ResultSet 转换为JAVABEAN的工具类
  • 资源所属:https://blog.csdn.net/qq_16773953/article/details/103461172
  • CallableStatement调用Oracle存储过程返回结果集(ResultSet).doc
  • 文章目录1、简介2、ResultSet 类图3、ResultSet 重要方法4、ResultSet 类型TYPE_FORWARD_ONLYTYPE_SCROLL_INSENSITIVETYPE_SCROLL_SENSITIVE5、ResultSet 并发性6、Cursor Holdability(游标可保持性)7、示例7.1、...

    1、简介

    ResultSet 接口提供了用于检索和处理已获得结果集的方法,并且ResultSet对象具有不同的功能和特性。 这些特性是type(类型), concurrency(并发性), cursor holdability(游标可保持性)。

    ResultSet 对象维护一个游标,该游标指向其当前数据行。 next 方法将光标移动到下一行,当ResultSet对象中没有更多行时它返回false,因此可以在while循环中使用它来迭代结果集。

    默认的 ResultSet 对象是不可更新的,并且只有仅向前移动的光标。 因此,您只能从第一行到最后一行迭代一次。

    可以生成可滚动或可更新的ResultSet对象。 下面的代码片段(其中con是有效的Connection对象)说明了如何创建一个可滚动且对其他更新不敏感并且可更新的结果集。

    Statement stmt = con.createStatement(
                                          ResultSet.TYPE_SCROLL_INSENSITIVE,
                                          ResultSet.CONCUR_UPDATABLE);
           ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2");
    

    ResultSet 接口提供了用于从当前行检索列值的getter方法(getBoolean,getLong等)。 可以使用列的索引号或列的名称来检索值。 通常,使用列索,列索引编号从1开始编号。为了实现最大的可移植性,应按从左到右的顺序读取每一行中的结果集列,并且每一列只能读取一次。

    对于getter方法,JDBC驱动程序尝试将基础数据转换为getter方法中指定的Java类型,并返回合适的Java值。 JDBC规范具有一个表,该表显示了ResultSet getter方法可以使用的从SQL类型到Java类型的映射。

    用作getter方法的列名不区分大小写。 当使用列名调用getter方法并且多个列具有相同的名称时,将返回第一个匹配列的值。 对于在查询中未明确命名的列,最好使用列号。 如果使用了列名,则应注意确保它们的唯一,这可以通过SQL AS子句来确保。

    在JDBC 2.0 API(Java™2 SDK,标准版,版本1.2)中,向该接口添加了一组更新程序方法。 有关getter方法的参数的注释也适用于updater方法的参数。

    更新方法有两种使用方式:

    1、更新当前行中的列值:在可滚动的ResultSet对象中,光标可以前后移动,移动到绝对位置或相对于当前行的位置。 下面的代码片段更新ResultSet对象rs的第五行中的NAME列,然后使用方法 updateRow 来更新 rs 数据源。

            rs.absolute(5); // 移动光标到 rs 的第五行
           rs.updateString("NAME", "AINSWORTH"); // 更新第五行 NAME 列的值为 AINSWORTH
           rs.updateRow(); // 更新当前数据源 rs 中的第五行操作
    

    2、将列值插入到插入行中:可更新的ResultSet对象具有与其关联的特殊行,该行用作构建要插入的行的暂存区。 下面的代码片段将光标移动到插入行,构建一个三列的行,然后使用insertRow方法将其插入rs和数据源表中。

           rs.moveToInsertRow(); // 移动游标到插入行
           rs.updateString(1, "AINSWORTH"); // 更新插入行第一列的值为 AINSWORTH
           rs.updateInt(2,35); // 更新第二列的值为 35
           rs.updateBoolean(3, true); // 更新第三列的值为 true
           rs.insertRow();
           rs.moveToCurrentRow();
    

    ResultSet 对象的列的数量,类型和属性由ResultSet.getMetaData方法返回的ResultSetMetaData对象提供。

    2、ResultSet 类图

    在这里插入图片描述

    3、ResultSet 重要方法

    方法描述
    boolean absolute(int row)将游标移动到此ResultSet对象中指定的行号。
    afterLast()将游标移动到该ResultSet对象的末尾,在最后一行之后。
    beforeFirst()将游标移动到该ResultSet对象的开头,在第一行之前。
    cancelRowUpdates()取消对此ResultSet对象中的当前行进行的更新。
    clearWarnings()清除此ResultSet对象上报告的所有警告。
    close()立即释放此ResultSet对象的数据库和JDBC资源。
    deleteRow()从此ResultSet对象和基础数据库中删除当前行。
    findColumn(String columnLabel)将给定的ResultSet列标签映射到其ResultSet列索引。
    first()将光标移动到此ResultSet对象的第一行。
    int getRow()检索当前行号。
    RowId getRowId(int columnIndex)以Java编程语言中java.sql.RowId对象的形式检索此ResultSet对象的当前行中指定列的值。
    getStatement()检索产生此ResultSet对象的Statement对象。
    SQLWarning getWarnings()检索此ResultSet对象上的调用报告的第一个警告。
    void insertRow()将插入行的内容插入到此ResultSet对象和数据库中。
    boolean last()将光标移动到此ResultSet对象的最后一行。
    void moveToCurrentRow()将光标移动到记住的光标位置,通常是当前行。
    void moveToInsertRow()将光标移动到插入行。
    boolean next()将光标从当前位置向前移动一行。
    boolean previous()将光标移动到此ResultSet对象的上一行。
    void refreshRow()用数据库中的最新值刷新当前行。
    boolean rowDeleted()检索是否已删除行。
    boolean rowInserted()检索当前行是否有插入。
    boolean rowUpdated()检索当前行是否已更新。
    updateArray(int columnIndex, Array x)使用java.sql.Array值更新指定的列。
    updateBinaryStream(int columnIndex, InputStream x)用二进制流值更新指定的列。
    updateBlob(int columnIndex, Blob x)使用java.sql.Blob值更新指定的列。
    updateBoolean(String columnLabel, boolean x)用布尔值更新指定的列。
    updateByte(String columnLabel, byte x)用byte值更新指定的列。
    updateDate(int columnIndex, Date x)使用java.sql.Date值更新指定的列。
    updateDouble(int columnIndex, double x)用double值更新指定的列。
    updateFloat(int columnIndex, float x)用float值更新指定的列。
    updateInt(int columnIndex, int x)用int值更新指定的列。
    updateLong(int columnIndex, long x)用long值更新指定的列。
    updateNull(String columnLabel)用空值更新指定的列。
    updateRow()使用此ResultSet对象的当前行的新内容更新基础数据库。
    updateShort(int columnIndex, short x)用short值更新指定的列。
    updateString(int columnIndex, String x)用字符串值更新指定的列。

    4、ResultSet 类型

    ResultSet 对象的类型在两个方面确定其功能级别:游标的操作方式以及ResultSet对象如何反映对基础数据源进行的并发更改。

    4.1、TYPE_FORWARD_ONLY

    结果集无法滚动,它的光标只能从第一行之前移到最后一行之后。 结果集中包含的行取决于基础数据库如何生成的结果。 即,它包含在执行查询时或在检索行时满足查询条件的行。

    4.2、TYPE_SCROLL_INSENSITIVE

    结果集可以滚动, 它的光标可以相对于当前位置向前和向后移动,并且可以移动到绝对位置。 结果集在打开时对基础数据源所做的更改不敏感。 它包含在执行查询时或在检索行时满足查询条件的行。

    4.3、TYPE_SCROLL_SENSITIVE

    结果可以滚动,它的光标可以相对于当前位置向前和向后移动,并且可以移动到绝对位置。 结果集反映在结果集保持打开状态时对基础数据源所做的更改。

    5、ResultSet 并发性

    ResultSet 对象的并发性确定了支持什么级别的更新功能。

    有两个并发级别:

    • CONCUR_READ_ONLY:无法使用ResultSet接口更新ResultSet对象。
    • CONCUR_UPDATABLE:可以使用ResultSet接口更新ResultSet对象。

    默认的ResultSet并发性是CONCUR_READ_ONLY。

    下面的示例演示如何使用并发级别为CONCUR_UPDATABLE的ResultSet对象。

    private static void modifyUserName() {
            String QUERY = "select id,name,email,country,password from Users where id = 1";
            // Step 1:创建 connection 对象
            try (Connection connection = DriverManager
                    .getConnection("jdbc:mysql://localhost:3306/lkf_db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT", "root", "root");
                 // Step 2:使用connection 对象创建一个statement 对象
                 Statement stmt = connection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                         ResultSet.CONCUR_UPDATABLE);
                 // Step 3: 执行查询或更新操作
                 ResultSet rs = stmt.executeQuery(QUERY)) {
                // Step 4: 处理结果集对象ResultSet
                while (rs.next()) {
                    String name = rs.getString("name");
                    System.out.println("更新之前的用户名 : " + name);
                    rs.updateString("name", name+"_update");
                    rs.updateRow();
                    System.out.println("更新之后的用户名 : " + rs.getString("name"));
                }
            } catch (SQLException e) {
                printSQLException(e);
            }
        }
    

    结果:

    更新之前的用户名 : 张三
    更新之后的用户名 : 张三_update
    

    6、Cursor Holdability(游标可保持性)

    调用方法Connection.commit可以关闭在当前事务期间创建的ResultSet对象。 但是,在某些情况下,这可能不是所需的行为。 ResultSet属性的可保留性使应用程序可以控制在调用提交时是否关闭ResultSet对象(光标)。

    可以将以下ResultSet常量提供给Connection方法的createStatement,prepareStatement和prepareCall:

    • HOLD_CURSORS_OVER_COMMIT: ResultSet游标未关闭,它是可保持的,调用方法commit时,它们保持打开状态。 如果您的应用程序主要使用只读的ResultSet对象,则可保持游标可能是理想的选择。
    • CLOSE_CURSORS_AT_COMMIT: 调用commit方法时,将关闭ResultSet对象(光标)。 调用此方法时关闭游标可以提高某些应用程序的性能。

    默认的游标可保留性取决于您的DBMS。

    以当前本机安装的MySQL为例:

     public static void main(String[] args) throws SQLException {
            try(Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/lkf_db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT", "root", "root");){
                cursorHoldabilitySupport(connection);
            }
        }
    
        public static void cursorHoldabilitySupport(Connection conn)
                throws SQLException {
    
            DatabaseMetaData dbMetaData = conn.getMetaData();
            System.out.println("ResultSet.HOLD_CURSORS_OVER_COMMIT = " +
                    ResultSet.HOLD_CURSORS_OVER_COMMIT);
    
            System.out.println("ResultSet.CLOSE_CURSORS_AT_COMMIT = " +
                    ResultSet.CLOSE_CURSORS_AT_COMMIT);
    
            System.out.println("Default cursor holdability: " +
                    dbMetaData.getResultSetHoldability());
    
            System.out.println("Supports HOLD_CURSORS_OVER_COMMIT? " +
                    dbMetaData.supportsResultSetHoldability(
                            ResultSet.HOLD_CURSORS_OVER_COMMIT));
    
            System.out.println("Supports CLOSE_CURSORS_AT_COMMIT? " +
                    dbMetaData.supportsResultSetHoldability(
                            ResultSet.CLOSE_CURSORS_AT_COMMIT));
        }
    

    输出结果:

    ResultSet.HOLD_CURSORS_OVER_COMMIT = 1
    ResultSet.CLOSE_CURSORS_AT_COMMIT = 2
    Default cursor holdability: 1
    Supports HOLD_CURSORS_OVER_COMMIT? true
    Supports CLOSE_CURSORS_AT_COMMIT? false
    

    7、示例

    7.1、从行中检索列值

    ResultSet 接口声明了用于从当前行中检索列值的getter方法(例如,getBoolean和getLong)。 您可以使用列的索引号或列的别名或名称来检索值。 列索引通常更有效。 列从1开始编号。为了实现最大的可移植性,应按从左到右的顺序读取每一行中的结果集列,并且每一列只能读取一次。

    例如,以下方法将按数字检索列值:

    public static void main(String[] args) throws SQLException {
            retrievingValueByDigital();
        }
    
    
        public static void retrievingValueByDigital() {
            // Step 1: 创建 Connection 对象
            try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/lkf_db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT", "root", "root");
    
                 // Step 2:使用 connection 创建 statement 对象
                 Statement stmt = connection.createStatement();
    
                 // Step 3: 执行查询或更新
                 ResultSet rs = stmt.executeQuery(QUERY)) {
    
                // Step 4: 处理 ResultSet 对象
                while (rs.next()) {
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    String email = rs.getString("email");
                    String country = rs.getString("country");
                    String password = rs.getString("password");
                    System.out.println(id + "," + name + "," + email + "," + country + "," + password);
                }
            } catch (SQLException e) {
                printSQLException(e);
            }
        }
    

    输出结果:

    1,张三_update,zhangsan@qq.com,china,123456
    2,李四,lisi@qq.com,china,123456
    

    7.2、更新ResultSet对象中的行

    您不能更新默认的ResultSet对象,而只能将其光标向前移动。 但是,您可以创建可以滚动(光标可以向后移动或移至绝对位置)和更新的ResultSet对象。

    以下方法 modifyUserName() 使用新名称更新现有名称:

    private static void modifyUserName() {
            String QUERY = "select id,name,email,country,password from Users where id = 1";
            // Step 1:创建 connection 对象
            try (Connection connection = DriverManager
                    .getConnection("jdbc:mysql://localhost:3306/lkf_db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT", "root", "root");
                 // Step 2:使用connection 对象创建一个statement 对象
                 Statement stmt = connection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                         ResultSet.CONCUR_UPDATABLE);
                 // Step 3: 执行查询或更新操作
                 ResultSet rs = stmt.executeQuery(QUERY)) {
                // Step 4: 处理结果集对象ResultSet
                while (rs.next()) {
                    String name = rs.getString("name");
                    System.out.println("更新之前的用户名 : " + name);
                    rs.updateString("name", name+"_update");
                    rs.updateRow();
                    System.out.println("更新之后的用户名 : " + rs.getString("name"));
                }
            } catch (SQLException e) {
                printSQLException(e);
            }
        }
    

    7.3、使用 Statement 对象进行批处理更新

    Statement,PreparedStatement 和 CallableStatement 对象具有与其关联的命令列表。 该列表在创建时与 Statement 对象相关联,初始是空的。 您可以使用addBatch方法将SQL命令添加到此列表,并使用clearBatch方法将其清空。 完成将语句添加到列表后,请调用executeBatch方法将其全部发送到数据库以作为一个单元或批处理执行。

     public static void main(String[] args) throws SQLException {
            batchUpdate();
        }
    
        /**
         * 使用 Statement 对象进行批处理更新
         */
        private static void batchUpdate() {
            //Step 1: 创建 Connection 对象
            try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/lkf_db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT", "root", "root");
                 // Step 2:使用 connection 创建 statement 对象
                 Statement statement = connection.createStatement()) {
                connection.setAutoCommit(false);
                statement.addBatch("INSERT INTO Users VALUES (3, '李梅', 'limei@qq.com', 'China', '123789');");
                statement.addBatch("INSERT INTO Users VALUES (4, '韩磊磊', 'hanleilei@qq.com', 'China', '123789');");
                statement.addBatch("INSERT INTO Users VALUES (5, '乔治', 'qiaozhi@qq.com', 'China', '123789');");
                statement.addBatch("INSERT INTO Users VALUES (6, '佩奇', 'peiqi@qq.com', 'China', '123789');");
                statement.addBatch("INSERT INTO Users VALUES (7, '光头强', 'guangtouqiang@qq.com', 'China', '123789');");
                int[] updateCounts = statement.executeBatch();
                System.out.println(Arrays.toString(updateCounts));
                connection.commit();
            } catch (BatchUpdateException batchUpdateException) {
                printBatchUpdateException(batchUpdateException);
            } catch (SQLException e) {
                printSQLException(e);
            }
        }
    

    结果:

    在这里插入图片描述

    7.4、执行参数化的批量更新

    也可以进行参数化的批量更新,如以下代码片段所示:

    private static void parameterizedBatchUpdate() {
            String INSERT_USERS_SQL = "INSERT INTO users" + "  (id, name, email, country, password) VALUES " +
                    " (?, ?, ?, ?, ?);";
    
            try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/lkf_db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT", "root", "root");
                 PreparedStatement preparedStatement = connection.prepareStatement(INSERT_USERS_SQL)) {
                connection.setAutoCommit(false);
    
                preparedStatement.setInt(1, 8);
                preparedStatement.setString(2, "悟空");
                preparedStatement.setString(3, "wukong@qq.com");
                preparedStatement.setString(4, "China");
                preparedStatement.setString(5, "189398");
                preparedStatement.addBatch();
    
                preparedStatement.setInt(1, 9);
                preparedStatement.setString(2, "八戒");
                preparedStatement.setString(3, "bajie@qq.com");
                preparedStatement.setString(4, "China");
                preparedStatement.setString(5, "189398");
                preparedStatement.addBatch();
    
                preparedStatement.setInt(1, 10);
                preparedStatement.setString(2, "唐生");
                preparedStatement.setString(3, "tangsheng@qq.com");
                preparedStatement.setString(4, "China");
                preparedStatement.setString(5, "189398");
                preparedStatement.addBatch();
    
                preparedStatement.setInt(1, 11);
                preparedStatement.setString(2, "沙和尚");
                preparedStatement.setString(3, "shaheshang.com");
                preparedStatement.setString(4, "China");
                preparedStatement.setString(5, "189398");
                preparedStatement.addBatch();
    
                int[] updateCounts = preparedStatement.executeBatch();
                System.out.println(Arrays.toString(updateCounts));
                connection.commit();
                connection.setAutoCommit(true);
            } catch (BatchUpdateException batchUpdateException) {
                printBatchUpdateException(batchUpdateException);
            } catch (SQLException e) {
                printSQLException(e);
            }
        }
    

    执行结果:

    在这里插入图片描述

    7.5、在ResultSet对象中插入行

    private static void insertRowInResultSetObject() {
            String QUERY = "select id,name,email,country,password from Users where id = 1";
            try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/lkf_db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT", "root", "root");
                 Statement stmt = connection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                         ResultSet.CONCUR_UPDATABLE);
                 ResultSet uprs = stmt.executeQuery(QUERY)) {
                uprs.moveToInsertRow();
                uprs.updateInt(1, 100);
                uprs.updateString(2, "博士生");
                uprs.updateString(3, "boss@qq.com");
                uprs.updateString(4, "China");
                uprs.updateString(5, "325468");
                uprs.insertRow();
                uprs.beforeFirst();
            } catch (SQLException e) {
                printSQLException(e);
            }
        }
    

    执行结果:

    在这里插入图片描述

    参考资料:

    https://docs.oracle.com/javase/8/docs/api/java/sql/ResultSet.html?is-external=true

    展开全文
  • 结果集(ResultSet)是数据中查询结果返回的一种对象,可以说结果集是一个存储查询结果的对象,但是结果集并不仅仅具有存储的功能,他同时还具有操纵数据的功能,可能完成对数据的更新等。 结果集读取数据的方法...

    原文地址: https://blog.csdn.net/walkerjong/article/details/7023872

    仅供学习参考使用。

     

    结果集(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(int colindex/String columnname),通过这个方法获得当前行中,colindex所在列的元素组成的对象的数组。使用getAsciiStream(
    int colindex/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和Result.TYPE_SCROLL_SENSITIVE这两个方法都能够实现任意的前后滚动,使用各种移动的ResultSet指针的方法。二者的区别在于前者对于修改不敏感,而后者对于修改敏感。TYPE_SCROLL_SENSITIVE仅针对已经取出来的记录的更改(update、delete)敏感,对新增(insert)的数据不敏感。
    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的第三种创建方式。如下:

     

    Statement st=createStatement(int resultsetscrollable,int resultsetupdateable,int resultsetSetHoldability)
    ResultSet rs = st.excuteQuery(sqlStr);

     

    前两个参数和两个参数的createStatement方法中的参数是完全相同的,这里只介绍第三个参数:
           resultSetHoldability表示在结果集提交后结果集是否打开,取值有两个:
           ResultSet.HOLD_CURSORS_OVER_COMMIT:表示修改提交时,不关闭数据库。
         ResultSet.CLOSE_CURSORS_AT_COMMIT:表示修改提交时ResultSet关闭。

     

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

    ResultSet 接口

    ResultSet 接口提供对数据表的访问。ResultSet 对象通常是通过执行“语句”来生成的。

    ResultSet 始终有一个游标指向其当前数据行。最初,游标定位在第一行的前面。next() 方法将游标移至下一行。

    getXXX 方法会检索当前行的列值。可使用列的索引号或列的名称来检索这些值。通常,使用列索引将更为有效。列是从 1 开始编号的。

    java.sql 包

    公共接口 ResultSet

    表 102 列示 ResultSet 接口中 DB2 Everyplace 支持的字段。

    表 102. ResultSet 接口字段

    字段类型

    字段

    static int

    CONCUR_READ_ONLY 该常量指示不能更新的 ResultSet 对象的并行性方式。 注意:DB2 Everyplace 不支持 CONCUR_UPDATABLE。如果在创建“语句”对象时对 ResultSet 对象的并行性方式指定 CONCUR_UPDATABLE,则 DB2 Everyplace JDBC 驱动程序将对产生“语句”对象的“连接”对象发出 SQLWarning 并使用 CONCUR_READ_ONLY 代替。

    static int

    TYPE_FORWARD_ONLY 该常量指示其游标只能向前移动的 ResultSet 对象的类型。

    static int

    TYPE_SCROLL_INSENSITIVE 该常量指示可滚动但通常对他人所作的更改不敏感的 ResultSet 对象的类型。注意:不要经常使用此类型的 ResultSet 对象,原因是它可能会影响性能。此类型使用 SQL_INSENSITIVE 作为 CLI 语句属性 SQL_ATTR_CURSOR_SENSITIVITY 的值。有关详细信息,参阅 CLI 函数 SQLSetStmtAttr 的文档。

    static int

    TYPE_SCROLL_SENSITIVE 该常量指示可滚动且通常对他人所作的更改敏感的 ResultSet 对象的类型。注意:此类型使用 SQL_UNSPECIFIED 作为 CLI 语句属性 SQL_ATTR_CURSOR_SENSITIVITY 的值。有关详细信息,参阅 CLI 函数 SQLSetStmtAttr 的文档。

    表 103 列示 ResultSet 接口中 DB2 Everyplace 支持的方法。

    表 103. ResultSet 接口方法

    方法返回值类型

    方法

    boolean

    absolute(int row) JDBC 2.0。将游标移至结果集中的给定行号。

    void

    afterLast() JDBC 2.0。将游标移至结果集的末尾,正好在最后一行的后面。

    void

    beforeFirst() JDBC 2.0。将游标移至结果集的前方,正好在第一行的前面。

    void

    clearWarnings() 清除此 ResultSet 对象上报告的所有警告。

    void

    close() 立即释放此 ResultSet 对象的数据库和 JDBC 资源,而不是等待对象自动关闭时才释放它们。

    int

    findColumn(String columnName) 将给定 ResultSet 列名映射至其 ResultSet 列索引。

    boolean

    first() JDBC 2.0。将游标移至结果集中的第一行。

    BigDecimal

    getBigDecimal(int columnIndex) JDBC 2.0。以具有全部精度的 java.math.BigDecimal 对象形式获取当前行中某个列的值。Palm OS 的 DB2 Everyplace JDBC 驱动程序不支持此方法。

    BigDecimal

    getBigDecimal(int columnIndex, int scale) 以 Java 编程语言中的 java.math.BigDecim

    BigDecimal

    getBigDecimal(int columnIndex, int scale) 以 Java 编程语言中的 java.math.BigDecimal 对象形式获取此 ResultSet 对象当前行中指定列的值。Palm OS 的 DB2 Everyplace JDBC 驱动程序不支持此方法。不受支持。

    BigDecimal

    getBigDecimal(String columnName) JDBC 2.0。以具有全部精度的 java.math.BigDecimal 对象形式获取当前行中某个列的值。Palm OS 的 DB2 Everyplace JDBC 驱动程序不支持此方法。

    BigDecimal

    getBigDecimal(String columnName, int scale) 以 Java 编程语言中的 java.math.BigDecimal 对象形式获取此 ResultSet 对象当前行中指定列的值。Palm OS 的 DB2 Everyplace JDBC 驱动程序不支持此方法。不受支持。

    Blob

    getBlob(int columnIndex) JDBC 2.0。获取此 ResultSet 对象的当前行中的 BLOB 值。

    Blob

    getBlob(String columnName) JDBC 2.0。获取此 ResultSet 对象的当前行中的 BLOB 值。

    boolean

    getBoolean(int columnIndex) 以 Java 布尔值形式获取当前行中某列的值。

    boolean

    getBoolean(String columnName) 以 Java 布尔值形式获取当前行中某列的值。

    byte

    getByte(int columnIndex) 以 Java 编程语言中的字节形式获取此 ResultSet 对象当前行中指定列的值。

    byte

    getByte(String columnName) 以 Java 编程语言中的字节形式获取此 ResultSet 对象当前行中指定列的值。

    byte[]

    getBytes(int columnIndex) 以 Java 编程语言中的字节数组形式获取此 ResultSet 对象当前行中指定列的值。

    byte[]

    getBytes(String columnName) 以 Java 编程语言中的字节数组形式获取此 ResultSet 对象当前行中指定列的值。

    int

    getConcurrency() JDBC 2.0。返回结果集的并行性方式。

    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 对象的当前行中指定列的值。

    double

    getDouble(int columnIndex) 以 Java 双精度形式获取当前行中某列的值。

    double

    getDouble(String columnName) 以 Java 双精度形式获取当前行中某列的值。

    float

    getFloat(int columnIndex) 以 Java 浮点形式获取当前行中某列的值。

    float

    getFloat(String columnName) 以 Java 浮点形式获取当前行中某列的值。

    int

    getInt(int columnIndex) 以 Java 编程语言中的整数形式获取此 ResultSet 对象当前行中指定列的值。

    int

    getInt(String columnName) 以 Java 编程语言中的整数形式获取此 ResultSet 对象的当前行中指定列的值。

    long

    getLong(int columnIndex) 以 Java 长整型形式获取当前行中某列的值。

    long

    getLong(String columnName) 以 Java 长整型形式获取当前行中某列的值。

    ResultSetMetaData

    getMetaData() 检索此 ResultSet 对象的列的数目、类型和属性。

    Object

    getObject(int columnIndex) 以 Java 对象形式获取当前行中某列的值。

    Object

    getObject(String columnName) 以 Java 对象形式获取当前行中某列的值。

    int

    getRow() JDBC 2.0。检索当前行号。

    short

    getShort

    short

    getShort(String columnName) 以 Java 编程语言中的 short 形式获取此 ResultSet 对象当前行中指定列的值。

    Statement

    getStatement() JDBC 2.0。返回产生此 ResultSet 对象的“语句”。

    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(String columnName) 以 Java 编程语言中的 java.sql.Date 对象形式获取此 ResultSet 对象的当前行中指定列的值。

    Timestamp

    getTimestamp(String columnName) 以 Java 编程语言中的 java.sql.Timestamp 对象形式获取此 ResultSet 对象的当前行中指定列的值。

    Timestamp

    getTimestamp(int columnIndex) 以 Java 编程语言中的 java.sql.Timestamp 对象形式获取此 ResultSet 对象的当前行中指定列的值。

    int

    getType() JDBC 2.0。返回此结果集的类型。

    SQLWarning

    getWarnings() 返回此 ResultSet 上的调用报告的首次警告。

    boolean

    isAfterLast() JDBC 2.0。指示游标是否在结果集中的最后一行后面。

    boolean

    isBeforeFirst() JDBC 2.0。指示游标是否在结果集中的第一行前面。

    boolean

    isFirst() JDBC 2.0。指示游标是否在结果集中的第一行上。

    boolean

    isLast() JDBC 2.0。指示游标是否在结果集中的最后一行上。对于具有类型 TYPE_FORWARD_ONLY 的结果集,不支持此方法。

    boolean

    last() JDBC 2.0。将游标移至结果集中的最后一行。

    boolean

    next() 将游标从当前位置向下移动一行。

    boolean

    previous() JDBC 2.0。将游标移至结果集中的前一行。

    boolean

    relative(int rows) JDBC 2.0。将游标移动相对行数,正数或负数。

    boolean

    wasNull() 报告读取的最后一列是否具有值 SQL NULL。

     

     

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


    1 新定义了若干个常数 

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

    2 ResultSet 接口提供了一整套的定位方法 
    这些可以在记录集中定位到任意一行: 
    public boolean absolute(int row); 该方法的作用是将记录集中的某一行设定为当前行,亦即将数据库游标移动到指定的行,参数row 指定了目标行的行号,这是绝对的行号,由记录集的第一行开始计算不是相对的行号。
    public boolean relative(int rows); 该方法的作用也是将记录集中的某一行设定为当前行,但是它的参数rows 表示目标行相对于当前行的行号。
    public boolean first(); 该方法的作用是将当前行定位到数据库记录集的第一行。 
    public boolean last(); 该方法的作用刚好和first()方法相反。 
    public boolean isFirst(); 
    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(); 该方法的作用是将数据库游标向后移动一位,使得上一行成为当前行。 

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

    修改了的记录集接口(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。

    往数据库当前记录集插入新行的操作流程如下: 
    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 API 3.0 中还在ResultSet 接口中添加了updateArray() updateBlob() updateClob() updateRef()等方法

     

    1、java数据库操作基本流程

      2、几个常用的重要技巧:

      可滚动、更新的记录集

      批量更新

      事务处理 

      java数据库操作基本流程:取得数据库连接 - 执行sql语句 - 处理执行结果 - 释放数据库连接

      1、取得数据库连接

      1)用DriverManager取数据库连接

      例子:

    String className,url,uid,pwd;
    className = "oracle.jdbc.driver.OracleDriver";
    url = "jdbc:oracle:thin:@127.0.0.1:1521:orasvr;
    uid = "system";
    pwd = "manager";
    Class.forName(className);
    Connection cn = DriverManager.getConnection(url,uid,pwd);


      2)用jndi(java的命名和目录服务)方式

      例子

    String jndi = "jdbc/db";
    Context ctx = (Context) new InitialContext().lookup("java:comp/env");
    DataSource ds = (DataSource) ctx.lookup(jndi);
    Connection cn = ds.getConnection();


      多用于jsp中

      2、执行sql语句

      1)用Statement来执行sql语句

    String sql;
    Statement sm = cn.createStatement();
    sm.executeQuery(sql); // 执行数据查询语句(select)
    sm.executeUpdate(sql); // 执行数据更新语句(delete、update、insert、drop等)statement.close();


      2)用PreparedStatement来执行sql语句

    String sql;
    sql = "insert into user (id,name) values (?,?)";
    PreparedStatement ps = cn.prepareStatement(sql);
    ps.setInt(1,xxx);
    ps.setString(2,xxx);
    ...
    ResultSet rs = ps.executeQuery(); // 查询
    int c = ps.executeUpdate(); // 更新


      3、处理执行结果

      查询语句,返回记录集ResultSet。

      更新语句,返回数字,表示该更新影响的记录数。

      ResultSet的方法:

      1、next(),将游标往后移动一行,如果成功返回true;否则返回false。

      2、getInt("id")或getSting("name"),返回当前游标下某个字段的值。

      3、释放连接。

    cn.close();


      一般,先关闭ResultSet,然后关闭Statement(或者PreparedStatement);最后关闭Connection

      可滚动、更新的记录集

      1、创建可滚动、更新的Statement

    Statement sm = cn.createStatement(ResultSet.TYPE_SCROLL_ENSITIVE,ResultSet.CONCUR_READ_ONLY);


      该Statement取得的ResultSet就是可滚动的

      2、创建PreparedStatement时指定参数

    PreparedStatemet ps = cn.prepareStatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);

    ResultSet.absolute(9000);


      批量更新

      1、Statement

    Statement sm = cn.createStatement();
    sm.addBatch(sql1);
    sm.addBatch(sql2);
    ...
    sm.executeBatch()


      一个Statement对象,可以执行多个sql语句以后,批量更新。这多个语句可以是delete、update、insert等或兼有

      2、PreparedStatement

    PreparedStatement ps = cn.preparedStatement(sql);
    {
     ps.setXXX(1,xxx);
     ...
     ps.addBatch();
    }
    ps.executeBatch();


      一个PreparedStatement,可以把一个sql语句,变换参数多次执行,一次更新。

      事务的处理

      1、关闭Connection的自动提交

    cn.setAutoCommit(false);


      2、执行一系列sql语句

      要点:执行每一个新的sql语句前,上一次执行sql语句的Statement(或者PreparedStatemet)必须先close

    Statement sm ;
    sm = cn.createStatement(insert into user...);
    sm.executeUpdate();
    sm.close();

    sm = cn.createStatement("insert into corp...);
    sm.executeUpdate();
    sm.close();


      3、提交

    cn.commit();


      4、如果发生异常,那么回滚

    cn.rollback();

    转载于:https://www.cnblogs.com/zhncnblogs/p/10880402.html

    展开全文
  • ResultSet常用方法

    2010-11-27 23:25:21
    ResultSet常用方法,指针滚动,讲解很详细哦!
  • ResultSet的介绍与使用

    万次阅读 2020-06-24 08:55:59
    ResultSet是我们使用jdbc连接时,查询的一个返回结果集,ResultSet resultSet = stmt.executeQuery(sql),下面就使用例子介绍ResultSet的使用 例子是通过jdbc连接查account表中的数据,然后用实体类Account封装起来...
  • 获得结果集的字段名称_ResultSet的属性要调用ResultSetMetaData的方法
  • 描述Connection、Statement、ResultSet接口的作用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 204,707
精华内容 81,882
关键字:

resultset