👭 👩🏽 🧒 Android में पूर्ण पाठ खोज 🐝 💤 🔹

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

मोबाइल एप्लिकेशन में खोज के कार्यान्वयन के लिए दृष्टिकोण

डेटा फ़िल्टर के रूप में खोजें

आमतौर पर यह किसी सूची के ऊपर एक खोज पट्टी की तरह दिखता है। यही है, हम सिर्फ तैयार डेटा को फ़िल्टर करते हैं।
सर्वर खोज

इस मामले में, हम सर्वर को संपूर्ण कार्यान्वयन देते हैं, और एप्लिकेशन एक पतले क्लाइंट के रूप में कार्य करता है, जिसमें से केवल डेटा को सही रूप में दिखाना आवश्यक है।
एकीकृत खोज
- एप्लिकेशन में विभिन्न प्रकार के डेटा की एक बड़ी मात्रा होती है;
- आवेदन ऑफ़लाइन काम करता है;
- एप्लिकेशन के अनुभागों / सामग्री तक एकल पहुंच बिंदु के रूप में खोज की आवश्यकता है।

बाद के मामले में, SQLite में निर्मित पूर्ण-पाठ खोज बचाव के लिए आता है। इसके साथ, आप बहुत तेज़ी से जानकारी की एक बड़ी मात्रा में मिलान पा सकते हैं, जो हमें प्रदर्शन का त्याग किए बिना विभिन्न तालिकाओं के लिए कई प्रश्न करने की अनुमति देता है।

एक विशिष्ट उदाहरण का उपयोग करके ऐसी खोज के कार्यान्वयन पर विचार करें।

डेटा की तैयारी

मान लीजिए कि हमें एक ऐसे एप्लिकेशन को लागू करने की आवश्यकता है जो themoviedb.org से फिल्मों की सूची दिखाता है । सरल बनाने के लिए (ताकि ऑनलाइन जाने के लिए नहीं), फिल्मों की एक सूची लें और उसमें से JSON फ़ाइल बनाएं, इसे संपत्ति में डालें और हमारे डेटाबेस को स्थानीय रूप से आबाद करें।

उदाहरण JSON फ़ाइल संरचना:

[ { "id": 278, "title": "  ", "overview": "  ..." }, { "id": 238, "title": " ", "overview": " , ..." }, { "id": 424, "title": " ", "overview": "   ..." } ]

डेटाबेस भरना

SQLite पूर्ण-पाठ खोज को कार्यान्वित करने के लिए वर्चुअल तालिकाओं का उपयोग करता है। बाह्य रूप से, वे नियमित SQLite तालिकाओं की तरह दिखते हैं, लेकिन उनके लिए कोई भी पहुँच कुछ बैकस्टेज कार्य करता है।

वर्चुअल टेबल हमें खोज को गति देने की अनुमति देते हैं। लेकिन, फायदे के अलावा, उनके नुकसान भी हैं:

आप वर्चुअल टेबल पर ट्रिगर नहीं बना सकते हैं;
आप वर्चुअल टेबल के लिए ALTER TABLE और ADD COLUMN कमांड निष्पादित नहीं कर सकते हैं;
वर्चुअल टेबल में प्रत्येक कॉलम को अनुक्रमित किया जाता है, जिसका अर्थ है कि संसाधनों को इंडेक्सिंग कॉलम पर बर्बाद किया जा सकता है जो खोज में शामिल नहीं होना चाहिए।

बाद की समस्या को हल करने के लिए, आप अतिरिक्त तालिकाओं का उपयोग कर सकते हैं जिसमें जानकारी का हिस्सा होगा, और एक आभासी तालिका में एक नियमित तालिका के तत्वों के लिए लिंक संग्रहीत करेगा।

तालिका बनाना मानक से थोड़ा अलग है, हमारे पास कीवर्ड और fts4 :

  CREATE VIRTUAL TABLE movies USING fts4(id, title, overview);

Fts5 संस्करण पर टिप्पणी करना

इसे पहले ही SQLite में जोड़ दिया गया है। यह संस्करण अधिक उत्पादक है, अधिक सटीक है और इसमें कई नई विशेषताएं हैं। लेकिन Android के बड़े विखंडन के कारण, हम सभी उपकरणों पर fts5 (API24 के साथ उपलब्ध) का उपयोग नहीं कर सकते हैं। आप ऑपरेटिंग सिस्टम के विभिन्न संस्करणों के लिए अलग-अलग तर्क लिख सकते हैं, लेकिन यह आगे के विकास और समर्थन को गंभीरता से जटिल करेगा। हमने आसान तरीका जाना और fts4 का उपयोग करने का निर्णय लिया, जो कि अधिकांश उपकरणों पर समर्थित है।

