ElasticSearch之Quick.ElasticSearch.Furion组件的使用

ElasticSearch 使用说明
本章,我们主要讲解在.Net 中对Quick.ElasticSearch.Furion的使用进行介绍!

ElasticSearch 的官方客户端 API 文档地址:https://www.elastic.co/guide/en/elasticsearch/client/index.html

ElasticSearch 的官方客户端 API 文档地址(.Net,ElasticSearch8.x):https://www.elastic.co/guide/en/elasticsearch/client/net-api/current/index.html

ElasticSearch 的官方客户端 API 文档地址(.Net,ElasticSearch7.x):https://www.elastic.co/guide/en/elasticsearch/client/net-api/7.17/index.html

我们知道,在.Net 中有Elasticsearch.NetNEST等组件可以对 ElasticSearch 服务端进行各种操作。

但是但是但是,由于 ElasticSearch 提供的是各类 API 接口,并且查询参数(JSON)条件会有很深的嵌套,这就导致了Elasticsearch.NetNEST等组件在使用的时候也有很深的内嵌条件,包括各种链式操作等,如果不是老手使用难度非常大,为了降低使用难度,Quick.ElasticSearch.Furion组件由此诞生了。

为了更好更简单的在.Net Core 中使用 ElasticSearch,特此基于NEST封装了Quick.ElasticSearch.Furion组件。

  • Quick.ElasticSearch.Furion:依赖于.Net6+、Furion

Quick.ElasticSearch.Furion 包地址为:https://www.nuget.org/packages/Quick.ElasticSearch.Furion

关于 Quick.ElasticSearch.Furion 的详细使用说明,如下所示:

1、🍹 更新日志

  • 1.0.3

    • 调整(简化)了方法GetModelsAllGetModelsAllAsyncGetModelsGetModelsAsyncGetModelsFieldsGetModelsFieldsAsync的排序参数传入方式;
    • 调整了InsertModelsInsertModelsAsync方法的内部实现,判断是否有添加失败采用了Errors属性以及ItemsWithErrors错误对象集合;
    • 增加了InsertModelsBatch方法,分批添加数据,适用于大批量添加数据的情况;
    • 调整了GetGroupValuesGetGroupValuesAsyncGetGroupCountGetGroupCountAsyncGetGroupCountSmmaGetGroupCountSmmaAsyncGetGroupsCountGetGroupsCountAsyncGetGroupsDateGetGroupsDateAsyncGetGroupsDateSmmaGetGroupsDateSmmaAsyncGetGroupsDateSubGetGroupsDateSubAsyncGetStatiCountGetStatiCountAsyncGetStatiSumMultiGetStatiSumMultiAsync方法的内部实现;
    • 调整了AddLike扩展方式的实现方式为 Wildcard;
    • 增加了AddIn条件查询扩展方法,类似 SQL 的 IN 条件;
    • GetStatiSumMultiGetStatiSumMultiAsync方法进行了性能优化,减少了 Http 请求次数。
  • 1.0.2

    • 方法GetGroupsCountGetGroupsCountAsync增加了第三个参数,以便于用户自定义返回统计数量的 Key 名称,默认为:GroupCount;
    • 增加了获取ElasticClient客户端对象方法:GetClient;
    • 增加获取所有索引的方法GetIndexsGetIndexsAsync
    • 增加了根据主键 Id 修改一个或多个字段值的方法UpdateModelFieldsByIdUpdateModelFieldsByIdAsync
    • 增加了根据查询条件修改一个或多个字段值的方法UpdateModelFieldsByConUpdateModelFieldsByConAsync
    • 增加了根据 Id 字段获取一条数据的方法GetModelGetModelAsync
    • 调整了InsertModelsInsertModelsAsync方法的实现,由原来的Bulk(BulkAsync)调整为了IndexMany(IndexManyAsync)方式。
  • 1.0.1

    • 增加了扩展方法 CreateEsQueryModel 和 AddEsQueryModel;
    • 重写了查询条件的使用方式;
    • 将所有涉及到查询条件的方法都进行了调整;
    • 简化了GetStatiSumMultiGetStatiSumMultiAsync方法所需参数的传入方式;
    • 方法GetStatiSumMultiGetStatiSumMultiAsync增加了第三个参数,错误回调方法。
  • 1.0.0

    • 全新组件重磅发布;
    • 支持切换连接功能;
    • 支持检查创建删除索引;
    • 支持获取索引健康状态;
    • 支持添加数据;
    • 支持修改数据;
    • 支持删除数据;
    • 支持获取数据;
    • 支持分组统计查询;
    • 支持获取总条数、最大、最小、求和或平均值等。

2、🍟 Quick.ElasticSearch.Furion 使用说明

该组件是基于NESTFurion组件进行封装使用的,目的在于结合.Net Core 更快、更简单和更灵活的使用 ElasticSearch!!!

组件使用对比:

假设我们要实现如下数据格式的统计:

[
    {
        "Name": "2021-01",
        "Count": 100,
        "Group": [
            {
                "Name": "碎石",
                "Count": 3,
                "Sum": 1000,
                "Max": 100,
                "Min": 10,
                "Avg": 50
            }
        ]
    }
]

使用 Quick.ElasticSearch.Furion 组件的代码如下:

//获取分组统计数据(日期字段分组,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值)
//统计的时间间隔维度支持的表达式有(1y:1年、1q:1季度、1M:1个月、1w:1星期、1d:1天、1h:1小时、1m:1分钟、1s:1秒钟)
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupsDateSub = _quickElasticSearch.GetGroupsDateSub(m => m.CreateTime, m => m.UserName, m => m.UserAge, "1h", "yyyy-MM-dd HH:mm", queryCon);

//异步
var retGetGroupsDateSubAsync = await _quickElasticSearch.GetGroupsDateSubAsync(m => m.CreateTime, m => m.UserName, m => m.UserAge, "1h", "yyyy-MM-dd HH:mm", queryCon);

使用 NEST 组件的代码如下:

/// 
/// 获取分组统计数据(日期字段分组,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值)
/// 
/// 
/// 要分组的字段(日期字段),格式如:m=>m.CreateTime
/// 另一个要分组的字段,格式如:m=>m.TypeName
/// 要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price
/// 统计的日期间隔,默认为1M(支持的表达式有1y:1年、1q:1季度、1M:1个月、1w:1星期、1d:1天、1h:1小时、1m:1分钟、1s:1秒钟)
/// 统计的日期格式化方式,默认为yyyy-MM(注意大小写,完整的格式化格式为yyyy-MM-dd HH:mm:ss)
/// 动态查询条件
/// 返回元组对象,包含3个值,第一个为是否成功,第二个为失败的提示信息,第三个为>]]>的集合,格式如:[{"Name":"2021-01","Count":100,"Group":[{"Name":"碎石","Count":3,"Sum":1000,"Max":100,"Min":10,"Avg":50}]}]
public (bool IsSucc, string ErrMsg, List>? Data) GetGroupsDateSub(Expression> field, Expression> fieldGroup, Expression> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List>? esQueryList = null) where T : class, new()
{
    try
    {
        //查询条件
        Func, QueryContainer> query = q =>
        {
            QueryContainer ret = q;

            if (esQueryList != null && esQueryList.Count > 0)
            {
                //组装条件为&&或||关系
                for (int i = 0; i  0)
                    {
                        if (i == 0)
                        {
                            ret = esQueryList[i].QueryType == EsQueryType.And ? q.Bool(b => b.Must(esQueryList[i].QueryCon)) : q.Bool(b => b.Should(esQueryList[i].QueryCon));
                        }
                        else
                        {
                            ret = esQueryList[i].PrevConType == EsQueryType.And ?
                                ret && (esQueryList[i].QueryType == EsQueryType.And ? q.Bool(b => b.Must(esQueryList[i].QueryCon)) : q.Bool(b => b.Should(esQueryList[i].QueryCon))) ://添加&&并且关系
                                ret || (esQueryList[i].QueryType == EsQueryType.And ? q.Bool(b => b.Must(esQueryList[i].QueryCon)) : q.Bool(b => b.Should(esQueryList[i].QueryCon))); //添加||或关系
                        }
                    }
                }
            }

            return ret;
        };

        var ret = new List>();

        var response = _client.Search(s => s
            .Index(GetIndexName())
            .Query(query)
            .Aggregations(ag => ag
                .DateHistogram("StatiGroup", dh => dh
                    .Field(field)                       //需要聚合分组的字段名称, 类型需要为date, 格式没有要求
                    .CalendarInterval(dateInterval)     //时间间隔,此处设置为1个月(1y:1年、1q:1季度、1M:1个月、1w:1星期、1d:1天、1h:1小时、1m:1分钟、1s:1秒钟)
                    .TimeZone("+08:00")                 //设置时区, 这样就相当于东八区的时间
                    .Format(dateFormat)                 //返回值格式化,HH大写,不然不能区分上午、下午
                    .MinimumDocumentCount(0)            //为空的话则填充0
                    .Order(HistogramOrder.KeyAscending) //根据日期字段升序排列

                    .Aggregations(ag => ag
                        .Terms("StatiGroup-1", t => t
                            .Field(fieldGroup)
                            .Size(_allConfig.MaxQueryCount)
                            .Order(o => o
                                .KeyAscending()  //按照分组字段升序排序
                                .CountAscending()//按照统计数量升序排序
                            )

                            //统计fieldStati字段的总和、最大值、最小值和平均值
                            .Aggregations(ags => ags
                                .Sum("StatiSum", m => m.Field(fieldGroupStati))         //求和
                                .Max("StatiMax", m => m.Field(fieldGroupStati))         //最大值
                                .Min("StatiMin", m => m.Field(fieldGroupStati))         //最小值
                                .Average("StatiAvg", m => m.Field(fieldGroupStati))     //平均值
                            )
                        )
                    )
                )
            )
            .TrackTotalHits(true)//TrackTotalHits必须设置为true,否则返回total总条数超过10000条时总是返回10000
        );

        if (response.IsValid)
        {
            //获取分组标识
            var stati = response.Aggregations["StatiGroup"];
            //获取分组后的集合
            var statiItems = ((BucketAggregate)stati).Items;

            foreach (var bucketMain in statiItems)
            {
                var item = (DateHistogramBucket)bucketMain;
                var retGroup = new List>();

                foreach (var bucket in ((Nest.BucketAggregate)(item.Values.ToList()[0])).Items)
                {
                    var obj = (KeyedBucket)bucket;

                    retGroup.Add(new Dictionary {
                        { "Name",obj.Key.ToString()!},
                        { "Count",obj.DocCount??0},
                        { "Sum",IsNotNull(obj.AverageBucket("StatiSum").Value)? ToDouble2Dec(obj.AverageBucket("StatiSum").Value!):0},
                        { "Max",IsNotNull(obj.AverageBucket("StatiMax").Value)? ToDouble2Dec(obj.AverageBucket("StatiMax").Value!):0},
                        { "Min",IsNotNull(obj.AverageBucket("StatiMin").Value)? ToDouble2Dec(obj.AverageBucket("StatiMin").Value!):0},
                        { "Avg",IsNotNull(obj.AverageBucket("StatiAvg").Value)? ToDouble2Dec(obj.AverageBucket("StatiAvg").Value!):0},
                    });
                }

                ret.Add(new Dictionary
                {
                    { "Name",item.KeyAsString},
                    { "Count",item.DocCount??0},
                    { "Group",retGroup}
                });
            }
        }

        return (response.IsValid, !response.IsValid ? response.DebugInformation : string.Empty, ret);
    }
    catch (Exception ex)
    {
        return (false, ex.Message, null);
    }
}

由此可见,NEST 使用的复杂程度,更不用说 ElasticSearch.Net 了。

功能说明:

  • 根据配置文件读取 ElasticSearch 连接的各个配置(如:ElasticSearch 服务地址、账号和密码等);
  • 支持配置多个 ElasticSearch 的连接配置;
  • 支持动态切换 ElasticSearch 的连接配置;
  • 支持检查创建删除索引;
  • 支持获取索引健康状态;
  • 支持添加数据(单条、多条);
  • 支持修改数据(单条、多条);
  • 支持删除数据(根据 Id 删除、根据条件删除);
  • 支持获取数据(获取所有数据、获取所有满足条件的数据、获取所有满足条件并返回指定字段的数据、根据 Id 获取一条数据、获取分页的数据、获取分页并返回指定字段的数据);
  • 支持分组统计查询(统计单字段并返回该字段所有统计值、统计单字段并返回该字段所有统计值及对应的数量、统计单段并返回另一个字段的总和最大值最小值和平均值、统计多个字段并返回多个字段对应的值以及对应分组的数据数量、按月统计并返回每个月及其数量、获取分组统计数据【日期字段分组,支持按年、季度、月份、星期、天、小时、分、秒等维度进行统计】、获取分组统计数据【日期字段分组,按月统计,并返回另一个字段的总和、最大值、最小值和平均值】、获取分组统计数据【日期字段分组,并返回另一个字段的总和、最大值、最小值和平均值】、获取分组统计数据【日期字段分组,按某年 1~12 月统计每个月的某个字段每个月的总和以及这一年的总和】、获取分组统计数据【日期字段分组,按月统计,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值】、获取分组统计数据【日期字段分组,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值】);
  • 支持获取总条数、最大、最小、求和或平均值等(获取符合条件的数据总条数、获取某字段的最大值最小值求和平均值和总数等、获取某些字段相加的多个总和)。

3、🍖 安装

安装命令如下所示:

Install-Package Quick.ElasticSearch.Furion

该组件的命名空间为:Quick.ElasticSearch

ElasticSearch之Quick.ElasticSearch.Furion组件的使用插图

ElasticSearch之Quick.ElasticSearch.Furion组件的使用插图1


4、🧀 配置

4.1、🥞 配置appsettings.json

appsettings.json配置文件中创建节点QuickElasticSearch>MaxQueryCountQuickElasticSearchConfigs,MaxQueryCount 为 ElasticSearch 索引查询的最大条数(ElasticSearch 内部默认为 10000),QuickElasticSearchConfigs 为数组类型(即可配置多个 ElasticSearch 服务地址),具体配置如下所示:

{
    "QuickElasticSearch": {
        "MaxQueryCount": 2000000000,
        "QuickElasticSearchConfigs": [
            {
                "Default": true,
                "ConnId": 1,
                "DefaultIndex": "",
                "UserName": "elastic",
                "Password": "123456",
                "Uri": ["http://192.168.3.200:9200/"]
            }
        ]
    }
}

配置说明:

属性名称 属性说明 是否必填 备注
MaxQueryCount 全局设置 ElasticSearch 索引查询的最大条数,ElasticSearch 默认为 10000 注意:此处我们最好设置为 2000000000,原因是 ElasticSearch 内部默认一次性最多返回 10000 条数据
Default 是否为默认连接 默认为 false
ConnId 连接 Id(请确保该 Id 的唯一性) 如果要动态切换连接配置,请确保该 Id 有值并且唯一
DefaultIndex 默认索引
UserName 连接账户
Password 连接密码
Uri 连接地址集合,数据类型为 List

4.2、🍞 实体特性

我们为实体提供了QuickElasticSearchConfig特性,起作用是设置该实体的索引名称主键字段,如下所示就是我们定义的一个实体对象:

using Nest;

namespace Quick.ElasticSearch.TestFurion
{
    [QuickElasticSearchConfig(indexName: "test_index", primaryKey: "Id")]
    public class TestElasticSearchModel
    {
        public long Id { get; set; }

        [Keyword]
        public string UserType { get; set; }

        public int UserId { get; set; }

        [Keyword]
        public string UserName { get; set; }

        public int UserAge { get; set; }

        public float Money { get; set; }

        public float MoneyOth { get; set; }

        public DateTime CreateTime { get; set; }
    }
}

说明:

  • indexName:索引名称;
  • primaryKey:主键名称。

4.3、🥐 配置 Program.cs

由于我们使用的是Furion,因此,我们可在程序启动文件中配置如下代码(具体可参考Furion 入门指南),目的是注册ElasticSearch 服务

[STAThread]
static void Main()
{
    ApplicationConfiguration.Initialize();

    //初始化Furion
    Serve.Run(GenericRunOptions.DefaultSilence);
}


