Elasticsearch搜索（API和DSL）

发表于 | 分类于

搜索API

搜索API 端点地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
GET /bank/accounts/_search?q=account_number:222

#从索引bank里面搜索字段firstname为Rachelle的记录

GET /bank/_search?q=firstname:Rachelle

#从索引bank、user里面搜索字段firstname为Rachelle的记录

GET /bank,user/_search?q=firstname:Rachelle

#从所有索引里面搜索字段firstname为Rachelle的记录
GET /_all/_search?q=firstname:Rachelle
GET /_search?q=firstname:Rachelle

#说明：搜索的端点地址可以是多索引多mapping type的。
#搜索的参数可作为URI请求参数给出，也可用 request body 给出

URI 搜索方式通过URI参数来指定查询相关参数。

GET /bank/_search?q=account_number:222

可用的参数请参考： https://www.elastic.co/guide/en/elasticsearch/reference/current/search-uri-request.html

查询结果说明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
{
  "took": 3,#耗时（ms）
  "timed_out": false,#是否超时
  "_shards": {#查询了多少分片
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {#命中结果
    "total": 1, #命中总数
    "max_score": 1,#最高得分
    "hits": [#本页结果文档数组
      {
        "_index": "bank",
        "_type": "accounts", 
        "_id": "222",
        "_score": 1,
        "_source": {
          "account_number": 222,
          "balance": 14764,
          "firstname": "Rachelle",
          "lastname": "Rice",
          "age": 36,
          "gender": "M",
          "address": "333 Narrows Avenue",
          "employer": "Enaut",
          "email": "rachellerice@enaut.com",
          "city": "Wright",
          "state": "AZ"
        }
      }
    ]
  }
}

特殊的查询参数用法

有多少文档匹配某个查询：GET /bank/_search?q=city:b*&size=0

有没有文档匹配某个查询：GET /bank/_search?q=city:b*&size=0&terminate_after=1 #”terminated_early”: true,

Request body Search

Request body 搜索方式以JSON格式在请求体中定义查询 query。请求方式可以是 GET 、POST 。

1
2
3
4
5
6
GET /bank/_search
{
    "query":{
        "term":{"firstname":"Effie"}
    }
}

可用的参数:

1
2
3
4
5
6
7
timeout：请求超时时长，限定在指定时长内响应（即使没查完）；
from： 分页的起始行，默认0；
size：分页大小；
request_cache：是否缓存请求结果，默认true。
terminate_after：限定每个分片取几个文档。如果设置，则响应将有一个布尔型字段terminated_early来指示查询执行是否实际已经terminate_early。缺省为no terminate_after；
search_type：查询的执行方式，可选值dfs_query_then_fetch or query_then_fetch ，默认： query_then_fetch ；
batched_reduce_size：一次在协调节点上应该减少的分片结果的数量。如果请求中的潜在分片数量可能很大，则应将此值用作保护机制以减少每个搜索请求的内存开销。

query 元素定义查询

query 元素用Query DSL 来定义查询。

1
2
3
4
5
6
GET /_search
{
    "query" : {
        "term" : {"firstname":"Effie"}
    }
}

指定返回哪些内容

source filter 对_source字段进行选择

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
GET /_search
{
    "_source": false,
    "query" : {
        "term" : {"firstname":"Virginia"}
    }
}

#通配符查询

GET /_search
{
    "_source": [ "obj1.*", "obj2.*" ],
    "query" : {
        "term" : {"firstname":"Virginia"}
    }
}

GET /_search
{
    "_source": "obj.*",
    "query" : {
        "term" : {"firstname":"Virginia"}
    }
}

#包含什么不包含什么
GET /_search
{
    "_source": {
        "includes": [ "obj1.*", "obj2.*" ],
        "excludes": [ "*.description" ]
    },
    "query" : {
        "term" : {"firstname":"Virginia"}
    }
}

stored_fields 来指定返回哪些stored字段

1
2
3
4
5
6
7
GET /_search
{
    "stored_fields" : ["account_number", "age"],
    "query" : {
        "term" : {"firstname":"Virginia"}
    }
}

说明：* 可用来指定返回所有存储字段

docValue Field 返回存储了docValue的字段值

1
2
3
4
5
6
7
GET /_search
{
    "query" : {
        "match_all": {}
    },
    "docvalue_fields" : ["account_number", "age"]
}

version 来指定返回文档的版本字段

1
2
3
4
5
6
7
GET /_search
{
    "version": true,
    "query" : {
        "term" : {"firstname":"Virginia"}
    }
}

explain 返回文档的评分解释

1
2
3
4
5
6
7
GET /_search
{
    "explain": true,
    "query" : {
        "term" : {"firstname":"Virginia"}
    }
}

Script Field 用脚本来对命中的每个文档的字段进行运算后返回

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
GET /bank/_search
{
  "query": {
    "match_all": {}
  },
  "script_fields": {
    "test1": {
      "script": {
        "lang": "painless",
        "source": "doc['balance'].value * 2"
      }
    },
    "test2": {
      "script": {
        "lang": "painless",
        "source": "doc['age'].value * params.factor",
        "params": {
          "factor": 2
        }
      }
    } }}

说明：params _source 取 _source字段值，官方推荐使用doc，理由是用doc效率比取_source 高

min_score 限制最低评分得分

1
2
3
4
5
6
7
GET /_search
{
    "min_score": 0.5,
    "query" : {
        "term" : {"firstname": "Virginia"}
    }
}

post_filter 后置过滤：在查询命中文档、完成聚合后，再对命中的文档进行过滤。

如：要在一次查询中查询品牌为gucci且颜色为红色的shirts，同时还要得到gucci品牌各颜色的shirts的分面统计。

创建索引并指定mappping：

1
2
3
4
5
6
7
8
9
10
11
12
PUT /shirts
{
    "mappings": {
        "_doc": {
            "properties": {
                "brand": { "type": "keyword"},
                "color": { "type": "keyword"},
                "model": { "type": "keyword"}
            }
        }
    }
}

往索引里面放入文档即类似数据库里面的向表插入一行数据，并立即刷新

1
2
3
4
5
6
7
8
9
10
11
12
PUT /shirts/_doc/1?refresh
{
    "brand": "gucci",
    "color": "red",
    "model": "slim"
}
PUT /shirts/_doc/2?refresh
{
    "brand": "gucci",
    "color": "green",
    "model": "seec"
}

执行查询：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
GET /shirts/_search
{
  "query": {
    "bool": {
      "filter": {
        "term": { "brand": "gucci" } 
      }
    }
  },
  "aggs": {
    "colors": {
      "terms": { "field": "color" } 
    }
  },
  "post_filter": { 
    "term": { "color": "red" }
  }
}

sort 排序

可以指定按一个或多个字段排序。也可通过_score指定按评分值排序，_doc按索引顺序排序。默认是按相关性评分从高到低排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
GET /bank/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [{
      "age": { "order": "desc" }    
    },
    {
      "balance": { "order": "asc" }  
    },
    "_score"
  ]
}

