es的简单查询和聚合查询用法说明

末蓝、 2023-07-01 08:45 1阅读 0赞

1，es：报表统计用法：类似报表统计sql,聚合列就是查询列

//数据库表  
SearchRequest request = new SearchRequest(indexName).types(typeName);

//返回列（聚合列（group by的列需要聚合函数运算，就叫聚合列））  
        TermsAggregationBuilder field = AggregationBuilders.terms(GroupByName.SCODEID).field(GroupByName.SCODEID)  
                .size(10000);  
//搜索条件  
        SearchSourceBuilder searchSourceBuilder = getBuilder(esQuery, field, null);  
//包装条件，搜索  
        request.source(searchSourceBuilder);  
        SearchResponse searchResponse = client.search(request, RequestOptions.DEFAULT);  
//获取聚合---需要的列  
        Map<String, Aggregation> aggMap = searchResponse.getAggregations().asMap();  
//通过key获取列值的列表  
        ParsedStringTerms scodeIds = (ParsedStringTerms) aggMap.get(GroupByName.SCODEID);  
//解析列值的对象出列值  
        List<? extends Bucket> buckets = scodeIds.getBuckets();

for (Bucket bucket : buckets) \{  
                String scodeId = bucket.getKeyAsString();  
                \}

public SearchSourceBuilder getBuilder(EsQuery esQuery, TermsAggregationBuilder agg, TermsAggregationBuilder agg1) \{  
//总的搜搜索（打包条件和聚合的结果列）  
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();  
//搜索条件（范围，输入等）  
        BoolQueryBuilder builder = new BoolQueryBuilder();  
//返回的聚合列  
        TermsAggregationBuilder field1 = null;

// 时间范围查询条件  
        builder.must(  
                QueryBuilders.rangeQuery(GroupByName.DATETIME).gte(esQuery.getStartTime()).lte(esQuery.getEndTime()));  
//直接匹配--真假值---全文匹配  
builder.must(QueryBuilders.boolQuery()  
                    .must(QueryBuilders.termQuery(GroupByName.ISEXPORT, esQuery.getTradeWays())));

// 筛选树号---文本输入匹配---模糊匹配  
        if (esQuery.getSCodeIds() != null && !esQuery.getSCodeIds().isEmpty()) \{  
            builder.must(QueryBuilders.termsQuery(GroupByName.SCODEID, esQuery.getSCodeIds()));  
        \}

//返回的列设置---每列列值--  
field1 = AggregationBuilders.terms(GroupByName.PROVINCECONVERTED).field(GroupByName.PROVINCECONVERTED)-----基础聚合列  
                        .size(10000);  
//可以是结果所有同列值的聚合结果   尤其有利于树形结构的层级汇总和细分展现  
SumAggregationBuilder field2 = AggregationBuilders.sum(GroupByName.MONEYDOLLAR).field(GroupByName.MONEYDOLLAR);

field1.subAggregation(field2).subAggregation(field3).subAggregation(field4);------------累加聚合列  
            searchSourceBuilder.query(builder).aggregation(agg.subAggregation(field1));  
            return searchSourceBuilder;

// es数据库名  
    @Value("$\{data.elasticsearch.index.name\}")  
    private String indexName;  
    // es数据库——表名  
    @Value("$\{data.elasticsearch.type.name\}")  
    private String typeName;

es:报表统计用法：

// 先按照有税则号的scodeId分组,然后再按照时间作为二级分组（一维中细分） group by ，每种分组中再构造查询条件where ，并且根据查询条件的不同构造增加新的聚合列,返回的就是group by   
在哪个下面加新的聚合就是在这个层级下再细化--实现不同层级的不同细分（简单细分，或者细分并聚合计算）  
\-----------------实现了不同条件不同查询结果列  
        TermsAggregationBuilder scodeTerms = AggregationBuilders.terms(GroupByName.SCODE).field(GroupByName.SCODE)  
                .size(10000);  
        BoolQueryBuilder builder = new BoolQueryBuilder();  
        if (query.getAggType() == 1) \{  
            // 按年聚合  
            TermsAggregationBuilder year = AggregationBuilders.terms("year").field("year").size(1000);  
            scodeTerms.subAggregation(year);  
    year.subAggregation(AggregationBuilders.sum(GroupByName.MONEYDOLLAR).field(GroupByName.MONEYDOLLAR));  
                year.subAggregation(AggregationBuilders.sum(GroupByName.NUM).field(GroupByName.NUM));  
                    year.subAggregation(customsTerms);  
                    customsTerms.subAggregation(  
                            AggregationBuilders.sum(GroupByName.MONEYDOLLAR).field(GroupByName.MONEYDOLLAR));  
                    customsTerms.subAggregation(AggregationBuilders.sum(GroupByName.NUM).field(GroupByName.NUM));  
                    customsTerms.subAggregation(AggregationBuilders.sum(GroupByName.CMONEY).field(GroupByName.CMONEY));  
            builder.must(scodeIds);  
            \}else\{  
              
            \}

查出后的结果集处理思路：  
按照es查出的聚合（细分）层级，内存中计算汇总（弥补es聚合计算做不了的地方）

对集合的内存操作java8可类似sql功能过滤，统计，聚合-----有利于树形结构的分组分层聚合计算----------实现了内存中计算聚合结果,使用数据集的处理繁杂需求

按一维条件时间聚合  
Map<String, List<GroupByScodeDTO>> collect = dtos.stream()  
                    .collect(Collectors.groupingBy(GroupByScodeDTO::getYear));-----------分组返回map,也可分组统计

每个一时间中按照二维条件聚合  
dto来源于搜索结果  
cdto来源dto  
cdtos.add(cdto);  
Map<String, List<ConditionDTO>> collect3 = cdtos.stream()  
                                    .collect(Collectors.groupingBy(ConditionDTO::getConditionName));  
                            List<ConditionDTO> cdtoms = Lists.newArrayList();  
for (Entry<String, List<ConditionDTO>> cdtoEntry : collect3.entrySet()) \{---------每一个二维条件聚合求和  
                                ConditionDTO cdto = new ConditionDTO();  
                                cdto.setConditionName(cdtoEntry.getKey());  
                                cdto.setMoneySum(  
                                        cdtoEntry.getValue().stream().mapToLong(ConditionDTO::getMoneySum).sum());  
                                cdto.setChMoneySum(  
                                        cdtoEntry.getValue().stream().mapToLong(ConditionDTO::getChMoneySum).sum());  
                                // 总数量  
                                cdto.setNumSum(  
                                        new DecimalFormat(GroupByName.UNITOFPRECISION).format(cdtoEntry.getValue()  
                                                .stream().mapToDouble(n -> Double.parseDouble(n.getNumSum())).sum()));  
                                cdtoms.add(cdto);  
                            \}

按照年聚合失败就按照datetime聚合（根据es中的两种聚合）

2， ES:简单查询用法，类似普通查询sql，没有指定列就是\*  
  BoolQueryBuilder dataQueryBuilder = new BoolQueryBuilder();  
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();  
            dataQueryBuilder.must().add(QueryBuilders.termQuery(FuturesConstants.FUTURES\_INDEX\_CODE, indexCode));  
            dataQueryBuilder.must().add(QueryBuilders.rangeQuery(FuturesConstants.FUTURES\_DATADATE).from(beginDate).to(endDate));  
            searchSourceBuilder.query(dataQueryBuilder);  
            searchSourceBuilder.sort(FuturesConstants.FUTURES\_DATADATE, SortOrder.ASC);  
            searchSourceBuilder.sort(FuturesConstants.FUTURES\_PUBLISHTIME, SortOrder.ASC);  
            searchSourceBuilder.size(daylist.size() \* 5);  
            SearchRequest searchRequestdata = new SearchRequest(FuturesConstants.FUTURES\_ANALYSIS\_LAYOUT\_DATA);  
            searchRequestdata.source(searchSourceBuilder);  
            SearchResponse searchResponseData = restHighLevelClient.search(searchRequestdata, RequestOptions.DEFAULT);  
            SearchHits searchHitsData = searchResponseData.getHits();