Implement ExecuteUpdate

Resolves #795

src/EFCore.Relational/Extensions/RelationalQueryableExtensions.cs

@@ -236,7 +236,7 @@ internal static readonly MethodInfo AsSplitQueryMethodInfo
  #region ExecuteDelete
 
  /// <summary>
- /// Deletes all entity instances which match the LINQ query from the database.
+ /// Deletes all database rows for given entity instances which match the LINQ query from the database.
  /// </summary>
  /// <remarks>
  /// <para>
@@ -251,12 +251,12 @@ internal static readonly MethodInfo AsSplitQueryMethodInfo
  /// </para>
  /// </remarks>
  /// <param name="source">The source query.</param>
- /// <returns>The total number of entity instances deleted from the database.</returns>
+ /// <returns>The total number of rows deleted in the database.</returns>
  public static int ExecuteDelete<TSource>(this IQueryable<TSource> source)
  => source.Provider.Execute<int>(Expression.Call(ExecuteDeleteMethodInfo.MakeGenericMethod(typeof(TSource)), source.Expression));
 
  /// <summary>
- /// Asynchronously deletes all entity instances which match the LINQ query from the database.
+ /// Asynchronously deletes database rows for given entity instances which match the LINQ query from the database.
  /// </summary>
  /// <remarks>
  /// <para>
@@ -272,7 +272,7 @@ public static int ExecuteDelete<TSource>(this IQueryable<TSource> source)
  /// </remarks>
  /// <param name="source">The source query.</param>
  /// <param name="cancellationToken">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param>
- /// <returns>The total number of entity instances deleted from the database.</returns>
+ /// <returns>The total number of rows deleted in the database.</returns>
  public static Task<int> ExecuteDeleteAsync<TSource>(this IQueryable<TSource> source, CancellationToken cancellationToken = default)
  => source.Provider is IAsyncQueryProvider provider
  ? provider.ExecuteAsync<Task<int>>(
@@ -283,4 +283,64 @@ internal static readonly MethodInfo ExecuteDeleteMethodInfo
  = typeof(RelationalQueryableExtensions).GetTypeInfo().GetDeclaredMethod(nameof(ExecuteDelete))!;
 
  #endregion
+
+ #region ExecuteUpdate
+
+ /// <summary>
+ /// Updates all database rows for given entity instances which match the LINQ query from the database.
+ /// </summary>
+ /// <remarks>
+ /// <para>
+ /// This operation executes immediately against the database, rather than being deferred until
+ /// <see cref="DbContext.SaveChanges()" /> is called. It also does not interact with the EF change tracker in any way:
+ /// entity instances which happen to be tracked when this operation is invoked aren't taken into account, and aren't updated
+ /// to reflect the changes.
+ /// </para>
+ /// <para>
+ /// See <see href="https://aka.ms/efcore-docs-bulk-operations">Executing bulk operations with EF Core</see>
+ /// for more information and examples.
+ /// </para>
+ /// </remarks>
+ /// <param name="source">The source query.</param>
+ /// <param name="setPropertyStatements">A collection of set property statements specifying properties to update.</param>
+ /// <returns>The total number of rows updated in the database.</returns>
+ public static int ExecuteUpdate<TSource>(
+ this IQueryable<TSource> source,
+ Expression<Func<SetPropertyStatements<TSource>, SetPropertyStatements<TSource>>> setPropertyStatements)
+ => source.Provider.Execute<int>(
+ Expression.Call(ExecuteUpdateMethodInfo.MakeGenericMethod(typeof(TSource)), source.Expression, setPropertyStatements));
+
+ /// <summary>
+ /// Asynchronously updates database rows for given entity instances which match the LINQ query from the database.
+ /// </summary>
+ /// <remarks>
+ /// <para>
+ /// This operation executes immediately against the database, rather than being deferred until
+ /// <see cref="DbContext.SaveChanges()" /> is called. It also does not interact with the EF change tracker in any way:
+ /// entity instances which happen to be tracked when this operation is invoked aren't taken into account, and aren't updated
+ /// to reflect the changes.
+ /// </para>
+ /// <para>
+ /// See <see href="https://aka.ms/efcore-docs-bulk-operations">Executing bulk operations with EF Core</see>
+ /// for more information and examples.
+ /// </para>
+ /// </remarks>
+ /// <param name="source">The source query.</param>
+ /// <param name="setPropertyStatements">A collection of set property statements specifying properties to update.</param>
+ /// <param name="cancellationToken">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param>
+ /// <returns>The total number of rows updated in the database.</returns>
+ public static Task<int> ExecuteUpdateAsync<TSource>(
+ this IQueryable<TSource> source,
+ Expression<Func<SetPropertyStatements<TSource>, SetPropertyStatements<TSource>>> setPropertyStatements,
+ CancellationToken cancellationToken = default)
+ => source.Provider is IAsyncQueryProvider provider
+ ? provider.ExecuteAsync<Task<int>>(
+ Expression.Call(
+ ExecuteUpdateMethodInfo.MakeGenericMethod(typeof(TSource)), source.Expression, setPropertyStatements), cancellationToken)
+ : throw new InvalidOperationException(CoreStrings.IQueryableProviderNotAsync);
+
+ internal static readonly MethodInfo ExecuteUpdateMethodInfo
+ = typeof(RelationalQueryableExtensions).GetTypeInfo().GetDeclaredMethod(nameof(ExecuteUpdate))!;
+
+ #endregion
 }