说明：order 值：asc、desc。如果不给定，默认是asc，_score默认是desc

结果中每个文档会有排序字段值给出

** 多值字段排序 **

对于值是数组或多值的字段，也可进行排序，通过mode参数指定按多值的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
PUT /my_index/_doc/1?refresh
{
   "product": "chocolate",
   "price": [20, 4]
}

POST /_search
{
   "query" : {
      "term" : { "product" : "chocolate" }
   },
   "sort" : [
      {"price" : {"order" : "asc", "mode" : "avg"}}
   ]
}

** Missing values 缺失该字段的文档 **

missing 的值可以是 _last, _first

1
2
3
4
5
6
7
8
9
GET /_search
{
    "sort" : [
        { "price" : {"missing" : "_last"} }
    ],
    "query" : {
        "term" : { "product" : "chocolate" }
    }
}

** 地理空间距离排序 **

官方文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-sort.html#geo-sorting

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
GET /_search
{
    "sort" : [
        {
            "_geo_distance" : {
                "pin.location" : [-70, 40],
                "order" : "asc",
                "unit" : "km",
                "mode" : "min",
                "distance_type" : "arc"
            }
        }
    ],
    "query" : {
        "term" : { "user" : "kimchy" }
    }
}

参数说明：

1
2
3
4
_geo_distance 距离排序关键字
pin.location是 geo_point 类型的字段
distance_type：距离计算方式 arc球面 、plane 平面。
unit: 距离单位 km 、m 默认m

