elasticsearch高级功能之聚合查询

最新推荐文章于 2024-10-12 08:54:04 发布
最新推荐文章于 2024-10-12 08:54:04 发布
阅读量5.6k 收藏 17
点赞数 4
分类专栏： ELK日志管理框架 文章标签： elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nandao158/article/details/128531078
版权

elasticsearch高级功能之聚合查询，是比较复杂的的高级功能，其中包含相关的统计功能，比如最大值、最小值、平均值、求和等，又比如筛选完数据后，还需要过滤筛选项，今天我们详细分析一下：

一、聚合指标

1、基本的统计指标

1.1、计算基本类型的平均值

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "my_agg": {
      "avg": {
        "field": "price"
      }
    }
  }
}

1.2、计算非基本类型的平均值

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "my_agg": {
      "avg": {
        "field": "comment.properties.good"
      }
    }
  }
}

java客户端：

 public void getAvgAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest(" scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String aggName = "my_agg";//聚合的名称
        //定义avg聚合，指定字段为价格
        AvgAggregationBuilder aggregationBuilder = AggregationBuilders.avg(aggName).field("price");
        searchSourceBuilder.aggregation(aggregationBuilder);//添加聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        //执行查询
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Avg avg = aggregations.get(aggName);//获取avg聚合返回的对象
        String key = avg.getName();//获取聚合名称
        double avgValue = avg.getValue();//获取聚合值
        System.out.println("key=" + key + ",avgValue=" + avgValue);//打印结果
    }

1.3、返回多个统计数据

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "my_agg": {
      "stats": {
        "field": "price"
      }
    }
  }
}

java客户端

public void getStatsAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String aggName = "my_agg";//聚合的名称
        //定义stats聚合，指定字段为价格
        StatsAggregationBuilder aggregationBuilder = AggregationBuilders.stats(aggName).field("price");
        searchSourceBuilder.aggregation(aggregationBuilder);//添加聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        //执行查询
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Stats stats = aggregations.get(aggName);//获取stats聚合返回的对象
        String key = stats.getName();//获取聚合名称
        double sumVal = stats.getSum();//获取聚合加和值
        double avgVal = stats.getAvg();//获取聚合平均值
        long countVal = stats.getCount();//获取聚合文档数量值
        double maxVal = stats.getMax();//获取聚合最大值
        double minVal = stats.getMin();//获取聚合最小值
        System.out.println("key=" + key);//打印聚合名称
        System.out.println("sumVal=" + sumVal + ",avgVal=" + avgVal + ",countVal=" + countVal + ",maxVal=" + maxVal + ",minVal=" + minVal);//打印结果
    }

 2、空值处理

2.1、基本类型非空值的个数

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "my_agg": {
       "value_count": {
         "field": "price"
       }
    }
  }
}

java客户端

 public void getValueCountAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String aggName = "my_agg";//聚合的名称
        //定义value_count聚合，指定字段为价格
        ValueCountAggregationBuilder aggregationBuilder = AggregationBuilders.count(aggName).field("price");
        aggregationBuilder.missing("200");
        searchSourceBuilder.aggregation(aggregationBuilder);//添加聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        //执行查询
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        ValueCount valueCount = aggregations.get(aggName);//获取value_count聚合返回的对象
        String key = valueCount.getName();//获取聚合名称
        long count = valueCount.getValue();//获取聚合值
        System.out.println("key=" + key + ",count=" + count);//打印结果
    }

 2.2、数组非空值个数

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "my_agg": {
       "value_count": {
         "field": "tag"
       }
    }
  }
}

2.3、空值替换相加

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "my_agg": {
       "sum": {
         "field": "price",
         "missing": 200
       }
    }
  }
}

java客户端

public void getSumAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String aggName = "my_agg";//聚合的名称
        //定义sum聚合，指定字段为价格
        SumAggregationBuilder aggregationBuilder = AggregationBuilders.sum(aggName).field("price");
        aggregationBuilder.missing("200");
        searchSourceBuilder.aggregation(aggregationBuilder);//添加聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        //执行查询
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Sum sum = aggregations.get(aggName);//获取sum聚合返回的对象
        String key = sum.getName();//获取聚合名称
        double sumVal = sum.getValue();//获取聚合值
        System.out.println("key=" + key + ",count=" + sumVal);//打印结果
    }

 二、桶聚合查询