src/EFCore.Relational/Query/EntityProjectionExpression.cs

@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
 
 namespace Microsoft.EntityFrameworkCore.Query;

src/EFCore.Relational/Query/NonQueryExpression.cs

@@ -5,22 +5,58 @@
 
 namespace Microsoft.EntityFrameworkCore.Query;
 
-#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+/// <summary>
+/// <para>
+/// An expression that contains a non-query expression. The result of non-query expression is typically number of rows affected.
+/// </para>
+/// <para>
+/// This type is typically used by database providers (and other extensions). It is generally
+/// not used in application code.
+/// </para>
+/// </summary>
+/// <remarks>
+/// See <see href="https://aka.ms/efcore-docs-providers">Implementation of database providers and extensions</see>
+/// and <see href="https://aka.ms/efcore-docs-how-query-works">How EF Core queries work</see> for more information and examples.
+/// </remarks>
 public class NonQueryExpression : Expression, IPrintableExpression
 {
+ /// <summary>
+ /// Creates a new instance of the <see cref="NonQueryExpression" /> class with associated query expression and command source.
+ /// </summary>
+ /// <param name="expression">The expression to affect rows on the server.</param>
+ /// <param name="commandSource">The command source to use for this non-query operation.</param>
+ public NonQueryExpression(Expression expression, CommandSource commandSource)
+ {
+ Expression = expression;
+ CommandSource = commandSource;
+ }
+
+ /// <summary>
+ /// Creates a new instance of the <see cref="NonQueryExpression" /> class with associated delete expression.
+ /// </summary>
+ /// <param name="deleteExpression">The delete expression to delete rows on the server.</param>
  public NonQueryExpression(DeleteExpression deleteExpression)
  : this(deleteExpression, CommandSource.ExecuteDelete)
  {
  }
 
- public NonQueryExpression(DeleteExpression expression, CommandSource commandSource)
+ /// <summary>
+ /// Creates a new instance of the <see cref="NonQueryExpression" /> class with associated update expression.
+ /// </summary>
+ /// <param name="updateExpression">The update expression to update rows on the server.</param>
+ public NonQueryExpression(UpdateExpression updateExpression)
+ : this(updateExpression, CommandSource.ExecuteUpdate)
  {
- DeleteExpression = expression;
- CommandSource = commandSource;
  }
 
- public virtual DeleteExpression DeleteExpression { get; }
+ /// <summary>
+ /// An expression representing the non-query to be run against server.
+ /// </summary>
+ public virtual Expression Expression { get; }
 
+ /// <summary>
+ /// The command source to use for this non-query operation.
+ /// </summary>
  public virtual CommandSource CommandSource { get; }
 
  /// <inheritdoc />
@@ -29,23 +65,30 @@ public NonQueryExpression(DeleteExpression expression, CommandSource commandSour
  /// <inheritdoc />
  public sealed override ExpressionType NodeType => ExpressionType.Extension;
 
+ /// <inheritdoc />
  protected override Expression VisitChildren(ExpressionVisitor visitor)
  {
- var deleteExpression = (DeleteExpression)visitor.Visit(DeleteExpression);
+ var expression = visitor.Visit(Expression);
 
- return Update(deleteExpression);
+ return Update(expression);
  }
 
- public virtual NonQueryExpression Update(DeleteExpression deleteExpression)
- => deleteExpression != DeleteExpression
- ? new NonQueryExpression(deleteExpression)
+ /// <summary>
+ /// Creates a new expression that is like this one, but using the supplied children. If all of the children are the same, it will
+ /// return this expression.
+ /// </summary>
+ /// <param name="expression">The <see cref="Expression" /> property of the result.</param>
+ /// <returns>This expression if no children changed, or an expression with the updated children.</returns>
+ public virtual NonQueryExpression Update(Expression expression)
+ => expression != Expression
+ ? new NonQueryExpression(expression, CommandSource)
  : this;
 
  /// <inheritdoc />
  public virtual void Print(ExpressionPrinter expressionPrinter)
  {
  expressionPrinter.Append($"({nameof(NonQueryExpression)}: ");
- expressionPrinter.Visit(DeleteExpression);
+ expressionPrinter.Visit(Expression);
  }
 
  /// <inheritdoc />
@@ -56,8 +99,8 @@ public override bool Equals(object? obj)
  && Equals(nonQueryExpression));
 
  private bool Equals(NonQueryExpression nonQueryExpression)
- => DeleteExpression == nonQueryExpression.DeleteExpression;
+ => Expression == nonQueryExpression.Expression;
 
  /// <inheritdoc />
- public override int GetHashCode() => DeleteExpression.GetHashCode();
+ public override int GetHashCode() => Expression.GetHashCode();
 }

