ലൂസീൻ ഉപയോഗിച്ച് ജാവയിൽ എഴുതിയ json rest api ഉള്ള ഒരു സെർച്ച് എഞ്ചിനാണ് ഇലാസ്റ്റിക് സെർച്ച്. ഈ എഞ്ചിന്റെ എല്ലാ ഗുണങ്ങളുടെയും വിവരണം ഇവിടെ ലഭ്യമാണ് ഔദ്യോഗിക വെബ്സൈറ്റ്. ഇനിപ്പറയുന്നതിൽ നമ്മൾ ഇലാസ്റ്റിക് സെർച്ചിനെ ES എന്ന് വിളിക്കും.

ഒരു ഡോക്യുമെന്റ് ഡാറ്റാബേസിൽ സങ്കീർണ്ണമായ തിരയലുകൾക്ക് സമാനമായ എഞ്ചിനുകൾ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ഭാഷയുടെ രൂപഘടന കണക്കിലെടുത്ത് തിരയുക അല്ലെങ്കിൽ ജിയോ കോർഡിനേറ്റുകൾ ഉപയോഗിച്ച് തിരയുക.

ഈ ലേഖനത്തിൽ ഞാൻ ബ്ലോഗ് പോസ്റ്റുകൾ സൂചികയിലാക്കുന്നതിന്റെ ഉദാഹരണം ഉപയോഗിച്ച് ES ന്റെ അടിസ്ഥാനകാര്യങ്ങളെക്കുറിച്ച് സംസാരിക്കും. പ്രമാണങ്ങൾ എങ്ങനെ ഫിൽട്ടർ ചെയ്യാമെന്നും അടുക്കാമെന്നും തിരയാമെന്നും ഞാൻ കാണിച്ചുതരാം.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തെ ആശ്രയിക്കാതിരിക്കാൻ, ഞാൻ CURL ഉപയോഗിച്ച് ES-ലേക്ക് എല്ലാ അഭ്യർത്ഥനകളും നടത്തും. ഗൂഗിൾ ക്രോമിനായി ഒരു പ്ലഗിനും ഉണ്ട് അർത്ഥം.

വാചകത്തിൽ ഡോക്യുമെന്റേഷനിലേക്കും മറ്റ് ഉറവിടങ്ങളിലേക്കുമുള്ള ലിങ്കുകൾ അടങ്ങിയിരിക്കുന്നു. അവസാനം ഡോക്യുമെന്റേഷനിലേക്കുള്ള ദ്രുത പ്രവേശനത്തിനുള്ള ലിങ്കുകൾ ഉണ്ട്. പരിചിതമല്ലാത്ത പദങ്ങളുടെ നിർവചനങ്ങൾ ഇതിൽ കാണാം ഗ്ലോസറികൾ.

ES ഇൻസ്റ്റാൾ ചെയ്യുന്നു

ഇത് ചെയ്യുന്നതിന്, നമുക്ക് ആദ്യം ജാവ ആവശ്യമാണ്. ഡെവലപ്പർമാർ ശുപാർശ ചെയ്യുന്നു ജാവ 8 അപ്ഡേറ്റ് 20 അല്ലെങ്കിൽ ജാവ 7 അപ്ഡേറ്റ് 55 നേക്കാൾ പുതിയ ജാവ പതിപ്പുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക.

ES വിതരണം ഇവിടെ ലഭ്യമാണ് ഡവലപ്പർ വെബ്സൈറ്റ്. ആർക്കൈവ് അൺപാക്ക് ചെയ്ത ശേഷം നിങ്ങൾ പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട് bin/elasticsearch. കൂടാതെ ലഭ്യമാണ് apt, yum എന്നിവയ്ക്കുള്ള പാക്കേജുകൾ. ഉണ്ട് ഡോക്കറിനായുള്ള ഔദ്യോഗിക ചിത്രം. ഇൻസ്റ്റാളേഷനെ കുറിച്ച് കൂടുതൽ.

ഇൻസ്റ്റാളേഷനും സമാരംഭത്തിനും ശേഷം, നമുക്ക് പ്രവർത്തനം പരിശോധിക്കാം:

# для удобства запомним адрес в переменную
#export ES_URL=$(docker-machine ip dev):9200
export ES_URL=localhost:9200

curl -X GET $ES_URL

