Elasticsearch聚合查询

最新推荐文章于 2024-01-16 08:15:00 发布
最新推荐文章于 2024-01-16 08:15:00 发布
阅读量573 收藏
点赞数
分类专栏： Elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangshuanshuan/article/details/90205438
版权

Elasticsearch不支持聚合后分页

1. 分组

//select max(TEM_Max) from XX group by Station_Id_d
POST /XX/_search
{
  "size": 0,
  "aggs": {
    "max_score": {
      "terms": {
        "field": "Station_Id_d"
      },
      "aggs": {
        "max_score": {
          "max": {
            "field": "TEM_Max"
          }
        }
      }
    }
  }
}

2、增加过滤

//select max(TEM_Max) from XX where time > 315504000000 and time < 1293811199000 group by Station_Id_d
POST /XX/_search
{"size": 0, 
  "query" : {
    "bool" : {
      "filter" : [
        { "range" : {
            "time" : {
              "gt" : 315504000000,
              "lt" : 1293811199000
            }
          } }
      ]
    }
  },
  "aggs" : {
    "max_score": {
      "terms": {
        "field": "Station_Id_d"
      },
      "aggs": {
        "max_score": {
          "max": {
            "field": "TEM_Max"
          }
        }
      }
    }
  }
}

3、多值聚合

//select max(TEM_Max),min(TEM_Min),avg(TEM_Avg) from XX where time > 315504000000 and time < 1293811199000 group by Station_Id_d
POST /XX/_search
{"size": 0, 
  "query" : {
    "bool" : {
      "filter" : [
        { "range" : {
            "time" : {
              "gte" : 315504000000,
              "lte" : 1293811199000
            }
          } }
      ]
    }
  },
  "aggs" : {
    "avg_score": {
      "terms": {
        "field": "Station_Id_d"
      },
      "aggs": {
        "min_score": {
          "min": {
            "field": "TEM_Min"
          }
        },
        "max_score": {
          "max": {
            "field": "TEM_Max"
          }
        }
        ,
        "avg_score": {
          "avg": {
            "field": "TEM_Avg"
          }
        }
      }
    }
  }
}

4、聚合默认显示10条

//显示13条
POST /XX/_search
{"size": 0, 
  "query" : {
    "bool" : {
      "filter" : [
        { "range" : {
            "time" : {
              "gte" : 315504000000,
              "lte" : 1293811199000
            }
          } 
        }
      ]
    }
  },
  "aggs" : {
    "avg_score": {
      "terms": {
        "field": "Station_Id_d",
        "size": 13
      },
      "aggs": {
        "win_avg_score": {
          "avg": {
            "field": "WIN_S_2mi_Avg"
          }
        },
        "PRS_Min_score": {
          "min": {
            "field": "PRS_Min"
          }
        },
        "PRS_Max_score": {
          "max": {
            "field": "PRS_Max"
          }
        }
      }
    }
  }
}

5、多个要素groupby

select min(A),max(B)… from surf_chn_mul_day where time>XX and time <xxx and Station_Id_d=51223 group by Station_Id_d,Mon,Day

{"size": 0,
  "query" : {
    "bool" : {
      "filter" : [
        { "range" : {
          "time" : {
            "gte" : 315504000000,
            "lte" : 1293811199000
          }
        }
        },{ "range" : {
          "Station_Id_d" : {
            "gte" : 54645,
            "lte" : 54645
          }
        }
        }
      ]
    }
  },
  "aggs" : {
    "avg_score": {
      "terms": {
        "script": {
          "inline": "doc['Station_Id_d'].value +'-'+ doc['Mon'].value+'-'+ doc['Day'].value "
        },"size": 1000
      },
      "aggs": {
        "WIN_D_INST_Max_score": {
          "max": {
            "field": "WIN_D_INST_Max"
          }
        }      ,
        "WIN_S_2mi_Avg_score": {
          "avg": {
            "field": "WIN_S_2mi_Avg"
          }
        },
        "PRS_Min_score": {
          "min": {
            "field": "PRS_Min"
          }
        }
      }
    }
  }
}

java代码


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
import io.searchbox.client.JestClient;
import io.searchbox.core.Bulk;
import io.searchbox.core.Index;
import io.searchbox.core.Search;
import io.searchbox.core.SearchResult;
import io.searchbox.core.search.aggregation.TermsAggregation;
import io.searchbox.core.search.aggregation.TopHitsAggregation;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.script.Script;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;

import java.io.IOException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DayAggs365 {
	static ObjectMapper mapper = new ObjectMapper();
	static DecimalFormat df = new DecimalFormat("#0.00");

	public static void dayAgg365(long start, long end, int stationId, String toIndexName) throws IOException {
		JestClient client = ConfigData.getJestClient();
		SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
		QueryBuilder queryBuilder = QueryBuilders.boolQuery()
				.must(QueryBuilders.rangeQuery("time") //对time字段进行范围限定
						.gte(start).lt(end)).must(QueryBuilders.termQuery("Station_Id_d", stationId));
		searchSourceBuilder.query(queryBuilder);
		AggregationBuilder aggregationBuilder =
				AggregationBuilders.terms("Station_Id_dAgg").script(new Script("doc['Station_Id_d'].value +'-'+ doc['Mon'].value+'-'+ doc['Day'].value ")).size(1000)
				//.script(new Script("doc['Datetime.keyword'].value.substring(5,7)"))
						.subAggregation(AggregationBuilders.min("TEM_Min_score").field("TEM_Min"))
						.subAggregation(AggregationBuilders.max("TEM_Max_score").field("TEM_Max"))
						.subAggregation(AggregationBuilders.avg("TEM_Avg_score").field("TEM_Avg"))
						.subAggregation(AggregationBuilders.max("WIN_S_Inst_Max_score").field("WIN_S_Inst_Max"))
						.subAggregation(AggregationBuilders.max("WIN_D_INST_Max_score").field("WIN_D_INST_Max"))
						.subAggregation(AggregationBuilders.max("WIN_S_Max_score").field("WIN_S_Max"))
						.subAggregation(AggregationBuilders.max("WIN_D_S_Max_score").field("WIN_D_S_Max"))
						.subAggregation(AggregationBuilders.avg("WIN_S_2mi_Avg_score").field("WIN_S_2mi_Avg"))
						.subAggregation(AggregationBuilders.avg("PRE_Time_2020_score").field("PRE_Time_2020"))
						.subAggregation(AggregationBuilders.avg("PRE_Time_0808_score").field("PRE_Time_0808"))
						.subAggregation(AggregationBuilders.avg("PRE_Time_2008_score").field("PRE_Time_2008"))
						.subAggregation(AggregationBuilders.avg("PRE_Time_0820_score").field("PRE_Time_0820"))
						.subAggregation(AggregationBuilders.min("PRS_Min_score").field("PRS_Min"))
						.subAggregation(AggregationBuilders.max("PRS_Max_score").field("PRS_Max"))
						.subAggregation(AggregationBuilders.avg("PRS_Avg_score").field("PRS_Avg"))
						.subAggregation(AggregationBuilders.min("RHU_Min_score").field("RHU_Min"))
						.subAggregation(AggregationBuilders.avg("RHU_Avg_score").field("RHU_Avg"))
						.subAggregation(AggregationBuilders.min("VIS_Min_score").field("VIS_Min"));
		searchSourceBuilder.aggregation(aggregationBuilder);
//		System.out.println("searchSourceBuilder = " + searchSourceBuilder.toString());
		String query = searchSourceBuilder.toString();
		Search search = new Search.Builder(query).addIndex("surf_chn_mul_day").addType("surf_chn_mul_day").build();
		SearchResult result = client.execute(search);
//		System.out.println("result = " + result.getJsonString());
		List<TermsAggregation.Entry> nameAgg = result.getAggregations().getTermsAggregation("Station_Id_dAgg").getBuckets();
		List<Map<String, Object>> mapList = new ArrayList<>();
		for (TermsAggregation.Entry entry : nameAgg) {
			Map<String, Object> maps = new HashMap<>();
			String[] keys = entry.getKeyAsString().split("-");
			maps.put("Station_Id_C", Float.valueOf(keys[0]).intValue()+"");
			maps.put("Station_Id_d", Float.valueOf(keys[0]).intValue());
			maps.put("Mon",Float.valueOf(keys[1]));
			maps.put("Day",Float.valueOf(keys[2]));
			maps.put("TEM_Min", Float.valueOf(df.format(entry.getAvgAggregation("TEM_Min_score").getAvg())));
			maps.put("TEM_Max", Float.valueOf(df.format(entry.getAvgAggregation("TEM_Max_score").getAvg())));
			maps.put("TEM_Avg", Float.valueOf(df.format(entry.getAvgAggregation("TEM_Avg_score").getAvg())));
			maps.put("WIN_S_Inst_Max", Float.valueOf(df.format(entry.getAvgAggregation("WIN_S_Inst_Max_score").getAvg())));
//			maps.put("WIN_D_INST_Max",Float.valueOf(df.format(entry.getAvgAggregation("WIN_D_INST_Max_score").getAvg())));
			maps.put("WIN_S_Max", Float.valueOf(df.format(entry.getAvgAggregation("WIN_S_Max_score").getAvg())));
//			maps.put("WIN_D_S_Max",Float.valueOf(df.format(entry.getAvgAggregation("WIN_D_S_Max_score").getAvg())));
			maps.put("WIN_S_2mi_Avg", Float.valueOf(df.format(entry.getAvgAggregation("WIN_S_2mi_Avg_score").getAvg())));
			maps.put("PRE_Time_2020", Float.valueOf(df.format(entry.getAvgAggregation("PRE_Time_2020_score").getAvg())));
			maps.put("PRE_Time_0808", Float.valueOf(df.format(entry.getAvgAggregation("PRE_Time_0808_score").getAvg())));
			maps.put("PRE_Time_2008", Float.valueOf(df.format(entry.getAvgAggregation("PRE_Time_2008_score").getAvg())));
			maps.put("PRE_Time_0820", Float.valueOf(df.format(entry.getAvgAggregation("PRE_Time_0820_score").getAvg())));
			maps.put("PRS_Min", Float.valueOf(df.format(entry.getAvgAggregation("PRS_Min_score").getAvg())));
			maps.put("PRS_Max", Float.valueOf(df.format(entry.getAvgAggregation("PRS_Max_score").getAvg())));
			maps.put("PRS_Avg", Float.valueOf(df.format(entry.getAvgAggregation("PRS_Avg_score").getAvg())));
			maps.put("RHU_Min", Float.valueOf(df.format(entry.getAvgAggregation("RHU_Min_score").getAvg())));
			maps.put("RHU_Avg", Float.valueOf(df.format(entry.getAvgAggregation("RHU_Avg_score").getAvg())));
			maps.put("VIS_Min", Float.valueOf(df.format(entry.getAvgAggregation("VIS_Min_score").getAvg())));
			mapList.add(maps);
		}
		System.out.println(new Gson().toJson(mapList));
		Bulk.Builder bulk = new Bulk.Builder();
		for (Map<String, Object> record : mapList) {
			String id = record.get("Station_Id_d").toString()+"-"+record.get("Mon").toString()+"-"+record.get("Day").toString();
			Index index = new Index.Builder(record).id(id).index(toIndexName).type(toIndexName).build();
			bulk.addAction(index);
		}
		try {
			ConfigData.getJestClient().execute(bulk.build());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) throws IOException {
		dayAgg365(315504000000l, 1293811199000l, 54619, "surf_chn_mul_day_his");
	}
}

支持group by substr(‘字段’,5,6)

#Datetime  2016-05-01 00:00:00
"inline": "doc['Station_Id_d'].value +'-'+ doc['Datetime.keyword'].value.substring(5,7)"

6、http方式聚合

"trackTime": {
"type": "date",
"ignore_malformed": true,
"format": "yyyy-MM-dd HH:mm:ss"
}

{
    "size": 0,
    "query": {
        "bool": {
            "filter": [
                {
                    "range": {
                        "trackTime": {
                            "gte": "2020-05-26 10:00:00",
                            "lte": "2020-05-26 20:00:00"
                        }
                    }
                }
            ]
        }
    },
    "aggs": {
        "sum_score": {
            "terms": {
                "script": {
                    "inline": "doc['username.keyword'].value +'-'+ doc['uri.keyword'].value"
                }
            },
            "aggs": {
                "sum_score": {
                    "sum": {
                        "field": "_score"
                    }
                }
            }
        }
    }
}

注意，若时间

"inline": "doc['stationId'].value+'-'+doc['observeTime'].value.toString('MM')"
"inline": "doc['stationId'].value+'-'+doc['observeTime'].value.toString('yyyy-MM-dd HH:mm:ss')"

long转时间

"inline": "new Date(doc['time'].value)"

Painless语法

        SearchResult result = xxx;
        List<TermsAggregation.Entry> nameAgg = result.getAggregations().getTermsAggregation("sum_score").getBuckets();
        return nameAgg.stream().collect(Collectors.groupingBy(f -> f.getKey().split("-")[0],
                Collectors.toMap(v -> v.getKey().split("-")[1], v -> v.getCount())));

7、时间聚合

{
    "query": {
        "bool": {
            "must": [
                {
                    "range": {
                        "time": {
                            "gte": 331228800000,
                            "lte": 1596211200000
                        }
                    }
                }
            ]
        }
    },
    "size": 0,
    "aggs": {
        "seasonAgg": {
            "date_histogram": {
                "field": "time",
                "interval": "1q"
            },
            "aggs": {
                "PRS_Avg_score": {
                    "avg": {
                        "field": "PRS_Avg"
                    }
                }
            }
        }
    }
}

year（1y）年
quarter（1q）季度
month（1M）月份
week（1w）星期
day（1d）天
hour（1h）小时
minute（1m）分钟
second（1s）秒

8、聚合count

{
  "query": {
    "match": {
      "stationId": "57418"
    }
  },
  "aggs": {
    "windAggs": {
      "terms": {
    "script": {
        "source": "doc['observeMonthDay'].value.substring(0,2)"
    	  }
		}
      }
    }
  }
}

{
  "query": {
    "match": {
      "stationId": "57418"
    }
  },
  "aggs": {
    "windAggs": {
      "terms": {
    		"field": "Mon"
		}
      }
    }
  }
}

		AggregationBuilder aggregationBuilder =
				AggregationBuilders.terms("windAgg")
						.script(new Script("doc['observeMonthDay'].value.substring(0,2)"))
						//						.field("Mon")
						.size(366);

Elasticsearch要实现聚合后分页，该怎么办？

全量聚合，size设置为： 2147483647。 
ES5.X/6.X版本设置为2147483647 ，它等于2^31-1， 
是32位操作系统中最大的符号型整型常量；ES1.X 2.X版本设置为0。
JesJiang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ElasticSearch聚合分页
冲出仁川，走出马德里，故事还会再继续
06-10 188
ES支持同时返回查询结果和聚合结果，前面的博客在介绍聚合查询时，查询结果和聚合结果各自封装在不同的子句中。但有时我们希望聚合的结果按照每组选出前N个文档的方式进行呈现，最常见的一个场景就是电商搜索，如搜索苹果手机6S，搜索结果应该展示手机6S型号中的一款手机即可，而不论该型号手机的颜色有多少种。另外，当聚合结果和查询结果封装在一起时，还需要考虑对结果分页的问题，此时之前的博客介绍的聚合查询就不能解决这些问题了。ES提供的Top hits聚合和Collapse。
ES 聚合查询结果转换成相应的List对象
07-11
ES 聚合查询结果转换成相应的对象集合，ES 聚合查询结果转换成相应的对象集合
Elasticsearch学习-- 聚合查询
CelineT的博客
09-03 2985
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中的聚合分组查询
qq_40708942的博客
12-05 4618
分组聚合及嵌套查询 聚合查询可以理解为SQL中的求和、求最大值、最小值以及求均值的需求 嵌套可以理解为es存值的某一个字段为对象属性的值做处理.Elasticsearch Java API分组与聚合结合 需要对多个字段分组 需要将分组结果的其他字段再进行统计的sum、min、max、avg聚合 只聚合不分组 简单的分组查询 解析查聚合结果 上面是最简单的一层聚合查询,其实其他复杂的聚合也都是大同小异,就是一个套娃的操作.复杂聚合查询 ElasticSearch Java API嵌套 上面E
elasticsearch的聚合查询
奇想派
07-05 1297
elasticsearch里包含很多语法，其中聚合查询尤其重要，本文罗列了几乎全部的聚合操作和案例。
ES分组和查询
Java菜鸟
02-21 2604
es分组查询java封装
java使用elasticsearch分组进行聚合查询过程解析
08-25
Java 使用 Elasticsearch 进行分组聚合查询过程解析 Java 使用 Elasticsearch 进行分组聚合查询是一个常见的需求，特别是在大数据处理和数据分析领域。Elasticsearch 提供了强大的聚合功能，可以对数据进行分组、...
elasticsearch聚合后分页
12-16
方法如果传总页数了，es就不用查询总页数，直接通过开始位置到结束位置取数即可
elasticaggregator-php:在 PHP 中更简单的 ElasticSearch 聚合查询
06-07
特点和目标简单的聚合查询构造（ ） 简单聚合结果解析和“压缩”（ ） 干净、简约的界面（在结合） 经过良好测试的代码库可根据不同需求进行配置和定制去做确定公共函数的更好命名约定（以更好地反映底层分桶和度量...
Elasticsearch高级聚合查询
09-22
代码示例
中国天气数据，中国地面气象站要素清单
无极低码
04-19 4131
分类 要素编码 要素名称 单位 基本信息 Station_Id_C 区站号/观测平台标识 (字符) Year 年 年 Mon 月 月 Day 日 日 Hour 时次 时 观测要素 PRS 气压 百帕 PRS_Sea 海平面气压 百帕 PRS_Max ...
es分组查询多个字段
Z17839192969的博客
11-30 4451
es
elasticsearch[四]-数据聚合排序查询、搜索框自动补全、数据同步、集群
最新发布
丨汀、的博客
01-16 1077
elasticsearch[四]-数据聚合排序查询、搜索框自动补全、数据同步、集群
使用Elasticsearch进行分组聚合统计
ue4的博客
05-18 8226
使用Elasticsearch进行分组聚合统计
Java Elasticsearch多条件分组聚合查询
记录工作开发中遇到的技术难点，方便自己查看，也希望可以帮助到他人...
07-12 1351
Java Elasticsearch多条件分组聚合查询
es系列：聚合查询
zhuchunyan_aijia的博客
02-08 9966
对某个字段取最大值max { "aggs":{ "max_age":{ "max":{"field":"age"} } }, "size":0 } 年龄字段取最大值 对某个字段求最小值 { "aggs":{ "min_age":{ "min":{"field":"age"} } }, "size":0 } 对某个字段求和 { "aggs":{ "sum_age":{ "sum":{"field":"age"} } }, "size":0 } 对某个字段取
CIMISS数据获取流程
热门推荐
只要最后是你就好
01-04 1万+
1、规整时间。将时间进行调整，根据需要，设定为北京时间，以获取天的数据为例，时间格式为yyyyMMdd000000，这里获取日数据，时间统一往后推一天，例如今天获取的数据是CIMISS昨天的数据。获取小时，获取分钟，通过代码的编写，可相应的调整时间。以天为例，这里主要就是利用java现成的工具类，实现时间的转换。log.info("DAY=====日值资料=======CIMISS DAY STA
[Java]-Elastic中查询与聚合操作
农家小舍
07-24 2308
文章目录search基础分词器request请求SearchSourceBuilder查询QueryBuildersQueryStringQuery排序游标Scroll聚合AggregationBuildersnested嵌套聚合排序查询聚合collapse去重 在《Elastic中index与document基本操作》中介绍了Elastic的基本知识，及索引与文档操作；本节将介绍Elasticsearch中常用的查询与聚合操作。 search基础 Elasticsearch会对文档内容进行分词，并根据分词
es 聚合查询排除null_elasticsearch 聚合查询篇
06-02
好的，针对您的问题，您可以使用 Elasticsearch 的聚合查询中的“missing”聚合来排除 null 值。 具体来说，您可以使用以下的聚合查询语句： ``` { "aggs": { "field_name": { "missing": { "field": "your_field_name" } } } } ``` 其中，“field_name”是您想要聚合的字段名称，“your_field_name”是您想要排除 null 值的字段名称。 这样，您就可以得到该字段的非 null 值的聚合结果了。希望这能够帮助到您！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值