Term查询

Term Query / Range Query / Exists Query / Prefix Query / Wildcard Query
特点:

  • 对输入不做分词, 因此应检索keyword
  • 会为每个包含该词项的文档进行相关度算分
  • 可用constant score将查询转换成一个filtering, 避免算分, 并利用缓存, 提高性能 ```json

    term查询

    GET movies/_search { “query”: { “term”: {
    1. "title.keyword": {
    2.   "value": "2012"
    3. }
    } } }

利用constant_score转为filter

GET movies/_search { “query”: { “constant_score”: { “filter”: { “term”: { “title.keyword”: “2012” } } } } }

  2. <a name="cI3dY"></a>
  3. ## 全文查询
  4. Match Query / Match Phrase Query / Query String Query <br />特点:
  6. - 索引和搜索时都会分词, 查询字符串会先分词生成一个共查询的词项列表
  7. - 会算分
  8. ```json
  9. # 全文查询
  10. POST movies/_search
  11. {
  12.   "query": {
  13.     "match": {
  14.       "title": {
  15.         "query": "Matrix reloaded",
  16.         "operator": "and"
  17.       }
  18.     }
  19.   }
  20. }
  22. POST movies/_search
  23. {
  24.   "query": {
  25.     "match": {
  26.       "title": {
  27.         "query": "Matrix reloaded",
  28.         "minimum_should_match": 2
  29.       }
  30.     }
  31.   }
  32. }
  34. POST movies/_search
  35. {
  36.   "query": {
  37.     "match_phrase": {
  38.       "title": {
  39.         "query": "Matrix reloaded",
  40.         "slop": 1
  41.       }
  42.     }
  43.   }
  44. }

结构化搜索

结构化搜索是指对结构化数据的搜索, 其中日期, 布尔类型和数字都是结构化的, 文本也可以是结构化的.

  1. # 对布尔类型, 数字类型直接term查询, 可以用constant_score转filter, 避免算分
  3. # 当term查询的字段是数组类型时, 是包含关系, 而不是等值
  4. # 如果要求等值, 则需在索引中加一个计数字段, 然后通过bool查询叠加条件实现
  6. #数字类型 terms
  7. POST products/_search
  8. {
  9.   "query": {
  10.     "constant_score": {
  11.       "filter": {
  12.         "terms": {
  13.           "price": [
  14.             "20",
  15.             "30"
  16.           ]
  17.         }
  18.       }
  19.     }
  20.   }
  21. }
  23. #字符类型 terms
  24. POST products/_search
  25. {
  26.   "query": {
  27.     "constant_score": {
  28.       "filter": {
  29.         "terms": {
  30.           "productID.keyword": [
  31.             "QQPX-R-3956-#aD8",
  32.             "JODL-X-1937-#pV7"
  33.           ]
  34.         }
  35.       }
  36.     }
  37.   }
  38. }
  40. #数字 Range 查询
  41. GET products/_search
  42. {
  43.     "query" : {
  44.         "constant_score" : {
  45.             "filter" : {
  46.                 "range" : {
  47.                     "price" : {
  48.                         "gte" : 20,
  49.                         "lte"  : 30
  50.                     }
  51.                 }
  52.             }
  53.         }
  54.     }
  55. }
  57. # 日期 range
  58. POST products/_search
  59. {
  60.     "query" : {
  61.         "constant_score" : {
  62.             "filter" : {
  63.                 "range" : {
  64.                     "date" : {
  65.                       "gte" : "now-1y"
  66.                     }
  67.                 }
  68.             }
  69.         }
  70.     }
  71. }
  73. #exists查询
  74. POST products/_search
  75. {
  76.   "query": {
  77.     "constant_score": {
  78.       "filter": {
  79.         "exists": {
  80.           "field": "date"
  81.         }
  82.       }
  83.     }
  84.   }
  85. }
  87. # 查询不存在date字段的文档
  88. POST products/_search
  89. {
  90.   "query": {
  91.     "constant_score": {
  92.       "filter": {
  93.         "bool": {
  94.           "must_not": {
  95.             "exists": {
  96.               "field": "date"
  97.             }
  98.           }
  99.         }
  100.       }
  101.     }
  102.   }
  103. }

相关性算分

