ES 聚合和过滤

这篇具有很好参考价值的文章主要介绍了ES 聚合和过滤。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

ES 聚合和过滤

  • 聚合范围限定还有一个自然的扩展就是过滤。因为聚合是在查询结果范围内操作的,任何可以适用于查询的过滤器也可以应用在聚合上。

数据准备

  • PUT cars
    {
      "mappings": {
          "transactions": {
            "properties": {
              "color": {
                "type": "keyword"
              },
              "make": {
                "type": "keyword"
              },
              "price": {
                "type": "long"
              },
              "sold": {
                "type": "date"
              }
            }
          }
        }
    }
    
  • POST /cars/transactions/_bulk
    { "index": {}}
    { "price" : 10000, "color" : "red", "make" : "honda", "sold" : "2014-10-28" }
    { "index": {}}
    { "price" : 20000, "color" : "red", "make" : "honda", "sold" : "2014-11-05" }
    { "index": {}}
    { "price" : 30000, "color" : "green", "make" : "ford", "sold" : "2014-05-18" }
    { "index": {}}
    { "price" : 15000, "color" : "blue", "make" : "toyota", "sold" : "2014-07-02" }
    { "index": {}}
    { "price" : 12000, "color" : "green", "make" : "toyota", "sold" : "2014-08-19" }
    { "index": {}}
    { "price" : 20000, "color" : "red", "make" : "honda", "sold" : "2014-11-05" }
    { "index": {}}
    { "price" : 80000, "color" : "red", "make" : "bmw", "sold" : "2014-01-01" }
    { "index": {}}
    { "price" : 25000, "color" : "blue", "make" : "ford", "sold" : "2014-02-12" }
    { "index": {}}
    { "price" : 8000, "color" : "blue", "make" : "bmw", "sold" : "2014-06-10" }
    { "index": {}}
    { "price" : 20000, "color" : "blue", "make" : "bmw", "sold" : "2014-10-10" }
    

过滤

  • 需求:找到售价在 $10,000 美元之上的所有汽车同时也为这些车计算平均售价

  • GET /cars/transactions/_search
    {
        "size" : 0,
        "query" : {
            "constant_score": {
                "filter": {
                    "range": {
                        "price": {
                            "gte": 10000
                        }
                    }
                }
            }
        },
        "aggs" : {
            "single_avg_price": {
                "avg" : { "field" : "price" }
            }
        }
    }
    
  • constant_score忽略评分,提高查询效率,同时使用缓存缓存查询结果

  • "hits": {
        "total": 9,
        "max_score": 1,
        "hits": [
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX-0cAvB7h9TQ4Sk42yy",
            "_score": 1,
            "_source": {
              "price": 15000,
              "color": "blue",
              "make": "toyota",
              "sold": "2014-07-02"
            }
          },
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX-0cAvB7h9TQ4Sk42yv",
            "_score": 1,
            "_source": {
              "price": 10000,
              "color": "red",
              "make": "honda",
              "sold": "2014-10-28"
            }
          },
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX-0cAvB7h9TQ4Sk42yw",
            "_score": 1,
            "_source": {
              "price": 20000,
              "color": "red",
              "make": "honda",
              "sold": "2014-11-05"
            }
          },
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX-0cAvB7h9TQ4Sk42y2",
            "_score": 1,
            "_source": {
              "price": 25000,
              "color": "blue",
              "make": "ford",
              "sold": "2014-02-12"
            }
          },
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX--vgKqH29RD64k5sAk",
            "_score": 1,
            "_source": {
              "price": 20000,
              "color": "blue",
              "make": "bmw",
              "sold": "2014-10-10"
            }
          },
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX-0cAvB7h9TQ4Sk42yz",
            "_score": 1,
            "_source": {
              "price": 12000,
              "color": "green",
              "make": "toyota",
              "sold": "2014-08-19"
            }
          },
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX-0cAvB7h9TQ4Sk42y0",
            "_score": 1,
            "_source": {
              "price": 20000,
              "color": "red",
              "make": "honda",
              "sold": "2014-11-05"
            }
          },
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX-0cAvB7h9TQ4Sk42y1",
            "_score": 1,
            "_source": {
              "price": 80000,
              "color": "red",
              "make": "bmw",
              "sold": "2014-01-01"
            }
          },
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX-0cAvB7h9TQ4Sk42yx",
            "_score": 1,
            "_source": {
              "price": 30000,
              "color": "green",
              "make": "ford",
              "sold": "2014-05-18"
            }
          }
        ]
      },
      "aggregations": {
        "single_avg_price": {
          "value": 25777.777777777777
        }
      }
    
  • @Test
    public void test07(){
        AvgAggregationBuilder avgAggregationBuilder = AggregationBuilders.avg("single_avg_price").field("price");
    
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery().filter(QueryBuilders.rangeQuery("price").gte(10000));
        ConstantScoreQueryBuilder constantScoreQueryBuilder = QueryBuilders.constantScoreQuery(boolQueryBuilder);
    
        SearchResponse searchResponse = elasticsearchTemplate.getClient().prepareSearch("cars")
                .setTypes("transactions")
                .setQuery(constantScoreQueryBuilder)
                .addAggregation(avgAggregationBuilder)
                .execute()
                .actionGet();
        SearchHit[] hits = searchResponse.getHits().getHits();
        for (SearchHit searchHit : hits){
            Map<String, Object> sourceAsMap = searchHit.getSourceAsMap();
            Integer price = (Integer) sourceAsMap.get("price");
            String color = (String) sourceAsMap.get("color");
            String make = (String) sourceAsMap.get("make");
            String sold = (String) sourceAsMap.get("sold");
            System.out.println(price+"-"+color+"-"+make+"-"+sold);
        }
        InternalAvg internalAvg = searchResponse.getAggregations().get("single_avg_price");
        System.out.println(internalAvg.getValue());
    }
    
  • 返回结果
    15000-blue-toyota-2014-07-02
    10000-red-honda-2014-10-28
    20000-red-honda-2014-11-05
    25000-blue-ford-2014-02-12
    20000-blue-bmw-2014-10-10
    12000-green-toyota-2014-08-19
    20000-red-honda-2014-11-05
    80000-red-bmw-2014-01-01
    30000-green-ford-2014-05-18
    25777.777777777777
    

过滤桶

  • 只对聚合结果进行过滤

  • 需求:找出经销商是ford并且出售时间大于2014-03-01的

  • GET /cars/transactions/_search
    {
       "query":{
          "match": {
             "make": "ford"
          }
       },
       "aggs":{
          "recent_sales": {
             "filter": { 
                "range": {
                   "sold": {
                      "gte": "2014-03-01"
                   }
                }
             },
             "aggs": {
                "average_price":{
                   "avg": {
                      "field": "price" 
                   }
                }
             }
          }
       }
    }
    
  •  返回结果
      "hits": {
        "total": 2,
        "max_score": 1.2039728,
        "hits": [
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX-0cAvB7h9TQ4Sk42y2",
            "_score": 1.2039728,
            "_source": {
              "price": 25000,
              "color": "blue",
              "make": "ford",
              "sold": "2014-02-12"
            }
          },
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX-0cAvB7h9TQ4Sk42yx",
            "_score": 0.2876821,
            "_source": {
              "price": 30000,
              "color": "green",
              "make": "ford",
              "sold": "2014-05-18"
            }
          }
        ]
      },
      "aggregations": {
        "recent_sales": {
          "doc_count": 1,
          "average_price": {
            "value": 30000
          }
        }
      }
    
  • @Test
    public void test08(){
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("make", "ford");
    
        FilterAggregationBuilder filterAggregationBuilder = AggregationBuilders.filter("recent_sales", QueryBuilders.rangeQuery("sold").gte("2014-03-01"));
        AvgAggregationBuilder avgAggregationBuilder = AggregationBuilders.avg("average_price").field("price");
        filterAggregationBuilder.subAggregation(avgAggregationBuilder);
    
        SearchResponse searchResponse = elasticsearchTemplate.getClient().prepareSearch("cars")
                .setTypes("transactions")
                .setQuery(matchQueryBuilder)
                .addAggregation(filterAggregationBuilder)
                .execute()
                .actionGet();
    
        SearchHit[] hits = searchResponse.getHits().getHits();
        for (SearchHit searchHit : hits){
            Map<String, Object> sourceAsMap = searchHit.getSourceAsMap();
            Integer price = (Integer) sourceAsMap.get("price");
            String color = (String) sourceAsMap.get("color");
            String make = (String) sourceAsMap.get("make");
            String sold = (String) sourceAsMap.get("sold");
            System.out.println(price+"-"+color+"-"+make+"-"+sold);
        }
        InternalFilter internalFilter = searchResponse.getAggregations().get("recent_sales");
        long docCount = internalFilter.getDocCount();
        System.out.println(docCount);
        InternalAvg internalAvg = internalFilter.getAggregations().get("average_price");
        System.out.println(internalAvg.getValue());
    }
    
  • 返回结果
    25000-blue-ford-2014-02-12
    30000-green-ford-2014-05-18
    1
    30000.0
    
  • 这样查询出来的结果是两个,而聚合的数据却只有一个,因为聚合的时候,出售时间为2011-02-12的数据被过滤掉了

  • filter 桶和其他桶的操作方式一样,所以可以随意将其他桶和度量嵌入其中。

后过滤

  • 只过滤搜索结果,不过滤聚合结果,使用post_filter

  • 需求:对ford所有颜色的数据进行聚合,但只查询颜色为绿色的数据

  • GET /cars/transactions/_search
    {
        "query": {
            "match": {
                "make": "ford"
            }
        },
        "post_filter": {    
            "term" : {
                "color" : "green"
            }
        },
        "aggs" : {
            "all_colors": {
                "terms" : { "field" : "color" }
            }
        }
    }
    
  • "hits": {
        "total": 1,
        "max_score": 0.2876821,
        "hits": [
          {
            "_index": "cars",
            "_type": "transactions",
            "_id": "AX-0cAvB7h9TQ4Sk42yx",
            "_score": 0.2876821,
            "_source": {
              "price": 30000,
              "color": "green",
              "make": "ford",
              "sold": "2014-05-18"
            }
          }
        ]
      },
      "aggregations": {
        "all_colors": {
          "doc_count_error_upper_bound": 0,
          "sum_other_doc_count": 0,
          "buckets": [
            {
              "key": "blue",
              "doc_count": 1
            },
            {
              "key": "green",
              "doc_count": 1
            }
          ]
        }
      }
    
  • @Test
    public void test09(){
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("make", "ford");
    
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("color", "green");
    
        TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("all_colors").field("color");
    
        SearchResponse searchResponse = elasticsearchTemplate.getClient().prepareSearch("cars")
                .setTypes("transactions")
                .setQuery(matchQueryBuilder)
                .setPostFilter(termQueryBuilder)
                .addAggregation(termsAggregationBuilder)
                .execute()
                .actionGet();
        SearchHit[] hits = searchResponse.getHits().getHits();
        for (SearchHit searchHit : hits){
            Map<String, Object> sourceAsMap = searchHit.getSourceAsMap();
            Integer price = (Integer) sourceAsMap.get("price");
            String color = (String) sourceAsMap.get("color");
            String make = (String) sourceAsMap.get("make");
            String sold = (String) sourceAsMap.get("sold");
            System.out.println(price+"-"+color+"-"+make+"-"+sold);
        }
        StringTerms stringTerms = searchResponse.getAggregations().get("all_colors");
        List<StringTerms.Bucket> buckets = stringTerms.getBuckets();
        for (StringTerms.Bucket bucket : buckets){
            String keyAsString = bucket.getKeyAsString();
            long docCount = bucket.getDocCount();
            System.out.println(keyAsString+"-"+docCount);
        }
    }
    
  • 30000-green-ford-2014-05-18
    blue-1
    green-1
    
  • 这样查询出来的数据只有一条,而进行聚合的数据是两条。

  • 另外,post_filter的特性是在查询之后进行过滤,和聚合一起使用,使用的情况一般是需求对查询结果和聚合结果进行不同的过滤,不要只在查询的时候使用,影响性能。文章来源地址https://www.toymoban.com/news/detail-615131.html

到了这里,关于ES 聚合和过滤的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Elasticsearch专栏-6.es基本用法-聚合查询

    在es中,所有的聚合查询都是放在aggs中进行的。平均值、总和、最大、最小、数量对应的分别是:avg、sum、max、min、value_count 分组用到的是terms 上面语句中的size:3,指的是分组后,只展示前三个分组内容。size:0,指的是所有query查询结果,也就是原始数据,不需

    2024年02月09日
    浏览(39)
  • 17、全文检索 -- Elasticsearch -- 使用 反应式 RestClient (ReactiveElasticsearchClient)操作 Es 服务器(增、删、查 :索引库和文档)

    Elasticsearch 所提供 RestHighLevelClient 本身提供了 【同步编程】 和 【异步编程】两种模型。 Elasticsearch 官方并未提供反应式的 RestClient : 因此 Spring Data Elasticsearch 额外补充了一个 ReactiveElasticsearchClient,用于提供反应式API支持, ReactiveElasticsearchClient 相当于 RestHighLevelClient 的反应式

    2024年04月28日
    浏览(50)
  • elasticsearch(ES)分布式搜索引擎04——(数据聚合,自动补全,数据同步,ES集群)

    **聚合(aggregations)**可以让我们极其方便的实现对数据的统计、分析、运算。例如: 什么品牌的手机最受欢迎? 这些手机的平均价格、最高价格、最低价格? 这些手机每月的销售情况如何? 实现这些统计功能的比数据库的sql要方便的多,而且查询速度非常快,可以实现近

    2024年02月08日
    浏览(51)
  • 【ES】Elasticsearch:词干、Shingles 和同义词过滤器

    分词器生成的分词可能需要进一步丰富或增强,例如小写(或大写)标记、提供同义词、开发词干词、删除撇号或标点符号等。 分词过滤器对分词进行处理以执行此类转换。 Elasticsearch 提供了将近 50 个分词过滤器,正如你可以想象的那样,在这里讨论所有这些过滤器是不可

    2024年02月05日
    浏览(45)
  • ElasticSearch(7.8版本)聚合查询使用javaHighLevelRestClient实现(从MySQL聚合查询概念->ES聚合概念及实操)

    申明:本文是在实现ES聚合功能中,将过程中查找的多篇博客文献拼接在一起,参考到的博文全部在标题中附上了原文的超链接,分享出来仅是为了提做一个笔记以防忘记,并给大家提供一个参考。 聚合操作指的是在数据查找基础上对于数据进一步整理筛选行为,聚合操作也

    2023年04月24日
    浏览(58)
  • ElasticSearch系列 - SpringBoot整合ES:查询条件 query 和过滤条件 filter 的区别

    01. Elasticsearch 查询条件和过滤条件的区别? Elasticsearch中的查询条件和过滤条件都是用于搜索和过滤文档的条件,但它们之间有一些区别。 查询条件是用于计算文档相关度得分的条件,它会将所有符合条件的文档按照相关度得分从高到低排序,并返回前N个文档。查询条件可以

    2024年02月14日
    浏览(61)
  • ES 聚合和过滤

    聚合范围限定还有一个自然的扩展就是过滤。因为聚合是在查询结果范围内操作的,任何可以适用于查询的过滤器也可以应用在聚合上。 需求:找到售价在 $10,000 美元之上的所有汽车同时也为这些车计算平均售价 constant_score 忽略评分,提高查询效率,同时使用缓存缓存查询

    2024年02月15日
    浏览(28)
  • Elasticsearch基础篇(五):创建es索引并学习分析器、过滤器、分词器的作用和配置

    Elasticsearch 是一个分布式搜索和分析引擎,它使用JSON文档来存储数据。索引是Elasticsearch中数据的基本组织单元之一,下面是Elasticsearch索引相关的基本概念: 结构元素 Elasticsearch MySQL 数据库 索引(Index) 数据库(Database) 表格 类型(Type)* 表(Table) 记录/行 文档(Document)

    2024年02月03日
    浏览(91)
  • ES聚合中的Filter Bucket(过滤桶)详解

           平常的过滤我们可以查询然后包括一个过滤器 (filter) 返回一组文档的子集但是如果我们只想对聚合结果过滤怎么办? 假设我们正在为汽车经销商创建一个搜索页面, 我们希望显示出 ford 上个月售出的汽车的平均售价 这里我们无法简单的做范围限定,因为有两个不同

    2024年02月12日
    浏览(45)
  • es Elasticsearch 六 java api spirngboot 集成es

    目录 Java restApi Springboot 集成es 新增-同步 新增-异步 增删改查流程 _bulk 批量操作 新增-同步 新增-异步 增删改查流程 创建请求、2.执行、3.查看返回结果     _bulk 批量操作 ok 持续更新

    2024年02月10日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包