ElasticSearch搜索底层基础原理总结

http://blog.51cto.com/qinbin/2051098

 

目录:

    1._search结果分析

    2.multi-index和multi-type

    3.分页查询与deep paging

    4.query DSL和query string

    5.mapping

    6.倒排索引和正排索引(doc value)

    7、分词器

    8.exact value和full text

    09.建立索引

    10.search api

    11.document相关度评分DF&IDF算法

    12.搜索相关参数

    13.query phase 

    14.fetch phase 

 

1._search结果分析

GET /_search
 
{
  "took": 6,
  "timed_out": false,
  "_shards": {
    "total": 6,
    "successful": 6,
    "failed": 0
  },
  "hits": {
    "total": 10,
    "max_score": 1,
    "hits": [
      {
        "_index": ".kibana",
        "_type": "config",
        "_id": "5.2.0",
        "_score": 1,
        "_source": {
          "buildNum": 14695
        }
      }
    ]
  }
}

took:整个搜索请求花费了多少毫秒

hits.total:本次搜索,返回了几条结果

hits.max_score:本次搜索的所有结果中,最大的相关度分数是多少,每一条document对于search的相关度,越相关,_score分数越大,排位越靠前

hits.hits:默认查询前10条数据,完整数据,_score降序排序

shards:shards fail的条件(primary和replica全部挂掉),不影响其他shard。默认情况下来说,一个搜索请求,会打到一个index的所有primary shard上去,当然了,每个primary shard都可能会有一个或多个replic shard,所以请求也可以到primary shard的其中一个replica shard上去。

timeout:默认无timeout,latency平衡completeness,手动指定timeout,timeout查询执行机制

格式:timeout=10ms,timeout=1s,timeout=1m

GET /_search?timeout=10m

 