搜索的相关性算分, 描述了一个文档和查询语句匹配的程度. 打分的本质是排序, 需要把最符合用户需求的文档排在前面, es5后默认的相关性算分采用BM25.

  • 词频TF(Term Frequency): 检索词在一篇文档中出现的频率=检索词出现次数/文档总字数

    • 度量一条查询与结果文档相关性的简单方法, 是将搜索中每一个词的TF进行相加
    • Stop Word除外, 比如”的”, “地”, 不贡献相关度, 不应考虑它们的TF

  • 逆文档频率IDF, 词在所有文档中出现的越少, 值越大

    • DF: 检索词在所有文档中出现的频率
    • IDF: Inverse Document Frequency=log(全部文档数/检索词出现过的文档总数)

  • TF-IDF: 本质上将TF求和变成了加权求和

比如搜索”区块链的应用”, TF-IDF=TF(区块链)IDF(区块链)+TF(的)IDF(的)+TF(应用)*IDF(应用)

image.png
image.png

  1. # 可以打开explain了解算分
  2. POST movies/_search
  3. {
  4.   "explain": true, 
  5.   "query": {
  6.     "match": {
  7.       "title": {
  8.         "query": "Matrix reloaded",
  9.         "operator": "and"
  10.       }
  11.     }
  12.   }
  13. }
  15. # 通过Boosting来控制相关度
  16.     # boost>1, 提升相关性
  17.     # 0<boost<1, 降低相关性
  18.     # boost<0, 贡献负分
  20. # 1. 设置索引以及mapping时可以设置字段的boost
  21. # 2. 查询时可以设置, 如下
  22. POST testscore/_search
  23. {
  24.     "query": {
  25.         "boosting" : {
  26.             "positive" : {
  27.                 "term" : {
  28.                     "content" : "elasticsearch"
  29.                 }
  30.             },
  31.             "negative" : {
  32.                  "term" : {
  33.                      "content" : "like"
  34.                 }
  35.             },
  36.             "negative_boost" : 0.2
  37.         }
  38.     }
  39. }

Query&Filtering与多字符串多字段查询

  • Query: 查询, 有算分
  • Filter: 过滤, 不需要算分, 可以利用缓存, 提升性能

bool查询, 一个或多个查询子句组合

  • 子查询可以任意顺序
  • 可以嵌套多个
  • 如果没有must条件, 则should必须至少满足一个

image.png

  1. # bool查询
  2. POST /products/_search
  3. {
  4.   "query": {
  5.     "bool" : {
  6.       "must" : {
  7.         "term" : { "price" : "30" }
  8.       },
  9.       "filter": {
  10.         "term" : { "avaliable" : "true" }
  11.       },
  12.       "must_not" : {
  13.         "range" : {
  14.           "price" : { "lte" : 10 }
  15.         }
  16.       },
  17.       "should" : [
  18.         { "term" : { "productID.keyword" : "JODL-X-1937-#pV7" } },
  19.         { "term" : { "productID.keyword" : "XHDK-A-1293-#fJ3" } }
  20.       ],
  21.       "minimum_should_match" :1
  22.     }
  23.   }
  24. }
  26. #嵌套，实现了 should not 逻辑
  27. POST /products/_search
  28. {
  29.   "query": {
  30.     "bool": {
  31.       "must": {
  32.         "term": {
  33.           "price": "30"
  34.         }
  35.       },
  36.       "should": [
  37.         {
  38.           "bool": {
  39.             "must_not": {
  40.               "term": {
  41.                 "avaliable": "false"
  42.               }
  43.             }
  44.           }
  45.         }
  46.       ],
  47.       "minimum_should_match": 1
  48.     }
  49.   }
  50. }
  52. # bool查询嵌套的层级会影响算分
  53. POST /animals/_search
  54. {
  55.   "query": {
  56.     "bool": {
  57.       "should": [
  58.         { "term": { "text": "brown" }},
  59.         { "term": { "text": "red" }},
  60.         { "term": { "text": "quick"   }},
  61.         { "term": { "text": "dog"   }}
  62.       ]
  63.     }
  64.   }
  65. }
  67. POST /animals/_search
  68. {
  69.   "query": {
  70.     "bool": {
  71.       "should": [
  72.         { "term": { "text": "quick" }},
  73.         { "term": { "text": "dog"   }},
  74.         {
  75.           "bool":{
  76.             "should":[
  77.                { "term": { "text": "brown" }},
  78.                  { "term": { "text": "brown" }},
  79.             ]
  80.           }
  82.         }
  83.       ]
  84.     }
  85.   }
  86. }
  88. # Boosting Query
  89. POST news/_search
  90. {
  91.   "query": {
  92.     "boosting": {
  93.       "positive": {
  94.         "match": {
  95.           "content": "apple"
  96.         }
  97.       },
  98.       "negative": {
  99.         "match": {
  100.           "content": "pie"
  101.         }
  102.       },
  103.       "negative_boost": 0.5
  104.     }
  105.   }
  106. }

