[10 Regression] ExecuteUpdate no longer works within compiled queries

[Atulin]

Bug description

After an update to .NET 10.0-rc1, a compiled query that worked no problem in 9.0 stopped working. That same query, when not compiled but invoked directly, works without a hitch.

Your code

private static async ValueTask<ReturnType> HandleAsync(
	Command _,
	ApplicationDbContext context,
	IUserService userService,
	CancellationToken cancellationToken
)
{
	if (userService.User?.GetNumericId() is not {} uid) return TypedResults.NoContent();
	var rows = await CompiledQuery(context, uid, cancellationToken);
	return TypedResults.Ok(rows);
}
private static readonly Func<ApplicationDbContext, long, CancellationToken, Task<int>> CompiledQuery =
	EF.CompileAsyncQuery(static (ApplicationDbContext context, long uid, CancellationToken _)
		=> context.Users
			.TagWith(nameof(UpdateLastActive))
			.Where(u => u.Id == uid)
			.ExecuteUpdate(setters => setters.SetProperty(u => u.LastActive, DateTimeOffset.UtcNow)));

When the compiled query is replaced with a direct query call, like so, everything works just fine:

private static async ValueTask<ReturnType> HandleAsync(
	Command _,
	ApplicationDbContext context,
	IUserService userService,
	CancellationToken cancellationToken
)
{
	if (userService.User?.GetNumericId() is not {} uid) return TypedResults.NoContent();
	// var rows = await CompiledQuery(context, uid, cancellationToken);
	var rows = await context.Users
		.TagWith(nameof(UpdateLastActive))
		.Where(u => u.Id == uid)
		.ExecuteUpdateAsync(setters => setters.SetProperty(u => u.LastActive, DateTimeOffset.UtcNow), cancellationToken);
	return TypedResults.Ok(rows);
}

Stack traces