ഞങ്ങൾക്ക് ഇതുപോലുള്ള ഒന്ന് ലഭിക്കും:

{
  "name" : "Heimdall",
  "cluster_name" : "elasticsearch",
  "version" : {
    "number" : "2.2.1",
    "build_hash" : "d045fc29d1932bce18b2e65ab8b297fbf6cd41a1",
    "build_timestamp" : "2016-03-09T09:38:54Z",
    "build_snapshot" : false,
    "lucene_version" : "5.4.1"
  },
  "tagline" : "You Know, for Search"
}

ഇൻഡെക്സിംഗ്

ES-ലേക്ക് ഒരു പോസ്റ്റ് ചേർക്കാം:

# Добавим документ c id 1 типа post в индекс blog.
# ?pretty указывает, что вывод должен быть человеко-читаемым.

curl -XPUT "$ES_URL/blog/post/1?pretty" -d'
{
  "title": "Веселые котята",
  "content": "<p>Смешная история про котят<p>",
  "tags": [
    "котята",
    "смешная история"
  ],
  "published_at": "2014-09-12T20:44:42+00:00"
}'

സെർവർ പ്രതികരണം:

{
  "_index" : "blog",
  "_type" : "post",
  "_id" : "1",
  "_version" : 1,
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "created" : false
}

ES സ്വയമേവ സൃഷ്ടിച്ചു സൂചിക ബ്ലോഗ് ഒപ്പം തരം പോസ്റ്റ്. നമുക്ക് ഒരു സോപാധിക സാമ്യം വരയ്ക്കാം: ഒരു സൂചിക ഒരു ഡാറ്റാബേസ് ആണ്, കൂടാതെ ഒരു തരം ഈ ഡാറ്റാബേസിൽ ഒരു പട്ടികയാണ്. ഓരോ തരത്തിനും അതിന്റേതായ സ്കീം ഉണ്ട് - മാപ്പിംഗ്, ഒരു റിലേഷണൽ ടേബിൾ പോലെ. പ്രമാണം സൂചികയിലാക്കുമ്പോൾ മാപ്പിംഗ് സ്വയമേവ ജനറേറ്റുചെയ്യുന്നു:

# Получим mapping всех типов индекса blog
curl -XGET "$ES_URL/blog/_mapping?pretty"

സെർവർ പ്രതികരണത്തിൽ, അഭിപ്രായങ്ങളിൽ സൂചികയിലാക്കിയ പ്രമാണത്തിന്റെ ഫീൽഡുകളുടെ മൂല്യങ്ങൾ ഞാൻ ചേർത്തു:

{
  "blog" : {
    "mappings" : {
      "post" : {
        "properties" : {
          /* "content": "<p>Смешная история про котят<p>", */ 
          "content" : {
            "type" : "string"
          },
          /* "published_at": "2014-09-12T20:44:42+00:00" */
          "published_at" : {
            "type" : "date",
            "format" : "strict_date_optional_time||epoch_millis"
          },
          /* "tags": ["котята", "смешная история"] */
          "tags" : {
            "type" : "string"
          },
          /*  "title": "Веселые котята" */
          "title" : {
            "type" : "string"
          }
        }
      }
    }
  }
}

ES ഒരൊറ്റ മൂല്യവും മൂല്യങ്ങളുടെ ഒരു നിരയും തമ്മിൽ വേർതിരിക്കുന്നില്ല എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ഉദാഹരണത്തിന്, ശീർഷക ഫീൽഡിൽ ഒരു ശീർഷകം അടങ്ങിയിരിക്കുന്നു, കൂടാതെ ടാഗ്സ് ഫീൽഡിൽ സ്ട്രിംഗുകളുടെ ഒരു നിര അടങ്ങിയിരിക്കുന്നു, എന്നിരുന്നാലും മാപ്പിംഗിൽ അവ അതേ രീതിയിൽ പ്രതിനിധീകരിക്കുന്നു.
മാപ്പിംഗിനെക്കുറിച്ച് ഞങ്ങൾ പിന്നീട് സംസാരിക്കും.

അഭ്യർത്ഥനകൾ

ഒരു ഡോക്യുമെന്റ് അതിന്റെ ഐഡി ഉപയോഗിച്ച് വീണ്ടെടുക്കുന്നു:

# извлечем документ с id 1 типа post из индекса blog
curl -XGET "$ES_URL/blog/post/1?pretty"

{
  "_index" : "blog",
  "_type" : "post",
  "_id" : "1",
  "_version" : 1,
  "found" : true,
  "_source" : {
    "title" : "Веселые котята",
    "content" : "<p>Смешная история про котят<p>",
    "tags" : [ "котята", "смешная история" ],
    "published_at" : "2014-09-12T20:44:42+00:00"
  }
}

പ്രതികരണത്തിൽ പുതിയ കീകൾ പ്രത്യക്ഷപ്പെട്ടു: _version и _source. പൊതുവേ, ആരംഭിക്കുന്ന എല്ലാ കീകളും _ ഔദ്യോഗികമായി തരംതിരിച്ചിരിക്കുന്നു.

കെ _version ഡോക്യുമെന്റ് പതിപ്പ് കാണിക്കുന്നു. ശുഭാപ്തിവിശ്വാസമുള്ള ലോക്കിംഗ് സംവിധാനം പ്രവർത്തിക്കുന്നതിന് ഇത് ആവശ്യമാണ്. ഉദാഹരണത്തിന്, പതിപ്പ് 1 ഉള്ള ഒരു പ്രമാണം മാറ്റാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. ഞങ്ങൾ മാറ്റിയ പ്രമാണം സമർപ്പിക്കുകയും ഇത് പതിപ്പ് 1 ഉള്ള ഒരു പ്രമാണത്തിന്റെ എഡിറ്റാണെന്ന് സൂചിപ്പിക്കുകയും ചെയ്യുന്നു. മറ്റാരെങ്കിലും പതിപ്പ് 1 ഉള്ള ഒരു പ്രമാണം എഡിറ്റ് ചെയ്യുകയും മാറ്റങ്ങൾ ഞങ്ങൾക്ക് മുമ്പാകെ സമർപ്പിക്കുകയും ചെയ്താൽ, തുടർന്ന് ES ഞങ്ങളുടെ മാറ്റങ്ങൾ അംഗീകരിക്കില്ല, കാരണം ഇത് പതിപ്പ് 2 ഉപയോഗിച്ച് പ്രമാണം സംഭരിക്കുന്നു.

കെ _source ഞങ്ങൾ സൂചികയിലാക്കിയ പ്രമാണം അടങ്ങിയിരിക്കുന്നു. തിരയൽ പ്രവർത്തനങ്ങൾക്കായി ES ഈ മൂല്യം ഉപയോഗിക്കുന്നില്ല കാരണം തിരയലിനായി സൂചികകൾ ഉപയോഗിക്കുന്നു. സ്ഥലം ലാഭിക്കാൻ, ES ഒരു കംപ്രസ് ചെയ്ത ഉറവിട പ്രമാണം സംഭരിക്കുന്നു. ഞങ്ങൾക്ക് ഐഡി മാത്രമേ ആവശ്യമുള്ളൂ, മുഴുവൻ ഉറവിട പ്രമാണവും ആവശ്യമില്ലെങ്കിൽ, നമുക്ക് ഉറവിട സംഭരണം പ്രവർത്തനരഹിതമാക്കാം.

ഞങ്ങൾക്ക് കൂടുതൽ വിവരങ്ങൾ ആവശ്യമില്ലെങ്കിൽ, _source-ന്റെ ഉള്ളടക്കം മാത്രമേ ഞങ്ങൾക്ക് ലഭിക്കൂ:

curl -XGET "$ES_URL/blog/post/1/_source?pretty"

{
  "title" : "Веселые котята",
  "content" : "<p>Смешная история про котят<p>",
  "tags" : [ "котята", "смешная история" ],
  "published_at" : "2014-09-12T20:44:42+00:00"
}

നിങ്ങൾക്ക് ചില ഫീൽഡുകൾ മാത്രം തിരഞ്ഞെടുക്കാനും കഴിയും:

# извлечем только поле title
curl -XGET "$ES_URL/blog/post/1?_source=title&pretty"

{
  "_index" : "blog",
  "_type" : "post",
  "_id" : "1",
  "_version" : 1,
  "found" : true,
  "_source" : {
    "title" : "Веселые котята"
  }
}

