Как да създадете обект на ResultSet с възможност за превъртане и актуализация в JDBC

Когато извличаме списък със записи чрез заявки, често се налага да ги съхраняваме в обект, който позволява преминаване напред-назад, като се актуализира при необходимост. Тази статия илюстрира тази често необходима техника в програмирането на бази данни с изрични кодове и примерни сценарии.

Относно ResultSet

Наборът с резултати е интерфейс, дефиниран в java.sql пакет. Той представлява таблица с данни, върнати от Изявление обект. Изявление обектът се използва за изпълнение на SQL заявки към базата данни. Обектът ResultSet поддържа курсор, сочещ към текущия запис в таблицата на базата данни. В резултат на това може ефективно да се използва за позициониране на различни редове, напред и назад с помощта на first() , предишен() , след () и последен() методи според изискванията. Първоначално ResultSet обектът е позициониран на място преди първия ред. Това е причината за ResultSet обходът винаги започва както следва:

while(resultSet.next()) {

   // ...

}

Имайте предвид, че ResultSet обектът се позиционира на първия ред чрез изпълнение на next() метод при влизане в цикъла, тъй като, както вече споменахме, ResultSet обектът първоначално се намира на позиция точно преди първия ред. Така че, трябва да бъде поставен поне на първия ред, например, за да получите валиден запис. Може да се счита за стойност -1 в позиция на масив, към която сочи указател/индекс. Първо трябва да бъде преместен поне на местоположението 0, за да получите каквато и да е валидна стойност от масива.

Сега, както споменахме, можем да превъртаме през записи с помощта на ResultSet обект. Но тази способност не идва по подразбиране. Поведението по подразбиране на ResultSet обектът е, че не може да се актуализира и курсорът, който притежава, всъщност се движи в една посока, само напред. Това означава, че можем да преминем през записите само веднъж и само в посока напред. Въпреки това, има начини да го направите гъвкав, така че ResultSet може не само да се актуализира, но и да се превърта.

Ще ги видим след минута в две отделни програми.

Превъртане ResultSet

Нека първо направим ResultSet обект с възможност за превъртане. С възможност за превъртане означава, че след като ResultSet обектът е създаден, можем да преминаваме през извлечените записи във всяка посока, напред и назад, както пожелаем. Това предоставя възможност за четене на последния запис, първия запис, следващия запис и предишния запис.

package org.mano.example;
import java.sql.*;
public class App
{
   static final String JDBC_DRIVER =
      "com.mysql.cj.jdbc.Driver";
   static final String DB_URL =
      "jdbc:mysql://localhost:3306/employees";
   static final String USER = "root";
   static final String PASS = "secret";
   static final String SQL =
      "SELECT * FROM employees ORDER BY first_name";