** Script Based Sorting 基于脚本计算的排序 **

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
GET /_search
{
    "query" : {
        "term" : { "user" : "kimchy" }
    },
    "sort" : {
        "_script" : {
            "type" : "number",
            "script" : {
                "lang": "painless",
                "source": "doc['field_name'].value * params.factor",
                "params" : {
                    "factor" : 1.1
                }
            },
            "order" : "asc"
        }
    }
}

折叠

用 collapse指定根据某个字段对命中结果进行折叠

1
2
3
4
5
6
7
8
9
10
GET /bank/_search
{
    "query": {
        "match_all": {}
    },
    "collapse" : {
        "field" : "age" 
    },
    "sort": ["balance"] 
}

** 高级折叠 **

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 指定inner_hits来解释折叠 
# 自命名"name": "details",  
# 指定每组取几个文档 "size": 5, 
# 组内排序 "sort": [{ "balance": "asc" }]  
# 指定组查询的并发数  "max_concurrent_group_searches": 4 

GET /bank/_search
{
    "query": {
        "match_all": {}
    },
    "collapse" : {
        "field" : "age" ,
        
        "inner_hits": {
            "name": "details", 
            "size": 5,   
            "sort": [{ "balance": "asc" }] 
        },
        "max_concurrent_group_searches": 4  
    },
    "sort": ["balance"] 
}

分页

** from and size **

1
2
3
4
5
6
7
GET /bank/_search
{
    "from" : 0, "size" : 10,
    "query" : {
        "term" : { "firstname" : "Virginia" }
    }
}

注：搜索请求耗用的堆内存和时间与 from + size 大小成正比。分页越深耗用越大，为了不因分页导致OOM或严重影响性能，ES中规定from + size 不能大于索引setting参数 index.max_result_window 的值，默认值为 10,000。

** Search after 在指定文档后取文档， 可用于深度分页 **
首次查询第一页

1
2
3
4
5
6
7
8
9
10
11
12
13
GET bank/_search
{
    "size": 10,
    "query": {
        "match" : {
            "age" : "37"
        }
    },
    "sort": [
        {"account_number": "asc"},
        {"balance": "desc"}
    ]
}

后续页的查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
GET bank/_search
{
    "size": 10,
    "query": {
        "match" : {
            "age" : "37"
        }
    },
    "search_after": [44, 34487],
    "sort": [
        {"account_number": "asc"},
        {"balance": "desc"}
    ]
}

使用search_after，要求查询必须指定排序，并且这个排序组合值每个文档唯一（最好排序中包含_id字段）。 search_after的值用的就是这个排序值。 用search_after时 from 只能为0、-1。

高亮

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
GET /bank/_search
{
  "query": {
    "match": {
      "lastname": "Justice"
    }
  },
  "highlight": {
    "fields": {
      "firstname": {},
      "lastname": {}
    }
  }
}

结果：
{
  "took": 0,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 1,
    "max_score": 4.8520303,
    "hits": [
      {
        "_index": "bank",
        "_type": "accounts",
        "_id": "59",
        "_score": 4.8520303,
        "_source": {
          "account_number": 59,
          "balance": 37728,
          "firstname": "Malone",
          "lastname": "Justice",
          "age": 37,
          "gender": "F",
          "address": "721 Russell Street",
          "employer": "Emoltra",
          "email": "malonejustice@emoltra.com",
          "city": "Trucksville",
          "state": "HI"
        },
        "highlight": {
          "lastname": [
            "<em>Justice</em>"
          ]
        }
      }
    ]
  }
}

多字段高亮，在highlight中加入：”require_field_match”: false,即可。

指定高亮标签

1
2
3
4
5
6
7
8
9
10
11
12
...
  "highlight": {
    "require_field_match": false,
    "fields": {
      "firstname": {
        "pre_tags":["<strong>"],
        "post_tags": ["</strong>"]
      },
      "firstname": {}
    }
  }
}

Profile 为了调试、优化

查询上加入上 profile 来获得详细的执行步骤、耗时信息。

