blog-post

Manticore Search में पेजिनेशन की समझ

पेजिनेशन किसी भी सर्च इंजन के लिए एक महत्वपूर्ण विशेषता है, जिससे उपयोगकर्ता बड़े परिणाम सेट में कुशलतापूर्वक नेविगेट कर सकते हैं। Manticore Search कई शक्तिशाली पेजिनेशन विधियाँ प्रदान करता है, प्रत्येक के अपने फायदे और सीमाएँ होती हैं। यह लेख Manticore Search में उपलब्ध विभिन्न पेजिनेशन विकल्पों की जांच करता है, साथ ही व्यावहारिक SQL उदाहरण प्रदान करता है ताकि आप अपने उपयोग केस के लिए सर्वश्रेष्ठ समाधान लागू कर सकें।

सामग्री की तालिका

  1. पेजिनेशन का परिचय
  2. टेस्ट वातावरण सेट करना
  3. पारंपरिक ऑफसेट-आधारित पेजिनेशन
  4. परिणाम सेट विंडो और max_matches
  5. स्क्रॉल-आधारित पेजिनेशन
  6. HTTP JSON के माध्यम से पेजिनेशन
  7. पेजिनेशन के लिएSorting Best Practices
  8. सीमाएँ और प्रदर्शन विचार
  9. पेजिनेशन के साथ फैसेटेड सर्च
  10. व्यावहारिक उपयोग केस
  11. निष्कर्ष

पेजिनेशन का परिचय

जब बड़े डेटासेट के साथ काम कर रहे होते हैं, तब सभी मिलान करने वाले परिणाम एक साथ वापस करना अव्यवहारिक होता है। पेजिनेशन इस समस्या को परिणामों को प्रबंधनीय टुकड़ों या “पृष्ठों” में विभाजित करके हल करता है। Manticore Search विभिन्न उपयोग केस को समायोजित करने के लिए कई पेजिनेशन दृष्टिकोण प्रदान करता है, साधारण सूची नेविगेशन से लेकर अनंत स्क्रॉलिंग इंटरफेस तक।

इस लेख में, हम तीन मुख्य पेजिनेशन विधियों की जांच करेंगे:

  • पारंपरिक ऑफसेट-आधारित पेजिनेशन ( अनुभाग 3 )
  • max_matches के साथ गहरी पेजिनेशन ( अनुभाग 4 )
  • बड़े परिणाम सेट में कुशलतापूर्वक नेविगेशन के लिए स्क्रॉल-आधारित पेजिनेशन ( अनुभाग 5 )

हम SQL और HTTP JSON इंटरफेस के माध्यम से उनके कार्यान्वयन, प्रदर्शन विचार, और व्यावहारिक अनुप्रयोगों पर भी चर्चा करेंगे।

टेस्ट वातावरण सेट करना

पेजिनेशन उदाहरणों में गहराई से जाने से पहले, चलिए Manticore Load उपकरण का उपयोग करके नमूना डेटा के साथ एक टेस्ट वातावरण बनाते हैं। यह उपकरण बेंचमार्किंग और प्रयोग के लिए परीक्षण डेटा उत्पन्न और लोड करना आसान बनाता है:

# Create a products table and populate it with 10,000 records containing "smartphone" in the title
manticore-load --quiet \
  --batch-size=1000 \
  --threads=4 \
  --total=10000 \
  --drop \
  --init="CREATE TABLE products(title text, description text, price int, category string, rating float, stock int)" \
  --load="INSERT INTO products(id, title, description, price, category, rating, stock) VALUES(<increment>, '<text/3/5> smartphone', '<text/20/50>', <int/10/1000>, '<string/5/10>', <float/1/5>, <int/0/100>)"

Output:
manticore-load output

इस टेस्ट वातावरण के साथ, हम अब विभिन्न पेजिनेशन विधियों की जांच कर सकते हैं।

पारंपरिक ऑफसेट-आधारित पेजिनेशन

Manticore Search में सबसे सीधा पेजिनेशन विधि LIMIT क्लॉज का उपयोग करता है जिसमें ऑफसेट और गिनती पैरामीटर होते हैं। यह दृष्टिकोण SQL डेटाबेस के साथ काम कर चुके किसी भी व्यक्ति के लिए परिचित है।

बेसिक सिंटैक्स

SELECT ... FROM ... [LIMIT [offset,] row_count]
SELECT ... FROM ... [LIMIT row_count][ OFFSET offset]

