रेल में इलास्टिक्स खोज के साथ पूर्ण-पाठ खोज

इलास्टिक्स खोज सबसे लोकप्रिय खोज इंजनों में से एक है। कई बड़ी कंपनियों में से जो इसे पसंद करती हैं और अपने उत्पादन में सक्रिय रूप से इसका इस्तेमाल करती हैं, नेटफ्लिक्स, मीडियम, गिटहब जैसे दिग्गज हैं।

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

दुर्भाग्य से, Elasticsearch पर रेल समुदाय का अधिक ध्यान नहीं जाता है, इसलिए यह लेख दो लक्ष्यों को ध्यान में रखते हुए इसे बदलने का प्रयास करता है:पाठक को Elasticsearch अवधारणाओं से परिचित कराएं और यह दिखाएं कि रूबी ऑन रेल्स के साथ इसका उपयोग कैसे करें।

आप एक उदाहरण प्रोजेक्ट का स्रोत कोड पा सकते हैं जिसे हम यहां बनाने जा रहे हैं। प्रतिबद्ध इतिहास कमोबेश इस लेख के अनुभागों के क्रम से मेल खाता है।

परिचय

व्यापक दृष्टिकोण से, Elasticsearch एक ऐसा खोज इंजन है जो

• अपाचे ल्यूसीन के शीर्ष पर बनाया गया है;
• JSON दस्तावेज़ों को संग्रहीत और प्रभावी ढंग से अनुक्रमित करता है;
• खुला स्रोत है;
• इसके साथ इंटरैक्ट करने के लिए REST API का एक सेट प्रदान करता है;
• डिफ़ॉल्ट रूप से कोई सुरक्षा नहीं है (कोई भी इसे सार्वजनिक समापन बिंदुओं के माध्यम से पूछ सकता है);
• क्षैतिज रूप से बहुत अच्छी तरह से मापता है।

आइए कुछ बुनियादी अवधारणाओं पर एक नज़र डालते हैं।

Elasticsearch के साथ, हम दस्तावेज़ों को इंडेक्स में डालते हैं, जो तब डेटा के लिए पूछे जाते हैं।

एक अनुक्रमणिका एक संबंधपरक डेटाबेस में एक तालिका के समान है; यह एक स्टोर है जहां हम दस्तावेज़ डालते हैं (पंक्तियाँ) जिन्हें बाद में पूछताछ की जा सकती है।

एक दस्तावेज़ फ़ील्ड का एक संग्रह है (रिलेशनल डेटाबेस में एक पंक्ति के समान)।

एक मानचित्रण एक संबंधपरक डेटाबेस में स्कीमा परिभाषा की तरह है। मैपिंग को स्पष्ट रूप से परिभाषित किया जा सकता है या सम्मिलित समय पर Elasticsearch द्वारा अनुमान लगाया जा सकता है; इंडेक्स मैपिंग को पहले से परिभाषित करना हमेशा बेहतर होता है।

उस कवर के साथ, आइए अब अपना परिवेश सेट करें।

इलास्टिक्स खोज स्थापित करना

macOS पर Elasticsearch को स्थापित करने का सबसे आसान तरीका काढ़ा का उपयोग करना है:

brew tap elastic/tap
brew install elastic/tap/elasticsearch-full

एक विकल्प के रूप में, हम इसे docker के माध्यम से चला सकते हैं:

docker run \
  -p 127.0.0.1:9200:9200 \
  -p 127.0.0.1:9300:9300 \
  -e "discovery.type=single-node" \
  docker.elastic.co/elasticsearch/elasticsearch:7.16.2

अन्य विकल्पों के लिए, कृपया आधिकारिक संदर्भ देखें।

Elasticsearch पोर्ट 9200 पर डिफ़ॉल्ट रूप से अनुरोध स्वीकार करता है। आप जांच सकते हैं कि यह एक साधारण कर्ल अनुरोध के साथ चल रहा है (या इसे ब्राउज़र में खोलें):

curl https://localhost:9200

API

Elasticsearch हर संभव प्रकार के कार्य के लिए बातचीत करने के लिए REST API का एक सेट प्रदान करता है। उदाहरण के लिए, मान लें कि हम एक दस्तावेज़ बनाने के लिए JSON सामग्री प्रकार के साथ एक POST अनुरोध चलाते हैं:

curl -X POST https://localhost:9200/my-index/_doc \
  -H 'Content-Type: application/json' \
  -d '{"title": "Banana Cake"}'

इस मामले में, my-index एक इंडेक्स का नाम है (अगर यह मौजूद नहीं है, तो यह अपने आप बन जाता है)।

_डॉक एक सिस्टम रूट है (सभी सिस्टम रूट अंडरस्कोर से शुरू होते हैं)।

ऐसे कई तरीके हैं जिनसे हम एपीआई के साथ इंटरैक्ट कर सकते हैं।

1. कर्ल का उपयोग करना कमांड-लाइन से (आपको jq आसान लग सकता है)।
2. JSON को सुंदर प्रिंट करने के लिए कुछ एक्सटेंशन का उपयोग करके ब्राउज़र से GET क्वेरीज़ चलाना।
3. किबाना स्थापित करना और देव टूल्स कंसोल का उपयोग करना, जो मेरा पसंदीदा तरीका है।
4. आखिरकार कुछ बेहतरीन क्रोम एक्सटेंशन भी हैं।

इस लेख के लिए, इससे कोई फर्क नहीं पड़ता कि आप किसे चुनते हैं—हम वैसे भी सीधे एपीआई के साथ इंटरैक्ट नहीं करने जा रहे हैं। इसके बजाय, हम एक रत्न का उपयोग करेंगे, जो हुड के तहत REST API से बात करता है।

नया ऐप शुरू करना

विचार 26K+ गानों के सार्वजनिक डेटासेट का उपयोग करके एक गीत गीत एप्लिकेशन बनाना है। प्रत्येक गीत में एक शीर्षक, कलाकार, शैली और पाठ गीत क्षेत्र होते हैं। हम पूर्ण-पाठ खोज के लिए इलास्टिक्स खोज का उपयोग करेंगे।

आइए एक साधारण रेल एप्लिकेशन बनाकर शुरू करें:

rails new songs_api --api -d postgresql

चूंकि हम इसे केवल एपीआई के रूप में उपयोग करेंगे, हम --api . प्रदान करते हैं इस्तेमाल किए गए मिडलवेयर के सेट को सीमित करने के लिए ध्वज।

आइए हमारे ऐप को स्कैफोल्ड करें:

bin/rails generate scaffold Song title:string artist:string genre:string lyrics:text

अब, माइग्रेशन चलाते हैं और सर्वर शुरू करते हैं:

bin/rails db:create db:migrate
bin/rails server

उसके बाद, हम सत्यापित करते हैं कि GET समापन बिंदु काम करता है:

curl https://localhost:3000/songs

यह एक खाली सरणी देता है, जो कोई आश्चर्य की बात नहीं है क्योंकि अभी तक कोई डेटा नहीं है।

इलास्टिक्स खोज का परिचय

आइए मिश्रण में इलास्टिक्स खोज जोड़ें। ऐसा करने के लिए, हमें इलास्टिक्सर्च-मॉडल रत्न की आवश्यकता होगी। यह एक आधिकारिक इलास्टिक्स खोज रत्न है जो रेल मॉडल के साथ अच्छी तरह से एकीकृत होता है।

निम्नलिखित को अपने Gemfile में जोड़ें :

gem 'elasticsearch-model'

डिफ़ॉल्ट रूप से, यह लोकलहोस्ट पर पोर्ट 9200 से कनेक्ट होगा, जो हमें पूरी तरह से सूट करता है, लेकिन अगर आप इसे बदलना चाहते हैं, तो आप क्लाइंट को इनिशियलाइज़ कर सकते हैं

Song.__elasticsearch__.client = Elasticsearch::Client.new host: 'myserver.com', port: 9876

इसके बाद, हमारे मॉडल को Elasticsearch द्वारा अनुक्रमित करने योग्य बनाने के लिए, हमें दो काम करने होंगे। सबसे पहले, हमें एक मैपिंग तैयार करने की आवश्यकता है (जो अनिवार्य रूप से हमारी डेटा संरचना के बारे में इलास्टिक्स खोज को बता रही है), और दूसरा, हमें एक खोज अनुरोध का निर्माण करना चाहिए। हमारा रत्न दोनों काम कर सकता है, तो आइए देखें कि इसका उपयोग कैसे करना है।

इलास्टिसर्च-संबंधित कोड को एक अलग मॉड्यूल में रखना हमेशा एक अच्छा विचार है, तो चलिए app/models/consterns/searchable.rb पर एक चिंता पैदा करते हैं। और जोड़ें

# app/models/concerns/searchable.rb

module Searchable
  extend ActiveSupport::Concern

  included do
    include Elasticsearch::Model
    include Elasticsearch::Model::Callbacks

    mapping do
      # mapping definition goes here
    end

    def self.search(query)
      # build and run search
    end
  end
end

भले ही यह सिर्फ एक कंकाल है, यहां अनपैक करने के लिए कुछ है।

पहली और सबसे महत्वपूर्ण बात है Elasticsearch::Model , जो ES के साथ बातचीत करने के लिए कुछ कार्यक्षमता जोड़ता है। इलास्टिक्स खोज::मॉडल::कॉलबैक मॉड्यूल सुनिश्चित करता है कि जब हम किसी रिकॉर्ड को अपडेट करते हैं, तो यह स्वचालित रूप से इलास्टिक्स खोज में डेटा को अपडेट करता है। मानचित्रण ब्लॉक वह जगह है जहां हम इलास्टिक्स खोज इंडेक्स मैपिंग डालते हैं, जो परिभाषित करता है कि इलास्टिक्स खोज में कौन से फ़ील्ड संग्रहीत किए जाने वाले हैं और उन्हें किस प्रकार का होना चाहिए। अंत में, एक खोज है विधि है कि हम वास्तव में गीत के बोल के लिए Elasticsearch खोजने के लिए उपयोग करेंगे। हम जिस रत्न का उपयोग कर रहे हैं वह खोज . प्रदान करता है एक सरल क्वेरी जैसे Song.search("जेनेसिस") . के साथ उपयोग की जा सकने वाली विधि , लेकिन हम क्वेरी डीएसएल (उस पर बाद में और अधिक) का उपयोग करके निर्मित एक अधिक जटिल खोज क्वेरी के साथ इसका उपयोग करेंगे।

आइए चिंता को अपने मॉडल वर्ग में शामिल करना न भूलें:

# /app/models/song.rb

class Song < ApplicationRecord
  include Searchable
end

मैपिंग

Elasticsearch में, मैपिंग एक रिलेशनल डेटाबेस में एक स्कीमा परिभाषा की तरह है। हम उन दस्तावेज़ों की संरचना का वर्णन करते हैं जिन्हें हम संग्रहीत करना चाहते हैं। एक विशिष्ट संबंधपरक डेटाबेस के विपरीत, हमें अपने मानचित्रण को पहले से परिभाषित करने की आवश्यकता नहीं है:Elasticsearch हमारे लिए प्रकार का अनुमान लगाने की पूरी कोशिश करेगा। फिर भी, जैसा कि हम कोई आश्चर्य नहीं चाहते हैं, हम स्पष्ट रूप से अपने मानचित्रण को पहले ही परिभाषित कर देंगे।

मैपिंग को REST एंडपॉइंट के माध्यम से PUT /my-index/_mapping का उपयोग करके अपडेट किया जा सकता है और GET /my-index/_mapping . के माध्यम से पढ़ें , लेकिन लोचदार खोज मणि सार तत्व जो हमारे लिए हैं, इसलिए हमें केवल मानचित्रण . प्रदान करना है ब्लॉक करें:

# app/models/concerns/searchable.rb

mapping do
  indexes :artist, type: :text
  indexes :title, type: :text
  indexes :lyrics, type: :text
  indexes :genre, type: :keyword
end

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

अब रेल कंसोल को बिन/रेल कंसोल के साथ चलाएं और फिर दौड़ें

Song.__elasticsearch__.create_index!

यह इलास्टिक्स खोज में हमारी अनुक्रमणिका बनाएगा। __elasticsearch__ ऑब्जेक्ट इलास्टिक्स खोज की दुनिया का हमारा द्वार है, जो इलास्टिक्स खोज के साथ बातचीत करने के लिए बहुत सारे उपयोगी तरीकों से भरा है।

डेटा आयात करना

हर बार जब हम एक रिकॉर्ड बनाते हैं, तो यह स्वचालित रूप से डेटा को इलास्टिक्स खोज को भेज देगा। इसलिए, हम गीत के बोल के साथ एक डेटासेट डाउनलोड करने जा रहे हैं और इसे अपने ऐप में आयात कर रहे हैं। सबसे पहले, इसे इस लिंक से डाउनलोड करें (क्रिएटिव कॉमन्स एट्रिब्यूशन 4.0 इंटरनेशनल लाइसेंस . के तहत एक डेटासेट) ) इस CSV फ़ाइल में 26,000 से अधिक रिकॉर्ड हैं, जिन्हें हम नीचे दिए गए कोड के साथ अपने डेटाबेस और Elasticsearch में आयात करेंगे:

require 'csv'

class Song < ApplicationRecord
  include Searchable

  def self.import_csv!
    filepath = "/path/to/your/file/tcc_ceds_music.csv"
    res = CSV.parse(File.read(filepath), headers: true)
    res.each_with_index do |s, ind|
      Song.create!(
        artist: s["artist_name"],
        title: s["track_name"],
        genre: s["genre"],
        lyrics: s["lyrics"]
      )
    end
  end
end

रेल कंसोल खोलें और Song.import_csv! चलाएं (इसमे कुछ समय लगेगा)। वैकल्पिक रूप से, हम अपने डेटा को थोक में आयात कर सकते हैं, जो बहुत तेज़ है, लेकिन इस मामले में, हम यह सुनिश्चित करना चाहते हैं कि हम अपने PostgreSQL डेटाबेस और Elasticsearch में रिकॉर्ड बना लें।

जब आयात समाप्त हो जाता है, तो अब हमारे पास बहुत सारे गीत हैं जिन्हें हम खोज सकते हैं।

डेटा खोजना

लोचदार खोज-मॉडल मणि एक खोज जोड़ता है विधि जो हमें सभी अनुक्रमित क्षेत्रों के बीच खोज करने की अनुमति देती है। आइए इसे अपनी खोज योग्य चिंता में उपयोग करें:

# app/models/concerns/searchable.rb

# ...
def self.search(query)
  self.__elasticsearch__.search(query)
end
# ...

रेल कंसोल खोलें और res =Song.search('genesis') run चलाएं . प्रतिक्रिया ऑब्जेक्ट में बहुत सारी मेटा जानकारी होती है:अनुरोध में कितना समय लगा, किन नोड्स का उपयोग किया गया, आदि। हम हिट में रुचि रखते हैं, res.response["hits"]["hits"] ।

आइए हमारे नियंत्रक के index को बदलें इसके बजाय ES को क्वेरी करने की विधि।

# app/controllers/songs_controller.rb

def index
  query = params["query"] || ""
  res = Song.search(query)
  render json: res.response["hits"]["hits"]
end

अब हम इसे ब्राउज़र में लोड करने या कर्ल https://localhost:3000/songs?query=genesis का उपयोग करने का प्रयास कर सकते हैं। . प्रतिक्रिया इस तरह दिखेगी:

[
  {
  "_index": "songs",
  "_type": "_doc",
  "_id": "22676",
  "_score": 12.540506,
  "_source": {
    "id": 22676,
    "title": "genesis",
    "artist": "grimes",
    "genre": "pop",
    "lyrics": "heart know heart ...",
    "created_at": "...",
    "updated_at": "..."
    }
  },
...
]

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

क्वेरी डीएसएल

Elasticsearch क्वेरी DSL जटिल प्रश्नों के निर्माण का एक तरीका प्रदान करती है, और हम इसका उपयोग रूबी कोड से भी कर सकते हैं। उदाहरण के लिए, आइए केवल कलाकार फ़ील्ड खोजने के लिए खोज पद्धति को संशोधित करें:

# app/models/concerns/searchable.rb

