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

  • ElasticSearch之Quick.ElasticSearch.Furion组件的使用已关闭评论
  • 12 次浏览
  • A+
所属分类:.NET技术
摘要

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


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

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

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

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

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

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

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

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

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

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

1、? 更新日志

  • 1.0.3

    • 调整(简化)了方法GetModelsAllGetModelsAllAsyncGetModelsGetModelsAsyncGetModelsFieldsGetModelsFieldsAsync的排序参数传入方式;

    • 调整了InsertModelsInsertModelsAsync方法的内部实现,判断是否有添加失败采用了Errors属性以及ItemsWithErrors错误对象集合;

    • 增加了InsertModelsBatch方法,分批添加数据,适用于大批量添加数据的情况;

    • 调整了GetGroupValuesGetGroupValuesAsyncGetGroupCountGetGroupCountAsyncGetGroupCountSmmaGetGroupCountSmmaAsyncGetGroupsCountGetGroupsCountAsyncGetGroupsDateGetGroupsDateAsyncGetGroupsDateSmmaGetGroupsDateSmmaAsyncGetGroupsDateSubGetGroupsDateSubAsyncGetStatiCountGetStatiCountAsyncGetStatiSumMultiGetStatiSumMultiAsync方法的内部实现;

    • 调整了AddLike扩展方式的实现方式为 Wildcard;

    • 增加了AddIn条件查询扩展方法,类似 SQL 的 IN 条件;

    • GetStatiSumMultiGetStatiSumMultiAsync方法进行了性能优化,减少了 Http 请求次数。

  • 1.0.2

    • 方法GetGroupsCountGetGroupsCountAsync增加了第三个参数,以便于用户自定义返回统计数量的 Key 名称,默认为:GroupCount;

    • 增加了获取ElasticClient客户端对象方法:GetClient;

    • 增加获取所有索引的方法GetIndexsGetIndexsAsync

    • 增加了根据主键 Id 修改一个或多个字段值的方法UpdateModelFieldsByIdUpdateModelFieldsByIdAsync

    • 增加了根据查询条件修改一个或多个字段值的方法UpdateModelFieldsByConUpdateModelFieldsByConAsync

    • 增加了根据 Id 字段获取一条数据的方法GetModelGetModelAsync

    • 调整了InsertModelsInsertModelsAsync方法的实现,由原来的Bulk(BulkAsync)调整为了IndexMany(IndexManyAsync)方式。

  • 1.0.1

    • 增加了扩展方法 CreateEsQueryModel 和 AddEsQueryModel;

    • 重写了查询条件的使用方式;

    • 将所有涉及到查询条件的方法都进行了调整;

    • 简化了GetStatiSumMultiGetStatiSumMultiAsync方法所需参数的传入方式;

    • 方法GetStatiSumMultiGetStatiSumMultiAsync增加了第三个参数,错误回调方法。

  • 1.0.0

    • 全新组件重磅发布;

    • 支持切换连接功能;

    • 支持检查创建删除索引;

    • 支持获取索引健康状态;

    • 支持添加数据;

    • 支持修改数据;

    • 支持删除数据;

    • 支持获取数据;

    • 支持分组统计查询;

    • 支持获取总条数、最大、最小、求和或平均值等。


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

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

组件使用对比:

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

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

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

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

使用 NEST 组件的代码如下:

/// <summary> /// 获取分组统计数据(日期字段分组,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值) /// </summary> /// <typeparam name="T"></typeparam> /// <param name="field">要分组的字段(日期字段),格式如:m=>m.CreateTime</param> /// <param name="fieldGroup">另一个要分组的字段,格式如:m=>m.TypeName</param> /// <param name="fieldGroupStati">要统计总和、最大值、最小值和平均值的字段,格式如:m=>m.Price</param> /// <param name="dateInterval">统计的日期间隔,默认为1M(支持的表达式有1y:1年、1q:1季度、1M:1个月、1w:1星期、1d:1天、1h:1小时、1m:1分钟、1s:1秒钟)</param> /// <param name="dateFormat">统计的日期格式化方式,默认为yyyy-MM(注意大小写,完整的格式化格式为yyyy-MM-dd HH:mm:ss)</param> /// <param name="esQueryList">动态查询条件</param> /// <returns>返回元组对象,包含3个值,第一个为是否成功,第二个为失败的提示信息,第三个为<![CDATA[List<Dictionary<string, object>>]]>的集合,格式如:[{"Name":"2021-01","Count":100,"Group":[{"Name":"碎石","Count":3,"Sum":1000,"Max":100,"Min":10,"Avg":50}]}]</returns> public (bool IsSucc, string ErrMsg, List<Dictionary<string, object>>? Data) GetGroupsDateSub<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null) where T : class, new() {     try     {         //查询条件         Func<QueryContainerDescriptor<T>, QueryContainer> query = q =>         {             QueryContainer ret = q;              if (esQueryList != null && esQueryList.Count > 0)             {                 //组装条件为&&或||关系                 for (int i = 0; i < esQueryList.Count; i++)                 {                     if (esQueryList[i].QueryCon.Count > 0)                     {                         if (i == 0)                         {                             ret = esQueryList[i].QueryType == EsQueryType.And ? q.Bool(b => b.Must(esQueryList[i].QueryCon)) : q.Bool(b => b.Should(esQueryList[i].QueryCon));                         }                         else                         {                             ret = esQueryList[i].PrevConType == EsQueryType.And ?                                 ret && (esQueryList[i].QueryType == EsQueryType.And ? q.Bool(b => b.Must(esQueryList[i].QueryCon)) : q.Bool(b => b.Should(esQueryList[i].QueryCon))) ://添加&&并且关系                                 ret || (esQueryList[i].QueryType == EsQueryType.And ? q.Bool(b => b.Must(esQueryList[i].QueryCon)) : q.Bool(b => b.Should(esQueryList[i].QueryCon))); //添加||或关系                         }                     }                 }             }              return ret;         };          var ret = new List<Dictionary<string, object>>();          var response = _client.Search<T>(s => s             .Index(GetIndexName<T>())             .Query(query)             .Aggregations(ag => ag                 .DateHistogram("StatiGroup", dh => dh                     .Field(field)                       //需要聚合分组的字段名称, 类型需要为date, 格式没有要求                     .CalendarInterval(dateInterval)     //时间间隔,此处设置为1个月(1y:1年、1q:1季度、1M:1个月、1w:1星期、1d:1天、1h:1小时、1m:1分钟、1s:1秒钟)                     .TimeZone("+08:00")                 //设置时区, 这样就相当于东八区的时间                     .Format(dateFormat)                 //返回值格式化,HH大写,不然不能区分上午、下午                     .MinimumDocumentCount(0)            //为空的话则填充0                     .Order(HistogramOrder.KeyAscending) //根据日期字段升序排列                      .Aggregations(ag => ag                         .Terms("StatiGroup-1", t => t                             .Field(fieldGroup)                             .Size(_allConfig.MaxQueryCount)                             .Order(o => o                                 .KeyAscending()  //按照分组字段升序排序                                 .CountAscending()//按照统计数量升序排序                             )                              //统计fieldStati字段的总和、最大值、最小值和平均值                             .Aggregations(ags => ags                                 .Sum("StatiSum", m => m.Field(fieldGroupStati))         //求和                                 .Max("StatiMax", m => m.Field(fieldGroupStati))         //最大值                                 .Min("StatiMin", m => m.Field(fieldGroupStati))         //最小值                                 .Average("StatiAvg", m => m.Field(fieldGroupStati))     //平均值                             )                         )                     )                 )             )             .TrackTotalHits(true)//TrackTotalHits必须设置为true,否则返回total总条数超过10000条时总是返回10000         );          if (response.IsValid)         {             //获取分组标识             var stati = response.Aggregations["StatiGroup"];             //获取分组后的集合             var statiItems = ((BucketAggregate)stati).Items;              foreach (var bucketMain in statiItems)             {                 var item = (DateHistogramBucket)bucketMain;                 var retGroup = new List<Dictionary<string, object>>();                  foreach (var bucket in ((Nest.BucketAggregate)(item.Values.ToList()[0])).Items)                 {                     var obj = (KeyedBucket<Object>)bucket;                      retGroup.Add(new Dictionary<string, object> {                         { "Name",obj.Key.ToString()!},                         { "Count",obj.DocCount??0},                         { "Sum",IsNotNull(obj.AverageBucket("StatiSum").Value)? ToDouble2Dec(obj.AverageBucket("StatiSum").Value!):0},                         { "Max",IsNotNull(obj.AverageBucket("StatiMax").Value)? ToDouble2Dec(obj.AverageBucket("StatiMax").Value!):0},                         { "Min",IsNotNull(obj.AverageBucket("StatiMin").Value)? ToDouble2Dec(obj.AverageBucket("StatiMin").Value!):0},                         { "Avg",IsNotNull(obj.AverageBucket("StatiAvg").Value)? ToDouble2Dec(obj.AverageBucket("StatiAvg").Value!):0},                     });                 }                  ret.Add(new Dictionary<string, object>                 {                     { "Name",item.KeyAsString},                     { "Count",item.DocCount??0},                     { "Group",retGroup}                 });             }         }          return (response.IsValid, !response.IsValid ? response.DebugInformation : string.Empty, ret);     }     catch (Exception ex)     {         return (false, ex.Message, null);     } } 

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

