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

qubernet

2024-04-27 帮助1人

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

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

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

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

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

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

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

Quick.ElasticSearch.Furion：依赖于.Net6 、Furion

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

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

1、🍹 更新日志

1.0.3
- 调整(简化)了方法GetModelsAll、GetModelsAllAsync、GetModels、GetModelsAsync、GetModelsFields和GetModelsFieldsAsync的排序参数传入方式；
- 调整了InsertModels和InsertModelsAsync方法的内部实现，判断是否有添加失败采用了Errors属性以及ItemsWithErrors错误对象集合；
- 增加了InsertModelsBatch方法，分批添加数据，适用于大批量添加数据的情况；
- 调整了GetGroupValues、GetGroupValuesAsync、GetGroupCount、GetGroupCountAsync、GetGroupCountSmma、GetGroupCountSmmaAsync、GetGroupsCount、GetGroupsCountAsync、GetGroupsDate、GetGroupsDateAsync、GetGroupsDateSmma、GetGroupsDateSmmaAsync、GetGroupsDateSub、GetGroupsDateSubAsync、GetStatiCount、GetStatiCountAsync、GetStatiSumMulti和GetStatiSumMultiAsync方法的内部实现；
- 调整了AddLike扩展方式的实现方式为 Wildcard；
- 增加了AddIn条件查询扩展方法，类似 SQL 的 IN 条件；
- 对GetStatiSumMulti和GetStatiSumMultiAsync方法进行了性能优化，减少了 Http 请求次数。
1.0.2
- 方法GetGroupsCount和GetGroupsCountAsync增加了第三个参数，以便于用户自定义返回统计数量的 Key 名称，默认为：GroupCount；
- 增加了获取ElasticClient客户端对象方法：GetClient;
- 增加获取所有索引的方法GetIndexs和GetIndexsAsync；
- 增加了根据主键 Id 修改一个或多个字段值的方法UpdateModelFieldsById和UpdateModelFieldsByIdAsync；
- 增加了根据查询条件修改一个或多个字段值的方法UpdateModelFieldsByCon和UpdateModelFieldsByConAsync；
- 增加了根据 Id 字段获取一条数据的方法GetModel和GetModelAsync；
- 调整了InsertModels和InsertModelsAsync方法的实现，由原来的Bulk(BulkAsync)调整为了IndexMany(IndexManyAsync)方式。
1.0.1
- 增加了扩展方法 CreateEsQueryModel 和 AddEsQueryModel；
- 重写了查询条件的使用方式；
- 将所有涉及到查询条件的方法都进行了调整；
- 简化了GetStatiSumMulti和GetStatiSumMultiAsync方法所需参数的传入方式;
- 方法GetStatiSumMulti和GetStatiSumMultiAsync增加了第三个参数，错误回调方法。
1.0.0
- 全新组件重磅发布；
- 支持切换连接功能;
- 支持检查创建删除索引；
- 支持获取索引健康状态；
- 支持添加数据；
- 支持修改数据；
- 支持删除数据；
- 支持获取数据；
- 支持分组统计查询；
- 支持获取总条数、最大、最小、求和或平均值等。

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

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

组件使用对比：

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

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

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

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

使用 NEST 组件的代码如下：

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

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

功能说明：

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

3、🍖 安装

安装命令如下所示：

Install-Package Quick.ElasticSearch.Furion

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

学新通

4、🧀 配置

4.1、🥞 配置`appsettings.json`

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

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

配置说明：

属性名称	属性说明	是否必填	备注
MaxQueryCount	全局设置 ElasticSearch 索引查询的最大条数，ElasticSearch 默认为 10000		注意：此处我们最好设置为 2000000000，原因是 ElasticSearch 内部默认一次性最多返回 10000 条数据

Default	是否为默认连接		默认为 false
ConnId	连接 Id(请确保该 Id 的唯一性)	√	如果要动态切换连接配置，请确保该 Id 有值并且唯一
DefaultIndex	默认索引
UserName	连接账户	√
Password	连接密码	√
Uri	连接地址集合，数据类型为 List<string>	√

