elasticsearch - Elasticsearch:使用Metric Aggregation的结果来过滤存储桶的元素并运行其他聚合

Question

给定像这样的数据集

[{
    "type": "A",
    "value": 32
}, {
    "type": "A",
    "value": 34
}, {
    "type": "B",
    "value": 35
}]

我想执行以下聚合:

首先，我想使用以下术语对存储桶中的“类型”进行分组
聚合。

之后，我想使用extended_stats计算字段“值”的一些度量。

我想知道std_deviation_bounds(上下)
计算除此以外的存储桶元素的平均值
超出[std_deviation_bounds.lower]范围的那些，
std_deviation_bounds.upper]

我名单的第一和第二点是微不足道的。我想知道第三点是否有可能，使用同级度量标准聚合结果的信息来筛选出存储桶中的元素并重新计算平均值。而且，如果是的话，我想暗示一下我需要使用的聚合结构。

Elasticsearch实例的版本为5.0.0

Answer 1

好吧，OP在这里。

我仍然不知道ElasticSearch是否允许像我在原始问题中描述的那样制定汇总。

为了解决这个问题，我采取了不同的方法。我将在这里发布它，以防对其他人有帮助。

所以，

POST hostname:9200/index/type/_search

与

{
    "query": {
        "match_all": {}
    },
    "size": 0,
    "aggs": {
        "group": {
            "terms": {
                "field": "type"
            },
            "aggs": {
                "histogramAgg": {
                    "histogram": {
                        "field": "value",
                        "interval": 10,
                        "offset": 0,
                        "order": {
                            "_key": "asc"
                        },
                        "keyed": true,
                        "min_doc_count": 0
                    },
                    "aggs": {
                        "statsAgg": {
                            "stats": {
                                "field": "value"
                            }
                        }
                    }
                },
                "extStatsAgg": {
                    "extended_stats": {
                        "field": "value",
                        "sigma": 2
                    }
                }
            }
        }
    }
}

将产生这样的结果

{
    "took": 100,
    "timed_out": false,
    "_shards": {
        "total": 10,
        "successful": 10,
        "failed": 0
    },
    "hits": {
        "total": 100000,
        "max_score": 0.0,
        "hits": []
    },
    "aggregations": {
        "group": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [{
                "key": "A",
                "doc_count": 10000,
                "histogramAgg": {
                    "buckets": {
                        "0.0": {
                            "key": 0.0,
                            "doc_count": 1234,
                            "statsAgg": {
                                "count": 1234,
                                "min": 0.0,
                                "max": 9.0,
                                "avg": 0.004974220783280196,
                                "sum": 7559.0
                            }
                        },
                        "10.0": {
                            "key": 10.0,
                            "doc_count": 4567,
                            "statsAgg": {
                                "count": 4567,
                                "min": 10.0,
                                "max": 19.0,
                                "avg": 15.544345993923,
                                "sum": 331846.0
                            }
                        },
                        [...]
                    }
                },
                "extStatsAgg": {
                    "count": 10000,
                    "min": 0.0,
                    "max": 104.0,
                    "avg": 16.855123857,
                    "sum": 399079395E10,
                    "sum_of_squares": 3.734838645273888E15,
                    "variance": 1.2690056384124432E9,
                    "std_deviation": 35.10540102369,
                    "std_deviation_bounds": {
                        "upper": 87.06592590438,
                        "lower": -54.35567819038
                    }
                }
            },
            [...]
            ]
        }
    }
}

如果您注意类型:“A”的组聚合结果，您会注意到我们现在有了直方图的每个子组的平均值和计数。
您还将注意到extStatsAgg聚合(直方图聚合的同级)的结果也显示了每个存储桶组的std_deviation_bounds(对于类型:“A”，类型:“B”，...)

您可能已经注意到，这并没有提供我一直在寻找的解决方案。
我需要对代码进行一些计算。伪代码中的示例

for bucket in buckets_groupAggregation

    Long totalCount = 0
    Double accumWeightedAverage = 0.0

    ExtendedStats extendedStats = bucket.extendedStatsAggregation
    Double upperLimit = extendedStats.std_deviation_bounds.upper
    Double lowerLimit = extendedStats.std_deviation_bounds.lower

    Histogram histogram = bucket.histogramAggregation
    for group in histogram

        Stats stats = group.statsAggregation

        if group.key > lowerLimit & group.key < upperLimit
            totalCount += group.count
            accumWeightedAverage += group.count * stats.average

    Double average = accumWeightedAverage / totalCount

笔记:
直方图间隔的大小将确定最终平均值的“准确性”。更小的间隔将在获得更准确的结果的同时增加聚合时间。

希望对别人有帮助