public void ConfigureServices(IServiceCollection services)
{
    //注册FrmMain窗体类
    services.AddScoped();

    //注入IQuickElasticSearch的方式
    //通过AddElasticSearch添加依赖注入
    services.AddElasticSearch();

    ////使用构造函数获取实例的方式:
    ////通过AddElasticSearch添加依赖注入,并注册TestConsumerClassForDI类
    //services.AddElasticSearch()

    //DI容器生成serviceProvider
    var serviceProvider = services.BuildServiceProvider();

    //通过serviceProvider获取MainForm的注册实例
    var frmMain = serviceProvider.GetRequiredService();
    //var frmMain = (FrmMain)serviceProvider.GetService(typeof(FrmMain));

    Application.Run(frmMain);
}



说明:上述的关键点就在于调用.AddElasticSearch()或者.AddElasticSearch()方法对服务进行注册。

4.4、🍝 获取依赖注入对象

定义IQuickElasticSearch对象(依赖注入方式):

public partial class FrmMain : Form
{
    //定义IQuickElasticSearch对象
    private readonly IQuickElasticSearch _quickElasticSearch;

    public FrmMain(IQuickElasticSearch quickElasticSearch)
    {
        InitializeComponent();

        //设置IQuickElasticSearch对象
        _quickElasticSearch = quickElasticSearch;
    }
}

5、🥪 具体使用

5.1、📮 获取 ElasticSearch 客户端

使用示例:

_quickElasticSearch.GetClient();

5.2、🌮 切换连接

使用示例:

_quickElasticSearch.ChangeConn(2);

5.3、🌯 获取检查创建删除索引

使用示例(获取所有索引):

//同步
var retGetIndexs = _quickElasticSearch.GetIndexs();

//异步
var retGetIndexsAsync = await _quickElasticSearch.GetIndexsAsync();

使用示例(检查索引是否存在):

//同步
var retIndexIsExist = _quickElasticSearch.IndexIsExist();

//异步
var retIndexIsExistAsync = await _quickElasticSearch.IndexIsExistAsync();

使用示例(创建索引):

//同步
var retCreateIndex = _quickElasticSearch.CreateIndex();

//异步
var retCreateIndexAsync = await _quickElasticSearch.CreateIndexAsync();

使用示例(删除索引):

//同步
var retDeleteIndex = _quickElasticSearch.DeleteIndex();

//异步
var retDeleteIndexAsync = await _quickElasticSearch.DeleteIndexAsync();

5.4、🥙 获取索引健康状态

使用示例(获取索引健康状态):

//同步
var retGetHealthStatus = _quickElasticSearch.GetHealthStatus();

//异步
var retGetHealthStatusAsyncc = await _quickElasticSearch.GetHealthStatusAsync();

5.5、🧆 添加数据

使用示例(添加数据-单条):

var rand = new Random(Guid.NewGuid().GetHashCode());
var testData = new TestElasticSearchModel
{
    Id = YitIdHelper.NextId(),
    UserId = rand.Next(1, 9999),
    UserName = "Quber",
    UserAge = rand.Next(20, 80),
    Money = (float)1.429,
    MoneyOth = (float)2.556,
    CreateTime = DateTime.Now
};
var testDataAsync = new TestElasticSearchModel
{
    Id = YitIdHelper.NextId(),
    UserId = rand.Next(1, 9999),
    UserName = "Jack",
    UserAge = rand.Next(20, 80),
    Money = (float)1.429,
    MoneyOth = (float)2.556,
    CreateTime = DateTime.Now
};

//同步
var retInsertModel = _quickElasticSearch.InsertModel(testData);

//异步
var retInsertModelAsync = await _quickElasticSearch.InsertModelAsync(testDataAsync);

使用示例(添加数据-多条):

var testDatas = new List
{
    new TestElasticSearchModel(),
    new TestElasticSearchModel()
};

//同步
var retInsertModels = _quickElasticSearch.InsertModels(testDatas, (errList, errMsg, allList) =>
{
    var thisErrList = errList;
    var thisErrMsg = errMsg;
});

//异步
var retInsertModelsAsync = await _quickElasticSearch.InsertModelsAsync(testDatas, async (errList, errMsg, allList) =>
{
    var thisErrList = errList;
    var thisErrMsg = errMsg;

    await Task.CompletedTask;
});

使用示例(添加数据-多条,分批次):

var testDatas = new List
{
    new TestElasticSearchModel(),
    new TestElasticSearchModel()
};

var retInsertModelsBatch = _quickElasticSearch.InsertModelsBatch(testDatas, (errList, errMsg, allList) =>
{
    var thisErrList = errList;
    var thisErrMsg = errMsg;
},

//每批次添加的数据条数
1000,

//集群繁忙,报429错误码的时候,等待多久进行重试
"5s",

//重试次数
2);

5.6、🥗 修改数据

使用示例(修改数据-根据主键 Id 修改一个或多个字段的值):

//类似SQL:UPDATE A SET col1=123,col2=456 WHERE Id=1

//同步
var retUpdateModelFieldById = _quickElasticSearch.UpdateModelFieldsById(342235158519882, new { UserAge = 32, Money = 66.66 });

//异步
var retUpdateModelFieldByIdAsync = await _quickElasticSearch.UpdateModelFieldsByIdAsync(342235158519882, new { UserAge = 32, Money = 66.66 });

使用示例(修改数据-根据查询条件修改一个或多个字段的值):

//类似SQL:UPDATE A SET col1=123,col2=456 WHERE (Id=1 OR Id=2)
//定义查询条件:(Id = 342235158519882 OR Id = 342235158519883)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,
        EsQueryType.Or,
        (queryCon) =>
        {
            //查询条件:(Id = 342235158519882 OR Id = 342235158519883)
            queryCon
                .AddEqu(m => m.Id, 342235158519882)
                .AddEqu(m => m.Id, 342235158519883);
        });

//异步
var retUpdateModelFieldsByCon = _quickElasticSearch.UpdateModelFieldsByCon(queryCon, new { UserAge = 13, Money = 996.33 });

//同步
var retUpdateModelFieldsByConAsync = await _quickElasticSearch.UpdateModelFieldsByConAsync(queryCon, new { UserAge = 14, Money = 997.44 });

使用示例(修改数据-单条):

var rand = new Random(Guid.NewGuid().GetHashCode());
var testData = new TestElasticSearchModel
{
    Id = 1,
    UserId = rand.Next(1, 9999),
    UserName = "Quber1",
    UserAge = rand.Next(20, 80),
    Money = (float)2.429,
    MoneyOth = (float)3.556,
    CreateTime = DateTime.Now
};
var testDataAsync = new TestElasticSearchModel
{
    Id = 3,
    UserId = rand.Next(1, 9999),
    UserName = "Jack1",
    UserAge = rand.Next(20, 80),
    Money = (float)2.429,
    MoneyOth = (float)3.556,
    CreateTime = DateTime.Now
};

//同步
var retUpdateModel = _quickElasticSearch.UpdateModel(testData);

//异步
var retUpdateModelAsync = await _quickElasticSearch.UpdateModelAsync(testDataAsync);

使用示例(修改数据-多条):

var rand = new Random(Guid.NewGuid().GetHashCode());
var testDatas = new List
{
    new TestElasticSearchModel
    {
        Id = 1,
        UserId = rand.Next(1, 9999),
        UserName = "Quber1",
        UserAge = rand.Next(20, 80),
        Money = (float)2.429,
        MoneyOth = (float)3.556,
        CreateTime = DateTime.Now
    },
    new TestElasticSearchModel
    {
        Id = 3,
        UserId = rand.Next(1, 9999),
        UserName = "Jack1",
        UserAge = rand.Next(20, 80),
        Money = (float)2.429,
        MoneyOth = (float)3.556,
        CreateTime = DateTime.Now
    },
    new TestElasticSearchModel
    {
        Id = 4,
        UserId = rand.Next(1, 9999),
        UserName = "Jack1",
        UserAge = rand.Next(20, 80),
        Money = (float)2.429,
        MoneyOth = (float)3.556,
        CreateTime = DateTime.Now
    }
};

//同步
var retUpdateModels = _quickElasticSearch.UpdateModels(testDatas, (errList, errMsg, allList) =>
{
    var thisErrList = errList;
    var thisErrMsg = errMsg;
});

//异步
var retUpdateModelsAsync = await _quickElasticSearch.UpdateModelsAsync(testDatas, async (errList, errMsg, allList) =>
{
    var thisErrList = errList;
    var thisErrMsg = errMsg;

    await Task.CompletedTask;
});

5.7、🥘 删除数据

使用示例(删除数据-根据 Id):

//同步
var retDeleteModel = _quickElasticSearch.DeleteModel(340504986927178);

//异步
var retDeleteModelAsync = await _quickElasticSearch.DeleteModelAsync(340504986927176);

使用示例(删除数据-根据条件):

//定义查询条件:(Id >= 340506710462542 AND UserAge (
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 340506710462542 AND UserAge  m.Id, 340506710462542)
                .AddLte(m => m.UserAge, 60);
        })
    //添加另一个组合条件
    .AddEsQueryModel(
        EsQueryType.Or,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.Or,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id = 340506710462539 OR Id = 340506710462538)
            queryCon
                .AddEqu(m => m.Id, 340506710462539)
                .AddEqu(m => m.Id, 340506710462538);
        });

//同步
var retDeleteModelBy = _quickElasticSearch.DeleteModelBy(queryCon);

//异步
var retDeleteModelByAsync = await _quickElasticSearch.DeleteModelByAsync(queryCon);

5.8、🍲 获取数据

使用示例(获取所有数据):

//排序条件:ORDER BY Id DESC

//同步
var retGetModelsAll = _quickElasticSearch.GetModelsAll(m => m.Id, true);

//异步
var retGetModelsAllAsync = await _quickElasticSearch.GetModelsAllAsync(m => m.CreateTime, false);


# 获取所有数据
# 类似SQL:SELECT TOP 2000000000 * FROM A ORDER BY CreateTime DESC
POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "from":0,
    "query":{
        "match_all":{

        }
    },
    "size":2000000000,
    "sort":[
        {
            "CreateTime":{
                "order":"asc"
            }
        }
    ]
}


{
    "took": 8,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": [
            {
                "_index": "test_index",
                "_type": "_doc",
                "_id": "343362545766476",
                "_score": null,
                "_source": {
                    "Id": 343362545766476,
                    "UserType": "高级用户",
                    "UserId": 5133,
                    "UserName": "Quber9",
                    "UserAge": 63,
                    "Money": 9.429,
                    "MoneyOth": 10.556,
                    "CreateTime": "2022-10-17T16:05:48.5451264+08:00"
                },
                "sort": [1665993948545]
            },
            {
                "_index": "test_index",
                "_type": "_doc",
                "_id": "343362545766473",
                "_score": null,
                "_source": {
                    "Id": 343362545766473,
                    "UserType": "系统用户",
                    "UserId": 7360,
                    "UserName": "Quber6",
                    "UserAge": 57,
                    "Money": 6.429,
                    "MoneyOth": 7.5559998,
                    "CreateTime": "2022-10-17T16:05:48.5451259+08:00"
                },
                "sort": [1665993948545]
            }
            ……
        ]
    }
}



使用示例(获取匹配条件的所有数据):

//排序条件:ORDER BY Id DESC
//定义查询条件:(Id >= 340506710462535 AND UserAge (
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 340506710462535 AND UserAge  m.Id, 340506710462535)
                .AddLte(m => m.UserAge, 70);
        });

//同步
var retGetModels = _quickElasticSearch.GetModels(m => m.Id, true, queryCon);

//异步
var retGetModelsAsync = await _quickElasticSearch.GetModelsAsync(m => m.Id, true, queryCon);


# 获取匹配条件的所有数据
# 类似SQL:SELECT TOP 2000000000 * FROM A WHERE Id >= 340506710462535 AND UserAge 


{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 65,
            "relation": "eq"
        },
        "max_score": null,
        "hits": [
            {
                "_index": "test_index",
                "_type": "_doc",
                "_id": "343362866188366",
                "_score": null,
                "_source": {
                    "Id": 343362866188366,
                    "UserType": "会员用户",
                    "UserId": 2106,
                    "UserName": "Quber10",
                    "UserAge": 30,
                    "Money": 10.429,
                    "MoneyOth": 11.556,
                    "CreateTime": "2022-10-17T16:07:06.7733297+08:00"
                },
                "sort": [343362866188366]
            },
            {
                "_index": "test_index",
                "_type": "_doc",
                "_id": "343362866188365",
                "_score": null,
                "_source": {
                    "Id": 343362866188365,
                    "UserType": "系统用户",
                    "UserId": 829,
                    "UserName": "Quber9",
                    "UserAge": 39,
                    "Money": 9.429,
                    "MoneyOth": 10.556,
                    "CreateTime": "2022-10-17T16:07:06.7733294+08:00"
                },
                "sort": [343362866188365]
            },
            ……
        ]
    }
}



使用示例(获取匹配条件的所有数据(返回指定字段的值)):

//排序条件:ORDER BY Id DESC
//定义查询条件:(Id >= 340506710462535 AND UserAge (
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 340506710462535 AND UserAge  m.Id, 340506710462535)
                .AddLte(m => m.UserAge, 70);
        });

//同步
var retGetModelsFields = _quickElasticSearch.GetModelsFields(new List { "UserId", "UserName", "UserAge" }, m => m.Id, true, queryCon);

//异步
var retGetModelsFieldsAsync = await _quickElasticSearch.GetModelsFieldsAsync(new List { "UserId", "UserName", "UserAge" }, m => m.Id, true, queryCon);


# 获取匹配条件的所有数据(返回指定字段的值)
# 类似SQL:SELECT TOP 2000000000 'UserId','UserName','UserAge' FROM A WHERE Id >= 340506710462535 AND UserAge 


{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 65,
            "relation": "eq"
        },
        "max_score": null,
        "hits": [
            {
                "_index": "test_index",
                "_type": "_doc",
                "_id": "343362866188366",
                "_score": null,
                "_source": {
                    "UserName": "Quber10",
                    "UserId": 2106,
                    "UserAge": 30
                },
                "sort": [343362866188366]
            },
            {
                "_index": "test_index",
                "_type": "_doc",
                "_id": "343362866188365",
                "_score": null,
                "_source": {
                    "UserName": "Quber9",
                    "UserId": 829,
                    "UserAge": 39
                },
                "sort": [343362866188365]
            }
            ……
        ]
    }
}



使用示例(获取一条数据-根据主键 Id 查询):

//同步
var retGetModel = _quickElasticSearch.GetModel(342235158519882);

//异步
var retGetModelAsync = await _quickElasticSearch.GetModelAsync(342235158519883);


# 获取一条数据(根据主键Id查询)
# 类似SQL:SELECT * FROM A WHERE Id = 343362866188364
GET /test_index/_doc/343362866188364


{
    "_index": "test_index",
    "_type": "_doc",
    "_id": "343362866188364",
    "_version": 1,
    "_seq_no": 14,
    "_primary_term": 1,
    "found": true,
    "_source": {
        "Id": 343362866188364,
        "UserType": "高级用户",
        "UserId": 7438,
        "UserName": "Quber8",
        "UserAge": 53,
        "Money": 8.429,
        "MoneyOth": 9.556,
        "CreateTime": "2022-10-17T16:07:06.7733293+08:00"
    }
}



使用示例(获取一条数据-根据某字段查询):

//同步
var retGetModel = _quickElasticSearch.GetModel(m => m.UserId, 340506710462542);

//异步
var retGetModelAsync = await _quickElasticSearch.GetModelAsync(m => m.UserId, 340506710462537);


# 获取一条数据(根据某字段查询)
# 类似SQL:SELECT * FROM A WHERE UserId = 7438
POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "query":{
        "term":{
            "UserId":{
                "value":7438
            }
        }
    }
}


{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 1.0,
        "hits": [
            {
                "_index": "test_index",
                "_type": "_doc",
                "_id": "343362866188364",
                "_score": 1.0,
                "_source": {
                    "Id": 343362866188364,
                    "UserType": "高级用户",
                    "UserId": 7438,
                    "UserName": "Quber8",
                    "UserAge": 53,
                    "Money": 8.429,
                    "MoneyOth": 9.556,
                    "CreateTime": "2022-10-17T16:07:06.7733293+08:00"
                }
            }
        ]
    }
}



使用示例(获取分页数据):

