इस ट्यूटोरियल में, हम Manticore Search में उपलब्ध पूर्ण-पाठ खोज ऑपरेटरों का अन्वेषण करेंगे।
पूर्ण पाठ ऑपरेटर और बुनियादी खोज की परिचय
Manticore Search में सभी खोज संचालन मानक बूलियन ऑपरेटरों (AND, OR, NOT) पर आधारित हैं, जिन्हें संयोजन में और स्वतंत्र क्रम में उपयोग किया जा सकता है ताकि अधिक प्रासंगिक परिणामों के लिए कीवर्ड को जोड़ा या बहिष्कृत किया जा सके।
डिफ़ॉल्ट और सबसे सरल पूर्ण-पाठ ऑपरेटर AND है, जिसे तब माना जाता है जब आप केवल कुछ शब्दों को खोज में सूचीबद्ध करते हैं।
AND एक डिफ़ॉल्ट ऑपरेटर है जिसके साथ fast slow क्वेरी उन दस्तावेज़ों को वापस करेगी जिनमें दोनों शब्द हैं: ‘fast’ और ‘slow’। यदि कोई एक शब्द किसी दस्तावेज़ में है और दूसरा नहीं है, तो वह दस्तावेज़ परिणामी सूची में शामिल नहीं होगा।
डिफ़ॉल्ट रूप से, शब्दों की खोज सभी उपलब्ध पूर्ण-पाठ क्षेत्रों में की जाएगी।
SELECT * FROM testrt WHERE MATCH('fast slow');
OR का उपयोग किसी भी शब्द (या दोनों) से मेल खाने के लिए किया जाता है। शब्दों को एक.vertical.line द्वारा विभाजित किया जाना चाहिए, जैसे fast | slow। यह दस्तावेज़ों को fast या slow के साथ खोजेगा।
SELECT * FROM testrt WHERE MATCH('fast | slow');
OR ऑपरेटर का प्राथमिकता AND से अधिक है, इसलिए क्वेरी ‘find me fast|slow’ को ‘find me (fast|slow)’ के रूप में समझा जा सकता है:
SELECT * FROM testrt WHERE MATCH('find me fast | slow');
NOT सुनिश्चित करता है कि - या ! से चिह्नित शब्द परिणामों में नहीं है। किसी भी दस्तावेज़ में ऐसा शब्द होने पर उसे बाहर रखा जाएगा। जैसे fast !slow दस्तावेज़ों को fast के साथ खोजेगा यदि उनमें slow नहीं है। इसे खोज को कम करने का प्रयास करते समय सावधान रहें, क्योंकि यह बहुत विशिष्ट हो सकता है और अच्छे दस्तावेज़ों को बाहर कर सकता है।
SELECT * FROM testrt WHERE MATCH('find !slow');
SELECT * FROM testrt WHERE MATCH('find -slow');
MAYBE एक विशेष ऑपरेटर है जो OR की तरह काम करता है, लेकिन बाएं शब्द को हमेशा परिणामों में होना चाहिए जबकि दाहिना शब्द वैकल्पिक होता है। लेकिन जब दोनों पूरे होते हैं तो दस्तावेज़ को उच्च खोज रैंक प्राप्त होगा। जैसे fast MAYBE slow दस्तावेज़ों को fast या slow के साथ खोजेगा, लेकिन दोनों शब्दों के साथ दस्तावेज़ों का स्कोर अधिक होगा।
SELECT * FROM testrt WHERE MATCH('find MAYBE slow');
उपयोग के उदाहरण
आओ हम mysql क्लाइंट का उपयोग करके Manticore से कनेक्ट करें:
# mysql -P9306 -h0
बूलियन खोजों के लिए OR ऑपरेटर | का उपयोग किया जा सकता है:
MySQL [(none)]> select * from testrt where match('find | me fast');
+------+------+------------------------+----------------+
| id | gid | title | content |
+------+------+------------------------+----------------+
| 1 | 1 | find me | fast and quick|
| 2 | 1 | find me fast | quick |
| 6 | 1 | find me fast now | quick |
| 5 | 1 | find me quick and fast | quick |
+------+------+------------------------+----------------+
4 rows in set (0.00 sec)
OR ऑपरेटर का प्राथमिकता AND से अधिक है, क्वेरी find me fast|slow को find me (fast|slow) के रूप में व्याख्यायित किया गया है:
MySQL [(none)]> SELECT * FROM testrt WHERE MATCH('find me fast|slow');
+------+------+------------------------+----------------+
| id | gid | title | content |
+------+------+------------------------+----------------+
| 1 | 1 | find me | fast and quick|
| 2 | 1 | find me fast | quick |
| 6 | 1 | find me fast now | quick |
| 3 | 1 | find me slow | quick |
| 5 | 1 | find me quick and fast | quick |
+------+------+------------------------+----------------+
5 rows in set (0.00 sec)
नकारात्मकताओं के लिए ऑपरेटर NOT को - या ! के रूप में निर्दिष्ट किया जा सकता है:
MySQL [(none)]> select * from testrt where match('find me -fast');
+------+------+--------------+---------+
| id | gid | title | content |
+------+------+--------------+---------+
| 3 | 1 | find me slow | quick |
+------+------+--------------+---------+
1 row in set (0.00 sec)
यह नोट करना आवश्यक है कि पूर्ण नकारात्मकता क्वेरी Manticore में डिफ़ॉल्ट रूप से समर्थित नहीं हैं और केवल -fast चलाना संभव नहीं है (यह v3.5.2 से संभव होगा)।
एक अन्य बुनियादी ऑपरेटर MAYBE है। MAYBE द्वारा परिभाषित शब्द दस्तावेज़ों में मौजूद हो सकता है या नहीं। यदि यह मौजूद है, तो यह रैंकिंग को प्रभावित करेगा और इसे रखने वाले दस्तावेज़ अधिक रैंक प्राप्त करेंगे।
MySQL [(none)]> select * from testrt where match('find me MAYBE slow');
+------+------+------------------------+----------------+
| id | gid | title | content |
+------+------+------------------------+----------------+
| 3 | 1 | find me slow | quick |
| 1 | 1 | find me | fast and quick|
| 2 | 1 | find me fast | quick |
| 5 | 1 | find me quick and fast | quick |
| 6 | 1 | find me fast now | quick |
+------+------+------------------------+----------------+
5 rows in set (0.00 sec)
फ़ील्ड ऑपरेटर
यदि हम खोज को केवल एक विशिष्ट क्षेत्र तक सीमित करना चाहते हैं तो ‘@’ ऑपरेटर का उपयोग किया जा सकता है:
mysql> select * from testrt where match('@title find me fast');
+------+------+------------------------+---------+
| id | gid | title | content |
+------+------+------------------------+---------+
| 2 | 1 | find me fast | quick |
| 6 | 1 | find me fast now | quick |
| 5 | 1 | मुझे जल्दी और तेज़ खोजें | जल्दी |
+------+------+------------------------+---------+
3 पंक्तियाँ सेट में (0.00 सेकंड)
हम कई फ़ील्ड भी निर्दिष्ट कर सकते हैं ताकि खोज को सीमित किया जा सके:
mysql> select * from testrt where match('@(title,content) मुझे तेजी से खोजें');
+------+------+------------------------+----------------+
| id | gid | title | content |
+------+------+------------------------+----------------+
| 1 | 1 | मुझे खोजें | तेज़ और जल्दी |
| 2 | 1 | मुझे तेजी से खोजें | जल्दी |
| 6 | 1 | मुझे अब तेजी से खोजें | जल्दी |
| 5 | 1 | मुझे जल्दी और तेज़ खोजें | जल्दी |
+------+------+------------------------+----------------+
4 पंक्तियाँ सेट में (0.00 सेकंड)
क्षेत्र ऑपरेटर का उपयोग केवल पहले x शब्दों में खोज को प्रतिबंधित करने के लिए भी किया जा सकता है। उदाहरण के लिए:
mysql> select * from testrt where match('@title आलसी कुत्ता');
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| id | gid | title | content |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| 4 | 1 | तेज़ भूरे गिलहरी आलसी कुत्ता पर कूदता है | पाँच मुक्केबाज़ जल्दी कूदते हैं |
| 7 | 1 | तेज़ भूरे गिलहरी एक कदम पीछे हटता है और आलसी कुत्ता पर कूदता है | पाँच मुक्केबाज़ जल्दी कूदते हैं |
| 8 | 1 | भूरे और सुंदर गिलहरी एक कदम पीछे हटता है और आलसी कुत्ता पर कूदता है | पाँच मुक्केबाज़ जल्दी कूदते हैं |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
4 पंक्तियाँ सेट में (0.00 सेकंड)
हालांकि यदि हम केवल पहले 5 शब्दों में खोज करते हैं तो हमें कुछ नहीं मिलता:
mysql> select * from testrt where match('@title[5] आलसी कुत्ता');
खाली सेट (0.00 सेकंड)
कुछ स्थितियों में खोज कई अनुक्रमणिकाओं पर की जा सकती है जिनमें समान पूर्ण-पाठ फ़ील्ड नहीं हो सकते हैं।
डिफ़ॉल्ट रूप से, यदि आप एक फ़ील्ड निर्दिष्ट करते हैं जो अनुक्रमणिका में मौजूद नहीं है, तो यह एक क्वेरी त्रुटि का परिणाम देगा। इसे पार करने के लिए, विशेष ऑपरेटर @@relaxed का उपयोग किया जा सकता है:
mysql> select * from testrt where match('@(title,keywords) आलसी कुत्ता');<br></br>त्रुटि 1064 (42000): अनुक्रमणिका testrt: क्वेरी त्रुटि: स्कीमा में कोई फ़ील्ड 'keywords' नहीं मिला
mysql> select * from testrt where match('@@relaxed @(title,keywords) आलसी कुत्ता');
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| id | gid | title | content |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| 4 | 1 | तेज़ भूरे गिलहरी आलसी कुत्ता पर कूदता है | पाँच मुक्केबाज़ जल्दी कूदते हैं |
| 7 | 1 | तेज़ भूरे गिलहरी एक कदम पीछे हटता है और आलसी कुत्ता पर कूदता है | पाँच मुक्केबाज़ जल्दी कूदते हैं |
| 8 | 1 | भूरे और सुंदर गिलहरी एक कदम पीछे हटता है और आलसी कुत्ता पर कूदता है | पाँच मुक्केबाज़ जल्दी कूदते हैं |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
3 पंक्तियाँ सेट में, 1 चेतावनी (0.01 सेकंड)
फजी खोज
फजी मिलान केवल क्वेरी स्ट्रिंग के कुछ शब्दों से मेल खाने की अनुमति देता है, उदाहरण के लिए:
mysql> select * from testrt where match('"गिलहरी पक्षी आलसी कुत्ता"/3');
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| id | gid | title | content |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| 4 | 1 | तेज़ भूरे गिलहरी आलसी कुत्ता पर कूदता है | पाँच मुक्केबाज़ जल्दी कूदते हैं |
| 7 | 1 | तेज़ भूरे गिलहरी एक कदम पीछे हटता है और आलसी कुत्ता पर कूदता है | पाँच मुक्केबाज़ जल्दी कूदते हैं |
| 8 | 1 | भूरे और सुंदर गिलहरी एक कदम पीछे हटता है और आलसी कुत्ता पर कूदता है | पाँच मुक्केबाज़ जल्दी कूदते हैं |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
3 पंक्तियाँ सेट में (0.00 सेकंड)
इस मामले में, हम QUORUM ऑपरेटर का उपयोग करते हैं और निर्दिष्ट करते हैं कि केवल 3 शब्दों से मेल होना ठीक है। /1 के साथ खोज OR बूलियन खोज के समान है जबकि /N के साथ खोज जहां N इनपुट शब्दों की संख्या है, AND खोज के समान है।
एक निश्चित संख्या के बजाय, आप 0.0 और 1.0 के बीच एक संख्या भी निर्दिष्ट कर सकते हैं (जो 0% और 100% का प्रतिनिधित्व करता है), और Manticore केवल उन दस्तावेज़ों से मेल खाएगा जिनमें निर्दिष्ट शब्दों में से कम से कम प्रतिशत होगा। ऊपर दिए गए वही उदाहरण "गिलहरी पक्षी आलसी कुत्ता"/0.3 के रूप में भी लिखा जा सकता था और यह कम से कम 30% 4 शब्दों के साथ दस्तावेज़ों को मेल करेगा।
mysql> select * from testrt where match('"गिलहरी पक्षी आलसी कुत्ता"/0.3');
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| id | gid | title | content |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| 4 | 1 | तेज़ भूरे गिलहरी आलसी कुत्ता पर कूदता है | पाँच मुक्केबाज़ जल्दी कूदते हैं |
| 7 | 1 | तेज़ भूरे गिलहरी एक कदम पीछे हटता है और आलसी कुत्ता पर कूदता है | पाँच मुक्केबाज़ जल्दी कूदते हैं |
| 8 | 1 | भूरे और सुंदर लोमड़ी एक कदम पीछे हटती है और सुस्त कुत्ते पर कूदती है | पाँच मुक्केबाजी जादूगर तेजी से कूदते हैं |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
3 पंक्तियाँ सेट में (0.00 सेकंड)
उन्नत ऑपरेटर
सरल ऑपरेटरों के अलावा कई उन्नत ऑपरेटर हैं जो कम उपयोग किए जाते हैं, लेकिन कुछ मामलों में यह बिल्कुल आवश्यक हो सकते हैं।
सबसे अधिक उपयोग किए जाने वाले उन्नत ऑपरेटरों में से एक वाक्यांश ऑपरेटर है।
वाक्यांश ऑपरेटर केवल तब मेल खाता है जब दिए गए शब्द शब्दश: निर्दिष्ट क्रम में पाए जाते हैं। यह शब्दों को एक ही क्षेत्र में खोजने के लिए भी प्रतिबंधित करेगा:
mysql> SELECT * FROM testrt WHERE MATCH('"त्वरित भूरे लोमड़ी"');
+------+------+-------------------------------------------------------------------+---------------------------------------+
| id | gid | शीर्षक | सामग्री |
+------+------+-------------------------------------------------------------------+---------------------------------------+
| 4 | 1 | त्वरित भूरे लोमड़ी सुस्त कुत्ते पर कूदती है | पाँच मुक्केबाजी जादूगर तेजी से कूदते हैं |
| 7 | 1 | त्वरित भूरे लोमड़ी एक कदम पीछे हटती है और सुस्त कुत्ते पर कूदती है | पाँच मुक्केबाजी जादूगर तेजी से कूदते हैं |
+------+------+-------------------------------------------------------------------+---------------------------------------+
2 पंक्तियाँ सेट में (0.00 सेकंड)
वाक्यांश ऑपरेटर का अधिक आसान संस्करण कड़क आदेश ऑपरेटर है।
ऑर्डर ऑपरेटर को खोजे जाने वाले शब्दों के ठीक उसी क्रम में खोजा जाना चाहिए जैसा कि निर्दिष्ट किया गया है, लेकिन अन्य शब्द बीच में स्वीकार किए जाते हैं:
mysql> SELECT * FROM testrt WHERE MATCH('ढूंढो << मुझे << तेजी से');
+------+------+------------------------+---------+
| id | gid | शीर्षक | सामग्री |
+------+------+------------------------+---------+
| 2 | 1 | मुझे तेजी से ढूंढो | तेजी |
| 6 | 1 | मुझे अब तेजी से ढूंढो | तेजी |
| 5 | 1 | मुझे तेजी से और तेजी से ढूंढो | तेजी |
+------+------+------------------------+---------+
3 पंक्तियाँ सेट में (0.00 सेकंड)
शब्द स्थितियों के साथ काम करने वाले ऑपरेटरों की एक अन्य जोड़ी प्रारंभ/समाप्त क्षेत्र ऑपरेटर हैं।
ये शब्द को एक क्षेत्र के प्रारंभ या अंत में उपस्थित होने के लिए प्रतिबंधित करेंगे।
mysql> SELECT * FROM testrt WHERE MATCH('^मुझे तेजी से$');
+------+------+------------------------+---------+
| id | gid | शीर्षक | सामग्री |
+------+------+------------------------+---------+
| 2 | 1 | मुझे तेजी से ढूंढो | तेजी |
| 5 | 1 | मुझे तेजी से और तेजी से ढूंढो | तेजी |
+------+------+------------------------+---------+
2 पंक्तियाँ सेट में (0.00 सेकंड)
निकटता ऑपरेटर AND ऑपरेटर के समान है, लेकिन शब्दों के बीच अधिकतम दूरी जोड़ता है ताकि वे अभी भी मेल खा सकें। आइए बस AND ऑपरेटर के साथ इस उदाहरण को लें:
mysql> SELECT * FROM testrt WHERE MATCH('भूरा लोमड़ी कूदती है');
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| id | gid | शीर्षक | सामग्री |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| 4 | 1 | त्वरित भूरे लोमड़ी सुस्त कुत्ते पर कूदती है | पाँच मुक्केबाजी जादूगर तेजी से कूदते हैं |
| 7 | 1 | त्वरित भूरे लोमड़ी एक कदम पीछे हटती है और सुस्त कुत्ते पर कूदती है | पाँच मुक्केबाजी जादूगर तेजी से कूदते हैं |
| 8 | 1 | भूरे और सुंदर लोमड़ी एक कदम पीछे हटती है और सुस्त कुत्ते पर कूदती है | पाँच मुक्केबाजी जादूगर तेजी से कूदते हैं |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
3 पंक्तियाँ सेट में (0.00 सेकंड)
हमारा क्वेरी 2 परिणाम लौटाता है: एक जिसमें सभी शब्द एक-दूसरे के निकट हैं और दूसरा जहाँ एक शब्द अधिक दूर है।
यदि हम केवल यह मेल करना चाहते हैं कि शब्द एक निश्चित दूरी के भीतर हैं, तो हम इसे निकटता ऑपरेटर के साथ प्रतिबंधित कर सकते हैं:
mysql> SELECT * FROM testrt WHERE MATCH('"भूरा लोमड़ी कूदती है"~5');
+------+------+---------------------------------------------+---------------------------------------+
| id | gid | शीर्षक | सामग्री |
+------+------+---------------------------------------------+---------------------------------------+
| 4 | 1 | त्वरित भूरे लोमड़ी सुस्त कुत्ते पर कूदती है | पाँच मुक्केबाजी जादूगर तेजी से कूदते हैं |
+------+------+---------------------------------------------+---------------------------------------+
1 पंक्ति सेट में (0.00 सेकंड)
निकटता ऑपरेटर का अधिक सामान्यीकृत संस्करण NEAR ऑपरेटर है। निकटता के मामले में एकल दूरी एक शब्दों के समूह पर निर्दिष्ट की जाती है, जबकि NEAR ऑपरेटर 2 ऑपरेटरों के साथ काम करता है, जो या तो एकल शब्द या अभिव्यक्तियाँ हो सकते हैं।
निम्नलिखित उदाहरण में, ‘भूरा’ और ‘लोमड़ी’ को 2 की दूरी के भीतर होना चाहिए और ‘लोमड़ी’ और ‘कूदती है’ को 6 की दूरी के भीतर होना चाहिए:
mysql> SELECT * FROM testrt WHERE MATCH('भूरा NEAR/2 लोमड़ी NEAR/6 कूदती है');
+------+------+-------------------------------------------------------------------+---------------------------------------+
| id | gid | शीर्षक | सामग्री |
+------+------+-------------------------------------------------------------------+---------------------------------------+
| 4 | 1 | त्वरित भूरे लोमड़ी सुस्त कुत्ते पर कूदती है | पाँच मुक्केबाजी जादूगर तेजी से कूदते हैं |
| 7 | 1 | त्वरित भूरे लोमड़ी एक कदम पीछे हटती है और सुस्त कुत्ते पर कूदती है | पाँच मुक्केबाजी जादूगर तेजी से कूदते हैं |
+------+------+-------------------------------------------------------------------+---------------------------------------+
2 पंक्तियाँ सेट में (0.00 सेकंड)
The query leaves out one document which doesn’t match the first NEAR condition (the last one here):
mysql> SELECT * FROM testrt WHERE MATCH('brown NEAR/3 fox NEAR/6 jumps');
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| id | gid | title | content |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
| 4 | 1 | The quick brown fox jumps over the lazy dog | The five boxing wizards jump quickly |
| 7 | 1 | The quick brown fox take a step back and jumps over the lazy dog | The five boxing wizards jump quickly |
| 8 | 1 | The brown and beautiful fox take a step back and jumps over the lazy dog | The five boxing wizards jump quickly |
+------+------+----------------------------------------------------------------------------+---------------------------------------+
3 rows in set (0.09 sec)
A variation of the NEAR operator is NOTNEAR, which matches only if the operands have a minimum distance between them.
mysql> SELECT * FROM testrt WHERE MATCH('"brown fox" NOTNEAR/5 jumps');
+------+------+-------------------------------------------------------------------+---------------------------------------+
| id | gid | title | content |
+------+------+-------------------------------------------------------------------+---------------------------------------+
| 7 | 1 | The quick brown fox take a step back and jumps over the lazy dog | The five boxing wizards jump quickly |
+------+------+-------------------------------------------------------------------+---------------------------------------+
1 row in set (0.00 sec)
Manticore can also detect sentences in plain texts and paragraphs in HTML content.
For indexing sentences the index_sp option needs to be enabled, while paragraphs also require html_strip
=1. Let’s take the following example:
mysql> select * from testrt where match('"the brown fox" jumps')G
*************************** 1. row ***************************
id: 15
gid: 2
title: The brown fox takes a step back. Then it jumps over the lazydog
content:
1 row in set (0.00 sec)
The document includes 2 sentences, while the phrase is found in the first one ‘jumps’ is only in the second sentence.
With the SENTENCE operator we can restrict the search to match only if the operands are in the same sentence:
mysql> select * from testrt where match('"the brown fox" SENTENCE jumps')G
Empty set (0.00 sec)
We can see that the document is not a match any more. If we correct the search query so all the words are from the same sentence we’ll see a match:
mysql> select * from testrt where match('"the brown fox" SENTENCE back')G<br></br>*************************** 1. row ***************************<br></br>id: 15<br></br>gid: 2<br></br>title: The brown fox takes a step back. Then it jumps over the lazydog<br></br>content:<br></br>1 row in set (0.00 sec)
To demonstrate the PARAGRAPH let’s use the following search:
mysql> select * from testrt where match('Samsung Galaxy');
+------+------+-------------------------------------------------------------------------------------+---------+
| id | gid | title | content |
+------+------+-------------------------------------------------------------------------------------+---------+
| 9 | 2 | <h1>Samsung Galaxy S10</h1>Is a smartphone introduced by Samsung in 2019 | |
| 10 | 2 | <h1>Samsung</h1>Galaxy,Note,A,J | |
+------+------+-------------------------------------------------------------------------------------+---------+
2 rows in set (0.00 sec)
These 2 documents have different HTML tags
If we add the PARAGRAPH only the document with the search terms found in the single tag will remain.
The more general operators are ZONE and it’s variant ZONESPAN. “zone” is text inside an HTML or XML tag.
The tags to be considered for the zones need to be declared in the index_zones setting, like index_zones = h*, th, title.
For example:
mysql> select * from testrt where match('hello world');
+------+------+-------------------------------+---------+
| id | gid | title | content |
+------+------+-------------------------------+---------+
| 12 | 2 | Hello world | |
| 14 | 2 | <h1>Hello world</h1> | |
| 13 | 2 | <h1>Hello</h1> <h1>world</h1> | |
+------+------+-------------------------------+---------+
3 rows in set (0.00 sec)
We have 3 documents, where ‘hello’ and ‘world’ are found in plain text, in different zones of the same type or in a single zone.
mysql> select * from testrt where match('ZONE:h1 hello world');
+------+------+-------------------------------+---------+
| id | gid | title | content |
+------+------+-------------------------------+---------+
| 14 | 2 | <h1>Hello world</h1> | |
| 13 | 2 | <h1>Hello</h1> <h1>world</h1> | |
+------+------+-------------------------------+---------+
2 rows in set (0.00 sec)
In this case, the words are present in H1 zones, but they are not required to be in the same zone. If we want to limit the match to a single zone, we can use ZONESPAN:
mysql> select * from testrt where match('ZONESPAN:h1 hello world');
+------+------+----------------------+---------+
| id | gid | title | content |
+------+------+----------------------+---------+
| 14 | 2 | <h1>नमस्ते दुनिया</h1> | |
+------+------+----------------------+---------+
1 row in set (0.00 sec)
आशा है कि, इस लेख से आपने Manticore में पूर्ण-पाठ खोज ऑपरेटर कैसे काम करता है, यह सीखा होगा। यदि आप इसे और बेहतर तरीके से जानने के लिए व्यावहारिक अनुभव की तलाश में हैं, तो आप अभी अपने ब्राउज़र में हमारे इंटरैक्टिव कोर्स की कोशिश कर सकते हैं।
इंटरैक्टिव कोर्स
<img src="Manticore-Full-text-operators-Interactive-course-optimized.webp" alt="img">
आप पूर्ण-पाठ मिलान के बारे में और अधिक जान सकते हैं यदि आप हमारे “पूर्ण-पाठ ऑपरेटर में परिचय” इंटरैक्टिव कोर्स की कोशिश करते हैं, जिसमें आसान सीखने के लिए एक कमांड लाइन शामिल है।