   public static void main( String[] args )
   {
      Connection connection = null;
      ResultSet rs = null;
      try {
         Class.forName(JDBC_DRIVER);
         connection = DriverManager.getConnection
            (DB_URL, USER, PASS);
         System.out.println("n1. Connection established");
      }catch(Exception ex) {
         ex.printStackTrace();
      }

      try (PreparedStatement pstmt =
            connection.prepareStatement(SQL,
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_READ_ONLY);){
            System.out.println("n2.
               Executing SQL query...");
            rs = pstmt.executeQuery();
            System.out.println("n3.
               ResultSet object created successfully.");
            System.out.println("n4.
               Now some RecordSet scrolling starts...");

            rs.first();
            show(rs);
            rs.last();
            show(rs);
            rs.previous();
            rs.previous();
            show(rs);
            rs.next();
            show(rs);

            System.out.println("nn5. That's all.
               RecordSet scrolling ends.");
      }catch(SQLException ex){
         ex.printStackTrace();
      }finally{
         try {
            connection.close();
         }catch(SQLException ex){
         }
      }
   }
   public static void show(ResultSet rs) throws
         SQLException{
      System.out.printf
         ("n--------------------------------"+
            "-------------------------------------");
      System.out.printf("n%7d | %10s | %10s | %s
         | %s | %s ",rs.getLong("emp_no"),
         rs.getString("first_name"),
         rs.getString("last_name"),
         rs.getDate("birth_date").toString(),
         rs.getDate("hire_date"),
         rs.getString("gender"));
      System.out.printf
         ("n---------------------------------"+
         "------------------------------------");
   }
}

Изход

1. Връзката е установена.
2. Изпълнение на SQL заявка...
3. Обектът ResultSet е създаден успешно.
4. Сега започва превъртане на RecordSet…

   -------------------------------------------------------------
    497615 |  Aamer  |  McDermid   | 1954-11-18 | 1985-04-24 | M
   -------------------------------------------------------------
   -------------------------------------------------------------
    484995 |  Zvonko |  Lakshmanan | 1964-11-04 | 1992-12-04 | M
   -------------------------------------------------------------
   -------------------------------------------------------------
    482000 |  Zvonko |  Cannata    | 1960-11-23 | 1986-08-13 | M
   -------------------------------------------------------------
   -------------------------------------------------------------
    483497 |  Zvonko |  Pollacia   | 1961-12-26 | 1985-08-01 | M
   -------------------------------------------------------------
   

5. Това е всичко. Превъртането на RecordSet приключва.

Имайте предвид, че превъртащият ResultSet обектът е резултат от изпълнението на executeQuery() метод, получен чрез екземпляр на Изявление или PreparedStatement . Типът ResultSet обектът, който искаме да създадем, трябва да бъде изрично деклариран в Изявление обект чрез дефинирани константи от тип превъртане.

• ResultSet.TYPE_FORWARD_ONLY: Това е типът по подразбиране.
• ResultSet.TYPE_SCROLL_INSENSITIVE: Позволява движение напред-назад, но е нечувствителен към ResultSet актуализации.
• ResultSet.TYPE_SCROLL_SENSITIVE: Позволява движение напред-назад, но е чувствителен към ResultSet актуализации.

Използват се и други константи, като CONCUR_READ_ONLY , което означава, че ResultSet не се актуализира. Има друга константа, CONCUR_UPDATABLE , което означава обратното, което означава ResultSet може да се актуализира.

Обновяем ResultSet

Създаване на обновяем ResultSet означава, че записът, към който сочи, е не само достъпен, но и актуализиран. Промените незабавно ще бъдат запазени в базата данни и ще бъдат отразени от ResultSet обект в реално време.

package org.mano.example;
import java.sql.*;
public class App
{
   static final String JDBC_DRIVER =
      "com.mysql.cj.jdbc.Driver";
   static final String DB_URL =
      "jdbc:mysql://localhost:3306/employees";
   static final String USER = "root";
   static final String PASS = "secret";
   static final String SQL =
      "SELECT * FROM employees WHERE emp_no = ?";
   public static void main( String[] args )
   {
      Connection connection = null;
      ResultSet rs = null;
      long emp_no = 484995;
      try {
         Class.forName(JDBC_DRIVER);
         connection = DriverManager.getConnection
            (DB_URL, USER, PASS);
         System.out.println("n1.
            Connection established");
      }catch(Exception ex) {
         ex.printStackTrace();
      }
      try(PreparedStatement pstmt =
            connection.prepareStatement(SQL,
         ResultSet.TYPE_SCROLL_SENSITIVE,
         ResultSet.CONCUR_UPDATABLE);){
            pstmt.setLong(1,emp_no);
            System.out.println("n2.
               Executing SQL query...");
            rs = pstmt.executeQuery();
            System.out.println("n3.
               ResultSet object created successfully.");
            while(rs.next()){
               show(rs);
               String fname = rs.getString("first_name");
               System.out.println("n4.
                  Updating name "+fname+" to Subham");
               rs.updateString("first_name", "Subham");
               rs.updateRow();
            }
            System.out.println("nn5.
               Record updated. See below.");
            rs.previous();
            show(rs);
      }catch(SQLException ex){
         ex.printStackTrace();
      }finally{
      try {
         rs.close();
         connection.close();
      }catch(SQLException ex){
      }
      }
   }
   public static void show(ResultSet rs)
         throwsSQLException{
      System.out.printf
         ("n--------------------------------"+
            "-------------------------------------");
      System.out.printf("n%7d | %10s | %10s | %s
            | %s | %s ",rs.getLong("emp_no"),
         rs.getString("first_name"),
         rs.getString("last_name"),
         rs.getDate("birth_date").toString(),
         rs.getDate("hire_date"),
         rs.getString("gender"));
         System.out.printf
            ("n---------------------------------"+
               "------------------------------------");
   }
}

Обновяващият ResultSet е особено полезно, когато искаме да актуализираме определени стойности, след като направим някакво сравнение, като обикаляме напред-назад през извлечените записи. Процесът на създаване е подобен на предходната програма, но ResultSet използваните тук константи са TYPE_SCROLL_SENSITIVE и CONCUR_UPDATABLE .

Заключение

Противно на поведението по подразбиране на ResultSet, дава възможност на обекта да има по-голяма гъвкавост. Тази функционалност може да бъде използвана от приложението, за да не само преминава през записи, но и да ги направи актуализирани, така че да предоставят по-добра услуга. Въпреки че стандартното поведение на набор от резултати изглежда доста неефективно в сравнение с превъртащия ResultSet , той има собствена употреба и затова е незаменим.