功能说明:

  • 根据配置文件读取 ElasticSearch 连接的各个配置(如:ElasticSearch 服务地址、账号和密码等);

  • 支持配置多个 ElasticSearch 的连接配置;

  • 支持动态切换 ElasticSearch 的连接配置;

  • 支持检查创建删除索引;

  • 支持获取索引健康状态;

  • 支持添加数据(单条、多条);

  • 支持修改数据(单条、多条);

  • 支持删除数据(根据 Id 删除、根据条件删除);

  • 支持获取数据(获取所有数据、获取所有满足条件的数据、获取所有满足条件并返回指定字段的数据、根据 Id 获取一条数据、获取分页的数据、获取分页并返回指定字段的数据);

  • 支持分组统计查询(统计单字段并返回该字段所有统计值、统计单字段并返回该字段所有统计值及对应的数量、统计单段并返回另一个字段的总和最大值最小值和平均值、统计多个字段并返回多个字段对应的值以及对应分组的数据数量、按月统计并返回每个月及其数量、获取分组统计数据【日期字段分组,支持按年、季度、月份、星期、天、小时、分、秒等维度进行统计】、获取分组统计数据【日期字段分组,按月统计,并返回另一个字段的总和、最大值、最小值和平均值】、获取分组统计数据【日期字段分组,并返回另一个字段的总和、最大值、最小值和平均值】、获取分组统计数据【日期字段分组,按某年 1~12 月统计每个月的某个字段每个月的总和以及这一年的总和】、获取分组统计数据【日期字段分组,按月统计,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值】、获取分组统计数据【日期字段分组,并按照另一个字段进行分组,统计其条数、总和、最大值、最小值和平均值】);

  • 支持获取总条数、最大、最小、求和或平均值等(获取符合条件的数据总条数、获取某字段的最大值最小值求和平均值和总数等、获取某些字段相加的多个总和)。


3、? 安装

安装命令如下所示:

Install-Package Quick.ElasticSearch.Furion 

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

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

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


4、? 配置

4.1、? 配置appsettings.json

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

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

配置说明:

属性名称 属性说明 是否必填 备注
MaxQueryCount 全局设置 ElasticSearch 索引查询的最大条数,ElasticSearch 默认为 10000 注意:此处我们最好设置为 2000000000,原因是 ElasticSearch 内部默认一次性最多返回 10000 条数据
Default 是否为默认连接 默认为 false
ConnId 连接 Id(请确保该 Id 的唯一性) 如果要动态切换连接配置,请确保该 Id 有值并且唯一
DefaultIndex 默认索引
UserName 连接账户
Password 连接密码
Uri 连接地址集合,数据类型为 List<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:()
该方法为IServiceProviderIHost的扩展方法,目的是获取某接口或类的实例。
重载 1 是基于IServiceProvider的扩展;
重载 2 是基于IHost的扩展。

6.2、? 获取 ElasticSearch 客户端

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

6.3、? 切换连接方法

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

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

方法名称 方法说明 方法参数 返回值 备注
GetIndexs 获取所有索引 (bool isIncludeSystemIndex = false) List<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)。

统计查询条件:

我们在使用GetStatiSumMultiGetStatiSumMultiAsync方法获取某些字段相加的多个总和的统计的时候,第一个参数需要传入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>):某几个字段相加的字段集合。