JDBC में स्क्रॉल करने योग्य, अद्यतन करने योग्य परिणाम कैसे बनाएं?

प्रश्नों के माध्यम से रिकॉर्ड की सूची प्राप्त करते समय, हमें अक्सर उन्हें एक ऐसी वस्तु में संग्रहीत करने की आवश्यकता होती है जो आवश्यकतानुसार आगे और पीछे ट्रैवर्सिंग की अनुमति देती है। यह आलेख स्पष्ट कोड और उदाहरण परिदृश्यों के साथ डेटाबेस प्रोग्रामिंग में इस सामान्य रूप से आवश्यक तकनीक को दिखाता है।

परिणाम सेट के बारे में

परिणाम सेट java.sql . में परिभाषित एक इंटरफ़ेस है पैकेट। यह विवरण . द्वारा लौटाए गए डेटा की तालिका का प्रतिनिधित्व करता है वस्तु। एक विवरण ऑब्जेक्ट का उपयोग डेटाबेस में SQL क्वेरी को निष्पादित करने के लिए किया जाता है। ResultSet ऑब्जेक्ट डेटाबेस तालिका में वर्तमान रिकॉर्ड की ओर इशारा करते हुए एक कर्सर रखता है। नतीजतन, इसे first() . का उपयोग करके विभिन्न पंक्तियों में, आगे और पीछे की स्थिति के लिए प्रभावी ढंग से उपयोग किया जा सकता है , पिछला () , अगला () , और अंतिम () आवश्यकताओं के अनुसार तरीके। प्रारंभ में, परिणाम सेट ऑब्जेक्ट पहली पंक्ति से पहले किसी स्थान पर स्थित है। यही कारण है कि एक परिणामसेट ट्रैवर्सल हमेशा इस तरह से शुरू होता है:

while(resultSet.next()) {

   // ...

}

ध्यान दें कि परिणाम सेट ऑब्जेक्ट अगला () . निष्पादित करके पहली पंक्ति में स्थित है लूप में प्रवेश करते समय विधि, क्योंकि, जैसा कि पहले ही उल्लेख किया गया है, ResultSet ऑब्जेक्ट शुरू में पहली पंक्ति से ठीक पहले की स्थिति में स्थित होता है। इसलिए, इसे कम से कम पहली पंक्ति में रखा जाना चाहिए, उदाहरण के लिए, एक वैध रिकॉर्ड प्राप्त करने के लिए। इसे एक मान -1 के रूप में समझा जा सकता है एक सरणी स्थिति में एक सूचक/सूचकांक इंगित कर रहा है। सरणी से किसी भी प्रकार का मान्य मान प्राप्त करने के लिए इसे पहले कम से कम 0 स्थान पर स्थानांतरित किया जाना चाहिए।

अब, जैसा कि हमने उल्लेख किया है, हम 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---------------------------------"+
         "------------------------------------");
   }
}

आउटपुट

कनेक्शन स्थापित हो गया।
एसक्यूएल क्वेरी निष्पादित की जा रही है…
ResultSet ऑब्जेक्ट सफलतापूर्वक बनाया गया।

अब, कुछ 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
-------------------------------------------------------------

बस इतना ही। रिकॉर्डसेट स्क्रॉलिंग समाप्त।

ध्यान दें कि स्क्रॉल करने योग्य परिणामसेट ऑब्जेक्ट executeQuery() . के निष्पादन का परिणाम है विवरण . के उदाहरण से प्राप्त विधि या तैयार विवरण . परिणाम सेट . का प्रकार जिस वस्तु को हम बनाना चाहते हैं उसे स्पष्ट रूप से विवरण . में घोषित किया जाना चाहिए परिभाषित स्क्रॉल प्रकार स्थिरांक के माध्यम से वस्तु।

ResultSet.TYPE_FORWARD_ONLY: यह डिफ़ॉल्ट प्रकार है।
ResultSet.TYPE_SCROLL_INSENSITIVE: आगे और पीछे की आवाजाही को सक्षम करता है, लेकिन परिणाम सेट . के प्रति असंवेदनशील है अपडेट।
ResultSet.TYPE_SCROLL_SENSITIVE: आगे और पीछे आंदोलन को सक्षम करता है, लेकिन परिणामसेट . के प्रति संवेदनशील है अपडेट।

अन्य स्थिरांक का उपयोग किया जाता है, जैसे CONCUR_READ_ONLY , जिसका अर्थ है कि परिणाम सेट अद्यतन करने योग्य नहीं है। एक और स्थिरांक है, CONCUR_UPDATABLE , जो विपरीत को दर्शाता है, जिसका अर्थ है 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 यहां उपयोग किए गए स्थिरांक TYPE_SCROLL_SENSITIVE . हैं और CONCUR_UPDATABLE ।

निष्कर्ष

ResultSet, . के डिफ़ॉल्ट व्यवहार के विपरीत यह वस्तु को अधिक लचीलापन रखने का अधिकार देता है। इस कार्यक्षमता का उपयोग एप्लिकेशन द्वारा न केवल रिकॉर्ड के माध्यम से पार करने के लिए किया जा सकता है बल्कि उन्हें अद्यतन करने योग्य भी बनाया जा सकता है ताकि वे एक बेहतर सेवा प्रदान कर सकें। हालांकि परिणाम सेट का मानक व्यवहार स्क्रॉल करने योग्य ResultSet . की तुलना में काफी अक्षम लगता है , इसका अपना उपयोग है और इसलिए अपूरणीय है।