Refactor: split unmapped FK helper into Register and Match methods

- RegisterUnmappedForeignKeyPredecessors: adds to predecessors map
- MatchUnmappedForeignKeyEdges: calls AddMatchingPredecessorEdge

Author: andrewraper-Sage

src/EFCore.Relational/Update/Internal/CommandBatchPreparer.cs

@@ -672,10 +672,8 @@ private void AddForeignKeyEdges()
                         predecessorCommands.Add(command);
                     }
 
-                    AddUnmappedForeignKeyEdges(new(
-                        command, predecessorsMap,
-                        Principal: true, FromOriginalValues: false,
-                        CheckStoreGenerated: true, MatchEdges: false));
+                    RegisterUnmappedForeignKeyPredecessors(
+                        command, predecessorsMap, principal: true, fromOriginalValues: false);
                 }
                 else
                 {
@@ -731,10 +729,8 @@ private void AddForeignKeyEdges()
                         }
                     }
 
-                    AddUnmappedForeignKeyEdges(new(
-                        command, originalPredecessorsMap,
-                        Principal: false, FromOriginalValues: true,
-                        CheckStoreGenerated: false, MatchEdges: false));
+                    RegisterUnmappedForeignKeyPredecessors(
+                        command, originalPredecessorsMap, principal: false, fromOriginalValues: true);
                 }
                 else
                 {
@@ -791,10 +787,8 @@ private void AddForeignKeyEdges()
                             predecessorsMap, dependentKeyValue, command, foreignKey, checkStoreGenerated: true);
                     }
 
-                    AddUnmappedForeignKeyEdges(new(
-                        command, predecessorsMap,
-                        Principal: false, FromOriginalValues: false,
-                        CheckStoreGenerated: true, MatchEdges: true));
+                    MatchUnmappedForeignKeyEdges(
+                        command, predecessorsMap, principal: false, fromOriginalValues: false, checkStoreGenerated: true);
                 }
                 else
                 {
@@ -842,10 +836,8 @@ private void AddForeignKeyEdges()
                             originalPredecessorsMap, principalKeyValue, command, foreignKey);
                     }
 
-                    AddUnmappedForeignKeyEdges(new(
-                        command, originalPredecessorsMap,
-                        Principal: true, FromOriginalValues: true,
-                        CheckStoreGenerated: false, MatchEdges: true));
+                    MatchUnmappedForeignKeyEdges(
+                        command, originalPredecessorsMap, principal: true, fromOriginalValues: true, checkStoreGenerated: false);
                 }
                 else
                 {
@@ -982,88 +974,92 @@ private static bool CanCreateDependency(IKey key, IReadOnlyModificationCommand c
         return false;
     }
 
-    private readonly record struct UnmappedFkEdgeContext(
-        IReadOnlyModificationCommand Command,
-        Dictionary<object, List<IReadOnlyModificationCommand>> PredecessorsMap,
-        bool Principal,
-        bool FromOriginalValues,
-        bool CheckStoreGenerated,
-        bool MatchEdges);
-
-    private void AddUnmappedForeignKeyEdges(UnmappedFkEdgeContext context)
+    private void RegisterUnmappedForeignKeyPredecessors(
+        IReadOnlyModificationCommand command,
+        Dictionary<object, List<IReadOnlyModificationCommand>> predecessorsMap,
+        bool principal,
+        bool fromOriginalValues)
     {
-        foreach (var entry in context.Command.Entries)
+        foreach (var entry in command.Entries)
         {
-            var foreignKeys = context.Principal
+            var foreignKeys = principal
                 ? entry.EntityType.GetReferencingForeignKeys()
                 : (IEnumerable<IForeignKey>)entry.EntityType.GetForeignKeys();
 
             foreach (var foreignKey in foreignKeys)
             {
-                if (foreignKey.GetMappedConstraints().Any())
+                if (foreignKey.GetMappedConstraints().Any()
+                    || !CanCreateDependency(foreignKey, command, principal)
+                    || !IsModified(principal ? foreignKey.PrincipalKey.Properties : foreignKey.Properties, entry))
                 {
                     continue;
                 }
 
-                if (!CanCreateDependency(foreignKey, context.Command, context.Principal))
+                var keyValue = principal
+                    ? foreignKey.GetDependentKeyValueFactory()
+                        .CreatePrincipalEquatableKey(entry, fromOriginalValues)
+                    : foreignKey.GetDependentKeyValueFactory()
+                        ?.CreateDependentEquatableKey(entry, fromOriginalValues);
+
+                if (principal)
                 {
-                    continue;
+                    Check.DebugAssert(keyValue != null, "null keyValue");
                 }
-
-                var keyProperties = context.Principal
-                    ? foreignKey.PrincipalKey.Properties
-                    : foreignKey.Properties;
-
-                if (!IsModified(keyProperties, entry))
+                else if (keyValue is null)
                 {
                     continue;
                 }
 
-                if (context.CheckStoreGenerated
-                    && context.Principal
-                    && !IsStoreGenerated(entry, foreignKey.PrincipalKey))
+                if (!predecessorsMap.TryGetValue(keyValue!, out var predecessorCommands))
                 {
-                    continue;
+                    predecessorCommands = [];
+                    predecessorsMap.Add(keyValue!, predecessorCommands);
                 }
 
-                if (context.MatchEdges)
-                {
-                    var keyValue = context.Principal
-                        ? foreignKey.GetDependentKeyValueFactory()
-                            .CreatePrincipalEquatableKey(entry, context.FromOriginalValues)
-                        : foreignKey.GetDependentKeyValueFactory()
-                            ?.CreateDependentEquatableKey(entry, context.FromOriginalValues);
+                predecessorCommands.Add(command);
+            }
+        }
+    }
 
-                    if (keyValue is null)
-                    {
-                        continue;
-                    }
+    private void MatchUnmappedForeignKeyEdges(
+        IReadOnlyModificationCommand command,
+        Dictionary<object, List<IReadOnlyModificationCommand>> predecessorsMap,
+        bool principal,
+        bool fromOriginalValues,
+        bool checkStoreGenerated)
+    {
+        foreach (var entry in command.Entries)
+        {
+            var foreignKeys = principal
+                ? entry.EntityType.GetReferencingForeignKeys()
+                : (IEnumerable<IForeignKey>)entry.EntityType.GetForeignKeys();
 
-                    AddMatchingPredecessorEdge(
-                        context.PredecessorsMap, keyValue, context.Command, foreignKey,
-                        context.CheckStoreGenerated);
-                }
-                else
+            foreach (var foreignKey in foreignKeys)
+            {
+                if (foreignKey.GetMappedConstraints().Any()
+                    || !CanCreateDependency(foreignKey, command, principal)
+                    || !IsModified(principal ? foreignKey.PrincipalKey.Properties : foreignKey.Properties, entry))
                 {
-                    var keyValue = context.Principal
-                        ? foreignKey.GetDependentKeyValueFactory()
-                            .CreatePrincipalEquatableKey(entry, context.FromOriginalValues)
-                        : foreignKey.GetDependentKeyValueFactory()
-                            ?.CreateDependentEquatableKey(entry, context.FromOriginalValues);
+                    continue;
+                }
 
-                    if (keyValue is null)
-                    {
-                        continue;
-                    }
+                var keyValue = principal
+                    ? foreignKey.GetDependentKeyValueFactory()
+                        .CreatePrincipalEquatableKey(entry, fromOriginalValues)
+                    : foreignKey.GetDependentKeyValueFactory()
+                        ?.CreateDependentEquatableKey(entry, fromOriginalValues);
 
-                    if (!context.PredecessorsMap.TryGetValue(keyValue, out var predecessorCommands))
-                    {
-                        predecessorCommands = [];
-                        context.PredecessorsMap.Add(keyValue, predecessorCommands);
-                    }
-
-                    predecessorCommands.Add(context.Command);
+                if (principal)
+                {
+                    Check.DebugAssert(keyValue != null, "null keyValue");
                 }
+                else if (keyValue is null)
+                {
+                    continue;
+                }
+
+                AddMatchingPredecessorEdge(
+                    predecessorsMap, keyValue!, command, foreignKey, checkStoreGenerated);
             }
         }
     }