单字符串多字段查询, Dis Max Query

总结: 这种场景还是要用dis_max+tie_breaker合适

  1. # 文档1
  2. PUT /blogs/_doc/1
  3. {
  4.     "title": "Quick brown rabbits",
  5.     "body":  "Brown rabbits are commonly seen."
  6. }
  8. # 文档2
  9. PUT /blogs/_doc/2
  10. {
  11.     "title": "Keeping pets healthy",
  12.     "body":  "My quick brown fox eats rabbits on a regular basis."
  13. }
  15. # 上面两篇文档
  16. # 单字符串多字段查询如下示例, 通过bool查询来实现
  17. # 当bool查询的条件为should时, 此时会简单的将所有匹配的得分相加, 
  18. # 由于brown在第一篇文档中出现两次, 因此文档1优先于文档2, 但语义上文档2的brown fox才更接近
  19. POST /blogs/_search
  20. {
  21.     "query": {
  22.         "bool": {
  23.             "should": [
  24.                 { "match": { "title": "Brown fox" }},
  25.                 { "match": { "body":  "Brown fox" }}
  26.             ]
  27.         }
  28.     }
  29. }
  31. # 此时, 使用dis_max查询即可达到效果, dis_max会简单返回匹配更高者的分数, 得到文档2优先于1
  32. POST blogs/_search
  33. {
  34.     "query": {
  35.         "dis_max": {
  36.             "queries": [
  37.                 { "match": { "title": "Brown fox" }},
  38.                 { "match": { "body":  "Brown fox" }}
  39.             ]
  40.         }
  41.     }
  42. }
  44. # 另一种场景, 当查询的字段是Quick pets时, dis_max算法会使得2个文档评分一样
  45. POST blogs/_search
  46. {
  47.     "query": {
  48.         "dis_max": {
  49.             "queries": [
  50.                 { "match": { "title": "Quick pets" }},
  51.                 { "match": { "body":  "Quick pets" }}
  52.             ]
  53.         }
  54.     }
  55. }
  57. # 这时, 可以引入tie_breaker, tie_breker决定了剩余匹配的贡献度, 
  58. # 引入后匹配了2个单词的文档2评分就会高于文档1
  59. POST blogs/_search
  60. {
  61.     "query": {
  62.         "dis_max": {
  63.             "queries": [
  64.                 { "match": { "title": "Quick pets" }},
  65.                 { "match": { "body":  "Quick pets" }}
  66.             ],
  67.             "tie_breaker": 0.2
  68.         }
  69.     }
  70. }

单字符串多字段查询: Multi Match

三种场景:

  1. 最佳字段(Best Fields)

当字段之间互相竞争, 又相互关联, 评分来自最匹配字段

补充: 效果就相当于上面的dis_max query

  1. POST blogs/_search
  2. {
  3.     "query": {
  4.         "dis_max": {
  5.             "queries": [
  6.                 { "match": { "title": "Quick pets" }},
  7.                 { "match": { "body":  "Quick pets" }}
  8.             ],
  9.             "tie_breaker": 0.2
  10.         }
  11.     }
  12. }
  14. POST blogs/_search
  15. {
  16.   "query": {
  17.     "multi_match": {
  18.       "type": "best_fields",
  19.       "query": "Quick pets",
  20.       "fields": ["title","body"],
  21.       "tie_breaker": 0.2,
  22.       "minimum_should_match": "20%"
  23.     }
  24.   }
  25. }
  1. 多数字段(Most Fields)