2.multi-index和multi-type

    2.1、multi-index和multi-type搜索模式

        如何一次性搜索多个index和多个type下的数据

        /_search:所有索引,所有type下的所有数据都搜索出来

        /index1/_search:指定一个index,搜索其下所有type的数据

        /index1,index2/_search:同时搜索两个index下的数据

        /*1,*2/_search:按照通配符去匹配多个索引

        /index1/type1/_search:搜索一个index下指定的type的数据

        /index1/type1,type2/_search:可以搜索一个index下多个type的数据

        /index1,index2/type1,type2/_search:搜索多个index下的多个type的数据

        /_all/type1,type2/_search:_all,可以代表搜索所有index下的指定type的数据

2.2、初步图解简单的搜索原理

初步图解搜索原理.png

3.分页查询与deep paging

3.1、使用es进行分页搜索的语法

size,from
GET /_search?size=10
GET /_search?size=10&from=0
GET /_search?size=10&from=20
 
//分页的上机实验
 
GET /test_index/test_type/_search
 
"hits": {
    "total": 9,
    "max_score": 1,
 
//我们假设将这9条数据分成3页,每一页是3条数据,来实验一下这个分页搜索的效果
 
GET /test_index/test_type/_search?from=0&size=3
 
{
  "took": 2,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "failed": 0
  },
  "hits": {
    "total": 9,
    "max_score": 1,
    "hits": [
      {
        "_index": "test_index",
        "_type": "test_type",
        "_id": "8",
        "_score": 1,
        "_source": {
          "test_field": "test client 2"
        }
      },
      {
        "_index": "test_index",
        "_type": "test_type",
        "_id": "6",
        "_score": 1,
        "_source": {
          "test_field": "tes test"
        }
      },
      {
        "_index": "test_index",
        "_type": "test_type",
        "_id": "4",
        "_score": 1,
        "_source": {
          "test_field": "test4"
        }
      }
    ]
  }
}

3.2、deep paging问题?为什么会产生这个问题,它的底层原理是什么?

deep paging图解1.png

deep paging图解.png

搜索过深的时候,就需要在coordinate node上保存大量的数据,还要进行大量数据的排序,排序之后,再取出对应的那一页。所以这个过程,既消耗网络带宽,消耗内存,消耗CPU。所以应尽量避免。

4.query DSL和query string

4.1query string search语法和_all metedata

    1、query string基础语法

        GET /test_index/test_type/_search?q=test_field:test

        GET /test_index/test_type/_search?q=+test_field:test(必须包含)

        GET /test_index/test_type/_search?q=-test_field:test(不包含)

        一个是掌握q=field:search content的语法,还有一个是掌握+和-的含义

    2、_all metadata的原理和作用

        GET /test_index/test_type/_search?q=test

        直接可以搜索所有的field,任意一个field包含指定的关键字就可以搜索出来。我们在进行中搜索的时候,难道是对document中的每一个field都进行一次搜索吗?不是的

        es中的_all元数据,在建立索引的时候,我们插入一条document,它里面包含了多个field,此时,es会自动将多个field的值,全部用字符串的方式串联起来,变成一个长的字符串,作为_all field的值,同时建立索引

        后面如果在搜索的时候,没有对某个field指定搜索,就默认搜索_all field,其中是包含了所有field的值的

4.2query DSL

GET /_search
{
    "query": {
        "match_all": {}
    }
}
2、Query DSL的基本语法
 
{
    QUERY_NAME: {
        ARGUMENT: VALUE,
        ARGUMENT: VALUE,...
    }
}
 
{
    QUERY_NAME: {
        FIELD_NAME: {
            ARGUMENT: VALUE,
            ARGUMENT: VALUE,...
        }
    }
}
 
示例:
 
GET /test_index/test_type/_search
{
  "query": {
    "match": {
      "test_field": "test"
    }
  }
}

    4.2.1如何组合多个搜索条件

    搜索需求:title必须包含elasticsearch,content可以包含elasticsearch也可以不包含,author_id必须不为111

GET /website/article/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "title": "elasticsearch"
          }
        }
      ],
      "should": [
        {
          "match": {
            "content": "elasticsearch"
          }
        }
      ],
      "must_not": [
        {
          "match": {
            "author_id": 111
          }
        }
      ]
    }
  }
}
 
GET /test_index/_search
{
    "query": {
            "bool": {
                "must": { "match":   { "name": "tom" }},
                "should": [
                    { "match":       { "hired": true }},
                    { "bool": {
                        "must":      { "match": { "personality": "good" }},
                        "must_not":  { "match": { "rude": true }}
                    }}
                ],
                "minimum_should_match": 1
            }
    }
}

4.2.2、filter与query对比大解密

filter,仅仅只是按照搜索条件过滤出需要的数据而已,不计算任何相关度分数,对相关度没有任何影响

query,会去计算每个document相对于搜索条件的相关度,并按照相关度进行排序

一般来说,如果你是在进行搜索,需要将最匹配搜索条件的数据先返回,那么用query;如果你只是要根据一些条件筛选出一部分数据,不关注其排序,那么用filter

除非是你的这些搜索条件,你希望越符合这些搜索条件的document越排在前面返回,那么这些搜索条件要放在query中;如果你不希望一些搜索条件来影响你的document排序,那么就放在filter中即可

4.2.3、filter与query性能

filter,不需要计算相关度分数,不需要按照相关度分数进行排序,同时还有内置的自动cache最常使用filter的数据

query,相反,要计算相关度分数,按照分数进行排序,而且无法cache结果

4.2.4、Query常用搜索语法

1、match all
GET /_search
{
    "query": {
        "match_all": {}
    }
}
 
2、match
GET /_search
{
    "query": { "match": { "title": "my elasticsearch article" }}
}
 
3、multi match
GET /test_index/test_type/_search
{
  "query": {
    "multi_match": {
      "query": "test",
      "fields": ["test_field", "test_field1"]
    }
  }
}
 
4、range query
GET /company/employee/_search
{
  "query": {
    "range": {
      "age": {
        "gte": 30
      }
    }
  }
}
 
5、term query
GET /test_index/test_type/_search
{
  "query": {
    "term": {
      "test_field": "test hello"
    }
  }
}
 
6、terms query
GET /_search
{
    "query": { "terms": { "tag": [ "search", "full_text", "nosql" ] }}
}
 
7、exist query(2.x中的查询,现在已经不提供了)

4.2.5、多搜索条件组合查询

bool

must,must_not,should,filter

每个子查询都会计算一个document针对它的相关度分数,然后bool综合所有分数,合并为一个分数,当然filter是不会计算分数的

{
    "bool": {
        "must":     { "match": { "title": "how to make millions" }},
        "must_not": { "match": { "tag":   "spam" }},
        "should": [
            { "match": { "tag": "starred" }}
        ],
        "filter": {
          "bool": {
              "must": [
                  { "range": { "date": { "gte": "2014-01-01" }}},
                  { "range": { "price": { "lte": 29.99 }}}
              ],
              "must_not": [
                  { "term": { "category": "ebooks" }}
              ]
          }
        }
    }
}

5.mapping

(1)往es里面直接插入数据,es会自动建立索引,同时建立type以及对应的mapping

(2)mapping中就自动定义了每个field的数据类型

(3)不同的数据类型(比如说text和date),可能有的是exact value,有的是full text

(4)exact value,在建立倒排索引的时候,分词的时候,是将整个值一起作为一个关键词建立到倒排索引中的;full text,会经历各种各样的处理,分词,normaliztion(时态转换,同义词转换,大小写转换),才会建立到倒排索引中

(5)同时呢,exact value和full text类型的field就决定了,在一个搜索过来的时候,对exact value field或者是full text field进行搜索的行为也是不一样的,会跟建立倒排索引的行为保持一致;比如说exact value搜索的时候,就是直接按照整个值进行匹配,full text query string,也会进行分词和normalization再去倒排索引中去搜索

(6)可以用es的dynamic mapping,让其自动建立mapping,包括自动设置数据类型;也可以提前手动创建index和type的mapping,自己对各个field进行设置,包括数据类型,包括索引行为,包括分词器,等等

mapping,就是index的type的元数据,每个type都有一个自己的mapping,决定了数据类型,建立倒排索引的行为,还有进行搜索的行为

插入几条数据,让es自动建立一个索引
PUT /website/article/1
{
  "post_date": "2017-01-01",
  "title": "my first article",
  "content": "this is my first article in this website",
  "author_id": 11400
}
PUT /website/article/2
{
  "post_date": "2017-01-02",
  "title": "my second article",
  "content": "this is my second article in this website",
  "author_id": 11400
}
PUT /website/article/3
{
  "post_date": "2017-01-03",
  "title": "my third article",
  "content": "this is my third article in this website",
  "author_id": 11400
}
 
尝试各种搜索
GET /website/article/_search?q=2017   3条结果             
GET /website/article/_search?q=2017-01-01         3条结果
GET /website/article/_search?q=post_date:2017-01-01    1条结果
GET /website/article/_search?q=post_date:2017          1条结果

搜索结果为什么不一致,因为es自动建立mapping的时候,设置了不同的field不同的data type。不同的data type的分词、搜索等行为是不一样的。所以出现了_all field和post_date field的搜索表现完全不一样。 

下面解释

GET /_search?q=2017
搜索的是_all field,document所有的field都会拼接成一个大串,进行分词
2017-01-02 my second article this is my second article in this website 11400
doc1  doc2  doc3
2017  *  *  *
01    *  
02       *
03          *
_all,2017,自然会搜索到3个docuemnt
-------------------------------------------------------------
GET /_search?q=2017-01-01
_all,2017-01-01,query string会用跟建立倒排索引一样的分词器去进行分词
2017
01
01
----------------------------------------------------------------
GET /_search?q=post_date:2017-01-01
date,会作为exact value去建立索引
            doc1   doc2  doc3
2017-01-01     *  
2017-01-02           *  
2017-01-03                 *
post_date:2017-01-01,2017-01-01,doc1一条document
----------------------------------------------------------- 
GET /_search?q=post_date:2017,这个在这里不说,因为是es 5.2以后做的一个优化

 

5.1、query string分词

query string必须以和index建立时相同的analyzer进行分词

query string对exact value和full text的区别对待

 

date:exact value

_all:full text

 

比如我们有一个document,其中有一个field,包含的value是:hello you and me,建立倒排索引

我们要搜索这个document对应的index,搜索文本是hell me,这个搜索文本就是query string

query string,默认情况下,es会使用它对应的field建立倒排索引时相同的分词器去进行分词,分词和normalization,只有这样,才能实现正确的搜索

我们建立倒排索引的时候,将dogs --> dog,结果你搜索的时候,还是一个dogs,那不就搜索不到了吗?所以搜索的时候,那个dogs也必须变成dog才行。才能搜索到。

知识点:不同类型的field,可能有的就是full text,有的就是exact value

post_date,date:exact value

_all:full text,分词,normalization

5.2、mapping数据类型

1、核心的数据类型

string

byte,short,integer,long

float,double

boolean

date

2、dynamic mapping

true or false --> boolean

123  --> long

123.45  --> double

2017-01-01 --> date

"hello world" --> string/text

3、查看mapping

GET /index/_mapping/type

5.3、mapping复杂数据类型

1、multivalue field
 
{ "tags": [ "tag1", "tag2" ]}
 
建立索引时与string是一样的,数据类型不能混
 
2、empty field
 
null,[],[null]
 
3、object field
 
PUT /company/employee/1
{
  "address": {
    "country": "china",
    "province": "guangdong",
    "city": "guangzhou"
  },
  "name": "jack",
  "age": 27,
  "join_date": "2017-01-01"
}
 
address:object类型
 
{
  "company": {
    "mappings": {
      "employee": {
        "properties": {
          "address": {
            "properties": {
              "city": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "country": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "province": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              }
            }
          },
          "age": {
            "type": "long"
          },
          "join_date": {
            "type": "date"
          },
          "name": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          }
        }
      }
    }
  }
}

6.倒排索引和正排索引(doc value)

搜索的时候,要依靠倒排索引;排序的时候,需要依靠正排索引,看到每个document的每个field,然后进行排序,所谓的正排索引,其实就是doc values

在建立索引的时候,一方面会建立倒排索引,以供搜索用;一方面会建立正排索引,也就是doc values,以供排序,聚合,过滤等操作使用

doc values是被保存在磁盘上的,此时如果内存足够,os会自动将其缓存在内存中,性能还是会很高;如果内存不足够,os会将其写入磁盘上

倒排索引

doc1: hello world you and me

doc2: hi, world, how are you

 

word  doc1  doc2

 

hello  *

world  *      *

you   *      *

and    *

me    *

hi         *

how        *

are        *

正排索引

oc1: { "name": "jack", "age": 27 }

doc2: { "name": "tom", "age": 30 }

document name  age

doc1  jack  27

doc2  tom  30

 

7、分词器

    什么是分词器:切分词语,normalization(提升recall召回率)

    给你一段句子,然后将这段句子拆分成一个一个的单个的单词,同时对每个单词进行normalization(时态转换,单复数转换),分词器

    recall,召回率:搜索的时候,增加能够搜索到的结果的数量

    character filter:在一段文本进行分词之前,先进行预处理,比如说最常见的就是,过滤html标签(<span>hello<span> --> hello),& --> and(I&you --> I and you)

    tokenizer:分词,hello you and me --> hello, you, and, me

    token filter:lowercase,stop word,synonymom,dogs --> dog,liked --> like,Tom --> tom,a/the/an --> 干掉,mother --> mom,small --> little

    一个分词器,很重要,将一段文本进行各种处理,最后处理好的结果才会拿去建立倒排索引

8.exact value和full text

    1、exact value

        2017-01-01,exact value,搜索的时候,必须输入2017-01-01,才能搜索出来

        如果你输入一个01,是搜索不出来的

    2、full text

    (1)缩写 vs. 全程:cn vs. china

    (2)格式转化:like liked likes

    (3)大小写:Tom vs tom

    (4)同义词:like vs love

09.建立索引

1、如何建立索引

    analyzed:进行分词

    not_analyzed:不进行分词

    no:不建立索引,不被查询

2、修改mapping

只能创建index时手动建立mapping,或者新增field mapping,但是不能update field mapping

PUT /website
{
  "mappings": {
    "article": {
      "properties": {
        "author_id": {
          "type": "long"
        },
        "title": {
          "type": "text",
          "analyzer": "english"
        },
        "content": {
          "type": "text"
        },
        "post_date": {
          "type": "date"
        },
        "publisher_id": {
          "type": "text",
          "index": "not_analyzed"
        }
      }
    }
  }
}

 

10.search api

10.1、search api的基本语法

GET /search
{}
GET /index1,index2/type1,type2/search
{}
GET /_search
{
  "from": 0,
  "size": 10
}

10.2、http协议中get是否可以带上request body

    HTTP协议,一般不允许get请求带上request body,但是因为get更加适合描述查询数据的操作,因此还是这么用了

    GET /_search?from=0&size=10

    POST /_search

    {

      "from":0,

      "size":10

    }

    碰巧,很多浏览器,或者是服务器,也都支持GET+request body模式

    如果遇到不支持的场景,也可以用POST /_search

11.document相关度评分DF&IDF算法

relevance score算法,简单来说,就是计算出,一个索引中的文本,与搜索文本,他们之间的关联匹配程度

Elasticsearch使用的是 term frequency/inverse document frequency算法,简称为TF/IDF算法

 

Term frequency:搜索文本中的各个词条在field文本中出现了多少次,出现次数越多,就越相关

搜索请求:hello world

doc1:hello you, and world is very good

doc2:hello, how are you

 

Inverse document frequency:搜索文本中的各个词条在整个索引的所有文档中出现了多少次,出现的次数越多,就越不相关

搜索请求:hello world

doc1:hello, today is very good

doc2:hi world, how are you

比如说,在index中有1万条document,hello这个单词在所有的document中,一共出现了1000次;world这个单词在所有的document中,一共出现了100次

doc2更相关

 

Field-length norm:field长度,field越长,相关度越弱

搜索请求:hello world

doc1:{ "title": "hello article", "content": "babaaba 1万个单词" }

doc2:{ "title": "my article", "content": "blablabala 1万个单词,hi world" }

hello world在整个index中出现的次数是一样多的

doc1更相关,title field更短

 

12.搜索相关参数

1、preference

    决定了哪些shard会被用来执行搜索操作

    _primary, _primary_first, _local, _only_node:xyz, _prefer_node:xyz, _shards:2,3

    bouncing results问题,两个document排序,field值相同;不同的shard上,可能排序不同;每次请求轮询打到不同的replica shard上;每次页面上看到的搜索结果的排序都不一样。这就是bouncing result,也就是跳跃的结果。

    搜索的时候,是轮询将搜索请求发送到每一个replica shard(primary shard),但是在不同的shard上,可能document的排序不同

    解决方案就是将preference设置为一个字符串,比如说user_id,让每个user每次搜索的时候,都使用同一个replica shard去执行,就不会看到bouncing results了

 

2、timeout,已经讲解过原理了,主要就是限定在一定时间内,将部分获取到的数据直接返回,避免查询耗时过长

 

3、routing,document文档路由,_id路由,routing=user_id,这样的话可以让同一个user对应的数据到一个shard上去

 

4、search_type

default:query_then_fetch

dfs_query_then_fetch,可以提升revelance sort精准度

 

13.query phase 

1、query phase

(1)搜索请求发送到某一个coordinate node,构构建一个priority queue,长度以paging操作from和size为准,默认为10

(2)coordinate node将请求转发到所有shard,每个shard本地搜索,并构建一个本地的priority queue

(3)各个shard将自己的priority queue返回给coordinate node,并构建一个全局的priority queue

2、replica shard如何提升搜索吞吐量

一次请求要打到所有shard的一个replica/primary上去,如果每个shard都有多个replica,那么同时并发过来的搜索请求可以同时打到其他的replica上去

query phase1.png

 

14.fetch phase 

1、fetch phbase工作流程

(1)coordinate node构建完priority queue之后,就发送mget请求去所有shard上获取对应的document

(2)各个shard将document返回给coordinate node

(3)coordinate node将合并后的document结果返回给client客户端

2、一般搜索,如果不加from和size,就默认搜索前10条,按照_score排序

fetch phase.png

 

 

 

没有更多推荐了,返回首页