[01:12:48 INF] Request starting HTTP/2 HEAD https://localhost:5001/api/useractivity - null null
[01:12:48 INF] Executing endpoint 'HTTP: HEAD api/useractivity'
[01:12:48 INF] Executed endpoint 'HTTP: HEAD api/useractivity'
[01:12:48 ERR] An unhandled exception has occurred while executing the request.
System.InvalidOperationException: The LINQ expression 'DbSet<OgmaUser>()
    .Where(o0 => o0.Id == @uid)
    .ExecuteUpdate(setters => setters.SetProperty<DateTimeOffset>(
        propertyExpression: u => u.LastActive, 
        valueExpression: DateTimeOffset.UtcNow))' could not be translated. Either rewrite the query in a form that can be translated, or switch to client evaluation explicitly by inserting a call to 'AsEnumerable', 'AsAsyncEnumerable', 'ToList', or 'ToListAsync'. See https://go.microsoft.com/fwlink/?linkid=2101038 for more information.
   at Microsoft.EntityFrameworkCore.Query.QueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.RelationalQueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.QueryableMethodTranslatingExpressionVisitor.Translate(Expression expression)
   at Microsoft.EntityFrameworkCore.Query.QueryCompilationContext.CreateQueryExecutorExpression[TResult](Expression query)
   at Microsoft.EntityFrameworkCore.Query.QueryCompilationContext.CreateQueryExecutor[TResult](Expression query)
   at Microsoft.EntityFrameworkCore.Storage.Database.CompileQuery[TResult](Expression query, Boolean async)
   at Microsoft.EntityFrameworkCore.Query.Internal.QueryCompiler.CompileQueryCore[TResult](IDatabase database, Expression query, IModel model, Boolean async)
   at Microsoft.EntityFrameworkCore.Query.Internal.QueryCompiler.CreateCompiledAsyncQuery[TResult](Expression query)
   at Microsoft.EntityFrameworkCore.Query.Internal.CompiledAsyncTaskQuery`2.CreateCompiledQuery(IQueryCompiler queryCompiler, Expression expression)
   at Microsoft.EntityFrameworkCore.Query.Internal.CompiledQueryBase`2.<>c.<EnsureExecutor>b__7_0(CompiledQueryBase`2 t, TContext c, LambdaExpression q)
   at Microsoft.EntityFrameworkCore.Internal.NonCapturingLazyInitializer.EnsureInitialized[TParam1,TParam2,TParam3,TValue](TValue& target, TParam1 param1, TParam2 param2, TParam3 param3, Func`4 valueFactory)
   at Microsoft.EntityFrameworkCore.Query.Internal.CompiledQueryBase`2.EnsureExecutor(TContext context)
   at Microsoft.EntityFrameworkCore.Query.Internal.CompiledQueryBase`2.ExecuteCore(TContext context, CancellationToken cancellationToken, Object[] parameters)
   at Microsoft.EntityFrameworkCore.Query.Internal.CompiledAsyncTaskQuery`2.ExecuteAsync[TParam1](TContext context, TParam1 param1, CancellationToken cancellationToken)
   at Ogma3.Api.V1.UserActivity.UpdateLastActive.HandleAsync(Command _, ApplicationDbContext context, IUserService userService, CancellationToken cancellationToken) in F:\VS Projects\Ogma3\Ogma3\Api\V1\UserActivity\UpdateLastActive.cs:line 35
   at Ogma3.Api.V1.UserActivity.UpdateLastActive.HandleBehavior.HandleAsync(Command request, CancellationToken cancellationToken) in F:\VS Projects\Ogma3\Ogma3\obj\Generated\Immediate.Handlers.Generators\Immediate.Handlers.Generators.ImmediateHandlersGenerator\IH.Ogma3.Api.V1.UserActivity.UpdateLastActive.g.cs:line 54
   at Ogma3.Api.V1.UserActivity.UpdateLastActive.Handler.HandleAsync(Command request, CancellationToken cancellationToken) in F:\VS Projects\Ogma3\Ogma3\obj\Generated\Immediate.Handlers.Generators\Immediate.Handlers.Generators.ImmediateHandlersGenerator\IH.Ogma3.Api.V1.UserActivity.UpdateLastActive.g.cs:line 28
   at Microsoft.AspNetCore.Builder.Ogma3RoutesBuilder.<>c.<<MapOgma3_Api_V1_UserActivity_UpdateLastActiveEndpoint>b__76_0>d.MoveNext() in F:\VS Projects\Ogma3\Ogma3\obj\Generated\Immediate.Apis.Generators\Immediate.Apis.Generators.ImmediateApisGenerator\RouteBuilder.Ogma3_Api_V1_UserActivity_UpdateLastActive.g.cs:line 24
--- End of stack trace from previous location ---
   at Microsoft.AspNetCore.Http.RequestDelegateFactory.ExecuteTaskResult[T](Task`1 task, HttpContext httpContext)
   at Microsoft.AspNetCore.Routing.EndpointMiddleware.<Invoke>g__AwaitRequestTask|7_0(Endpoint endpoint, Task requestTask, ILogger logger)
   at Ogma3.Infrastructure.Middleware.UserBanMiddleware.InvokeAsync(HttpContext httpContext, RequestDelegate next) in F:\VS Projects\Ogma3\Ogma3\Infrastructure\Middleware\UserBanMiddleware.cs:line 29
   at Microsoft.AspNetCore.Builder.UseMiddlewareExtensions.InterfaceMiddlewareBinder.<>c__DisplayClass2_0.<<CreateMiddleware>b__0>d.MoveNext()
--- End of stack trace from previous location ---
   at Microsoft.AspNetCore.Authorization.AuthorizationMiddleware.Invoke(HttpContext context)
   at Microsoft.AspNetCore.Authentication.AuthenticationMiddleware.Invoke(HttpContext context)
   at Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddlewareImpl.Invoke(HttpContext context)

Verbose output

EF Core version

10.0.0-rc.1.25451.107

Database provider

Npgsql.EntityFrameworkCore.PostgreSQL 10.0.0-rc.1

Target framework

10.0.100-rc.1.25451.107

Operating system

Windows 11

IDE

JetBrains Rider 2025.2.1