src/EFCore.Relational/Query/QuerySqlGenerator.cs

@@ -95,12 +95,9 @@ protected virtual void GenerateRootCommand(Expression queryExpression)
  }
  break;
 
- case DeleteExpression deleteExpression:
- VisitDelete(deleteExpression);
- break;
-
  default:
- throw new InvalidOperationException();
+ base.Visit(queryExpression);
+ break;
  }
  }
 
@@ -1229,4 +1226,49 @@ protected override Expression VisitUnion(UnionExpression unionExpression)
 
  return unionExpression;
  }
+
+ /// <inheritdoc />
+ protected override Expression VisitUpdate(UpdateExpression updateExpression)
+ {
+ var selectExpression = updateExpression.SelectExpression;
+
+ if (selectExpression.Offset == null
+ && selectExpression.Limit == null
+ && selectExpression.Having == null
+ && selectExpression.Orderings.Count == 0
+ && selectExpression.GroupBy.Count == 0
+ && selectExpression.Tables.Count == 1
+ && selectExpression.Tables[0] == updateExpression.Table
+ && selectExpression.Projection.Count == 0)
+ {
+ _relationalCommandBuilder.Append("UPDATE ");
+ Visit(updateExpression.Table);
+ _relationalCommandBuilder.AppendLine();
+ using (_relationalCommandBuilder.Indent())
+ {
+ _relationalCommandBuilder.Append("SET ");
+ GenerateList(updateExpression.SetColumnValues,
+ e =>
+ {
+ Visit(e.Column);
+ _relationalCommandBuilder.Append(" = ");
+ Visit(e.Value);
+
+ },
+ joinAction: e => e.AppendLine(","));
+ _relationalCommandBuilder.AppendLine();
+ }
+
+ if (selectExpression.Predicate != null)
+ {
+ _relationalCommandBuilder.AppendLine().Append("WHERE ");
+ Visit(selectExpression.Predicate);
+ }
+
+ return updateExpression;
+ }
+
+ throw new InvalidOperationException(
+ RelationalStrings.ExecuteOperationWithUnsupportedOperatorInSqlGeneration(nameof(RelationalQueryableExtensions.ExecuteUpdate)));
+ }
 }

src/EFCore.Relational/Query/RelationalQueryTranslationPostprocessor.cs

@@ -99,7 +99,7 @@ private sealed class TableAliasVerifyingExpressionVisitor : ExpressionVisitor
  return relationalSplitCollectionShaperExpression;
 
  case NonQueryExpression nonQueryExpression:
- VerifyUniqueAliasInExpression(nonQueryExpression.DeleteExpression);
+ VerifyUniqueAliasInExpression(nonQueryExpression.Expression);
  return nonQueryExpression;
 
  default: