Elasticsearch_聚合查询

最新推荐文章于 2023-01-05 10:31:12 发布
最新推荐文章于 2023-01-05 10:31:12 发布
阅读量370 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24099547/article/details/102321043
版权

聚合查询
Elasticsearch 聚合
Elasticsearch 聚合2
Elasticsearch三种聚合 Metrics Aggregations、Bucket Aggregations、Pipeline Aggregations中的常用聚合。

  • Metrics Aggregations 度量聚合
    如Count、Sum、Min、Max、Avg、Count(Distinct)就是度量。
  • Bucket Aggregations 分桶聚合
    如 Group by country,每个country就是一个桶，也可以叫做一个分组。可对每个分组内的数据进行聚合。
  • Pipeline Aggregations 管道聚合
    管道聚合，基于现有的聚合结果，再进行聚合。

1.数据准备

创建索引

PUT user_logs
{
  "settings": {
    "number_of_shards": 3,
    "number_of_replicas": 1
  },
  "mappings": {
    "recharge_log": {
      "properties": {
        "uid": {
          "type": "keyword"
        },
        "name": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword"
            }
          }
        },
        "age": {
          "type": "integer"
        },
        "country": {
          "type": "keyword"
        },
        "payTime": {
          "type": "date",
          "format": "yyyy-MM-dd HH:mm:ss"
        },
        "payWay": {
          "type": "integer"
        },
        "money": {
          "type": "integer"
        }
      }
    }
  }
}

插入数据

POST /user_logs/recharge_log/_bulk
{"index": {}}
{"uid": "1", "country": "US", "age": 26, "payWay": 2, "money": 30, "payTime": "2016-08-25 08:05:16", "name": "Rose petal"}
{"index": {}}
{"uid": "1", "country": "US", "age": 26, "payWay": 1, "money": 20, "payTime": "2016-08-26 08:05:16", "name": "Rose petal"}
{"index": {}}
{"uid": "1", "country": "US", "age": 26, "payWay": 1, "money": 30, "payTime": "2016-08-27 10:05:16", "name": "Rose petal"}
{"index": {}}
{"uid": "2", "country": "CN", "age": 23, "payWay": 2, "money": 20, "payTime": "2016-08-25 08:05:16", "name": "Belen Rose"}
{"index": {}}
{"uid": "2", "country": "CN", "age": 23, "payWay": 2, "money": 20, "payTime": "2016-08-26 08:05:16", "name": "Belen Rose"}
{"index": {}}
{"uid": "2", "country": "CN", "age": 23, "payWay": 1, "money": 20, "payTime": "2016-08-27 10:05:16", "name": "Belen Rose"}
{"index": {}}
{"uid": "3", "country": "CN", "age": 29, "payWay": 2, "money": 20, "payTime": "2016-08-25 08:05:16", "name": "Rose petal"}
{"index": {}}
{"uid": "3", "country": "CN", "age": 29, "payWay": 2, "money": 20, "payTime": "2016-08-26 08:05:16", "name": "Rose petal"}
{"index": {}}
{"uid": "3", "country": "CN", "age": 29, "payWay": 1, "money": 10, "payTime": "2016-08-27 10:05:16", "name": "Rose petal"}

只返回聚合结果
设置size=0,只返回聚合结果，不返回搜索结果。

GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "avg_money": {
      "avg": {
        "field": "money"
      }
    }
  }
}

#返回
{
    "took": 895,
    "timed_out": false,
    "_shards": {
        "total": 3,
        "successful": 3,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": 9,
        "max_score": 0.0,
        "hits": []
    },
    "aggregations": {
        "avg_money": {
            "value": 21.11111111111111
        }
    }
}

同时返回聚合类型
添加typed_keys参数，在返回聚合结果时，可同时返回聚合类型。
如下avg#avg_money，在聚合名称(avg_money)前添加聚合类型(avg)前缀，并一并返回。

#查询
GET user_logs/recharge_log/_search?size=0&typed_keys
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "avg_money": {
      "avg": {
        "field": "money"
      }
    }
  }
}

#返回
{
  "took": 3,
  "timed_out": false,
  "_shards": {
    "total": 3,
    "successful": 3,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 9,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "avg#avg_money": {
      "value": 21.11111111111111
    }
  }
}

2.度量聚集

2.1 max/min/sum/avg

查询结果中某字段的最大值。

#1.查询：单笔充值最高值
GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "max_money":{
      "max": {
        "field": "money"
      }
    }
  }
}
max_money是我们自定义的名称,用来接收聚合结果

#2.查询：最小充值金额
GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "min_money":{
      "min": {
        "field": "money"
      }
    }
  }
}

#3.查询：总充值金额
GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "sum_money":{
      "sum": {
        "field": "money"
      }
    }
  }
}

##4.查询：平均充值金额=总充值金额/充值订单数
GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "avg_money":{
      "avg": {
        "field": "money"
      }
    }
  }
}
2.2 Value Count

相似于count(列)
值计数聚合。计算聚合文档中某个值（可以是特定的数值型字段，也可以通过脚本计算而来）的个数。该聚合一般域其它 single-value 聚合联合使用，比如在计算一个字段的平均值的时候，可能还会关注这个平均值是由多少个值计算而来。

#查询：文档总数
GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "value_count_docs": {
      "value_count": {
        "field": "_id"
      }
    }
  }
}
2.3 去重计数聚合(Cardinality Aggregation)

计算查询结果中某字段值的去重计数。
去重计数聚合基于HyperLogLog++ 算法，这个算法基于散列值，可通过precision_threshold控制精度。
precision_threshold默认值3000，最大值40000。

#查询：充值uv
GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "recharge_uv":{
      "cardinality": {
        "field": "uid",
        "precision_threshold": 40000
      }
    }
  }
}

#返回
{
  "took": 9,
  "timed_out": false,
  "_shards": {
    "total": 3,
    "successful": 3,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 9,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "recharge_uv": {
      "value": 3
    }
  }
}
最终的值有3个,即[1,2,3]
2.4 统计信息聚合(Stats Aggregation)

Stats Aggregation，统计聚合。它属于multi-value，基于文档的某个值（可以是特定的数值型字段，也可以通过脚本计算而来），计算出一些统计信息（min、max、sum、count、avg5个值）。

计算查询结果中某字段的统计数据。

#查询：充值金额统计
GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "stats_money":{
      "stats": {
        "field": "money"
      }
    }
  }
}

#返回
{
  "took": 9,
  "timed_out": false,
  "_shards": {
    "total": 3,
    "successful": 3,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 9,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "stats_money": {
      "count": 9,
      "min": 10,
      "max": 30,
      "avg": 21.11111111111111,
      "sum": 190
    }
  }
}
2.5 百分位数聚合(Percentiles Aggregation)

计算查询结果中某字段的百分位数。可用来评估字段值分布。
如用来评估请求SLA延迟是否达标。每条请求日志都包含请求延时字段，可以查看请求延时99百分位数，如果99百分位数的值在100ms以内则说明请求在100ms内响应的占比99%，SLA达标，否则SLA不达标。

如下，返回结果50.0:20，意味着，单笔充值金额在20以内的占比50%。
默认百分位数1,5,25,50,75,95,99。

注意：
百分位数也可通过numpy取得。如 print numpy.percentile(numpy.array([5,10,18]),99)
常用平均值度量，但平均值容易受异常最大最小值影响，

#查询：
GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "percentiles_money":{
      "percentiles": {
        "field": "money",
        "percents": [
          50, 
          99
        ]
      }
    }
  }
}

#返回
{
  "took": 15,
  "timed_out": false,
  "_shards": {
    "total": 3,
    "successful": 3,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 9,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "percentiles_money": {
      "values": {
        "50.0": 20, //单笔充值金额在20以内的占比50%
        "99.0": 30 //单笔充值金额在30以内的占比99%
      }
    }
  }
}

3.分桶聚合(Bucket Aggregations)

它执行的是对文档分组的操作（与sql中的group by类似），把满足相关特性的文档分到一个桶里，即桶分，输出结果往往是一个个包含多个文档的桶（一个桶就是一个group）。

它有一个关键字（field、script），以及一些桶分（分组）的判断条件。执行聚合操作时候，文档会判断每一个分组条件，如果满足某个，该文档就会被分为该组（fall in）。

它不进行权值的计算，他们对文档根据聚合请求中提供的判断条件（比如：{“from”:0, “to”:100}）来进行分组（桶分）。桶聚合还会额外返回每一个桶内文档的个数。

3.1 Terms Aggregation 词聚合

Terms Aggregation，词聚合。基于某个field，该 field 内的每一个【唯一词元】为一个桶，并计算每个桶内文档个数。默认返回顺序是按照文档个数多少排序。它属于multi-bucket
当不返回所有 buckets 的情况（它size控制），文档个数可能不准确。

#每种充值方式对应的充值总额
GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "terms_payWay": {
     "terms": {
       "field": "payWay"
     }
    }
  }
}

##返回
{
    "took": 379,
    "timed_out": false,
    "_shards": {
        "total": 3,
        "successful": 3,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": 9,
        "max_score": 0.0,
        "hits": []
    },
    "aggregations": {
        "terms_payWay": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": 2,
                    "doc_count": 5
                },
                {
                    "key": 1,
                    "doc_count": 4
                }
            ]
        }
    }
}

##扩展
{
    "aggs" : {
        "age_terms" : {
            "terms" : { 
              "field" : "age",
              "size" : 10,                     //size用来定义需要返回多个 buckets（防止太多），默认会全部返回。
              "order" : { "_count" : "asc" },  //根据文档计数排序，根据分组值排序（{ "_key" : "asc" }）
              "min_doc_count": 10,             //只返回文档个数不小于该值的 buckets
              "include" : ".*sport.*",         //包含过滤
              "exclude" : "water_.*",          //排除过滤
              "missing": "N/A" 
            }
        }
    }
}

3.2 单过滤聚合(Filter Aggregation)

对Quey结果单次Filter后形成的新的Bucket进行聚合。是单Bucket聚合。

POST user_logs/recharge_log/_search?size=0
{
  "query": {"match_all": {}},
  "aggs": {
    "payWay2_agg":{
      "filter": {"term": {"payWay": 2}},							//先过滤出来payWay为2的数据
      "aggs": {"sum_money_payWay2": {"sum": {"field":"money"}}}		//对过滤出的数据,根据money字段进行分组
    }
  }
}

(1)先过滤出来payWay为2的数据,显示有5条数据
(2)对过滤出来的5条数据,根据money字段进行分组

#返回
"aggregations": {
    "payWay2_agg": {
        "doc_count": 5,
        "sum_money_payWay2": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": 23,
                    "doc_count": 2
                },
                {
                    "key": 29,
                    "doc_count": 2
                },
                {
                    "key": 26,
                    "doc_count": 1
                }
            ]
        }
    }
}

进阶:
{
	"query": {
		"match_all": {}
	},
	"aggs": {
		"payWay2_agg": {
			"filter": {
				"term": {
					"payWay": 2								//1.过滤出payWay为2的数据,一共有5条数据,显示payWay2_agg的doc_count为5
				}
			},
			"aggs": {
				"sum_money_payWay2": {
					"terms": {
						"field": "age"						//2.对这5条数据,以age分组,一共分为3组,23有2个.26有1个,29有2个
					},
					"aggs": {
						"filter_CN":{
							"filter": {
								"term": {
									"country":"CN" 			//3.对这三个组中的数据进行过滤,在每个桶中筛选出country为CN的数据,23的filter_CN的doc_count是2,26的filter_CN的doc_count是0,29的filter_CN的doc_count是2
								}
							},
							"aggs": {
								"uid_count": {
									"terms": {
										"field": "uid"		//4.三个桶都过滤出了数据,此时对每个桶中的数据进行分组
									}
								}
							}
						}
					}
				}
			}
		}
	}
}

3.3 多过滤聚合(Filters Aggregation)

对Quey结果多次Filter后形成的多个Bucket分别聚合。是多Bucket聚合。

POST user_logs/recharge_log/_search?size=0
{
  "query": {"match_all": {}},
  "aggs": {
    "flters_agg": {
     "filters": {
       "filters": {
         "uid1": {"term": {"uid": 1}},
         "uid2":{"term": {"uid": 2}}
       }
     },
     "aggs": {
       "payWay": {
         "terms": {
           "field": "payWay"
         }
       }
     }
    }
  }
}

总结:Filter,Filters,terms的区别
## 1.单过滤聚合
{
  "query": {"match_all": {}},
  "aggs": {
    "flters_agg": {
    	"filter":{
    		"term": {"uid": 1}
    	}
    }
  }
}

## 结果:过滤出了uid为1的数据有3个
{
	"aggregations": {
	    "flters_agg": {
	        "doc_count": 3
	    }
	}
}

## 2.多过滤聚合
{
  "query": {"match_all": {}},
  "aggs": {
    "flters_agg": {
    	"filters":{
    		"filters":{
    			"uid1": {"term": {"uid": 1}},
        		"uid2":{"term": {"uid": 2}}
    		}
    	}
    }
  }
}

## 结果:过滤出了uid为1的有3个,uid为2的也有3个(等于有两个桶了,本质上就是桶)
{
	"aggregations": {
        "flters_agg": {
            "buckets": {
                "uid1": {
                    "doc_count": 3
                },
                "uid2": {
                    "doc_count": 3
                }
            }
        }
    }
}

## 3.唯一值聚合
{
  "query": {"match_all": {}},
  "aggs": {
  	"terms_agg":{
		"terms":{
			"field":"uid"
		}
	}
  }
}

## 结果,我们看到返回结果和多过滤聚合的返回结果是差不多的,不过多过滤的buckets是对象(对象有属性叫uid1和uid2),而唯一值聚合的buckets是数组
{
	"aggregations": {
        "terms_agg": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": "1",
                    "doc_count": 3
                },
                {
                    "key": "2",
                    "doc_count": 3
                },
                {
                    "key": "3",
                    "doc_count": 3
                }
            ]
        }
    }
}

3.4 范围聚合(Range Aggregation)

自定义一系列范围，每个范围代表一个分桶。

GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "range": {
      "age": {
        "gte": 20,
        "lte": 36
      }
    }
  },
  "aggs": {
    "age_range_agg": {
      "range": {
        "field": "age",
        "ranges": [
          {
            "to": 30
          },
          {
            "from": 25,
            "to": 30
          }
        ]
      }
    }
  }
}

##结果如下:
{
	"aggregations": {
        "age_range_agg": {
            "buckets": [
                {
                    "key": "*-30.0",				//表示0-30的有9个
                    "to": 30,
                    "doc_count": 9
                },
                {
                    "key": "25.0-30.0",				//表示25-30的有6个
                    "from": 25,
                    "to": 30,
                    "doc_count": 6
                }
            ]
        }
    }
}


##扩展:
{
	"query": {
		"range": {
			"age": {
				"gte": 20,
				"lte": 36
			}
		}
	},
	"aggs": {
		"age_range_agg": {
			"range": {
				"field": "age",
				"ranges": [{
						"to": 30
					},
					{
						"from": 25,
						"to": 30
					}
				]
			},
			"aggs": {
				"country": {
					"terms": {
						"field": "country"
					}
				}
			}
		}
	}
}
#结果如下
{
 "aggregations": {
        "age_range_agg": {
            "buckets": [
                {
                    "key": "*-30.0",
                    "to": 30,
                    "doc_count": 9,
                    "xxx": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "CN",
                                "doc_count": 6
                            },
                            {
                                "key": "US",
                                "doc_count": 3
                            }
                        ]
                    }
                },
                {
                    "key": "25.0-30.0",
                    "from": 25,
                    "to": 30,
                    "doc_count": 6,
                    "xxx": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "CN",
                                "doc_count": 3
                            },
                            {
                                "key": "US",
                                "doc_count": 3
                            }
                        ]
                    }
                }
            ]
        }
    }
}

3.5 日期范围聚合

对日期字段按日期范围聚合。是多Bucket聚合。

同范围聚合(Range Aggregation)相比，日期范围聚合可用ES 内置日期格式或JodaDate日期表达式来表示日期范围。

format指定输入和输出日期格式。

GET /user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "date_range_payTime": {
      "date_range": {
        "field": "payTime",
        "format": "epoch_second", 
        "ranges": [
          {
            "from": 1472083200000,
            "to": 1472169600000
          },
          {
            "from": 1472169600000,
            "to": 1472256000000
          }
        ]
      }
    }
  }
}

## 返回值
"aggregations": {
   "date_range_payTime": {
       "buckets": [
           {
               "key": "1472083200-1472169600",		//2016-08-25 08:00:00 ~ 2016-08-26 08:00:00 的文档有3个
               "from": 1472083200000,
               "from_as_string": "1472083200",
               "to": 1472169600000,
               "to_as_string": "1472169600",
               "doc_count": 3
           },
           {
               "key": "1472169600-1472256000",		//2016-08-26 08:00:00 ~ 2016-08-27 08:00:00 的文档有三个
               "from": 1472169600000,
               "from_as_string": "1472169600",
               "to": 1472256000000,
               "to_as_string": "1472256000",
               "doc_count": 3
           }
       ]
   }
}

## 扩展 使用JodaDate日期表达式
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "date_range_payTime": {
      "date_range": {
        "field": "payTime",
        "format": "yyyy-MM-dd", 
        "ranges": [
          {
            "to": "now-3y"								//当前时间2019/10/15日 往前推3年,即2016/10/15
          },
          {
            "from": "now-3y"
          }
        ]
      }
    }
  }
}

结果如下
"aggregations": {
    "date_range_payTime": {
        "buckets": [
            {
                "key": "*-2016-10-15",					//2016-10-15以前的文档有9个
                "to": 1476516729585,
                "to_as_string": "2016-10-15",
                "doc_count": 9
            },
            {
                "key": "2016-10-15-*",					//2016-10-15以后的文档有0个
                "from": 1476516729585,
                "from_as_string": "2016-10-15",
                "doc_count": 0
            }
        ]
    }
}

如果想让时间设定为月初开始,即2016/10/1
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "date_range_payTime": {
      "date_range": {
        "field": "payTime",
        "format": "yyyy-MM-dd", 
        "ranges": [
          {
            "to": "now-3y/M"								//当前时间2019/10/15日 往前推3年的当月第一天,即2016/10/1
          },
          {
            "from": "now-3y/M"
          }
        ]
      }
    }
  }
}

可参考:date range

3.6 直方图聚合(Histogram Aggregation)
#value:字段值
#interval:间隔
#rem:取余
#举例:
#如 interval=10
#当 value=10 时，rem=0,则bucket_key=10
rem = value % interval
if (rem < 0) {
    rem += interval
}
bucket_key = value - rem

#查询：每个充值区间的订单数
GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "money_histogram": {
      "histogram": {
        "field": "money",		//必须为数值类型
        "interval": 10,		    //分桶间距
        "min_doc_count" : 1,    //最少文档数桶过滤，只有不少于这么多文档的桶才会返回
        "extended_bounds" : {   //范围扩展
                    "min" : 0,
                    "max" : 500
                },
        "order" : { "_count" : "desc" },//对桶排序，如果 histogram 聚合有一个权值聚合类型的"直接"子聚合，那么排序可以使用子聚合中的结果
        "keyed":true,           //hash结构返回，默认以数组形式返回每一个桶
         "missing":0            //配置缺省默认值
      }
    }
  }
}

3.7 全局聚合(Global Aggregation)

全局聚合不受Query的影响。是单Bucket聚合。

#全部年龄充值总金额和query年龄段充值总金额。

{
  "query": {"range": {"age": {"gte": 10,"lte": 25}}},
  "aggs": {
    "all_age_sum_money": {
      "global": {}, 				//all_age_sum_money使用全局聚合
      "aggs": {
        "sum_money": {
          "sum": {
            "field": "money"
          }
        }
      }
    },
    "this_age_sum_money":{
      "sum": {						//this_age_sum_money不使用全局聚合
        "field": "money"
      }
    }  
  }
}

#返回结果
{
  "took": 4,
  "timed_out": false,
  "_shards": {
    "total": 3,
    "successful": 3,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 3,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "all_age_sum_money": { 			//全局聚合结果-不受Query影响
      "doc_count": 9,
      "sum_money": {
        "value": 190
      }
    },
    "this_age_sum_money": {			 //Query聚合结果
      "value": 60
    }
  }
}

3.8 缺失值聚合(Missing Aggregation)

对Query结果中某缺失字段统计。是单Bucket聚合。

#统计没有payWay字段或payWay字段为NULL的文档数。
GET user_logs/recharge_log/_search?size=0
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "missing_payWay": {
      "missing": {
        "field": "payWay"
      }
    }
  }
}

#返回结果
{
  "took": 23,
  "timed_out": false,
  "_shards": {
    "total": 3,
    "successful": 3,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 9,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "missing_payWay": {
      "doc_count": 0
    }
  }
}

管道聚合

管道聚合分为两类：

  • Sibling
    基于同级聚合结果再进行聚合。

  • Parent
    基于父级聚合结果再进行聚合。


1.桶均值聚合(Avg Bucket Aggregation)

同级管道聚合,计算同级聚合中所有桶指定度量的均值。

先对日期进行分组,每一天的数据一个桶,之后计算每个桶的充值金额总数

#每天充值金额与平均每天充值金额
GET user_logs/recharge_log/_search?size=0
{
  "query": {"match_all": {}},
  "aggs": {
    "date_agg": {  						//对日期进行聚合,此处的day表示天
      "date_histogram": {
        "field": "payTime",
        "interval": "day"
      },
    "aggs": {							//同级聚合,和date_histogram同级,日期分桶后,计算桶中的金额总数
      "day_avg_money": { 
        "avg": {
          "field": "money"
        }
      }
    }
    },
    "pipeline_avg_money":{ 				//平均每天充值金额
      "avg_bucket": {
        "buckets_path": "date_agg>day_sum_money"
      }
    }
  }
}

## 返回结果
{
  "took": 182,
  "timed_out": false,
  "_shards": {
    "total": 3,
    "successful": 3,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 9,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "date_agg": {
      "buckets": [
        {
          "key_as_string": "2016-08-25 00:00:00",
          "key": 1472083200000,
          "doc_count": 3,
          "day_sum_money": {
            "value": 70
          }
        },
        {
          "key_as_string": "2016-08-26 00:00:00",
          "key": 1472169600000,
          "doc_count": 3,
          "day_sum_money": {
            "value": 60
          }
        },
        {
          "key_as_string": "2016-08-27 00:00:00",
          "key": 1472256000000,
          "doc_count": 3,
          "day_sum_money": {
            "value": 60
          }
        }
      ]
    },
    "pipeline_avg_money": {
      "value": 63.333333333333336
    }
  }
}

sp_wxf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ElasticSearch搜索-响应结果说明
zc0565的博客
03-19 1279
响应结果说明 示例： GET http://localhost:9200/superz/_search 得到的响应结果一般如下所示： { "took": 2, "timed_out": false, "_shards": { "total": 5, "successful": 5, "skipped": 0, "failed": 0 }, "h...
Elasticsearch高级聚合查询
最新发布
09-22
代码示例
【ElasticSearch教程】--- Elasticsearch文档聚合查询(十四）
maoye的博客
05-09 577
聚合查询 对查询的结果进行统计，分组等操作的时候就需要用的聚合操作， 聚合操作需要用到聚合操作对应的参数。参数字段名叫：aggs。 分组统计(terms) { "aggs": { // 聚合操作 "category_group":{ // 名称，随意取名 "terms":{ "field":"price" } } } } 返回内容 { "took": 2, "t
ElasticSearch 学习笔记：聚合(Aggregation) - Top Hits
崔显龙的博客
02-21 1万+
聚合后，每一个聚合Bucket里面仅返回指定顺序的前N条数据。
ElasticSearch 实践
z69183787的专栏
04-10 1524
版本：2.3.5 版本：5.3.0 （应为3.X，随ELK版本统一，故从5.X 开始） Windows端 1、官网下载 https://www.elastic.co/downloads/past-releases/elasticsearch-2-3-5 2、安装head插件 进入目录E:\elasticsearch-2.3.5\bin&gt; 执行 plugin.bat inst...
Elasticsearch使用
s7799653的博客
12-06 158
Getting Started 基本概念 Near Realtime（近实时） Elasticsearch 是一个near-realtime(接近于实时)的搜索平台。从索引文档到它被搜索到只用轻微的延迟（通常是1秒） Cluster（集群） 集群是一个或多个节点的集合，这些节点被用来保存数据或提供索引和跨节点搜索服务。集群有唯一的名称标识（cluster name...
java使用elasticsearch分组进行聚合查询过程解析
08-25
Java 使用 Elasticsearch 进行分组聚合查询过程解析 Java 使用 Elasticsearch 进行分组聚合查询是一个常见的需求，特别是在大数据处理和数据分析领域。Elasticsearch 提供了强大的聚合功能，可以对数据进行分组、...
elasticsearch_ES_Elasticsearch界面_elasticsearch_源码
10-04
**Elasticsearch（ES）详解** Elasticsearch是一款开源、分布式、实时的全文搜索引擎，它基于Lucene构建，被广泛用于大数据分析、日志聚合、实时搜索和索引等场景。其强大的功能和易用性使得它在IT行业中备受青睐。...
elasticsearch聚合后分页
12-16
方法如果传总页数了，es就不用查询总页数，直接通过开始位置到结束位置取数即可
es与solr的区别_solr_ES_es与solr的区别_elasticsearch_
10-03
在大数据和搜索引擎领域，Elasticsearch (ES) 和 Apache Solr 都是广泛使用的开源技术，它们都基于 Lucene 库，提供高性能、可扩展的全文搜索和分析能力。然而，两者在设计哲学、使用场景、功能特性以及社区支持等...
ElasticSearch的查询
weixin_45882228的博客
11-19 869
ElasticSearch的查询
Elasticsearch：如何在搜索时得到精确的总 hits 数
roakcom的博客
01-05 1153
这里面提到：某个查询条件下的total hits是不准确的，因为它没有：visiting all matches。从 Elasticsearch 7.0之后，为了提高搜索的性能，在 hits 字段中返回的文档数有时不是最精确的数值。我们在请求的参数中加入 track_total_hits，并设置为true，那么我们可以看到在返回的参数中，它正确地显示了所有满足条件的文档个数。显然我们得到的文档的数目是10000个，但是它并不是我们的实际的满足条件的所有文档数。返回符合查询条件的文档数量，应该能满足需求。
ElasticSearch进阶_基本操作
qq_24099547的博客
10-01 156
1.倒排索引 常规的索引建立方式: 文件>关键词的映射过程(正向索引) 缺点:费时,需要将文档全部遍历一遍 倒排反向建立索引 关键词>文档的映射 把正向索引的结果重新构建成倒排索引 通俗解释: 例如有5个文档,全文搜索将这5个文档进行分词(中文或英文),将文档中一个个单词根据不用的语言,拆分成单个微小的词项,然后每个单词都有一个id,对文档也做一个集合,然后对单词集合和文档集合...
Elasticsearch 搜索数据基本用法
热门推荐
wushizhezhe的博客
01-09 1万+
深入搜索编辑 在 基础入门 中涵盖了基本工具并对它们有足够详细的描述，这让我们能够开始用 Elasticsearch 搜索数据。 用不了多长时间，就会发现我们想要的更多：希望查询匹配更灵活，排名结果更精确，不同问题域下搜索更具体。 想要进阶，只知道如何使用 match 查询是不够的，我们需要理解数据以及如何能够搜索到它们。本章会解释如何索引和查询我们的数据让我们能利用词的相似度
五分钟带你玩转Elasticsearch（四）es基础语法全总结
小鲍侃java
06-01 845
1.语句返回值概述 Hits：返回结果中最重要的部分是hits，它包含total字段来表示匹配到的文档总数，并且一个hits数组包含所查询结果的前十个文档。在hits数组中每个结果包含文档的_index、_type、_id，加上_source字段。这意味着我们可以直接从返回的搜索结果中使用整个文档。这不像其他的搜索引擎，仅仅返回文档的ID，需要你单独去获取文档。每个结果还有一个_score，它衡量了文档与查询的匹配程度。默认情况下，首先返回最相关的文档结果，就是说，返回...
ElasticSearch 学习记录,持续更新中
m0_37528968的博客
10-14 122
1.索引 1.创建索引，因为需要客户端去设置索引的 名称，所以需要使用PUT不要使用POST，关于post和get的详解可以查看RESTful 架构详解 | 菜鸟教程 ​ PUThttp://localhost:9200/schools/
elasticsearch入门操作+高级操作(超详细)
Knight
07-16 3457
目录1.ElasticSearch相关概念2.索引库操作2.1.创建索引库2.2.查看索引库2.3.删除索引库3.类型及映射操作3.1.创建映射字段(**`需先创建索引库`**)3.2.映射属性详解3.3.查看映射关系3.4.一次创建索引库和类型（常用）4.文档操作4.1.新增并随机生成id4.2.查看文档4.3.新增文档并自定义id4.4.修改数据4.5.删除数据4.6.删除所有数据5.查询5.1.基本查询5.1.1 查询所有（match_all)5.1.2 匹配查询（match）5.1.3 多字段查询（
TIKV.log
weixin_54896604的博客
10-14 403
【代码】TIKV.log。
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、付费专栏及课程。

余额充值