EFCore中将IQueryable泛型对象提前转换成SQL语句
背景
在EFCore中有些时候我们不可避免需要将EFCore中使用Linq写的查询语句提前转换成SQL语句，特别是在写一些报表应用的时候特别适用，在我们的应用中我们可以将部分查询操作的语句通过Linq来写，然后再将其转换成SQL语句，将转换的SQL语句嵌入到其它SQL语句中，我们先来看看我们的是如何将IQueryable泛型对象直接转换成SQL语句的。
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Common;
using System.Linq;
using System.Reflection;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Query;
using Sunlight.Domain.Models;
using Sunlight.EFCore.Repositories;
#if NETCOREAPP2_2
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Query.Internal;
using Microsoft.EntityFrameworkCore.Storage;
#else
using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
#endif
namespace Sunlight.EFCore.Extensions {
/// <summary>
/// IQueryable类型的扩展方法
/// </summary>
public static class QueryableExtensions {
#if NETCOREAPP2_2
/// <summary>
/// 将查询语句转换成Sql, 便于进一步的Sql拼接
/// <seealso href="https://github.com/yangzhongke/ZackData.Net/blob/master/Tests.NetCore/IQueryableExtensions.cs" />
/// </summary>
/// <param name="query"></param>
/// <param name="dbCtx"></param>
/// <typeparam name="TEntity"></typeparam>
/// <returns></returns>
public static string ToSql<TEntity>(this IQueryable<TEntity> query, DbContext dbCtx) {
var modelGenerator = dbCtx.GetService<IQueryModelGenerator>();
var queryModel = modelGenerator.ParseQuery(query.Expression);
var databaseDependencies = dbCtx.GetService<DatabaseDependencies>();
var queryCompilationContext = databaseDependencies.QueryCompilationContextFactory.Create(false);
var modelVisitor = (RelationalQueryModelVisitor)queryCompilationContext.CreateQueryModelVisitor();
modelVisitor.CreateQueryExecutor<TEntity>(queryModel);
var sql = modelVisitor.Queries.First().ToString();
return sql;
}
#else
/// <summary>
/// 将查询语句转换成Sql, 便于进一步的Sql拼接
/// <seealso href="https://gist.github.com/rionmonster/2c59f449e67edf8cd6164e9fe66c545a#gistcomment-3109335" />
/// </summary>
/// <param name="query"></param>
/// <param name="dbCtx">数据库上下文</param>
/// <typeparam name="TEntity"></typeparam>
/// <returns></returns>
public static string ToSql<TEntity>(this IQueryable<TEntity> query, DbContext dbCtx = null) where TEntity : class {
return ToSql(query);
}
/// <summary>
/// 将查询语句转换成Sql, 便于进一步的Sql拼接
/// <seealso href="https://gist.github.com/rionmonster/2c59f449e67edf8cd6164e9fe66c545a#gistcomment-3109335" />
/// </summary>
/// <param name="query"></param>
/// <typeparam name="TEntity"></typeparam>
/// <returns></returns>
private static string ToSql<TEntity>(this IQueryable<TEntity> query) where TEntity : class {
using var enumerator = query.Provider.Execute<IEnumerable<TEntity>>(query.Expression).GetEnumerator();
var relationalCommandCache = enumerator.Private("_relationalCommandCache");
var selectExpression = relationalCommandCache.Private<SelectExpression>("_selectExpression");
var factory = relationalCommandCache.Private<IQuerySqlGeneratorFactory>("_querySqlGeneratorFactory");
var sqlGenerator = factory.Create();
var command = sqlGenerator.GetCommand(selectExpression);
var sql = command.CommandText;
return sql;
}
private static object Private(this object obj, string privateField) => obj?.GetType().GetField(privateField, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(obj);
private static T Private<T>(this object obj, string privateField) => (T)obj?.GetType().GetField(privateField, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(obj);
/// <summary>
/// 增加
/// </summary>
/// <param name="query"></param>
/// <typeparam name="TEntity"></typeparam>
/// <returns></returns>
public static (string, IReadOnlyDictionary<string, object>) ToSqlWithParams<TEntity>(this IQueryable<TEntity> query) {
using var enumerator = query.Provider.Execute<IEnumerable<TEntity>>(query.Expression).GetEnumerator();
var relationalCommandCache = enumerator.Private("_relationalCommandCache");
var selectExpression = relationalCommandCache.Private<SelectExpression>("_selectExpression");
var factory = relationalCommandCache.Private<IQuerySqlGeneratorFactory>("_querySqlGeneratorFactory");
var queryContext = enumerator.Private<RelationalQueryContext>("_relationalQueryContext");
var sqlGenerator = factory.Create();
var command = sqlGenerator.GetCommand(selectExpression);
var parametersDict = queryContext.ParameterValues;
var sql = command.CommandText;
return (sql, parametersDict);
}
#endif
}
}
在这个里面有个NETCOREAPP2_2的编译开关便于我们在EFCore2.2版本和EFCore3.1版本中分别使用不同的方法，我们首先来看在EFCore2.2版本中的这段用法，任何IQueryable<T>类型的查询表达式都可以使用ToSql方法将我们的查询表达式转换成最终的SQL语句，这个方法还必须传入当前的DbContext对象从而正确的转换，另外一种是EFCore3.1版本中的两种方法，其中一种是查询的时候不带变量的ToSql方法另外一种是带参数的ToSqlWithParams,下面我们着重来说明在Asp.Net Core中我们到底该怎么使用这几个方法。
使用
无论是在EFCore2.2和EFCore3.1 版本中不带参数的方法都很好理解，下面的例子主要来讲述EFCore3.1中如何执行带参数的ToSqlWithParams方法，我们来看下面的Linq方法
public async Task<int> PartConsumeStatisticAsync(DateTime? statisticDateTime) {
// 每个服务站，每个仓库 + 备件生成一条结转数据
var lastMonth = statisticDateTime ?? DateTime.Now;
lastMonth = new DateTime(lastMonth.AddMonths(-1).Year, lastMonth.AddMonths(-1).Month, 1);
await _partConsumeRepository.BatchDeleteAsync(c => c.Month == lastMonth);
var outTypes = new[] {
PartOutType.维修领料出库,
PartOutType.零售出库,
PartOutType.保养套餐销售出库,
PartOutType.延保销售出库,
PartOutType.二网调拨出库,
PartOutType.领用出库
};
var inTypes = new[] {
PartInType.维修退料入库,
PartInType.零售退货入库,
PartInType.保养套餐退货入库,
PartInType.延保销售退货入库
};
var partOuts = (from partOut in _partOutRepository.GetAll()
.Where(p => p.CreateTime.HasValue && p.CreateTime.Value.Year == lastMonth.Year && p.CreateTime.Value.Month == lastMonth.Month
//这里在EFCore 3.1 版本使用 outTypes.Contains(p.OutType) 会报错：Unable to cast object of type 'Microsoft.EntityFrameworkCore.Query.SqlExpressions.SqlParameterExpression'
//to type 'Microsoft.EntityFrameworkCore.Query.SqlExpressions.SqlConstantExpression'
// chery/home#4597
&& (p.OutType == PartOutType.维修领料出库 || p.OutType == PartOutType.零售出库 || p.OutType == PartOutType.保养套餐销售出库
|| p.OutType == PartOutType.延保销售出库 || p.OutType == PartOutType.二网调拨出库 || p.OutType == PartOutType.领用出库))
join detail in _partOutDetailRepository.GetAll() on partOut.Id equals detail.PartOutId
select new {
partOut.DealerId,
partOut.WarehouseId,
partOut.OutType,
detail.PartId,
detail.OutQuantity
}).GroupBy(p => new { p.DealerId, p.WarehouseId, p.PartId },
(k, g) => new {
k.DealerId,
k.WarehouseId,
k.PartId,
WXOutQuantity = g.Sum(s => s.OutType == PartOutType.维修领料出库 ? s.OutQuantity : 0),
LSOutQuantity = g.Sum(s => s.OutType == PartOutType.零售出库 ? s.OutQuantity : 0),
BYOutQuantity = g.Sum(s => s.OutType == PartOutType.保养套餐销售出库 ? s.OutQuantity : 0),
YBOutQuantity = g.Sum(s => s.OutType == PartOutType.延保销售出库 ? s.OutQuantity : 0),
EWOutQuantity = g.Sum(s => s.OutType == PartOutType.二网调拨出库 ? s.OutQuantity : 0),
LYOutQuantity = g.Sum(s => s.OutType == PartOutType.领用出库 ? s.OutQuantity : 0)
});
var partIns = (from partIn in _partInRepository.GetAll().Where(p => p.CreateTime.HasValue && p.CreateTime.Value.Year == lastMonth.Year && p.CreateTime.Value.Month == lastMonth.Month
//这里在EFCore 3.1 版本使用 inTypes.Contains(p.InType) 会报错 同上
&& (p.InType == PartInType.维修退料入库 || p.InType == PartInType.零售退货入库 || p.InType == PartInType.保养套餐退货入库 || p.InType == PartInType.延保销售退货入库))
join detail in _partInDetailRepository.GetAll() on partIn.Id equals detail.PartInId
select new {
partIn.DealerId,
partIn.WarehouseId,
partIn.InType,
detail.PartId,
detail.InQuantity
}).GroupBy(p => new {
p.DealerId,
p.WarehouseId,
p.PartId
}, (k, g) => new {
k.DealerId,
k.WarehouseId,
k.PartId,
WXInQuantity = g.Sum(s => s.InType == PartInType.维修退料入库 ? s.InQuantity : 0),
LSInQuantity = g.Sum(s => s.InType == PartInType.零售退货入库 ? s.InQuantity : 0),
BYInQuantity = g.Sum(s => s.InType == PartInType.保养套餐退货入库 ? s.InQuantity : 0),
YBInQuantity = g.Sum(s => s.InType == PartInType.延保销售退货入库 ? s.InQuantity : 0),
});
return await _partConsumeStatsRepository.GeneratePartConsume(partOuts, partIns, lastMonth);
}
这里面partIns和partOuts是两个IQueryable的匿名对象的集合，这里我们先来看看使用 var partInsSql=partIns.ToSql()方法，我们来看看最终转换成的sql到底长成啥样子。
SELECT
[p].[DealerId],
[p].[WarehouseId],
[p0].[PartId],
SUM(CASE
WHEN [p].[InType] = 6
THEN [p0].[InQuantity]
ELSE 0.0
END) AS [WXInQuantity],
SUM(CASE
WHEN [p].[InType] = 4
THEN [p0].[InQuantity]
ELSE 0.0
END) AS [LSInQuantity],
SUM(CASE
WHEN [p].[InType] = 5
THEN [p0].[InQuantity]
ELSE 0.0
END) AS [BYInQuantity],
SUM(CASE
WHEN [p].[InType] = 8
THEN [p0].[InQuantity]
ELSE 0.0
END) AS [YBInQuantity]
FROM [PartIn] AS [p]
INNER JOIN [PartInDetail] AS [p0] ON [p].[Id] = [p0].[PartInId]
WHERE (((DATEPART(year, [p].[CreateTime]) = @__lastMonth_Year_0) OR
(DATEPART(year, [p].[CreateTime]) IS NULL AND @__lastMonth_Year_0 IS NULL)) AND
((DATEPART(month, [p].[CreateTime]) = @__lastMonth_Month_1) OR
(DATEPART(month, [p].[CreateTime]) IS NULL AND @__lastMonth_Month_1 IS NULL))) AND
(((([p].[InType] = 6) OR ([p].[InType] = 4)) OR ([p].[InType] = 5)) OR ([p].[InType] = 8))
GROUP BY [p].[DealerId], [p].[WarehouseId], [p0].[PartId]
这里我们发现我们定义的lastMonth变量传递到Linq中去,最后我们发现转换成的SQL中是以变量@__lastMonth_Year_0、@__lastMonth_Month_1的形式呈现的，那么我们怎样将最终的变量传递到这两个参数中去呢？这里我们肯定想到了使用ToSqlWithParams方法，那么我们来看看这个_partConsumeStatsRepository.GeneratePartConsume(partOuts, partIns, lastMonth)这个子方法我们最终是怎么实现的？
public async Task<int> GeneratePartConsume<T1, T2>(IQueryable<T1> outQuery, IQueryable<T2> inQuery, DateTime theMonth)
where T1 : class where T2 : class {
var (outQuerySql, outParams) = outQuery.ToSqlWithParams();
var (inQuerySql, inParams) = inQuery.ToSqlWithParams();
var sql = $@"Insert into PartConsume
(Id, DealerId, WarehouseId, PartId,
WXOutQuantity,LSOutQuantity,BYOutQuantity,YBOutQuantity,EWOutQuantity, LYOutQuantity,
WXInQuantity,LSInQuantity,BYInQuantity,YBInQuantity,TotalQuantity,
PartName, PartCode, DealerName, DealerCode, WarehouseName, WarehouseCode, Month, TheDate, IsExternalPart)
select newid(), a.*, Part.Name PartName, Part.Code PartCode,
(select Name From Company WHERE Id = a.DealerId) DealerName,
(select Code From Company WHERE Id = a.DealerId) DealerCode,
(select Name From DealerPartWarehouse WHERE Id = a.WarehouseId) WarehouseName,
(select Code From DealerPartWarehouse WHERE Id = a.WarehouseId) WarehouseCode, '{theMonth:u}', GetDate(), Part.IsExternalPart
FROM (select isnull(outQ.DealerId, inQ.DealerId) DealerId,
isnull(outQ.WarehouseId, inQ.WarehouseId) WarehouseId,
isnull(outQ.PartId, inQ.PartId) PartId,
ISNULL(WXOutQuantity,0) WXOutQuantity,ISNULL(LSOutQuantity,0) LSOutQuantity,ISNULL(BYOutQuantity,0) BYOutQuantity,
ISNULL(YBOutQuantity,0) YBOutQuantity,ISNULL(EWOutQuantity,0) EWOutQuantity, ISNULL(LYOutQuantity,0) LYOutQuantity,
ISNULL(WXInQuantity,0) WXInQuantity,ISNULL(LSInQuantity,0) LSInQuantity,ISNULL(BYInQuantity,0) BYInQuantity,ISNULL(YBInQuantity,0) YBInQuantity,
(ISNULL(WXOutQuantity,0)+ISNULL(LSOutQuantity,0)+ISNULL(BYOutQuantity,0)
+ISNULL(YBOutQuantity,0)+ISNULL(EWOutQuantity,0)+ISNULL(LYOutQuantity,0)
-ISNULL(WXInQuantity,0)-ISNULL(LSInQuantity,0)-ISNULL(BYInQuantity,0)-ISNULL(YBInQuantity,0)) TotalQuantity
From ({outQuerySql}) outQ
full join
({inQuerySql}) inQ
on outQ.DealerId = inQ.DealerId and outQ.WarehouseId = inQ.WarehouseId and outQ.PartId = inQ.PartId) a
inner join Part on Part.Id = a.PartId";
var parameters = new List<SqlParameter>();
outParams.ForEach(outParam => {
parameters.Add(new SqlParameter(outParam.Key, outParam.Value));
});
inParams.ForEach(inParam => {
if (parameters.Any(p => p.ParameterName == inParam.Key && p.Value.ToString() != inParam.Value.ToString())) {
throw new ValidationException("转换出的SQL语句中参数存在参数名称相同但是值不同的对象");
}
if (parameters.All(p => p.ParameterName != inParam.Key && p.Value != inParam.Value)) {
parameters.Add(new SqlParameter(inParam.Key, inParam.Value));
}
});
return await Context.Database.ExecuteSqlRawAsync(sql, parameters.ToArray());
}
在ToSqlWithParams返回值除了当前的sql之外还有当前sql中的参数信息，我们后面需要将当前的参数信息转换成SqlParameter集合，然后通过ExecuteSqlRawAsync带参数的方法将参数传递进去，这样才能够真正将最终的参数值传递到sql中的@__lastMonth_Year_0、@__lastMonth_Month_1中去，从而最终实现数据库中的sql的执行和应用。
浙公网安备 33010602011771号