4.2、🍞 实体特性

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

using Nest;
namespace Quick.ElasticSearch.TestFurion
{
[QuickElasticSearchConfig(indexName: "test_index", primaryKey: "Id")]
public class TestElasticSearchModel
{
public long Id { get; set; }
[Keyword]
public string UserType { get; set; }
public int UserId { get; set; }
[Keyword]
public string UserName { get; set; }
public int UserAge { get; set; }
public float Money { get; set; }
public float MoneyOth { get; set; }
public DateTime CreateTime { get; set; }
}
}

说明：

indexName：索引名称；
primaryKey：主键名称。

4.3、🥐 配置 Program.cs

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

[STAThread]
static void Main()
{
ApplicationConfiguration.Initialize();
//初始化Furion
Serve.Run(GenericRunOptions.DefaultSilence);
}

public void ConfigureServices(IServiceCollection services)
{
//注册FrmMain窗体类
services.AddScoped<FrmMain>();
//注入IQuickElasticSearch的方式
//通过AddElasticSearch添加依赖注入
services.AddElasticSearch();
使用构造函数获取实例的方式：
通过AddElasticSearch添加依赖注入，并注册TestConsumerClassForDI类
//services.AddElasticSearch<TestConsumerClassForDI>()
//DI容器生成serviceProvider
var serviceProvider = services.BuildServiceProvider();
//通过serviceProvider获取MainForm的注册实例
var frmMain = serviceProvider.GetRequiredService<FrmMain>();
//var frmMain = (FrmMain)serviceProvider.GetService(typeof(FrmMain));
Application.Run(frmMain);
}

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

4.4、🍝 获取依赖注入对象

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

public partial class FrmMain : Form
{
//定义IQuickElasticSearch对象
private readonly IQuickElasticSearch _quickElasticSearch;
public FrmMain(IQuickElasticSearch quickElasticSearch)
{
InitializeComponent();
//设置IQuickElasticSearch对象
_quickElasticSearch = quickElasticSearch;
}
}

5、🥪 具体使用

5.1、📮 获取 ElasticSearch 客户端

使用示例：

_quickElasticSearch.GetClient();

5.2、🌮 切换连接

使用示例：

_quickElasticSearch.ChangeConn(2);

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

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

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

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

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

使用示例(创建索引)：

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

使用示例(删除索引)：

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

5.4、🥙 获取索引健康状态

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

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

5.5、🧆 添加数据

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

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

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

var testDatas = new List<TestElasticSearchModel>
{
new TestElasticSearchModel(),
new TestElasticSearchModel()
};
//同步
var retInsertModels = _quickElasticSearch.InsertModels(testDatas, (errList, errMsg, allList) =>
{
var thisErrList = errList;
var thisErrMsg = errMsg;
});
//异步
var retInsertModelsAsync = await _quickElasticSearch.InsertModelsAsync(testDatas, async (errList, errMsg, allList) =>
{
var thisErrList = errList;
var thisErrMsg = errMsg;
await Task.CompletedTask;
});

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

var testDatas = new List<TestElasticSearchModel>
{
new TestElasticSearchModel(),
new TestElasticSearchModel()
};
var retInsertModelsBatch = _quickElasticSearch.InsertModelsBatch(testDatas, (errList, errMsg, allList) =>
{
var thisErrList = errList;
var thisErrMsg = errMsg;
},
//每批次添加的数据条数
1000,
//集群繁忙，报429错误码的时候，等待多久进行重试
"5s",
//重试次数
2);

5.6、🥗 修改数据

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

//类似SQL：UPDATE A SET col1=123,col2=456 WHERE Id=1
//同步
var retUpdateModelFieldById = _quickElasticSearch.UpdateModelFieldsById<TestElasticSearchModel>(342235158519882, new { UserAge = 32, Money = 66.66 });
//异步
var retUpdateModelFieldByIdAsync = await _quickElasticSearch.UpdateModelFieldsByIdAsync<TestElasticSearchModel>(342235158519882, new { UserAge = 32, Money = 66.66 });

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