//分页条件
var pagerCon = new EsPagerConModel
{
    PageIndex = 1,
    PageSize = 15,
    OrderField = "Id",
    OrderType = "desc"
};
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetPager = _quickElasticSearch.GetPager(pagerCon, queryCon);

//异步
var retGetPagerAsync = await _quickElasticSearch.GetPagerAsync(pagerCon, queryCon);


# 获取分页数据
# 类似SQL:SELECT * FROM A WHERE Id >= 1 LIMIT 0,15 ORDER BY Id DESC
POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "from":0,
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":15,
    "sort":[
        {
            "Id":{
                "order":"desc"
            }
        }
    ]
}


{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": [
            {
                "_index": "test_index",
                "_type": "_doc",
                "_id": "343362866188366",
                "_score": null,
                "_source": {
                    "Id": 343362866188366,
                    "UserType": "会员用户",
                    "UserId": 2106,
                    "UserName": "Quber10",
                    "UserAge": 30,
                    "Money": 10.429,
                    "MoneyOth": 11.556,
                    "CreateTime": "2022-10-17T16:07:06.7733297+08:00"
                },
                "sort": [343362866188366]
            },
            {
                "_index": "test_index",
                "_type": "_doc",
                "_id": "343362866188365",
                "_score": null,
                "_source": {
                    "Id": 343362866188365,
                    "UserType": "系统用户",
                    "UserId": 829,
                    "UserName": "Quber9",
                    "UserAge": 39,
                    "Money": 9.429,
                    "MoneyOth": 10.556,
                    "CreateTime": "2022-10-17T16:07:06.7733294+08:00"
                },
                "sort": [343362866188365]
            }
            ……
        ]
    }
}



使用示例(获取分页数据-返回指定字段的值):

//分页条件
var pagerCon = new EsPagerConModel
{
    PageIndex = 1,
    PageSize = 15,
    OrderField = "Id",
    OrderType = "desc"
};
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetPagerFields = _quickElasticSearch.GetPagerFields(pagerCon, new List { "UserId", "UserName", "UserAge" }, queryCon);

//异步
var retGetPagerFieldsAsync = await _quickElasticSearch.GetPagerFieldsAsync(pagerCon, new List { "UserId", "UserName", "UserAge" }, queryCon);


# 获取分页数据(返回指定字段的值)
# 类似SQL:SELECT 'UserId','UserName','UserAge' FROM A WHERE Id >= 1 LIMIT 0,15 ORDER BY Id DESC
POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "from":0,
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":15,
    "sort":[
        {
            "Id":{
                "order":"desc"
            }
        }
    ],
    "_source":{
        "includes":[
            "UserId",
            "UserName",
            "UserAge"
        ]
    }
}


{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": [
            {
                "_index": "test_index",
                "_type": "_doc",
                "_id": "343362866188366",
                "_score": null,
                "_source": {
                    "UserName": "Quber10",
                    "UserId": 2106,
                    "UserAge": 30
                },
                "sort": [343362866188366]
            },
            {
                "_index": "test_index",
                "_type": "_doc",
                "_id": "343362866188365",
                "_score": null,
                "_source": {
                    "UserName": "Quber9",
                    "UserId": 829,
                    "UserAge": 39
                },
                "sort": [343362866188365]
            }
            ……
        ]
    }
}


5.9、🥣 分组统计查询

使用示例(单个字段分组,并返回该字段的所有值集合):

//类似SQL:SELECT col1 FROM A GROUP BY col1
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupValues = _quickElasticSearch.GetGroupValues(m => m.UserName, queryCon);

//异步
var retGetGroupValuesAsync = await _quickElasticSearch.GetGroupValuesAsync(m => m.UserName, queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": ["Jack1", "Jack2", "Jack3"]
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiGroup":{
            "terms":{
                "field":"UserName",
                "order":[
                    {
                        "_key":"asc"
                    }
                ],
                "size":2000000000
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "sterms#StatiGroup": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": "Jack1",
                    "doc_count": 2
                },
                {
                    "key": "Jack10",
                    "doc_count": 1
                },
                {
                    "key": "Jack2",
                    "doc_count": 2
                },
                {
                    "key": "Jack3",
                    "doc_count": 2
                },
                {
                    "key": "Jack4",
                    "doc_count": 2
                },
                {
                    "key": "Jack5",
                    "doc_count": 2
                },
                {
                    "key": "Jack6",
                    "doc_count": 1
                },
                {
                    "key": "Jack7",
                    "doc_count": 1
                },
                {
                    "key": "Jack8",
                    "doc_count": 1
                },
                {
                    "key": "Jack9",
                    "doc_count": 1
                },
                {
                    "key": "Quber1",
                    "doc_count": 7
                },
                {
                    "key": "Quber10",
                    "doc_count": 3
                },
                {
                    "key": "Quber11",
                    "doc_count": 1
                },
                {
                    "key": "Quber12",
                    "doc_count": 1
                },
                {
                    "key": "Quber2",
                    "doc_count": 7
                },
                {
                    "key": "Quber3",
                    "doc_count": 7
                },
                {
                    "key": "Quber4",
                    "doc_count": 7
                },
                {
                    "key": "Quber5",
                    "doc_count": 7
                },
                {
                    "key": "Quber6",
                    "doc_count": 6
                },
                {
                    "key": "Quber7",
                    "doc_count": 5
                },
                {
                    "key": "Quber8",
                    "doc_count": 5
                },
                {
                    "key": "Quber9",
                    "doc_count": 4
                }
            ]
        }
    }
}



使用示例(单个字段分组,并返回该字段的所有值和数量集合):

//类似SQL:SELECT col1,COUNT(1) FROM A GROUP BY col1
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupCount = _quickElasticSearch.GetGroupCount(m => m.UserName, queryCon);

//异步
var retGetGroupCountAsync = await _quickElasticSearch.GetGroupCountAsync(m => m.UserName, queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": [
        {
            "Name": "Jack1",
            "Count": 2
        },
        {
            "Name": "Jack2",
            "Count": 2
        },
        {
            "Name": "Jack3",
            "Count": 2
        }
    ]
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiGroup":{
            "terms":{
                "field":"UserName",
                "order":[
                    {
                        "_key":"asc"
                    },
                    {
                        "_count":"asc"
                    }
                ],
                "size":2000000000
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "sterms#StatiGroup": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": "Jack1",
                    "doc_count": 2
                },
                {
                    "key": "Jack10",
                    "doc_count": 1
                },
                {
                    "key": "Jack2",
                    "doc_count": 2
                },
                {
                    "key": "Jack3",
                    "doc_count": 2
                },
                {
                    "key": "Jack4",
                    "doc_count": 2
                },
                {
                    "key": "Jack5",
                    "doc_count": 2
                },
                {
                    "key": "Jack6",
                    "doc_count": 1
                },
                {
                    "key": "Jack7",
                    "doc_count": 1
                },
                {
                    "key": "Jack8",
                    "doc_count": 1
                },
                {
                    "key": "Jack9",
                    "doc_count": 1
                },
                {
                    "key": "Quber1",
                    "doc_count": 7
                },
                {
                    "key": "Quber10",
                    "doc_count": 3
                },
                {
                    "key": "Quber11",
                    "doc_count": 1
                },
                {
                    "key": "Quber12",
                    "doc_count": 1
                },
                {
                    "key": "Quber2",
                    "doc_count": 7
                },
                {
                    "key": "Quber3",
                    "doc_count": 7
                },
                {
                    "key": "Quber4",
                    "doc_count": 7
                },
                {
                    "key": "Quber5",
                    "doc_count": 7
                },
                {
                    "key": "Quber6",
                    "doc_count": 6
                },
                {
                    "key": "Quber7",
                    "doc_count": 5
                },
                {
                    "key": "Quber8",
                    "doc_count": 5
                },
                {
                    "key": "Quber9",
                    "doc_count": 4
                }
            ]
        }
    }
}



使用示例(单个字段分组,并返回另一个字段的总和、最大值、最小值和平均值):

//类似SQL:SELECT col1,COUNT(1),SUM(col2),MAX(col2),MIN(col2),AVG(col2) FROM A GROUP BY col1
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupCountSmma = _quickElasticSearch.GetGroupCountSmma(m => m.UserName, m => m.UserAge, queryCon);

//异步
var retGetGroupCountSmmaAsync = await _quickElasticSearch.GetGroupCountSmmaAsync(m => m.UserName, m => m.UserAge, queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": [
        {
            "Name": "Jack1",
            "Count": 2,
            "Sum": 54,
            "Max": 31,
            "Min": 23,
            "Avg": 27
        },
        {
            "Name": "Jack2",
            "Count": 2,
            "Sum": 98,
            "Max": 77,
            "Min": 21,
            "Avg": 49
        },
        {
            "Name": "Jack3",
            "Count": 2,
            "Sum": 126,
            "Max": 67,
            "Min": 59,
            "Avg": 63
        }
    ]
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiGroup":{
            "aggs":{
                "StatiSum":{
                    "sum":{
                        "field":"UserAge"
                    }
                },
                "StatiMax":{
                    "max":{
                        "field":"UserAge"
                    }
                },
                "StatiMin":{
                    "min":{
                        "field":"UserAge"
                    }
                },
                "StatiAvg":{
                    "avg":{
                        "field":"UserAge"
                    }
                }
            },
            "terms":{
                "field":"UserName",
                "order":[
                    {
                        "_key":"asc"
                    },
                    {
                        "_count":"asc"
                    }
                ],
                "size":2000000000
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "sterms#StatiGroup": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": "Jack1",
                    "doc_count": 2,
                    "avg#StatiAvg": {
                        "value": 34.0
                    },
                    "max#StatiMax": {
                        "value": 39.0
                    },
                    "min#StatiMin": {
                        "value": 29.0
                    },
                    "sum#StatiSum": {
                        "value": 68.0
                    }
                },
                {
                    "key": "Jack10",
                    "doc_count": 1,
                    "avg#StatiAvg": {
                        "value": 60.0
                    },
                    "max#StatiMax": {
                        "value": 60.0
                    },
                    "min#StatiMin": {
                        "value": 60.0
                    },
                    "sum#StatiSum": {
                        "value": 60.0
                    }
                },
                {
                    "key": "Jack2",
                    "doc_count": 2,
                    "avg#StatiAvg": {
                        "value": 40.0
                    },
                    "max#StatiMax": {
                        "value": 48.0
                    },
                    "min#StatiMin": {
                        "value": 32.0
                    },
                    "sum#StatiSum": {
                        "value": 80.0
                    }
                },
                {
                    "key": "Jack3",
                    "doc_count": 2,
                    "avg#StatiAvg": {
                        "value": 39.5
                    },
                    "max#StatiMax": {
                        "value": 53.0
                    },
                    "min#StatiMin": {
                        "value": 26.0
                    },
                    "sum#StatiSum": {
                        "value": 79.0
                    }
                },
                {
                    "key": "Jack4",
                    "doc_count": 2,
                    "avg#StatiAvg": {
                        "value": 48.0
                    },
                    "max#StatiMax": {
                        "value": 65.0
                    },
                    "min#StatiMin": {
                        "value": 31.0
                    },
                    "sum#StatiSum": {
                        "value": 96.0
                    }
                },
                {
                    "key": "Jack5",
                    "doc_count": 2,
                    "avg#StatiAvg": {
                        "value": 54.0
                    },
                    "max#StatiMax": {
                        "value": 78.0
                    },
                    "min#StatiMin": {
                        "value": 30.0
                    },
                    "sum#StatiSum": {
                        "value": 108.0
                    }
                },
                {
                    "key": "Jack6",
                    "doc_count": 1,
                    "avg#StatiAvg": {
                        "value": 57.0
                    },
                    "max#StatiMax": {
                        "value": 57.0
                    },
                    "min#StatiMin": {
                        "value": 57.0
                    },
                    "sum#StatiSum": {
                        "value": 57.0
                    }
                },
                {
                    "key": "Jack7",
                    "doc_count": 1,
                    "avg#StatiAvg": {
                        "value": 40.0
                    },
                    "max#StatiMax": {
                        "value": 40.0
                    },
                    "min#StatiMin": {
                        "value": 40.0
                    },
                    "sum#StatiSum": {
                        "value": 40.0
                    }
                },
                {
                    "key": "Jack8",
                    "doc_count": 1,
                    "avg#StatiAvg": {
                        "value": 29.0
                    },
                    "max#StatiMax": {
                        "value": 29.0
                    },
                    "min#StatiMin": {
                        "value": 29.0
                    },
                    "sum#StatiSum": {
                        "value": 29.0
                    }
                },
                {
                    "key": "Jack9",
                    "doc_count": 1,
                    "avg#StatiAvg": {
                        "value": 72.0
                    },
                    "max#StatiMax": {
                        "value": 72.0
                    },
                    "min#StatiMin": {
                        "value": 72.0
                    },
                    "sum#StatiSum": {
                        "value": 72.0
                    }
                },
                {
                    "key": "Quber1",
                    "doc_count": 7,
                    "avg#StatiAvg": {
                        "value": 48.857142857142854
                    },
                    "max#StatiMax": {
                        "value": 79.0
                    },
                    "min#StatiMin": {
                        "value": 21.0
                    },
                    "sum#StatiSum": {
                        "value": 342.0
                    }
                },
                {
                    "key": "Quber10",
                    "doc_count": 3,
                    "avg#StatiAvg": {
                        "value": 31.0
                    },
                    "max#StatiMax": {
                        "value": 43.0
                    },
                    "min#StatiMin": {
                        "value": 20.0
                    },
                    "sum#StatiSum": {
                        "value": 93.0
                    }
                },
                {
                    "key": "Quber11",
                    "doc_count": 1,
                    "avg#StatiAvg": {
                        "value": 29.0
                    },
                    "max#StatiMax": {
                        "value": 29.0
                    },
                    "min#StatiMin": {
                        "value": 29.0
                    },
                    "sum#StatiSum": {
                        "value": 29.0
                    }
                },
                {
                    "key": "Quber12",
                    "doc_count": 1,
                    "avg#StatiAvg": {
                        "value": 74.0
                    },
                    "max#StatiMax": {
                        "value": 74.0
                    },
                    "min#StatiMin": {
                        "value": 74.0
                    },
                    "sum#StatiSum": {
                        "value": 74.0
                    }
                },
                {
                    "key": "Quber2",
                    "doc_count": 7,
                    "avg#StatiAvg": {
                        "value": 51.0
                    },
                    "max#StatiMax": {
                        "value": 78.0
                    },
                    "min#StatiMin": {
                        "value": 25.0
                    },
                    "sum#StatiSum": {
                        "value": 357.0
                    }
                },
                {
                    "key": "Quber3",
                    "doc_count": 7,
                    "avg#StatiAvg": {
                        "value": 48.142857142857146
                    },
                    "max#StatiMax": {
                        "value": 74.0
                    },
                    "min#StatiMin": {
                        "value": 28.0
                    },
                    "sum#StatiSum": {
                        "value": 337.0
                    }
                },
                {
                    "key": "Quber4",
                    "doc_count": 7,
                    "avg#StatiAvg": {
                        "value": 53.285714285714285
                    },
                    "max#StatiMax": {
                        "value": 76.0
                    },
                    "min#StatiMin": {
                        "value": 25.0
                    },
                    "sum#StatiSum": {
                        "value": 373.0
                    }
                },
                {
                    "key": "Quber5",
                    "doc_count": 7,
                    "avg#StatiAvg": {
                        "value": 47.285714285714285
                    },
                    "max#StatiMax": {
                        "value": 70.0
                    },
                    "min#StatiMin": {
                        "value": 25.0
                    },
                    "sum#StatiSum": {
                        "value": 331.0
                    }
                },
                {
                    "key": "Quber6",
                    "doc_count": 6,
                    "avg#StatiAvg": {
                        "value": 41.5
                    },
                    "max#StatiMax": {
                        "value": 78.0
                    },
                    "min#StatiMin": {
                        "value": 20.0
                    },
                    "sum#StatiSum": {
                        "value": 249.0
                    }
                },
                {
                    "key": "Quber7",
                    "doc_count": 5,
                    "avg#StatiAvg": {
                        "value": 43.0
                    },
                    "max#StatiMax": {
                        "value": 61.0
                    },
                    "min#StatiMin": {
                        "value": 21.0
                    },
                    "sum#StatiSum": {
                        "value": 215.0
                    }
                },
                {
                    "key": "Quber8",
                    "doc_count": 5,
                    "avg#StatiAvg": {
                        "value": 42.2
                    },
                    "max#StatiMax": {
                        "value": 61.0
                    },
                    "min#StatiMin": {
                        "value": 22.0
                    },
                    "sum#StatiSum": {
                        "value": 211.0
                    }
                },
                {
                    "key": "Quber9",
                    "doc_count": 4,
                    "avg#StatiAvg": {
                        "value": 54.75
                    },
                    "max#StatiMax": {
                        "value": 65.0
                    },
                    "min#StatiMin": {
                        "value": 39.0
                    },
                    "sum#StatiSum": {
                        "value": 219.0
                    }
                }
            ]
        }
    }
}



