在CSDN学Golang分布式中间件（ElasticSearch）
一，倒排索引，lucene
倒排索引是一种用于快速查找文本中特定单词或短语的数据结构。它将文本中的每个单词或短语与包含该单词或短语的文档列表相关联。这使得可以轻松地查找包含给定单词或短语的所有文档。
在 Go 中，可以使用 map 和 slice 来实现倒排索引。具体来说，可以使用一个 map 将每个单词映射到包含该单词的文档列表。例如：
index := make(map[string][]string)然后，在处理每个文档时，将其拆分成单词，并将每个单词添加到相应的列表中：
words := strings.Split(text, " ")
for _, word := range words {
index[word] = append(index[word], docID)
}这样就可以通过检索特定单词来获取包含该单词的所有文档。
另一方面，Lucene 是一个全文搜索引擎库，可用于建立更高效和更复杂的倒排索引。它提供了许多功能，例如支持布尔查询、模糊查询、范围查询等，并且能够处理大规模数据集。
Lucene 倒排索引使用 B 树和倒排列表（Inverted List）来存储信息。B 树是一种平衡树结构，可用于快速查找索引中的文档。而倒排列表则是一个映射，将单词映射到它们出现在哪些文档中。
Go 中的倒排索引适用于较小的数据集和简单的搜索需求，而 Lucene 则适用于需要处理大规模数据集和更高级别查询需求的场景。
二，es-head和kibana
ES-Head 是一个 Elasticsearch 可视化管理工具，它提供了一个 Web 界面，可以帮助用户更直观地理解和管理 Elasticsearch 集群。ES-Head 提供了各种功能，例如索引管理、集群健康监控、搜索等。
Kibana 是一个用于可视化和分析 Elasticsearch 数据的开源工具。它提供了一个基于 Web 的界面，使用户可以轻松地创建交互式仪表板、图表和可视化效果，并进行深入的数据分析。Kibana 也是 ELK（Elasticsearch + Logstash + Kibana）技术栈中的一部分。
在 Go 中使用 ES-Head 和 Kibana 是非常简单的，因为它们都是 Web 应用程序。只需下载这些应用程序并在本地运行即可开始使用。
要使用 ES-Head，请按照以下步骤操作：
- 下载 ES-Head：https://github.com/mobz/elasticsearch-head
- 解压缩文件并进入目录
- 启动 ES-Head：
npm install
grunt server- 打开浏览器访问 http://localhost:9100/ 即可开始使用
要使用 Kibana，请按照以下步骤操作：
- 下载 Kibana：https://www.elastic.co/downloads/kibana
- 解压缩文件并进入目录
- 修改 kibana.yml 文件以指定 Elasticsearch 主机和端口：
elasticsearch.hosts: ["http://localhost:9200"]- 启动 Kibana：
bin/kibana- 打开浏览器访问 http://localhost:5601/ 即可开始使用
ES-Head 和 Kibana 是非常有用的 Elasticsearch 可视化工具。它们可以帮助用户更好地管理和分析 Elasticsearch 数据，并提供了各种功能来满足不同的需求。
三，es 集群健康值检查
在 Go 中，可以使用 Elasticsearch 官方提供的 Go 客户端库（github.com/elastic/go-elasticsearch）来检查 ES 集群的健康值。该客户端库提供了许多方法和结构体，以便于与 Elasticsearch 交互。
以下是一个示例代码，用于获取 ES 集群的健康值：
package main
import (
"context"
"fmt"
"log"
"github.com/elastic/go-elasticsearch/v7"
)
func main() {
// 创建一个 Elasticsearch 客户端
es, err := elasticsearch.NewDefaultClient()
if err != nil {
log.Fatalf("Error creating the client: %s", err)
}
// 发送集群健康请求
res, err := es.Cluster.Health(
es.Cluster.Health.WithContext(context.Background()),
es.Cluster.Health.WithIndex("my_index"),
es.Cluster.Health.WithWaitForStatus("yellow"), // 等待集群状态为黄色或更好
es.Cluster.Health.WithTimeout(30), // 设置超时时间为 30 秒
)
if err != nil {
log.Fatalf("Error getting cluster health: %s", err)
}
// 获取响应中的健康状态
health, _ := res.Status()
fmt.Printf("Cluster health is %q\n", health)
}在上面的代码中，我们首先创建了一个默认配置的 Elasticsearch 客户端（elasticsearch.NewDefaultClient()）。然后，我们使用 es.Cluster.Health 方法发送一个集群健康请求，并通过各种选项来设置请求参数，例如：索引名称、期望的健康状态等。最后，我们通过 res.Status() 方法获取响应中的健康状态。
需要注意的是，在发送集群健康请求时，可以使用不同的选项来定制请求参数，以满足不同的需求。例如：
- WithIndex()：指定一个或多个索引名称。
- WithWaitForStatus()：指定期望的健康状态（green/yellow/red）。
- WithTimeout()：设置超时时间（单位为秒）。
- WithPretty()：指定是否将响应格式化为易于阅读的 JSON 格式。
在 Go 中检查 ES 集群健康值非常简单，只需使用 Elasticsearch 官方提供的 Go 客户端库即可。
四，es 索引操作以及文档操作
在 Go 中，可以使用 Elasticsearch 官方提供的 Go 客户端库（github.com/elastic/go-elasticsearch）来进行索引操作和文档操作。该客户端库提供了许多方法和结构体，以便于与 Elasticsearch 交互。
以下是一个示例代码，用于对 ES 索引进行创建、删除、更新以及文档的增删改查：
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/elastic/go-elasticsearch/v7"
)
func main() {
// 创建一个 Elasticsearch 客户端
es, err := elasticsearch.NewDefaultClient()
if err != nil {
log.Fatalf("Error creating the client: %s", err)
}
// 创建索引
createIndex(es)
// 添加文档
addDocument(es)
// 获取文档
getDocument(es)
// 更新文档
updateDocument(es)
// 删除文档
deleteDocument(es)
// 删除索引
deleteIndex(es)
}
func createIndex(es *elasticsearch.Client) {
// 准备请求参数
reqBody := `{
"settings": {
"number_of_shards": 1,
"number_of_replicas": 0
},
"mappings": {
"properties": {
"title": { "type": "text" },
"content": { "type": "text" }
}
}
}`
// 发送请求创建索引
res, err := es.Indices.Create("my_index",
es.Indices.Create.WithContext(context.Background()),
es.Indices.Create.WithBody(strings.NewReader(reqBody)),
)
if err != nil {
log.Fatalf("Error creating the index: %s", err)
}
// 获取响应中的状态码
statusCode := res.StatusCode
fmt.Printf("Index created, status code: %d\n", statusCode)
}
func addDocument(es *elasticsearch.Client) {
// 准备文档数据
docData := map[string]interface{}{
"title": "First document",
"content": "This is the first document.",
}
// 发送请求添加文档
res, err := es.Index(
"my_index",
es.Index.WithDocumentID("1"), // 指定文档 ID
es.Index.WithBodyJSON(docData), // 指定文档内容
es.Index.WithRefresh("true"), // 立即刷新索引以使文档可用于搜索（仅用于测试）
es.Index.WithContext(context.Background()),
)
if err != nil {
log.Fatalf("Error adding document: %s", err)
}
// 获取响应中的状态码和 ID
statusCode := res.StatusCode
id := res.Id
fmt.Printf("Document added, status code: %d, id: %s\n", statusCode, id)
}
func getDocument(es *elasticsearch.Client) {
// 发送请求获取指定 ID 的文档
res, err := es.Get(
"my_index",
"1",
es.Get.WithContext(context.Background()),
)
if err != nil {
log.Fatalf("Error getting document: %s", err)
}
defer res.Body.Close()
// 解析响应中的文档内容
var docData map[string]interface{}
if err := json.NewDecoder(res.Body).Decode(&docData); err != nil {
log.Fatalf("Error parsing the response body: %s", err)
}
fmt.Printf("Document found, title: %s, content: %s\n", docData["title"], docData["content"])
}
func updateDocument(es *elasticsearch.Client) {
// 准备更新数据
updateData := map[string]interface{}{
"doc": map[string]interface{}{
"content": "This is an updated document.",
},
}
// 发送请求更新文档
res, err := es.Update(
"my_index",
"1",
es.Update.WithBodyJSON(updateData),
es.Update.WithRefresh("true"),
es.Update.WithContext(context.Background()),
)
if err != nil {
log.Fatalf("Error updating document: %s", err)
}
// 获取响应中的状态码和 ID
statusCode := res.StatusCode
id := res.Id
fmt.Printf("Document updated, status code: %d, id: %s\n", statusCode, id)
}
func deleteDocument(es *elasticsearch.Client) {
// 发送请求删除指定 ID 的文档
res, err := es.Delete(
"my_index",
"1",
es.Delete.WithRefresh("true"),
es.Delete.WithContext(context.Background()),
)
if err != nil {
log.Fatalf("Error deleting document: %s", err)
}
// 获取响应中的状态码和 ID
statusCode := res.StatusCode
id := res.Id
fmt.Printf("Document deleted, status code: %d, id: %s\n", statusCode, id)
}
func deleteIndex(es *elasticsearch.Client) {
// 发送请求删除索引
res, err := es.Indices.Delete(
[]string{"my_index"},
es.Indices.Delete.WithIgnoreUnavailable(true), // 如果索引不存在，则忽略错误
es.Indices.Delete.WithContext(context.Background()),
)
if err != nil {
log.Fatalf("Error deleting index: %s", err)
}
// 获取响应中的状态码和索引名称
statusCode := res.StatusCode
indexName := res.Index
fmt.Printf("Index deleted, status code: %d, index name: %s\n", statusCode, indexName)
}在上面的代码中，我们首先创建了一个默认配置的 Elasticsearch 客户端（elasticsearch.NewDefaultClient()）。然后，我们分别实现了创建索引、添加文档、获取文档、更新文档以及删除文档和删除索引等操作。
需要注意的是，在执行这些操作时，可以使用不同的选项来定制请求参数，以满足不同的需求。例如：
- WithDocumentID()：指定文档 ID。
- WithBodyJSON()：指定请求体中包含的 JSON 数据。
- WithRefresh()：控制何时使文档可用于搜索（仅用于测试）。
- WithIgnoreUnavailable()：如果索引不存在，则忽略错误。
在 Go 中进行 ES 索引操作和文档操作非常简单，只需使用 Elasticsearch 官方提供的 Go 客户端库即可。
五，es 读写机制
在 Elasticsearch 中，数据存储在分片（Shard）中，并且每个分片都可以有多个副本。这意味着写入和读取操作涉及到许多网络通信和数据复制等操作，因此需要一些特殊的机制来管理读写请求。
以下是 Elasticsearch 中的一些常见的读写机制：
写入机制
- 数据先被写入主分片（Primary Shard）。主分片负责处理所有文档的添加、更新和删除操作。
- 如果有副本分片，则主分片会将数据复制到其它副本上。这样可以保证数据的可靠性和冗余性。
- 当客户端发送写请求时，Elasticsearch 会使用 write consistency level 选项来控制写入操作的行为。write consistency level 有以下几种级别：
- one：只需将数据写入一个节点即可返回成功响应。
- quorum：至少需要将数据写入大多数节点才能返回成功响应。
- all：需要将数据写入所有节点才能返回成功响应。
- 在向客户端返回成功响应之前，Elasticsearch 会执行 refresh 操作以确保新添加或修改过的文档可以立即被搜索。
读取机制
- 客户端发送 read 请求时，Elasticsearch 会根据 request consistency level 选项来确定从哪些节点获取数据。request consistency level 有以下几种级别：
- one：只需从一个节点获取数据即可返回成功响应。
- quorum：需要从大多数节点获取数据才能返回成功响应。
- all：需要从所有节点获取数据才能返回成功响应。
- 如果请求的分片或副本尚未完成写入，则读取操作可能会失败。为了避免这种情况，可以使用 refresh 操作来强制刷新索引以确保文档可用于搜索。
以上是 Elasticsearch 中常见的读写机制，可以通过一些选项来调整和控制它们的行为。在 Go 中使用 Elasticsearch 官方提供的 Go 客户端库时，可以通过在请求中设置相关选项来管理读写请求。
六，es 匹配查询，范围查询，多条件查询
在 Elasticsearch 中，可以使用各种查询来搜索和过滤文档。以下是一些常见的查询类型：
匹配查询
匹配查询是最简单和最基本的查询类型之一，用于查找一个或多个字段中包含指定字符串的文档。在 Go 中，可以使用 MatchQuery 来执行匹配查询。
import (
"context"
"fmt"
"github.com/elastic/go-elasticsearch/v7"
"github.com/elastic/go-elasticsearch/v7/esapi"
)
func main() {
es, _ := elasticsearch.NewDefaultClient()
var buf bytes.Buffer
query := map[string]interface{}{
"query": map[string]interface{}{
"match": map[string]interface{}{
"name": "John",
},
},
}
if err := json.NewEncoder(&buf).Encode(query); err != nil {
log.Fatalf("Error encoding query: %s", err)
}
res, err := es.Search(
es.Search.WithContext(context.Background()),
es.Search.WithIndex("my-index"),
es.Search.WithBody(&buf),
es.Search.WithTrackTotalHits(true),
es.Search.WithPretty(),
)
if err != nil {
log.Fatalf("Error getting response: %s", err)
}
}范围查询
范围查询用于查找指定字段中符合指定范围条件的文档。在 Go 中，可以使用 RangeQuery 来执行范围查询。
import (
"context"
"fmt"
"github.com/elastic/go-elasticsearch/v7"
"github.com/elastic/go-elasticsearch/v7/esapi"
)
func main() {
es, _ := elasticsearch.NewDefaultClient()
var buf bytes.Buffer
query := map[string]interface{}{
"query": map[string]interface{}{
"range": map[string]interface{}{
"age": map[string]interface{}{
"gte": 30,
"lte": 40,
},
},
},
}
if err := json.NewEncoder(&buf).Encode(query); err != nil {
log.Fatalf("Error encoding query: %s", err)
}
res, err := es.Search(
es.Search.WithContext(context.Background()),
es.Search.WithIndex("my-index"),
es.Search.WithBody(&buf),
es.Search.WithTrackTotalHits(true),
es.Search.WithPretty(),
)
if err != nil {
log.Fatalf("Error getting response: %s", err)
}
}多条件查询
多条件查询允许同时使用多个查询条件来过滤文档。在 Go 中，可以使用 BoolQuery 来执行多条件查询。
import (
"context"
"fmt"
"github.com/elastic/go-elasticsearch/v7"
"github.com/elastic/go-elasticsearch/v7/esapi"
)
func main() {
es, _ := elasticsearch.NewDefaultClient()
var buf bytes.Buffer
query := map[string]interface{}{
"query": map[string]interface{}{
"bool": map[string]interface{}{
"must": []map[string]interface{}{ // 所有子条件必须匹配
{"match": {"name": "John"}},
{"range": {"age": {"gte": 30}}},
},
"should": []map[string]interface{}{ // 至少有一个子条件匹配
{"match_phrase_prefix":{"description":"quick brown fox"}},
{"term":{"is_published":true}},
},
"must_not": []map[string]interface{}{ // 所有子条件都不匹配
{"match": {"gender": "female"}},
},
},
},
}
if err := json.NewEncoder(&buf).Encode(query); err != nil {
log.Fatalf("Error encoding query: %s", err)
}
res, err := es.Search(
es.Search.WithContext(context.Background()),
es.Search.WithIndex("my-index"),
es.Search.WithBody(&buf),
es.Search.WithTrackTotalHits(true),
es.Search.WithPretty(),
)
if err != nil {
log.Fatalf("Error getting response: %s", err)
}
}以上是 Elasticsearch 中常见的查询类型和 Go 客户端库中对应的使用方法。可以根据具体需求来选择合适的查询类型和选项来搜索和过滤文档。
七，es 中文分词，聚合查询
在 Elasticsearch 中，中文分词和聚合查询是非常常见的功能。以下是如何在 Go 中使用官方客户端库实现这些功能：
中文分词
Elasticsearch 默认支持中文分词器，可以使用 ik_max_word 或 ik_smart 分词器来处理中文字段。在 Go 中，可以通过 mapping 来指定字段的类型和分词器。
import (
"context"
"fmt"
"github.com/elastic/go-elasticsearch/v7"
"github.com/elastic/go-elasticsearch/v7/esapi"
)
func main() {
es, _ := elasticsearch.NewDefaultClient()
var mapping = `
{
"mappings": {
"properties": {
"content": {
"type": "text",
"analyzer": "ik_max_word" // 使用 ik_max_word 分词器
}
}
}
}`
res, err := es.Indices.Create(
[]string{"my-index"},
es.Indices.Create.WithBody(strings.NewReader(mapping)),
es.Indices.Create.WithPretty(),
)
if err != nil {
log.Fatalf("Error creating index: %s", err)
}
}然后，在执行查询时，可以使用 MatchQuery 或其他查询类型来搜索包含指定关键字的文档。
var buf bytes.Buffer
query := map[string]interface{}{
"query": map[string]interface{}{
"match": map[string]interface{}{
"content": "中国",
},
},
}
if err := json.NewEncoder(&buf).Encode(query); err != nil {
log.Fatalf("Error encoding query: %s", err)
}
res, err := es.Search(
es.Search.WithContext(context.Background()),
es.Search.WithIndex("my-index"),
es.Search.WithBody(&buf),
es.Search.WithTrackTotalHits(true),
es.Search.WithPretty(),
)
if err != nil {
log.Fatalf("Error getting response: %s", err)
}聚合查询
聚合查询是对搜索结果进行分组、统计和分析的一种功能。在 Go 中，可以使用 Aggregations 和 Bucket 来执行聚合查询。
var buf bytes.Buffer
query := map[string]interface{}{
"size": 0,
"aggs": map[string]interface{}{
"group_by_category": map[string]interface{}{
"terms": map[string]interface{}{
"field": "category",
},
},
"stats_on_price": map[string]interface{}{
"stats": map[string]interface{}{
"field": "price",
},
},
},
}
if err := json.NewEncoder(&buf).Encode(query); err != nil {
log.Fatalf("Error encoding query: %s", err)
}
res, err := es.Search(
es.Search.WithContext(context.Background()),
es.Search.WithIndex("my-index"),
es.Search.WithBody(&buf),
es.Search.WithTrackTotalHits(true),
)
if err != nil {
log.Fatalf("Error getting response: %s", err)
}
defer res.Body.Close()
var r map[string]interface{}
if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
log.Printf("Error parsing the response body: %s", err)
} else {
// 处理聚合结果
groupByCategoryBuckets := r["aggregations"].(map[string]interface{})["group_by_category"].(map[string]interface{})["buckets"].([]interface{})
for _, bucket := range groupByCategoryBuckets {
key := bucket.(map[string]interface{})["key"]
docCount := bucket.(map[string]interface{})["doc_count"]
fmt.Printf("%s: %d\n", key, docCount)
}
statsOnPrice := r["aggregations"].(map[string]interface{})["stats_on_price"].(map[string]interface{})
count := statsOnPrice["count"]
min := statsOnPrice["min"]
max := statsOnPrice["max"]
avg := statsOnPrice["avg"]
sum := statsOnPrice["sum"]
fmt.Printf("count: %v, min: %v, max: %v, avg: %v, sum: %v\n", count, min, max, avg, sum)
}以上是在 Go 中使用官方 Elasticsearch 客户端库执行中文分词和聚合查询的示例。可以根据具体需求来选择合适的分词器和聚合查询选项。
八，es go驱动包操作，索引以及文档操作
在 Go 中，可以使用官方 Elasticsearch 客户端库来进行索引和文档操作。
创建索引
创建一个新的索引，需要指定名称和映射。以下是一个示例：
import (
"context"
"fmt"
"github.com/elastic/go-elasticsearch/v7"
)
func main() {
es, _ := elasticsearch.NewDefaultClient()
mapping := `{
"mappings": {
"properties": {
"name": { "type": "text" },
"age": { "type": "integer" }
}
}
}`
res, err := es.Indices.Create(
[]string{"my-index"},
es.Indices.Create.WithBody(strings.NewReader(mapping)),
es.Indices.Create.WithContext(context.Background()),
)
if err != nil {
log.Fatalf("Error creating index: %s", err)
}
defer res.Body.Close()
fmt.Println("Index created")
}删除索引
删除一个已存在的索引，只需要指定名称即可。以下是一个示例：
res, err := es.Indices.Delete(
[]string{"my-index"},
es.Indices.Delete.WithContext(context.Background()),
)
if err != nil {
log.Fatalf("Error deleting index: %s", err)
}
defer res.Body.Close()
fmt.Println("Index deleted")添加文档
向指定的索引中添加文档，需要指定文档 ID 和文档内容。以下是一个示例：
doc := `{
"name": "John",
"age": 30
}`
res, err := es.Index(
"my-index",
strings.NewReader(doc),
es.Index.WithDocumentID("1"),
es.Index.WithContext(context.Background()),
)
if err != nil {
log.Fatalf("Error indexing document: %s", err)
}
defer res.Body.Close()
fmt.Println("Document added")获取文档
从指定的索引中获取文档，需要指定文档 ID。以下是一个示例：
res, err := es.Get(
"my-index",
"1",
es.Get.WithContext(context.Background()),
)
if err != nil {
log.Fatalf("Error getting document: %s", err)
}
defer res.Body.Close()
var r map[string]interface{}
if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
log.Fatalf("Error parsing the response body: %s", err)
}
doc := r["_source"].(map[string]interface{})
fmt.Printf("Name: %s, Age: %d\n", doc["name"], int(doc["age"].(float64)))更新文档
更新一个已存在的文档，需要指定文档 ID 和更新内容。以下是一个示例：
updateDoc := `{
"doc": {
"age": 35
}
}`
res, err := es.Update(
"my-index",
"1",
strings.NewReader(updateDoc),
es.Update.WithContext(context.Background()),
)
if err != nil {
log.Fatalf("Error updating document: %s", err)
}
defer res.Body.Close()
fmt.Println("Document updated")以上是在 Go 中使用官方 Elasticsearch 客户端库进行索引和文档操作的一些示例。可以根据具体需求来选择合适的选项和参数。
九，es 高级查询：term，match，aggregation
在 Go 中，可以使用官方 Elasticsearch 客户端库来进行高级查询，包括 term、match 和聚合操作。
Term 查询
Term 查询是一个完全匹配的查询。它查找指定字段中包含指定值的文档。以下是一个示例：
import (
"context"
"fmt"
"github.com/elastic/go-elasticsearch/v7"
)
func main() {
es, _ := elasticsearch.NewDefaultClient()
var buf bytes.Buffer
query := map[string]interface{}{
"query": map[string]interface{}{
"term": map[string]string{
"name.keyword": "John",
},
},
}
if err := json.NewEncoder(&buf).Encode(query); err != nil {
log.Fatalf("Error encoding query: %s", err)
}
res, err := es.Search(
es.Search.WithContext(context.Background()),
es.Search.WithIndex("my-index"),
es.Search.WithBody(&buf),
es.Search.WithTrackTotalHits(true),
es.Search.WithPretty(),
)
if err != nil {
log.Fatalf("Error searching for documents: %s", err)
}
defer res.Body.Close()
var r map[string]interface{}
if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
log.Fatalf("Error parsing the response body: %s", err)
}
totalHits := int(r["hits"].(map[string]interface{})["total"].(map[string]interface{})["value"].(float64))
fmt.Printf("Found %d documents\n", totalHits)
}Match 查询
Match 查询会根据查询条件对指定字段进行分词并搜索匹配的文档。以下是一个示例：
var buf bytes.Buffer
query := map[string]interface{}{
"query": map[string]interface{}{
"match": map[string]string{
"name": "John",
},
},
}
if err := json.NewEncoder(&buf).Encode(query); err != nil {
log.Fatalf("Error encoding query: %s", err)
}
res, err := es.Search(
es.Search.WithContext(context.Background()),
es.Search.WithIndex("my-index"),
es.Search.WithBody(&buf),
es.Search.WithTrackTotalHits(true),
es.Search.WithPretty(),
)
if err != nil {
log.Fatalf("Error searching for documents: %s", err)
}
defer res.Body.Close()
var r map[string]interface{}
if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
log.Fatalf("Error parsing the response body: %s", err)
}
totalHits := int(r["hits"].(map[string]interface{})["total"].(map[string]interface{})["value"].(float64))
fmt.Printf("Found %d documents\n", totalHits)Aggregation
聚合操作可以对搜索结果进行统计和分析，例如计算平均值、最大值等。以下是一个示例：
var buf bytes.Buffer
aggQuery := map[string]interface{}{
"aggs": map[string]interface{}{
"avg_age": map[string]interface{}{
"avg": map[string]interface{}{
"field": "age",
},
},
},
}
query := map[string]interface{}{
"size": 0,
}
query["aggs"] = aggQuery
if err := json.NewEncoder(&buf).Encode(query); err != nil {
log.Fatalf("Error encoding query: %s", err)
}
res, err := es.Search(
es.Search.WithContext(context.Background()),
es.Search.WithIndex("my-index"),
es.Search.WithBody(&buf),
es.Search.WithTrackTotalHits(true),
es.Search.WithPretty(),
)
if err != nil {
log.Fatalf("Error searching for documents: %s", err)
}
defer res.Body.Close()
var r map[string]interface{}
if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
log.Fatalf("Error parsing the response body: %s", err)
}
aggResult := r["aggregations"].(map[string]interface{})["avg_age"].(map[string]interface{})
avgAge := aggResult["value"].(float64)
fmt.Printf("Average age is %f\n", avgAge)以上是在 Go 中使用官方 Elasticsearch 客户端库进行 term、match 和聚合操作的一些示例。可以根据具体需求来选择合适的选项和参数。