Elasticsearch అనేది లూసీన్‌ని ఉపయోగించి మరియు జావాలో వ్రాయబడిన json rest apiతో కూడిన శోధన ఇంజిన్. ఈ ఇంజిన్ యొక్క అన్ని ప్రయోజనాల వివరణ ఇక్కడ అందుబాటులో ఉంది అధికారిక వెబ్సైట్. కింది వాటిలో మనం సాగే శోధనను ESగా సూచిస్తాము.

డాక్యుమెంట్ డేటాబేస్‌లో సంక్లిష్ట శోధనల కోసం ఇలాంటి ఇంజన్‌లు ఉపయోగించబడతాయి. ఉదాహరణకు, భాష యొక్క పదనిర్మాణాన్ని పరిగణనలోకి తీసుకొని శోధించండి లేదా జియో కోఆర్డినేట్‌ల ద్వారా శోధించండి.

ఈ వ్యాసంలో నేను బ్లాగ్ పోస్ట్‌లను ఇండెక్సింగ్ చేసే ఉదాహరణను ఉపయోగించి ES యొక్క ప్రాథమికాలను గురించి మాట్లాడతాను. పత్రాలను ఎలా ఫిల్టర్ చేయాలో, క్రమబద్ధీకరించాలో మరియు శోధించాలో నేను మీకు చూపుతాను.

ఆపరేటింగ్ సిస్టమ్‌పై ఆధారపడకుండా ఉండటానికి, నేను CURLని ఉపయోగించి 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 అవుట్‌పుట్‌లో సార్టింగ్ నిర్వహించబడే పూర్ణాంకాల శ్రేణిని కలిగి ఉంటుంది. ఆ. తేదీ పూర్ణాంకానికి మార్చబడింది. క్రమబద్ధీకరణ గురించి మరింత సమాచారం ఇక్కడ చూడవచ్చు డాక్యుమెంటేషన్.

ఫిల్టర్‌లు మరియు ప్రశ్నలు

ES వెర్షన్ 2 నుండి ఫిల్టర్‌లు మరియు ప్రశ్నల మధ్య తేడా లేదు సందర్భాల భావన పరిచయం చేయబడింది.
ప్రశ్న సందర్భం ఫిల్టర్ సందర్భం నుండి భిన్నంగా ఉంటుంది, దీనిలో ప్రశ్న _స్కోర్‌ను ఉత్పత్తి చేస్తుంది మరియు కాష్ చేయబడదు. నేను మీకు _స్కోర్ ఏమిటో తర్వాత చూపిస్తాను.

తేదీ వారీగా ఫిల్టర్ చేయండి

మేము అభ్యర్థనను ఉపయోగిస్తాము పరిధి ఫిల్టర్ సందర్భంలో:

# получим посты, опубликованные 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"
        }
      }
    }
  }
}'

అదే 3 పోస్ట్‌లను ఈ సూచికకు (blog2) జోడిద్దాం. నేను ఈ ప్రక్రియను విస్మరిస్తాను ఎందుకంటే... ఇది బ్లాగ్ ఇండెక్స్‌కు పత్రాలను జోడించడం లాంటిది.

వ్యక్తీకరణ మద్దతుతో పూర్తి వచన శోధన

మరొక రకమైన అభ్యర్థనను పరిశీలిద్దాం:

# найдем документы, в которых встречается слово 'истории'
# 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 поста про котиков

సూచనలు

• Elasctic.co
• సూచన
• గైడ్
• పదకోశం
• సెట్టింగ్
• డాక్యుమెంట్ మానిప్యులేషన్
• ఇండెక్స్ కార్యకలాపాలు
• అభ్యర్థనల జాబితా

PS

మీకు ఇలాంటి కథనాలు-పాఠాలపై ఆసక్తి ఉంటే, కొత్త కథనాల కోసం ఆలోచనలు ఉంటే లేదా సహకారం కోసం ప్రతిపాదనలు ఉంటే, నేను వ్యక్తిగత సందేశంలో లేదా ఇమెయిల్ ద్వారా సందేశాన్ని స్వీకరించడానికి సంతోషిస్తాను [ఇమెయిల్ రక్షించబడింది].

మూలం: www.habr.com