1、单维度桶聚合查询

1.1、按照城市聚合查询

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "my_agg": {
       "terms": {
         "field": "city"
       }
    }
  }
}

java客户端

public void getBucketDocCountAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String termsAggName = "my_terms";//指定聚合的名称
        //定义terms聚合，指定字段为城市
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms(termsAggName).field("full_room");

        searchSourceBuilder.aggregation(termsAggregationBuilder);//添加聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        //执行查询
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Terms terms = aggregations.get(termsAggName);//获取聚合返回的对象

        for (Terms.Bucket bucket : terms.getBuckets()) {
            String bucketKey = bucket.getKeyAsString();//获取桶名称
            long docCount = bucket.getDocCount();//获取文档个数
            System.out.println("termsKey=" + bucketKey + ",docCount=" + docCount);
        }
    }

 1.2、范围聚合查询

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "my_agg": {
       "range": {
         "field": "price",
         "ranges": [
           {
             "to": 20
           },
           {
             "from": 100, 
             "to": 50
           },
           {
             "from": 1000, 
             "to": 500
           }
         ]
       }
    }
  }
}

java客户端

public void getRangeDocCountAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String rangeAggName = "my_range";//sum聚合的名称
        //定义range聚合，指定字段为price
        RangeAggregationBuilder rangeAgg = AggregationBuilders.range(rangeAggName).field("price");
        rangeAgg.addRange(new RangeAggregator.Range(null,null,200d));
        rangeAgg.addRange(new RangeAggregator.Range(null,200d,500d));
        rangeAgg.addRange(new RangeAggregator.Range(null,500d,null));
        searchSourceBuilder.aggregation(rangeAgg);//添加range聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        //执行查询
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Range range = aggregations.get(rangeAggName);//获取range聚合返回的对象
        for (Range.Bucket bucket : range.getBuckets()) {
            String bucketKey = bucket.getKeyAsString();//获取桶名称
            long docCount = bucket.getDocCount();//获取聚合文档个数
            System.out.println("bucketKey=" + bucketKey + ",docCount=" + docCount);
        }
    }

 1.3、按照城市维度聚合查询各城市的平均价格

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "my_agg": {
       "terms": {
         "field": "city"
       },
       "aggs": {
         "my_sum": {
           "sum": {
             "field": "price",
             "missing": 100
           }
         }
       }
    }
  }
}

java客户端

public void getBucketAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String termsAggName = "my_terms";//sum聚合的名称
        //定义terms聚合，指定字段为城市
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms(termsAggName).field("city");
        String sumAggName = "my_sum";//sum聚合的名称
        //定义sum聚合，指定字段为价格
        SumAggregationBuilder sumAggregationBuilder = AggregationBuilders.sum(sumAggName).field("price");
        //定义聚合的父子关系
        termsAggregationBuilder.subAggregation(sumAggregationBuilder);
        searchSourceBuilder.aggregation(termsAggregationBuilder);//添加聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        //执行查询
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Terms terms = aggregations.get(termsAggName);//获取sum聚合返回的对象

        for (Terms.Bucket bucket : terms.getBuckets()) {
            String termsKey = bucket.getKey().toString();
            System.out.println("termsKey=" + termsKey);
            Sum sum = bucket.getAggregations().get(sumAggName);
            String key = sum.getName();//获取聚合名称
            double sumVal = sum.getValue();//获取聚合值
            System.out.println("key=" + key + ",count=" + sumVal);//打印结果
        }
    }

 2、多维度桶嵌套聚合查询

查询景区时搜索各城市的满房状态和平均价格等

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "group_city": {
       "terms": {
         "field": "city"
       },
       "aggs": {
         "grup_full_room": {
           "terms": {
             "field": "full"
           },
           "aggs": {
             "my_sum": {
               "avg": {
                 "field": "price",
                 "missing": 100
               }
               
             }
           }
         }
       }
    }
  }
}

java客户端

public void getExternalBucketAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        String aggNameCity = "my_terms_city";//按城市聚合的名称
        //定义terms聚合，指定字段为城市
        TermsAggregationBuilder termsAggCity = AggregationBuilders.terms(aggNameCity).field("city");

        String aggNameFullRoom = "my_terms_full_room";//按满房状态聚合的名称
        //定义terms聚合，指定字段为满房状态
        TermsAggregationBuilder termsArrFullRoom = AggregationBuilders.terms(aggNameCity).field("full_room");

        String sumAggName = "my_sum";//sum聚合的名称
        //定义sum聚合，指定字段为价格
        SumAggregationBuilder sumAgg = AggregationBuilders.sum(sumAggName).field("price");

        //定义聚合的父子关系
        termsArrFullRoom.subAggregation(sumAgg);
        termsAggCity.subAggregation(termsArrFullRoom);
        searchSourceBuilder.aggregation(termsAggCity);//添加聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        //执行查询
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Terms terms = aggregations.get(aggNameCity);//获取sum聚合返回的对象
        for (Terms.Bucket bucket : terms.getBuckets()) {//遍历第一层bucket
            String termsKeyCity = bucket.getKey().toString();//获取第一层bucket名称
            System.out.println("--------" + "termsKeyCity=" + termsKeyCity + "--------");
            Terms termsFullRom = bucket.getAggregations().get(aggNameCity);
            for (Terms.Bucket bucketFullRoom : termsFullRom.getBuckets()) {//遍历第二层bucket
                String termsKeyFullRoom = bucketFullRoom.getKeyAsString();//获取第二层bucket名称
                System.out.println("termsKeyFullRoom=" + termsKeyFullRoom);
                Sum sum = bucketFullRoom.getAggregations().get(sumAggName);//获取聚合指标
                String key = sum.getName();//获取聚合指标名称
                double sumVal = sum.getValue();//获取聚合指标值
                System.out.println("key=" + key + ",count=" + sumVal);//打印结果
            }
        }
    }

 3、地理位置聚合

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "my_agg": {
      "geo_distance": {
        "field": "location",
        "origin": {
          "lat": 39.915143,
          "lon": 116.4039
        } 
        , "unit": "km",
         "ranges": [
           {
             "to": 2
           },
           {
             "from": 3, 
             "to": 10
           },
           {
             "from": 10
           }
         ]
      },
      "aggs": {
        "my_min": {
          "min": {
            "field": "price",
            "missing": 200
          }
        }
      }
    }
  }
}

java客户端

public void geGeoDistanceAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String geoDistanceAggName = "location";//sum聚合的名称
        //定义GeoDistance聚合
        GeoDistanceAggregationBuilder geoDistanceAgg=AggregationBuilders.geoDistance(geoDistanceAggName,new GeoPoint(39.915143,116.4039));
        geoDistanceAgg.unit(DistanceUnit.KILOMETERS);
        geoDistanceAgg.field("location");
        //指定分桶范围规则
        geoDistanceAgg.addRange(new GeoDistanceAggregationBuilder.Range(null,0d,3d));
        geoDistanceAgg.addRange(new GeoDistanceAggregationBuilder.Range(null,3d,110d));
        geoDistanceAgg.addRange(new GeoDistanceAggregationBuilder.Range(null,110d,null));
        String minAggName = "my_min";//min聚合的名称
        //定义sum聚合，指定字段为价格
        MinAggregationBuilder minAgg = AggregationBuilders.min(minAggName).field("price");
        minAgg.missing(100);//指定默认值
        //定义聚合的父子关系
        geoDistanceAgg.subAggregation(minAgg);
        searchSourceBuilder.aggregation(geoDistanceAgg);//添加聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        //执行查询
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        ParsedGeoDistance range = aggregations.get(geoDistanceAggName);//获取GeoDistance聚合返回的对象
        for (Range.Bucket  bucket : range.getBuckets()) {
            String termsKey = bucket.getKeyAsString();//获取bucket名称的字符串形式
            System.out.println("termsKey=" + termsKey);
            ParsedMin min = bucket.getAggregations().get(minAggName);
            String key = min.getName();//获取聚合名称
            double minVal = min.getValue();//获取聚合值
            System.out.println("key=" + key + ",min=" + minVal);//打印结果
        }
    }

三、聚合方式

1、先查询在聚合

GET /nandao_scenic/_search
{
  "size": 0,
  "query": {
    "term": {
      "city": {
        "value": "河南"
      }
    }
  }, 
  "aggs": {
    "my_agg": {
      "avg": {
        "field": "price"
      }
    }
  }
}

java客户端

public void getQueryAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        String avgAggName = "my_avg";//avg聚合的名称
        //定义sum聚合，指定字段为价格
        AvgAggregationBuilder avgAgg = AggregationBuilders.avg(avgAggName).field("price");

        searchSourceBuilder.aggregation(avgAgg);//添加聚合
        searchSourceBuilder.query(QueryBuilders.termQuery("city", "北京"));//构建query查询
        searchRequest.source(searchSourceBuilder);//设置查询请求
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);//执行搜索
        SearchHits searchHits = searchResponse.getHits();//获取搜索结果集
        System.out.println("---------------hit--------------");
        for (SearchHit searchHit : searchHits) {//遍历搜索结果集
            String index = searchHit.getIndex();//获取索引名称
            String id = searchHit.getId();//获取文档_id
            Float score = searchHit.getScore();//获取得分
            String source = searchHit.getSourceAsString();//获取文档内容
            System.out.println("index=" + index + ",id=" + id + ",source=" + source);//打印数据
        }
        System.out.println("---------------agg--------------");
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        ParsedAvg avg = aggregations.get(avgAggName);//获取sum聚合返回的对象
        String avgName = avg.getName();//获取聚合名称
        double avgVal = avg.getValue();//获取聚合值
        System.out.println("avgName=" + avgName + ",avgVal=" + avgVal);//打印结果
    }

 2、前过滤器

GET /nandao_scenic/_search
{
  "size": 0,
  "query": {
    "term": {
      "city": {
        "value": "河南"
      }
    }
  }, 
  "aggs": {
    "my_agg": {
      "filter": {
        "term": {
          "full": false
        }
      }, 
      "aggs": {
        "my_avg": {
          "avg": {
            "field": "price"
          }
        }
      }
    }
  }
}

java客户端

public void getFilterAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String filterAggName = "my_terms";//sum聚合的名称
        TermQueryBuilder termQueryBuilder=QueryBuilders.termQuery("full",true);
        FilterAggregationBuilder filterAggregationBuilder=AggregationBuilders.filter(filterAggName,termQueryBuilder);

        String avgAggName = "my_avg";//avg聚合的名称
        //定义sum聚合，指定字段为价格
        AvgAggregationBuilder avgAgg= AggregationBuilders.avg(avgAggName).field("price");

        filterAggregationBuilder.subAggregation(avgAgg);//为filter聚合添加子聚合
        searchSourceBuilder.aggregation(filterAggregationBuilder);//添加聚合
        searchSourceBuilder.query(QueryBuilders.termQuery("city", "北京"));//构建term查询
        searchRequest.source(searchSourceBuilder);//设置查询请求
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);//执行搜索
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        ParsedFilter filter = aggregations.get(filterAggName);//获取sum聚合返回的对象
        Avg avg =filter.getAggregations().get(avgAggName);
        String key = avg.getName();//获取聚合名称
        double avgVal = avg.getValue();//获取聚合值
        System.out.println("key=" + key + ",avgVal=" + avgVal);//打印结果
    }

 3、后过滤器

GET /nandao_scenic/_search
{
  "size": 0,
  "query": {
    "match": {
      "title": "山"
    }
  }, 
  "post_filter": {
    "term": {
      "city": "北京"
    }
  },
  "aggs": {
      "my_avg": {
        "avg": {
          "field": "price",
          "missing": 100
        }
      }
    }
}

java客户端

public void getPostFilterAggSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        String avgAggName = "my_avg";//avg聚合的名称
        //定义sum聚合，指定字段为价格
        AvgAggregationBuilder avgAgg= AggregationBuilders.avg(avgAggName).field("price");
        avgAgg.missing(200);//设置默认值为200
        searchSourceBuilder.aggregation(avgAgg);//添加聚合
        searchSourceBuilder.query(QueryBuilders.matchQuery("title", "假日"));//构建term查询
        TermQueryBuilder termQueryBuilder=QueryBuilders.termQuery("city","北京");
        searchSourceBuilder.postFilter(termQueryBuilder);
        searchRequest.source(searchSourceBuilder);//设置查询请求
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);//执行搜索
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Avg avg =aggregations.get(avgAggName);
        String key = avg.getName();//获取聚合名称
        double avgVal = avg.getValue();//获取聚合值
        System.out.println("key=" + key + ",avgVal=" + avgVal);//打印结果
    }

四、聚合排序

1、 按文档计数排序

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "group_city": {
      "terms": {
        "field": "city",
        "order": {
          "_count": "asc"
        }
      },
      "aggs": {
      "my_avg": {
        "avg": {
          "field": "price",
          "missing": 100
        }
      }
    }
    }
  }
}

java客户端

public void getAggDocCountOrderSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String termsAggName = "my_terms";//sum聚合的名称
        //定义terms聚合，指定字段为城市
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms(termsAggName).field("city");
        BucketOrder bucketOrder=BucketOrder.count(true);
        termsAggregationBuilder.order(bucketOrder);
        String avgAggName = "my_avg";//avg聚合的名称
        //定义sum聚合，指定字段为价格
        SumAggregationBuilder avgAgg = AggregationBuilders.sum(avgAggName).field("price");
        //定义聚合的父子关系
        termsAggregationBuilder.subAggregation(avgAgg);
        searchSourceBuilder.aggregation(termsAggregationBuilder);//添加聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);//执行搜索
        SearchHits searchHits = searchResponse.getHits();//获取搜索结果集
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Terms terms = aggregations.get(termsAggName);//获取sum聚合返回的对象
        for (Terms.Bucket bucket : terms.getBuckets()) {
            String bucketKey = bucket.getKey().toString();
            System.out.println("termsKey=" + bucketKey);
            Sum sum = bucket.getAggregations().get(avgAggName);
            String key = sum.getName();//获取聚合名称
            double sumVal = sum.getValue();//获取聚合值
            System.out.println("key=" + key + ",count=" + sumVal);//打印结果
        }
    }

2、 按照聚合指标排序

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "group_city": {
      
      "terms": {
        "field": "city",
        "order": {
          "my_avg": "asc"
        }
      },
      "aggs": {
      "my_avg": {
        "avg": {
          "field": "price",
          "missing": 200
        }
      }
    }
    
    }
  }
}

java客户端

public void getAggMetricsOrderSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String termsAggName = "my_terms";//sum聚合的名称
        //定义terms聚合，指定字段为城市
        String avgAggName = "my_avg";//avg聚合的名称
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms(termsAggName).field("city");
        BucketOrder bucketOrder=BucketOrder.aggregation(avgAggName,true);
        termsAggregationBuilder.order(bucketOrder);

        //定义sum聚合，指定字段为价格
        AvgAggregationBuilder avgAgg = AggregationBuilders.avg(avgAggName).field("price");
        //定义聚合的父子关系
        termsAggregationBuilder.subAggregation(avgAgg);
        searchSourceBuilder.aggregation(termsAggregationBuilder);//添加聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);//执行搜索
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Terms terms = aggregations.get(termsAggName);//获取聚合返回的对象
        for (Terms.Bucket bucket : terms.getBuckets()) {
            String bucketKey = bucket.getKey().toString();
            System.out.println("termsKey=" + bucketKey);
            Avg avg = bucket.getAggregations().get(avgAggName);
            String key = avg.getName();//获取聚合名称
            double avgVal = avg.getValue();//获取聚合值
            System.out.println("key=" + key + ",avgVal=" + avgVal);//打印结果
        }
    }

 3、 分组key排序

GET /nandao_scenic/_search
{
  "size": 0,
  "aggs": {
    "group_city": {
      "terms": {
        "field": "city",
        "order": {
          "_key": "asc"
        }
      },
      "aggs": {
      "my_avg": {
        "avg": {
          "field": "price",
          "missing": 200
        }
      }
    }
    }
  }
}

java客户端

public void getAggKeyOrderSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String termsAggName = "my_terms";//sum聚合的名称
        //定义terms聚合，指定字段为城市
        String avgAggName = "my_avg";//avg聚合的名称
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms(termsAggName).field("city");
        BucketOrder bucketOrder=BucketOrder.key(true);
        termsAggregationBuilder.order(bucketOrder);

        //定义sum聚合，指定字段为价格
        SumAggregationBuilder avgAgg = AggregationBuilders.sum(avgAggName).field("price");
        //定义聚合的父子关系
        termsAggregationBuilder.subAggregation(avgAgg);
        searchSourceBuilder.aggregation(termsAggregationBuilder);//添加聚合
        searchRequest.source(searchSourceBuilder);//设置查询请求
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);//执行搜索
        SearchHits searchHits = searchResponse.getHits();//获取搜索结果集
        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Terms terms = aggregations.get(termsAggName);//获取sum聚合返回的对象
        for (Terms.Bucket bucket : terms.getBuckets()) {
            String bucketKey = bucket.getKey().toString();
            System.out.println("termsKey=" + bucketKey);
            Sum sum = bucket.getAggregations().get(avgAggName);
            String key = sum.getName();//获取聚合名称
            double sumVal = sum.getValue();//获取聚合值
            System.out.println("key=" + key + ",count=" + sumVal);//打印结果
        }
    }

五、聚合分页

1、Top hits 聚合分页

GET /nandao_scenic/_search
{
  "size": 0,
  "query": {
    "match": {
      "title": "山"
    }
  }, 
  "aggs": {
    "group_city": {
      "terms": {
        "field": "city"
      },
      "aggs": {
      "my_avg": {
        "top_hits": {
           "size": 10
        }
      }
    }
    }
  }
}

java客户端

public void getAggTopHitsSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("nandao_scenic");//创建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        String termsAggName = "my_terms";//sum聚合的名称

        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms(termsAggName).field("city");
        BucketOrder bucketOrder=BucketOrder.key(true);
        termsAggregationBuilder.order(bucketOrder);

        String topHitsAggName = "my_top";//avg聚合的名称
        TopHitsAggregationBuilder topHitsAgg=AggregationBuilders.topHits(topHitsAggName);
        topHitsAgg.size(3);
        //定义聚合的父子关系
        termsAggregationBuilder.subAggregation(topHitsAgg);
        searchSourceBuilder.aggregation(termsAggregationBuilder);//添加聚合
        searchSourceBuilder.query(QueryBuilders.matchQuery("title","金都"));
        searchRequest.source(searchSourceBuilder);//设置查询请求
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);//执行搜索

        Aggregations aggregations = searchResponse.getAggregations();//获取聚合结果
        Terms terms = aggregations.get(termsAggName);//获取sum聚合返回的对象
        for (Terms.Bucket bucket : terms.getBuckets()) {
            String bucketKey = bucket.getKey().toString();
            System.out.println("termsKey=" + bucketKey);
            TopHits topHits = bucket.getAggregations().get(topHitsAggName);
            SearchHit[] searchHits=topHits.getHits().getHits();
            for(SearchHit searchHit:searchHits){
                System.out.println(searchHit.getSourceAsString());
            }
        }
    }

此种分页影响性能，优化方向可以一次性存到redis，然后再redis里面做分页缓存

stringRedisTemplate.opsForList().range(key,0, 10);

  2、Collapse 聚合分页

GET /nandao_scenic/_search
{
  "from": 0, 
  "size": 5,
  "query": {
    "match": {
      "title": "山"
    }
  },
  "collapse": {
    "field": "city"
  }
}

 java客户端

public void getCollapseAggSearch() throws IOException{
        //按照spu进行分组
        CollapseBuilder collapseBuilder = new CollapseBuilder("city");//按照城市进行分组
        SearchRequest searchRequest = new SearchRequest();//新建搜索请求
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchQuery("title", "金都"));//新建match查询
        searchSourceBuilder.collapse(collapseBuilder);//设置折叠
        searchRequest.source(searchSourceBuilder);//设置查询
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);//执行搜索
        SearchHits searchHits = searchResponse.getHits();//获取搜索结果集
        for (SearchHit searchHit : searchHits) {//遍历搜索结果集
            String index = searchHit.getIndex();//获取索引名称
            String id = searchHit.getId();//获取文档_id
            Float score = searchHit.getScore();//获取得分
            String source = searchHit.getSourceAsString();//获取文档内容
            System.out.println("index=" + index + ",id=" + id + ",score=" + score + ",source=" + source);//打印数据
        }
    }

到此，聚合相关的查询分享完毕，大家一定要结合项目多多实战练习，定会早日掌握，下篇我们分析文本搜索相关的内容，敬请期待。

寅灯
关注
专栏目录
elasticsearch聚合查询
warrah 南极狼
02-08 443
es 聚合复杂应用的实际运营，项目中实际用到的
Elasticsearch的灵魂，查询的用法与解析，基本查询，聚合查询，多条件复合查询等。通过java，elasticsearch-rest-high-level-client api操作es。
bb1272196672的博客
08-23 1361
Elasticsearch的灵魂，查询的用法与解析，基本查询，聚合查询，多条件复合查询等。通过java，elasticsearch-rest-high-level-client api操作es。利用term，composite等高级聚合查询手法。springcloud技术，elastic Stack技术。
es数据聚合
CV工程师呀
02-09 2988
1.kibana实现 1.1.聚合的种类 聚合常见的有三类： 桶（Bucket）聚合：用来对文档做分组 TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组 Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组 度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等 Avg：求平均值 Max：求最大值 Min：求最小值 Stats：同时求max、min、avg、sum等 管道（pipeline）聚合：其它聚合的结
Elasticsearch 聚合查询的 Java 实现
Leon_Jinhai_Sun的博客
10-12 374
Elasticsearch 聚合查询的 Java 实现
elasticsearch 查询聚合操作
qq_50761817的博客
04-16 2102
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 的聚合查询
FireFox1997
08-15 909
Elasticsearch 的聚合查询功能为用户提供了强大的数据分析能力。从简单的统计计算到复杂的分组和关系分析，各类聚合查询满足了不同的业务需求。Metrics Aggregations 适用于基本的统计报告，Bucket Aggregations 则用于数据的分组和分类分析，Pipeline Aggregations 允许在现有数据上进行进一步的计算，而 Matrix Aggregations 提供了多字段关系的深入分析能力。
Elasticsearch学习-- 聚合查询
CelineT的博客
09-03 3059
missing：对空值赋默认值（设置成500，上图中表示，将price缺失的数据的price设置成500）min_doc_count：设置成1，表示输出结果doc_value大于等于1的数据（过滤0）因为聚合查询使用的是doc_values的正排索引，tags.keyword有正排索引。2）对分桶后的tags取平均price（在哪个的基础上进行操作，就放在同一级）1）查询price>4000的平均price和所有商品的平均price。doc_vaules是基于磁盘的，filed_data是基于内存的。
ElasticSearch高级查询.zip
01-09
以上就是Elasticsearch高级查询的一些核心概念，通过熟练掌握这些技术，可以构建出强大且功能丰富的搜索应用。在实际操作中，结合具体场景灵活运用，将能充分发挥Elasticsearch的潜力，为用户提供优质的搜索体验。
Elasticsearch高级搜索与过滤技巧及其应用
最新发布
10-17
内容概要：本文详细介绍了Elasticsearch的高级搜索和过滤技巧，涵盖基本概念、搜索机制、查询DSL、过滤与聚合、性能优化等多个方面。通过实战代码示例，演示了如何在电子商务搜索、日志分析和全文搜索中应用这些技术...
elasticSearch查询语句DSL
06-27
在这篇资源中，我们将详细介绍如何使用DSL...最后，我们将分享一些实用技巧和最佳实践，帮助您充分发挥DSL在Elasticsearch中的优势。我们将探讨性能优化、查询调试和索引优化等关键主题，以提升查询效率和搜索准确性。
elasticsearch聚合值过滤
03-02
而“elasticsearch聚合值过滤”是ES聚合功能的一个高级应用场景，它允许我们根据聚合计算出的结果来进一步筛选文档，即在聚合后的基础上进行过滤操作。这一特性在数据分析和报表生成时非常有用，能够帮助我们得到更...
elasticsearch的聚合查询
奇想派
07-05 1358
elasticsearch里包含很多语法，其中聚合查询尤其重要，本文罗列了几乎全部的聚合操作和案例。
ElasticSearch 聚合查询
wanson2015的博客
05-15 553
桶（bucket）和指标（metric） （1）桶　　 　　a、简单来说桶就是满足特定条件的文档的集合。 　　b、当聚合开始被执行，每个文档里面的值通过计算来决定符合哪个桶的条件，如果匹配到，文档将放入相应的桶并接着开始聚合操作。 　　c、桶也可以被嵌套在其他桶里面。 （2）指标 　　a、桶能让我们划分文档到有意义的集合，但是最终我们需要的是对这些桶内的文档进行一些指标的计算。分桶是一...
ElasticSearch--聚合查询
qq_50596778的博客
06-23 1211
ElasticSearch--过滤查询
Elasticsearch-桶聚合查询详解
苍煜
04-03 4400
在之前我们详细面熟了es的查询用法，但是es还拥有强大的聚合查询功能，可以得到类似分组，直方图，折线图等数据组合。类似SQL的SUM、AVG、COUNT、GROUP BY Elasticsearch-02-es的restapi使用ES聚合查询类似SQL的GROUP by，一般统计分析主要分为两个步骤：es中满足特定条件的文档的集合，叫做桶。 桶的就是一组数据的集合，对数据分组后，得到一组组的数据，就是一个个的桶。ES中桶聚合，指的就是先对数据进行分组，ES支持多种分组条件，例如：支持类似SQL的group
Elasticsearch 聚合检索 (分组统计)
cxs812760493的博客
09-20 2941
"size": 0,"aggs": {"terms": {"order": { "avg_price": "desc" } // 根据下述统计的结果排序},"aggs": {与#2.1节内容相似, 区别在于按照价格排序显示了.
一起学Elasticsearch系列-聚合查询
BookSea的博客
01-01 1287
聚合查询是 Elasticsearch 中一种强大的数据分析工具，用于从索引中提取和计算有关数据的统计信息。聚合查询可以执行各种聚合操作，如计数、求和、平均值、最小值、最大值、分组等，以便进行数据汇总和分析
Elasticsearch聚合查询
37749442的博客
10-19 328
Elasticsearch 聚合查询(aggs) elasticsearch es sum求和统计用法 在查询出来的记录中，如果需要对记录的数据进行再次操作（比如求和、平均值、最大值。。。），就需要用到聚合查询。 1、求和 第一种方法： GET qrydev-*/_search { "query": { //这里根据业务查询的要求 }, "aggs": { "my_sum": { "sum": { "field": "TranNum" } } } } 第二种方法： GET q
ElasticSearch聚合查询
dreamzuora的博客
02-23 435
文章目录聚合分组求和平均值分析每种颜色下每种品牌的平均价格更多的metric学习Cardinality(唯一值)stats 一个聚合，输出多值查询+聚合分析查询聚合+全局聚合 深入聚合数据分析_global bucket：单个品牌与所有品牌销量对比过滤+聚合：统计价格大于1200的电视平均价格统计最近一个月的平均价格按照每种品牌的平均价格排序 聚合分组 select * from table order by title.keyword { "size": 0, "aggs": { "gro
简化ElasticSearch聚合查询：elasticaggregator-php PHP包
ElasticSearch 的一个重要特性是聚合功能，这允许用户对数据进行分析和处理，如分类、统计数据分布、搜索结果分桶等。 聚合查询是通过使用一种叫做 DSL (Domain Specific Language) 的查询语言实现的，这种语言为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

寅灯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值