Go Elasticsearch 查询快速入门

Posted 2021-11-22 恋喵大鲤鱼

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Go Elasticsearch 查询快速入门相关的知识，希望对你有一定的参考价值。

0.前言

搜索是 ES 最为复杂精妙的地方，这里只示例项目中较为常用的查询。

ES 中的条件查询常用的有如下几种：

TermQuery 精确匹配单个字段
TermsQuery 精确匹配单个字段，但使用多值进行匹配，类似于 SQL 中的 in 操作
MatchQuery 单个字段匹配查询（匹配分词结果，不需要全文匹配）
RangeQuery 范围查询
BoolQuery 组合查询

1.根据 ID 查询

根据文档ID获取单个文档信息。

// GetByID4ES 根据ID查询单个文档
func GetByID4ES(ctx context.Context, index, id string) (string, error) {
	res, err := GetESClient().Get().Index(index).Id(id).Do(ctx)
	if err != nil {
		return "", err
	}
	return string(res.Source), nil
}

注意：查询不存在的 ID，会报elastic: Error 404 (Not Found)错误。

对应的 RESTful api 为：

GET /es_index_userinfo/_doc/1

如果只想返回部分字段，可以使用_source_includes或_source_excludes参数来包括或过滤掉特定字段。

例如不返回创建时间（create_time）和更新时间（update_time），支持通配符。

GET /es_index_userinfo/_doc/1?_source_includes=*&_source_excludes=*time

2.精确匹配单个字段

比如获指定用户名的用户。

// 创建 term 查询条件，用于精确查询
termQuery := elastic.NewTermQuery("username", "cat")
searchResult, err := GetESClient().Search().
	Index("es_index_userinfo"). 			// 设置索引名
	Query(termQuery).           			// 设置查询条件
	Sort("create_time", true).    			// 设置排序字段，根据 create_time 字段升序排序
	From(0).                    			// 设置分页参数 - 起始偏移量，从第 0 行记录开始
	Size(10).                   			// 设置分页参数 - 每页大小
	Do(ctx)                     			// 执行请求

对应的 RESTful api 为：

GET /es_index_userinfo/_search
{
  "query": {
    "term": {"username": "bob"}
  },
  "sort": [
    {"create_time": "asc"}
  ],
  "from": 0,
  "size":10
}

注意： term 精确匹配 text 类型的字段可能匹配不到，因为 text 类型的字段会被分词，如果分词的结果中不包含整个字段内容，那么将无法匹配，因为 term 匹配是和分词的结果匹配。keyword 类型字段不会进行分词，所以可以用 term 进行精确匹配。

解决办法：给 text 类型的字段取一个别名，别名的类型为 keyword，即不进行分词。

"ancestral":{                 
    "type": "text",         
    "fields": {             
      "alias": {          
        "type": "keyword"
      }
    }
}

那么可以通过 ancestral.alias 访问字段 ancestral，其类型设为 keyword。

3.多值精确匹配单个字段

通过 TermsQuery 实现多值单个字段的精确匹配，类似于 SQL 的 in 查询。

比如获指定用户名的用户，只需要命中一个即可。

// 创建 terms 查询条件，用于多值精确查询
termsQuery := elastic.NewTermsQuery("username", "cat", "bob")
searchResult, err := GetESClient().Search().
	Index("es_index_userinfo"). 			// 设置索引名
	Query(termsQuery).           			// 设置查询条件
	Sort("create_time", true).    			// 设置排序字段，根据 create_time 字段升序排序
	From(0).                    			// 设置分页参数 - 起始偏移量，从第 0 行记录开始
	Size(10).                   			// 设置分页参数 - 每页大小
	Do(ctx)                     			// 执行请求

对应的 RESTful api 为：

GET /es_index_userinfo/_search
{
  "query": {
    "terms": {"username": ["bobs","bob"]}
  },
  "sort": [
    {"create_time": "asc"}
  ],
  "from": 0,
  "size":10
}

4.匹配查询（全文分词搜索）

匹配查询 MatchQuery 是个 ES 的核心查询。无论需要查询什么字段， MatchQuery 查询都应该会是首选的查询方式。它是一个高级全文查询，这表示它既能处理全文字段，又能处理精确字段。