//类似SQL：UPDATE A SET col1=123,col2=456 WHERE (Id=1 OR Id=2)
//定义查询条件：(Id = 342235158519882 OR Id = 342235158519883)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,
EsQueryType.Or,
(queryCon) =>
{
//查询条件：(Id = 342235158519882 OR Id = 342235158519883)
queryCon
.AddEqu(m => m.Id, 342235158519882)
.AddEqu(m => m.Id, 342235158519883);
});
//异步
var retUpdateModelFieldsByCon = _quickElasticSearch.UpdateModelFieldsByCon<TestElasticSearchModel>(queryCon, new { UserAge = 13, Money = 996.33 });
//同步
var retUpdateModelFieldsByConAsync = await _quickElasticSearch.UpdateModelFieldsByConAsync<TestElasticSearchModel>(queryCon, new { UserAge = 14, Money = 997.44 });

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

var rand = new Random(Guid.NewGuid().GetHashCode());
var testData = new TestElasticSearchModel
{
Id = 1,
UserId = rand.Next(1, 9999),
UserName = "Quber1",
UserAge = rand.Next(20, 80),
Money = (float)2.429,
MoneyOth = (float)3.556,
CreateTime = DateTime.Now
};
var testDataAsync = new TestElasticSearchModel
{
Id = 3,
UserId = rand.Next(1, 9999),
UserName = "Jack1",
UserAge = rand.Next(20, 80),
Money = (float)2.429,
MoneyOth = (float)3.556,
CreateTime = DateTime.Now
};
//同步
var retUpdateModel = _quickElasticSearch.UpdateModel(testData);
//异步
var retUpdateModelAsync = await _quickElasticSearch.UpdateModelAsync(testDataAsync);

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

var rand = new Random(Guid.NewGuid().GetHashCode());
var testDatas = new List<TestElasticSearchModel>
{
new TestElasticSearchModel
{
Id = 1,
UserId = rand.Next(1, 9999),
UserName = "Quber1",
UserAge = rand.Next(20, 80),
Money = (float)2.429,
MoneyOth = (float)3.556,
CreateTime = DateTime.Now
},
new TestElasticSearchModel
{
Id = 3,
UserId = rand.Next(1, 9999),
UserName = "Jack1",
UserAge = rand.Next(20, 80),
Money = (float)2.429,
MoneyOth = (float)3.556,
CreateTime = DateTime.Now
},
new TestElasticSearchModel
{
Id = 4,
UserId = rand.Next(1, 9999),
UserName = "Jack1",
UserAge = rand.Next(20, 80),
Money = (float)2.429,
MoneyOth = (float)3.556,
CreateTime = DateTime.Now
}
};
//同步
var retUpdateModels = _quickElasticSearch.UpdateModels(testDatas, (errList, errMsg, allList) =>
{
var thisErrList = errList;
var thisErrMsg = errMsg;
});
//异步
var retUpdateModelsAsync = await _quickElasticSearch.UpdateModelsAsync(testDatas, async (errList, errMsg, allList) =>
{
var thisErrList = errList;
var thisErrMsg = errMsg;
await Task.CompletedTask;
});

5.7、🥘 删除数据

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

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

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

//定义查询条件：(Id >= 340506710462542 AND UserAge <= 60) OR (Id = 340506710462539 OR Id = 340506710462538)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id >= 340506710462542 AND UserAge <= 60)
queryCon
.AddGte(m => m.Id, 340506710462542)
.AddLte(m => m.UserAge, 60);
})
//添加另一个组合条件
.AddEsQueryModel(
EsQueryType.Or,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.Or,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id = 340506710462539 OR Id = 340506710462538)
queryCon
.AddEqu(m => m.Id, 340506710462539)
.AddEqu(m => m.Id, 340506710462538);
});
//同步
var retDeleteModelBy = _quickElasticSearch.DeleteModelBy<TestElasticSearchModel>(queryCon);
//异步
var retDeleteModelByAsync = await _quickElasticSearch.DeleteModelByAsync<TestElasticSearchModel>(queryCon);