भरना सामान्य से अलग नहीं है:

 fun populate(context: Context) { val movies: MutableList<Movie> = mutableListOf() context.assets.open("movies.json").use { val typeToken = object : TypeToken<List<Movie>>() {}.type movies.addAll(Gson().fromJson(InputStreamReader(it), typeToken)) } try { writableDatabase.beginTransaction() movies.forEach { movie -> val values = ContentValues().apply { put("id", movie.id) put("title", movie.title) put("overview", movie.overview) } writableDatabase.insert("movies", null, values) } writableDatabase.setTransactionSuccessful() } finally { writableDatabase.endTransaction() } }

मूल संस्करण

क्वेरी निष्पादित करते समय, MATCH कीवर्ड का उपयोग LIKE बजाय किया जाता है:

 fun firstSearch(searchString: String): List<Movie> { val query = "SELECT * FROM movies WHERE movies MATCH '$searchString'" val cursor = readableDatabase.rawQuery(query, null) val result = mutableListOf<Movie>() cursor?.use { if (!cursor.moveToFirst()) return result while (!cursor.isAfterLast) { val id = cursor.getInt("id") val title = cursor.getString("title") val overview = cursor.getString("overview") result.add(Movie(id, title, overview)) cursor.moveToNext() } } return result }

इंटरफ़ेस में पाठ इनपुट प्रसंस्करण को लागू करने के लिए, हम RxJava उपयोग RxJava :

 RxTextView.afterTextChangeEvents(findViewById(R.id.editText)) .debounce(500, TimeUnit.MILLISECONDS) .map { it.editable().toString() } .filter { it.isNotEmpty() && it.length > 2 } .map(dbHelper::firstSearch) .subscribeOn(Schedulers.computation()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(movieAdapter::updateMovies)

परिणाम एक बुनियादी खोज विकल्प है। पहले तत्व में वांछित शब्द वर्णन में और दूसरे तत्व में शीर्षक और विवरण में पाया गया। जाहिर है, इस रूप में यह पूरी तरह से स्पष्ट नहीं है कि हमने क्या पाया। चलो इसे ठीक करते हैं।

उच्चारण जोड़ें

खोज की स्पष्टता में सुधार करने के लिए, हम सहायक फ़ंक्शन SNIPPET उपयोग करेंगे। इसका उपयोग एक स्वरूपित पाठ खंड को प्रदर्शित करने के लिए किया जाता है जिसमें एक मिलान पाया जाता है।

 snippet(movies, '<b>', '</b>', '...', 1, 15)

फिल्में - तालिका का नाम;
<b & gt; और </ b> - इन तर्कों का उपयोग उस पाठ के एक भाग को उजागर करने के लिए किया जाता है जिसे खोजा गया था;
... - पाठ के डिजाइन के लिए, यदि परिणाम एक अपूर्ण मूल्य था;
1 - तालिका का स्तंभ संख्या जिसमें से पाठ के टुकड़े आवंटित किए जाएंगे;
15 लौटे पाठ मान में शामिल शब्दों की एक अनुमानित संख्या है।

कोड पहले के समान है, अनुरोध की गिनती नहीं:

 SELECT id, snippet(movies, '<b>', '</b>', '...', 1, 15) title, snippet(movies, '<b>', '</b>', '...', 2, 15) overview FROM movies WHERE movies MATCH ''

हम फिर से कोशिश करते हैं:

यह पिछले संस्करण की तुलना में अधिक स्पष्ट रूप से निकला। लेकिन यह अंत नहीं है। चलो हमारी खोज को और अधिक "पूर्ण" बनाते हैं। हम लेक्सिकल विश्लेषण का उपयोग करेंगे और हमारी खोज क्वेरी के महत्वपूर्ण भागों को उजागर करेंगे।

सुधार खत्म करो

SQLite में अंतर्निहित टोकन हैं जो आपको शाब्दिक विश्लेषण करने और मूल खोज क्वेरी को बदलने की अनुमति देते हैं। यदि तालिका बनाते समय हमने एक विशिष्ट टोकन निर्दिष्ट नहीं किया, तो "सरल" का चयन किया जाएगा। वास्तव में, यह केवल हमारे डेटा को निचले अक्षरों में परिवर्तित करता है और अपठनीय वर्णों को जोड़ता है। यह हमें काफी सूट नहीं करता है

खोज में गुणात्मक सुधार के लिए, हमें स्टेमिंग का उपयोग करने की आवश्यकता है - किसी दिए गए स्रोत शब्द के लिए एक शब्द का आधार खोजने की प्रक्रिया।

SQLite में एक अतिरिक्त अंतर्निहित टोकन है जो पोर्टर स्टीमर एल्गोरिथ्म का उपयोग करता है। यह एल्गोरिथ्म क्रमिक रूप से कुछ नियमों को लागू करता है, अंत और प्रत्ययों को काटकर किसी शब्द के महत्वपूर्ण भागों को उजागर करता है। उदाहरण के लिए, "कुंजी" की खोज करते समय, हम एक खोज प्राप्त कर सकते हैं जहां शब्द "कुंजी", "कुंजी" और "कुंजी" निहित हैं। मैं अंत में एल्गोरिथ्म के विस्तृत विवरण के लिए एक लिंक छोड़ दूंगा।

दुर्भाग्य से, SQLite में बनाया गया टोकन केवल अंग्रेजी के साथ काम करता है, इसलिए रूसी भाषा के लिए आपको अपने स्वयं के कार्यान्वयन को लिखने या तैयार किए गए घटनाक्रम का उपयोग करने की आवश्यकता है। हम एल्गोरिदम साइट से तैयार कार्यान्वयन को ले लेंगे।

हम अपनी खोज क्वेरी को आवश्यक रूप में बदलते हैं:

अतिरिक्त वर्ण निकालें।
वाक्यांश को शब्दों में तोड़ो।
तने के माध्यम से छोड़ें।
एक खोज क्वेरी में इकट्ठा करें।

पोर्टर एलगोरिदम

  object Porter { private val PERFECTIVEGROUND = Pattern.compile("((|||||)|((<=[])(||)))$") private val REFLEXIVE = Pattern.compile("([])$") private val ADJECTIVE = Pattern.compile("(|||||||||||||||||||||||||)$") private val PARTICIPLE = Pattern.compile("((||)|((?<=[])(||||)))$") private val VERB = Pattern.compile("((||||||||||||||||||||||||||||)|((?<=[])(||||||||||||||||)))$") private val NOUN = Pattern.compile("(|||||||||||||||||||||||||||||||||||)$") private val RVRE = Pattern.compile("^(.*?[])(.*)$") private val DERIVATIONAL = Pattern.compile(".*[^]+[].*?$") private val DER = Pattern.compile("?$") private val SUPERLATIVE = Pattern.compile("(|)$") private val I = Pattern.compile("$") private val P = Pattern.compile("$") private val NN = Pattern.compile("$") fun stem(words: String): String { var word = words word = word.toLowerCase() word = word.replace('', '') val m = RVRE.matcher(word) if (m.matches()) { val pre = m.group(1) var rv = m.group(2) var temp = PERFECTIVEGROUND.matcher(rv).replaceFirst("") if (temp == rv) { rv = REFLEXIVE.matcher(rv).replaceFirst("") temp = ADJECTIVE.matcher(rv).replaceFirst("") if (temp != rv) { rv = temp rv = PARTICIPLE.matcher(rv).replaceFirst("") } else { temp = VERB.matcher(rv).replaceFirst("") if (temp == rv) { rv = NOUN.matcher(rv).replaceFirst("") } else { rv = temp } } } else { rv = temp } rv = I.matcher(rv).replaceFirst("") if (DERIVATIONAL.matcher(rv).matches()) { rv = DER.matcher(rv).replaceFirst("") } temp = P.matcher(rv).replaceFirst("") if (temp == rv) { rv = SUPERLATIVE.matcher(rv).replaceFirst("") rv = NN.matcher(rv).replaceFirst("") } else { rv = temp } word = pre + rv } return word } }

एल्गोरिथ्म जहां हम वाक्यांश को शब्दों में तोड़ते हैं

 val words = searchString .replace("\"(\\[\"]|.*)?\"".toRegex(), " ") .split("[^\\p{Alpha}]+".toRegex()) .filter { it.isNotBlank() } .map(Porter::stem) .filter { it.length > 2 } .joinToString(separator = " OR ", transform = { "$it*" })

इस रूपांतरण के बाद, "प्रांगण और भूत" वाक्यांश "यार्ड * या भूत * " जैसा दिखता है।

प्रतीक " * " का अर्थ है कि खोज दूसरे शब्दों में किसी दिए गए शब्द की घटना द्वारा आयोजित की जाएगी। " OR " ऑपरेटर का मतलब है कि परिणाम दिखाए जाएंगे जिसमें खोज वाक्यांश से कम से कम एक शब्द होता है। हम देखते हैं:

सारांश

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

Android में पूर्ण पाठ खोज