Elasticsearch Nest动态聚合

Question

我试图在c＃中运行聚合查询（使用嵌套5），但是我不知道输入多少聚合以及什么是聚合类型。

例如，一个查询是：{“ aggs”：{“ type_count”：{“ terms”：{“ field”：“ type”}}}}

其他查询将是：{“ aggs”：{“ type_count”：{“ terms”：{“ field”：“ type”}}，“ salary_count”：{“ field”：“ salary”}}}

其他查询可能根本不包含聚合。

如何在C＃中动态编​​写此代码？

这就是我尝试过的（我有选择的聚合类型的情况。问题是此代码仅支持一种聚合。

SearchDescriptor<object> SearchAgg = new SearchDescriptor<object>();
for (i=0;i < aggList.length;i++)
{
    SearchAgg.Aggregations(a => a.terms (aggList[i]), t=> t.Field(aggList[i]));
}

编辑：

我成功使用此代码添加了多个聚合：

AggregationContainerDescriptor<SearchRequest> agg = new
AggregationContainerDescriptor<SearchRequest>();

agg.Terms("bucket", tm=> tm.Field("field"));
agg &= new AggregationContainerDescriptor<SearchRequest>().Terms("bucket2", tm=> tm.Field("field2"));

谢谢

Answer 1

一般而言，在NEST中使用Fluent lambda表达式语法的方法调用执行分配，而不是累加，这意味着同一方法的连续调用将覆盖分配的内容。 在你的例子中

SearchDescriptor<object> SearchAgg = new SearchDescriptor<object>();
for (i=0;i < aggList.length;i++)
{
    SearchAgg.Aggregations(a => a.terms (aggList[i]), t=> t.Field(aggList[i]));
}

仅分配对SearchAgg.Aggregations(...)的最后一次调用。

写作汇总文档提供了发布多个汇总的示例。 鉴于以下POCO

public class Project
{
    public string Name { get; set; }
    public string Description { get; set; }
    public DateTime StartedOn { get; set; }
    public DateTime LastActivity { get; set; }
    public IList<string> Tags { get; set; }
    public IList<string> Branches { get; set; }
    public IList<CommitActivity> Commits { get; set; }
}

public class CommitActivity
{
    public string Id { get; set; }
    public string Message { get; set; }
    public long SizeInBytes { get; set; }
}

其中CommitActivity被映射为nested类型，在提交时发布两个术语，并在嵌套中进行嵌套聚合，以汇总有关每个项目的提交的统计信息

使用流畅的Lambda表达式语法

var searchResponse = client.Search<Project>(s => s
    .Aggregations(aggs => aggs
        .Terms("project_tags", t => t.Field(p => p.Tags))
        .Terms("project_branches", t => t.Field(p => p.Branches))
        .Nested("commits", n => n
            .Path(p => p.Commits)
            .Aggregations(aa => aa
                .Stats("commit_size_stats", m => m.Field(p => p.Commits.First().SizeInBytes))
            )
        )
    )
);

对象初始化语法

var searchRequest = new SearchRequest<Project>
{
    Aggregations = new AggregationDictionary
    {
        { "project_tags", new TermsAggregation("project_tags") { Field = Nest.Infer.Field<Project>(p => p.Tags) } },
        { "project_branches", new TermsAggregation("project_branches") { Field = Nest.Infer.Field<Project>(p => p.Branches) } },
        { "commits", new NestedAggregation("commits") 
            {
                Path = Nest.Infer.Field<Project>(p => p.Commits),
                Aggregations = new AggregationDictionary
                {
                    { "commit_size_stats", new StatsAggregation("commit_size_stats", Nest.Infer.Field<Project>(p => p.Commits.First().SizeInBytes)) },
                }
            }
        }
    }
};

var searchResponse = client.Search<Project>(searchRequest);

由于最终搜索请求上的聚合只是聚合名称和聚合类型的字典，因此使用此语法可以非常迅速地发展。 因此，NEST重载了逻辑&&运算符并实现了隐式转换，以允许以更简洁的方式组合聚合

简洁对象初始化语法

var searchRequest = new SearchRequest<Project>
{
    Aggregations = 
        new TermsAggregation("project_tags") { Field = Nest.Infer.Field<Project>(p => p.Tags) } &&
        new TermsAggregation("project_branches") { Field = Nest.Infer.Field<Project>(p => p.Branches) } &&
        new NestedAggregation("commits") 
        {
            Path = Nest.Infer.Field<Project>(p => p.Commits),
            Aggregations = 
                new StatsAggregation("commit_size_stats", Nest.Infer.Field<Project>(p => p.Commits.First().SizeInBytes))
        }
};

var searchResponse = client.Search<Project>(searchRequest);