使用示例(多个字段分组,并返回多个字段对应的值以及对应分组的数据数量):

//类似SQL:SELECT col1,col2,COUNT(1) FROM A GROUP BY col1,col2
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupsCount = _quickElasticSearch.GetGroupsCount(new List { "UserName", "UserAge" }, queryCon);

//异步
var retGetGroupsCountAsync = await _quickElasticSearch.GetGroupsCountAsync(new List { "UserName", "UserAge" }, queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": [
        {
            "UserName": "Jack1",
            "UserAge": 23,
            "GroupCount": 1
        },
        {
            "UserName": "Jack1",
            "UserAge": 31,
            "GroupCount": 1
        },
        {
            "UserName": "Jack2",
            "UserAge": 21,
            "GroupCount": 1
        },
        {
            "UserName": "Jack2",
            "UserAge": 77,
            "GroupCount": 1
        },
        {
            "UserName": "Jack3",
            "UserAge": 59,
            "GroupCount": 1
        },
        {
            "UserName": "Jack3",
            "UserAge": 67,
            "GroupCount": 1
        }
    ]
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiGroup":{
            "multi_terms":{
                "order":[
                    {
                        "_key":"asc"
                    },
                    {
                        "_count":"asc"
                    }
                ],
                "size":2000000000,
                "terms":[
                    {
                        "field":"UserType"
                    },
                    {
                        "field":"UserName"
                    }
                ]
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "multi_terms#StatiGroup": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": ["会员用户", "Jack1"],
                    "key_as_string": "会员用户|Jack1",
                    "doc_count": 1
                },
                {
                    "key": ["会员用户", "Jack6"],
                    "key_as_string": "会员用户|Jack6",
                    "doc_count": 1
                },
                {
                    "key": ["会员用户", "Jack9"],
                    "key_as_string": "会员用户|Jack9",
                    "doc_count": 1
                },
                {
                    "key": ["会员用户", "Quber1"],
                    "key_as_string": "会员用户|Quber1",
                    "doc_count": 1
                },
                {
                    "key": ["会员用户", "Quber10"],
                    "key_as_string": "会员用户|Quber10",
                    "doc_count": 1
                },
                {
                    "key": ["会员用户", "Quber11"],
                    "key_as_string": "会员用户|Quber11",
                    "doc_count": 1
                },
                {
                    "key": ["会员用户", "Quber2"],
                    "key_as_string": "会员用户|Quber2",
                    "doc_count": 2
                },
                {
                    "key": ["会员用户", "Quber3"],
                    "key_as_string": "会员用户|Quber3",
                    "doc_count": 2
                },
                {
                    "key": ["会员用户", "Quber4"],
                    "key_as_string": "会员用户|Quber4",
                    "doc_count": 1
                },
                {
                    "key": ["会员用户", "Quber5"],
                    "key_as_string": "会员用户|Quber5",
                    "doc_count": 3
                },
                {
                    "key": ["会员用户", "Quber6"],
                    "key_as_string": "会员用户|Quber6",
                    "doc_count": 2
                },
                {
                    "key": ["会员用户", "Quber7"],
                    "key_as_string": "会员用户|Quber7",
                    "doc_count": 1
                },
                {
                    "key": ["会员用户", "Quber8"],
                    "key_as_string": "会员用户|Quber8",
                    "doc_count": 1
                },
                {
                    "key": ["会员用户", "Quber9"],
                    "key_as_string": "会员用户|Quber9",
                    "doc_count": 1
                },
                {
                    "key": ["普通用户", "Jack1"],
                    "key_as_string": "普通用户|Jack1",
                    "doc_count": 1
                },
                {
                    "key": ["普通用户", "Jack10"],
                    "key_as_string": "普通用户|Jack10",
                    "doc_count": 1
                },
                {
                    "key": ["普通用户", "Jack2"],
                    "key_as_string": "普通用户|Jack2",
                    "doc_count": 1
                },
                {
                    "key": ["普通用户", "Jack4"],
                    "key_as_string": "普通用户|Jack4",
                    "doc_count": 1
                },
                {
                    "key": ["普通用户", "Jack7"],
                    "key_as_string": "普通用户|Jack7",
                    "doc_count": 1
                },
                {
                    "key": ["普通用户", "Jack8"],
                    "key_as_string": "普通用户|Jack8",
                    "doc_count": 1
                },
                {
                    "key": ["普通用户", "Quber1"],
                    "key_as_string": "普通用户|Quber1",
                    "doc_count": 3
                },
                {
                    "key": ["普通用户", "Quber12"],
                    "key_as_string": "普通用户|Quber12",
                    "doc_count": 1
                },
                {
                    "key": ["普通用户", "Quber3"],
                    "key_as_string": "普通用户|Quber3",
                    "doc_count": 1
                },
                {
                    "key": ["普通用户", "Quber4"],
                    "key_as_string": "普通用户|Quber4",
                    "doc_count": 2
                },
                {
                    "key": ["普通用户", "Quber6"],
                    "key_as_string": "普通用户|Quber6",
                    "doc_count": 1
                },
                {
                    "key": ["普通用户", "Quber7"],
                    "key_as_string": "普通用户|Quber7",
                    "doc_count": 2
                },
                {
                    "key": ["普通用户", "Quber8"],
                    "key_as_string": "普通用户|Quber8",
                    "doc_count": 2
                },
                {
                    "key": ["普通用户", "Quber9"],
                    "key_as_string": "普通用户|Quber9",
                    "doc_count": 1
                },
                {
                    "key": ["系统用户", "Jack2"],
                    "key_as_string": "系统用户|Jack2",
                    "doc_count": 1
                },
                {
                    "key": ["系统用户", "Jack3"],
                    "key_as_string": "系统用户|Jack3",
                    "doc_count": 2
                },
                {
                    "key": ["系统用户", "Jack5"],
                    "key_as_string": "系统用户|Jack5",
                    "doc_count": 1
                },
                {
                    "key": ["系统用户", "Quber1"],
                    "key_as_string": "系统用户|Quber1",
                    "doc_count": 1
                },
                {
                    "key": ["系统用户", "Quber10"],
                    "key_as_string": "系统用户|Quber10",
                    "doc_count": 2
                },
                {
                    "key": ["系统用户", "Quber2"],
                    "key_as_string": "系统用户|Quber2",
                    "doc_count": 3
                },
                {
                    "key": ["系统用户", "Quber3"],
                    "key_as_string": "系统用户|Quber3",
                    "doc_count": 1
                },
                {
                    "key": ["系统用户", "Quber4"],
                    "key_as_string": "系统用户|Quber4",
                    "doc_count": 2
                },
                {
                    "key": ["系统用户", "Quber5"],
                    "key_as_string": "系统用户|Quber5",
                    "doc_count": 3
                },
                {
                    "key": ["系统用户", "Quber6"],
                    "key_as_string": "系统用户|Quber6",
                    "doc_count": 3
                },
                {
                    "key": ["系统用户", "Quber7"],
                    "key_as_string": "系统用户|Quber7",
                    "doc_count": 1
                },
                {
                    "key": ["系统用户", "Quber9"],
                    "key_as_string": "系统用户|Quber9",
                    "doc_count": 1
                },
                {
                    "key": ["高级用户", "Jack4"],
                    "key_as_string": "高级用户|Jack4",
                    "doc_count": 1
                },
                {
                    "key": ["高级用户", "Jack5"],
                    "key_as_string": "高级用户|Jack5",
                    "doc_count": 1
                },
                {
                    "key": ["高级用户", "Quber1"],
                    "key_as_string": "高级用户|Quber1",
                    "doc_count": 2
                },
                {
                    "key": ["高级用户", "Quber2"],
                    "key_as_string": "高级用户|Quber2",
                    "doc_count": 2
                },
                {
                    "key": ["高级用户", "Quber3"],
                    "key_as_string": "高级用户|Quber3",
                    "doc_count": 3
                },
                {
                    "key": ["高级用户", "Quber4"],
                    "key_as_string": "高级用户|Quber4",
                    "doc_count": 2
                },
                {
                    "key": ["高级用户", "Quber5"],
                    "key_as_string": "高级用户|Quber5",
                    "doc_count": 1
                },
                {
                    "key": ["高级用户", "Quber7"],
                    "key_as_string": "高级用户|Quber7",
                    "doc_count": 1
                },
                {
                    "key": ["高级用户", "Quber8"],
                    "key_as_string": "高级用户|Quber8",
                    "doc_count": 2
                },
                {
                    "key": ["高级用户", "Quber9"],
                    "key_as_string": "高级用户|Quber9",
                    "doc_count": 1
                }
            ]
        }
    }
}



使用示例(日期字段分组,按月统计):

//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupsDateMonth = _quickElasticSearch.GetGroupsDateMonth(m => m.CreateTime, queryCon);

//异步
var retGetGroupsDateMonthAsync = await _quickElasticSearch.GetGroupsDateMonthAsync(m => m.CreateTime, queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": [
        {
            "Name": "2022-08",
            "Count": 110
        },
        {
            "Name": "2022-09",
            "Count": 132
        },
        {
            "Name": "2022-10",
            "Count": 166
        }
    ]
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiGroup":{
            "date_histogram":{
                "field":"CreateTime",
                "format":"yyyy-MM",
                "calendar_interval":"1M",
                "min_doc_count":0,
                "order":{
                    "_key":"asc"
                },
                "time_zone":"+08:00"
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "date_histogram#StatiGroup": {
            "buckets": [
                {
                    "key_as_string": "2022-10",
                    "key": 1664553600000,
                    "doc_count": 75
                }
            ]
        }
    }
}



使用示例(日期字段分组,支持按年、季度、月份、星期、天、小时、分、秒等维度进行统计):

//统计的时间间隔维度支持的表达式有(1y:1年、1q:1季度、1M:1个月、1w:1星期、1d:1天、1h:1小时、1m:1分钟、1s:1秒钟)
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupsDate = _quickElasticSearch.GetGroupsDate(m => m.CreateTime, "1m", "yyyy-MM-dd HH:mm", queryCon);

//异步
var retGetGroupsDateAsync = await _quickElasticSearch.GetGroupsDateAsync(m => m.CreateTime, "1m", "yyyy-MM-dd HH:mm", queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": [
        {
            "Name": "2022-10-12 09:24",
            "Count": 10
        },
        {
            "Name": "2022-10-12 09:25",
            "Count": 50
        },
        {
            "Name": "2022-10-12 09:26",
            "Count": 10
        },
        {
            "Name": "2022-10-12 09:27",
            "Count": 10
        },
        {
            "Name": "2022-10-12 09:28",
            "Count": 0
        },
        {
            "Name": "2022-10-12 09:29",
            "Count": 0
        },
        {
            "Name": "2022-10-12 09:30",
            "Count": 0
        },
        {
            "Name": "2022-10-12 09:31",
            "Count": 0
        },
        {
            "Name": "2022-10-12 09:32",
            "Count": 0
        },
        {
            "Name": "2022-10-12 09:33",
            "Count": 0
        },
        {
            "Name": "2022-10-12 09:34",
            "Count": 0
        },
        {
            "Name": "2022-10-12 09:35",
            "Count": 0
        },
        {
            "Name": "2022-10-12 09:36",
            "Count": 11
        },
        {
            "Name": "2022-10-12 09:37",
            "Count": 41
        }
    ]
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiGroup":{
            "date_histogram":{
                "field":"CreateTime",
                "format":"yyyy-MM-dd HH:mm",
                "calendar_interval":"1m",
                "min_doc_count":0,
                "order":{
                    "_key":"asc"
                },
                "time_zone":"+08:00"
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "date_histogram#StatiGroup": {
            "buckets": [
                {
                    "key_as_string": "2022-10-17 16:05",
                    "key": 1665993900000,
                    "doc_count": 15
                },
                {
                    "key_as_string": "2022-10-17 16:06",
                    "key": 1665993960000,
                    "doc_count": 50
                },
                {
                    "key_as_string": "2022-10-17 16:07",
                    "key": 1665994020000,
                    "doc_count": 10
                }
            ]
        }
    }
}



使用示例(日期字段分组,按月统计,并返回另一个字段的总和、最大值、最小值和平均值):

//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupsDateMonthSmma = _quickElasticSearch.GetGroupsDateMonthSmma(m => m.CreateTime, m => m.UserAge, queryCon);

//异步
var retGetGroupsDateMonthSmmaAsync = await _quickElasticSearch.GetGroupsDateMonthSmmaAsync(m => m.CreateTime, m => m.UserAge, queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": [
        {
            "Name": "2022-10",
            "Count": 132,
            "Sum": 6842,
            "Max": 79,
            "Min": 21,
            "Avg": 51.83
        }
    ]
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiGroup":{
            "aggs":{
                "StatiSum":{
                    "sum":{
                        "field":"UserAge"
                    }
                },
                "StatiMax":{
                    "max":{
                        "field":"UserAge"
                    }
                },
                "StatiMin":{
                    "min":{
                        "field":"UserAge"
                    }
                },
                "StatiAvg":{
                    "avg":{
                        "field":"UserAge"
                    }
                }
            },
            "date_histogram":{
                "field":"CreateTime",
                "format":"yyyy-MM",
                "calendar_interval":"1M",
                "min_doc_count":0,
                "order":{
                    "_key":"asc"
                },
                "time_zone":"+08:00"
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "date_histogram#StatiGroup": {
            "buckets": [
                {
                    "key_as_string": "2022-10",
                    "key": 1664553600000,
                    "doc_count": 75,
                    "avg#StatiAvg": {
                        "value": 46.92
                    },
                    "max#StatiMax": {
                        "value": 79.0
                    },
                    "min#StatiMin": {
                        "value": 20.0
                    },
                    "sum#StatiSum": {
                        "value": 3519.0
                    }
                }
            ]
        }
    }
}



使用示例(日期字段分组,并返回另一个字段的总和、最大值、最小值和平均值):

//统计的时间间隔维度支持的表达式有(1y:1年、1q:1季度、1M:1个月、1w:1星期、1d:1天、1h:1小时、1m:1分钟、1s:1秒钟)
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupsDateSmma = _quickElasticSearch.GetGroupsDateSmma(m => m.CreateTime, m => m.UserAge, "1m", "yyyy-MM-dd HH:mm", queryCon);

//异步
var retGetGroupsDateSmmaAsync = await _quickElasticSearch.GetGroupsDateSmmaAsync(m => m.CreateTime, m => m.UserAge, "1m", "yyyy-MM-dd HH:mm", queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": [
        {
            "Name": "2022-10-12 09:24",
            "Count": 10,
            "Sum": 588,
            "Max": 76,
            "Min": 31,
            "Avg": 58.8
        },
        {
            "Name": "2022-10-12 09:25",
            "Count": 50,
            "Sum": 2432,
            "Max": 79,
            "Min": 21,
            "Avg": 48.64
        },
        {
            "Name": "2022-10-12 09:26",
            "Count": 10,
            "Sum": 512,
            "Max": 79,
            "Min": 27,
            "Avg": 51.2
        },
        {
            "Name": "2022-10-12 09:27",
            "Count": 10,
            "Sum": 616,
            "Max": 76,
            "Min": 34,
            "Avg": 61.6
        },
        {
            "Name": "2022-10-12 09:28",
            "Count": 0,
            "Sum": 0,
            "Max": 0,
            "Min": 0,
            "Avg": 0
        },
        {
            "Name": "2022-10-12 09:29",
            "Count": 0,
            "Sum": 0,
            "Max": 0,
            "Min": 0,
            "Avg": 0
        },
        {
            "Name": "2022-10-12 09:30",
            "Count": 0,
            "Sum": 0,
            "Max": 0,
            "Min": 0,
            "Avg": 0
        },
        {
            "Name": "2022-10-12 09:31",
            "Count": 0,
            "Sum": 0,
            "Max": 0,
            "Min": 0,
            "Avg": 0
        },
        {
            "Name": "2022-10-12 09:32",
            "Count": 0,
            "Sum": 0,
            "Max": 0,
            "Min": 0,
            "Avg": 0
        },
        {
            "Name": "2022-10-12 09:33",
            "Count": 0,
            "Sum": 0,
            "Max": 0,
            "Min": 0,
            "Avg": 0
        },
        {
            "Name": "2022-10-12 09:34",
            "Count": 0,
            "Sum": 0,
            "Max": 0,
            "Min": 0,
            "Avg": 0
        },
        {
            "Name": "2022-10-12 09:35",
            "Count": 0,
            "Sum": 0,
            "Max": 0,
            "Min": 0,
            "Avg": 0
        },
        {
            "Name": "2022-10-12 09:36",
            "Count": 11,
            "Sum": 527,
            "Max": 74,
            "Min": 21,
            "Avg": 47.91
        },
        {
            "Name": "2022-10-12 09:37",
            "Count": 41,
            "Sum": 2167,
            "Max": 78,
            "Min": 25,
            "Avg": 52.85
        }
    ]
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiGroup":{
            "aggs":{
                "StatiSum":{
                    "sum":{
                        "field":"UserAge"
                    }
                },
                "StatiMax":{
                    "max":{
                        "field":"UserAge"
                    }
                },
                "StatiMin":{
                    "min":{
                        "field":"UserAge"
                    }
                },
                "StatiAvg":{
                    "avg":{
                        "field":"UserAge"
                    }
                }
            },
            "date_histogram":{
                "field":"CreateTime",
                "format":"yyyy-MM-dd HH:mm",
                "calendar_interval":"1m",
                "min_doc_count":0,
                "order":{
                    "_key":"asc"
                },
                "time_zone":"+08:00"
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "date_histogram#StatiGroup": {
            "buckets": [
                {
                    "key_as_string": "2022-10-17 16:05",
                    "key": 1665993900000,
                    "doc_count": 15,
                    "avg#StatiAvg": {
                        "value": 44.06666666666667
                    },
                    "max#StatiMax": {
                        "value": 76.0
                    },
                    "min#StatiMin": {
                        "value": 21.0
                    },
                    "sum#StatiSum": {
                        "value": 661.0
                    }
                },
                {
                    "key_as_string": "2022-10-17 16:06",
                    "key": 1665993960000,
                    "doc_count": 50,
                    "avg#StatiAvg": {
                        "value": 46.2
                    },
                    "max#StatiMax": {
                        "value": 79.0
                    },
                    "min#StatiMin": {
                        "value": 20.0
                    },
                    "sum#StatiSum": {
                        "value": 2310.0
                    }
                },
                {
                    "key_as_string": "2022-10-17 16:07",
                    "key": 1665994020000,
                    "doc_count": 10,
                    "avg#StatiAvg": {
                        "value": 54.8
                    },
                    "max#StatiMax": {
                        "value": 78.0
                    },
                    "min#StatiMin": {
                        "value": 30.0
                    },
                    "sum#StatiSum": {
                        "value": 548.0
                    }
                }
            ]
        }
    }
}



使用示例(日期字段分组,按某年 1~12 月统计每个月的某个字段每个月的总和以及这一年的总和):

//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupsDateMonthOneYear = _quickElasticSearch.GetGroupsDateMonthOneYear(m => m.CreateTime, m => m.UserName, m => m.UserAge, 2022, queryCon);

//异步
var retGetGroupsDateMonthOneYearAsync = await _quickElasticSearch.GetGroupsDateMonthOneYearAsync(m => m.CreateTime, m => m.UserName, m => m.UserAge, 2022, queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": [
        ["Jack1", 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 54],
        ["Jack2", 0, 0, 0, 0, 0, 0, 0, 0, 0, 98, 0, 0, 98],
        ["Jack3", 0, 0, 0, 0, 0, 0, 0, 0, 0, 126, 0, 0, 126]
    ]
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiGroup":{
            "aggs":{
                "StatiGroup-1":{
                    "aggs":{
                        "StatiSum":{
                            "sum":{
                                "field":"UserAge"
                            }
                        },
                        "StatiMax":{
                            "max":{
                                "field":"UserAge"
                            }
                        },
                        "StatiMin":{
                            "min":{
                                "field":"UserAge"
                            }
                        },
                        "StatiAvg":{
                            "avg":{
                                "field":"UserAge"
                            }
                        }
                    },
                    "terms":{
                        "field":"UserName",
                        "order":[
                            {
                                "_key":"asc"
                            },
                            {
                                "_count":"asc"
                            }
                        ],
                        "size":2000000000
                    }
                }
            },
            "date_histogram":{
                "field":"CreateTime",
                "format":"yyyy-MM",
                "calendar_interval":"1M",
                "min_doc_count":0,
                "order":{
                    "_key":"asc"
                },
                "time_zone":"+08:00"
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "date_histogram#StatiGroup": {
            "buckets": [
                {
                    "key_as_string": "2022-10",
                    "key": 1664553600000,
                    "doc_count": 75,
                    "sterms#StatiGroup-1": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "Jack1",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 34.0
                                },
                                "max#StatiMax": {
                                    "value": 39.0
                                },
                                "min#StatiMin": {
                                    "value": 29.0
                                },
                                "sum#StatiSum": {
                                    "value": 68.0
                                }
                            },
                            {
                                "key": "Jack10",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 60.0
                                },
                                "max#StatiMax": {
                                    "value": 60.0
                                },
                                "min#StatiMin": {
                                    "value": 60.0
                                },
                                "sum#StatiSum": {
                                    "value": 60.0
                                }
                            },
                            {
                                "key": "Jack2",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 40.0
                                },
                                "max#StatiMax": {
                                    "value": 48.0
                                },
                                "min#StatiMin": {
                                    "value": 32.0
                                },
                                "sum#StatiSum": {
                                    "value": 80.0
                                }
                            },
                            {
                                "key": "Jack3",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 39.5
                                },
                                "max#StatiMax": {
                                    "value": 53.0
                                },
                                "min#StatiMin": {
                                    "value": 26.0
                                },
                                "sum#StatiSum": {
                                    "value": 79.0
                                }
                            },
                            {
                                "key": "Jack4",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 48.0
                                },
                                "max#StatiMax": {
                                    "value": 65.0
                                },
                                "min#StatiMin": {
                                    "value": 31.0
                                },
                                "sum#StatiSum": {
                                    "value": 96.0
                                }
                            },
                            {
                                "key": "Jack5",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 54.0
                                },
                                "max#StatiMax": {
                                    "value": 78.0
                                },
                                "min#StatiMin": {
                                    "value": 30.0
                                },
                                "sum#StatiSum": {
                                    "value": 108.0
                                }
                            },
                            {
                                "key": "Jack6",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 57.0
                                },
                                "max#StatiMax": {
                                    "value": 57.0
                                },
                                "min#StatiMin": {
                                    "value": 57.0
                                },
                                "sum#StatiSum": {
                                    "value": 57.0
                                }
                            },
                            {
                                "key": "Jack7",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 40.0
                                },
                                "max#StatiMax": {
                                    "value": 40.0
                                },
                                "min#StatiMin": {
                                    "value": 40.0
                                },
                                "sum#StatiSum": {
                                    "value": 40.0
                                }
                            },
                            {
                                "key": "Jack8",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 29.0
                                },
                                "max#StatiMax": {
                                    "value": 29.0
                                },
                                "min#StatiMin": {
                                    "value": 29.0
                                },
                                "sum#StatiSum": {
                                    "value": 29.0
                                }
                            },
                            {
                                "key": "Jack9",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 72.0
                                },
                                "max#StatiMax": {
                                    "value": 72.0
                                },
                                "min#StatiMin": {
                                    "value": 72.0
                                },
                                "sum#StatiSum": {
                                    "value": 72.0
                                }
                            },
                            {
                                "key": "Quber1",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 48.857142857142854
                                },
                                "max#StatiMax": {
                                    "value": 79.0
                                },
                                "min#StatiMin": {
                                    "value": 21.0
                                },
                                "sum#StatiSum": {
                                    "value": 342.0
                                }
                            },
                            {
                                "key": "Quber10",
                                "doc_count": 3,
                                "avg#StatiAvg": {
                                    "value": 31.0
                                },
                                "max#StatiMax": {
                                    "value": 43.0
                                },
                                "min#StatiMin": {
                                    "value": 20.0
                                },
                                "sum#StatiSum": {
                                    "value": 93.0
                                }
                            },
                            {
                                "key": "Quber11",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 29.0
                                },
                                "max#StatiMax": {
                                    "value": 29.0
                                },
                                "min#StatiMin": {
                                    "value": 29.0
                                },
                                "sum#StatiSum": {
                                    "value": 29.0
                                }
                            },
                            {
                                "key": "Quber12",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 74.0
                                },
                                "max#StatiMax": {
                                    "value": 74.0
                                },
                                "min#StatiMin": {
                                    "value": 74.0
                                },
                                "sum#StatiSum": {
                                    "value": 74.0
                                }
                            },
                            {
                                "key": "Quber2",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 51.0
                                },
                                "max#StatiMax": {
                                    "value": 78.0
                                },
                                "min#StatiMin": {
                                    "value": 25.0
                                },
                                "sum#StatiSum": {
                                    "value": 357.0
                                }
                            },
                            {
                                "key": "Quber3",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 48.142857142857146
                                },
                                "max#StatiMax": {
                                    "value": 74.0
                                },
                                "min#StatiMin": {
                                    "value": 28.0
                                },
                                "sum#StatiSum": {
                                    "value": 337.0
                                }
                            },
                            {
                                "key": "Quber4",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 53.285714285714285
                                },
                                "max#StatiMax": {
                                    "value": 76.0
                                },
                                "min#StatiMin": {
                                    "value": 25.0
                                },
                                "sum#StatiSum": {
                                    "value": 373.0
                                }
                            },
                            {
                                "key": "Quber5",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 47.285714285714285
                                },
                                "max#StatiMax": {
                                    "value": 70.0
                                },
                                "min#StatiMin": {
                                    "value": 25.0
                                },
                                "sum#StatiSum": {
                                    "value": 331.0
                                }
                            },
                            {
                                "key": "Quber6",
                                "doc_count": 6,
                                "avg#StatiAvg": {
                                    "value": 41.5
                                },
                                "max#StatiMax": {
                                    "value": 78.0
                                },
                                "min#StatiMin": {
                                    "value": 20.0
                                },
                                "sum#StatiSum": {
                                    "value": 249.0
                                }
                            },
                            {
                                "key": "Quber7",
                                "doc_count": 5,
                                "avg#StatiAvg": {
                                    "value": 43.0
                                },
                                "max#StatiMax": {
                                    "value": 61.0
                                },
                                "min#StatiMin": {
                                    "value": 21.0
                                },
                                "sum#StatiSum": {
                                    "value": 215.0
                                }
                            },
                            {
                                "key": "Quber8",
                                "doc_count": 5,
                                "avg#StatiAvg": {
                                    "value": 42.2
                                },
                                "max#StatiMax": {
                                    "value": 61.0
                                },
                                "min#StatiMin": {
                                    "value": 22.0
                                },
                                "sum#StatiSum": {
                                    "value": 211.0
                                }
                            },
                            {
                                "key": "Quber9",
                                "doc_count": 4,
                                "avg#StatiAvg": {
                                    "value": 54.75
                                },
                                "max#StatiMax": {
                                    "value": 65.0
                                },
                                "min#StatiMin": {
                                    "value": 39.0
                                },
                                "sum#StatiSum": {
                                    "value": 219.0
                                }
                            }
                        ]
                    }
                }
            ]
        }
    }
}



使用示例(日期字段分组,按月统计,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值):

//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupsDateMonth = _quickElasticSearch.GetGroupsDateMonth(m => m.CreateTime, m => m.UserName, m => m.UserAge, queryCon);

//异步
var retGetGroupsDateMonthAsync = await _quickElasticSearch.GetGroupsDateMonthAsync(m => m.CreateTime, m => m.UserName, m => m.UserAge, queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": [
        {
            "Name": "2022-10",
            "Count": 132,
            "Group": [
                {
                    "Name": "Jack1",
                    "Count": 2,
                    "Sum": 54,
                    "Max": 31,
                    "Min": 23,
                    "Avg": 27
                },
                {
                    "Name": "Jack2",
                    "Count": 2,
                    "Sum": 98,
                    "Max": 77,
                    "Min": 21,
                    "Avg": 49
                },
                {
                    "Name": "Jack3",
                    "Count": 2,
                    "Sum": 126,
                    "Max": 67,
                    "Min": 59,
                    "Avg": 63
                }
            ]
        }
    ]
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiGroup":{
            "aggs":{
                "StatiGroup-1":{
                    "aggs":{
                        "StatiSum":{
                            "sum":{
                                "field":"UserAge"
                            }
                        },
                        "StatiMax":{
                            "max":{
                                "field":"UserAge"
                            }
                        },
                        "StatiMin":{
                            "min":{
                                "field":"UserAge"
                            }
                        },
                        "StatiAvg":{
                            "avg":{
                                "field":"UserAge"
                            }
                        }
                    },
                    "terms":{
                        "field":"UserName",
                        "order":[
                            {
                                "_key":"asc"
                            },
                            {
                                "_count":"asc"
                            }
                        ],
                        "size":2000000000
                    }
                }
            },
            "date_histogram":{
                "field":"CreateTime",
                "format":"yyyy-MM",
                "calendar_interval":"1M",
                "min_doc_count":0,
                "order":{
                    "_key":"asc"
                },
                "time_zone":"+08:00"
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "date_histogram#StatiGroup": {
            "buckets": [
                {
                    "key_as_string": "2022-10",
                    "key": 1664553600000,
                    "doc_count": 75,
                    "sterms#StatiGroup-1": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "Jack1",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 34.0
                                },
                                "max#StatiMax": {
                                    "value": 39.0
                                },
                                "min#StatiMin": {
                                    "value": 29.0
                                },
                                "sum#StatiSum": {
                                    "value": 68.0
                                }
                            },
                            {
                                "key": "Jack10",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 60.0
                                },
                                "max#StatiMax": {
                                    "value": 60.0
                                },
                                "min#StatiMin": {
                                    "value": 60.0
                                },
                                "sum#StatiSum": {
                                    "value": 60.0
                                }
                            },
                            {
                                "key": "Jack2",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 40.0
                                },
                                "max#StatiMax": {
                                    "value": 48.0
                                },
                                "min#StatiMin": {
                                    "value": 32.0
                                },
                                "sum#StatiSum": {
                                    "value": 80.0
                                }
                            },
                            {
                                "key": "Jack3",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 39.5
                                },
                                "max#StatiMax": {
                                    "value": 53.0
                                },
                                "min#StatiMin": {
                                    "value": 26.0
                                },
                                "sum#StatiSum": {
                                    "value": 79.0
                                }
                            },
                            {
                                "key": "Jack4",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 48.0
                                },
                                "max#StatiMax": {
                                    "value": 65.0
                                },
                                "min#StatiMin": {
                                    "value": 31.0
                                },
                                "sum#StatiSum": {
                                    "value": 96.0
                                }
                            },
                            {
                                "key": "Jack5",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 54.0
                                },
                                "max#StatiMax": {
                                    "value": 78.0
                                },
                                "min#StatiMin": {
                                    "value": 30.0
                                },
                                "sum#StatiSum": {
                                    "value": 108.0
                                }
                            },
                            {
                                "key": "Jack6",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 57.0
                                },
                                "max#StatiMax": {
                                    "value": 57.0
                                },
                                "min#StatiMin": {
                                    "value": 57.0
                                },
                                "sum#StatiSum": {
                                    "value": 57.0
                                }
                            },
                            {
                                "key": "Jack7",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 40.0
                                },
                                "max#StatiMax": {
                                    "value": 40.0
                                },
                                "min#StatiMin": {
                                    "value": 40.0
                                },
                                "sum#StatiSum": {
                                    "value": 40.0
                                }
                            },
                            {
                                "key": "Jack8",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 29.0
                                },
                                "max#StatiMax": {
                                    "value": 29.0
                                },
                                "min#StatiMin": {
                                    "value": 29.0
                                },
                                "sum#StatiSum": {
                                    "value": 29.0
                                }
                            },
                            {
                                "key": "Jack9",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 72.0
                                },
                                "max#StatiMax": {
                                    "value": 72.0
                                },
                                "min#StatiMin": {
                                    "value": 72.0
                                },
                                "sum#StatiSum": {
                                    "value": 72.0
                                }
                            },
                            {
                                "key": "Quber1",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 48.857142857142854
                                },
                                "max#StatiMax": {
                                    "value": 79.0
                                },
                                "min#StatiMin": {
                                    "value": 21.0
                                },
                                "sum#StatiSum": {
                                    "value": 342.0
                                }
                            },
                            {
                                "key": "Quber10",
                                "doc_count": 3,
                                "avg#StatiAvg": {
                                    "value": 31.0
                                },
                                "max#StatiMax": {
                                    "value": 43.0
                                },
                                "min#StatiMin": {
                                    "value": 20.0
                                },
                                "sum#StatiSum": {
                                    "value": 93.0
                                }
                            },
                            {
                                "key": "Quber11",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 29.0
                                },
                                "max#StatiMax": {
                                    "value": 29.0
                                },
                                "min#StatiMin": {
                                    "value": 29.0
                                },
                                "sum#StatiSum": {
                                    "value": 29.0
                                }
                            },
                            {
                                "key": "Quber12",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 74.0
                                },
                                "max#StatiMax": {
                                    "value": 74.0
                                },
                                "min#StatiMin": {
                                    "value": 74.0
                                },
                                "sum#StatiSum": {
                                    "value": 74.0
                                }
                            },
                            {
                                "key": "Quber2",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 51.0
                                },
                                "max#StatiMax": {
                                    "value": 78.0
                                },
                                "min#StatiMin": {
                                    "value": 25.0
                                },
                                "sum#StatiSum": {
                                    "value": 357.0
                                }
                            },
                            {
                                "key": "Quber3",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 48.142857142857146
                                },
                                "max#StatiMax": {
                                    "value": 74.0
                                },
                                "min#StatiMin": {
                                    "value": 28.0
                                },
                                "sum#StatiSum": {
                                    "value": 337.0
                                }
                            },
                            {
                                "key": "Quber4",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 53.285714285714285
                                },
                                "max#StatiMax": {
                                    "value": 76.0
                                },
                                "min#StatiMin": {
                                    "value": 25.0
                                },
                                "sum#StatiSum": {
                                    "value": 373.0
                                }
                            },
                            {
                                "key": "Quber5",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 47.285714285714285
                                },
                                "max#StatiMax": {
                                    "value": 70.0
                                },
                                "min#StatiMin": {
                                    "value": 25.0
                                },
                                "sum#StatiSum": {
                                    "value": 331.0
                                }
                            },
                            {
                                "key": "Quber6",
                                "doc_count": 6,
                                "avg#StatiAvg": {
                                    "value": 41.5
                                },
                                "max#StatiMax": {
                                    "value": 78.0
                                },
                                "min#StatiMin": {
                                    "value": 20.0
                                },
                                "sum#StatiSum": {
                                    "value": 249.0
                                }
                            },
                            {
                                "key": "Quber7",
                                "doc_count": 5,
                                "avg#StatiAvg": {
                                    "value": 43.0
                                },
                                "max#StatiMax": {
                                    "value": 61.0
                                },
                                "min#StatiMin": {
                                    "value": 21.0
                                },
                                "sum#StatiSum": {
                                    "value": 215.0
                                }
                            },
                            {
                                "key": "Quber8",
                                "doc_count": 5,
                                "avg#StatiAvg": {
                                    "value": 42.2
                                },
                                "max#StatiMax": {
                                    "value": 61.0
                                },
                                "min#StatiMin": {
                                    "value": 22.0
                                },
                                "sum#StatiSum": {
                                    "value": 211.0
                                }
                            },
                            {
                                "key": "Quber9",
                                "doc_count": 4,
                                "avg#StatiAvg": {
                                    "value": 54.75
                                },
                                "max#StatiMax": {
                                    "value": 65.0
                                },
                                "min#StatiMin": {
                                    "value": 39.0
                                },
                                "sum#StatiSum": {
                                    "value": 219.0
                                }
                            }
                        ]
                    }
                }
            ]
        }
    }
}



