Don't undelete dependents if principal key changes

src/EFCore.Cosmos/Infrastructure/Internal/CosmosModelValidator.cs

@@ -342,6 +342,29 @@ protected virtual void ValidateKeys(
         }
     }
 
+    /// <summary>
+    ///     Validates the mapping/configuration of mutable in the model.
+    /// </summary>
+    /// <param name="model">The model to validate.</param>
+    /// <param name="logger">The logger to use.</param>
+    protected override void ValidateNoMutableKeys(
+        IModel model,
+        IDiagnosticsLogger<DbLoggerCategory.Model.Validation> logger)
+    {
+        foreach (var entityType in model.GetEntityTypes())
+        {
+            foreach (var key in entityType.GetDeclaredKeys())
+            {
+                var mutableProperty = key.Properties.FirstOrDefault(p => p.ValueGenerated.HasFlag(ValueGenerated.OnUpdate));
+                if (mutableProperty != null
+                    && !mutableProperty.IsOrdinalKeyProperty())
+                {
+                    throw new InvalidOperationException(CoreStrings.MutableKeyProperty(mutableProperty.Name));
+                }
+            }
+        }
+    }
+
     /// <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.Cosmos/Metadata/Conventions/CosmosValueGenerationConvention.cs

@@ -78,11 +78,11 @@ public virtual void ProcessEntityTypeAnnotationChanged(
             {
                 var pk = property.FindContainingPrimaryKey();
                 if (pk != null
-                    && !ownership.Properties.Contains(property)
+                    && !property.IsForeignKey()
                     && pk.Properties.Count == ownership.Properties.Count + 1
                     && ownership.Properties.All(fkProperty => pk.Properties.Contains(fkProperty)))
                 {
-                    return base.GetValueGenerated(property);
+                    return ValueGenerated.OnAddOrUpdate;
                 }
             }
         }

src/EFCore.Cosmos/Metadata/Internal/CosmosPropertyExtensions.cs

@@ -27,6 +27,6 @@ public static bool IsOrdinalKeyProperty(this IReadOnlyProperty property)
             && key.Properties.Count > 1
             && !property.IsForeignKey()
             && property.ClrType == typeof(int)
-            && property.ValueGenerated == ValueGenerated.OnAdd;
+            && (property.ValueGenerated & ValueGenerated.OnAdd) != 0;
     }
 }

src/EFCore.Cosmos/Update/Internal/DocumentSource.cs

