Move join-lifting from postprocessor to TranslateExecuteUpdate

Move the SQLite UPDATE join-lifting logic from a separate
ExpressionVisitor in the postprocessor to an override of
TranslateExecuteUpdate in SqliteQueryableMethodTranslatingExpressionVisitor.
This runs the fix earlier during translation and only for ExecuteUpdate
queries, rather than as a full tree walk over all queries.

Delete SqliteUpdateJoinLiftingVisitor.cs as it is no longer needed.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: roji

src/EFCore.Sqlite.Core/Query/Internal/SqliteQueryTranslationPostprocessor.cs

@@ -40,7 +40,6 @@ public override Expression Process(Expression query)
     {
         var result = base.Process(query);
         _applyValidator.Visit(result);
-        result = new SqliteUpdateJoinLiftingVisitor(RelationalQueryCompilationContext.SqlAliasManager).Visit(result);
 
         return result;
     }

src/EFCore.Sqlite.Core/Query/Internal/SqliteQueryableMethodTranslatingExpressionVisitor.cs

@@ -84,6 +84,83 @@ protected SqliteQueryableMethodTranslatingExpressionVisitor(
     protected override QueryableMethodTranslatingExpressionVisitor CreateSubqueryVisitor()
         => new SqliteQueryableMethodTranslatingExpressionVisitor(this);
 
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    protected override UpdateExpression TranslateExecuteUpdate(ShapedQueryExpression source, IReadOnlyList<ExecuteUpdateSetter> setters)
+    {
+        var updateExpression = base.TranslateExecuteUpdate(source, setters);
+
+        // SQLite doesn't support referencing the UPDATE target table alias in JOIN ON clauses.
+        // Detect such joins and replace them with cross joins, lifting their predicates to WHERE.
+        var selectExpression = updateExpression.SelectExpression;
+        if (selectExpression.Tables.Count <= 1)
+        {
+            return updateExpression;
+        }
+
+        var targetAlias = updateExpression.Table.Alias;
+        var tables = selectExpression.Tables.ToList();
+        var predicate = selectExpression.Predicate;
+        var changed = false;
+
+        for (var i = 0; i < tables.Count; i++)
+        {
+            if (tables[i] is InnerJoinExpression innerJoin
+                && ContainsTargetReference(innerJoin.JoinPredicate, targetAlias))
+            {
+                predicate = predicate == null
+                    ? innerJoin.JoinPredicate
+                    : new SqlBinaryExpression(
+                        ExpressionType.AndAlso,
+                        predicate,
+                        innerJoin.JoinPredicate,
+                        typeof(bool),
+                        predicate.TypeMapping);
+
+                tables[i] = new CrossJoinExpression(innerJoin.Table);
+                changed = true;
+            }
+        }
+
+        if (!changed)
+        {
+            return updateExpression;
+        }
+
+#pragma warning disable EF1001 // Internal EF Core API usage.
+        var newSelect = new SelectExpression(
+            selectExpression.Alias,
+            tables,
+            predicate,
+            selectExpression.GroupBy,
+            selectExpression.Having,
+            selectExpression.Projection,
+            selectExpression.IsDistinct,
+            selectExpression.Orderings,
+            selectExpression.Offset,
+            selectExpression.Limit,
+            _sqlAliasManager,
+            (IReadOnlySet<string>)selectExpression.Tags);
+#pragma warning restore EF1001 // Internal EF Core API usage.
+
+        return updateExpression.Update(newSelect, updateExpression.ColumnValueSetters);
+
+        static bool ContainsTargetReference(SqlExpression expression, string targetAlias)
+            => expression switch
+            {
+                ColumnExpression col => col.TableAlias == targetAlias,
+                SqlBinaryExpression binary
+                    => ContainsTargetReference(binary.Left, targetAlias)
+                        || ContainsTargetReference(binary.Right, targetAlias),
+                SqlUnaryExpression unary => ContainsTargetReference(unary.Operand, targetAlias),
+                _ => false
+            };
+    }
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in

src/EFCore.Sqlite.Core/Query/Internal/SqliteUpdateJoinLiftingVisitor.cs

@@ -133,6 +133,8 @@ public override async Task Update_main_table_in_entity_with_entity_splitting(boo
             """
 UPDATE "Blogs" AS "b"
 SET "CreationTimestamp" = '2020-01-01 00:00:00'
+FROM "BlogsPart1" AS "b0"
+WHERE "b"."Id" = "b0"."Id"
 """);
     }