使用示例(日期字段分组,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值):

//统计的时间间隔维度支持的表达式有(1y:1年、1q:1季度、1M:1个月、1w:1星期、1d:1天、1h:1小时、1m:1分钟、1s:1秒钟)
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetGroupsDateSub = _quickElasticSearch.GetGroupsDateSub(m => m.CreateTime, m => m.UserName, m => m.UserAge, "1h", "yyyy-MM-dd HH:mm", queryCon);

//异步
var retGetGroupsDateSubAsync = await _quickElasticSearch.GetGroupsDateSubAsync(m => m.CreateTime, m => m.UserName, m => m.UserAge, "1h", "yyyy-MM-dd HH:mm", queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": [
        {
            "Name": "2022-10-12 09:00",
            "Count": 132,
            "Group": [
                {
                    "Name": "Jack1",
                    "Count": 2,
                    "Sum": 54,
                    "Max": 31,
                    "Min": 23,
                    "Avg": 27
                },
                {
                    "Name": "Jack2",
                    "Count": 2,
                    "Sum": 98,
                    "Max": 77,
                    "Min": 21,
                    "Avg": 49
                },
                {
                    "Name": "Jack3",
                    "Count": 2,
                    "Sum": 126,
                    "Max": 67,
                    "Min": 59,
                    "Avg": 63
                }
            ]
        }
    ]
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiGroup":{
            "aggs":{
                "StatiGroup-1":{
                    "aggs":{
                        "StatiSum":{
                            "sum":{
                                "field":"UserAge"
                            }
                        },
                        "StatiMax":{
                            "max":{
                                "field":"UserAge"
                            }
                        },
                        "StatiMin":{
                            "min":{
                                "field":"UserAge"
                            }
                        },
                        "StatiAvg":{
                            "avg":{
                                "field":"UserAge"
                            }
                        }
                    },
                    "terms":{
                        "field":"UserName",
                        "order":[
                            {
                                "_key":"asc"
                            },
                            {
                                "_count":"asc"
                            }
                        ],
                        "size":2000000000
                    }
                }
            },
            "date_histogram":{
                "field":"CreateTime",
                "format":"yyyy-MM-dd HH:mm",
                "calendar_interval":"1h",
                "min_doc_count":0,
                "order":{
                    "_key":"asc"
                },
                "time_zone":"+08:00"
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "date_histogram#StatiGroup": {
            "buckets": [
                {
                    "key_as_string": "2022-10-17 16:00",
                    "key": 1665993600000,
                    "doc_count": 75,
                    "sterms#StatiGroup-1": {
                        "doc_count_error_upper_bound": 0,
                        "sum_other_doc_count": 0,
                        "buckets": [
                            {
                                "key": "Jack1",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 34.0
                                },
                                "max#StatiMax": {
                                    "value": 39.0
                                },
                                "min#StatiMin": {
                                    "value": 29.0
                                },
                                "sum#StatiSum": {
                                    "value": 68.0
                                }
                            },
                            {
                                "key": "Jack10",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 60.0
                                },
                                "max#StatiMax": {
                                    "value": 60.0
                                },
                                "min#StatiMin": {
                                    "value": 60.0
                                },
                                "sum#StatiSum": {
                                    "value": 60.0
                                }
                            },
                            {
                                "key": "Jack2",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 40.0
                                },
                                "max#StatiMax": {
                                    "value": 48.0
                                },
                                "min#StatiMin": {
                                    "value": 32.0
                                },
                                "sum#StatiSum": {
                                    "value": 80.0
                                }
                            },
                            {
                                "key": "Jack3",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 39.5
                                },
                                "max#StatiMax": {
                                    "value": 53.0
                                },
                                "min#StatiMin": {
                                    "value": 26.0
                                },
                                "sum#StatiSum": {
                                    "value": 79.0
                                }
                            },
                            {
                                "key": "Jack4",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 48.0
                                },
                                "max#StatiMax": {
                                    "value": 65.0
                                },
                                "min#StatiMin": {
                                    "value": 31.0
                                },
                                "sum#StatiSum": {
                                    "value": 96.0
                                }
                            },
                            {
                                "key": "Jack5",
                                "doc_count": 2,
                                "avg#StatiAvg": {
                                    "value": 54.0
                                },
                                "max#StatiMax": {
                                    "value": 78.0
                                },
                                "min#StatiMin": {
                                    "value": 30.0
                                },
                                "sum#StatiSum": {
                                    "value": 108.0
                                }
                            },
                            {
                                "key": "Jack6",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 57.0
                                },
                                "max#StatiMax": {
                                    "value": 57.0
                                },
                                "min#StatiMin": {
                                    "value": 57.0
                                },
                                "sum#StatiSum": {
                                    "value": 57.0
                                }
                            },
                            {
                                "key": "Jack7",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 40.0
                                },
                                "max#StatiMax": {
                                    "value": 40.0
                                },
                                "min#StatiMin": {
                                    "value": 40.0
                                },
                                "sum#StatiSum": {
                                    "value": 40.0
                                }
                            },
                            {
                                "key": "Jack8",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 29.0
                                },
                                "max#StatiMax": {
                                    "value": 29.0
                                },
                                "min#StatiMin": {
                                    "value": 29.0
                                },
                                "sum#StatiSum": {
                                    "value": 29.0
                                }
                            },
                            {
                                "key": "Jack9",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 72.0
                                },
                                "max#StatiMax": {
                                    "value": 72.0
                                },
                                "min#StatiMin": {
                                    "value": 72.0
                                },
                                "sum#StatiSum": {
                                    "value": 72.0
                                }
                            },
                            {
                                "key": "Quber1",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 48.857142857142854
                                },
                                "max#StatiMax": {
                                    "value": 79.0
                                },
                                "min#StatiMin": {
                                    "value": 21.0
                                },
                                "sum#StatiSum": {
                                    "value": 342.0
                                }
                            },
                            {
                                "key": "Quber10",
                                "doc_count": 3,
                                "avg#StatiAvg": {
                                    "value": 31.0
                                },
                                "max#StatiMax": {
                                    "value": 43.0
                                },
                                "min#StatiMin": {
                                    "value": 20.0
                                },
                                "sum#StatiSum": {
                                    "value": 93.0
                                }
                            },
                            {
                                "key": "Quber11",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 29.0
                                },
                                "max#StatiMax": {
                                    "value": 29.0
                                },
                                "min#StatiMin": {
                                    "value": 29.0
                                },
                                "sum#StatiSum": {
                                    "value": 29.0
                                }
                            },
                            {
                                "key": "Quber12",
                                "doc_count": 1,
                                "avg#StatiAvg": {
                                    "value": 74.0
                                },
                                "max#StatiMax": {
                                    "value": 74.0
                                },
                                "min#StatiMin": {
                                    "value": 74.0
                                },
                                "sum#StatiSum": {
                                    "value": 74.0
                                }
                            },
                            {
                                "key": "Quber2",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 51.0
                                },
                                "max#StatiMax": {
                                    "value": 78.0
                                },
                                "min#StatiMin": {
                                    "value": 25.0
                                },
                                "sum#StatiSum": {
                                    "value": 357.0
                                }
                            },
                            {
                                "key": "Quber3",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 48.142857142857146
                                },
                                "max#StatiMax": {
                                    "value": 74.0
                                },
                                "min#StatiMin": {
                                    "value": 28.0
                                },
                                "sum#StatiSum": {
                                    "value": 337.0
                                }
                            },
                            {
                                "key": "Quber4",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 53.285714285714285
                                },
                                "max#StatiMax": {
                                    "value": 76.0
                                },
                                "min#StatiMin": {
                                    "value": 25.0
                                },
                                "sum#StatiSum": {
                                    "value": 373.0
                                }
                            },
                            {
                                "key": "Quber5",
                                "doc_count": 7,
                                "avg#StatiAvg": {
                                    "value": 47.285714285714285
                                },
                                "max#StatiMax": {
                                    "value": 70.0
                                },
                                "min#StatiMin": {
                                    "value": 25.0
                                },
                                "sum#StatiSum": {
                                    "value": 331.0
                                }
                            },
                            {
                                "key": "Quber6",
                                "doc_count": 6,
                                "avg#StatiAvg": {
                                    "value": 41.5
                                },
                                "max#StatiMax": {
                                    "value": 78.0
                                },
                                "min#StatiMin": {
                                    "value": 20.0
                                },
                                "sum#StatiSum": {
                                    "value": 249.0
                                }
                            },
                            {
                                "key": "Quber7",
                                "doc_count": 5,
                                "avg#StatiAvg": {
                                    "value": 43.0
                                },
                                "max#StatiMax": {
                                    "value": 61.0
                                },
                                "min#StatiMin": {
                                    "value": 21.0
                                },
                                "sum#StatiSum": {
                                    "value": 215.0
                                }
                            },
                            {
                                "key": "Quber8",
                                "doc_count": 5,
                                "avg#StatiAvg": {
                                    "value": 42.2
                                },
                                "max#StatiMax": {
                                    "value": 61.0
                                },
                                "min#StatiMin": {
                                    "value": 22.0
                                },
                                "sum#StatiSum": {
                                    "value": 211.0
                                }
                            },
                            {
                                "key": "Quber9",
                                "doc_count": 4,
                                "avg#StatiAvg": {
                                    "value": 54.75
                                },
                                "max#StatiMax": {
                                    "value": 65.0
                                },
                                "min#StatiMin": {
                                    "value": 39.0
                                },
                                "sum#StatiSum": {
                                    "value": 219.0
                                }
                            }
                        ]
                    }
                }
            ]
        }
    }
}


5.10、🍝 获取总条数、最大、最小、求和或平均值等

使用示例(获取符合条件的数据总条数):

//类似SQL:SELECT COUNT(1) FROM A
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetCount = _quickElasticSearch.GetCount(queryCon);

//异步
var retGetCountAsync = await _quickElasticSearch.GetCountAsync(queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": 132
}


POST /test_index/_count
{
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    }
}


{
    "count": 75,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    }
}



使用示例(获取某字段的最大值、最小值、求和、平均值和总数等):

//类似SQL:SELECT COUNT(1),SUM(col1),MAX(col1),MIN(col1),AVG(col1) FROM A
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetStatiCount = _quickElasticSearch.GetStatiCount(m => m.UserAge, queryCon);

//异步
var retGetStatiCountAsync = await _quickElasticSearch.GetStatiCountAsync(m => m.UserAge, queryCon);


{
    "Item1": true,
    "Item2": "",
    "Item3": {
        "Count": 132,
        "Sum": 6842,
        "Max": 79,
        "Min": 21,
        "Avg": 51.83
    }
}


POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiCount":{
            "value_count":{
                "field":"UserAge"
            }
        },
        "StatiSum":{
            "sum":{
                "field":"UserAge"
            }
        },
        "StatiMax":{
            "max":{
                "field":"UserAge"
            }
        },
        "StatiMin":{
            "min":{
                "field":"UserAge"
            }
        },
        "StatiAvg":{
            "avg":{
                "field":"UserAge"
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "avg#StatiAvg": {
            "value": 46.92
        },
        "max#StatiMax": {
            "value": 79.0
        },
        "value_count#StatiCount": {
            "value": 75
        },
        "min#StatiMin": {
            "value": 20.0
        },
        "sum#StatiSum": {
            "value": 3519.0
        }
    }
}



使用示例(获取某些字段相加的多个总和):

//类似SQL:SELECT SUM(col1)分类1,SUM(col2+col3+col4)分类2 FROM A
//统计的字段条件
var fieldCons = new List()
{
    new() { AsName="分类1",Fields=new List{ "Money" } },
    new() { AsName="分类2",Fields=new List{ "Money", "MoneyOth" } }
};
//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetStatiSumMulti = _quickElasticSearch.GetStatiSumMulti(fieldCons, true, queryCon,
    (errMsg) =>
    {
        var thisErrMsg = errMsg;
    });

//异步
var retGetStatiSumMultiAsync = await _quickElasticSearch.GetStatiSumMultiAsync(fieldCons, true, queryCon,
    async (errMsg) =>
    {
        var thisErrMsg = errMsg;

        await Task.CompletedTask;
    });


{
    "Item1": true,
    "Item2": "",
    "Item3": {
        "分类1": 754.63,
        "分类2": 1658.02
    }
}