@@ -120,13 +120,20 @@ public virtual JObject CreateDocument(IUpdateEntry entry, int? ordinal)
             }
             else
             {
+                SetTemporaryOrdinals(entry, fk, embeddedValue);
+
+#pragma warning disable EF1001 // Internal EF Core API usage.
+                // #16707
+                var stateManager = ((InternalEntityEntry)entry).StateManager;
+#pragma warning restore EF1001 // Internal EF Core API usage.
+
                 var embeddedOrdinal = 1;
                 var array = new JArray();
                 foreach (var dependent in (IEnumerable)embeddedValue)
                 {
 #pragma warning disable EF1001 // Internal EF Core API usage.
                     // #16707
-                    var dependentEntry = ((InternalEntityEntry)entry).StateManager.TryGetEntry(dependent, fk.DeclaringEntityType)!;
+                    var dependentEntry = stateManager.TryGetEntry(dependent, fk.DeclaringEntityType)!;
                     array.Add(_database.GetDocumentSource(dependentEntry.EntityType).CreateDocument(dependentEntry, embeddedOrdinal));
 #pragma warning restore EF1001 // Internal EF Core API usage.
                     embeddedOrdinal++;
@@ -157,13 +164,17 @@ public virtual JObject CreateDocument(IUpdateEntry entry, int? ordinal)
     public virtual JObject? UpdateDocument(JObject document, IUpdateEntry entry, int? ordinal)
     {
         var anyPropertyUpdated = false;
-#pragma warning disable EF1001 // Internal EF Core API usage.
-        // #16707
-        var stateManager = ((InternalEntityEntry)entry).StateManager;
-#pragma warning restore EF1001 // Internal EF Core API usage.
         foreach (var property in entry.EntityType.GetProperties())
         {
+            if (ordinal != null
+                && entry.HasTemporaryValue(property)
+                && property.IsOrdinalKeyProperty())
+            {
+                entry.SetStoreGeneratedValue(property, ordinal.Value);
+            }
+
             if (entry.EntityState == EntityState.Added
+                || entry.SharedIdentityEntry != null
                 || entry.IsModified(property))
             {
                 var storeName = property.GetJsonPropertyName();
@@ -173,13 +184,6 @@ public virtual JObject CreateDocument(IUpdateEntry entry, int? ordinal)
                     anyPropertyUpdated = true;
                 }
             }
-
-            if (ordinal != null
-                && entry.HasTemporaryValue(property)
-                && property.IsOrdinalKeyProperty())
-            {
-                entry.SetStoreGeneratedValue(property, ordinal.Value);
-            }
         }
 
         foreach (var ownedNavigation in entry.EntityType.GetNavigations())
@@ -207,12 +211,8 @@ public virtual JObject CreateDocument(IUpdateEntry entry, int? ordinal)
             {
 #pragma warning disable EF1001 // Internal EF Core API usage.
                 // #16707
-                var embeddedEntry = ((InternalEntityEntry)entry).StateManager.TryGetEntry(embeddedValue, fk.DeclaringEntityType);
+                var embeddedEntry = ((InternalEntityEntry)entry).StateManager.TryGetEntry(embeddedValue, fk.DeclaringEntityType)!;
 #pragma warning restore EF1001 // Internal EF Core API usage.
-                if (embeddedEntry == null)
-                {
-                    continue;
-                }
 
                 var embeddedDocument = embeddedDocumentSource.GetCurrentDocument(embeddedEntry);
                 embeddedDocument = embeddedDocument != null
@@ -227,64 +227,21 @@ public virtual JObject CreateDocument(IUpdateEntry entry, int? ordinal)
             }
             else
             {
-                var embeddedOrdinal = 1;
-                var ordinalKeyProperty = FindOrdinalKeyProperty(fk.DeclaringEntityType);
-                if (ordinalKeyProperty != null)
-                {
-                    var shouldSetTemporaryKeys = false;
-                    foreach (var dependent in (IEnumerable)embeddedValue)
-                    {
-#pragma warning disable EF1001 // Internal EF Core API usage.
-                        // #16707
-                        var embeddedEntry = stateManager.TryGetEntry(dependent, fk.DeclaringEntityType);
-                        if (embeddedEntry == null)
-                        {
-                            continue;
-                        }
-
-                        if ((int)embeddedEntry.GetCurrentValue(ordinalKeyProperty)! != embeddedOrdinal)
-                        {
-                            shouldSetTemporaryKeys = true;
-                            break;
-                        }
-#pragma warning restore EF1001 // Internal EF Core API usage.
+                SetTemporaryOrdinals(entry, fk, embeddedValue);
 
-                        embeddedOrdinal++;
-                    }
-
-                    if (shouldSetTemporaryKeys)
-                    {
-                        var temporaryOrdinal = -1;
-                        foreach (var dependent in (IEnumerable)embeddedValue)
-                        {
 #pragma warning disable EF1001 // Internal EF Core API usage.
-                            // #16707
-                            var embeddedEntry = stateManager.TryGetEntry(dependent, fk.DeclaringEntityType);
-                            if (embeddedEntry == null)
-                            {
-                                continue;
-                            }
-
-                            embeddedEntry.SetTemporaryValue(ordinalKeyProperty, temporaryOrdinal, setModified: false);
+                // #16707
+                var stateManager = ((InternalEntityEntry)entry).StateManager;
 #pragma warning restore EF1001 // Internal EF Core API usage.
 
-                            temporaryOrdinal--;
-                        }
-                    }
-                }
-
-                embeddedOrdinal = 1;
+                var embeddedOrdinal = 1;
                 var array = new JArray();
                 foreach (var dependent in (IEnumerable)embeddedValue)
                 {
 #pragma warning disable EF1001 // Internal EF Core API usage.
                     // #16707
-                    var embeddedEntry = ((InternalEntityEntry)entry).StateManager.TryGetEntry(dependent, fk.DeclaringEntityType);
+                    var embeddedEntry = stateManager.TryGetEntry(dependent, fk.DeclaringEntityType)!;
 #pragma warning restore EF1001 // Internal EF Core API usage.
-                    if (embeddedEntry == null)
-                    {
-                        continue;
-                    }
 
                     var embeddedDocument = embeddedDocumentSource.GetCurrentDocument(embeddedEntry);
                     embeddedDocument = embeddedDocument != null
@@ -303,10 +260,58 @@ public virtual JObject CreateDocument(IUpdateEntry entry, int? ordinal)
         return anyPropertyUpdated ? document : null;
     }
 
+    private static void SetTemporaryOrdinals(
+        IUpdateEntry entry,
+        IForeignKey fk,
+        object embeddedValue)
+    {
+        var embeddedOrdinal = 1;
+        var ordinalKeyProperty = FindOrdinalKeyProperty(fk.DeclaringEntityType);
+        if (ordinalKeyProperty != null)
+        {
+#pragma warning disable EF1001 // Internal EF Core API usage.
+            // #16707
+            var stateManager = ((InternalEntityEntry)entry).StateManager;
+#pragma warning restore EF1001 // Internal EF Core API usage.
+            var shouldSetTemporaryKeys = false;
+            foreach (var dependent in (IEnumerable)embeddedValue)
+            {
+#pragma warning disable EF1001 // Internal EF Core API usage.
+                // #16707
+                var embeddedEntry = stateManager.TryGetEntry(dependent, fk.DeclaringEntityType)!;
+
+                if ((int)embeddedEntry.GetCurrentValue(ordinalKeyProperty)! != embeddedOrdinal
+                    && !embeddedEntry.HasTemporaryValue(ordinalKeyProperty))
+                {
+                    shouldSetTemporaryKeys = true;
+                    break;
+                }
+#pragma warning restore EF1001 // Internal EF Core API usage.
+
+                embeddedOrdinal++;
+            }
+
+            if (shouldSetTemporaryKeys)
+            {
+                var temporaryOrdinal = -1;
+                foreach (var dependent in (IEnumerable)embeddedValue)
+                {
+#pragma warning disable EF1001 // Internal EF Core API usage.
+                    // #16707
+                    var embeddedEntry = stateManager.TryGetEntry(dependent, fk.DeclaringEntityType)!;
+
+                    embeddedEntry.SetTemporaryValue(ordinalKeyProperty, temporaryOrdinal, setModified: false);
+#pragma warning restore EF1001 // Internal EF Core API usage.
+
+                    temporaryOrdinal--;
+                }
+            }
+        }
+    }
+
     private static IProperty? FindOrdinalKeyProperty(IEntityType entityType)
         => entityType.FindPrimaryKey()!.Properties.FirstOrDefault(
-            p =>
-                p.GetJsonPropertyName().Length == 0 && p.IsOrdinalKeyProperty());
+            p => p.GetJsonPropertyName().Length == 0 && p.IsOrdinalKeyProperty());
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore.Relational/Extensions/Internal/RelationalPropertyInternalExtensions.cs

@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 namespace Microsoft.EntityFrameworkCore.Metadata.Internal;
@@ -21,7 +21,6 @@ public static bool IsOrdinalKeyProperty(this IReadOnlyProperty property)
         => property.FindContainingPrimaryKey() is IReadOnlyKey key
             && key.Properties.Count > 1
             && !property.IsForeignKey()
-            && property.IsShadowProperty()
             && property.ClrType == typeof(int)
             && property.GetJsonPropertyName() == null;
 }

src/EFCore.Relational/Infrastructure/RelationalModelValidator.cs

@@ -720,6 +720,29 @@ protected virtual void ValidateDefaultValuesOnKeys(
             }
         }
     }