处理英文内容时, 常见手段是, 在主字段(English Analyzer), 抽取词干, 加入同义词, 以匹配更多的文档, 相同的文本, 加入子字段(Standard Analyzer), 以提供更加精确的匹配, 其他字段作为匹配文档提高相关度的信号, 匹配字段越多则越好

  1. # standard分词器不会对单词进行处理
  2. GET /_analyze
  3. {
  4.   "analyzer":"standard",
  5.   "text":"barking dogs"
  6. }
  7. ------------------------
  8. {
  9.   "tokens" : [
  10.     {
  11.       "token" : "barking",
  12.       "start_offset" : 0,
  13.       "end_offset" : 7,
  14.       "type" : "<ALPHANUM>",
  15.       "position" : 0
  16.     },
  17.     {
  18.       "token" : "dogs",
  19.       "start_offset" : 8,
  20.       "end_offset" : 12,
  21.       "type" : "<ALPHANUM>",
  22.       "position" : 1
  23.     }
  24.   ]
  25. }
  27. # english分词器会去除单词的时态, 单复数等特征
  28. GET /_analyze
  29. {
  30.   "analyzer":"english",
  31.   "text":"barking dogs"
  32. }
  33. ------------------------
  34. {
  35.   "tokens" : [
  36.     {
  37.       "token" : "bark",
  38.       "start_offset" : 0,
  39.       "end_offset" : 7,
  40.       "type" : "<ALPHANUM>",
  41.       "position" : 0
  42.     },
  43.     {
  44.       "token" : "dog",
  45.       "start_offset" : 8,
  46.       "end_offset" : 12,
  47.       "type" : "<ALPHANUM>",
  48.       "position" : 1
  49.     }
  50.   ]
  51. }

案例

  1. # 现有titles这样的索引, 对title字段设定了english分词器
  2. PUT /titles
  3. {
  4.   "mappings": {
  5.     "properties": {
  6.       "title": {
  7.         "type": "text",
  8.         "analyzer": "english"
  9.       }
  10.     }
  11.   }
  12. }
  14. POST titles/_bulk
  15. { "index": { "_id": 1 }}
  16. { "title": "My dog barks" }
  17. { "index": { "_id": 2 }}
  18. { "title": "I see a lot of barking dogs on the road " }
  20. # 写入上面两篇文档后, 有如下搜索, 由于两篇文档都有俩单词匹配, 且第一篇文档更短, 
  21. # 因此文档1优先于文档2, 但是明显文档2才是我们想要的
  22. GET titles/_search
  23. {
  24.   "query": {
  25.     "match": {
  26.       "title": "barking dogs"
  27.     }
  28.   }
  29. }
  31. # 解决方式, 修改mapping, 对title字段, 添加一个使用standard分词器的子字段std
  32. DELETE /titles
  33. PUT /titles
  34. {
  35.     "settings": { "number_of_shards": 1 },
  36.     "mappings": {
  37.         "my_type": {
  38.             "properties": {
  39.                 "title": {
  40.                     "type":     "string",
  41.                     "analyzer": "english",
  42.                     "fields": {
  43.                         "std":   {
  44.                             "type":     "string",
  45.                             "analyzer": "standard"
  46.                         }
  47.                     }
  48.                 }
  49.             }
  50.         }
  51.     }
  52. }
  54. # 再使用most_fields的multi_match查询, 此时文档2的title以及子字段都有匹配, 因此优先于文档1
  55. GET /titles/_search
  56. {
  57.    "query": {
  58.         "multi_match": {
  59.             "query":  "barking dogs",
  60.             "type":   "most_fields",
  61.             "fields": [ "title", "title.std" ]
  62.         }
  63.     }
  64. }

专业解释如下:
image.png

  1. 混合字段(Cross Field)

对于某些实体, 例如人名, 地址, 图书信息, 需要在多个字段中确定信息, 单个字段只能作为整体的一部分, 希望在任何这些列出的字段中找到尽可能多的词

  1. # Cross Field的multi_match常用于跨字段查询, 比如地区字段如下
  2. # 这种情形的另一个解决方式是使用copy_to, 新增一个字段, 但是会占用更多索引空间
  3. # 此外使用Cross Field还可以设定每个字段的权重
  4. PUT address/_doc/1
  5. {
  6.   "street": "5 Poland Street",
  7.   "city": "London",
  8.   "country" : "UK",
  9.   "postcode": "W1V 3DG"
  10. }
  13. POST address/_search
  14. {
  15.   "query": {"multi_match": {
  16.     "query": "Poland Street W1V",
  17.     "type": "cross_fields",
  18.     "operator": "and", 
  19.     "fields": ["street","city","country","postcode"]
  20.   }}
  21. }