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

原创

qubernet 2022-10-30 18:08:09 ©著作权

文章标签 elasticsearch 大数据搜索引擎全文检索 java 文章分类 虚拟化云计算

©著作权归作者所有：来自51CTO博客作者qubernet的原创作品，请联系作者获取转载授权，否则将追究法律责任

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.Net和NEST等组件可以对 ElasticSearch 服务端进行各种操作。

但是，但是，但是，由于 ElasticSearch 提供的是各类 API 接口，并且查询参数(JSON)条件会有很深的嵌套，这就导致了Elasticsearch.Net和NEST等组件在使用的时候也有很深的内嵌条件，包括各种链式操作等，如果不是老手使用难度非常大，为了降低使用难度，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

调整(简化)了方法GetModelsAll、GetModelsAllAsync、GetModels、GetModelsAsync、GetModelsFields和GetModelsFieldsAsync的排序参数传入方式；
调整了InsertModels和InsertModelsAsync方法的内部实现，判断是否有添加失败采用了Errors属性以及ItemsWithErrors错误对象集合；
增加了InsertModelsBatch方法，分批添加数据，适用于大批量添加数据的情况；
调整了GetGroupValues、GetGroupValuesAsync、GetGroupCount、GetGroupCountAsync、GetGroupCountSmma、GetGroupCountSmmaAsync、GetGroupsCount、GetGroupsCountAsync、GetGroupsDate、GetGroupsDateAsync、GetGroupsDateSmma、GetGroupsDateSmmaAsync、GetGroupsDateSub、GetGroupsDateSubAsync、GetStatiCount、GetStatiCountAsync、GetStatiSumMulti和GetStatiSumMultiAsync方法的内部实现；
调整了AddLike扩展方式的实现方式为 Wildcard；
增加了AddIn条件查询扩展方法，类似 SQL 的 IN 条件；
对GetStatiSumMulti和GetStatiSumMultiAsync方法进行了性能优化，减少了 Http 请求次数。

1.0.2

方法GetGroupsCount和GetGroupsCountAsync增加了第三个参数，以便于用户自定义返回统计数量的 Key 名称，默认为：GroupCount；
增加了获取ElasticClient客户端对象方法：GetClient;
增加获取所有索引的方法GetIndexs和GetIndexsAsync；
增加了根据主键 Id 修改一个或多个字段值的方法UpdateModelFieldsById和UpdateModelFieldsByIdAsync；
增加了根据查询条件修改一个或多个字段值的方法UpdateModelFieldsByCon和UpdateModelFieldsByConAsync；
增加了根据 Id 字段获取一条数据的方法GetModel和GetModelAsync；
调整了InsertModels和InsertModelsAsync方法的实现，由原来的Bulk(BulkAsync)调整为了IndexMany(IndexManyAsync)方式。

1.0.1

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

1.0.0

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

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

该组件是基于NEST和Furion组件进行封装使用的，目的在于结合.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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, "1h", "yyyy-MM-dd HH:mm", queryCon);

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