使用 MatchQuery 对字段进行全文搜索，即匹配分词结果。如果分词出现在 MatchQuery 中指定的内容（指定的内容也会分词），如果存在相同的分词，则匹配。

假设“我爱中国”的分词结果为“我”、“爱”、“中国”，那么搜索“我是第一名”也会匹配，因为“我是第一名”的分词结果中也有“我”。

ES 查看某个字段数据的分词结果。

GET /{index}/{type}/{id}/_termvectors?fields={fields_name}

注意： 如果是对 keyword 字段进行 MatchQuery，因为该类型不会分词，所以是精确匹配。

比如获取指定用户名的用户。

// 创建 match 查询条件
matchQuery := elastic.NewMatchQuery("username", "bob")
searchResult, err := GetESClient().Search().
	Index("es_index_userinfo"). // 设置索引名
	Query(matchQuery).          // 设置查询条件
	Sort("create_time", true).  // 设置排序字段，根据 create_time 字段升序排序
	From(0).                    // 设置分页参数 - 起始偏移量，从第 0 行记录开始
	Size(10).                   // 设置分页参数 - 每页大小
	Do(ctx)                     // 执行请求

对应的 RESTful api 为：

GET /es_index_userinfo/_search
{
  "query": {
    "match": {"username": "bob"}
  },
  "sort": [
    {"create_time": "asc"}
  ],
  "from": 0,
  "size":10
}

5.范围查询

实现类似age >= 18 and age < 35的范围查询条件。

// 创建 range 查询条件
rangeQuery := elastic.NewRangeQuery("age").Gte(18).Lte(35)
searchResult, err := GetESClient().Search().
	Index("es_index_userinfo"). // 设置索引名
	Query(rangeQuery).          // 设置查询条件
	Sort("create_time", true).  // 设置排序字段，根据 create_time 字段升序排序
	From(0).                    // 设置分页参数 - 起始偏移量，从第 0 行记录开始
	Size(10).                   // 设置分页参数 - 每页大小
	Do(ctx)                     // 执行请求

对应的 RESTful api 为：

GET /es_index_userinfo/_search
{
  "query": {
    "range":{"age" : {"gte" : 18, "lte": 35}}
  },
  "sort": [
    {"create_time": "asc"}
  ],
  "from": 0,
  "size":10
}

6.bool 组合查询

BoolQuery 是一种组合查询，将多个条件通过类似 SQL 语句 and 和 or 组合在一起来作为查询条件。

其有四种类型的子句：

类型	描述
must	条件必须要满足，并将对分数起作用
filter	条件必须要满足，但又不同于 must 子句，在 filter context 中执行，这意味着忽略评分，并考虑使用缓存。效率会高于 must
should	条件应该满足。可以通过 minimum_should_match 参数指定应该满足的条件个数。如果 bool 查询包含 should 子句，并且没有 must 和 filter 子句，则默认值为 1，否则默认值为 0
must_not	条件必须不能满足。在 filter context 中执行，这意味着评分被忽略，并考虑使用缓存。因为评分被忽略，所以会返回所有 0 分的文档

must

类似 SQL 的 and，代表必须匹配的条件。

	// 创建 bool 查询
	boolQuery := elastic.NewBoolQuery()

	// 创建查询条件
	termQuery := elastic.NewTermQuery("username", "bob")
	rangeQuery := elastic.NewRangeQuery("age").Gte(18).Lte(35)

	// 设置 bool 查询的 must 条件, 组合了两个子查询
	// 搜索用户名为 bob 且年龄在 18～35 岁的用户
	boolQuery.Must(termQuery, rangeQuery)

	searchResult, err := GetESClient().Search().
		Index("es_index_userinfo"). // 设置索引名
		Query(boolQuery).           // 设置查询条件
		Sort("create_time", true).  // 设置排序字段，根据 create_time 字段升序排序
		From(0).                    // 设置分页参数 - 起始偏移量，从第 0 行记录开始
		Size(10).                   // 设置分页参数 - 每页大小
		Do(ctx)                     // 执行请求

对应的 RESTful api 为：