उदाहरण

-- Return the first 5 results (page 1)
SELECT id, title, price, weight() FROM products 
WHERE MATCH('smartphone') 
ORDER BY weight() DESC, price ASC, id ASC
LIMIT 5;

Output:

+------+----------------------------------------------+-------+----------+
| id   | title                                        | price | weight() |
+------+----------------------------------------------+-------+----------+
| 1179 | Weak spoke? fall. smartphone                 |    10 |     1272 |
| 1388 | 3; her day of. smartphone                    |    10 |     1272 |
| 1636 | Positively bad winter clean. smartphone      |    10 |     1272 |
| 5628 | Foolish from went heard low. smartphone      |    10 |     1272 |
| 8561 | Left sent. Infrequently, try lay. smartphone |    10 |     1272 |
+------+----------------------------------------------+-------+----------+

-- Return results 6-10 (page 2)
SELECT id, title, price, weight() FROM products 
WHERE MATCH('smartphone') 
ORDER BY weight() DESC, price ASC, id ASC
LIMIT 5, 5;

Output:

+------+----------------------------------------------+-------+----------+
| id   | title                                        | price | weight() |
+------+----------------------------------------------+-------+----------+
|  246 | Soft technically took. smartphone            |    11 |     1272 |
| 1105 | Dirty up are! temporarily called. smartphone |    11 |     1272 |
| 3293 | Instantly thick ran that hurt. smartphone    |    11 |     1272 |
| 3736 | Work her wrong locally. smartphone           |    11 |     1272 |
| 6978 | Stale loud passively sweet clean. smartphone |    11 |     1272 |
+------+----------------------------------------------+-------+----------+

-- Alternative syntax with separate LIMIT and OFFSET
SELECT id, title, price, weight() FROM products 
WHERE MATCH('smartphone') 
ORDER BY weight() DESC, price ASC, id ASC
LIMIT 5 OFFSET 10;
-- Results 11-15 (page 3)

Output:

+------+----------------------------------------+-------+----------+
| id   | title                                  | price | weight() |
+------+----------------------------------------+-------+----------+
| 7318 | Her spent at. smartphone               |    11 |     1272 |
| 8436 | His? felt work. Angry fast. smartphone |    11 |     1272 |
| 9699 | Feel spend funny. smartphone           |    11 |     1272 |
| 2326 | Quietly wet drew found. smartphone     |    12 |     1272 |
| 4171 | Set perhaps new send soon. smartphone  |    12 |     1272 |
+------+----------------------------------------+-------+----------+

यह विधि लागू करने में सरल है और परिणामों के प्रारंभिक पृष्ठों के माध्यम से नेविगेट करने के लिए अच्छी तरह से काम करती है। हालाँकि, यह गहरी पेजिनेशन के लिए कम प्रभावी होती है क्योंकि Manticore आंतरिक रूप से प्रश्नों को कैसे संसाधित करता है। इन सीमाओं के बारे में विवरण के लिए, देखें अनुभाग 8: सीमाएँ और प्रदर्शन विचार 。

परिणाम सेट विंडो और max_matches

डिफ़ॉल्ट रूप से, Manticore Search अधिकतम 1000 मिलान परिणामों की संख्या की सीमा लगाता है। यदि आप इस सीमा से आगे पेजिनेट करने का प्रयास करते हैं, तो प्रश्न त्रुटि का परिणाम देगा। इस सीमा को max_matches विकल्प का उपयोग करके समायोजित किया जा सकता है।

max_matches को समझना

max_matches विकल्प यह नियंत्रित करता है कि Manticore खोजते समय RAM में कितने मिलान परिणाम रखेगा। इसका उद्देश्य प्रति प्रश्न मेमोरी उपयोग को सीमित करना है। डिफ़ॉल्ट मान 1000 है, जो अधिकांश सामान्य सर्च परिदृश्यों के लिए पर्याप्त है, लेकिन आप इसे बढ़ा सकते हैं जब आपको गहरे परिणाम पृष्ठों तक पहुँचने की आवश्यकता हो।

-- Increase max_matches to allow deeper pagination (results 1001-1005)
SELECT id, title, price FROM products 
WHERE MATCH('smartphone') 
ORDER BY weight() DESC, price ASC, id ASC
LIMIT 1000, 5 
OPTION max_matches=1500;

Output:

+------+-----------------------------------------+-------+
| id   | title                                   | price |
+------+-----------------------------------------+-------+
| 3550 | Open sold being late wide. smartphone   |   111 |
| 4896 | Grew. Wrote as hungry. smartphone       |   111 |
|  647 | Went seen had. smartphone               |   112 |
|  883 | Hold lose; have thought. smartphone     |   112 |
| 1774 | Get! began sick. Gone, wild. smartphone |   112 |
+------+-----------------------------------------+-------+

-- For very deep pagination (results 5000-5005)
SELECT id, title, price FROM products 
WHERE MATCH('smartphone') 
ORDER BY weight() DESC, price ASC, id ASC
LIMIT 5000, 5 
OPTION max_matches=5500;

Output:

+------+------------------------------------------------+-------+
| id   | title                                          | price |
+------+------------------------------------------------+-------+
| 4894 | Subtly? inside for spend evening. smartphone   |   507 |
| 5203 | Bad; artistically from yearly. smartphone      |   507 |
| 7446 | Empty probably clever! universally. smartphone |   507 |
| 8053 | In! rich daily irregularly. smartphone         |   507 |
| 8055 | Short cold fall; keep physically. smartphone   |   507 |
+------+------------------------------------------------+-------+

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

स्क्रॉल-आधारित पेजिनेशन

स्क्रॉल-आधारित पेजिनेशन बड़े परिणाम सेट में नेविगेट करने का एक कुशल तरीका प्रदान करती है। पारंपरिक ऑफसेट-आधारित पेजिनेशन के विपरीत, यह परिणाम सेट में वर्तमान स्थिति को ट्रैक करने के लिए एक टोकन का उपयोग करती है, जो परिणामों के अनुक्रमिक पृष्ठों के माध्यम से नेविगेट करने में सहायक होती है।

यह कैसे काम करता है

  1. क्रमबद्ध मानदंडों के साथ प्रारंभिक प्रश्न निष्पादित करें (ORDER BY में id शामिल होना चाहिए)
  2. वर्तमान स्थिति को संक्षिप्त करने वाला एक स्क्रॉल टोकन प्राप्त करें
  3. अगले बैच के परिणाम प्राप्त करने के लिए आगे के प्रश्नों में इस टोकन का उपयोग करें

उदाहरण

-- Initial query with sorting criteria (must include id in ORDER BY)
SELECT id, title, price, weight() FROM products 
WHERE MATCH('smartphone') 
ORDER BY weight() DESC, price ASC, id ASC 
LIMIT 5; SHOW SCROLL\G

Output:

+------+----------------------------------------------+-------+----------+
| id   | title                                        | price | weight() |
+------+----------------------------------------------+-------+----------+
| 1179 | Weak spoke? fall. smartphone                 |    10 |     1272 |
| 1388 | 3; her day of. smartphone                    |    10 |     1272 |
| 1636 | Positively bad winter clean. smartphone      |    10 |     1272 |
| 5628 | Foolish from went heard low. smartphone      |    10 |     1272 |
| 8561 | Left sent. Infrequently, try lay. smartphone |    10 |     1272 |
+------+----------------------------------------------+-------+----------+

*************************** 1. row ***************************
scroll_token: eyJvcmRlcl9ieV9zdHIiOiJ3ZWlnaHQoKSBERVNDLCBwcmljZSBBU0MsIGlkIEFTQyIsIm9yZGVyX2J5IjpbeyJhdHRyIjoid2VpZ2h0KCkiLCJkZXNjIjp0cnVlLCJ2YWx1ZSI6MTI3MiwidHlwZSI6ImludCJ9LHsiYXR0ciI6InByaWNlIiwiZGVzYyI6ZmFsc2UsInZhbHVlIjoxMCwidHlwZSI6ImludCJ9LHsiYXR0ciI6ImlkIiwiZGVzYyI6ZmFsc2UsInZhbHVlIjo4NTYxLCJ0eXBlIjoiaW50In1dfQ==

-- Subsequent paginated query using the scroll token
SELECT id, title, price, weight() FROM products 
WHERE MATCH('smartphone') 
ORDER BY weight() DESC, price ASC, id ASC 
LIMIT 5 
OPTION scroll='eyJvcmRlcl9ieV9zdHIiOiJ3ZWlnaHQoKSBERVNDLCBwcmljZSBBU0MsIGlkIEFTQyIsIm9yZGVyX2J5IjpbeyJhdHRyIjoid2VpZ2h0KCkiLCJkZXNjIjp0cnVlLCJ2YWx1ZSI6MTI3MywidHlwZSI6ImludCJ9LHsiYXR0ciI6InByaWNlIiwiZGVzYyI6ZmFsc2UsInZhbHVlIjo1MiwidHlwZSI6ImludCJ9LHsiYXR0ciI6ImlkIiwiZGVzYyI6ZmFsc2UsInZhbHVlIjo0NCwidHlwZSI6ImludCJ9XX0=';

