Elasticsearch聚合查询

最新推荐文章于 2024-06-27 20:30:00 发布
最新推荐文章于 2024-06-27 20:30:00 发布
阅读量405 收藏 2
点赞数 2
分类专栏： Elasticsearch 文章标签： elasticsearch 聚合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jingyoushui/article/details/101222158
版权

本文使用的elasticsearch为6.x版本，7.x版本不支持文档的类型type了。使用相对应版本的kibana进行对elasticsearch的操作。
创建索引：

PUT /user2
{
    "settings": {
        "index": {
            "number_of_shards": "1",
            "number_of_replicas": "0"
        }
    },
    "mappings": {
        "user":{
        "properties": {
            "name": {
                "type": "text"
            },
            "age": {
                "type": "integer"
            },
            "mail": {
                "type": "keyword"
            },
            "hobby": {
                "type": "text",
                "analyzer":"ik_max_word"
            }
        }
        }
    }
}

批量添加数据：

POST user2/_bulk
{"index":{"_index":"user2","_type":"user"}}
{"name":"张三","age": 20,"mail": "111@qq.com","hobby":"羽毛球、乒乓球、足球"}
{"index":{"_index":"user2","_type":"user"}}
{"name":"李四","age": 21,"mail": "222@qq.com","hobby":"羽毛球、乒乓球、足球、篮球"}
{"index":{"_index":"user2","_type":"user"}}
{"name":"王五","age": 21,"mail": "333@qq.com","hobby":"羽毛球、篮球、游泳、听音乐"}
{"index":{"_index":"user2","_type":"user"}}
{"name":"赵六","age": 24,"mail": "444@qq.com","hobby":"跑步、游泳、篮球"}
{"index":{"_index":"user2","_type":"user"}}
{"name":"孙七","age": 24,"mail": "555@qq.com","hobby":"羽毛球、乒乓球、足球"}

在这里插入图片描述
聚合查询：

  • 求和：
GET user2/user/_search
{
  "size": 0, 
  "aggs":{
    "age_of_sum":{
      "sum": {
        "field": "age"
      }
    }
  }
}

size不需要返回文档,可以直接设置为0.可以提高查询速度
aggsaggregations的缩写
age_of_sum聚合的名字，随意写
sum用来求和
返回结果：

{
  "took": 0,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 5,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "age_of_sum": {
      "value": 110
    }
  }
}
  • 求最小值：
GET user2/user/_search
{
  "size": 0, 
  "aggs":{
    "age_of_min":{
      "min": {
        "field": "age"
      }
    }
  }
}

...
 "aggregations": {
    "age_of_min": {
      "value": 20
    }
  }
  • 求最大值：
GET user2/user/_search
{
  "size": 0, 
  "aggs":{
    "age_of_max":{
      "max": {
        "field": "age"
      }
    }
  }
}

...
  "aggregations": {
    "age_of_max": {
      "value": 24
    }
  }
  • 求平均值：
...
GET user2/user/_search
{
  "size": 0, 
  "aggs":{
    "age_of_avg":{
      "avg": {
        "field": "age"
      }
    }
  }
}

 "aggregations": {
    "age_of_avg": {
      "value": 22
    }
  }
  • 求互不相同的个数
GET user2/user/_search
{
  "size": 0, 
  "aggs":{
    "age_of_cardi":{
      "cardinality": {
        "field": "age"
      }
    }
  }
}

"aggregations": {
    "age_of_cardi": {
      "value": 3
    }
  }
  • 分组：
GET user2/user/_search
{
  "size": 0, 
  "aggs":{
    "age_of_group":{
      "terms": {
        "field": "age"
      }
    }
  }
}

 "aggregations": {
    "age_of_group": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": 21,
          "doc_count": 2
        },
        {
          "key": 24,
          "doc_count": 2
        },
        {
          "key": 20,
          "doc_count": 1
        }
      ]
    }
  }
  • 先查询再分组再排序
    按照爱好中包含篮球的进行查询，把查询结果按照年龄进行分组，然后按平均年龄进行排序
GET user2/user/_search
{
  "size": 0, 
  "query": {
    "match": {
      "hobby": "篮球"
    }
  }, 
  "aggs":{
    "age_of_group":{
      "terms": {
        "field": "age",
        "order": {
          "age_of_avg": "desc"
        }
      },
      "aggs": {
        "age_of_avg": {
          "avg": {
            "field": "age"
          }
        }
      }
    }
  }
}

查询结果：

"aggregations": {
    "age_of_group": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": 24,
          "doc_count": 1,
          "age_of_avg": {
            "value": 24
          }
        },
        {
          "key": 21,
          "doc_count": 2,
          "age_of_avg": {
            "value": 21
          }
        }
      ]
    }
  }
  • extended_stats：同时得出多条聚合信息，包括计数，最大值，最小值，平均数，求和等等
GET user2/user/_search
{
  "size": 0, 
  "aggs":{
    "age_of_extended":{
      "extended_stats": {
        "field": "age"
      }
    }
  }
}

"aggregations": {
    "age_of_extended": {
      "count": 5,
      "min": 20,
      "max": 24,
      "avg": 22,
      "sum": 110,
      "sum_of_squares": 2434,
      "variance": 2.8,
      "std_deviation": 1.6733200530681511,
      "std_deviation_bounds": {
        "upper": 25.346640106136302,
        "lower": 18.653359893863698
      }
    }
  }

嵌套聚合

  • 构造数据：
PUT /cars
{
    "settings": {
        "index": {
            "number_of_shards": "1",
            "number_of_replicas": "0"
        }
    },
    "mappings": {
        "transactions":{
        "properties": {
            "factory": {
                "type": "keyword"
            },
            "price": {
                "type": "integer"
            },
            "color": {
                "type": "keyword"
            },
            "sold": {
                "type": "date"
            }
        }
        }
    }
}

POST cars/_bulk
{ "index": {"_index":"cars","_type":"transactions"}}
{ "price" : 10000, "color" : "red", "factory" : "honda", "sold" : "2014-10-28" }
{ "index": {"_index":"cars","_type":"transactions"}}
{ "price" : 20000, "color" : "red", "factory" : "honda", "sold" : "2014-11-05" }
{ "index": {"_index":"cars","_type":"transactions"}}
{ "price" : 30000, "color" : "green", "factory" : "ford", "sold" : "2014-05-18" }
{ "index": {"_index":"cars","_type":"transactions"}}
{ "price" : 15000, "color" : "blue", "factory" : "toyota", "sold" : "2014-07-02" }
{ "index": {"_index":"cars","_type":"transactions"}}
{ "price" : 12000, "color" : "green", "factory" : "toyota", "sold" : "2014-08-19" }
{ "index": {"_index":"cars","_type":"transactions"}}
{ "price" : 20000, "color" : "red", "factory" : "honda", "sold" : "2014-11-05" }
{ "index": {"_index":"cars","_type":"transactions"}}
{ "price" : 80000, "color" : "red", "factory" : "bmw", "sold" : "2014-01-01" }
{ "index": {"_index":"cars","_type":"transactions"}}
{ "price" : 25000, "color" : "blue", "factory" : "ford", "sold" : "2014-02-12" }

在这里插入图片描述

  • 根据颜色分组：
GET cars/transactions/_search
{
    "size" : 0,
    "aggs" : { 
        "popular_colors" : { 
            "terms" : { 
              "field" : "color"
            }
        }
    }
}

"buckets": [
        {
          "key": "red",
          "doc_count": 4
        },
        {
          "key": "blue",
          "doc_count": 2
        },
        {
          "key": "green",
          "doc_count": 2
        }
      ]

java api为

public void aggsTermsQuery(){
        SearchResponse response = transportClient.prepareSearch("cars")
                .setTypes("transactions")
                .addAggregation(
                        AggregationBuilders.terms("popular_colors")
                                .field("color"))
                .setSize(0)
                .get();
        Aggregation popular_colors = response.getAggregations().get("popular_colors");
    }
  • 根据颜色分组后，计算每一组的平均价格
GET /cars/transactions/_search
{
   "size" : 0,
   "aggs": {
      "colors": {
         "terms": {
            "field": "color"
         },
         "aggs": {
            "avg_price": { 
               "avg": {
                  "field": "price" 
               }
            }
         }
      }
   }
}

结果：

"buckets": [
        {
          "key": "red",
          "doc_count": 4,
          "avg_price": {
            "value": 32500
          }
        },
        {
          "key": "blue",
          "doc_count": 2,
          "avg_price": {
            "value": 20000
          }
        },
        {
          "key": "green",
          "doc_count": 2,
          "avg_price": {
            "value": 21000
          }
        }
      ]

java api实现：

 public void setMertricsQuery(){
        SearchResponse response = transportClient.prepareSearch("cars")
                .setTypes("transactions")
                .addAggregation(
                        AggregationBuilders.terms("colors")
                                .field("color")
                                //添加指标
                                .subAggregation(AggregationBuilders
                                        .avg("avg_price")
                                        .field("price")
                                )
                )
                .setSize(0)
                .get();
        Aggregation colors = response.getAggregations().get("colors");
    }
  • 先按颜色分组，计算平均价格，再按生产厂家分组：
GET /cars/transactions/_search
{
  "size" : 0,
  "aggs": {
     "colors": {
        "terms": {
           "field": "color"
        },
        "aggs": {
           "avg_price": { 
              "avg": {
                 "field": "price"
              }
           },
           "factorys": { 
               "terms": {
                   "field": "factory" 
               }
           }
        }
     }
  }
}

结果：

"buckets": [
        {
          "key": "red",
          "doc_count": 4,
          "factorys": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
              {
                "key": "honda",
                "doc_count": 3
              },
              {
                "key": "bmw",
                "doc_count": 1
              }
            ]
          },
          "avg_price": {
            "value": 32500
          }
        },
        {
          "key": "blue",
          "doc_count": 2,
          "factorys": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
              {
                "key": "ford",
                "doc_count": 1
              },
              {
                "key": "toyota",
                "doc_count": 1
              }
            ]
          },
          "avg_price": {
            "value": 20000
          }
        },
        {
          "key": "green",
          "doc_count": 2,
          "factorys": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
              {
                "key": "ford",
                "doc_count": 1
              },
              {
                "key": "toyota",
                "doc_count": 1
              }
            ]
          },
          "avg_price": {
            "value": 21000
          }
        }
      ]

java api实现

public void subMertricsQuery(){
        SearchResponse response = transportClient.prepareSearch("cars")
                .setTypes("transactions")
                .addAggregation(
                        AggregationBuilders.terms("colors")
                                .field("color")
                                .subAggregation(AggregationBuilders
                                        .avg("avg_price")
                                        .field("price")
                                )
                                .subAggregation(AggregationBuilders
                                        .terms("factory")//子集合的名字
                                        .field("factory")//分类的字段
                                )
                )
                .setSize(0)
                .get();
        Aggregation colors = response.getAggregations().get("colors");
    }
  • 在上面基础上，再查询每个生产厂家生产的价格最高的和最低的车子的价格
GET /cars/transactions/_search
{
   "size" : 0,
   "aggs": {
      "colors": {
         "terms": {
            "field": "color"
         },
         "aggs": {
            "avg_price": { "avg": { "field": "price" }
            },
            "factorys" : {
                "terms" : {
                    "field" : "factory"
                },
                "aggs" : { 
                    "min_price" : { 
                        "min": { 
                            "field": "price"
                            } 
                        }, 
                    "max_price" : {
                         "max": { 
                                 "field": "price"
                                 } 
                         } 
                }
            }
         }
      }
   }
}

结果：

  {
          "key": "red",
          "doc_count": 4,
          "factorys": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
              {
                "key": "honda",
                "doc_count": 3,
                "max_price": {
                  "value": 20000
                },
                "min_price": {
                  "value": 10000
                }
              },
              {
                "key": "bmw",
                "doc_count": 1,
                "max_price": {
                  "value": 80000
                },
                "min_price": {
                  "value": 80000
                }
              }
            ]
          },
          "avg_price": {
            "value": 32500
          }
        },

java api 实现：

public void subMertricsQuery(){
        SearchResponse response = transportClient.prepareSearch("cars")
                .setTypes("transactions")
                .addAggregation(
                        AggregationBuilders.terms("colors")
                                .field("color")
                                .subAggregation(AggregationBuilders
                                        .avg("avg_price")
                                        .field("price")
                                )
                                .subAggregation(AggregationBuilders
                                        .terms("factorys")
                                        .field("factory")
                                        .subAggregation(AggregationBuilders
                                                        .max("max_price")
                                                        .field("price")
                                        )
                                        .subAggregation(AggregationBuilders
                                                .min("min_price")
                                                .field("price")
                                        )
                                )
                )
                .setSize(0)
                .get();
        Aggregation colors = response.getAggregations().get("colors");
    }

参考文章

ElasticSearch超强聚合查询(一)

程序员修炼
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ES 聚合查询结果转换成相应的List对象
07-11
ES 聚合查询结果转换成相应的对象集合，ES 聚合查询结果转换成相应的对象集合
elasticsearch聚合后分页
12-16
方法如果传总页数了，es就不用查询总页数，直接通过开始位置到结束位置取数即可
elasticsearch-聚合查询
Felix的小黑板
09-28 579
目录依赖引入目录结构代码详情DemoApplication.javaElasticsearchRestClient.javaBucketAggregationTest.javaMetricAggregationTest.java 本篇目将写一个案例来介绍, java 集成 elasticsearch 并且实现常见的聚合查询 依赖引入 我们使用 springboot快速创建一个项目, pom.xml如下 <?xml version="1.0" encoding="UTF-8"?> <pr
Elasticsearch8.x聚合查询全面指南：从理论到实战
最新发布
qq_41934990的博客
06-27 877
类似于SQL中的GROUP BY操作，根据指定的条件对数据进行分组统计。可以进行嵌套分桶，即在一个分桶的基础上再进行细分。示例：按照手机的品牌进行分桶统计数量，再在小米手机的分桶基础上按照档次进行二次分桶。语法格式 指标聚合（Metrics Aggregations） 主要用于计算数值字段的统计信息，如平均值、最大值、最小值、求和、去重计数等。示例：计算某个班级、某个学科的最高分、最低分等。语法格式 聚合查询的特点 嵌套性：聚合查询支持嵌套，即一个聚合内部可以包含别的子聚合，实现复杂的数据挖掘和统计
七.全文检索ElasticSearch经典入门-聚合查询
墨家巨子@俏如来
04-09 6409
前言 今天我们讲ES的高亮和聚合查询,聚合功能是ES很重要的功能，它基于查询条件来对数据进行分桶和计算。它提供了类似于关系型数据库的SUM，COUNT, AVG , Group By 等功能。聚合也可以嵌套，可以组成复杂的操作。
Elasticsearch之_search聚合查询
鹤啸九天
03-04 444
聚合查询用于分组、汇总等操作，可与查询表达式结合使用。根据不同的汇总用途，主要分为4种不同的聚合。这4种聚合可以并列使用，用不同的自定义聚合结果名称区分。这4种聚合分别是： 一、Metric（指标聚合）： 主要用于数值汇总计算，可以作为子聚合，但不能包含子聚合。 1、平均值avg： GET http://$user:$passwd...
ElasticSearch读取查询结果（search）
热门推荐
节至
06-17 1万+
在es中所有的查询结果都会保存在SearchResponse中，在从SearchResponse中读取数据的时候，有两种方式：第一种是对Query的结果进行读取，使用的是hit，每一条查询到的doc都是一个hit，可以将每个hit转换为map形式的数据，map的具体形式为的形式，可以得到每一个字段的名称与内容（具体代码如下）； public static List getSC(Searc
java使用elasticsearch分组进行聚合查询过程解析
08-25
Java 使用 Elasticsearch 进行分组聚合查询过程解析 Java 使用 Elasticsearch 进行分组聚合查询是一个常见的需求，特别是在大数据处理和数据分析领域。Elasticsearch 提供了强大的聚合功能，可以对数据进行分组、...
elasticaggregator-php:在 PHP 中更简单的 ElasticSearch 聚合查询
06-07
特点和目标简单的聚合查询构造（ ） 简单聚合结果解析和“压缩”（ ） 干净、简约的界面（在结合） 经过良好测试的代码库可根据不同需求进行配置和定制去做确定公共函数的更好命名约定（以更好地反映底层分桶和度量...
Elasticsearch高级聚合查询
09-22
代码示例
【Elasticsearch】搜索结果处理和RestClient查询文档
专注于Java领域开发 关注我 带你玩转Java
07-15 844
搜索结果处理以及RestClient查询
ElasticSearch查询排序
袁铖
06-13 3483
Date stratDate = DateUtil.beginOfDay(date); Date endDate = DateUtil.endOfDay(date); // 查询条件：编号确定，创建时间在某范围内 queryBuilder = QueryBuilders .boolQuery() .must(QueryBuilders.matchQuery("sen...
elasticsearch-java api之搜索（一）
赶路人儿
12-04 4217
1、全文搜索两个最重要的方面是： 1）相关性（Relevance） 它是评价查询与其结果间的相关程度，并根据这种相关程度对结果排名的一种能力，这种计算方式可以是 TF/IDF 方法（参见 相关性的介绍）、地理位置邻近、模糊相似，或其他的某些算法。 2）分析（Analysis） 它是将文本块转换为有区别的、规范化的 token 的一个过程，（参见 分析的介绍） 目的是为了（a）创建倒排索引以
ElasticSearch学习(五)，搜索管理
cnsummerLi
11-09 1543
1、准备环境 1）创建xc_course索引库。 2）创建如下映射 post：http://localhost:9200/xc_course/doc/_mapping { "properties":{ "description":{ "type":"text", "analyzer":"ik_ma...
Elasticsearch 第二天
qq_45618899的博客
09-07 540
Elasticsearch day02 1 Elasticsearch高级检索DSL检索 准备测试数据： #删除索引 DELETE /ems #添加索引并设置类型 PUT /ems { "mappings":{ "emp":{ "properties":{ "name":{ "type":"text" }, "age
Elasticsearch基础08—— 简单的搜索
大风的博客
10-30 402
关于版本 内容 版本 Elasticsearch版本 7.2.0 JAVA依赖版本 7.2.1 Elasticsearch 7.x 和之前版本有相当大的变化，所以本篇内容尤其是JAVA代码的操作对于使用旧版本的同学帮助可能不大。因为本人主要是JAVA开发，在介绍相关操作的时候会附带JAVA代码操作的逻辑。 ES的简单搜索 精确查找和短语匹配 精确查找(（)term词...
【44-商城检索服务的搭建-页面跳转调整-elasticsearch检索服务前后端响应的VO对象-检索服务前后端逻辑实现-构建SearchRequest、SearchResponse对象】
Coder_ljw的博客
12-03 372
【44-商城检索服务的搭建-页面跳转调整-elasticsearch检索服务前后端响应的VO对象-检索服务前后端逻辑实现-构建SearchRequest、SearchResponse对象】检索服务结构图商品检索页面我们放在search服务中处理，首页我们需要在mall-search服务中支持Thymeleaf。添加对应的依赖然后我们拷贝模板文件到template目录下，然后不要忘记添加Thymeleaf的名称空间需要把相关的静态资源文件拷贝到Nginx服务中。
ElasticSearch超强聚合查询(一)
tiansheng1225的博客
08-15 1974
Elasticsearch聚合查询一 Elasticsearch聚合查询一 聚合与搜索的概念 高阶概念 举例说明—关于汽车数据的相关聚合(Index=cars;type=transactions) 注意点:官方文档说明,如何设置fildData. 实战之—-查询那个颜色的汽车销量最好? 实战之—-在上面的聚合基础上添加一些指标—&gt;’average‘平均价格 ...
es 聚合查询排除null_elasticsearch 聚合查询篇
06-02
好的，针对您的问题，您可以使用 Elasticsearch 的聚合查询中的“missing”聚合来排除 null 值。 具体来说，您可以使用以下的聚合查询语句： ``` { "aggs": { "field_name": { "missing": { "field": "your_...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值