നമുക്ക് കുറച്ച് പോസ്റ്റുകൾ കൂടി സൂചികയിലാക്കി കൂടുതൽ സങ്കീർണ്ണമായ ചോദ്യങ്ങൾ പ്രവർത്തിപ്പിക്കാം.

curl -XPUT "$ES_URL/blog/post/2" -d'
{
  "title": "Веселые щенки",
  "content": "<p>Смешная история про щенков<p>",
  "tags": [
    "щенки",
    "смешная история"
  ],
  "published_at": "2014-08-12T20:44:42+00:00"
}'

curl -XPUT "$ES_URL/blog/post/3" -d'
{
  "title": "Как у меня появился котенок",
  "content": "<p>Душераздирающая история про бедного котенка с улицы<p>",
  "tags": [
    "котята"
  ],
  "published_at": "2014-07-21T20:44:42+00:00"
}'

അടുക്കുന്നു

# найдем последний пост по дате публикации и извлечем поля title и published_at
curl -XGET "$ES_URL/blog/post/_search?pretty" -d'
{
  "size": 1,
  "_source": ["title", "published_at"],
  "sort": [{"published_at": "desc"}]
}'

{
  "took" : 8,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 3,
    "max_score" : null,
    "hits" : [ {
      "_index" : "blog",
      "_type" : "post",
      "_id" : "1",
      "_score" : null,
      "_source" : {
        "title" : "Веселые котята",
        "published_at" : "2014-09-12T20:44:42+00:00"
      },
      "sort" : [ 1410554682000 ]
    } ]
  }
}

ഞങ്ങൾ അവസാനത്തെ പോസ്റ്റ് തിരഞ്ഞെടുത്തു. size നൽകേണ്ട രേഖകളുടെ എണ്ണം പരിമിതപ്പെടുത്തുന്നു. total അഭ്യർത്ഥനയുമായി പൊരുത്തപ്പെടുന്ന മൊത്തം രേഖകളുടെ എണ്ണം കാണിക്കുന്നു. sort ഔട്ട്പുട്ടിൽ സോർട്ടിംഗ് നടത്തുന്ന പൂർണ്ണസംഖ്യകളുടെ ഒരു നിര അടങ്ങിയിരിക്കുന്നു. ആ. തീയതി ഒരു പൂർണ്ണസംഖ്യയാക്കി മാറ്റി. അടുക്കുന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ ഇതിൽ കാണാം പ്രമാണീകരണം.

ഫിൽട്ടറുകളും അന്വേഷണങ്ങളും

പതിപ്പ് 2 മുതൽ ES, പകരം ഫിൽട്ടറുകളും അന്വേഷണങ്ങളും തമ്മിൽ വേർതിരിച്ചറിയുന്നില്ല സന്ദർഭങ്ങൾ എന്ന ആശയം അവതരിപ്പിക്കപ്പെടുന്നു.
ഒരു ഫിൽട്ടർ സന്ദർഭത്തിൽ നിന്ന് ഒരു അന്വേഷണ സന്ദർഭം വ്യത്യാസപ്പെട്ടിരിക്കുന്നു, കാരണം ചോദ്യം ഒരു _സ്കോർ സൃഷ്ടിക്കുകയും കാഷെ ചെയ്യപ്പെടാതിരിക്കുകയും ചെയ്യുന്നു. _സ്കോർ എന്താണെന്ന് ഞാൻ പിന്നീട് കാണിച്ചുതരാം.

തീയതി പ്രകാരം ഫിൽട്ടർ ചെയ്യുക

ഞങ്ങൾ അഭ്യർത്ഥന ഉപയോഗിക്കുന്നു ശ്രേണി ഫിൽട്ടറിന്റെ പശ്ചാത്തലത്തിൽ:

# получим посты, опубликованные 1ого сентября или позже
curl -XGET "$ES_URL/blog/post/_search?pretty" -d'
{
  "filter": {
    "range": {
      "published_at": { "gte": "2014-09-01" }
    }
  }
}'

ടാഗുകൾ പ്രകാരം ഫിൽട്ടർ ചെയ്യുക

ഞങ്ങൾ ഉപയോഗിക്കുന്നു കാലാവധി ചോദ്യം തന്നിരിക്കുന്ന വാക്ക് അടങ്ങിയ ഡോക്യുമെന്റ് ഐഡികൾക്കായി തിരയാൻ:

# найдем все документы, в поле tags которых есть элемент 'котята'
curl -XGET "$ES_URL/blog/post/_search?pretty" -d'
{
  "_source": [
    "title",
    "tags"
  ],
  "filter": {
    "term": {
      "tags": "котята"
    }
  }
}'

{
  "took" : 9,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 2,
    "max_score" : 1.0,
    "hits" : [ {
      "_index" : "blog",
      "_type" : "post",
      "_id" : "1",
      "_score" : 1.0,
      "_source" : {
        "title" : "Веселые котята",
        "tags" : [ "котята", "смешная история" ]
      }
    }, {
      "_index" : "blog",
      "_type" : "post",
      "_id" : "3",
      "_score" : 1.0,
      "_source" : {
        "title" : "Как у меня появился котенок",
        "tags" : [ "котята" ]
      }
    } ]
  }
}

മുഴുവൻ ടെക്സ്റ്റ് തിരയൽ

ഞങ്ങളുടെ മൂന്ന് പ്രമാണങ്ങളിൽ ഉള്ളടക്ക ഫീൽഡിൽ ഇനിപ്പറയുന്നവ അടങ്ങിയിരിക്കുന്നു:

• <p>Смешная история про котят<p>
• <p>Смешная история про щенков<p>
• <p>Душераздирающая история про бедного котенка с улицы<p>

ഞങ്ങൾ ഉപയോഗിക്കുന്നു പൊരുത്ത ചോദ്യം തന്നിരിക്കുന്ന വാക്ക് അടങ്ങിയ ഡോക്യുമെന്റ് ഐഡികൾക്കായി തിരയാൻ:

# source: false означает, что не нужно извлекать _source найденных документов
curl -XGET "$ES_URL/blog/post/_search?pretty" -d'
{
  "_source": false,
  "query": {
    "match": {
      "content": "история"
    }
  }
}'

{
  "took" : 13,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 3,
    "max_score" : 0.11506981,
    "hits" : [ {
      "_index" : "blog",
      "_type" : "post",
      "_id" : "2",
      "_score" : 0.11506981
    }, {
      "_index" : "blog",
      "_type" : "post",
      "_id" : "1",
      "_score" : 0.11506981
    }, {
      "_index" : "blog",
      "_type" : "post",
      "_id" : "3",
      "_score" : 0.095891505
    } ]
  }
}

എന്നിരുന്നാലും, ഞങ്ങൾ ഉള്ളടക്ക ഫീൽഡിൽ "കഥകൾ" എന്ന് തിരഞ്ഞാൽ, ഞങ്ങൾ ഒന്നും കണ്ടെത്തുകയില്ല, കാരണം സൂചികയിൽ യഥാർത്ഥ പദങ്ങൾ മാത്രമേ ഉള്ളൂ, അവയുടെ കാണ്ഡമല്ല. ഉയർന്ന നിലവാരമുള്ള തിരയൽ നടത്തുന്നതിന്, നിങ്ങൾ അനലൈസർ കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്.

ഫീൽഡ് _score ഷോകൾ പ്രസക്തി. അഭ്യർത്ഥന ഒരു ഫിൽട്ടർ സന്ദർഭത്തിലാണ് നടപ്പിലാക്കുന്നതെങ്കിൽ, _സ്കോർ മൂല്യം എല്ലായ്പ്പോഴും 1 ന് തുല്യമായിരിക്കും, അതായത് ഫിൽട്ടറുമായി പൂർണ്ണമായ പൊരുത്തം.

അനലൈസറുകൾ

അനലൈസറുകൾ സോഴ്‌സ് ടെക്‌സ്‌റ്റ് ഒരു കൂട്ടം ടോക്കണുകളായി പരിവർത്തനം ചെയ്യേണ്ടതുണ്ട്.
അനലൈസറുകൾ ഒന്ന് ഉൾക്കൊള്ളുന്നു ടോക്കനൈസർ കൂടാതെ നിരവധി ഓപ്ഷണൽ ടോക്കൺ ഫിൽട്ടറുകൾ. ടോക്കണൈസറിന് മുമ്പായി പലതും ഉണ്ടാകാം ചാർഫിൽറ്ററുകൾ. ടോക്കണൈസറുകൾ ഉറവിട സ്‌ട്രിംഗിനെ സ്‌പെയ്‌സുകളും വിരാമചിഹ്ന പ്രതീകങ്ങളും പോലുള്ള ടോക്കണുകളായി വിഭജിക്കുന്നു. ടോക്കൺഫിൽട്ടറിന് ടോക്കണുകൾ മാറ്റാനോ ഇല്ലാതാക്കാനോ പുതിയവ ചേർക്കാനോ കഴിയും, ഉദാഹരണത്തിന്, വാക്കിന്റെ തണ്ട് മാത്രം വിടുക, പ്രീപോസിഷനുകൾ നീക്കം ചെയ്യുക, പര്യായങ്ങൾ ചേർക്കുക. CharFilter - മുഴുവൻ ഉറവിട സ്‌ട്രിംഗും മാറ്റുന്നു, ഉദാഹരണത്തിന്, html ടാഗുകൾ മുറിക്കുന്നു.

ES ന് നിരവധിയുണ്ട് സ്റ്റാൻഡേർഡ് അനലൈസറുകൾ. ഉദാഹരണത്തിന്, ഒരു അനലൈസർ റഷ്യൻ.

നമുക്ക് പ്രയോജനപ്പെടുത്താം api സ്റ്റാൻഡേർഡ്, റഷ്യൻ അനലൈസറുകൾ "പൂച്ചക്കുട്ടികളെക്കുറിച്ചുള്ള രസകരമായ കഥകൾ" എന്ന സ്ട്രിംഗിനെ എങ്ങനെ രൂപാന്തരപ്പെടുത്തുന്നുവെന്ന് നമുക്ക് നോക്കാം:

# используем анализатор standard       
# обязательно нужно перекодировать не ASCII символы
curl -XGET "$ES_URL/_analyze?pretty&analyzer=standard&text=%D0%92%D0%B5%D1%81%D0%B5%D0%BB%D1%8B%D0%B5%20%D0%B8%D1%81%D1%82%D0%BE%D1%80%D0%B8%D0%B8%20%D0%BF%D1%80%D0%BE%20%D0%BA%D0%BE%D1%82%D1%8F%D1%82"

{
  "tokens" : [ {
    "token" : "веселые",
    "start_offset" : 0,
    "end_offset" : 7,
    "type" : "<ALPHANUM>",
    "position" : 0
  }, {
    "token" : "истории",
    "start_offset" : 8,
    "end_offset" : 15,
    "type" : "<ALPHANUM>",
    "position" : 1
  }, {
    "token" : "про",
    "start_offset" : 16,
    "end_offset" : 19,
    "type" : "<ALPHANUM>",
    "position" : 2
  }, {
    "token" : "котят",
    "start_offset" : 20,
    "end_offset" : 25,
    "type" : "<ALPHANUM>",
    "position" : 3
  } ]
}

# используем анализатор russian
curl -XGET "$ES_URL/_analyze?pretty&analyzer=russian&text=%D0%92%D0%B5%D1%81%D0%B5%D0%BB%D1%8B%D0%B5%20%D0%B8%D1%81%D1%82%D0%BE%D1%80%D0%B8%D0%B8%20%D0%BF%D1%80%D0%BE%20%D0%BA%D0%BE%D1%82%D1%8F%D1%82"

{
  "tokens" : [ {
    "token" : "весел",
    "start_offset" : 0,
    "end_offset" : 7,
    "type" : "<ALPHANUM>",
    "position" : 0
  }, {
    "token" : "истор",
    "start_offset" : 8,
    "end_offset" : 15,
    "type" : "<ALPHANUM>",
    "position" : 1
  }, {
    "token" : "кот",
    "start_offset" : 20,
    "end_offset" : 25,
    "type" : "<ALPHANUM>",
    "position" : 3
  } ]
}

സ്റ്റാൻഡേർഡ് അനലൈസർ സ്ട്രിംഗിനെ സ്‌പെയ്‌സ് ഉപയോഗിച്ച് വിഭജിക്കുകയും എല്ലാം ചെറിയ അക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുകയും റഷ്യൻ അനലൈസർ അപ്രധാനമായ വാക്കുകൾ നീക്കം ചെയ്യുകയും ചെറിയ അക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുകയും പദങ്ങളുടെ തണ്ട് ഉപേക്ഷിക്കുകയും ചെയ്തു.