Output:

+------+----------------------------------------------+-------+----------+
| id   | title                                        | price | weight() |
+------+----------------------------------------------+-------+----------+
| 1179 | Weak spoke? fall. smartphone                 |    10 |     1272 |
| 1388 | 3; her day of. smartphone                    |    10 |     1272 |
| 1636 | Positively bad winter clean. smartphone      |    10 |     1272 |
| 5628 | Foolish from went heard low. smartphone      |    10 |     1272 |
| 8561 | Left sent. Infrequently, try lay. smartphone |    10 |     1272 |
+------+----------------------------------------------+-------+----------+

स्क्रॉल-आधारित पेजिनेशन विशेष रूप से वेब अनुप्रयोगों में “और लोड करें” या अनंत स्क्रॉल क्षमता लागू करने के लिए उपयुक्त है। पूर्ण कार्यान्वयन उदाहरण के लिए देखें व्यावहारिक उपयोग केस ।

HTTP JSON के माध्यम से पेजिनेशन

SQL के अलावा, Manticore Search HTTP JSON के माध्यम से पेजिनेशन प्रदान करता है। यह विशेष रूप से वेब अनुप्रयोगों या माइक्रोसर्विस आर्किटेक्चर के लिए उपयोगी है। पारंपरिक ऑफसेट-आधारित पेजिनेशन और स्क्रॉल-आधारित पेजिनेशन दोनों को JSON API के माध्यम से समर्थित किया गया है।

HTTP JSON के माध्यम से पारंपरिक ऑफसेट-आधारित पेजिनेशन

HTTP JSON API पेजिनेशन को नियंत्रित करने के लिए offset और limit पैरामीटर का उपयोग करता है। यह SQL LIMIT offset, count सिंटैक्स के बराबर है।

बेसिक सिंटैक्स

{
  "table": "table_name",
  "query": { "match": { ... } },
  "limit": number_of_results,
  "offset": starting_position
}

उदाहरण

# First page (results 1-5)
curl -s 0:9308/search -d '{
  "table": "products",
  "query": { "match": { "*": "smartphone" } },
  "limit": 5,
  "offset": 0,
  "sort": [
    { "_score": "desc" },
    { "price": "asc" },
    { "id": "asc" }
  ]
}'|jq .

Output:

{
  "took": 0,
  "timed_out": false,
  "hits": {
    "total": 10000,
    "total_relation": "eq",
    "hits": [
      {
        "_id": 1179,
        "_score": 1272,
        "_source": {
          "title": "Weak spoke? fall. smartphone",
          "description": "Made down never long 3 angry are went asked closed! cold historically got take can to commonly emotionally; socially asked get tame frequently think nowhere? carefully? scientifically small.",
          "price": 10,
          "category": "hkadwpwwk",
          "rating": 2.300000,
          "stock": 63
        }
      },
      // ... more results ...
    ]
  }
}

# Second page (results 6-10)
curl -s 0:9308/search -d '{
  "table": "products",
  "query": { "match": { "*": "smartphone" } },
  "limit": 5,
  "offset": 5,
  "sort": [
    { "_score": "desc" },
    { "price": "asc" },
    { "id": "asc" }
  ]
}' | jq .

Output:

{
  "took": 0,
  "timed_out": false,
  "hits": {
    "total": 10000,
    "total_relation": "eq",
    "hits": [
      {
        "_id": 246,
        "_score": 1272,
        "_source": {
          "title": "Soft technically took. smartphone",
          "description": "This sometimes empty short normally! been send. Locally kind! quickly might infrequently culturally softly became tried quietly good gradually; inside dead loud.",
          "price": 11,
          "category": "wuiymrjdp",
          "rating": 1.600000,
          "stock": 87
        }
      },
      // ... more results ...
    ]
  }
}

वैकल्पिक सिंटैक्स

Read also

मैंटीकोर सर्च इंस्टॉल करें

मैंटीकोर सर्च इंस्टॉल करें

© 2017-2025 Manticore Software Ltd. नियम एवं शर्तें गोपनीयता नीति