# 获取某些字段相加的多个总和
# 类似SQL:SELECT SUM(Money)分类1,SUM(Money+MoneyOth)分类2 FROM A WHERE Id >= 1
# 此处只是做了一个演示,真正做到上述SQL的统计效果,需要在后台程序处理,也就是说“分类1”和“分类2”是2次请求,分类2这次的请求需要将StatiSumMoney和StatiSumMoneyOth统计的结果相加才能得到最总的总和
POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "aggs":{
        "StatiSumMoney":{
            "sum":{
                "field":"Money"
            }
        },
        "StatiSumMoneyOth":{
            "sum":{
                "field":"MoneyOth"
            }
        }
    },
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":1
                        }
                    }
                }
            ]
        }
    },
    "size":0
}


{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 75,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "sum#StatiSumMoneyOth": {
            "value": 491.69998598098755
        },
        "sum#StatiSumMoney": {
            "value": 407.17499363422394
        }
    }
}



6、💎 Quick.ElasticSearch.Furion 方法

首先通过依赖注入在构造函数中得到IQuickElasticSearch的实例,具体可参照上述文档中的相关示例。

6.1、📔 依赖注入方法

方法名称 方法说明 方法参数 备注
AddElasticSearch 添加依赖注入服务 重载 1:()
重载 2:()
该方法为IServiceCollection的扩展方法,目的是实现IQuickElasticSearch接口的注册。
重载 1 代表注册的是IQuickElasticSearch服务;
重载 2 传入了泛型 T,代表的是注册了IQuickElasticSearch服务的同时,也注册了 T 这个服务(T这个泛型类中,在构造函数中实现了IQuickElasticSearch接口服务,该方法可能在控制台程序使用的情况较多)。
GetInstance 获取某接口服务的实例 重载 1:()
重载 2:()
该方法为IServiceProviderIHost的扩展方法,目的是获取某接口或类的实例。
重载 1 是基于IServiceProvider的扩展;
重载 2 是基于IHost的扩展。

6.2、💸 获取 ElasticSearch 客户端

方法名称 方法说明 方法参数 返回值 备注
GetClient 获取 ElasticSearch 客户端 () 返回 ElasticClient 对象

6.3、📕 切换连接方法

方法名称 方法说明 方法参数 返回值 备注
ChangeConn 切换连接 (int connId) 切换配置文件中某个连接配置,connId 为连接 Id

6.4、📗 获取检查创建删除索引方法

方法名称 方法说明 方法参数 返回值 备注
GetIndexs 获取所有索引 (bool isIncludeSystemIndex = false) List isIncludeSystemIndex:是否包含系统索引
GetIndexsAsync 获取所有索引(异步) (bool isIncludeSystemIndex = false) List isIncludeSystemIndex:是否包含系统索引
IndexIsExist 检查索引是否存在 (string indexName) 返回 bool 类型 indexName:索引名称
IndexIsExistAsync 检查索引是否存在(异步) (string indexName) 返回 bool 类型 indexName:索引名称
CreateIndex 如果同名索引不存在则创建索引 (int numberOfReplicas = 0, int numberOfShards = 5) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 numberOfReplicas:默认副本数量,如果是单实例,注意改成 0
numberOfShards:默认分片数量
CreateIndexAsync 如果同名索引不存在则创建索引(异步) (int numberOfReplicas = 0, int numberOfShards = 5) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息
DeleteIndex 删除索引 (string indexName) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 indexName:索引名称
DeleteIndexAsync 删除索引(异步) (string indexName) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 indexName:索引名称

6.5、📘 获取索引健康状态方法

方法名称 方法说明 方法参数 返回值 备注
GetHealthStatus 获取索引健康状态 (string indexName) 返回 Health 枚举对象(Green:0、Yellow:1、Red:2) indexName:索引名称
GetHealthStatusAsync 获取索引健康状态 (string indexName) 返回 Health 枚举对象(Green:0、Yellow:1、Red:2) indexName:索引名称

6.6、📙 添加数据方法

方法名称 方法说明 方法参数 返回值 备注
InsertModel 添加一条数据 (T docData) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
docData:数据
InsertModelAsync 添加一条数据(异步) (T docData) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
docData:数据
InsertModels 添加多条数据 (List docDatas, Action, string, List>? insertError = null) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
docDatas:数据
insertError:错误回调方法(参数 1 为出错的数据集合,参数 2 为出错的提示信息,参数 3 为修改的所有数据集合)
InsertModelsAsync 添加多条数据(异步) (List docDatas, Action, string, List>? insertError = null) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
docDatas:数据
insertError:错误回调方法(参数 1 为出错的数据集合,参数 2 为出错的提示信息,参数 3 为修改的所有数据集合)
InsertModelsBatch 添加多条数据(分批次) (List docDatas, Action, string, List>? insertError = null, int? batchCount = 1000, string backOffTime = "30s", int? backOffRetries = 5) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
docDatas:数据
insertError:错误回调方法(参数 1 为出错的数据集合,参数 2 为出错的提示信息,参数 3 为修改的所有数据集合)
batchCount:每批次添加的数据条数
backOffTime:集群繁忙,报 429 错误码的时候,等待多久进行重试,默认为:30s
backOffRetries:重试次数,默认为:5 次

6.7、📚 修改数据方法

方法名称 方法说明 方法参数 返回值 备注
UpdateModelFieldsById 根据主键 Id 修改一个或多个字段的值 (object id, object updateObj) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
id:主键 Id 值
updateObj:修改的动态对象,格式如:new { col1 = 123, col2 = 456},需要注意的是,填写的字段一定要和实体一致,如果修改的字段在数据中不存在,会自动增加这个字段的
UpdateModelFieldsByIdAsync 根据主键 Id 修改一个或多个字段的值(异步) (object id, object updateObj) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
id:主键 Id 值
updateObj:修改的动态对象,格式如:new { col1 = 123, col2 = 456},需要注意的是,填写的字段一定要和实体一致,如果修改的字段在数据中不存在,会自动增加这个字段的
UpdateModelFieldsByCon 根据查询条件修改一个或多个字段的值 (List> esQueryList, object updateObj) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
esQueryList:动态查询条件
updateObj:修改的动态对象,格式如:new { col1 = 123, col2 = 456},需要注意的是,填写的字段一定要和实体一致,如果修改的字段在数据中不存在,会自动增加这个字段的
UpdateModelFieldsByConAsync 根据查询条件修改一个或多个字段的值(异步) (List> esQueryList, object updateObj) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
esQueryList:动态查询条件
updateObj:修改的动态对象,格式如:new { col1 = 123, col2 = 456},需要注意的是,填写的字段一定要和实体一致,如果修改的字段在数据中不存在,会自动增加这个字段的
UpdateModel 修改一条数据 (T docData) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
docData:数据
UpdateModelAsync 修改一条数据(异步) (T docData) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
docData:数据
UpdateModels 修改多条数据 (List docDatas, Action, string, List>? updateError = null) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
docDatas:数据
updateError:错误回调方法(参数 1 为出错的数据集合,参数 2 为出错的提示信息,参数 3 为修改的所有数据集合)
UpdateModelsAsync 修改多条数据(异步) (List docDatas, Action, string, List>? updateError = null) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
docDatas:数据
updateError:错误回调方法(参数 1 为出错的数据集合,参数 2 为出错的提示信息,参数 3 为修改的所有数据集合)

6.8、📓 删除数据方法

方法名称 方法说明 方法参数 返回值 备注
DeleteModel 删除数据(根据 Id 字段) (object dataId) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
dataId:要删除的数据 ID
DeleteModelAsync 删除数据(根据 Id 字段,异步) (object dataId) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 T:泛型对象
dataId:要删除的数据 ID
DeleteModelBy 删除符合条件的所有数据 (List>? esQueryList = null) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 params:动态查询条件
DeleteModelByAsync 删除符合条件的所有数据(异步) (List>? esQueryList = null) 返回元组对象,包含 2 个值,第一个为是否成功,第二个为失败的提示信息 params:动态查询条件

6.9、📒 获取数据方法

