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。
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：查询条件集合。
查询条件扩展方法：
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| 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"); |
分页查询条件：
我们在使用分页方法的时候，第一个参数需要传入分页查询参数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>）：某几个字段相加的字段集合。