1
2
3
4
5
6
7
8
9
GET /bank/_search
{
  "profile": true,
  "query": {
    "match": {
      "lastname": "Justice"
    }
  }
}

count api 查询数量

1
2
3
4
5
6
7
8
GET /bank/accounts/_count?q=firstname:Malone
# 或 
GET /bank/accounts/_count
{
    "query" : {
        "term" : { "firstname" : "Malone" }
    }
}

validate api

用来检查我们的查询是否正确，以及查看底层生成查询。

GET /bank/_validate/query?q=firstname:Malone

校验查询

1
2
3
4
5
6
7
8
9
GET /bank/accounts/_validate/query
{
  "query": {
    "query_string": {
      "query": "firstname:Malone",
      "lenient": false
    }
  }
}

获得查询解释

1
2
3
4
5
6
7
8
9
GET /bank/accounts/_validate/query?explain=true
{
  "query": {
    "query_string": {
      "query": "firstname:Malone",
      "lenient": false
    }
  }
}

** 用rewrite获得比explain 更详细的解释 **

1
2
3
4
5
6
7
8
9
GET /bank/accounts/_validate/query?rewrite=true
{
  "query": {
    "query_string": {
      "query": "firstname:Malone",
      "lenient": false
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
GET /bank/accounts/_validate/query?rewrite=true
{
  "query": {
    "more_like_this": {	
      "like": {
        "_id": "3"
      },
      "boost_terms": 1
    }
  }
}

获得所有分片上的查询解释

1
2
3
4
5
6
7
8
GET /bank/_doc/_validate/query?rewrite=true&all_shards=true
{
  "query": {
    "match": {
        "firstname": "Virginia"
    }
  }
}

Explain api

获得某个查询的评分解释，及某个文档是否被这个查询命中。

1
2
3
4
5
6
GET /bank/accounts/0/_explain
{
  "query" : {
      "match" : {"firstname": "Virginia"}
  }
}

官网链接：https://www.elastic.co/guide/en/elasticsearch/reference/current/search-explain.html

Search Shards API

让我们可以获取查询的索引分片节点情况

GET /bank/_search_shards

指定routing值的查询将在哪些分片节点上执行

GET /bank/_search_shards?routing=25,56

这里使用默认的路由，就是文档ID

Search Template 查询模板

注册一个模板

1
2
3
4
5
6
7
8
9
10
11
12
13
POST _scripts/bank_accounts_tm1
{
    "script": {
        "lang": "mustache",
        "source": {
            "query": {
                "match": {
                    "email": "{{query_string}}"
                }
            }
        }
    }
}

使用模板进行查询

1
2
3
4
5
6
7
GET _search/template
{
    "id": "bank_accounts_tm1", 
    "params": {
        "query_string": "virginiaayala@filodyne.com"
    }
}

Query DSL

Domain Specific Language：领域特定语言

Elasticsearch 提供了一个完整的 query DSL，并且是 JSON 形式的。它和 AST 比较类似，并且包含两种类型的语句：

  • 叶子查询语句（Leaf Query)，用于查询某个特定的字段，如 match , term 或 range 等

  • 复合查询语句 (Compound query clauses) 用于合并其他的叶查询或复合查询语句，也就是说复合语句之间可以嵌套，用来表示一个复杂的单一查询

    1
    2
    3
    ​ ** DSL ** （domain-specific language），领域特定语言指的是专注于某个应用程序领域的计算机语言，又译作领域专用语言。不同于普通的跨领域通用计算机语言(GPL)，领域特定语言只用在某些特定的领域。
    ​ ** AST** （abstract syntax tree), 抽象语法树是源代码的抽象语法结构的树形表现形式。树上的每个节点都表示源代码中的一种结构。之所以说语法是“抽象”的，是因为这里的语法并不会表示出真实语法中出现的每个细节。比如，嵌套括号被隐含在树的结构中，并没有以节点的形式呈现；而类似于if-condition-then这样的条件跳转语句，可以使用带有两个分支的节点来表示。
    ——百度百科
    • Query and filter context **
      一个查询语句究竟具有什么样的行为和得到什么结果，主要取决于它到底是处于查询上下文(Query Context) 还是过滤上下文(Filter Context)。两者有很大区别，我们来看下：

  • Query context 查询上下文：这种语句在执行时既要计算文档是否匹配，还要计算文档相对于其他文档的匹配度有多高，匹配度越高，_score 分数就越高

  • Filter context 过滤上下文：过滤上下文中的语句在执行时只关心文档是否和查询匹配，不会计算匹配度，也就是得分。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
GET /_search
{
  "query": { 
    "bool": { 
      "must": [
        { "match": { "title":   "Search"        }}, 
        { "match": { "content": "Elasticsearch" }}  
      ],
      "filter": [ 
        { "term":  { "status": "published" }}, 
        { "range": { "publish_date": { "gte": "2015-01-01" }}} 
      ]
    }
  }
}

query 参数表示整个语句是处于 query context 中
bool 和 match 语句被用在 query context 中，也就是说它们会计算每个文档的匹配度（_score)
filter 参数则表示这个子查询处于 filter context 中
filter 语句中的 term 和 range 语句用在 filter context 中，它们只起到过滤的作用，并不会计算文档的得分。

Match all query

1
2
3
4
5
6
7
8
9
10
11
12
13
14
GET /_search
{
    "query": {
        "match_all": {}
    }
}

# 什么都不查 
GET /_search
{
    "query": {
        "match_none": {}
    }
}

全文查询 Full text queries

全文查询，用于对分词的字段进行搜索。会用查询字段的分词器对查询的文本进行分词生成查询。可用于短语查询、模糊查询、前缀查询、临近查询等查询场景。

官网链接：https://www.elastic.co/guide/en/elasticsearch/reference/current/full-text-queries.html

match query

全文查询的标准查询，它可以对一个字段进行模糊、短语查询。 match queries 接收 text/numerics/dates, 对它们进行分词分析, 再组织成一个boolean查询。可通过operator 指定bool组合操作（or、and 默认是 or ）， 以及minimum_should_match 指定至少需多少个should(or)字句需满足。还可用ananlyzer指定查询用的特殊分析器。包括模糊查询(fuzzy matching) 或者临近查询(proximity queries)。

新增文档：

1
2
3
4
5
6
7
8
9
10
11
PUT /ftq/_doc/1
{
  "title": "lucene solr and elasticsearch",
  "content": "lucene solr and elasticsearch for search"
}

PUT /ftq/_doc/2
{
  "title": "java spring boot",
  "content": "lucene is writerd by java"
}

查询：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
GET ftq/_search
{
  "query": {
    "match": {
      "title": "lucene java"  #分词后用or
    }
  }
}

GET ftq/_search
{
  "query": {
    "match": {
      "title": {
        "query": "lucene java",
        "operator": "and"  #指定分词后用and
      }
    }
  }
}

** 模糊查询，可以指定fuzziness最大编辑数 **

1
2
3
最大编辑数为2，说明query字符串中分词后，每个词允许编辑两次单个字符，可删除、新增、修改字符
fuzziness 参数可以被设置为 AUTO，此时字符串只有 1 到 2 个字符时是 0；字符串有 3 、4 或者 5 个字符时是 1；字符串大于 5 个字符时是 2
有时编辑距离 2 仍然是太多了，返回的结果似乎并不相关。 把最大 fuzziness 设置为 1 ，可以得到更好的结果和更好的性能
1
2
3
4
5
6
7
8
9
10
11
GET ftq/_search
{
  "query": {
    "match": {
      "title": {
        "query": "ucen elatic",
        "fuzziness": 2
      }
    }
  }
}

** 指定最少需满足两个词匹配 ** 

1
2
3
4
5
6
7
8
9
10
11
12
GET ftq/_search
{
  "query": {
    "match": {
      "content": {
        "query": "ucen elatic java",
        "fuzziness": 2,
        "minimum_should_match": 2
      }
    }
  }
}

** max_expansions 指定模糊匹配的最大词项数，默认是50。**

比如：反向索引中有 100 个词项与 ucen 模糊匹配，只选用前50 个。

1
2
3
4
5
6
7
8
9
10
11
12
13
GET ftq/_search
{
  "query": {
    "match": {
      "content": {
        "query": "ucen elatic java",
        "fuzziness": 2,
        "minimum_should_match": 2,
        "max_expansions ": 50
      }
    }
  }
}

match_phrase query

match_phrase 查询用来对一个字段进行短语查询，可以指定 analyzer、slop移动因子。和 match 查询比较类似，但是它会保留包含所有搜索词项，且位置与搜索词项相同的文档。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#短语查询
GET ftq/_search
{
  "query": {
    "match_phrase": {
      "title": "lucene solr"
    }
  }
}

#指定移动因子  
GET ftq/_search
{
  "query": {
    "match_phrase": {
      "title": {
        "query": "lucene elasticsearch",
        "slop": 2
      }
    }
  }
}

match_phrase_prefix query

是一种输入即搜索(search-as-you-type) 的查询，它和 match_phrase 比较类似，区别就是会将查询字符串的最后一个词作为前缀来使用。

1
2
3
4
5
6
7
8
GET /_search
{
    "query": {
        "match_phrase_prefix" : {
            "message" : "quick brown f"
        }
    }
}

指定前缀匹配选用的最大词项数量

1
2
3
4
5
6
7
8
9
10
11
GET /_search
{
    "query": {
        "match_phrase_prefix" : {
            "message" : {
                "query" : "quick brown f",
                "max_expansions" : 10
            }
        }
    }
}

multi_match query

需要在多个字段上进行文本搜索，可用multi_match 。 multi_match在 match的基础上支持对多个字段进行文本查询。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
GET ftq/_search
{
  "query": {
    "multi_match" : {
      "query":    "lucene java", 
      "fields": [ "title", "content" ] 
    }
  }
}

还可以使用*匹配多个字段：

GET ftq/_search
{
  "query": {
    "multi_match" : {
      "query":    "lucene java", 
      "fields": [ "title", "cont*" ] 
    }
  }
}

query_string query

支持复杂的 Lucene query String 语法，可以直接用lucene查询语法写一个查询串进行查询，ES中接到请求后，通过查询解析器解析查询串生成对应的查询。使用它要求掌握lucene的查询语法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 单字段
GET /_search
{
    "query": {
        "query_string" : {
            "default_field" : "content",
            "query" : "this AND that OR thus"
        }
    }
}
# 多字段通配符查询
GET /_search
{
    "query": {
        "query_string" : {
            "fields" : ["content",  "name.*^5"],
            "query" : "this AND that OR thus"
        }
    }
}

common terms query

common 常用词查询

1
2
3
4
5
6
7
8
9
问1、什么是停用词？索引时做停用词处理的目的是什么？
不再使用的词，做停用词处理的目的是提高索引的效率，去掉不需要的索引操作，即停用词不需要索引

问2、如果在索引时应用停用词处理，下面的两个查询会查询什么词项？
the brown fox—— brown fox
not happy——happy

问3、索引时应用停用词处理对搜索精度是否有影响？如果不做停用词处理又会有什么影响？如何协调这两个问题？如何保证搜索的精确度又兼顾搜索性能？
索引时应用停用词处理对搜索精度有影响，不做停用词处理又会影响索引的效率，要协调这两个问题就必须要使用tf-idf 相关性计算模型

** tf-idf 相关性计算模型 **
tf：term frequency 词频 ：指一个词在一篇文档中出现的频率。

如“世界杯”在文档A中出现3次，那么可以定义“世界杯”在文档A中的词频为3。请问在一篇3000字的文章中出现“世界杯”3次和一篇150字的文章中出现3词，哪篇文章更是与“世界杯”有关的。也就是说，简单用出现次数作为频率不够准确。那就用占比来表示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
问：tf值越大是否就一定说明这个词更相关？
 不是，出现太多了说明不重要

 说明：tf的计算不一定非是这样的，可以定义不同的计算方式。
	df：document frequency 词的文档频率 ：指包含某个词的文档数（有多少文档中包含这个词）。 df越大的词越常见，哪些词会是高频词？

问：词的df值越大说明这个词在这个文档集中是越重要还是越不重要？
 越不重要

问：词t的tf高，在文档集中的重要性也高，是否说明文档与该词越相关？举例：整个文档集中只有3篇文档中有“世界杯”，文档A中就出现了“世界杯”好几次。 
 不能说明文档与该词越相关

问：如何用数值体现词t在文档集中的重要性？df可以吗？
 不可以

idf：inverse document frequency 词的逆文档频率 ：用来表示词在文档集中的重要性。文档总数/ df ，df越小，词越重要，这个值会很大，那就对它取个自然对数，将值映射到一个较小的取值范围。

说明： +1 是为了避免除0（即词t在文档集中未出现的情况）

tf-idf 相关性性计算模型：tf-idf t = tf t,d * idf t

说明： tf-idf 相关性性计算模型的值为词频（ tf t,d）乘以词的逆文档频率（idf t）

** Common terms query **

common 区分常用（高频）词查询让我们可以通过cutoff_frequency来指定一个分界文档频率值，将搜索文本中的词分为高频词和低频词，低频词的重要性高于高频词，先对低频词进行搜索并计算所有匹配文档相关性得分；然后再搜索和高频词匹配的文档，这会搜到很多文档，但只对和低频词重叠的文档进行相关性得分计算（这可保证搜索精确度，同时大大提高搜索性能），和低频词累加作为文档得分。实际执行的搜索是 必须包含低频词 + 或包含高频词。

1
2
3
思考：这样处理下，如果用户输入的都是高频词如 “to be or not to be”结果会是怎样的？你希望是怎样的？
优化：如果都是高频词，那就对这些词进行and 查询。
进一步优化：让用户可以自己定对高频词做and/or 操作，自己定对低频词进行and/or 操作；或指定最少得多少个同时匹配
1
2
3
4
5
6
7
8
9
10
11
GET /_search
{
    "query": {
        "common": {
            "address": {
                "query": "171 Putnam Avenue",
                "cutoff_frequency": 0.001
            }
        }
    }
}

说明：cutoff_frequency : 值大于1表示文档数，0-1.0表示占比。 此处界定 文档频率大于 0.1%的词为高频词。

1
2
3
4
5
6
7
8
9
10
11
12
GET /_search
{
    "query": {
        "common": {
          "address": {
                "query": "171 Putnam Avenue",
                "cutoff_frequency": 0.001,
                "low_freq_operator": "and"
            }
        }
    }
}

说明：low_freq_operator指定对低频词做与操作。

可用参数：minimum_should_match (high_freq, low_freq), low_freq_operator (default “or”) and high_freq_operator (default “or”)、 boost and analyzer