使用 NEST 组件的代码如下：

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

            if (esQueryList != null && esQueryList.Count > 0)
            {
                //组装条件为&&或||关系
                for (int i = 0; i < esQueryList.Count; i++)
                {
                    if (esQueryList[i].QueryCon.Count > 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<Dictionary<string, object>>();

        var response = _client.Search<T>(s => s
            .Index(GetIndexName<T>())
            .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<Dictionary<string, object>>();

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

                    retGroup.Add(new Dictionary<string, object> {
                        { "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<string, object>
                {
                    { "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组件的使用_java_02

4、🧀 配置

4.1、🥞 配置`appsettings.json`

在appsettings.json配置文件中创建节点QuickElasticSearch>MaxQueryCount和QuickElasticSearchConfigs，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<string>	√

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<FrmMain>();

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

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

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

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

    Application.Run(frmMain);
}

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

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<TestElasticSearchModel>();

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

使用示例(删除索引)：

//同步
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<TestElasticSearchModel>
{
    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<TestElasticSearchModel>
{
    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<TestElasticSearchModel>(342235158519882, new { UserAge = 32, Money = 66.66 });

//异步
var retUpdateModelFieldByIdAsync = await _quickElasticSearch.UpdateModelFieldsByIdAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(queryCon, new { UserAge = 13, Money = 996.33 });

//同步
var retUpdateModelFieldsByConAsync = await _quickElasticSearch.UpdateModelFieldsByConAsync<TestElasticSearchModel>(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<TestElasticSearchModel>
{
    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<TestElasticSearchModel>(340504986927178);

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

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

//定义查询条件：(Id >= 340506710462542 AND UserAge <= 60) OR (Id = 340506710462539 OR Id = 340506710462538)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel<TestElasticSearchModel>(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
        (queryCon) =>
        {
            //查询条件：(Id >= 340506710462542 AND UserAge <= 60)
            queryCon
                .AddGte(m => 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<TestElasticSearchModel>(queryCon);

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

5.8、🍲 获取数据

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

//排序条件：ORDER BY Id DESC

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

//异步
var retGetModelsAllAsync = await _quickElasticSearch.GetModelsAllAsync<TestElasticSearchModel>(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 <= 70)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel<TestElasticSearchModel>(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
        (queryCon) =>
        {
            //查询条件：(Id >= 340506710462535 AND UserAge <= 70)
            queryCon
                .AddGte(m => m.Id, 340506710462535)
                .AddLte(m => m.UserAge, 70);
        });

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

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

# 获取匹配条件的所有数据
# 类似SQL：SELECT TOP 2000000000 * FROM A WHERE Id >= 340506710462535 AND UserAge <= 70 ORDER BY Id DESC
POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "from":0,
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":340506710462535
                        }
                    }
                },
                {
                    "range":{
                        "UserAge":{
                            "lte":70
                        }
                    }
                }
            ]
        }
    },
    "size":2000000000,
    "sort":[
        {
            "Id":{
                "order":"desc"
            }
        }
    ]
}

{
    "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 <= 70)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel<TestElasticSearchModel>(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
        (queryCon) =>
        {
            //查询条件：(Id >= 340506710462535 AND UserAge <= 70)
            queryCon
                .AddGte(m => m.Id, 340506710462535)
                .AddLte(m => m.UserAge, 70);
        });

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

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

# 获取匹配条件的所有数据(返回指定字段的值)
# 类似SQL：SELECT TOP 2000000000 'UserId','UserName','UserAge' FROM A WHERE Id >= 340506710462535 AND UserAge <= 70 ORDER BY Id DESC
POST /test_index/_search?typed_keys=true
{
    "track_total_hits":true,
    "from":0,
    "query":{
        "bool":{
            "must":[
                {
                    "range":{
                        "Id":{
                            "gte":340506710462535
                        }
                    }
                },
                {
                    "range":{
                        "UserAge":{
                            "lte":70
                        }
                    }
                }
            ]
        }
    },
    "size":2000000000,
    "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": 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<TestElasticSearchModel>(342235158519882);

//异步
var retGetModelAsync = await _quickElasticSearch.GetModelAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(m => m.UserId, 340506710462542);

//异步
var retGetModelAsync = await _quickElasticSearch.GetModelAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(pagerCon, queryCon);

//异步
var retGetPagerAsync = await _quickElasticSearch.GetPagerAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(pagerCon, new List<string> { "UserId", "UserName", "UserAge" }, queryCon);

//异步
var retGetPagerFieldsAsync = await _quickElasticSearch.GetPagerFieldsAsync<TestElasticSearchModel>(pagerCon, new List<string> { "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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.UserName, queryCon);

//异步
var retGetGroupValuesAsync = await _quickElasticSearch.GetGroupValuesAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.UserName, queryCon);

//异步
var retGetGroupCountAsync = await _quickElasticSearch.GetGroupCountAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.UserName, m => m.UserAge, queryCon);

//异步
var retGetGroupCountSmmaAsync = await _quickElasticSearch.GetGroupCountSmmaAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(new List<string> { "UserName", "UserAge" }, queryCon);

//异步
var retGetGroupsCountAsync = await _quickElasticSearch.GetGroupsCountAsync<TestElasticSearchModel>(new List<string> { "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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.CreateTime, queryCon);

//异步
var retGetGroupsDateMonthAsync = await _quickElasticSearch.GetGroupsDateMonthAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.CreateTime, "1m", "yyyy-MM-dd HH:mm", queryCon);

//异步
var retGetGroupsDateAsync = await _quickElasticSearch.GetGroupsDateAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, queryCon);

//异步
var retGetGroupsDateMonthSmmaAsync = await _quickElasticSearch.GetGroupsDateMonthSmmaAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, "1m", "yyyy-MM-dd HH:mm", queryCon);

//异步
var retGetGroupsDateSmmaAsync = await _quickElasticSearch.GetGroupsDateSmmaAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, 2022, queryCon);

//异步
var retGetGroupsDateMonthOneYearAsync = await _quickElasticSearch.GetGroupsDateMonthOneYearAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, queryCon);

//异步
var retGetGroupsDateMonthAsync = await _quickElasticSearch.GetGroupsDateMonthAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, "1h", "yyyy-MM-dd HH:mm", queryCon);

//异步
var retGetGroupsDateSubAsync = await _quickElasticSearch.GetGroupsDateSubAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(queryCon);

//异步
var retGetCountAsync = await _quickElasticSearch.GetCountAsync<TestElasticSearchModel>(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<TestElasticSearchModel>(
        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<TestElasticSearchModel>(m => m.UserAge, queryCon);

//异步
var retGetStatiCountAsync = await _quickElasticSearch.GetStatiCountAsync<TestElasticSearchModel>(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<EsStatisticalSumMultiModel>()
{
    new() { AsName="分类1",Fields=new List<string>{ "Money" } },
    new() { AsName="分类2",Fields=new List<string>{ "Money", "MoneyOth" } }
};
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel<TestElasticSearchModel>(
        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<TestElasticSearchModel>(fieldCons, true, queryCon,
    (errMsg) =>
    {
        var thisErrMsg = errMsg;
    });

//异步
var retGetStatiSumMultiAsync = await _quickElasticSearch.GetStatiSumMultiAsync<TestElasticSearchModel>(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：<T>()	该方法为IServiceCollection的扩展方法，目的是实现`IQuickElasticSearch`接口的注册。重载 1 代表注册的是IQuickElasticSearch服务；重载 2 传入了泛型 T，代表的是注册了IQuickElasticSearch服务的同时，也注册了 T 这个服务(T这个泛型类中，在构造函数中实现了IQuickElasticSearch接口服务，该方法可能在控制台程序使用的情况较多)。
GetInstance	获取某接口服务的实例	重载 1：() 重载 2：()	该方法为IServiceProvider或IHost的扩展方法，目的是获取某接口或类的实例。重载 1 是基于IServiceProvider的扩展；重载 2 是基于IHost的扩展。

6.2、💸 获取 ElasticSearch 客户端

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

6.3、📕 切换连接方法

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

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

方法名称	方法说明	方法参数	返回值	备注
GetIndexs	获取所有索引	(bool isIncludeSystemIndex = false)	List<CatIndicesRecord>	isIncludeSystemIndex：是否包含系统索引
GetIndexsAsync	获取所有索引(异步)	(bool isIncludeSystemIndex = false)	List<CatIndicesRecord>	isIncludeSystemIndex：是否包含系统索引
IndexIsExist	检查索引是否存在	(string indexName)	返回 bool 类型	indexName：索引名称
IndexIsExistAsync	检查索引是否存在(异步)	(string indexName)	返回 bool 类型	indexName：索引名称
CreateIndex	如果同名索引不存在则创建索引	<T>(int numberOfReplicas = 0, int numberOfShards = 5)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	numberOfReplicas：默认副本数量，如果是单实例，注意改成 0 numberOfShards：默认分片数量
CreateIndexAsync	如果同名索引不存在则创建索引(异步)	<T>(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>(T docData)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 docData：数据
InsertModelAsync	添加一条数据(异步)	<T>(T docData)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 docData：数据
InsertModels	添加多条数据	<T>(List<T> docDatas, Action<List<T>, string, List<T>>? insertError = null)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 docDatas：数据 insertError：错误回调方法(参数 1 为出错的数据集合，参数 2 为出错的提示信息，参数 3 为修改的所有数据集合)
InsertModelsAsync	添加多条数据(异步)	<T>(List<T> docDatas, Action<List<T>, string, List<T>>? insertError = null)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 docDatas：数据 insertError：错误回调方法(参数 1 为出错的数据集合，参数 2 为出错的提示信息，参数 3 为修改的所有数据集合)
InsertModelsBatch	添加多条数据(分批次)	<T>(List<T> docDatas, Action<List<T>, string, List<T>>? 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 修改一个或多个字段的值	<T>(object id, object updateObj)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 id：主键 Id 值 updateObj：修改的动态对象，格式如：new { col1 = 123, col2 = 456}，需要注意的是，填写的字段一定要和实体一致，如果修改的字段在数据中不存在，会自动增加这个字段的
UpdateModelFieldsByIdAsync	根据主键 Id 修改一个或多个字段的值(异步)	<T>(object id, object updateObj)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 id：主键 Id 值 updateObj：修改的动态对象，格式如：new { col1 = 123, col2 = 456}，需要注意的是，填写的字段一定要和实体一致，如果修改的字段在数据中不存在，会自动增加这个字段的
UpdateModelFieldsByCon	根据查询条件修改一个或多个字段的值	<T>(List<EsQueryModel<T>> esQueryList, object updateObj)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 esQueryList：动态查询条件 updateObj：修改的动态对象，格式如：new { col1 = 123, col2 = 456}，需要注意的是，填写的字段一定要和实体一致，如果修改的字段在数据中不存在，会自动增加这个字段的
UpdateModelFieldsByConAsync	根据查询条件修改一个或多个字段的值(异步)	<T>(List<EsQueryModel<T>> esQueryList, object updateObj)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 esQueryList：动态查询条件 updateObj：修改的动态对象，格式如：new { col1 = 123, col2 = 456}，需要注意的是，填写的字段一定要和实体一致，如果修改的字段在数据中不存在，会自动增加这个字段的
UpdateModel	修改一条数据	<T>(T docData)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 docData：数据
UpdateModelAsync	修改一条数据(异步)	<T>(T docData)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 docData：数据
UpdateModels	修改多条数据	<T>(List<T> docDatas, Action<List<T>, string, List<T>>? updateError = null)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 docDatas：数据 updateError：错误回调方法(参数 1 为出错的数据集合，参数 2 为出错的提示信息，参数 3 为修改的所有数据集合)
UpdateModelsAsync	修改多条数据(异步)	<T>(List<T> docDatas, Action<List<T>, string, List<T>>? updateError = null)	返回元组对象，包含 2 个值，第一个为是否成功，第二个为失败的提示信息	T：泛型对象 docDatas：数据 updateError：错误回调方法(参数 1 为出错的数据集合，参数 2 为出错的提示信息，参数 3 为修改的所有数据集合)

6.8、📓 删除数据方法

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

6.9、📒 获取数据方法

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

6.10、📋 分组统计查询方法

方法名称	方法说明	方法参数	返回值	备注
GetGroupValues	单个字段分组，并返回该字段的所有值集合	<T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<string>的集合，格式如：["分类 1","分类 2"]	T：泛型对象 field：要分组的字段，格式如：m=>m.col1 esQueryList：动态查询条件
GetGroupValuesAsync	单个字段分组，并返回该字段的所有值集合，异步	<T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<string>的集合，格式如：["分类 1","分类 2"]	T：泛型对象 field：要分组的字段，格式如：m=>m.col1 esQueryList：动态查询条件
GetGroupCount	单个字段分组，并返回该字段的所有值和数量集合	<T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"Name":"分类 1","Count":100}]	T：泛型对象 field：要分组的字段，格式如：m=>m.col1 esQueryList：动态查询条件
GetGroupCountAsync	单个字段分组，并返回该字段的所有值和数量集合，异步	<T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"Name":"分类 1","Count":100}]	T：泛型对象 field：要分组的字段，格式如：m=>m.col1 esQueryList：动态查询条件
GetGroupCountSmma	单个字段分组，并返回另一个字段的总和、最大值、最小值和平均值	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldStati, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"Name":"分类 1","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}]	T：泛型对象 field：要分组的字段，格式如：m=>m.col1 fieldStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.col2 esQueryList：动态查询条件
GetGroupCountSmmaAsync	单个字段分组，并返回另一个字段的总和、最大值、最小值和平均值，异步	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldStati, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"Name":"分类 1","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}]	T：泛型对象 field：要分组的字段，格式如：m=>m.col1 fieldStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.col2 esQueryList：动态查询条件
GetGroupsCount	多个字段分组	<T>(List<string> groupFields, List<EsQueryModel<T>>? esQueryList = null, string countKeyName = "GroupCount")	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"col1":"val1","col2":"val2","GroupCount":100}]	T：泛型对象 groupFields：要分组的字段集合，如：new List<string> { "col1", "col2" } esQueryList：动态查询条 countKeyName：返回统计数量的 Key 名称，默认为：GroupCount 件
GetGroupsCountAsync	多个字段分组，异步	<T>(List<string> groupFields, List<EsQueryModel<T>>? esQueryList = null, string countKeyName = "GroupCount")	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"col1":"val1","col2":"val2","GroupCount":100}]	T：泛型对象 groupFields：要分组的字段集合，如：new List<string> { "col1", "col2" } esQueryList：动态查询条 countKeyName：返回统计数量的 Key 名称，默认为：GroupCount 件
GetGroupsDateMonth	日期字段分组，按月统计	<T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100}]	T：泛型对象 field：要分组的字段(日期字段)，格式如：m=>m.CreateTime esQueryList：动态查询条件
GetGroupsDateMonthAsync	日期字段分组，按月统计，异步	<T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100}]	T：泛型对象 field：要分组的字段(日期字段)，格式如：m=>m.CreateTime esQueryList：动态查询条件
GetGroupsDate	日期字段分组，支持按年、季度、月份、星期、天、小时、分、秒等维度进行统计	<T>(Expression<Func<T, object>> field, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"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	日期字段分组，支持按年、季度、月份、星期、天、小时、分、秒等维度进行统计，异步	<T>(Expression<Func<T, object>> field, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"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	日期字段分组，按月统计，并返回另一个字段的总和、最大值、最小值和平均值	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroupStati, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}]	T：泛型对象 field：要分组的字段(日期字段)，格式如：m=>m.CreateTime fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price esQueryList：动态查询条件
GetGroupsDateMonthSmmaAsync	日期字段分组，按月统计，并返回另一个字段的总和、最大值、最小值和平均值，异步	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroupStati, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}]	T：泛型对象 field：要分组的字段(日期字段)，格式如：m=>m.CreateTime fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price esQueryList：动态查询条件
GetGroupsDateSmma	日期字段分组，并返回另一个字段的总和、最大值、最小值和平均值	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"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	日期字段分组，并返回另一个字段的总和、最大值、最小值和平均值，异步	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"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 月统计每个月的某个字段每个月的总和以及这一年的总和	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, int year, List<EsQueryModel<T>>? 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 月统计每个月的某个字段每个月的总和以及这一年的总和，异步	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, int year, List<EsQueryModel<T>>? 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	日期字段分组，按月统计，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"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	日期字段分组，按月统计，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值，异步	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"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	日期字段分组，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"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	日期字段分组，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值，异步	<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为 List<Dictionary<string, object>>的集合，格式如：[{"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	获取符合条件的数据总条数	<T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为总条数	T：泛型对象 esQueryList：动态查询条件
GetCountAsync	获取符合条件的数据总条数(异步)	<T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为总条数	T：泛型对象 esQueryList：动态查询条件
GetStatiCount	获取某字段的最大值、最小值、求和、平均值和总数等	<T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为统计数据，格式为{"Count":100,"Sum":999,"Max":150,"Min":10,"Avg":200}	T：泛型对象 field：要求和、最大值、最小值和平均值的字段 B，格式如：m=>m.col1 esQueryList：动态查询条件
GetStatiCountAsync	获取某字段的最大值、最小值、求和、平均值和总数等(异步)	<T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为统计数据，格式为{"Count":100,"Sum":999,"Max":150,"Min":10,"Avg":200}	T：泛型对象 field：要求和、最大值、最小值和平均值的字段 B，格式如：m=>m.col1 esQueryList：动态查询条件
GetStatiSumMulti	获取某些字段相加的多个总和	<T>(List<EsStatisticalSumMultiModel> fieldCons, bool is2Dec, List<EsQueryModel<T>>? esQueryList = null, Action<string>? error = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为统计数据，格式为{"分类 1":100,"分类 2":200}	T：泛型对象 fieldCons：统计的某些字段多个总和的条件集合 is2Dec：是否将总和结果保留 2 为小数，false 则将保持原小数返回 esQueryList：动态查询条件 error：错误回调方法(参数 1 为出错的提示信息)
GetStatiSumMultiAsync	获取某些字段相加的多个总和(异步)	<T>(List<EsStatisticalSumMultiModel> fieldCons, bool is2Dec, List<EsQueryModel<T>>? esQueryList = null, Func<string, Task>? error = null)	返回元组对象，包含 3 个值，第一个为是否成功，第二个为失败的提示信息，第三个为统计数据，格式为{"分类 1":100,"分类 2":200}	T：泛型对象 fieldCons：统计的某些字段多个总和的条件集合 is2Dec：是否将总和结果保留 2 为小数，false 则将保持原小数返回 esQueryList：动态查询条件 error：错误回调方法(参数 1 为出错的提示信息)

6.12、💰 查询条件

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

创建查询条件：

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

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

组合条件：

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

var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel<TestElasticSearchModel>(
        EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
        EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
        (queryCon) =>
        {
            //查询条件：(Id >= 340506710462542 AND UserAge <= 60)
            queryCon
                .AddGte(m => 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<TestElasticSearchModel>(queryCon);

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

更多条件：

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

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

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

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

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

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

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

EsQueryModel 说明：

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

查询条件扩展方法：

分页查询条件：

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

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

//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel<TestElasticSearchModel>(
        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<TestElasticSearchModel>(pagerCon, queryCon);

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

EsPagerConModel 说明：

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

统计查询条件：

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

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

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

//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
    //创建条件(默认创建了一个组合条件)
    .CreateEsQueryModel<TestElasticSearchModel>(
        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<TestElasticSearchModel>(fieldCons, true, queryCon,
    (errMsg) =>
    {
        var thisErrMsg = errMsg;
    });

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

        await Task.CompletedTask;
    });

EsStatisticalSumMultiModel 说明：

AsName(string)：某几个字段相加总和最后返回的 Key 名称；
Fields(List<string>)：某几个字段相加的字段集合。

上一篇：ElasticSearch之Windows中环境安装

下一篇：Docker之介绍与安装

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

方法名称	方法说明	方法参数	返回值	备注
CreateEsQueryModel	创建查询条件集合对象	(EsQueryType prevConType = EsQueryType.And, EsQueryType queryType = EsQueryType.And, Action<List<Func<QueryContainerDescriptor<T>, QueryContainer>>>? queryConAction = null)	List<EsQueryModel<T>>	T：泛型对象 prevConType：和上一个 EsQueryModel 之间的连接类型(AND 或 OR 操作，默认为 AND 操作) queryType：当前组合查询条件集合的连接类型，针对 QueryCon 而言(AND 或 OR 操作，默认为 AND 操作) queryConAction：当前组合查询条件的回调函数，用于添加具体条件
AddEsQueryModel	添加查询条件	<T>(this List<EsQueryModel<T>> queryModels, EsQueryType prevConType = EsQueryType.And, EsQueryType queryType = EsQueryType.And, Action<List<Func<QueryContainerDescriptor<T>, QueryContainer>>>? queryConAction = null)	List<EsQueryModel<T>>	T：泛型对象 prevConType：和上一个 EsQueryModel 之间的连接类型(AND 或 OR 操作，默认为 AND 操作) queryType：当前组合查询条件集合的连接类型，针对 QueryCon 而言(AND 或 OR 操作，默认为 AND 操作) queryConAction：当前组合查询条件的回调函数，用于添加具体条件

GetSort	获取排序条件	<T>(string field, bool isDesc = true)	Func<SortDescriptor<T>, SortDescriptor<T>>	T：泛型对象 field：排序字段 isDesc：是否为降序(默认为降序)
GetSort	获取排序条件	<T>(string field, bool isDesc = true)	Func<SortDescriptor<T>, SortDescriptor<T>>	T：泛型对象 field：排序字段 isDesc：是否为降序(默认为降序)
CreateAndOrs	创建 AND 或 OR 条件集合	<T>()	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象使用示例：var queryCon = QuickElasticSearchExtension.CreateAndOrs<T>();
AddEqu	添加等于查询条件=	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, object value)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.Id value：查询的具体值使用示例：queryCon.AddEqu(m => m.Id, "7");
AddIn	添加 IN 查询条件	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, List<object> values)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.Id values：查询的具体值使用示例：queryCon.AddNotEqu(m => m.Id, new List<object>{"7","21","28"});
AddNotEqu	添加不等于查询条件=	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, object value)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.Id value：查询的具体值使用示例：queryCon.AddNotEqu(m => m.Id, "7");
AddNotEqu	添加不等于查询条件=	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, List<object> values)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.Id values：查询的具体值使用示例：queryCon.AddNotEqu(m => m.Id, new List<object>{"7","21","28"});
AddLike	添加模糊查询条件 LIKE	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> fields, string value)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 fields：字段表达式，如：m => m.Id 或 m=>new [] {m.EngPart, m.TestType} value：查询的关键字使用示例：queryCon.AddLike(m => m.EngPart, "测试的关键字");
AddGt	添加大于查询条件>	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, double value)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.Id value：查询的具体值使用示例：queryCon.AddGt(m => m.Id, 28);
AddGt	添加大于查询条件>	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, DateTime value)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.CreateTime value：查询的具体值使用示例：queryCon.AddGt(m => m.CreateTime, "2022-10-12 14:10:26");
AddGte	添加大于或等于查询条件>=	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, double value)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.Id value：查询的具体值使用示例：queryCon.AddGte(m => m.Id, 28);
AddGte	添加大于或等于查询条件>=	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, DateTime value)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.CreateTime value：查询的具体值使用示例：queryCon.AddGte(m => m.CreateTime, "2022-10-12 14:10:26");
AddLt	添加小于查询条件<	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, double value)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.Id value：查询的具体值使用示例：queryCon.AddLt(m => m.Id, 28);
AddLt	添加小于查询条件<	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, DateTime value)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.CreateTime value：查询的具体值使用示例：queryCon.AddLt(m => m.CreateTime, "2022-10-12 14:10:26");
AddLte	添加小于或等于查询条件<=	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, double value)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.Id value：查询的具体值使用示例：queryCon.AddLte(m => m.Id, 28);
AddLte	添加小于或等于查询条件<=	<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, DateTime value)	List<Func<QueryContainerDescriptor<T>, QueryContainer>>	T：泛型对象 field：字段表达式，如：m => m.CreateTime value：查询的具体值使用示例：queryCon.AddLte(m => m.CreateTime, "2022-10-12 14:10:26");