当前位置：首页 > news >正文

【EF Core】两种方法记录生成的 SQL 语句

news 2026/5/12 17:54:14

原本计划 N 天前写的内容，无奈拖到今天。大伙伴们可能都了解，年近岁末，风干物燥，bug 特多，改需求的精力特旺盛。有几个工厂的项目需要不同程度的修改或修复。这些项目都是老周个人名义与他们长期合作的（有些项目已断尾了，他们觉得不用再改了），所以不一定都是新项目，有两三个都维护好几年了。

今天咱们的主题是记录 SQL 语句。用过 EF 的都知道，它可以将 LINQ 表达式树翻译成 SQL 语句，然后发送到数据库执行。这个框架从 Framework 时代走到 Core 时代，虽说不是什么新鲜技术，但这活真的是好活，以面向对象的方式与数据库交互是真的爽。

将 LINQ 转译为 SQL 是框架内部功能，官方团队或许也没考虑让我们做太多的扩展（实际开发中也的确很少），因此，框架并没有提供独立的服务让我们去做表达式树的翻译。在执行查询时，EF Core 是经过几个步骤的，这个可以看看 QueryCompilationContext 类的源代码。其实处理查询转译的代码是写在这个类里面的，不是 Database 类。上次在某公司有位妹子程序员问过老周，她想看看 LINQ 翻译 SQL 的大致过程，可在源代码中找不到。你不要惊讶，这个公司的团队绝对少见，七个成员，四个是女的，恐怕你都找不出第二个这样的团队。

老周告诉她，源代码庞大，直接拿着看很多东西不好找的，你可以用调试进入源码，一步步跟进去，才比较好找。不废话了，咱们看代码。

    public virtual Expression<Func<QueryContext, TResult>> CreateQueryExecutorExpression<TResult>(Expression query){var queryAndEventData = Logger.QueryCompilationStarting(Dependencies.Context, _expressionPrinter, query);var interceptedQuery = queryAndEventData.Query;var preprocessedQuery = _queryTranslationPreprocessorFactory.Create(this).Process(interceptedQuery);var translatedQuery = _queryableMethodTranslatingExpressionVisitorFactory.Create(this).Translate(preprocessedQuery);var postprocessedQuery = _queryTranslationPostprocessorFactory.Create(this).Process(translatedQuery);var compiledQuery = _shapedQueryCompilingExpressionVisitorFactory.Create(this).Visit(postprocessedQuery);// If any additional parameters were added during the compilation phase (e.g. entity equality ID expression),// wrap the query with code adding those parameters to the query contextvar compiledQueryWithRuntimeParameters = InsertRuntimeParameters(compiledQuery);return Expression.Lambda<Func<QueryContext, TResult>>(compiledQueryWithRuntimeParameters,QueryContextParameter);}

这代码一旦展开是非常复杂的，你不仅要有使用 LINQ 表达式树的知识，还得看懂其思路，所以，没兴趣的话就不用看了。而且看不懂也不影响写代码。大体过程是这样的：

1、先执行拦截器。拦截器这东西老周以后会介绍，拦截器可以拦截你执行的 LINQ 表达式树，并且你可以在翻译之前修改它。

2、预处理。这里面又是一堆处理，如参数命名规整化、把如 long.Max 这样的方法调用标准化为 Math.Max 调用、表达式简化等等。

3、特殊方法调用转换，如调用 Where、All、FirstOrDefault 这样标准查询方法，还有 ExecuteUpdate、ExecuteDelete 这些专用方法的调用转换等。

4、转换扫尾工作，这个主要是不同数据库的特殊处理，比如，Sqlite 和 SQL Server 的处理不同。

5、正式转译为 SQL 语句。

6、生成 Lambda 表达式树。这个委托接收 QueryContext 类型的参数（可以用 IQueryContextFactory 服务创建），返回的结果一般是 IEnumerable<T>。

想想，调用这些代码获取 SQL 太麻烦，这等同于把人家源代码抄一遍了。其实，单纯的把 LINQ 转 SQL 意义不大的，许多场景下，可能最需要的是日志功能——记录发送到数据库的 SQL 语句。

好了，上面的只是理论铺设，接下来咱们聊主题。咱们有两种方法可以记录SQL语句，不废话，老周直接说答案：

1、通过日志 + 事件过滤功能。这个最简单；

2、通过拦截器拦截 DbCommand 对象，从而获取 SQL 语句。

-----------------------------------------------------------------------------------------------------------------------------------

先说第一种，先写个实体类，随便写就行。

public class Song
{public int ID { get; set; }public string Name { get; set; } = null!;public string? Artist { get; set; }public long Duration { get; set; }
}

然后写数据库上下文。

public class MyDbContext : DbContext
{protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder){optionsBuilder.UseSqlite("data source=demo.db");}protected override void OnModelCreating(ModelBuilder modelBuilder){modelBuilder.Entity<Song>(et =>{et.ToTable("tb_songs");et.HasKey(x => x.ID).HasName("PK_Song");et.Property(a => a.Name).HasMaxLength(20);});}// 公开数据集合public DbSet<Song> Songs { get; set; }
}