റഷ്യൻ അനലൈസർ ഉപയോഗിക്കുന്ന ടോക്കനൈസർ, ടോക്കൺ ഫിൽട്ടറുകൾ, ചാർഫിൽട്ടറുകൾ ഏതൊക്കെയെന്ന് നോക്കാം:

{
  "filter": {
    "russian_stop": {
      "type":       "stop",
      "stopwords":  "_russian_"
    },
    "russian_keywords": {
      "type":       "keyword_marker",
      "keywords":   []
    },
    "russian_stemmer": {
      "type":       "stemmer",
      "language":   "russian"
    }
  },
  "analyzer": {
    "russian": {
      "tokenizer":  "standard",
      /* TokenFilters */
      "filter": [
        "lowercase",
        "russian_stop",
        "russian_keywords",
        "russian_stemmer"
      ]
      /* CharFilters отсутствуют */
    }
  }
}

html ടാഗുകൾ വെട്ടിമാറ്റുന്ന റഷ്യൻ ഭാഷയെ അടിസ്ഥാനമാക്കിയുള്ള ഞങ്ങളുടെ അനലൈസർ വിവരിക്കാം. നമുക്ക് അതിനെ ഡിഫോൾട്ട് എന്ന് വിളിക്കാം, കാരണം ഈ പേരുള്ള ഒരു അനലൈസർ സ്ഥിരസ്ഥിതിയായി ഉപയോഗിക്കും.

{
  "filter": {
    "ru_stop": {
      "type":       "stop",
      "stopwords":  "_russian_"
    },
    "ru_stemmer": {
      "type":       "stemmer",
      "language":   "russian"
    }
  },
  "analyzer": {
    "default": {
      /* добавляем удаление html тегов */
      "char_filter": ["html_strip"],
      "tokenizer":  "standard",
      "filter": [
        "lowercase",
        "ru_stop",
        "ru_stemmer"
      ]
    }
  }
}

ആദ്യം, എല്ലാ HTML ടാഗുകളും ഉറവിട സ്‌ട്രിംഗിൽ നിന്ന് നീക്കംചെയ്യപ്പെടും, തുടർന്ന് ടോക്കണൈസർ സ്റ്റാൻഡേർഡ് അതിനെ ടോക്കണുകളായി വിഭജിക്കും, തത്ഫലമായുണ്ടാകുന്ന ടോക്കണുകൾ ചെറിയ അക്ഷരത്തിലേക്ക് നീങ്ങും, അപ്രധാനമായ വാക്കുകൾ നീക്കംചെയ്യപ്പെടും, ശേഷിക്കുന്ന ടോക്കണുകൾ വാക്കിന്റെ തണ്ടായി തുടരും.

ഒരു സൂചിക സൃഷ്ടിക്കുന്നു

മുകളിൽ ഞങ്ങൾ ഡിഫോൾട്ട് അനലൈസർ വിവരിച്ചു. എല്ലാ സ്ട്രിംഗ് ഫീൽഡുകൾക്കും ഇത് ബാധകമാകും. ഞങ്ങളുടെ പോസ്റ്റിൽ ടാഗുകളുടെ ഒരു നിര അടങ്ങിയിരിക്കുന്നു, അതിനാൽ ടാഗുകളും അനലൈസർ പ്രോസസ്സ് ചെയ്യും. കാരണം ഒരു ടാഗുമായി കൃത്യമായ പൊരുത്തമനുസരിച്ച് ഞങ്ങൾ പോസ്റ്റുകൾക്കായി തിരയുകയാണ്, തുടർന്ന് ടാഗ് ഫീൽഡിനായുള്ള വിശകലനം ഞങ്ങൾ പ്രവർത്തനരഹിതമാക്കേണ്ടതുണ്ട്.

ഒരു അനലൈസറും മാപ്പിംഗും ഉപയോഗിച്ച് നമുക്ക് ഒരു സൂചിക ബ്ലോഗ്2 സൃഷ്ടിക്കാം, അതിൽ ടാഗ് ഫീൽഡിന്റെ വിശകലനം പ്രവർത്തനരഹിതമാക്കിയിരിക്കുന്നു:

curl -XPOST "$ES_URL/blog2" -d'
{
  "settings": {
    "analysis": {
      "filter": {
        "ru_stop": {
          "type": "stop",
          "stopwords": "_russian_"
        },
        "ru_stemmer": {
          "type": "stemmer",
          "language": "russian"
        }
      },
      "analyzer": {
        "default": {
          "char_filter": [
            "html_strip"
          ],
          "tokenizer": "standard",
          "filter": [
            "lowercase",
            "ru_stop",
            "ru_stemmer"
          ]
        }
      }
    }
  },
  "mappings": {
    "post": {
      "properties": {
        "content": {
          "type": "string"
        },
        "published_at": {
          "type": "date"
        },
        "tags": {
          "type": "string",
          "index": "not_analyzed"
        },
        "title": {
          "type": "string"
        }
      }
    }
  }
}'

ഈ സൂചികയിൽ (blog3) അതേ 2 പോസ്റ്റുകൾ ചേർക്കാം. ഞാൻ ഈ പ്രക്രിയ ഒഴിവാക്കും കാരണം... ഇത് ബ്ലോഗ് സൂചികയിലേക്ക് പ്രമാണങ്ങൾ ചേർക്കുന്നതിന് സമാനമാണ്.

എക്‌സ്‌പ്രഷൻ പിന്തുണയോടെ പൂർണ്ണമായ വാചക തിരയൽ

നമുക്ക് മറ്റൊരു തരത്തിലുള്ള അഭ്യർത്ഥന നോക്കാം:

# найдем документы, в которых встречается слово 'истории'
# query -> simple_query_string -> query содержит поисковый запрос
# поле title имеет приоритет 3
# поле tags имеет приоритет 2
# поле content имеет приоритет 1
# приоритет используется при ранжировании результатов
curl -XPOST "$ES_URL/blog2/post/_search?pretty" -d'
{
  "query": {
    "simple_query_string": {
      "query": "истории",
      "fields": [
        "title^3",
        "tags^2",
        "content"
      ]
    }
  }
}'

കാരണം ഞങ്ങൾ റഷ്യൻ സ്റ്റെമ്മിംഗ് ഉള്ള ഒരു അനലൈസർ ഉപയോഗിക്കുന്നു, തുടർന്ന് ഈ അഭ്യർത്ഥന എല്ലാ രേഖകളും തിരികെ നൽകും, എന്നിരുന്നാലും അവയിൽ 'ചരിത്രം' എന്ന വാക്ക് മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ.

അഭ്യർത്ഥനയിൽ പ്രത്യേക പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കാം, ഉദാഹരണത്തിന്:

""fried eggs" +(eggplant | potato) -frittata"

വാക്യഘടന അഭ്യർത്ഥിക്കുക:

+ signifies AND operation
| signifies OR operation
- negates a single token
" wraps a number of tokens to signify a phrase for searching
* at the end of a term signifies a prefix query
( and ) signify precedence
~N after a word signifies edit distance (fuzziness)
~N after a phrase signifies slop amount

# найдем документы без слова 'щенки'
curl -XPOST "$ES_URL/blog2/post/_search?pretty" -d'
{
  "query": {
    "simple_query_string": {
      "query": "-щенки",
      "fields": [
        "title^3",
        "tags^2",
        "content"
      ]
    }
  }
}'

# получим 2 поста про котиков

റെഫറൻസുകൾ

• ഇലാസ്റ്റിക്.കോ
• അവലംബം
• വഴികാട്ടി
• ഗ്ലോസറി
• ഇൻസ്റ്റലേഷൻ
• പ്രമാണ കൃത്രിമത്വം
• സൂചിക പ്രവർത്തനങ്ങൾ
• അഭ്യർത്ഥനകളുടെ പട്ടിക

PS

നിങ്ങൾക്ക് അത്തരം ലേഖന-പാഠങ്ങളിൽ താൽപ്പര്യമുണ്ടെങ്കിൽ, പുതിയ ലേഖനങ്ങൾക്കുള്ള ആശയങ്ങൾ ഉണ്ടെങ്കിൽ അല്ലെങ്കിൽ സഹകരണത്തിനുള്ള നിർദ്ദേശങ്ങൾ ഉണ്ടെങ്കിൽ, ഒരു വ്യക്തിഗത സന്ദേശമായോ m.kuzmin+habr@darkleaf.ru എന്ന മെയിൽ വഴിയോ ഒരു സന്ദേശം ലഭിക്കുന്നതിൽ ഞാൻ സന്തുഷ്ടനാകും.

അവലംബം: www.habr.com