Elasticsearch
संबंधपरक डेटाबेस और इलास्टिक्स खोज के बीच अंतर

परिचय

शब्दावली अंतर

तालिका के ऊपर मोटे तौर पर संबंधपरक डेटाबेस के बुनियादी तत्वों और इलास्टिक्स खोज के बीच एक समानता है।

सेट अप

एक संबंधपरक डेटाबेस में निम्नलिखित संरचना पर विचार:

create databse test;

use test;

create table product;

create table product (name varchar, id int PRIMARY KEY);

insert into product  (id,name) VALUES (1,'Shirt');

insert into product  (id,name) VALUES (2,'Red Shirt');

select * from product;

name      | id 
----------+----
Shirt     |  1
Red Shirt |  2

एलीटेसर्च समतुल्य:

POST test/product
{
    "id" : 1,
    "name" : "Shirt"
}

POST test/product
{
    "id" : 2,
    "name" : "Red Shirt"
}

GET test/product/_search


"hits": [
     {                                      ==============
        "_index": "test",                   ===> index    |
        "_type": "product",                 ===>type      |
        "_id": "AVzglFomaus3G2tXc6sB",                    |
        "_score": 1,                                      |
        "_source": {                                      |===> document
           "id": 2,                        ===>field      | 
           "name": "Red Shirt"             ===>field      |
        }                                                 |
     },                                     ==============
     {
        "_index": "test",
        "_type": "product",
        "_id": "AVzglD12aus3G2tXc6sA",
        "_score": 1,
        "_source": {
           "id": 1,                 
           "name": "Shirt"           
        }
     }
  ]

Usecases जहाँ रिलेशनल डेटाबेस उपयुक्त नहीं हैं

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

  सेट अप

  पिछले उदाहरण में इस्तेमाल के रूप में ही।

  समस्या का विवरण

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

  समाधान रिलेशनल डेटाबेस क्वेरी का उपयोग करना

  select * from product where name like '%Red%' or name like '%Shirt%' ;

  उत्पादन

  name       | id 
  -----------+----
  Shirt      |  1
  Red Shirt  |  2
  

  एलेस्टिक्स खोज समाधान

  POST test/product/_search
  {
       "query": {
            "match": {
              "name": "Red Shirt"
           }
       }
  }
  

  उत्पादन

  "hits": [
    {
       "_index": "test",
       "_type": "product",
       "_id": "AVzglFomaus3G2tXc6sB",
       "_score": 1.2422675,              ===> Notice this
       "_source": {
          "id": 2,
          "name": "Red Shirt"
       }
    },
    {
       "_index": "test",
       "_type": "product",
       "_id": "AVzglD12aus3G2tXc6sA",
       "_score": 0.25427115,             ===> Notice this
       "_source": {
          "id": 1,
          "name": "Shirt"
       }
    }
   ]
  

  निष्कर्ष

  जैसा कि हम ऊपर देख सकते हैं कि रिलेशनल डेटाबेस ने कुछ यादृच्छिक क्रम में परिणाम लौटाए हैं, जबकि _score ने _score घटते क्रम में परिणाम _score जो प्रासंगिकता के आधार पर गणना की जाती है।

• हम खोज स्ट्रिंग दर्ज करते समय गलतियाँ करते हैं। ऐसे मामले हैं जब उपयोगकर्ता एक गलत खोज पैरामीटर में प्रवेश करता है। रिलेशनल डेटाबेस इस तरह के मामलों को हैंडल नहीं करेंगे। बचाव के लिए एलेस्टिक्स खोज।

  सेट अप

  पिछले उदाहरण में इस्तेमाल के रूप में ही।

  समस्या का विवरण

  मान लें कि उपयोगकर्ता shirts खोजना चाहता है, लेकिन वह गलती से गलत शब्द shrt प्रवेश करता है। उपयोगकर्ता अभी भी शर्ट के परिणामों को देखने की उम्मीद करता है ।

  समाधान रिलेशनल डेटाबेस क्वेरी का उपयोग करना

  select * from product where name like '%shrt%' ;

  उत्पादन

  No results found
  

  एलेस्टिक्स खोज समाधान

  POST /test/product/_search
  
   {
      "query": {
        "match": {
          "name": {
            "query": "shrt",
            "fuzziness": 2,
            "prefix_length": 0
           }
        }
      }
   }  
  

  उत्पादन

   "hits": [
    {
       "_index": "test",
       "_type": "product",
       "_id": "AVzglD12aus3G2tXc6sA",
       "_score": 1,
       "_source": {
          "id": 1,
          "name": "Shirt"
       }
    },
    {
       "_index": "test",
       "_type": "product",
       "_id": "AVzglFomaus3G2tXc6sB",
       "_score": 0.8784157,
       "_source": {
          "id": 2,
          "name": "Red Shirt"
       }
    }
  ]
  

  निष्कर्ष

  जैसा कि हम ऊपर देख सकते हैं कि रिलेशनल डेटाबेस ने खोजे गए गलत शब्द के लिए कोई परिणाम नहीं दिया है, जबकि एलिस्टिक्स ने अपने विशेष fuzzy क्वेरी रिटर्न परिणामों का उपयोग किया है।