module Searchable
  extend ActiveSupport::Concern

  included do
    # ...

    def self.search(query)
      params = {
        query: {
          match: {
            artist: query,
          },
        },
      }

      self.__elasticsearch__.search(params)
    end
  end
end

क्वेरी-मिलान निर्माण हमें केवल एक विशेष फ़ील्ड (इस मामले में, कलाकार) को खोजने की अनुमति देता है। अब, अगर हम गाने को फिर से "जेनेसिस" के साथ क्वेरी करते हैं (इसे https://localhost:3000/songs?query=genesis लोड करके देखें। ), हमें केवल "उत्पत्ति" बैंड के गीत मिलेंगे, न कि वे गीत जिनके शीर्षक में "उत्पत्ति" है। यदि हम कई क्षेत्रों को क्वेरी करना चाहते हैं, जो अक्सर होता है, तो हम एक बहु-मिलान क्वेरी का उपयोग कर सकते हैं:

# app/models/concerns/searchable.rb

def self.search(query)
  params = {
    query: {
      multi_match: {
        query: query, 
        fields: [ :title, :artist, :lyrics ] 
      },
    },
  }

  self.__elasticsearch__.search(params)
end

फ़िल्टर करना

क्या होगा अगर हम केवल रॉक गानों के बीच खोजना चाहते हैं? फिर, हमें शैली के अनुसार फ़िल्टर करने की आवश्यकता है! यह हमारी खोज को थोड़ा और जटिल बनाने वाला है, लेकिन चिंता न करें—हम सब कुछ चरण दर चरण समझाएंगे!

  def self.search(query, genre = nil)
    params = {
      query: {
        bool: {
          must: [
            {
              multi_match: {
                query: query, 
                fields: [ :title, :artist, :lyrics ] 
              }
            },
          ],
          filter: [
            {
              term: { genre: genre }
            }
          ]
        }
      }
    }

    self.__elasticsearch__.search(params)
  end

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

यह नोट करना महत्वपूर्ण है कि फ़िल्टर-अवधि संयोजन का पूर्ण-पाठ खोज से कोई लेना-देना नहीं है। यह सटीक मान के अनुसार एक नियमित फ़िल्टर है, ठीक उसी तरह जैसे WHERE खंड SQL में काम करता है (WHERE शैली ='रॉक' ) यह जानना अच्छा है कि शब्द का उपयोग कैसे किया जाता है फ़िल्टर कर रहे हैं, लेकिन हमें यहां इसकी आवश्यकता नहीं होगी।

स्कोरिंग

खोज परिणामों को _score . द्वारा क्रमित किया जाता है यह दर्शाता है कि कोई आइटम किसी विशेष खोज के लिए कैसे प्रासंगिक है। स्कोर जितना अधिक होगा, दस्तावेज़ उतना ही प्रासंगिक होगा। आपने शायद गौर किया होगा कि जब हमने उत्पत्ति . शब्द की खोज की थी , पहला परिणाम जो पॉप अप हुआ वह ग्रिम्स का गीत था, जबकि मुझे वास्तव में जेनेसिस बैंड में अधिक दिलचस्पी थी। तो, क्या हम कलाकार क्षेत्र पर अधिक ध्यान देने के लिए स्कोरिंग तंत्र को बदल सकते हैं? हाँ, हम कर सकते हैं, लेकिन ऐसा करने के लिए, हमें पहले अपनी क्वेरी में बदलाव करना होगा:

  def self.search(query)
    params = {
      query: {
        bool: {
          should: [
            { match: { title: query }},
            { match: { artist: query }},
            { match: { lyrics: query }},
          ],
        }
      },
    }

    self.__elasticsearch__.search(params)
  end

यह क्वेरी अनिवार्य रूप से पहले वाले के बराबर है, सिवाय इसके कि यह बूल कीवर्ड का उपयोग कर रहा है, जो कि कई प्रश्नों को एक में संयोजित करने का एक तरीका है। हम उपयोग करते हैं चाहिए , जिसमें तीन प्रश्न अलग-अलग होते हैं (एक प्रति फ़ील्ड):वे अनिवार्य रूप से तार्किक OR का उपयोग करके संयुक्त होते हैं। अगर हम उपयोग करते हैं जरूरी इसके बजाय, उन्हें तार्किक AND का उपयोग करके संयोजित किया जाएगा। हमें प्रत्येक क्षेत्र के लिए एक अलग मैच की आवश्यकता क्यों है? ऐसा इसलिए है क्योंकि अब हम बूस्ट प्रॉपर्टी निर्दिष्ट कर सकते हैं, जो एक गुणांक है जो विशेष क्वेरी से स्कोर को गुणा करता है:

  def self.search(query)
    params = {
      query: {
        bool: {
          should: [
            { match: { title: query }},
            { match: { artist: { query: query, boost: 5 } }},
            { match: { lyrics: query }},
          ],
        }
      },
    }

    self.__elasticsearch__.search(params)
  end

अन्य चीजें समान हैं, हमारा स्कोर पांच गुना अधिक होगा बशर्ते प्रश्न कलाकार से मेल खाता हो। उत्पत्तिको आजमाएं https://localhost:3000/songs?query=genesis . के साथ फिर से क्वेरी करें , और आप जेनेसिस बैंड के गाने सबसे पहले आते हुए देखेंगे। मीठा!

हाइलाइट करना

Elasticsearch की एक अन्य उपयोगी विशेषता दस्तावेज़ के भीतर मिलान को हाइलाइट करने में सक्षम है, जो उपयोगकर्ता को बेहतर ढंग से समझने की अनुमति देता है कि खोज में कोई विशेष परिणाम क्यों दिखाई दिया।

HTML में, उसके लिए एक विशेष HTML टैग है, और Elasticsearch उसे स्वचालित रूप से जोड़ सकता है।

आइए खोलें searchable.rb फिर से चिंता करें और एक नया कीवर्ड जोड़ें:

def self.search(query)
  params = {
    query: {
      bool: {
        should: [
          { match: { title: query }},
          { match: { artist: { query: query, boost: 5 } }},
          { match: { lyrics: query }},
        ],
      }
    },
    highlight: { fields: { title: {}, artist: {}, lyrics: {} } }
  }

  self.__elasticsearch__.search(params)
end

नया हाइलाइट फ़ील्ड निर्दिष्ट करता है कि किन क्षेत्रों को हाइलाइट किया जाना चाहिए। हम उन सभी का चयन करते हैं। अब, अगर हम लोड करते हैं https://localhost:3000/query=genesis , हमें "हाइलाइट" नामक एक नया फ़ील्ड देखना चाहिए जिसमें em में लिपटे मिलान वाले वाक्यांशों के साथ दस्तावेज़ फ़ील्ड शामिल हैं टैग।

हाइलाइट करने के बारे में अधिक जानकारी के लिए, कृपया आधिकारिक मार्गदर्शिका देखें।

फ़ज़ीनेस

ठीक है, क्या हुआ अगर हम गलती से बेनिसिस wrote लिख गए उत्पत्ति . के बजाय ? यह किसी भी परिणाम को वापस नहीं करने वाला है, लेकिन हम इलास्टिक्स खोज को कम पसंद करने वाले और अस्पष्ट खोज की अनुमति देने के लिए कह सकते हैं, इसलिए यह उत्पत्ति प्रदर्शित करेगा। परिणाम भी।

यहां बताया गया है कि यह कैसे किया जाता है। बस कलाकार की क्वेरी को {मिलान:{कलाकार:{ क्वेरी:क्वेरी, बूस्ट:5 } }} से बदलें से {मिलान:{कलाकार:{ क्वेरी:क्वेरी, बूस्ट:5, अस्पष्टता:"ऑटो"} }}} . सटीक फ़िज़नेस यांत्रिकी को कॉन्फ़िगर किया जा सकता है। अधिक जानकारी के लिए कृपया आधिकारिक दस्तावेज़ देखें।

आगे कहां जाएं?

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

संसाधन

• आधिकारिक इलास्टिक्स खोज संदर्भ
• रूबी रत्न
• रेल रत्न
• व्यावहारिक ज्ञान से भरी एक बहुत अच्छी किताब
• बिल्डिंग स्वतः पूर्ण

वैकल्पिक रत्न

• सर्चकिक
• चबाना