+
+    /// <summary>
+    ///     Validates the mapping/configuration of mutable in the model.
+    /// </summary>
+    /// <param name="model">The model to validate.</param>
+    /// <param name="logger">The logger to use.</param>
+    protected override void ValidateNoMutableKeys(
+        IModel model,
+        IDiagnosticsLogger<DbLoggerCategory.Model.Validation> logger)
+    {
+        foreach (var entityType in model.GetEntityTypes())
+        {
+            foreach (var key in entityType.GetDeclaredKeys())
+            {
+                var mutableProperty = key.Properties.FirstOrDefault(p => p.ValueGenerated.HasFlag(ValueGenerated.OnUpdate));
+                if (mutableProperty != null
+                    && !mutableProperty.IsOrdinalKeyProperty())
+                {
+                    throw new InvalidOperationException(CoreStrings.MutableKeyProperty(mutableProperty.Name));
+                }
+            }
+        }
+    }
 
     /// <summary>
     ///     Validates the mapping/configuration of shared tables in the model.

src/EFCore.Relational/Metadata/Conventions/RelationalValueGenerationConvention.cs

@@ -186,9 +186,9 @@ private void ProcessTableChanged(
             : table.Name != null
                 ? GetValueGenerated(property, table)
                 : property.DeclaringEntityType.IsMappedToJson()
-                && !property.DeclaringEntityType.FindOwnership()!.IsUnique
-                && property.IsOrdinalKeyProperty()
-                    ? ValueGenerated.OnAdd
+                    && !property.DeclaringEntityType.FindOwnership()!.IsUnique
+                    && property.IsOrdinalKeyProperty()
+                    ? ValueGenerated.OnAddOrUpdate
                     : property.GetMappedStoreObjects(StoreObjectType.InsertStoredProcedure).Any()
                         ? GetValueGenerated((IReadOnlyProperty)property)
                         : null;

src/EFCore/ChangeTracking/Internal/InternalEntityEntry.cs

@@ -963,13 +963,7 @@ public bool AddToCollection(
         }
 
         var collection = GetOrCreateShadowCollection(navigationBase);
-        if (!collectionAccessor.ContainsStandalone(collection, value))
-        {
-            collectionAccessor.AddStandalone(collection, value);
-            return true;
-        }
-
-        return false;
+        return collectionAccessor.AddStandalone(collection, value);
     }
 
     /// <summary>

src/EFCore/ChangeTracking/Internal/NavigationFixer.cs

@@ -525,8 +525,11 @@ var targetDependentEntry
                     foreach (InternalEntityEntry dependentEntry in stateManager
                                  .GetDependentsUsingRelationshipSnapshot(entry, foreignKey).ToList())
                     {
+                        if (dependentEntry.EntityState == EntityState.Deleted)
+                        {
+                            continue;
+                        }
                         SetForeignKeyProperties(dependentEntry, entry, foreignKey, setModified: true, fromQuery: false);
-                        UndeleteDependent(dependentEntry, entry);
                     }
 
                     if (foreignKey.IsOwnership)