写好后回过头看 OnConfiguring 方法，现在咱们要配置日志。

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder){optionsBuilder.UseSqlite("data source=demo.db");optionsBuilder.LogTo(// 第一个委托：过滤事件(eventid, loglevel) =>{if(eventid.Id == RelationalEventId.CommandExecuting){return true;}return false;},// 第二个委托：记录SQLeventData =>{// 转换事件数据if(eventData is CommandEventData data){// 记录SQLConsole.Write("命令源：{0}", data.CommandSource);Console.Write("，SQL 语句：{0}", data.LogCommandText);Console.Write("\n\n");}});}

这里，LogTo 调用的是以下重载：

public virtual DbContextOptionsBuilder LogTo(Func<EventId, LogLevel, bool> filter,Action<EventData> logger)

filter 是个过滤器，EventId 表示相关事件，LogLevel 表示日志级别，如 Information、Warning、Error 等。第三个是返回值，布尔类型。所以，这个委托的用法很明显，如果返回 false，表示不记录该事件的日志，第二个委托logger就不会调用；如果过滤器返回 true，表明要接收此事件的日志，此时，logger 委托会调用。

咱们的代码只关心 CommandExecuting 事件，这是 DbCommand 执行之前触发的，如果是命令执行之后，会触发 CommandExecuted 事件。咱们的目标明确——获取生成的 SQL 语句，其实这里也可以用 CommandInitialized 事件。其实 CommandInitialized、CommandExecuting、CommandExecuted 三个事件都能得到 SQL 语句，任意抓取一个用即可。

在第二个委托中，它有一个输入参数—— EventData，它是所有事件数据的基类，所以，在委托内部需要进行类型分析。

if(eventData is CommandEventData data)……

不过这里我们不必关心其他类型，毕竟 filter 只选出一个事件，其他事件都返回 false，不会调用 logger 委托。

从 LogCommandText 属性上就能得到 SQL 语句。另外，CommandSource 是一个枚举，它表示这个 SQL 语句是由哪个操作引发的。如

SaveChanges：你调用 DbContext.SaveChanges 方法后保存数据时触发的。
Migrations：迁移数据库时触发，包括在运行阶段执行迁移，或者调用 Database.EnsureCreate 或 EnsureDelete 等方法也会触发。
LinqQuery：这个熟悉，就是你常规操作，使用 LINQ 查询转 SQL 后执行。
ExecuteDelete 与 ExecuteUpdate：就是调用 ExecuteUpdate、ExecuteDelete 方法时触发。

好，咱们试一下，先用 EnsureCreate 创建数据库，然后执行一个查询。

using var ctx = new MyDbContext();
ctx.Database.EnsureCreated();
// 查询
var res = ctx.Songs.Where(s => s.ID > 2).ToArray();

运行一下看看。结果如下：

命令源：Migrations，SQL 语句：PRAGMA journal_mode = 'wal';命令源：Migrations，SQL 语句：CREATE TABLE "tb_songs" ("ID" INTEGER NOT NULL CONSTRAINT "PK_Song" PRIMARY KEY AUTOINCREMENT,"Name" TEXT NOT NULL,"Artist" TEXT NULL,"Duration" INTEGER NOT NULL
);命令源：LinqQuery，SQL 语句：SELECT "t"."ID", "t"."Artist", "t"."Duration", "t"."Name"
FROM "tb_songs" AS "t"
WHERE "t"."ID" > 2

前两个语句的命令源都是 Migrations，这是创建数据库和表时的语句（SQLite 不需要 CREATE DATABASE 语句，直接建表）。第三个就是咱们执行查询生成的 SQL 语句，可以看到命令源是 LinqQuery。

----------------------------------------------------------------------------------------------------------------------------------------------------------------

现在看一下第二种方案，咱们先把数据库上下文的 OnConfiguring 方法中的日志配置注释掉。

现在，咱们实现自己的命令拦截器。

拦截器的基础接口是 IInterceptor，它是个空接口，没有任何成员，仅作为标志。咱们一般不会直接实现它。

拦截命令，框架提供的是 IDbCommandInterceptor 接口，它要求你实现以下成员：

public interface IDbCommandInterceptor : IInterceptor
{// 当 DbCommand 对象（不同数据库有具体的类）被创建前触发// 这个时候是获取不到 SQL 语句的，命令对象原则上还没创建// 但是，你可以自己创建一个，并用 InterceptorResult 返回// 你要么原样返回，要么用 SuppressWithResult 静态方法自己创建一个命令对象// 这时候 EF Core 会用你创建的命令对象代替内部代码所创建的命令对象// 注意这里只是抑制内部创建命令对象而已，并不能阻止命令的执行InterceptionResult<DbCommand> CommandCreating(CommandCorrelatedEventData eventData, InterceptionResult<DbCommand> result){return result;}// 命令对象创建后，这里是 EF Core 负责创建命令对象，你负责修改// 不修改就原样返回。此时，你不能自己 new 命令对象了，只能修属性
    DbCommand CommandCreated(CommandEndEventData eventData, DbCommand result){return result;}// 这里可以获取到 SQL 了
    DbCommand CommandInitialized(CommandEndEventData eventData, DbCommand result)=> result;// 和前面的命令对象一样，这里你可以用自己创建的 DataReader 代替框架内部创建的// 这是有查询结果的 reader，比如 SELECT 语句// 此时还没有执行 SQLInterceptionResult<DbDataReader> ReaderExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result)=> result;// 查询单个标量值之前调用此方法，你可以自己分配一个值来代替     // 此时还没执行 SQL 语句InterceptionResult<object> ScalarExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<object> result)=> result;// 执行无结果查询前触发，你可以自己弄一个结果值覆盖真实查询的结果// 此时还没有执行 SQL 语句InterceptionResult<int> NonQueryExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<int> result)=> result;// 异步版本ValueTask<InterceptionResult<DbDataReader>> ReaderExecutingAsync(DbCommand command,CommandEventData eventData,InterceptionResult<DbDataReader> result,CancellationToken cancellationToken = default)=> new(result);// 异步版本ValueTask<InterceptionResult<object>> ScalarExecutingAsync(DbCommand command,CommandEventData eventData,InterceptionResult<object> result,CancellationToken cancellationToken = default)=> new(result);// 异步版本ValueTask<InterceptionResult<int>> NonQueryExecutingAsync(DbCommand command,CommandEventData eventData,InterceptionResult<int> result,CancellationToken cancellationToken = default)=> new(result);// 以下是 SQL 语句执行完毕，且从数据库返回结果，但你仍可以处理这些结果
    DbDataReader ReaderExecuted(DbCommand command, CommandExecutedEventData eventData, DbDataReader result)=> result;object? ScalarExecuted(DbCommand command, CommandExecutedEventData eventData, object? result)=> result;int NonQueryExecuted(DbCommand command, CommandExecutedEventData eventData, int result)=> result;// 以下是异步版本ValueTask<DbDataReader> ReaderExecutedAsync(DbCommand command,CommandExecutedEventData eventData,DbDataReader result,CancellationToken cancellationToken = default)=> new(result);ValueTask<object?> ScalarExecutedAsync(DbCommand command,CommandExecutedEventData eventData,object? result,CancellationToken cancellationToken = default)=> new(result);ValueTask<int> NonQueryExecutedAsync(DbCommand command,CommandExecutedEventData eventData,int result,CancellationToken cancellationToken = default)=> new(result);// 以下是命令被取消或执行失败后调用void CommandCanceled(DbCommand command, CommandEndEventData eventData){}Task CommandCanceledAsync(DbCommand command, CommandEndEventData eventData, CancellationToken cancellationToken = default)=> Task.CompletedTask;void CommandFailed(DbCommand command, CommandErrorEventData eventData){}Task CommandFailedAsync(DbCommand command, CommandErrorEventData eventData, CancellationToken cancellationToken = default)=> Task.CompletedTask;// 以下是当 dataReader 被关闭前触发
    InterceptionResult DataReaderClosing(DbCommand command, DataReaderClosingEventData eventData, InterceptionResult result)=> result;ValueTask<InterceptionResult> DataReaderClosingAsync(DbCommand command, DataReaderClosingEventData eventData, InterceptionResult result)=> new(result);// dataReader 被释放前触发// 这个最好原样返回，就算你 Suppressed 它，阻止不了连象、命令、阅读器被设为 null// Suppressed 它纯粹只是在设为 null 前不调用 Dispose 方法罢了
    InterceptionResult DataReaderDisposing(DbCommand command, DataReaderDisposingEventData eventData, InterceptionResult result)=> result;
}

你看看，我只是想拦截某个操作，却要实现这么多方法，这太不像话了。为了你觉得像话，EF Core 提供了一个抽象类，叫 DbCommandInterceptor，它会以默认行为实现 IDbCommandInterceptor 接口。这样你就轻松了，想修改哪个操作，只要重写某个方法成员就好了。

这里，咱们要获取 SQL 语句，只有在 CommandInitialized 时 SQL 语句才被设置，所以重写 CommandInitialized 方法。

public class MyCommandInterceptor : DbCommandInterceptor
{public override DbCommand CommandInitialized(CommandEndEventData eventData, DbCommand result){// 只获取 LINQ 查询生成的 SQL 语句if (eventData.CommandSource == CommandSource.LinqQuery){// 第一种方法Console.WriteLine($"\nLog Command:\n{eventData.LogCommandText}");// 第二种方法Console.WriteLine($"DB Command:\n{result.CommandText}\n");// 第三种方法//Console.WriteLine($"From Event Data:\n{eventData.Command.CommandText}\n");
        }return base.CommandInitialized(eventData, result);}
}

其实传入方法的参数里面有些对象是重复的，所以你有多个方法来获取 SQL。eventData.Command 其实就是 result 参数所引用的对象，所以随便哪个的 CommandText 属性都能获取 SQL 语句；另外，eventData 的 LogCommandText 属性也是 SQL 语句。这些方法你随便选一个。

上述代码中，老周用 CommandSource.LinqQuery 进行判断，咱们只记下由 LINQ 查询生成的 SQL 语句。

现在回到数据库上下文类，在 OnConfiguring 方法中添加刚刚弄好的拦截器。

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder){optionsBuilder.UseSqlite("data source=demo.db");optionsBuilder.AddInterceptors(new MyCommandInterceptor());}

调用 AddInterceptors 方法，把你想要添加的拦截器实例扔进去就完事了。

再次运行程序，控制台输出以下内容：

Log Command:
SELECT "t"."ID", "t"."Artist", "t"."Duration", "t"."Name"
FROM "tb_songs" AS "t"
WHERE "t"."ID" > 2
DB Command:
SELECT "t"."ID", "t"."Artist", "t"."Duration", "t"."Name"
FROM "tb_songs" AS "t"
WHERE "t"."ID" > 2