[roji]

Confirmed regression in 10.0 (mostly likely a result of #32018).

Minimal repro

await using var context = new ApplicationDbContext();
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();

var query = EF.CompileAsyncQuery(static (ApplicationDbContext context)
    => context.Users.ExecuteUpdate(setters => setters.SetProperty(u => u.LastActive, DateTimeOffset.UtcNow)));

_ = await query(context);

public class ApplicationDbContext : DbContext
{
    public DbSet<User> Users { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .UseSqlServer("Server=localhost;Database=test;User=SA;Password=Abcd5678;Connect Timeout=60;ConnectRetryCount=0;Encrypt=false")
            .LogTo(Console.WriteLine, LogLevel.Information)
            .EnableSensitiveDataLogging();
}

public class User
{
    public int Id { get; set; }
    public DateTimeOffset LastActive { get; set; }
}

[roji]

The reason this no longer works is indeed because of #32018, which changed the argument of ExecuteUpdate to be an Action<UpdateSettersBuilder<TSource>>, where before it was Expression<Func<SetPropertyCalls<TSource>, SetPropertyCalls<TSource>>>. While this allows much better usage of ExecuteUpdate in dynamic scenarios where the setters aren't fixed, it also diverges the ExecuteUpdate method signature from the expression node that this method injects into the tree. This is similar to ExecuteUpdateAsync (the async version) not working within EF.CompileQuery(), since ExecuteUpdateAsync (async) injects a node for the non-async ExecuteUpdate into the expression tree (just like with the other terminating LINQ operators).

Ultimately, this runs against a known design limitation of compiled queries which affects other query scenarios, and cannot easily be fixed, but requires a deeper rethinking of the API and how it operates under the hood. FWIW the same difficulties affect NativeAOT precompiled queries, which also need special handling for cases where the public API called by the user diverges from the node injected by that same API.

Specifically for ExecuteUpdate, the value of using compiled queries seems to be particularly low, as databasew update operations typically take enough time that the compiled query optimization is likely completely negligible. This is also the first time I remember seeing a user actually doing ExecuteUpdate inside a compiled query, and I very much doubt this regression will affect a significant number of users. My recommendation here is to simply not use compiled queries when doing ExecuteUpdate.

I'll go ahead and put this in the backlog in case we decide to improve compiled queries at some point.

Test in NorthwindBulkUpdatesTestBase

[ConditionalTheory, MemberData(nameof(IsAsyncData))]
public virtual Task Update_with_compiled_query(bool async)
    => TestHelpers.ExecuteWithStrategyInTransactionAsync(
        Fixture.GetContextCreator(),
        Fixture.UseTransaction,
        async context =>
        {
            if (async)
            {
                var query = EF.CompileAsyncQuery(static (DbContext context, CancellationToken _) => context.Set<Customer>().ExecuteUpdate(s => s.SetProperty(c => c.ContactName, "Updated")));
                await query(context, CancellationToken.None);

                // TODO: Query and assert
            }
            else
            {
                var query = EF.CompileQuery(static (DbContext context) => context.Set<Customer>().ExecuteUpdate(s => s.SetProperty(c => c.ContactName, "Updated")));
                query(context);

                // TODO: Query and assert
            }
        });

[Atulin]

No support for it in compiled queries is fine, I guess (though it should be documented somewhere), since this endpoint was me experimenting with compiled queries in general.

That it also affects precompiled AOT queries, though? I already had to ditch them for whatever other reason I can't recall right now, but this makes me even less likely to use then. I use the .Execute methods quite a bit.

[roji]

ExecuteUpdate does work with precompiled queries in 10 - that's covered by our testing, and I specifically did work in #35257 to ensure that support stays. My point was only that any divergence between between the public API called by the user and the node injected by that same API causes this kind of issue, which need to be specially/manually handled (and that's what I did for precompiled queries for ExecuteUpdate - but not for compiled queries where we lack the infra for it).

Having said that, precompiled queries are definitely still experimental, and do not yet work across the board. Definitely expect issues with them in various scenarios.