1. 准备测试数据
PUT article
{
"mappings": {
"_doc": {
"properties": {
"articleId": {
"type": "keyword"
}
}
}
}
}
POST /article/_doc/_bulk
{"index": {"_id": 1}}
{"articleId": "XHDK-A-1293-#fJ3", "userId": 1, "hidden": false, "postDate": "2017-01-01", "tag": ["java", "elasticsearch"], "tag_cnt": 2, "view_cnt": 30, "title" : "this is java and elasticsearch blog"}
{"index": {"_id": 2}}
{"articleId": "KDKE-B-9947-#kL5", "userId": 1, "hidden": false, "postDate": "2017-01-02", "tag": ["java"], "tag_cnt": 1, "view_cnt": 50, "title" : "this is java blog"}
{"index": {"_id": 3}}
{"articleId": "JODL-X-1937-#pV7", "userId": 2, "hidden": false, "postDate": "2017-01-01", "tag": ["elasticsearch"], "tag_cnt": 1, "view_cnt": 100, "title": "this is elasticsearch blog"}
{"index": {"_id": 4}}
{"articleId": "QQPX-R-3956-#aD8", "userId": 2, "hidden": true, "postDate": "2017-01-02", "tag": ["java", "elasticsearch", "hadoop"], "tag_cnt": 3, "view_cnt": 80, "title": "this is java, elasticsearch, hadoop blog"}
{"index": {"_id": 5}}
{"articleID": "DHJK-B-1395-#Ky5", "userID": 3, "hidden": false, "postDate": "2017-03-01", "tag": ["spark"], "tag_cnt": 1, "view_cnt": 10, "title": "this is spark blog"}
2. 手动控制搜索精确度
# 搜索标题中包含java或elasticsearch的blog
# 4条结果
GET /article/_doc/_search
{
"query": {
"match": {
"title": "java elasticsearch"
}
}
}
# 搜索标题中包含java和elasticsearch的blog
# 2条结果
# 如果希望所有的搜索关键字都要匹配，那么就用and
GET /article/_doc/_search
{
"query": {
"match": {
"title": {
"query": "java elasticsearch",
"operator": "and"
}
}
}
}
# 搜索包含标题中java，elasticsearch，spark，hadoop，4个关键字中，至少3个的blog
# 1条结果
GET /article/_doc/_search
{
"query": {
"match": {
"title": {
"query": "java elasticsearch spark hadoop",
"minimum_should_match": "75%"
}
}
}
}
# 用bool组合多个搜索条件
# 查询标题中必须包含"java"，必须不包含"spark"，"hadoop"和"elasticsearch"包含不包含都可以的帖子
GET /article/_doc/_search
{
"query": {
"bool": {
"must": {
"match": {"title": "java"}
},
"must_not": {
"match": {"title": "spark"}
},
"should": [
{"match": {"title": "hadoop"}},
{"match": {"title": "elasticsearch"}}
]
}
}
}
# 结果
{
"took" : 10,
"timed_out" : false,
"_shards" : {
"total" : 5,
"successful" : 5,
"skipped" : 0,
"failed" : 0
},
"hits" : {
"total" : 3,
"max_score" : 1.449981,
"hits" : [
{
"_index" : "article",
"_type" : "_doc",
"_id" : "4",
"_score" : 1.449981,
"_source" : {
"articleId" : "QQPX-R-3956-#aD8",
"userId" : 2,
"hidden" : true,
"postDate" : "2017-01-02",
"tag" : [
"java",
"elasticsearch",
"hadoop"
],
"tag_cnt" : 3,
"view_cnt" : 80,
"title" : "this is java, elasticsearch, hadoop blog"
}
},
{
"_index" : "article",
"_type" : "_doc",
"_id" : "1",
"_score" : 0.5753642,
"_source" : {
"articleId" : "XHDK-A-1293-#fJ3",
"userId" : 1,
"hidden" : false,
"postDate" : "2017-01-01",
"tag" : [
"java",
"elasticsearch"
],
"tag_cnt" : 2,
"view_cnt" : 30,
"title" : "this is java and elasticsearch blog"
}
},
{
"_index" : "article",
"_type" : "_doc",
"_id" : "2",
"_score" : 0.19856805,
"_source" : {
"articleId" : "KDKE-B-9947-#kL5",
"userId" : 1,
"hidden" : false,
"postDate" : "2017-01-02",
"tag" : [
"java"
],
"tag_cnt" : 1,
"view_cnt" : 50,
"title" : "this is java blog"
}
}
]
}
}
bool组合多个搜索条件，如何计算relevance score(相关度分数)？
relevance score = must和should搜索对应的分数加起来 / must和should的总数
排名第一：标题包含"java"，同时包含should中所有的关键字即"hadoop"和"elasticsearch"
排名第二：标题包含"java"，同时包含should中的任何一个关键字
排名第三：标题包含"java"，不包含should中的任何关键字
should是可以影响相关度分数的，根据must的条件去计算出document对这个搜索条件的relevance score，在满足must的基础之上，should中的条件，不匹配也可以，但是如果匹配的更多，那么document的relevance score就会更高
# 使用bool组合多个搜索条件，控制全文检索的精确度
# 搜索标题中至少包含"java"、"hadoop"、"spark"、"elasticsearch"其中3个关键字的帖子
GET /article/_doc/_search
{
"query": {
"bool": {
"should": [
{"match": {"title": "java"}},
{"match": {"title": "elasticsearch"}},
{"match": {"title": "hadoop"}},
{"match": {"title": "spark"}}
],
"minimum_should_match": 3
}
}
}
默认情况下，在有must的情况下，should可以不匹配任何条件，在没有must的情况下，多个should的条件必须满足其中一个，可以使用"minimum_should_match"参数来精确控制should的行为。
minimum_should_match：
- 正数，例如3，那么should的多个条件中必须满足3个条件
- 负数，例如-2，代表可以有2个条件不满足，其他都应该满足
- 百分比正数：代表should条件总数的百分比个条件应该满足，例如总共10个条件，百分比为30%，那么至少3个条件应该满足，需满足条件的个数向下取整
- 百分比负数：代表占此比例的条件可以不满足，其余的均需要满足，计算结果向下取整
- 百分比和数字组合：3<90%，如果条件个数<=3，那么必须全部满足，否则，满足90%(向下取整)即可
- 多个组合(空格隔开)：2<-25% 9<-3，如果条件个数<=2，则必须都满足，如果条件个数为[3,9]，则需要25%的条件满足，否则，只能有3个条件不满足，其余都需要满足
3.match query的自动转化
# 在使用match query进行多值搜索的时候，es会在底层自动将match query转换为bool的语法
{
"match": {"title": "java elasticsearch"}
}
# 转化为
{
"bool": {
"should": [
{"term": {"title": "java"}},
{"term": {"title": "elasticsearch"}},
]
}
}
{
"match": {
"title": {
"query": "java elasticsearch",
"operator": "and"
}
}
}
# 转换为
{
"bool": {
"must": [
{ "term": { "title": "java" }},
{ "term": { "title": "elasticsearch"}}
]
}
}
{
"match": {
"title": {
"query": "java elasticsearch hadoop spark",
"minimum_should_match": "75%"
}
}
}
# 转换为
{
"bool": {
"should": [
{ "term": { "title": "java" }},
{ "term": { "title": "elasticsearch"}},
{ "term": { "title": "hadoop" }},
{ "term": { "title": "spark" }}
],
"minimum_should_match": 3
}
}
4. boost：搜索条件权重控制
需求：搜索标题中包含"blog"的帖子，同时如果标题中包含"java"、hadoop"、"elasticsearch"或者"spark"也可以，但包含"spark"的帖子要求它被优先搜索出来
知识点，搜索条件的权重，boost，可以将某个搜索条件的权重加大，此时当匹配这个搜索条件和匹配另一个搜索条件的document，计算relevance score时，匹配权重更大的搜索条件的document，relevance score会更高，也就会优先被返回
默认情况下，搜索条件的权重都是一样的，都是1
GET /article/_doc/_search
{
"query": {
"bool": {
"must": [
{"match": {"title": "blog"}}
],
"should": [
{"match": {"title": "java"}},
{"match": {"title": "hadoop"}},
{"match": {"title": "elasticsearch"}},
{
"match": {
"title": {
"query": "spark",
"boost": 5.0
}
}
}
]
}
}
}
5. 多shard场景下relevance score不准确问题
如果你的一个index有多个shard的话，可能搜索结果会不准确，原因如下：
当一个搜索请求被转发到一个shard后，会这样计算每条document的relevance score：
- 计算关键词在这条docuemnt的指定field中出现的次数（TF）
- 计算关键词在此shard的所有docuemnt的指定field中出现的次数（IDF）
- 注意：某个shard中只是包含一个index的部分document，而在默认情况下，IDF就是在shard本地进行计算
relevance score与TF成正比，与IDF成反比，在不考虑其他因素的前提下（relevance score不仅与TF和IDF有关），我们可以认为score=TF/IDF
假设在A shard中，所有"title"中包含"java"关键词的doucment，在某一条document中，"java"在"title"字段中出现了10次，但是在A shard中，"java"在所有的document的"title"字段中出现了100次，那么在A shard中，score=10/100=0.1
假设在B shard中，所有"title"中包含"java"关键词的doucment，在某一条document中，"java"在"title"字段中出现了1次，但是在B shard中，"java"在所有的document的"title"字段中也出现了1次，那么在B shard中，score=1/1=1
这样就造成了结果的不准确，应该是A shard中的那条document的score比B shard中的docuemnt的score高，造成这种现象的原因就是IDF是在一个shard的本地计算的，如果是在所有的shard中计算就不会有这个问题
解决办法：
-
生产环境下，数据量大，尽可能实现均匀分配
数据量很大的话，一般情况下，ES都是在多个shard中均匀路由数据的，路由的时候根据_id，进行负载均衡，比如说有10个document，其"title"都包含"java"关键词，一共有5个shard，如果负载均衡的话，每个shard都应该有2个document，这样计算出来的结果就没有问题了
测试环境下，将索引的primary shard设置为1个，如果说只有一个shard，当然也就没有这个问题了
测试环境下，搜索附带
search_type=dfs_query_then_fetch参数，此参数的作用是计算IDF的时候，计算全局的IDF而非本地的IDF，这样可以解决这个问题，但是会带来性能问题，在生产环境不推荐使用
6. dis_max：实现搜索的best_fields策略
6.1 dis_max
# 为帖子增加"content"字段
POST /article/_doc/_bulk
{"update": {"_id": "1"}}
{"doc": {"content": "i like to write best elasticsearch article"}}
{"update": {"_id": "2"}}
{"doc": {"content": "i think java is the best programming language"}}
{"update": {"_id": "3"}}
{"doc": {"content": "i am only an elasticsearch beginner"}}
{"update": { "_id": "4"}}
{"doc": {"content": "elasticsearch and hadoop are all very good solution, i am a beginner"}}
{"update": { "_id": "5"}}
{"doc": {"content": "spark is best big data solution based on scala ,an programming language similar to java"}}
# 搜索title或content中包含java或solution的帖子
GET /article/_doc/_search
{
"query": {
"bool": {
"should": [
{"match": {"title": "java solution"}},
{"match": {"content": "java solution"}}
]
}
},
"_source": ["title", "content"]
}
# 结果
# 1. doc2(score=0.95): title匹配"java"，content匹配"java"
# 2. doc4(score=0.81): title匹配"java"，content匹配"solution"
# 3. doc5(score=0.58): title无匹配，content匹配"java"和"solution"
# 4. doc1(score=0.29): title匹配"java"，content无匹配
# 我们期望的是doc5排名靠前，因为content同时匹配了"java"和"solution"
# 而实际却是doc2和doc4排名更靠前
# 分析一下doc4和doc5的socre
# score=每个query的分数 * 匹配到条件的个数 / 总条件个数
# 假设在每个查询条件中，匹配到一个单词得分1
# 那么doc4得分为(1+1)*2/2=2
# 同理doc5得分为(0+2)*1/2=1
# 于是doc4就排在了doc5之前
- dis_max query：搜索到的结果，如果某一个field中匹配到了尽可能多的关键词，那么它应该评分更高，而不是尽可能多的field匹配到了少数的关键词就排在了前面
- dis_max的原理是：多个query中，得分最高的query的分数，就是最终的分数
GET /article/_doc/_search
{
"query": {
"dis_max": {
"queries": [
{"match": {"title": "java solution"}},
{"match": {"content": "java solution"}}
]
}
},
"_source": ["title", "content"]
}
# 结果
# 1. doc2(score=0.75): title匹配"java"，content匹配"java"
# 2. doc4(score=0.64): title匹配"java"，content匹配"solution"
# 3. doc5(score=0.58): title无匹配，content匹配"java"和"solution"
# 4. doc1(score=0.29): title匹配"java"，content无匹配
# 说明
# 这里没有达到我的预期效果，预期应该是doc5的排名应该更靠前，这可能与影响评分的其他因素有关
# 但是doc2和doc4的得分都下降了，说明dis_max还是有有效果的
6.2 tie_breaker
# 换一个搜索条件
GET /article/_doc/_search
{
"query": {
"dis_max": {
"queries": [
{"match": {"title": "java beginner"}},
{"match": {"content": "java beginner"}}
]
}
},
"_source": ["title", "content"]
}
# 结果
# 1. doc2(score=0.75): title匹配java，content匹配java
# 2. doc4(score=0.64): title匹配java，content匹配beginner
# 3. doc5(score=0.29): title不匹配，content匹配java
# 4. doc1(score=0.29): title匹配java，content不匹配
# 5. doc3(score=0.29): title不匹配，content匹配beginner
# tie_breaker
# 这里结果还是比较符合预期的，以下是一种不符合预期的结果：
# 1. docA: title匹配java，content不匹配
# 1. docB: title不匹配，content匹配beginner
# 2. docC: title匹配java，content匹配beginner
# 对于上述结果，我们期望的可能是docC排在其他两个doc之前，这就需要使用tie_breaker
# dis_max只取某一个query最大的分数，完全不考虑其他query的分数
# 使用tie_breaker可以将其他query的分数也考虑进去
# tie_breaker参数的作用：
# 将其他query的分数乘以tie_breaker的值
# 然后与最高的分数综合在一起进行计算
# 除了取最高分以外，还会考虑其他的query的分数
# tie_breaker的值，在0~1之间，是个小数
GET /article/_doc/_search
{
"query": {
"dis_max": {
"queries": [
{"match": {"title": "java beginner"}},
{"match": {"content": "java beginner"}}
],
"tie_breaker": 0.3
}
},
"_source": ["title", "content"]
}
# 结果
# 1. doc2(score=0.81): title匹配java，content匹配java
# 2. doc4(score=0.69): title匹配java，content匹配beginner
# 3. doc5(score=0.29): title不匹配，content匹配java
# 4. doc1(score=0.29): title匹配java，content不匹配
# 5. doc3(score=0.29): title不匹配，content匹配beginner
# 可以看出对分数还是有影响的
6.3 multi_match、dis_max和tie_breaker的联合使用
GET /article/_doc/_search
{
"query": {
"multi_match": {
"query": "java solution",
"type": "best_fields", # best fields就是dis_max的策略，即认为一个字段匹配到尽可能多的关键词就评分更高
"fields": ["title^2", "content"], # "title^2：将title字段的权重乘以2
"tie_breaker": 0.3,
"minimum_should_match": "50%"
}
},
"_source": ["title", "content"]
}
# 上面的查询语法与下面的查询语法的结果是一样的
GET /article/_doc/_search
{
"query": {
"dis_max": {
"queries": [
{
"match": {
"title": {
"query": "java solution",
"minimum_should_match": "50%",
"boost": 2
}
}
},
{
"match": {
"content": {
"query": "java solution",
"minimum_should_match": "50%"
}
}
}
],
"tie_breaker": 0.3
}
},
"_source": ["title", "content"]
}
# minimum_should_match的作用：去长尾
# 比如搜索5个关键词，但是很多结果只匹配1个关键词的，这些结果与预期相差甚远，这些结果就是长尾
# minimum_should_match，控制搜索结果的精准度，只有匹配一定数量的关键词的数据，才能返回
7. most-fields策略
- best-fields策略：某一个field匹配尽可能多的关键词的doc评分更高
- most-fields策略：尽可能多的field可以匹配到关键词，那个这个doc的评分会更高
# 增加测试数据
POST /article/_mapping/_doc
{
"properties": {
"sub_title": {
"type": "text",
"analyzer": "english",
"fields": {
"std": {
"type": "text",
"analyzer": "standard"
}
}
}
}
}
POST /article/_doc/_bulk
{"update": {"_id": "1"}}
{"doc": {"sub_title": "learning more courses"}}
{"update": {"_id": "2"}}
{"doc": {"sub_title": "learned a lot of course"}}
{"update": {"_id": "3"}}
{"doc": {"sub_title" : "we have a lot of fun"}}
{"update": {"_id": "4"}}
{"doc": {"sub_title": "both of them are good"}}
{"update": {"_id": "5"}}
{"doc": {"sub_title": "haha, hello world"}}
GET /article/_doc/search
{
"query": {
"match": {
"sub_title": "learning courses"
}
}
}
# 结果，两条：doc1和doc2
# 使用english分词器进行分词后,learning->learn,learned->learn,courses->course
# 所以两条都可以搜索到
# 只有doc1一条结果
# sub_title.std使用standard分词器，按照非字母和非数字字符进行分隔，单词转为小写，不会进行常规化处理
GET /article/_doc/_search
{
"query": {
"match": {
"sub_title.std": "learning courses"
}
}
}
# most_fieds策略
GET /article/_doc/_search
{
"query": {
"multi_match": {
"query": "learning courses",
"type": "most_fields",
"fields": ["sub_title", "sub_title.std"]
}
},
"_source": ["sub_title"]
}}
# 1. doc2(score=1.39): sub_title匹配learn和course，sub_title.std无匹配
# 2. doc1(score=1.15): sub_title匹配learn和course，sub_title.std匹配learning和courses
# 这里结果也是很难理解的，因为我们预期doc1是比doc2优先返回的
# 评分计算时很复杂的， 不只是TF/IDF算法，不同的query，不同的语法，都有不同的计算score的细节，所以这里就不再深究了
best_fields与most_fields策略的区别：
-
best_fields，对多个field进行搜索，挑选某个field匹配度最高的那个分数，同时在多个query最高分相同的情况下，在一定程度上考虑其他query的分数，简单来说，对多个field进行搜索，某一个field尽可能包含更多关键字的doc评分更好
优点：通过best_fields策略，以及综合考虑其他field，还有minimum_should_match支持，可以尽可能精准地将匹配的结果推送到最前面
缺点：除了那些精准匹配的结果，其他差不多大的结果，排序结果不是太均匀，没有什么区分度了
例子：百度，最匹配的排到最前面
-
most_fields，综合多个field一起进行搜索，尽可能多地让所有field的query参与到总分数的计算中来，有越多的field可以匹配到关键词，这条doc的评分就更高
优点：将匹配到更多field的结果推送到最前面，整个排序结果是比较均匀的
缺点：可能那些精准匹配的结果，无法推送到最前面
例子：wiki，明显的most_fields策略，搜索结果比较均匀，但是的确要翻好几页才能找到最匹配的结果
8. cross-fields搜索
cross-fields搜索：
搜索的文本包含在多个field中，比如搜索"James Bob"，"James"在"first_name"字段中保存，"Bob"在"last_name"字段中保存，或者搜索一个地址文本，这些信息散落在"country"，"province"，"city"等字段中，这样的搜索就叫做cross-fields搜索。
使用most_fields策略进行cross-fields搜索是比较合适的，因为cross-fields本来就是需要在多个field中去搜索，而most_fields策略就是尽可能得去多个field中去匹配关键词
# 添加测试数据
POST /article/_doc/_bulk
{"update": {"_id": "1"}}
{"doc" : {"author_first_name": "Peter", "author_last_name": "Smith"}}
{"update": {"_id": "2"}}
{"doc" : {"author_first_name": "Smith", "author_last_name": "Williams"}}
{"update": {"_id": "3"}}
{"doc" : {"author_first_name": "Jack", "author_last_name": "Ma"}}
{"update": {"_id": "4"}}
{"doc" : {"author_first_name": "Robbin", "author_last_name": "Li"}}
{"update": {"_id": "5"}}
{"doc" : {"author_first_name": "Tonny", "author_last_name": "Peter Smith"}}
GET /article/_doc/_search
{
"query": {
"multi_match": {
"query": "Peter Smith",
"type": "most_fields",
"fields": ["author_first_name", "author_last_name"]
}
},
"_source": ["author_first_name", "author_last_name"]
}
# 结果
# 1. doc2(score=0.69): author_first_name匹配Smith，author_last_name无匹配
# 2. doc5(score=0.58): author_first_name不匹配，author_last_name匹配Peter和Smith
# 3. doc1(score=0.58): author_first_name匹配Peter，author_last_name匹配Smith
# 结果分析：为什么只匹配到"Smith"的doc反而排名最高
# score受TF/IDF的影响，IDF就是搜索词在所有文档中出现的次数，这个数字越高，TF/IDF越低
# 在所有文档的 "author_last_name"字段中，Smith出现2次，Peter出现1次
# 在所有文档的 "author_first_name"字段中，Smith出现1次，Peter出现1次
# 所有，在author_last_name中匹配到Smith的分数就不如在author_first_name中匹配到Smith的分数
# 当然影响分数的因素是很多的，这里是说一个普适的规律
使用most_fields进行cross-fields搜索的一些问题：
- 问题1：越多的field的匹配到关键词其分数会高与少量field匹配到多个关键词的分数
- 问题2：没办法用minimum_should_match去掉长尾数据，就是匹配的特别少的数据
- 问题3：TF/IDF算法可能导致结果无法符合预期，比如上面例子中的情况
解决办法一：copy_to，将多个field组合成一个field，用了copy_to语法之后，就可以将多个字段的值拷贝到一个字段中，并建立倒排索引，但是在index中是查不到这个字段的，这是一个隐藏的字段
PUT my_index
{
"mappings": {
"_doc": {
"properties": {
"first_name": {
"type": "text",
"copy_to": "full_name"
},
"last_name": {
"type": "text",
"copy_to": "full_name"
},
"full_name": {
"type": "text"
}
}
}
}
}
PUT my_index/_doc/1
{
"first_name": "Peter",
"last_name": "Smith"
}
PUT my_index/_doc/2
{
"first_name": "Smith",
"last_name": "Williams"
}
PUT my_index/_doc/3
{
"first_name": "Jack",
"last_name": "Ma"
}
PUT my_index/_doc/4
{
"first_name": "Robbin",
"last_name": "Li"
}
PUT my_index/_doc/5
{
"first_name": "Tonny",
"last_name": "Peter Smith"
}
GET my_index/_search
{
"query": {
"match": {
"full_name": "Peter Smith"
}
}
}
# 结果
# 1. doc2(score=0.69): first_name匹配Smith，last_name无匹配
# 2. doc5(score=0.58): first_name不匹配，author_last_name匹配Peter和Smith
# 3. doc1(score=0.58): first_name匹配Peter，last_name匹配Smith
# 这个结果也是不符合预期的，这与ES计算分数的算法有关，影响分数的因素是很多的
GET my_index/_search
{
"query": {
"match": {
"full_name": {
"query": "Peter Smith",
"operator": "and"
}
}
}
}
# 结果
# 1. doc5(score=0.58): first_name不匹配，author_last_name匹配Peter和Smith
# 2. doc1(score=0.58): first_name匹配Peter，last_name匹配Smith
解决办法二：使用cross-fields的原生语法
most-fields，只需要任意一个字段中出现一个关键词即可
GET my_index/_search
{
"query": {
"multi_match": {
"query": "Peter Smith",
"type": "cross_fields",
"operator": "and",
"fields": ["first_name", "last_name"]
}
}
}
# 结果
[
{
"_index" : "my_index",
"_type" : "_doc",
"_id" : "5",
"_score" : 0.5753642,
"_source" : {
"first_name" : "Tonny",
"last_name" : "Peter Smith"
}
},
{
"_index" : "my_index",
"_type" : "_doc",
"_id" : "1",
"_score" : 0.5753642,
"_source" : {
"first_name" : "Peter",
"last_name" : "Smith"
}
}
]
# type=cross_fields的原理
# 要求Peter必须在first_name或last_name中出现
# 要求Smith必须在first_name或last_name中出现
# doc2(first_name=Smith,last_name=Williams)就无法满足条件了
# 而原来的most-fields，只需要任意一个字段中出现一个关键词即可