Elasticsearch 聚合查询（下）

最新推荐文章于 2024-06-13 14:26:00 发布
最新推荐文章于 2024-06-13 14:26:00 发布
阅读量182 收藏
点赞数
分类专栏： 人在江湖之Elasticsearch 文章标签： elasticsearch 分组查询 聚合查询 having group by 脚本
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/forlinkext/article/details/131371800
版权

文章目录

按条件聚合

例如：查询 30 岁以下的人的 “age” 统计信息

  1. 使用 query 条件进行过滤
{
    "size": 0,
    "query":{
        "range":{
            "age":{
                "lte":30
            }
        }
    },
    "aggs" :{
        "age_aggs":{
            "stats":{
                "field":"age"
            }
        }
    }
}

结果：

{
    "took": 6,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 514,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "age_aggs": {
            "count": 514,
            "min": 10.0,
            "max": 30.0,
            "avg": 20.445525291828794,
            "sum": 10509.0
        }
    }
}
  1. 使用 filter 进行过滤
{
    "size": 0,
    "aggs" :{
        "filter_aggs":{ 
            "filter":{
                "range":{
                    "age":{
                        "lte":30
                    }
                }
            },
            "aggs":{
                "age_stat":{ "stats":{"field":"age"}}
            }
        }
    }
}

注：此示例出现了 aggs 嵌套，这个我们在下面再说，此处先关注 filter 的使用

结果：

{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1003,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "filter_aggs": {
            "doc_count": 514,
            "age_stat": {
                "count": 514,
                "min": 10.0,
                "max": 30.0,
                "avg": 20.445525291828794,
                "sum": 10509.0
            }
        }
    }
}

filters 多条件聚合

列如：查询 10 ~ 20 岁 和 20 ~ 30 岁的文档个数

{
    "size": 0,
    "aggs" :{
        "state_f":{ 
            "filters":{
                "filters":{
                    "a1020":{
                        "range":{"age":{"gte":"10","lt":"20"}}
                    },
                    "a2030":{
                        "range":{"age":{"gte":"20","lt":"30"}}
                    }
                }
            }
        }
    }
}

查询结果：

{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1003,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "state_f": {
            "buckets": {
                "a1020": {
                    "doc_count": 219
                },
                "a2030": {
                    "doc_count": 268
                }
            }
        }
    }
}

other_bucket_key 统计其他

列如：查询 10 ~ 20 岁 和 20 ~ 30 岁 和 其他情况的文档个数

{
    "size": 0,
    "aggs" :{
        "state_f":{ 
            "filters":{
                "other_bucket_key": "others",
                "filters":{
                    "a1020":{
                        "range":{"age":{"gte":"10","lt":"20"}}
                    },
                    "a2030":{
                        "range":{"age":{"gte":"20","lt":"30"}}
                    }
                }
            }
        }
    }
}

查询结果

{
    "took": 7,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1003,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "state_f": {
            "buckets": {
                "a1020": {
                    "doc_count": 219
                },
                "a2030": {
                    "doc_count": 268
                },
                "others": {
                    "doc_count": 516
                }
            }
        }
    }
}

嵌套聚合

列如：查询 10 ~ 20 岁 和 20 ~ 30 岁 和 其他年龄段的年龄统计数据（max、min、sum、avg、count）

{
    "size": 0,
    "aggs" :{
        "state_f":{ 
            "filters":{
                "other_bucket_key": "others",
                "filters":{
                    "a1020":{
                        "range":{"age":{"gte":"10","lt":"20"}}
                    },
                    "a2030":{
                        "range":{"age":{"gte":"20","lt":"30"}}
                    }
                }
            },
            "aggs":{
                "state_age":{"stats":{"field":"age"}}
            }
        }
    }
}

注意json对象的层数，以及对应的字段所在层数。

按聚合结果进行排序（桶排序）

列如：查询 10 ~ 20 岁 和 20 ~ 30 岁 和 其他年龄段的年龄统计数据（max、min、sum、avg、count）并按统计求和数进行降序