5.8、🍲 获取数据

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

//排序条件：ORDER BY Id DESC
//同步
var retGetModelsAll = _quickElasticSearch.GetModelsAll<TestElasticSearchModel>(m => m.Id, true);
//异步
var retGetModelsAllAsync = await _quickElasticSearch.GetModelsAllAsync<TestElasticSearchModel>(m => m.CreateTime, false);

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

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

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

//排序条件：ORDER BY Id DESC
//定义查询条件：(Id >= 340506710462535 AND UserAge <= 70)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id >= 340506710462535 AND UserAge <= 70)
queryCon
.AddGte(m => m.Id, 340506710462535)
.AddLte(m => m.UserAge, 70);
});
//同步
var retGetModels = _quickElasticSearch.GetModels<TestElasticSearchModel>(m => m.Id, true, queryCon);
//异步
var retGetModelsAsync = await _quickElasticSearch.GetModelsAsync<TestElasticSearchModel>(m => m.Id, true, queryCon);

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

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

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

//排序条件：ORDER BY Id DESC
//定义查询条件：(Id >= 340506710462535 AND UserAge <= 70)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id >= 340506710462535 AND UserAge <= 70)
queryCon
.AddGte(m => m.Id, 340506710462535)
.AddLte(m => m.UserAge, 70);
});
//同步
var retGetModelsFields = _quickElasticSearch.GetModelsFields<TestElasticSearchModel>(new List<string> { "UserId", "UserName", "UserAge" }, m => m.Id, true, queryCon);
//异步
var retGetModelsFieldsAsync = await _quickElasticSearch.GetModelsFieldsAsync<TestElasticSearchModel>(new List<string> { "UserId", "UserName", "UserAge" }, m => m.Id, true, queryCon);

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

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

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

//同步
var retGetModel = _quickElasticSearch.GetModel<TestElasticSearchModel>(342235158519882);
//异步
var retGetModelAsync = await _quickElasticSearch.GetModelAsync<TestElasticSearchModel>(342235158519883);

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

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

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

//同步
var retGetModel = _quickElasticSearch.GetModel<TestElasticSearchModel>(m => m.UserId, 340506710462542);
//异步
var retGetModelAsync = await _quickElasticSearch.GetModelAsync<TestElasticSearchModel>(m => m.UserId, 340506710462537);

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

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

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

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

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

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

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

//分页条件
var pagerCon = new EsPagerConModel
{
PageIndex = 1,
PageSize = 15,
OrderField = "Id",
OrderType = "desc"
};
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetPagerFields = _quickElasticSearch.GetPagerFields<TestElasticSearchModel>(pagerCon, new List<string> { "UserId", "UserName", "UserAge" }, queryCon);
//异步
var retGetPagerFieldsAsync = await _quickElasticSearch.GetPagerFieldsAsync<TestElasticSearchModel>(pagerCon, new List<string> { "UserId", "UserName", "UserAge" }, queryCon);

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

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

5.9、🥣 分组统计查询

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//类似SQL：SELECT col1,col2,COUNT(1) FROM A GROUP BY col1,col2
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsCount = _quickElasticSearch.GetGroupsCount<TestElasticSearchModel>(new List<string> { "UserName", "UserAge" }, queryCon);
//异步
var retGetGroupsCountAsync = await _quickElasticSearch.GetGroupsCountAsync<TestElasticSearchModel>(new List<string> { "UserName", "UserAge" }, queryCon);

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

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

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

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

//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDateMonth = _quickElasticSearch.GetGroupsDateMonth<TestElasticSearchModel>(m => m.CreateTime, queryCon);
//异步
var retGetGroupsDateMonthAsync = await _quickElasticSearch.GetGroupsDateMonthAsync<TestElasticSearchModel>(m => m.CreateTime, queryCon);

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

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

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

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

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

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

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

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

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

//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDateMonthSmma = _quickElasticSearch.GetGroupsDateMonthSmma<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, queryCon);
//异步
var retGetGroupsDateMonthSmmaAsync = await _quickElasticSearch.GetGroupsDateMonthSmmaAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, queryCon);

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

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

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

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

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

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

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

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

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

//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDateMonthOneYear = _quickElasticSearch.GetGroupsDateMonthOneYear<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, 2022, queryCon);
//异步
var retGetGroupsDateMonthOneYearAsync = await _quickElasticSearch.GetGroupsDateMonthOneYearAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, 2022, queryCon);

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

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

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

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

//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDateMonth = _quickElasticSearch.GetGroupsDateMonth<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, queryCon);
//异步
var retGetGroupsDateMonthAsync = await _quickElasticSearch.GetGroupsDateMonthAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, queryCon);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//类似SQL：SELECT SUM(col1)分类1,SUM(col2 col3 col4)分类2 FROM A
//统计的字段条件
var fieldCons = new List<EsStatisticalSumMultiModel>()
{
new() { AsName="分类1",Fields=new List<string>{ "Money" } },
new() { AsName="分类2",Fields=new List<string>{ "Money", "MoneyOth" } }
};
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetStatiSumMulti = _quickElasticSearch.GetStatiSumMulti<TestElasticSearchModel>(fieldCons, true, queryCon,
(errMsg) =>
{
var thisErrMsg = errMsg;
});
//异步
var retGetStatiSumMultiAsync = await _quickElasticSearch.GetStatiSumMultiAsync<TestElasticSearchModel>(fieldCons, true, queryCon,
async (errMsg) =>
{
var thisErrMsg = errMsg;
await Task.CompletedTask;
});

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

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

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

6、💎 Quick.ElasticSearch.Furion 方法

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

6.1、📔 依赖注入方法

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

6.2、💸 获取 ElasticSearch 客户端

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

6.3、📕 切换连接方法

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

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

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

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

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

6.6、📙 添加数据方法

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

6.7、📚 修改数据方法

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

6.8、📓 删除数据方法

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

6.9、📒 获取数据方法

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

6.10、📋 分组统计查询方法

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

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

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

6.12、💰 查询条件

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

创建查询条件：

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

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

组合条件：

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

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

更多条件：

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

var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(……,……,……)
//第二个组合条件
.AddEsQueryModel(……,……,……)
//第三个组合条件
.AddEsQueryModel(……,……,……)
//第四个组合条件
.AddEsQueryModel(……,……,……)
//第五个组合条件
.AddEsQueryModel(……,……,……)
//第n个组合条件
.……;

EsQueryModel 说明：

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

查询条件扩展方法：

分页查询条件：

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

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

EsPagerConModel 说明：

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

统计查询条件：

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

//类似SQL：SELECT SUM(col1)分类1,SUM(col2 col3 col4)分类2 FROM A
//统计的字段条件
var fieldCons = new List<EsStatisticalSumMultiModel>()
{
new() { AsName="分类1",Fields=new List<string>{ "Money" } },
new() { AsName="分类2",Fields=new List<string>{ "Money", "MoneyOth" } }
};
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件(默认创建了一个组合条件)
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型(AND或OR操作，默认为AND操作)
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言(AND或OR操作，默认为AND操作)
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetStatiSumMulti = _quickElasticSearch.GetStatiSumMulti<TestElasticSearchModel>(fieldCons, true, queryCon,
(errMsg) =>
{
var thisErrMsg = errMsg;
});
//异步
var retGetStatiSumMultiAsync = await _quickElasticSearch.GetStatiSumMultiAsync<TestElasticSearchModel>(fieldCons, true, queryCon,
async (errMsg) =>
{
var thisErrMsg = errMsg;
await Task.CompletedTask;
});

EsStatisticalSumMultiModel 说明：

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

这篇好文章是转载于：学新通技术网

方法名称	方法说明	方法参数	返回值	备注
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");