GET /es_index_userinfo/_search
{
  "query":{
    "bool":{
      "must":[
        {"term":{"username": "bob"}},
        {"range":{"age":{"gte":18, "lte":35}}}
      ]
    }
  },
  "sort": [
    {"create_time": "asc"}
  ],
  "from": 0,
  "size":10
}

filter

类似 SQL 的 and，代表必须匹配的条件。不计算匹配分值，且子句被考虑用于缓存。

使用 filter 替代 must 条件，查询用户名为 bob 且年龄在 18～35 岁的用户

	// 创建 bool 查询
	boolQuery := elastic.NewBoolQuery()

	// 创建查询条件
	termQuery := elastic.NewTermQuery("username", "bob")
	rangeQuery := elastic.NewRangeQuery("age").Gte(18).Lte(35)

	// 设置 bool 查询的 filter 条件, 组合了两个子查询
	// 搜索用户名为 bob 且年龄在 18～35 岁的用户
	boolQuery.Filter(termQuery, rangeQuery)

	searchResult, err := GetESClient().Search().
		Index("es_index_userinfo"). // 设置索引名
		Query(boolQuery).          // 设置查询条件
		Sort("create_time", true).  // 设置排序字段，根据 create_time 字段升序排序
		From(0).                    // 设置分页参数 - 起始偏移量，从第 0 行记录开始
		Size(10).                   // 设置分页参数 - 每页大小
		Do(ctx)                     // 执行请求

对应的 RESTful api 为：

GET /es_index_userinfo/_search
{
  "query":{
    "bool":{
      "filter":[
        {"term":{"username": "bob"}},
        {"range":{"age":{"gte":18, "lte":35}}}
      ]
    }
  },
  "sort": [
    {"create_time": "asc"}
  ],
  "from": 0,
  "size":10
}

should

类似 SQL 中的 or，可以通过 minimum_should_match 参数指定应该满足的条件个数。如果 bool 查询包含 should 子句，并且没有 must 和 filter 子句，则默认值为 1，否则默认值为 0。

比如查询用户名为 bob 且年龄为18 或 35 岁的用户。

// 创建 bool 查询
boolQuery := elastic.NewBoolQuery()

// 创建查询条件
termQuery := elastic.NewTermQuery("username", "bob")
termQuery1 := elastic.NewTermQuery("age", 18)
termQuery2 := elastic.NewTermQuery("age", 35)

// 设置 bool 查询的 filter 条件, 组合了两个子查询
// 搜索用户名为 bob 且年龄为 18 或 35 岁的用户
boolQuery.Filter(termQuery, termQuery)
boolQuery.Should(termQuery, termQuery1, termQuery2)
boolQuery.MinimumNumberShouldMatch(1) // 至少满足 should 中的一个条件

searchResult, err := GetESClient().Search().
	Index("es_index_userinfo"). // 设置索引名
	Query(boolQuery).           // 设置查询条件
	Sort("create_time", true).  // 设置排序字段，根据 create_time 字段升序排序
	From(0).                    // 设置分页参数 - 起始偏移量，从第 0 行记录开始
	Size(10).                   // 设置分页参数 - 每页大小
	Do(ctx)                     // 执行请求

对应的 RESTful api 为：

GET /es_index_userinfo/_search
{
  "query":{
    "bool":{
      "filter": {"term":{"username": "bob"}},
      "should":[
        {"term":{"age":18}},
        {"term":{"age":35}}
      ],
      "minimum_should_match" : 1
    }
  },
  "sort": [
    {"create_time": "asc"}
  ],
  "from": 0,
  "size":10
}

must_not

跟 must 作用相反，表示条件必须不能满足。