{
    "size": 0,
    "aggs" :{
        "state_f":{ 
            "filters":{
                "other_bucket_key": "others",
                "filters":{
                    "a1020":{
                        "range":{"age":{"gte":"10","lt":"20"}}
                    },
                    "a2030":{
                        "range":{"age":{"gte":"20","lt":"30"}}
                    }
                }
            },
            "aggs":{
                "stats_age":{"stats":{"field":"age"}},
                "sum_age_sort":{
                    "bucket_sort":{
                        "sort":[{
                            "stats_age.sum": { "order": "desc" }
                        }]
                    }
                }
            }
        }
    }
}

因为 stats_age 返回是一个对象，所以在桶排序中sort的字段为stats_age.sum。

参数说明

sum_age_sort 是我们自定义的排序的名称，bucket_sort 表示桶排序，bucket_sort 有如下几个参数：

  • sort：排序规则列表（与我们 查询进阶 一章的排序规则一样）
  • from：排序的桶的开始位置。默认为0
  • size：要返回的排序桶的数量。默认为所有桶。（即：默认对所有桶进行排序）
  • gap_policy：在数据中发现差距时应用的策略。默认是 skip

数据的差距

我们的数据通常充满噪音或间隙，常见的原因：

  • 落入桶中的文档不包含必填字段
  • 没有与一个或多个存储桶的查询相匹配的文档
  • 正在计算的指标无法生成值，可能是因为另一个依赖存储桶缺少值。或者要计算的值不满足特定的要求等等。

数据差距策略

  • skip：将丢失的数据视为存储桶不存在。它将跳过存储桶并使用下一个可用值继续计算。
  • insert_zeros（插入0）：此选项将用零 ( 0) 替换缺失值，并且管道聚合计算将正常进行。
  • keep_values（保留值）：此选项与跳过类似，除非指标提供非空、非 NaN 值，否则使用该值，否则将跳过空存储桶。
{
    "took": 4,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1003,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "state_f": {
            "buckets": {
                "others": {
                    "doc_count": 516,
                    "stats_age": {
                        "count": 516,
                        "min": 30.0,
                        "max": 50.0,
                        "avg": 39.9031007751938,
                        "sum": 20590.0
                    }
                },
                "a2030": {
                    "doc_count": 268,
                    "stats_age": {
                        "count": 268,
                        "min": 20.0,
                        "max": 29.0,
                        "avg": 24.473880597014926,
                        "sum": 6559.0
                    }
                },
                "a1020": {
                    "doc_count": 219,
                    "stats_age": {
                        "count": 219,
                        "min": 10.0,
                        "max": 19.0,
                        "avg": 14.337899543378995,
                        "sum": 3140.0
                    }
                }
            }
        }
    }
}

以聚合结果进行再聚合（管道聚合）

查询 10 ~ 20 岁 和 20 ~ 30 岁 和 其他年龄段的年龄统计数据（max、min、sum、avg、count），并查询平均年龄最小的桶

min_bucket 最小桶

{
    "size": 0,
    "aggs" :{
        "state_f":{ 
            "filters":{
                "other_bucket_key": "others",
                "filters":{
                    "a1020":{
                        "range":{"age":{"gte":"10","lt":"20"}}
                    },
                    "a2030":{
                        "range":{"age":{"gte":"20","lt":"30"}}
                    }
                }
            },
            "aggs":{
                "state_age":{"stats":{"field":"age"}}
            }
        },
        "sss":{
            "min_bucket":{
                "buckets_path": "state_f  > state_age.avg"
            }
        }
    }
}

sss 的结果即是我们的最小桶

示例 buckets_path 说明

state_f > state_age.avg ，表示按 state_f（聚合的名称）的结果指标 state_age 的 avg 的值来度量。如果是 min_bucket 则取最小的桶。注意：> 不是小于符号

结果

{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1003,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "state_f": {
            "buckets": {
                "a1020": {
                    "doc_count": 219,
                    "state_age": {
                        "count": 219,
                        "min": 10.0,
                        "max": 19.0,
                        "avg": 14.337899543378995,
                        "sum": 3140.0
                    }
                },
                "a2030": {
                    "doc_count": 268,
                    "state_age": {
                        "count": 268,
                        "min": 20.0,
                        "max": 29.0,
                        "avg": 24.473880597014926,
                        "sum": 6559.0
                    }
                },
                "others": {
                    "doc_count": 516,
                    "state_age": {
                        "count": 516,
                        "min": 30.0,
                        "max": 50.0,
                        "avg": 39.9031007751938,
                        "sum": 20590.0
                    }
                }
            }
        },
        "sss": {
            "value": 14.337899543378995,
            "keys": [
                "a1020"
            ]
        }
    }
}

min_bucket 是取最小桶，同理 max_bucket 取最大桶。

sum_bucket 桶求和

查询 10 ~ 20 岁 和 20 ~ 30 岁 和 其他年龄段的年龄统计数据（max、min、sum、avg、count），并计算平均年龄之和

{
    "size": 0,
    "aggs" :{
        "state_f":{ 
            "filters":{
                "other_bucket_key": "others",
                "filters":{
                    "a1020":{
                        "range":{"age":{"gte":"10","lt":"20"}}
                    },
                    "a2030":{
                        "range":{"age":{"gte":"20","lt":"30"}}
                    }
                }
            },
            "aggs":{
                "state_age":{"stats":{"field":"age"}}
            }
        },
        "sss":{
            "sum_bucket":{
                "buckets_path": "state_f  > state_age.avg"
            }
        }
    }
}

结果

{
    "took": 5,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1003,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "state_f": {
            "buckets": {
                "a1020": {
                    "doc_count": 219,
                    "state_age": {
                        "count": 219,
                        "min": 10.0,
                        "max": 19.0,
                        "avg": 14.337899543378995,
                        "sum": 3140.0
                    }
                },
                "a2030": {
                    "doc_count": 268,
                    "state_age": {
                        "count": 268,
                        "min": 20.0,
                        "max": 29.0,
                        "avg": 24.473880597014926,
                        "sum": 6559.0
                    }
                },
                "others": {
                    "doc_count": 516,
                    "state_age": {
                        "count": 516,
                        "min": 30.0,
                        "max": 50.0,
                        "avg": 39.9031007751938,
                        "sum": 20590.0
                    }
                }
            }
        },
        "sss": {
            "value": 78.71488091558771
        }
    }
}

注意：min_bucket 、max_bucket 、sum_bucket 都是聚合同级的桶。

bucket_script 聚合（桶）脚本

示例：查询男女的最大年龄差。即：男最大年龄 - 男最小年龄；女最大年龄 - 最小年龄；

{
    "size": 0,
    "aggs" :{
        "group_sex":{ 
            "terms":{
                "field":"sex"
            },
            "aggs":{
                "stats_age":{
                    "stats":{
                        "field":"age"
                    }
                },
                "sex-percentage": {
                    "bucket_script": {
                        "buckets_path": {
                            "age_min": "stats_age.min",
                            "age_max": "stats_age.max"
                        },
                        "script": "params.age_max  - params.age_min"
                    }
                }
            }
        }
        
    }
}

这里用到了 bucket_script 来进行相关的计算返回，使用是注意 bucket_script 只能用在子聚合中，注意层次，其次需要注意 bucket_script 的计算结果只能是数字类型。关于脚本的详细讲解，我们会在后面具体章节来说。这里 bucket_script 把 buckets_path 定义的字段作为参数在 script 脚本中进行计算

执行结果：

{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1003,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "group_sex": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": 1,
                    "doc_count": 511,
                    "stats_age": {
                        "count": 511,
                        "min": 10.0,
                        "max": 50.0,
                        "avg": 30.031311154598825,
                        "sum": 15346.0
                    },
                    "sex-percentage": {
                        "value": 40.0
                    }
                },
                {
                    "key": 0,
                    "doc_count": 492,
                    "stats_age": {
                        "count": 492,
                        "min": 10.0,
                        "max": 50.0,
                        "avg": 30.371951219512194,
                        "sum": 14943.0
                    },
                    "sex-percentage": {
                        "value": 40.0
                    }
                }
            ]
        }
    }
}

由于我们数据的特殊原因，此处计算出的男女的年龄差都是40

bucket_selector 过滤桶聚合

查询 10 ~ 20 岁 和 20 ~ 30 岁 和 其他年龄段的年龄统计数据（max、min、sum、avg、count），并筛选平均年龄大于20的桶

{
    "size": 0,
    "aggs" :{
        "state_f":{ 
            "filters":{
                "other_bucket_key": "others",
                "filters":{
                    "a1020":{
                        "range":{"age":{"gte":"10","lt":"20"}}
                    },
                    "a2030":{
                        "range":{"age":{"gte":"20","lt":"30"}}
                    }
                }
            },
            "aggs":{
                "state_age":{"stats":{"field":"age"}},
                "age_bucket_filter":{
                    "bucket_selector":{
                        "buckets_path":{
                            "bucket_avg_age":"state_age.avg"
                        },
                        "script": "params.bucket_avg_age > 20"
                    }
                }
            }
        }
    }
}

使用 bucket_selector 来实现分组的过滤，此方式类似于 sql 的 having 查询，script 脚本中的 20 可以定义为脚本参数，我们甚至可以预定义脚本，这都是我们后续脚本编写一章中再说。

结果

{
    "took": 182,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1003,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "state_f": {
            "buckets": {
                "a2030": {
                    "doc_count": 268,
                    "state_age": {
                        "count": 268,
                        "min": 20.0,
                        "max": 29.0,
                        "avg": 24.473880597014926,
                        "sum": 6559.0
                    }
                },
                "others": {
                    "doc_count": 516,
                    "state_age": {
                        "count": 516,
                        "min": 30.0,
                        "max": 50.0,
                        "avg": 39.9031007751938,
                        "sum": 20590.0
                    }
                }
            }
        }
    }
}

注意我们的示例其实没有实际的意义，只为了讲解 bucket_selector 的用法而已，实际中，可能是计算商品总金额超过800w的某些类型的商品。

没事儿写两篇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java对es做聚合查询_java操作elasticsearch实现聚合查询
weixin_34244326的博客
02-27 5267
1、max 最大值//max 求最大值@Testpublic void test30() throws UnknownHostException{//1、指定es集群 cluster.name 是固定的key值，my-application是ES集群的名称Settings settings = Settings.builder().put("cluster.name", "my-applicat...
Elasticsearch 聚合查询(aggs)
m0_63099094的博客
11-06 2079
测试聚合 创建索引： PUT /cars { “settings”: { “number_of_shards”: 1, “number_of_replicas”: 0 }, “mappings”: { “transactions”: { “properties”: { “color”: { “type”: “keyword” }, “make”: { “type”: “keyword” } } } } } 注意：在ES中，需要进行聚合、排序、过滤的字段其处理方式比较特殊，因此不能被分词。这里我们将colo
ElasticSearch 聚合查询语法解析
勤于笔记，成于点滴。
02-06 885
ElasticSearch 聚合查询语法j解析,在一些企业制定化需求中有很多特殊的场景，需要我们去聚合数据来满足业务需求，如sum、avg、value_count、max、min等指标聚合，terms、histogram、date_histogram、range等桶聚合函数。
elasticsearch 查询聚合操作
qq_50761817的博客
04-16 1143
2、模糊查询 关键词：wildcard 匹配出状态码status 以 5 开头的日志 3、指定某个值 同时匹配多个字段 关键词：multi_match query 要查询的值 fields 要匹配的字段【数组】 匹配出 字段code和status 为400的所有日志 4、一个字段查询多个值 关键词：terms { “字段”：[ 要匹配的多个值 ] } 5、多种组合查询 关键词：bool must should range size sort 6、es默认时间格式查询/ java时间查
Elasticsearch Aggregation 聚合查询
uxff的专栏
04-09 4452
聚合API ES中的Aggregations API是从Facets功能基础上发展而来，官网正在进行替换计划，建议用户使用Aggregations API，而不是Facets API。ES中的聚合上可以分为下面两类： metric（度量）聚合：度量类型聚合主要针对的number类型的数据，需要ES做比较多的计算工作 bucketing（桶）聚合：划分不同的“桶”，将数据分配到不同的“桶”...
java使用elasticsearch分组进行聚合查询过程解析
08-25
主要介绍了java使用elasticsearch分组进行聚合查询过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
elasticsearch聚合后分页
12-16
方法如果传总页数了，es就不用查询总页数，直接通过开始位置到结束位置取数即可
Elasticsearch高级聚合查询
09-22
代码示例
elasticSearch查询语句DSL
06-27
在这篇资源中，我们将详细介绍如何使用DSL...最后，我们将分享一些实用技巧和最佳实践，帮助您充分发挥DSL在Elasticsearch中的优势。我们将探讨性能优化、查询调试和索引优化等关键主题，以提升查询效率和搜索准确性。
ES 聚合查询结果转换成相应的List对象
07-11
ES 聚合查询结果转换成相应的对象集合，ES 聚合查询结果转换成相应的对象集合
Elasticsearch 认证模拟题 - 12
Wolf_xujie的博客
06-08 416
索引中包含了过去11个月的地震信息，请通过一句查询，获取以下信息。
vscode 中 eslint 无效？npm init 是什么？
笔记本
06-07 689
项目配置了 eslint，但是 vscode 并不能实时提示。研究后发现是 vscode 版本过旧，不能识别新版 eslint 的配置文件，升级 vscode 和其 eslint 插件即可解决。在此过程中，简单了解了 npm init 的用法。
git版本管理工具
You辉编程的博客
06-08 1050
git管理工具
#15松桑前端后花园周刊-Turborepo 2.0、ESLint v9.4.0、重新学习promise、CSS gap
weixin_43303603的博客
06-10 1022
ESLint 用户没有升级到 ESLint v9.x 的最大原因之一是迁移配置文件似乎很困难和复杂。因此 Eslint 推出支持将. eslintrc 文件迁移到 eslint.config.js，以帮助用户提高配置文件的速度。
Elasticsearch 认证模拟题 - 11
Wolf_xujie的博客
06-08 404
仔细看题，似乎并不需要索引模板，但是我在官网没找到不适用模板就建立数据流的方法。2. 聚合a值小于-2的文档。3. 聚合-5到5之间的文档。按照上述要求建立数据流。4. 聚合大于5的文档。
程序员学习Processing和TouchDesigner视觉编程相关工具
那个西瓜有点甜
06-09 593
TouchDesigner 是一个强大的实时交互式创意软件平台，用于构建和展示实时图形、音频、视频和交互式内容。用户可以利用它进行视频合成、分析、变形、过滤、映射等操作，用于创建视觉艺术作品、舞台背景、实时视频表演等。艺术家和设计师可以利用它创建各种各样的互动装置、实时投影映射作品、互动艺术展览等，为观众带来沉浸式的体验。: TouchDesigner 还支持实时数据可视化，用户可以将实时数据源（如传感器数据、网络数据、音频数据等）与图形和视觉效果进行结合，创建动态的数据可视化作品。
【Bazel入门与精通】 rules之属性
06-10 962
属性可以为目标的 implementation 提供特定值，也可以引用其他目标，从而创建依赖关系图。
Vue3表单组件el-form校验规则rules属性
最新发布
李长渊的博客
06-13 284
Vue3表单组件el-form校验规则rules属性
PostgreSQL的视图pg_rules
lee_vincent1的博客
06-11 411
是 PostgreSQL 中的一个系统视图，用于显示数据库中存在的规则（rules）的相关信息。规则是一种允许在表的查询、插入、更新或删除操作上定义自定义行为的机制。通过查询 视图，数据库管理员和开发人员可以查看当前数据库中定义的所有规则信息。以下是一些常用的查询示例，可以帮助你获取和分析规则的信息。 查看特定模式下的所有规则 查看特定表的所有规则 查看特定规则的信息 显示所有规则及其所属的表和定义 获取所有规则的完整信息 查看特定表的所有规则定义 根据规则名称查找规则 通过 视图，数据库
es 聚合查询排除null_elasticsearch 聚合查询篇
06-02
好的，针对您的问题，您可以使用 Elasticsearch 的聚合查询中的“missing”聚合来排除 null 值。 具体来说，您可以使用以下的聚合查询语句： ``` { "aggs": { "field_name": { "missing": { "field": "your_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值