1
2
3
4
5
6
7
8
9
10
11
12
GET /_search
{
    "query": {
        "common": {
            "address": {
                "query": "171 Putnam Avenue",
                "cutoff_frequency": 0.001,
                "minimum_should_match": 2
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
GET /_search
{
    "query": {
        "common": {
            "address": {
                "query": "171 Putnam Avenue",
                "cutoff_frequency": 0.001,
                "minimum_should_match": {
                    "low_freq" : 2,
                    "high_freq" : 3
                }
            }
        }
    }
}

simple_query_string query

简化版的 query_string ，simple_query_string 查同 query_string 查询一样用lucene查询语法写查询串，较query_string不同的地方：更小的语法集；查询串有错误，它会忽略错误的部分，不抛出错误。更适合给用户使用。

1
2
3
4
5
6
7
8
9
10
GET /_search
{
  "query": {
    "simple_query_string" : {
        "query": "\"fried eggs\" +(eggplant | potato) -frittata",
        "fields": ["title^5", "body"],
        "default_operator": "and"
    }
  }
}

词项查询

https://www.elastic.co/guide/en/elasticsearch/reference/current/term-level-queries.html

term/terms query

term 查询用于查询指定字段包含某个词项的文档。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
POST _search
{
  "query": {
    "term" : { "address" : "Putnam" } 
  }
}

# 权重boost 
POST _search
{
  "query": {
    "term": {
            "balance": {"value": 40540,"boost": 2}
          }
  }
}

#  terms 查询用于查询指定字段包含某些词项的文档。
POST _search
{
  "query": {
    "terms" : { "address" : ["171","Putnam"] } 
  }
}

Terms 还可以查询支持嵌套查询的方式来获得查询词项，相当于 in (select term from other)

1
2
3
4
5
6
7
8
9
10
11
12
13
GET /bank/_search
{
  "query": {
    "terms" : {
        "firstname" : {
          "index": "bank",
          "type": "accounts",
          "id": "25",
          "path": "followers"
        }
    }  
  }
}

range query

范围查询

1
2
3
4
5
gte：大于等于
gt：大于
lte：小于等于
lt：小于
boost：查询权重
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
GET _search
{
    "query": {
        "range" : {
            "age" : {
                "gte" : 10,
                "lte" : 20,
                "boost" : 2.0
            }
        }
    }
}

GET _search
{
    "query": {
        "range" : {
            "date" : {
                "gte" : "now-1d/d",  #当前时间减1天后转成天数
                "lt" :  "now/d"  #当前时间转成条数
            }
        }
    }
}

GET _search
{
    "query": {
        "range" : {
            "born" : {
                "gte": "01/01/2012",
                "lte": "2013",
                "format": "dd/MM/yyyy||yyyy"
            }
        }
    }
}

时间舍入||说明：

1
2
3
4
gt：大于的情况下，四舍五入，比如2014-11-18||/M变成2014-11-30T23:59:59:999，不包含整个月
gte：大于等于的情况下，向下取整，比如2014-11-18||/M变成2014-11-01，包含整个月
lt：小于的情况下，向下取整，比如2014-11-18||/M变成2014-11-01，不包含整个月
lte：小于等于的情况下，四舍五入，比如2014-11-18||/M变成2014-11-30T23:59:59:999，包含整个月

exits query

查询指定字段值不为空的文档。相当 SQL 中的 column is not null

1
2
3
4
5
6
GET /_search
{
    "query": {
        "exists" : { "field" : "balance" }
    }
}

prefix query 词项前缀查询

1
2
3
4
5
GET /_search
{ "query": {
    "prefix" : { "address" : "171" }
  }
}

wildcard query 通配符查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
GET /_search
{
    "query": {
        "wildcard" : { "lastname" : "A*a*" }
    }
}
# 加权 
GET /_search
{
  "query": {
    "wildcard": {
      "lastname": {
        "value": "ki*y",
        "boost": 2
      }
    }
  }
 }

regexp query 正则查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
GET /_search
{
    "query": {
        "regexp":{
            "name.first": "s.*y"
        }
    }
}

GET /_search
{
    "query": {
        "regexp":{
            "name.first":{
                "value":"s.*y",
                "boost":1.2
            }
        }
    }
}

正则语法参考：https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-regexp-query.html#regexp-syntax

fuzzy query 模糊查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
GET /_search
{
    "query": {
       "fuzzy" : { "address" : "Avenue" }
    }
}

GET /_search
{
    "query": {
        "fuzzy" : {
            "address" : {
                "value": "Avenue",
                "boost": 1.0,
                "fuzziness": 2,
                "prefix_length": 0,
                "max_expansions": 100
            }
        }
    }
}

ids 根据文档id查询

1
2
3
4
5
6
7
8
9
GET /_search
{
    "query": {
        "ids" : {
            "type" : "_doc",
            "values" : ["1", "4", "100"]
        }
    }
}

复合查询

constant score query

用来包装另一个查询，将查询匹配的文档的评分设为一个常值。

1
2
3
4
5
6
7
8
9
10
11
GET /_search
{
    "query": {
        "constant_score" : {
            "filter" : {
                "term" : { "age" : "39"}
            },
            "boost" : 1.2
        }
    }
}

bool query

Bool 查询用bool操作来组合多个查询字句为一个查询。 可用的关键字：

1
2
3
4
must：必须满足
filter：必须满足，但执行的是filter上下文，不参与、不影响评分
should：或
must_not：必须不满足，在filter上下文中执行，不参与、不影响评分
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
POST _search
{
  "query": {
    "bool" : {
      "must" : {
        "term" : { "lastname": "Ayala"}
      },
      "filter": {
        "term" : { "state": "PA" }
      },
      "must_not" : {
        "range" : {
          "age" : { "gte" : 10, "lte" : 20 }
        }
      },
      "should" : [
        { "term" : { "city": "Nicholson" } },
        { "term" : { "city": "Shaft" } }
      ],
      "minimum_should_match" : 1,
      "boost" : 1.0
    }
  }
}
分享到： 收藏夹 复制网址 邮件 微信 QQ空间 腾讯微博 豆瓣 一键分享 更多