方法名称 方法说明 方法参数 返回值 备注
GetModelsAll 获取所有数据 (Expression>? field = null, bool isDesc = true) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List的集合 T:泛型对象
field:排序字段,格式如:m => m.OptTime
isDesc:是否为降序(默认为降序)
GetModelsAllAsync 获取所有数据(异步) (Expression>? field = null, bool isDesc = true) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List的集合 T:泛型对象
field:排序字段,格式如:m => m.OptTime
isDesc:是否为降序(默认为降序)
GetModels 获取匹配条件的所有数据 (Expression>? field = null, bool isDesc = true, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List的集合 T:泛型对象
field:排序字段,格式如:m => m.OptTime
isDesc:是否为降序(默认为降序)
esQueryList:动态查询条件
GetModelsAsync 获取匹配条件的所有数据(异步) (Expression>? field = null, bool isDesc = true, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List的集合 T:泛型对象
field:排序字段,格式如:m => m.OptTime
isDesc:是否为降序(默认为降序)
esQueryList:动态查询条件
GetModelsFields 获取匹配条件的所有数据(返回指定字段的值) (List speFields, Expression>? field = null, bool isDesc = true, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合 T:泛型对象
speFields:只返回设置字段的值,如:new List { "SampleId", "SampleName" }
field:排序字段,格式如:m => m.OptTime
isDesc:是否为降序(默认为降序)
esQueryList:动态查询条件
GetModelsFieldsAsync 获取匹配条件的所有数据(返回指定字段的值,异步) (List speFields, Expression>? field = null, bool isDesc = true, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合 T:泛型对象
speFields:只返回设置字段的值,如:new List { "SampleId", "SampleName" }
field:排序字段,格式如:m => m.OptTime
isDesc:是否为降序(默认为降序)
esQueryList:动态查询条件
GetModel 获取一条数据(根据某字段执行等于查询) (Expression> field, object fieldVal) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 T 的数据对象 T:泛型对象
field:查询的字段
fieldVal:查询的字段对应的值
GetModelAsync 获取一条数据(根据某字段执行等于查询,异步) (Expression> field, object fieldVal) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 T 的数据对象 T:泛型对象
field:查询的字段
fieldVal:查询的字段对应的值
GetPagerAsync 获取分页数据 (EsPagerConModel esPagerCon, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 EsPagerModel的数据对象 T:泛型对象
esPagerCon:分页条件
esQueryList:动态查询条件
GetPagerAsync 获取分页数据(异步) (EsPagerConModel esPagerCon, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 EsPagerModel的数据对象 T:泛型对象
esPagerCon:分页条件
esQueryList:动态查询条件
GetPagerFields 获取分页数据(返回指定字段的值) (EsPagerConModel esPagerCon, List speFields, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 EsPagerDicModel 的数据对象 T:泛型对象
esPagerCon:分页条件
speFields:只返回设置字段的值,如:new List { "SampleId", "SampleName" }
esQueryList:动态查询条件
GetPagerFieldsAsync 获取分页数据(返回指定字段的值,异步) (EsPagerConModel esPagerCon, List speFields, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 EsPagerDicModel 的数据对象 T:泛型对象
esPagerCon:分页条件
speFields:只返回设置字段的值,如:new List { "SampleId", "SampleName" }
esQueryList:动态查询条件

6.10、📋 分组统计查询方法

方法名称 方法说明 方法参数 返回值 备注
GetGroupValues 单个字段分组,并返回该字段的所有值集合 (Expression> field, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List的集合,格式如:["分类 1","分类 2"] T:泛型对象
field:要分组的字段,格式如:m=>m.col1
esQueryList:动态查询条件
GetGroupValuesAsync 单个字段分组,并返回该字段的所有值集合,异步 (Expression> field, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List的集合,格式如:["分类 1","分类 2"] T:泛型对象
field:要分组的字段,格式如:m=>m.col1
esQueryList:动态查询条件
GetGroupCount 单个字段分组,并返回该字段的所有值和数量集合 (Expression> field, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"分类 1","Count":100}] T:泛型对象
field:要分组的字段,格式如:m=>m.col1
esQueryList:动态查询条件
GetGroupCountAsync 单个字段分组,并返回该字段的所有值和数量集合,异步 (Expression> field, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"分类 1","Count":100}] T:泛型对象
field:要分组的字段,格式如:m=>m.col1
esQueryList:动态查询条件
GetGroupCountSmma 单个字段分组,并返回另一个字段的总和、最大值、最小值和平均值 (Expression> field, Expression> fieldStati, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"分类 1","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] T:泛型对象
field:要分组的字段,格式如:m=>m.col1
fieldStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.col2
esQueryList:动态查询条件
GetGroupCountSmmaAsync 单个字段分组,并返回另一个字段的总和、最大值、最小值和平均值,异步 (Expression> field, Expression> fieldStati, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"分类 1","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] T:泛型对象
field:要分组的字段,格式如:m=>m.col1
fieldStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.col2
esQueryList:动态查询条件
GetGroupsCount 多个字段分组 (List groupFields, List>? esQueryList = null, string countKeyName = "GroupCount") 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"col1":"val1","col2":"val2","GroupCount":100}] T:泛型对象
groupFields:要分组的字段集合,如:new List { "col1", "col2" }
esQueryList:动态查询条
countKeyName:返回统计数量的 Key 名称,默认为:GroupCount 件
GetGroupsCountAsync 多个字段分组,异步 (List groupFields, List>? esQueryList = null, string countKeyName = "GroupCount") 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"col1":"val1","col2":"val2","GroupCount":100}] T:泛型对象
groupFields:要分组的字段集合,如:new List { "col1", "col2" }
esQueryList:动态查询条
countKeyName:返回统计数量的 Key 名称,默认为:GroupCount 件
GetGroupsDateMonth 日期字段分组,按月统计 (Expression> field, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
esQueryList:动态查询条件
GetGroupsDateMonthAsync 日期字段分组,按月统计,异步 (Expression> field, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
esQueryList:动态查询条件
GetGroupsDate 日期字段分组,支持按年、季度、月份、星期、天、小时、分、秒等维度进行统计 (Expression> field, string dateInterval = "1M", string dateFormat = "yyyy-MM", List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
dateInterval:统计的日期间隔,默认为 1M(支持的表达式有 1y:1 年、1q:1 季度、1M:1 个月、1w:1 星期、1d:1 天、1h:1 小时、1m:1 分钟、1s:1 秒钟)
dateFormat:统计的日期格式化方式,默认为 yyyy-MM(注意大小写,完整的格式化格式为 yyyy-MM-dd HH:mm:ss)
esQueryList:动态查询条件
GetGroupsDateAsync 日期字段分组,支持按年、季度、月份、星期、天、小时、分、秒等维度进行统计,异步 (Expression> field, string dateInterval = "1M", string dateFormat = "yyyy-MM", List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
dateInterval:统计的日期间隔,默认为 1M(支持的表达式有 1y:1 年、1q:1 季度、1M:1 个月、1w:1 星期、1d:1 天、1h:1 小时、1m:1 分钟、1s:1 秒钟)
dateFormat:统计的日期格式化方式,默认为 yyyy-MM(注意大小写,完整的格式化格式为 yyyy-MM-dd HH:mm:ss)
esQueryList:动态查询条件
GetGroupsDateMonthSmma 日期字段分组,按月统计,并返回另一个字段的总和、最大值、最小值和平均值 (Expression> field, Expression> fieldGroupStati, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
fieldGroupStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price
esQueryList:动态查询条件
GetGroupsDateMonthSmmaAsync 日期字段分组,按月统计,并返回另一个字段的总和、最大值、最小值和平均值,异步 (Expression> field, Expression> fieldGroupStati, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
fieldGroupStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price
esQueryList:动态查询条件
GetGroupsDateSmma 日期字段分组,并返回另一个字段的总和、最大值、最小值和平均值 (Expression> field, Expression> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
fieldGroupStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price
dateInterval:统计的日期间隔,默认为 1M(支持的表达式有 1y:1 年、1q:1 季度、1M:1 个月、1w:1 星期、1d:1 天、1h:1 小时、1m:1 分钟、1s:1 秒钟)
dateFormat:统计的日期格式化方式,默认为 yyyy-MM(注意大小写,完整的格式化格式为 yyyy-MM-dd HH:mm:ss)
esQueryList:动态查询条件
GetGroupsDateSmmaAsync 日期字段分组,并返回另一个字段的总和、最大值、最小值和平均值,异步 (Expression> field, Expression> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
fieldGroupStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price
dateInterval:统计的日期间隔,默认为 1M(支持的表达式有 1y:1 年、1q:1 季度、1M:1 个月、1w:1 星期、1d:1 天、1h:1 小时、1m:1 分钟、1s:1 秒钟)
dateFormat:统计的日期格式化方式,默认为 yyyy-MM(注意大小写,完整的格式化格式为 yyyy-MM-dd HH:mm:ss)
esQueryList:动态查询条件
GetGroupsDateMonthOneYear 日期字段分组,按某年 1~12 月统计每个月的某个字段每个月的总和以及这一年的总和 (Expression> field, Expression> fieldGroup, Expression> fieldGroupStati, int year, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为分组统计数组,格式如:[["小米",3006,0,0,0,1100,0,0,0,1200,0,0,0,5306]],其中第一个值为 fieldGroup 的分组名称;后面第二个到第十三个值为 1~12 月份的总和;第十四个值为 1~12 月份的总和 T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
fieldGroup:另一个要分组的字段,格式如:m=>m.TypeName
fieldGroupStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price
year:统计的年份,如 2021
esQueryList:动态查询条件
GetGroupsDateMonthOneYearAsync 日期字段分组,按某年 1~12 月统计每个月的某个字段每个月的总和以及这一年的总和,异步 (Expression> field, Expression> fieldGroup, Expression> fieldGroupStati, int year, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为分组统计数组,格式如:[["小米",3006,0,0,0,1100,0,0,0,1200,0,0,0,5306]],其中第一个值为 fieldGroup 的分组名称;后面第二个到第十三个值为 1~12 月份的总和;第十四个值为 1~12 月份的总和 T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
fieldGroup:另一个要分组的字段,格式如:m=>m.TypeName
fieldGroupStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price
year:统计的年份,如 2021
esQueryList:动态查询条件
GetGroupsDateMonth 日期字段分组,按月统计,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值 (Expression> field, Expression> fieldGroup, Expression> fieldGroupStati, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100,"Group":[{"Name":"碎石","Count":3,"Sum":1000,"Max":100,"Min":10,"Avg":50}]}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
fieldGroup:另一个要分组的字段,格式如:m=>m.TypeName
fieldGroupStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price
esQueryList:动态查询条件
GetGroupsDateMonthAsync 日期字段分组,按月统计,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值,异步 (Expression> field, Expression> fieldGroup, Expression> fieldGroupStati, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100,"Group":[{"Name":"碎石","Count":3,"Sum":1000,"Max":100,"Min":10,"Avg":50}]}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
fieldGroup:另一个要分组的字段,格式如:m=>m.TypeName
fieldGroupStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price
esQueryList:动态查询条件
GetGroupsDateSub 日期字段分组,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值 (Expression> field, Expression> fieldGroup, Expression> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100,"Group":[{"Name":"碎石","Count":3,"Sum":1000,"Max":100,"Min":10,"Avg":50}]}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
fieldGroup:另一个要分组的字段,格式如:m=>m.TypeName
fieldGroupStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price
dateInterval:统计的日期间隔,默认为 1M(支持的表达式有 1y:1 年、1q:1 季度、1M:1 个月、1w:1 星期、1d:1 天、1h:1 小时、1m:1 分钟、1s:1 秒钟)
dateFormat:统计的日期格式化方式,默认为 yyyy-MM(注意大小写,完整的格式化格式为 yyyy-MM-dd HH:mm:ss)
esQueryList:动态查询条件
GetGroupsDateSubAsync 日期字段分组,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值,异步 (Expression> field, Expression> fieldGroup, Expression> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为 List>的集合,格式如:[{"Name":"2021-01","Count":100,"Group":[{"Name":"碎石","Count":3,"Sum":1000,"Max":100,"Min":10,"Avg":50}]}] T:泛型对象
field:要分组的字段(日期字段),格式如:m=>m.CreateTime
fieldGroup:另一个要分组的字段,格式如:m=>m.TypeName
fieldGroupStati:要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price
dateInterval:统计的日期间隔,默认为 1M(支持的表达式有 1y:1 年、1q:1 季度、1M:1 个月、1w:1 星期、1d:1 天、1h:1 小时、1m:1 分钟、1s:1 秒钟)
dateFormat:统计的日期格式化方式,默认为 yyyy-MM(注意大小写,完整的格式化格式为 yyyy-MM-dd HH:mm:ss)
esQueryList:动态查询条件

6.11、📜 获取总条数、最大、最小、求和或平均值等方法

方法名称 方法说明 方法参数 返回值 备注
GetCount 获取符合条件的数据总条数 (Expression> field, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为总条数 T:泛型对象
esQueryList:动态查询条件
GetCountAsync 获取符合条件的数据总条数(异步) (Expression> field, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为总条数 T:泛型对象
esQueryList:动态查询条件
GetStatiCount 获取某字段的最大值、最小值、求和、平均值和总数等 (Expression> field, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为统计数据,格式为{"Count":100,"Sum":999,"Max":150,"Min":10,"Avg":200} T:泛型对象
field:要求和、最大值、最小值和平均值的字段 B,格式如:m=>m.col1
esQueryList:动态查询条件
GetStatiCountAsync 获取某字段的最大值、最小值、求和、平均值和总数等(异步) (Expression> field, List>? esQueryList = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为统计数据,格式为{"Count":100,"Sum":999,"Max":150,"Min":10,"Avg":200} T:泛型对象
field:要求和、最大值、最小值和平均值的字段 B,格式如:m=>m.col1
esQueryList:动态查询条件
GetStatiSumMulti 获取某些字段相加的多个总和 (List fieldCons, bool is2Dec, List>? esQueryList = null, Action? error = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为统计数据,格式为{"分类 1":100,"分类 2":200} T:泛型对象
fieldCons:统计的某些字段多个总和的条件集合
is2Dec:是否将总和结果保留 2 为小数,false 则将保持原小数返回
esQueryList:动态查询条件
error:错误回调方法(参数 1 为出错的提示信息)
GetStatiSumMultiAsync 获取某些字段相加的多个总和(异步) (List fieldCons, bool is2Dec, List>? esQueryList = null, Func? error = null) 返回元组对象,包含 3 个值,第一个为是否成功,第二个为失败的提示信息,第三个为统计数据,格式为{"分类 1":100,"分类 2":200} T:泛型对象
fieldCons:统计的某些字段多个总和的条件集合
is2Dec:是否将总和结果保留 2 为小数,false 则将保持原小数返回
esQueryList:动态查询条件
error:错误回调方法(参数 1 为出错的提示信息)

6.12、💰 查询条件

在上面的方法中,基本都涉及到了关于查询条件(List>? esQueryList = null)的参数,在此专门对查询条件的使用进行说明。

创建查询条件:

我们使用QuickElasticSearchExtension.CreateEsQueryModel静态方法来创建一个查询条件集合对象,如下所示:

//创建查询条件集合对象
//CreateEsQueryModel方法需要传入泛型T,第一个参数代表和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)、第二个参数代表当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)、第三个参数代表当前组合查询条件的回调函数,用于添加具体条件
//下述代表的是创建了一个查询条件集合对象queryCon,并且设置了该对象第一个集合中的2个查询条件,类似SQL:(Id >= 340506710462542 AND UserAge (
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 340506710462542 AND UserAge  m.Id, 340506710462542)
                .AddLte(m => m.UserAge, 60);
        });

组合条件:

上述的例子,我们只声明了一个组合条件,如果需要多个组合条件一起使用,则直接调用AddEsQueryModel方法继续添加组合条件即可(该方法为上述创建的条件集合对象queryCon的扩展方法【链式操作】),该方法的参数和CreateEsQueryModel一模一样,如下所示的代码代表(Id 大于或等于 340506710462542 并且 UserAge 小于或等于 60) 或者(Id 等于 340506710462539 或者 Id 等于 340506710462538)

var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 340506710462542 AND UserAge  m.Id, 340506710462542)
                .AddLte(m => m.UserAge, 60);
        })
    //添加另一个组合条件
    .AddEsQueryModel(
        EsQueryType.Or,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.Or,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id = 340506710462539 OR Id = 340506710462538)
            queryCon
                .AddEqu(m => m.Id, 340506710462539)
                .AddEqu(m => m.Id, 340506710462538);
        });

//同步
var retDeleteModelBy = _quickElasticSearch.DeleteModelBy(queryCon);

//异步
var retDeleteModelByAsync = await _quickElasticSearch.DeleteModelByAsync(queryCon);

更多条件:

如果我们想添加更多条件,直接使用方法AddEsQueryModel追加即可,如下所示:

var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(……,……,……)

    //第二个组合条件
    .AddEsQueryModel(……,……,……)

    //第三个组合条件
    .AddEsQueryModel(……,……,……)

    //第四个组合条件
    .AddEsQueryModel(……,……,……)

    //第五个组合条件
    .AddEsQueryModel(……,……,……)

    //第n个组合条件
    .……;

EsQueryModel 说明:

  • PrevConType:和上一个 EsQueryModel 之间的连接类型(AND 或 OR 操作,默认为 AND 操作);
  • QueryType:查询条件集合的连接类型,针对 QueryCon 而言(AND 或 OR 操作,默认为 AND 操作);
  • QueryCon:查询条件集合。

查询条件扩展方法:

方法名称 方法说明 方法参数 返回值 备注
CreateEsQueryModel 创建查询条件集合对象 (EsQueryType prevConType = EsQueryType.And, EsQueryType queryType = EsQueryType.And, Action, QueryContainer>>>? queryConAction = null) List> T:泛型对象
prevConType:和上一个 EsQueryModel 之间的连接类型(AND 或 OR 操作,默认为 AND 操作)
queryType:当前组合查询条件集合的连接类型,针对 QueryCon 而言(AND 或 OR 操作,默认为 AND 操作)
queryConAction:当前组合查询条件的回调函数,用于添加具体条件
AddEsQueryModel 添加查询条件 (this List> queryModels, EsQueryType prevConType = EsQueryType.And, EsQueryType queryType = EsQueryType.And, Action, QueryContainer>>>? queryConAction = null) List> T:泛型对象
prevConType:和上一个 EsQueryModel 之间的连接类型(AND 或 OR 操作,默认为 AND 操作)
queryType:当前组合查询条件集合的连接类型,针对 QueryCon 而言(AND 或 OR 操作,默认为 AND 操作)
queryConAction:当前组合查询条件的回调函数,用于添加具体条件
GetSort 获取排序条件 (string field, bool isDesc = true) Func, SortDescriptor> T:泛型对象
field:排序字段
isDesc:是否为降序(默认为降序)
GetSort 获取排序条件 (string field, bool isDesc = true) Func, SortDescriptor> T:泛型对象
field:排序字段
isDesc:是否为降序(默认为降序)
CreateAndOrs 创建 AND 或 OR 条件集合 () List, QueryContainer>> T:泛型对象

使用示例:var queryCon = QuickElasticSearchExtension.CreateAndOrs();

AddEqu 添加等于查询条件= (this List, QueryContainer>> andOrCons, Expression> field, object value) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.Id
value:查询的具体值

使用示例:queryCon.AddEqu(m => m.Id, "7");

AddIn 添加 IN 查询条件 (this List, QueryContainer>> andOrCons, Expression> field, Listvalues) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.Id
values:查询的具体值

使用示例:queryCon.AddNotEqu(m => m.Id, new List{"7","21","28"});

AddNotEqu 添加不等于查询条件= (this List, QueryContainer>> andOrCons, Expression> field, object value) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.Id
value:查询的具体值

使用示例:queryCon.AddNotEqu(m => m.Id, "7");

AddNotEqu 添加不等于查询条件= (this List, QueryContainer>> andOrCons, Expression> field, Listvalues) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.Id
values:查询的具体值

使用示例:queryCon.AddNotEqu(m => m.Id, new List{"7","21","28"});

AddLike 添加模糊查询条件 LIKE (this List, QueryContainer>> andOrCons, Expression> fields, string value) List, QueryContainer>> T:泛型对象
fields:字段表达式,如:m => m.Id 或 m=>new [] {m.EngPart, m.TestType}
value:查询的关键字

使用示例:queryCon.AddLike(m => m.EngPart, "测试的关键字");

AddGt 添加大于查询条件> (this List, QueryContainer>> andOrCons, Expression> field, double value) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.Id
value:查询的具体值

使用示例:queryCon.AddGt(m => m.Id, 28);

AddGt 添加大于查询条件> (this List, QueryContainer>> andOrCons, Expression> field, DateTime value) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.CreateTime
value:查询的具体值

使用示例:queryCon.AddGt(m => m.CreateTime, "2022-10-12 14:10:26");

AddGte 添加大于或等于查询条件>= (this List, QueryContainer>> andOrCons, Expression> field, double value) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.Id
value:查询的具体值

使用示例:queryCon.AddGte(m => m.Id, 28);

AddGte 添加大于或等于查询条件>= (this List, QueryContainer>> andOrCons, Expression> field, DateTime value) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.CreateTime
value:查询的具体值

使用示例:queryCon.AddGte(m => m.CreateTime, "2022-10-12 14:10:26");

AddLt 添加小于查询条件 (this List, QueryContainer>> andOrCons, Expression> field, double value) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.Id
value:查询的具体值

使用示例:queryCon.AddLt(m => m.Id, 28);

AddLt 添加小于查询条件 (this List, QueryContainer>> andOrCons, Expression> field, DateTime value) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.CreateTime
value:查询的具体值

使用示例:queryCon.AddLt(m => m.CreateTime, "2022-10-12 14:10:26");

AddLte 添加小于或等于查询条件 (this List, QueryContainer>> andOrCons, Expression> field, double value) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.Id
value:查询的具体值

使用示例:queryCon.AddLte(m => m.Id, 28);

AddLte 添加小于或等于查询条件 (this List, QueryContainer>> andOrCons, Expression> field, DateTime value) List, QueryContainer>> T:泛型对象
field:字段表达式,如:m => m.CreateTime
value:查询的具体值

使用示例:queryCon.AddLte(m => m.CreateTime, "2022-10-12 14:10:26");

分页查询条件:

我们在使用分页方法的时候,第一个参数需要传入分页查询参数EsPagerConModel,如下所示:

//分页条件
var pagerCon = new EsPagerConModel
{
    PageIndex = 1,
    PageSize = 15,
    OrderField = "Id",
    OrderType = "desc"
};

//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetPager = _quickElasticSearch.GetPager(pagerCon, queryCon);

//异步
var retGetPagerAsync = await _quickElasticSearch.GetPagerAsync(pagerCon, queryCon);

EsPagerConModel 说明:

  • PageIndex:当前页码(默认为 1);
  • PageSize:当前页数量(默认为 15);
  • OrderField:排序字段;
  • OrderType:排序方式(默认为 desc)。

统计查询条件:

我们在使用GetStatiSumMultiGetStatiSumMultiAsync方法获取某些字段相加的多个总和的统计的时候,第一个参数需要传入EsStatisticalSumMultiModel,如下所示:

//类似SQL:SELECT SUM(col1)分类1,SUM(col2+col3+col4)分类2 FROM A

//统计的字段条件
var fieldCons = new List()
{
    new() { AsName="分类1",Fields=new List{ "Money" } },
    new() { AsName="分类2",Fields=new List{ "Money", "MoneyOth" } }
};

//定义查询条件:(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作,默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型,针对QueryCon而言(AND或OR操作,默认为AND操作)
        (queryCon) =>
        {
            //查询条件:(Id >= 1)
            queryCon.AddGte(m => m.Id, 1);
        });

//同步
var retGetStatiSumMulti = _quickElasticSearch.GetStatiSumMulti(fieldCons, true, queryCon,
    (errMsg) =>
    {
        var thisErrMsg = errMsg;
    });

//异步
var retGetStatiSumMultiAsync = await _quickElasticSearch.GetStatiSumMultiAsync(fieldCons, true, queryCon,
    async (errMsg) =>
    {
        var thisErrMsg = errMsg;

        await Task.CompletedTask;
    });

EsStatisticalSumMultiModel 说明:

  • AsName(string):某几个字段相加总和最后返回的 Key 名称;
  • Fields(List):某几个字段相加的字段集合。

文章来源于互联网:ElasticSearch之Quick.ElasticSearch.Furion组件的使用

THE END
分享
二维码