कभी-कभी, किसी डेटाबेस में एप्लिकेशन क्वेरीज़ बड़ी संख्या में पंक्तियाँ लौटाती हैं। हालांकि प्राप्त किए गए डेटा परिणामसेट . के भीतर कैश किए जाते हैं ऑब्जेक्ट, उनके साथ काम करना अक्सर बहुत बड़ा होता है। परिणामस्वरूप, हमें दृश्यमान पंक्तियों को सीमित करने के लिए उन्हें डेटा के विभिन्न सेटों में फ़िल्टर करने में सक्षम होना चाहिए। यह लेख JDBC RowSet . के फ़िल्टरिंग पहलू का वर्णन करता है उपयुक्त उदाहरणों के साथ।
RowSet . का एक सिंहावलोकन
रोसेट एक इंटरफ़ेस है जो JavaBeans घटक मॉडल के लिए JDBC API का पूरक है। यह गुणों का एक सेट प्रदान करता है जो इसके उदाहरण को JDBC डेटा स्रोत से कनेक्ट करने के लिए कॉन्फ़िगर करने की अनुमति देता है। एक रोसेट उदाहरण मुख्य रूप से डेटा स्रोत से डेटा पुनर्प्राप्त करने के लिए उपयोग किया जाता है। इस इंटरफ़ेस के सेटर विधियों का उपयोग SQL क्वेरी की कमांड प्रॉपर्टी के पैरामीटर को पॉप्युलेट करने के लिए किया जाता है, जिसका उपयोग रिलेशनल डेटाबेस से रिकॉर्ड लाने के लिए किया जाता है। क्योंकि रोसेट जावाबीन घटक मॉडल का पालन करता है, यह जावाबीन घटनाओं का समर्थन करता है। इन घटनाओं का उपयोग अन्य घटकों को घटनाओं के बारे में सूचित करने के लिए किया जाता है, जैसे कि एक पंक्ति पर मूल्य में परिवर्तन। क्योंकि रोसेट इंटरफ़ेस को JDBC ड्राइवर के ऊपर एक परत के रूप में डिज़ाइन किया गया है, यह कस्टम कार्यान्वयन के लिए खुला है। यह स्वतंत्रता विक्रेता को अपने स्वयं के फाइन-ट्यून प्रभाव को गढ़ने और इसे JDBC उत्पाद के साथ शिप करने का अधिकार देती है।
द फ़िल्टर किया गया रोसेट
FilteredRowSet RowSet . का एक इंटरफ़ेस एक्सटेंशन है परिवार। इस इंटरफ़ेस का एक संदर्भ कार्यान्वयन है, जिसे FilteredRowSetImpl . कहा जाता है कक्षा। FilteredRowSet . का कस्टम कार्यान्वयन प्रदान करने के लिए इंटरफ़ेस, कोई भी FilteredRowSetImpl . का विस्तार कर सकता है क्लास या FilteredRowSet . का उपयोग करें अपनी आवश्यकता के अनुसार इंटरफ़ेस। कुछ अवसरों पर, हमें उस सामग्री पर फ़िल्टरिंग के कुछ रूप लागू करने की आवश्यकता होती है जो RowSet . है लाता है एक आसान संभव समाधान सभी RowSet . के लिए एक क्वेरी भाषा प्रदान करना है कार्यान्वयन। लेकिन फिर, यह एक व्यवहार्य दृष्टिकोण नहीं है क्योंकि RowSet डिस्कनेक्ट किए गए हल्के घटक के विचार से बनाया गया है। यह वस्तु को भारी बना देगा और इसके डिजाइन सिद्धांत के खिलाफ जाएगा। हमें एक ऐसे दृष्टिकोण की आवश्यकता है जो फ़िल्टरिंग के प्रसंस्करण तर्क के साथ-साथ हैवीवेट क्वेरी भाषा को इंजेक्ट न करने की आवश्यकता को संबोधित करे। JDBC FilteredRowSet मानक कार्यान्वयन रोसेट को बढ़ाता है सबइंटरफेस जैसे CachedRowSet . के माध्यम से और WebRowSet क्रमश। FilteredRowSet CachedRowSet . द्वारा आपूर्ति की गई संरक्षित कर्सर हेरफेर विधियों के सेट के माध्यम से कर्सर में हेरफेर कर सकता है इंटरफेस। RowSet . को फ़िल्टर करते समय आवश्यकताओं और सहायता के अनुसार इन विधियों को ओवरराइड किया जा सकता है सामग्री।
एक त्वरित उदाहरण
FilteredRowSet . कैसे यह स्पष्ट करने के लिए यहां एक उदाहरण दिया गया है डेटाबेस में फ़ायर की गई क्वेरी द्वारा लौटाई गई सामग्री को संग्रहीत करने के लिए उपयोग किया जाता है। क्वेरी का परिणाम FilteredRowset पर लागू किए गए कॉन्फ़िगरेशन के अनुसार फ़िल्टर किया जाता है कार्यान्वयन। यह दृश्य सामग्री या उन पंक्तियों को परिभाषित करता है जिनमें हम रुचि रखते हैं क्वेरी द्वारा दिए गए परिणाम से। निम्नलिखित उदाहरण में, हमने SimpleFilter . नामक एक फ़िल्टर वर्ग बनाया है . यह वर्ग, हमारे मामले में, FilteredRowSet . के कस्टम कार्यान्वयन को परिभाषित करता है . फिर हमने इस फ़िल्टर को डेटाबेस क्वेरी से प्राप्त परिणाम पर लागू किया। फ़िल्टर करना इसका मतलब है कि दिखाई देने वाली पंक्तियों की संख्या को सीमित करना। इसलिए, हम यहां दिए गए चयनित लेखक के नाम के अनुसार पुस्तक सूचना रिकॉर्ड की संख्या को सीमित कर देंगे।
हैंड्स ऑन के लिए, आगामी जावा कोड के साथ उपयोग की जाने वाली डेटाबेस तालिकाएँ निम्नलिखित हैं।
चित्र 1: डेटाबेस तालिका, पुस्तक
चित्र 2: डेटाबेस तालिका, लेखक
चित्र 3: डेटाबेस तालिका, book_author
सरल फ़िल्टर वर्ग विधेय . को लागू करता है हमारे कस्टम फ़िल्टर को लागू करने के तरीकों का मूल्यांकन करें।
package org.mano.example;
import javax.sql.RowSet;
import javax.sql.rowset.Predicate;
import java.sql.SQLException;
public class SimpleFilter implements Predicate {
private String[] authors;
private String colname = null;
private int colno = -1;
public SimpleFilter(String[] authors, String colname) {
this.authors = authors;
this.colno = -1;
this.colname = colname;
}
public SimpleFilter(String[] authors, int colno) {
this.authors = authors;
this.colno = colno;
this.colname = null;
}
@Override
public Boolean evaluate(Object value, String colName) {
if (colName.equalsIgnoreCase(this.colname)) {
for (String author : this.authors) {
if (author.equalsIgnoreCase((String)value)) {
return true;
}
}
}
return false;
}
@Override
public Boolean evaluate(Object value, int colNumber) {
if (colNumber == this.colno) {
for (String author : this.authors)
if (author.equalsIgnoreCase((String)value)) {
return true;
}
}
}
return false
}
@Override
public Boolean evaluate(RowSet rs) {
if (rs == null) return false;
try {
for (int i=0;i<authors.length;i++) {
String al = null;
if (this.colno> 0) {
al = (String)rs.getObject(this.colno);
} else if (this.colname != null) {
al = (String)rs.getObject(this.colname);
} else {
return false;
}
if (al.equalsIgnoreCase(authors[i])) {
return true;
}
}
} catch (SQLException e) {
return false;
}
return false;
}
}
इस वर्ग का उपयोग SimpleRowSet . को निष्पादित करने के लिए किया जाता है फिल्टर वर्ग। ध्यान दें कि हमने FilteredRowSet . का उपयोग कैसे किया है एप्लिकेशन में डेटा फ़िल्टर करने के लिए। प्रसंस्करण SQL डेटाबेस स्तर के बजाय अनुप्रयोग स्तर पर होता है। नतीजतन, हम फिल्टर की एक श्रृंखला को लागू कर सकते हैं और वांछित परिणाम प्राप्त करने के लिए उन्हें उसी परिणाम सेट पर लागू कर सकते हैं। यह प्रदर्शन का लाभ उठाता है क्योंकि संशोधित परिणाम प्राप्त करने के लिए हमें डेटाबेस में एकाधिक प्रश्नों को सक्रिय करने की आवश्यकता नहीं है। इसके बजाय, हम डेटाबेस में एक बार फ़ायर किए गए क्वेरी परिणाम पर एकाधिक फ़िल्टरिंग लागू कर सकते हैं। आवेदन के दो महत्वपूर्ण चरण हैं:
- हम एक फ़िल्टर बनाते हैं जो डेटा को फ़िल्टर करने के लिए मानदंड निर्धारित करता है। यह विधेय . को लागू करके किया जाता है इंटरफेस। तर्कों के विभिन्न सेटों को स्वीकार करने वाले कई निर्माता हो सकते हैं। साथ ही, फ़िल्टर में मूल्यांकन () . की एक सरणी हो सकती है कार्यान्वयन के अपने अलग सेट के साथ तर्कों के विभिन्न सेटों को स्वीकार करने के तरीके भी।
- द फ़िल्टर किया गया रोसेट वांछित प्रभाव प्राप्त करने के लिए वर्ग को तत्काल किया जाना चाहिए, कुछ ऐसा जो हमने यहां applyFilter() के साथ किया है तरीका। FilteredRowSet देखे जाने वाले रिकॉर्ड को निर्धारित करने के लिए हमारे द्वारा प्रदान किए गए कस्टम फ़िल्टर वर्ग का उपयोग करता है।
package org.mano.example;
import com.sun.rowset.FilteredRowSetImpl;
import javax.sql.RowSet;
import javax.sql.rowset.FilteredRowSet;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DemoApp {
private static final String DB_URL =
"jdbc:mysql://localhost:3306/my_lib";
private static final String DB_DRIVER =
"com.mysql.cj.jdbc.Driver";
private static final String DB_USERNAME =
"root";
private static final String DB_PASSWORD =
"secret";
public static Connection conn = null;
public static FilteredRowSet filteredRowSet = null;
public static void main(String[] args) {
try {
Class.forName(DB_DRIVER);
conn = DriverManager.getConnection(DB_URL,
DB_USERNAME,DB_PASSWORD);
System.out.println("Database connection
successful.");
applyFilter();
} catch (SQLException | ClassNotFoundException ex) {
System.out.println(ex);
} finally {
if (conn != null) {
try {
conn.close();
catch (SQLException ex) {
ex.printStackTrace();
}
}
if (filteredRowSet != null) {
try {
filteredRowSet.close();
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}
}
public static void applyFilter() {
String[] arr = {"Donne", "Milton"};
SimpleFilter aFilter = new SimpleFilter(arr, 3);
try {
filteredRowSet = new FilteredRowSetImpl();
filteredRowSet.setCommand("SELECT title, f_name, l_name "
+ "FROM book_author BA, "
+ "author A, "
+ "book B "
+ "WHERE A.auth_id = BA.fk_author "
+ "AND B.book_id = BA.fk_book");
filteredRowSet.execute(conn);
System.out.println
("--------------------------------------------");
System.out.println("Before applying any
filter:");
System.out.println
("--------------------------------------------");
show(filteredRowSet);
System.out.println
("--------------------------------------------");
System.out.println("After applying
filter :");
System.out.println
("--------------------------------------------");
filteredRowSet.beforeFirst();
filteredRowSet.setFilter(aFilter);
show(filteredRowSet);
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void show(RowSet rs) {
try {
while (rs.next()) {
System.out.println(rs.getString(1) + " / "
+ rs.getString(2)
+ " "+rs.getString(3));
}
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}
आउटपुट
Database connection successful. -------------------------------------------- Before applying any filter: -------------------------------------------- Gulliver's Travels / Jonathan Swift ... Ill Pensoroso / John Milton Areopagitica / John Milton -------------------------------------------- After applying filter: -------------------------------------------- The Flea / John Donne Holy Sonnet / John Donne Paradise Lost / John Milton Paradise Regained / John Milton Ill Pensoroso / John Milton Areopagitica / John Milton
निष्कर्ष
किसी क्वेरी से लौटाई गई बड़ी संख्या में पंक्तियों के साथ काम करने में कई समस्याएं होती हैं। एक के लिए, पुनर्प्राप्त किया गया डेटा स्मृति पर कब्जा कर लेता है।
यह उन्हें आवश्यकता और प्रासंगिकता के अनुसार सीमित करने में हमेशा मदद करता है। रोसेट . के साथ , हम कोई अतिरिक्त डेटाबेस अनुरोध किए बिना उन्हें एक मानदंड के अनुसार फ़िल्टर कर सकते हैं। यह डेटाबेस पंक्तियों के साथ काम करने के लिए इसे और अधिक प्रबंधनीय बनाता है और कोड की दक्षता का लाभ उठाता है।
