• 首页 首页 icon
  • 工具库 工具库 icon
    • IP查询 IP查询 icon
  • 内容库 内容库 icon
    • 快讯库 快讯库 icon
    • 精品库 精品库 icon
    • 问答库 问答库 icon
  • 更多 更多 icon
    • 服务条款 服务条款 icon

Elasticsearch:通过例子快速入门

武飞扬头像
Elasticsearch
帮助85

前言

Elasticsearch 是业界最流行的开源企业搜索引擎,应用广泛。 在我们的手机里的 App 背后的搜索引擎好多都是 Elasticsearch,比如我们熟知的抖音,滴滴,美团,携程,点评,银行 app,保险,证券,交友,健康宝等等。

>安装

如果你还没有安装好自己的 Elasticsearch 及 Kibana,请参考如下的两篇文章来进行安装:

针对一些还没有对 Elasticsearch 及 Kibana 有所认识的开发者来说,我强烈建议参考文章 “Elasticsearch:如何在 Docker 上运行 Elasticsearch 8.x 进行本地开发” 来进行一键安装。我们先不考虑安全的问题。请参考文章中的 “使用 Docker Compose 运行 Elasticsearch 和 Kibana” 章节来进行一键安装 Elasticsearch 及 Kibana。

准备数据

我们有如下的两种方法写入数据: 

1)针对有一定 Python 开发经验的开发者来说

2)在 Kibana 的 Dev Tools 中打入如下的命令:

>` 1. PUT laptops-demo 2. { 3. "settings": { 4. "index": { 5. "number_of_replicas": 1 6. }, 7. "analysis": { 8. "filter": { 9. "ngram_filter": { 10. "type": "edge_ngram", 11. "min_gram": 2, 12. "max_gram": 15 13. } 14. }, 15. "analyzer": { 16. "ngram_analyzer": { 17. "type": "custom", 18. "tokenizer": "standard", 19. "filter": [ 20. "lowercase", 21. "ngram_filter" 22. ] 23. } 24. } 25. } 26. }, 27. "mappings": { 28. "properties": { 29. "id": { 30. "type": "long" 31. }, 32. "name": { 33. "type": "text", 34. "analyzer": "standard", 35. "fields": { 36. "keyword": { 37. "type": "keyword" 38. }, 39. "ngrams": { 40. "type": "text", 41. "analyzer": "ngram_analyzer" 42. } 43. } 44. }, 45. "brand": { 46. "type": "text", 47. "fields": { 48. "keyword": { 49. "type": "keyword" 50. } 51. } 52. }, 53. "price": { 54. "type": "float" 55. }, 56. "attributes": { 57. "type": "nested", 58. "properties": { 59. "attribute_name": { 60. "type": "text" 61. }, 62. "attribute_value": { 63. "type": "text" 64. } 65. } 66. } 67. } 68. } 69. } `![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

我们到地址 github.com/liu-xiao-gu… 下载 aptops_demo.json 文件。然后在电脑上打入如下的命令:

curl -s -H "Content-Type: application/x-ndjson" -XPOST "http://localhost:9200/_bulk" --data-binary "@laptops_demo.json"

上面的有些字段的类型可能对初学的开发者并不熟悉。我们先可以不管这些。

 这样我们就完成了数据的写入部分了。我们可以通过如下的命令来查看文档的个数:

GET laptops-demo/_count


1.  {
2.    "count": 200,
3.    "_shards": {
4.      "total": 1,
5.      "successful": 1,
6.      "skipped": 0,
7.      "failed": 0
8.    }
9.  }


Dev Tools 操作

我们在 Dev Tools 中可以向 Elasticsearch 发送 REST API 请求并完成我们许多的指令。

创建一个索引

我们可以使用如下的命令来创建一个索引:

PUT /test-index

你只能运行此命令一次,否则,你将看到资源已存在的错误。 请注意,前导正斜杠 (/) 是可选的,你可以省略它并且结果相同。

检查集群中的索引

 我们可以通过如下的命令来检查集群中的索引:

GET _cat/indices

>更新索引的设置

我们可以通过如下命令来更新一个索引的设置:



1.  PUT test-index/_settings
2.  {
3.    "settings": {
4.      "number_of_replicas": 2
5.    }
6.  }


你需要指定 _settings 端点,否则你将看到使用现有名称创建索引的相同错误。

删除索引

我们通过如下的命令来删除一个索引:

DELETE test-index

针对文档的创建(create)、读取(read)、更新(update)和删除(delete)这些 CRUD 操作的基本 Elasticsearch 查询。

在 Elasticsearch 中,索引就像一张表,文档就像一行数据。 但是,与 MySQL 等关系型数据库中的列式数据不同,Elasticsearch 中的数据是 JSON 对象。

创建一个文档



1.  PUT test-index/_doc/1
2.  {
3.    "name": "John Doe"
4.  }


如果索引尚不存在,此查询将自动创建索引。 此外,还会创建一个带有 name 字段的新文档。

读取一个文档

GET test-index/_doc/1

更新一个文档

通过如下的命令添加一个叫做 age 的字段:



1.  POST test-index/_update/1
2.  {
3.    "doc": {
4.      "age": 30
5.    }
6.  }


请注意,你必须使用 POST 命令来更新文档。 要更新的字段在 doc 字段中指定。更新完后,我们可以使用如下的命令来进行查看:

GET test-index/_doc/1


1.  {
2.    "_index": "test-index",
3.    "_id": "1",
4.    "_version": 2,
5.    "_seq_no": 1,
6.    "_primary_term": 1,
7.    "found": true,
8.    "_source": {
9.      "name": "John Doe",
10.      "age": 30
11.    }
12.  }


我们可以更新一个已有的字段,比如:



1.  POST test-index/_update/1
2.  {
3.    "doc": {
4.      "name": "liuxg"
5.    }
6.  }


我们再次查询:

GET test-index/_doc/1


1.  {
2.    "_index": "test-index",
3.    "_id": "1",
4.    "_version": 3,
5.    "_seq_no": 2,
6.    "_primary_term": 1,
7.    "found": true,
8.    "_source": {
9.      "name": "liuxg",
10.      "age": 30
11.    }
12.  }


删除一个文档

DELETE test-index/_doc/1

现在我们对 Elasticsearch 索引和文档的 CRUD 操作有了一些感受。 我们可以看到,编写 Elasticsearch 查询就像使用 GET、POST、PUT 和 DELETE 方法发出 RESTful API 请求一样。 但是,主要区别在于我们可以将 JSON 对象传递给 GET 方法,这在常规 REST GET 方法中是不允许的。

查询索引

要检查索引中的所有文档,请运行以下命令:

GET laptops-demo/_search

它是以下的简短版本:



1.  GET laptops-demo/_search
2.  {
3.    "query": {
4.      "match_all": {}
5.    }
6.  }


>从上面我们可以看出来有 200 个文档被搜索到了。你应该能够看到从 JSON 文件添加的所有文档。 现在索引和文档都准备好了,我们可以开始搜索了。

我们已经知道如何检查索引中的所有文档。 默认情况下,返回所有可能难以阅读的字段。 要仅显示特定字段,我们可以指定 _sources 关键字:



1.  GET laptops-demo/_search
2.  {
3.    "query": {
4.      "match_all": {}
5.    },
6.    "_source": ["name"]
7.  }


如果你根本不想看到来源,你可以将 _source 设置为 false:



1.  GET laptops-demo/_search
2.  {
3.    "query": {
4.      "match_all": {}
5.    },
6.    "_source": false
7.  }


事实上,在最新的 Elasticsearch 发布版中,我们更倾向于如下的一种方式来获取我们想要的字段:



1.  GET laptops-demo/_search
2.  {
3.    "fields": [
4.      "name",
5.      "price"
6.    ], 
7.    "query": {
8.      "match_all": {}
9.    },
10.    "_source": false
11.  }


我们使用 fields 来指定想要返回的字段。

顾名思义,match_all 匹配所有内容。 要根据某些条件进行搜索,我们可以使用匹配关键字。 例如,要搜索名称中包含 Apple 的所有笔记本电脑:



1.  GET laptops-demo/_search
2.  {
3.    "query": {
4.      "match": {
5.        "name": "Apple"
6.      }
7.    }
8.  }


从上面的映射我们知道,name 字段是一个 text 字段,会被解析。 简单来说,分析就是将文本字符串小写,拆分成t oken,去掉标点符号。 你可以在此链接上阅读有关分析的更多信息。

要查看如何分析文本,我们可以使用 _analyze 端点:



1.  GET laptops-demo/_analyze
2.  {
3.    "text": "Apple MackBook!",
4.    "analyzer": "standard"
5.  }


这里我们使用 standard 分析器,如上所述,它将小写文本,将其拆分为标记并删除标点符号:

`

1.  {
2.    "tokens": [3.      {4.        "token": "apple",5.        "start_offset": 0,6.        "end_offset": 5,7.        "type": "<ALPHANUM>",8.        "position": 09.      },10.      {11.        "token": "mackbook",12.        "start_offset": 6,13.        "end_offset": 14,14.        "type": "<ALPHANUM>",15.        "position": 116.      }17.    ]
18.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

更多关于 Elasticsearch analyzer 的文章

由于我们在索引的设置中定义了一个特殊的分析器 ngram_analyzer ,让我们使用这个分析器来分析我们的文本,看看我们会得到什么:



1.  GET laptops-demo/_analyze
2.  {
3.    "text": "Apple MackBook!",
4.    "analyzer": "ngram_analyzer"
5.  }


我们可以看到生成了一堆:

`

1.  {
2.    "tokens": [3.      {4.        "token": "ap",5.        "start_offset": 0,6.        "end_offset": 5,7.        "type": "<ALPHANUM>",8.        "position": 09.      },10.      {11.        "token": "app",12.        "start_offset": 0,13.        "end_offset": 5,14.        "type": "<ALPHANUM>",15.        "position": 016.      },17.      {18.        "token": "appl",19.        "start_offset": 0,20.        "end_offset": 5,21.        "type": "<ALPHANUM>",22.        "position": 023.      },24.      {25.        "token": "apple",26.        "start_offset": 0,27.        "end_offset": 5,28.        "type": "<ALPHANUM>",29.        "position": 030.      },31.      {32.        "token": "ma",33.        "start_offset": 6,34.        "end_offset": 14,35.        "type": "<ALPHANUM>",36.        "position": 137.      },38.      {39.        "token": "mac",40.        "start_offset": 6,41.        "end_offset": 14,42.        "type": "<ALPHANUM>",43.        "position": 144.      },45.      {46.        "token": "mack",47.        "start_offset": 6,48.        "end_offset": 14,49.        "type": "<ALPHANUM>",50.        "position": 151.      },52.      {53.        "token": "mackb",54.        "start_offset": 6,55.        "end_offset": 14,56.        "type": "<ALPHANUM>",57.        "position": 158.      },59.      {60.        "token": "mackbo",61.        "start_offset": 6,62.        "end_offset": 14,63.        "type": "<ALPHANUM>",64.        "position": 165.      },66.      {67.        "token": "mackboo",68.        "start_offset": 6,69.        "end_offset": 14,70.        "type": "<ALPHANUM>",71.        "position": 172.      },73.      {74.        "token": "mackbook",75.        "start_offset": 6,76.        "end_offset": 14,77.        "type": "<ALPHANUM>",78.        "position": 179.      }80.    ]
81.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

这些 N-grams 对于输入即搜索或自动完成很有用,让我们尝试通过部分输入进行搜索:



1.  GET laptops-demo/_search
2.  {
3.    "query": {
4.      "match": {
5.        "name.ngrams": "Appl"
6.      }
7.    }
8.  }


在此查询中,你还可以获得所有 Apple 笔记本电脑。 如果你在 name 字段而不是 name.ngrams 字段中按 Appl 搜索,你将找不到任何内容,因为 name 字段由standard 分析器分析,因此没有 N-gram。

你可能想知道 name 字段和 name.ngrams 字段之间的关系是什么。 嗯,这就是所谓的多字段(multi-fields),就是为了不同的目的,用不同的方式索引同一个字段。 由于始终分析文本字段,因此我们经常为其添加一些额外的字段。 例如,keyword 类型字段通常被添加到文本字段中。 keyword 类型意味着文本将按原样处理,不会被分析。 同一字段的多个字段可以用不同的分析器进行分析。 在本文中,使用 standard 分析器分析 name 字段,使用自定义 ngram_analyzer 分析 name.ngrams 字段,这在不同情况下很有用。

我们已经学习了如何使用匹配查询来搜索文本字段。 还有 long、float 等其他类型的字段,这些字段类似于文本字段的关键字类型,不做分析。 如果我们不想在搜索中分析查询输入,我们可以使用 term 查询



1.  GET laptops-demo/_search
2.  {
3.    "query": {
4.      "term": {
5.        "name.keyword": {
6.          "value": "Apple MacBook Model 131"
7.        }
8.      }
9.    }
10.  }


通过这个查询,我们得到了名字恰好是 “Apple MacBook Model 131” 的笔记本电脑。 如果我们将查询中的任何单词更改为小写或删除任何单词,我们将一无所获。 这是因为,对于 term 查询,我们按原样搜索查询字符串,不会对其进行分析。  Elasticsearch 搜索引擎中存储的文本字段数据不是原始字符串,而是上面用分析器演示的一堆 token。这种搜索也通常被称之为精确匹配。

如果我们想搜索多个值(原样),我们可以使用 terms 查询。 例如,如果我们要搜索 id 为 1、10 和 100 的笔记本电脑:



1.  GET laptops-demo/_search
2.  {
3.    "query": {
4.      "terms": {
5.        "id": [
6.          1,
7.          10,
8.          100
9.        ]
10.      }
11.    }
12.  }


我们可以使用 range 查询来搜索包含具有给定范围的术语的文档。 例如,让我们搜索价格在 10,000 到 20,000 Kr 之间的笔记本电脑。



1.  GET laptops-demo/_search
2.  {
3.    "query": {
4.      "range": {
5.        "price": {
6.          "gte": 10000,
7.          "lte": 20000
8.        }
9.      }
10.    }
11.  }


我们已经知道如何通过 ID 更新和删除单个文档。 有时我们需要更新或删除许多满足某些条件的文件。 在这种情况下,我们可以使用 update_by_querydelete_by_query

`

1.  POST laptops-demo/_update_by_query
2.  {
3.    "script": {
4.      "source": "ctx._source.price  = params.increase",
5.      "lang": "painless",
6.      "params" : {
7.        "increase" : 2000
8.      }    
9.    },
10.    "query": {
11.      "match": {
12.        "brand": "Apple"
13.      }
14.    }
15.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

在此示例中,我们将所有 Apple 笔记本电脑的价格提高 2,000 Kr。

关键点

  • 在 query 部分,我们使用常规搜索查询来查找需要更新的文档。
  • 在script 部分,我们指定如何处理查询找到的结果。 在这里,我们正在进行脚本更新。
  • lang 指定要使用的语言。 在 Elasticsearch 中,默认的脚本语言称为 painless,我会说这是一个奇怪的名字。 由于它是要使用的默认语言,因此你可以省略此字段。
  • params 指定将在脚本中使用的参数。
  • source 指定要运行的源代码。 源码中 ctx 为上下文数据,ctx._source.price 代表查询到的每个文档的 price 字段。

 

对于delete_by_query,就简单多了,因为我们不需要指定源代码来运行。 让我们删除 id 为 1、11、111 的笔记本电脑,仅用于演示目的。



1.  POST laptops-demo/_delete_by_query
2.  {
3.    "query": {
4.      "terms": {
5.        "id": [
6.          1,
7.          11,
8.          111
9.        ]
10.      }
11.    }
12.  }


默认情况下,查询结果按相关性得分降序排列。 我们也可以按照我们指定的一些字段对结果进行排序。 例如,让我们搜索所有 Apple MacBook 并按价格降序对结果进行排序:

`

1.  GET laptops-demo/_search
2.  {
3.    "query": {
4.      "match": {
5.        "name": "Apple MacBook"
6.      }
7.    },
8.    "sort": [
9.      {
10.        "price": {
11.          "order": "desc"
12.        }
13.      }
14.    ]
15.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

>sort 字段需要一个对象列表,这意味着我们可以按多个字段排序。

让我们检查一个更高级的排序示例。 让我们将 Apple 笔记本电脑放在其他品牌之前,然后按 price 升序排列。 为了这个排序目的,我们需要写一些 painless 脚本:

`

1.  GET laptops-demo/_search
2.  {
3.    "sort": [
4.      {
5.        "_script": {
6.          "type": "number",
7.          "script": {
8.            "lang": "painless",
9.            "source": """
10.                if (doc['brand.keyword'].value == 'Apple') {
11.                  return 1;
12.                } else {
13.                  return 0;
14.                }
15.              """
16.          },
17.          "order": "desc"
18.        }
19.      },
20.      {
21.        "price": {
22.          "order": "asc"
23.        }
24.      }
25.    ]
26.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

_script 关键字指定我们将按脚本返回的结果排序。 注意,我们不能直接按布尔条件排序,而是需要将布尔结果转化为数值,然后再按它们排序。 type 字段指定从脚本返回的结果的类型,这里我们希望返回一个 number。

在 source 字段指定的 painless 脚本中,doc 变量包含了当前文档的所有字段。 对于常规字段,可以通过 doc['fieldname'].value 访问该值。 对于 keyword 等多字段,可以通过 doc['fieldname.keyword'].value 访问值。

到目前为止,我们只使用了一个查询。 如果我们希望文档满足多个条件,我们可以使用 bool 查询,它使用一个或多个布尔子句构建,包括 must、should、filter 和 must_not。 这就是 Elasticsearch 查询可能变得非常复杂的地方。

默认情况下,Elasticsearch 按相关性分数对匹配结果进行排序,相关性分数衡量每个文档与查询的匹配程度。 相关性分数是一个正浮点数,在搜索 API 的 _score 元数据字段中返回。 _score 越高,文档越相关。 每种查询类型都会以不同方式计算相关性分数。 布尔子句可以在所谓的查询或过滤器上下文中运行。

查询上下文

  • must:子句(query)必须出现在匹配的文档中,并将有助于得分。
  • should:子句(query)应该出现在匹配的文档中,也就是说它实际上可能出现也可能不出现。 我们可以通过 minimum_should_match 字段指定应该出现多少个 should 子句,如下所示。

must 和 should 查询在查询上下文中执行。 除了决定文档是否匹配之外,查询子句还在 _score 元数据字段中计算相关性分数。

过滤器上下文

  • filter:子句(query)必须出现在匹配的文档中。 但是,与 must 不同的是,查询的分数将被忽略。
  • must_not:子句(查询)不得出现在匹配文档中。

filter 和 must_not 查询在过滤器上下文中执行,其中忽略评分并考虑缓存子句,这可以使以后使用相同子句的搜索更快。

作为演示,让我们找到满足以下条件的 Apple 笔记本电脑:

  • brand 字段必须包含“Apple”。
  • name 应包含 “MacBook” 或 “Pro”,或两者(如果有)。
  • price 不得低于 5,000 Kr 或高于 50,000 Kr。
  • memory 必须是 8GB。

这是要使用的查询:

`

1.  GET laptops-demo/_search
2.  {
3.    "query": {
4.      "bool": {
5.        "must": {
6.          "match": {
7.            "brand": "Apple"
8.          }
9.        },
10.        "should": [
11.          {
12.            "match": {
13.              "name": "MacBook"
14.            }
15.          },
16.          {
17.            "match": {
18.              "name": "Pro"
19.            }
20.          }
21.        ],
22.        "must_not": {
23.          "range": {
24.            "price": {
25.              "gt": 50000,
26.              "lt": 5000
27.            }
28.          }
29.        },
30.        "filter": {
31.          "nested": {
32.            "path": "attributes",
33.            "query": {
34.              "bool": {
35.                "must": [
36.                  {
37.                    "match": {
38.                      "attributes.attribute_name": "memory"
39.                    }
40.                  },
41.                  {
42.                    "match": {
43.                      "attributes.attribute_value": "16GB"
44.                    }
45.                  }
46.                ]
47.              }
48.            }
49.          }
50.        },
51.        "minimum_should_match": 1
52.      }
53.    }
54.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

这个演示可能看起来很愚蠢,因为我们在文档中没有很多字段。 在实际情况下,一个文档中可以有几十个字段,布尔查询可以变得非常强大。 本例中使用的 nested 查询将在稍后介绍。简单一句话,如果是针对一个数组来进行查询,需要同时满足其中的两个及以上的属性的查询,我们需要使用到 nested 数据类型。比如,我们需要查询 attribute 的名称为 memory,并且它的值也为 16G,那么我们在这种情况下需要使用到 nested 数据类型。需要特别指出的是 nested 目前在 Kibana 中支持的不是很好。不能使用 nested 字段来进行可视化。

到目前为止,我们还没有解释 laptops-demo 索引的属性字段。 attributes 字段的特殊之处在于它是一个 nested 字段,包含 attribute_name 和 attribure_value 字段作为子字段。 nested 类型是对象数据类型的特殊版本,它允许对象数组以一种可以彼此独立查询的方式进行索引。 我们应该始终为 nested 字段创建映射,如本例所示,因为 Elasticsearch 没有内部对象的概念。 因此,它将对象层次结构扁平化为字段名称和值的简单列表。 如果你查询展平的对象,你将得不到预期的结果。

要查询 nested 字段,我们可以使用 nested 查询。 让我们找出内存为 16GB 的所有笔记本电脑:

`

1.  GET laptops-demo/_search
2.  {
3.    "query": {
4.      "nested": {
5.        "path": "attributes",
6.        "query": {
7.          "bool": {
8.            "must": [
9.              { "match": { "attributes.attribute_name": "memory" }},
10.              { "match": { "attributes.attribute_value":  "16GB" }} 
11.            ]
12.          }
13.        }
14.      }
15.    }
16.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

关键点

  • nested 关键字指定我们正在查询 nested 字段。
  • path 指定 nested 字段的名称,在本例中为 attributes。
  • bool 表示我们正在使用布尔查询,因为我们希望 attribute_name 和 attribute_value 字段都满足某些条件。
  • must 表示子查询必须全部出现在文档中。
  • match 表示全文搜索,因为 attribute_name 和 attribute_value 字段都是文本字段。 如果其中一些不是文本字段,我们需要使用 term、terms 或 range 查询。

Elasticsearch 不仅仅是一个搜索引擎,它还提供了非常强大的分析功能。 在 Elasticsearch 中,分析通常是通过 aggregations 来完成的,聚合将我们的数据汇总为指标、统计数据或其他分析。

你可以通过指定搜索 API 的 aggs 参数来运行聚合作为搜索的一部分。 最常见的聚合类型是 terms 聚合,它是一种基于多桶值的聚合,其中桶(bucket)是动态构建的 —— 每个唯一值一个。 请注意,此处的术语字段与查询中使用的字段不同。 terms in aggs 表示聚合方法是多桶聚合,而 terms in query 表示返回在给定字段中包含一个或多个确切术语的文档。 terms 查询term 查询相同,只是你可以搜索多个值。

让我们计算每个品牌的产品数量。 请注意,术语聚合应该是 keyword 类型的字段或任何其他适合桶聚合的数据类型,例如离散数值。



1.  GET laptops-demo/_search
2.  {
3.    "aggs": {
4.      "brand-count-agg": {
5.        "terms": {
6.          "field": "brand.keyword"
7.        }
8.      }
9.    }
10.  }


默认情况下,搜索结果显示在聚合结果之前,这会使后者难以阅读。 如果我们只想看到聚合结果,我们将 size 设置为 0,这意味着不会显示任何查询结果。



1.  GET laptops-demo/_search
2.  {
3.    "size":0,
4.    "aggs": {
5.      "brand-count-agg": {
6.        "terms": {
7.          "field": "brand.keyword"
8.        }
9.      }
10.    }
11.  }


我们也可以在聚合前指定搜索条件。 例如,我们只统计价格超过 20,000 Kr 的笔记本电脑。

`

1.  GET laptops-demo/_search
2.  {
3.    "size": 0,
4.    "aggs": {
5.      "brand-count-agg": {
6.        "terms": {
7.          "field": "brand.keyword"
8.        }
9.      }
10.    },
11.    "query": {
12.      "range": {
13.        "price": {
14.          "gte": 20000
15.        }
16.      }
17.    }
18.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

当你有更多要求时,聚合可能会变得复杂。 可以基于多个字段进行聚合,通过正则表达式过滤值,写一些脚本在聚合前转换数据等。如果你想有更高级的聚合,可以查看官方文档

我们在本文中介绍了很多关于 Elasticsearch 的内容。 如果你已经了解了基本知识和查询,那么你可以开始在工作中编写自己的查询。 但是,还有很多东西需要学习,本文无法涵盖。 这篇文章的目的是给大家一个大概的介绍,如何在不同的场合使用 Elasticsearch 查询,让大家可以快速上手或初步对 Elasticsearch 有所了解。 我希望你喜欢这篇文章。

这篇好文章是转载于:学新通技术网

  • 版权申明: 本站部分内容来自互联网,仅供学习及演示用,请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系,请提供相关证据及您的身份证明,我们将在收到邮件后48小时内删除。
  • 本站站名: 学新通技术网
  • 本文地址: /boutique/detail/tanfbfek
系列文章
更多 icon
同类精品
更多 icon
继续加载