如果不忽略进一步的AGG，不能嵌套超过两个深度的术语聚合吗？

Question

我正在使用C#的Nest库查询ElasticSearch，以获取具有多个透视点的图形数据。每个透视点都是查询上的嵌套TermsAg聚集，一两个透视点一切正常。但是，一旦我达到三个透视点，SearchRequest对象就不会生成进一步的聚合。

构建聚合的代码如下所示：

TermsAggregation topTermAgg = null;
TermsAggregation currentAgg = null;
foreach (var pivotName in activePivots)
{
    newTermAgg = new TermsAggregation("pivot")
    {
        Field = pivot.ToString().ToLower()
    };

    if (topTermAgg == null)
    {
        topTermAgg = newTermAgg;
    }
    else
    {
        currentAgg.Aggregations = newTermAgg;
    }
    currentAgg = newTermAgg;
}

SearchRequest本身非常简单：

var searchRequest = new SearchRequest(Indices.Index("a", "b", "c"))
{
    Size = 0,
    Aggregations = topTermAgg,
    Query = query,
};

不幸的是，当转换为字符串时，3个或更多数据透视的SearchRequest如下（通过nestClient.Serializer.SerializeToString（SearchRequest））：

{
  "size": 0,
  "query": {
    "bool": <Fairly complex query, that works fine. It's the aggregation that has the problem.>
  },
  "aggs": {
    "pivot": {
      "terms": {
        "field": "pivot1"
      },
      "aggs": {
        "pivot": {
          "terms": {
            "field": "pivot2"
          }
        }
      }
    }
  }
}

当我在调试器中检查searchRequest对象时，它肯定有3个或更多聚合。这里发生了什么，如何让3个或更多嵌套术语聚合正常工作？

我使用的是Nest版本5.01。

Answer 1

我通过自下而上而不是自上而下构建聚合来运行代码。

var terminalAggregation = <some aggregation. In my code, there's a lowest aggregation that's different from the rest. For the code I presented, you could just build the lowest pivot.>
TermsAggregation topTermAgg = null;
activePivots.Reverse();
foreach (var pivotName in activePivots)
{
    newTermAgg = new TermsAggregation("pivot")
    {
        Field = pivot.ToString().ToLower(),
        Aggregations = topTermAgg ?? terminalAggregation
    };

    topTermAgg = newTermAgg;
}

这看起来像Nest库中的一个错误；有不同的类，如AggregationBase和BucketAggregationBase和AggregationDicpedia，它们都可以分配给“Aggregations”属性，但当您递归地执行此操作时，第二次分配后似乎存在一些微妙的缺陷。

文档也不是最新的：它声称您可以自己创建AggregationDictionary，但由于AggregationDictionary没有公共的Add（）方法，我真的不能。我也不能使用C#'s{}（在初始化语法之后）来填充其属性，因为Add（）不是公共的。

Answer 2

这必须与构建嵌套聚合的方式有关。可以使用客户端构建任意深度嵌套聚合。这是一个三个深度嵌套聚合的示例

client.Search<Question>(s => s
    .Aggregations(a => a
        .Terms("top", ta => ta
            .Field("top_field")
            .Aggregations(aa => aa
                .Terms("nested_1", nta => nta
                    .Field("nested_field_1")
                    .Aggregations(aaa => aaa
                        .Terms("nested_2", nnta => nnta
                            .Field("nested_field_3")
                        )
                    )
                )
            )
        )
    )
);

将其序列化为

{
  "aggs": {
    "top": {
      "terms": {
        "field": "top_field"
      },
      "aggs": {
        "nested_1": {
          "terms": {
            "field": "nested_field_1"
          },
          "aggs": {
            "nested_2": {
              "terms": {
                "field": "nested_field_3"
              }
            }
          }
        }
      }
    }
  }
}

您还可以直接向AggregationDicpedia添加值

var request = new SearchRequest<Question>
{
    Aggregations = new AggregationDictionary
    {
        { "top", new TermsAggregation("top")
            {
                Field = "top_field",
                Aggregations = new AggregationDictionary
                {
                    { "nested_1", new TermsAggregation("nested_1")
                        {
                            Field = "nested_field_1",
                            Aggregations = new AggregationDictionary
                            {
                                { "nested_2", new TermsAggregation("nested_2")
                                    {
                                        Field = "nested_field_2"
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
};

client.Search<Question>(request);

与前面的请求相同。您可以将其进一步缩短为

var request = new SearchRequest<Question>
{
    Aggregations = new TermsAggregation("top")
    {
        Field = "top_field",
        Aggregations = new TermsAggregation("nested_1")
        {
            Field = "nested_field_1",
            Aggregations = new TermsAggregation("nested_2")
            {
                Field = "nested_field_2"
            }
        }
    }
};

client.Search<Question>(request);