比如搜索用户名为 bob 且年龄不为 18 或 35 岁的用户。

	// 创建 bool 查询
	boolQuery := elastic.NewBoolQuery()

	// 创建查询条件
	termQuery := elastic.NewTermQuery("username", "bob")
	termQuery1 := elastic.NewTermQuery("age", 18)
	termQuery2 := elastic.NewTermQuery("age", 35)

	// 设置 bool 查询的 filter 条件, 组合了两个子查询
	// 搜索用户名为 bob 且年龄不为 18 和 35 岁的用户
	boolQuery.Filter(termQuery)
	boolQuery.MustNot(termQuery1, termQuery2)

	searchResult, err := GetESClient().Search().
		Index("es_index_userinfo"). // 设置索引名
		Query(boolQuery).           // 设置查询条件
		Sort("create_time", true).  // 设置排序字段，根据 create_time 字段升序排序
		From(0).                    // 设置分页参数 - 起始偏移量，从第 0 行记录开始
		Size(10).                   // 设置分页参数 - 每页大小
		Do(ctx)                     // 执行请求

对应的 RESTful api 为：

GET /es_index_userinfo/_search
{
  "query":{
    "bool":{
      "filter": {"term":{"username": "bob"}},
      "must_not":[
        {"term":{"age":18}},
        {"term":{"age":35}}
      ]
    }
  },
  "sort": [
    {"create_time": "asc"}
  ],
  "from": 0,
  "size":10
}

7.分页查询

我们也可以根据条件分页查询。

ES 分页搜索一般有三种方案，from + size、search after、scroll api，这三种方案分别有自己的优缺点。

from + size

这是 ES 分页中最常用的一种方式，与 mysql 类似，from 指定起始位置，size 指定返回的文档数。

这种分页方式，在分布式的环境下的深度分页是有性能问题的，一般不建议用这种方式做深度分页，可以用下面将要介绍的两种方式。

理解为什么深度分页是有问题的，假设取的页数较大时（深分页），如请求第20页，Elasticsearch 不得不取出所有分片上的第 1 页到第 20 页的所有文档，并做排序，最终再取出 from 后的 size 条结果作爲最终的返回值。

所以，当索引记录非常非常多(千万或亿)，是无法使用 from + size 做深分页的，分页越深则越容易 OOM。即便不 OOM，也很消耗 CPU 和内存资源。

所以 ES 为了避免深分页，不允许使用 from + size 的方式查询 1 万条以后的数据，即 from + size 大于 10000 会报错，不过可以通过 index.max_result_window 参数进行修改。

// GetByQueryPage4ES 分页查询
// param: index 索引; query 查询条件; page 起始页（从 1 开始）; size 页大小
func GetByQueryPage4ES(ctx context.Context, index string, query elastic.Query, page, size int) ([]string, error) {
	start := (page - 1) * size
	res, err := GetESClient().Search(index).Query(query).From(start).Size(size).Do(ctx)
	if err != nil {
		return nil, err
	}
	sl := make([]string, 0, res.TotalHits())
	for _, hit := range res.Hits.Hits {
		sl = append(sl, string(hit.Source))
	}
	return sl, nil
}

// GetByQueryPageSort4ES 根据条件分页查询 & 指定字段排序
// param: index 索引; query 查询条件; page 起始页（从 1 开始）; size 页大小; field 排序字段; ascending 升序
func GetByQueryPageSort4ES(ctx context.Context, index string, query elastic.Query, page, size int, field string,
	ascending bool) ([]string, error) {
	from := (page - 1) * size
	res, err := GetESClient().Search(index).Query(query).Sort(field, ascending).From(from).Size(size).Do(ctx)
	if err != nil {
		return nil, err
	}
	sl := make([]string, 0, res.TotalHits())
	for _, hit := range res.Hits.Hits {
		sl = append(sl, string(hit.Source))
	}
	return sl, nil
}

比如分页查询年龄 >=18 且按照创建时间降序排序：

query := elastic.NewBoolQuery()
query.Filter(elastic.NewRangeQuery("age").Gte(18))
sl, err := GetByQueryPageSort4ESGo Elasticsearch CRUD 快速入门
 Go Elasticsearch CRUD 快速入门
 Go Elasticsearch 删除快速入门
 Go Elasticsearch 删除快速入门
 Go Elasticsearch 更新快速入门
 Go Elasticsearch 更新快速入门

Go Elasticsearch 查询快速入门

文章目录

0.前言

1.根据 ID 查询

2.精确匹配单个字段

3.多值精确匹配单个字段

4.匹配查询（全文分词搜索）

5.范围查询

6.bool 组合查询

must

filter

should

must_not

7.分页查询

from + size