Allow database default values for FK properties that are part of a co…

…mposite key (#29047)

src/EFCore.Relational/Infrastructure/RelationalModelValidator.cs

@@ -475,6 +475,7 @@ private static void ValidateSproc(IStoredProcedure sproc, string mappingStrategy
  entityType.DisplayName(),
  property.GetBeforeSaveBehavior()));
  }
+
  break;
 
  case StoreObjectType.UpdateStoredProcedure:
@@ -708,19 +709,31 @@ protected virtual void ValidateDefaultValuesOnKeys(
  {
  foreach (var key in entityType.GetDeclaredKeys())
  {
+ IProperty? propertyWithDefault = null;
  foreach (var property in key.Properties)
  {
  var defaultValue = (IConventionAnnotation?)property.FindAnnotation(RelationalAnnotationNames.DefaultValue);
- if (defaultValue?.Value != null
+ if (!property.IsForeignKey()
+ && defaultValue?.Value != null
  && defaultValue.GetConfigurationSource().Overrides(ConfigurationSource.DataAnnotation))
  {
- logger.ModelValidationKeyDefaultValueWarning(property);
+ propertyWithDefault ??= property;
+ }
+ else
+ {
+ propertyWithDefault = null;
+ break;
  }
  }
+
+ if (propertyWithDefault != null)
+ {
+ logger.ModelValidationKeyDefaultValueWarning(propertyWithDefault);
+ }
  }
  }
  }
- 
+
  /// <summary>
  /// Validates the mapping/configuration of mutable in the model.
  /// </summary>

src/EFCore/ChangeTracking/Internal/IValueGenerationManager.cs

@@ -33,6 +33,14 @@ public interface IValueGenerationManager
  /// </summary>
  InternalEntityEntry? Propagate(InternalEntityEntry entry);
 
+ /// <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>
+ Task<InternalEntityEntry?> PropagateAsync(InternalEntityEntry entry, CancellationToken cancellationToken);
+
  /// <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/ChangeTracking/Internal/InternalEntityEntry.cs

@@ -186,23 +186,24 @@ public async Task SetEntityStateAsync(
  {
  var oldState = _stateData.EntityState;
  bool adding;
- Setup();
+ await SetupAsync().ConfigureAwait(false);
 
  if ((adding || oldState is EntityState.Detached)
  && await StateManager.ValueGenerationManager
  .GenerateAsync(this, includePrimaryKey: adding, cancellationToken).ConfigureAwait(false)
  && fallbackState.HasValue)
  {
  entityState = fallbackState.Value;
- Setup();
+ await SetupAsync().ConfigureAwait(false);
  }
 
  SetEntityState(oldState, entityState, acceptChanges, modifyProperties);
 
- void Setup()
+ async Task SetupAsync()
  {
  adding = PrepareForAdd(entityState);
- entityState = PropagateToUnknownKey(oldState, entityState, adding, forceStateWhenUnknownKey);
+ entityState = await PropagateToUnknownKeyAsync(
+ oldState, entityState, adding, forceStateWhenUnknownKey, cancellationToken).ConfigureAwait(false);
  }
  }
 
@@ -214,27 +215,50 @@ private EntityState PropagateToUnknownKey(
  {
  var keyUnknown = IsKeyUnknown;
 
- if (adding
- || (oldState == EntityState.Detached
- && keyUnknown))
+ if (adding || (oldState == EntityState.Detached && keyUnknown))
  {
  var principalEntry = StateManager.ValueGenerationManager.Propagate(this);
 
- if (forceStateWhenUnknownKey.HasValue
- && keyUnknown
- && principalEntry != null
- && principalEntry.EntityState != EntityState.Detached
- && principalEntry.EntityState != EntityState.Deleted)
- {
- entityState = principalEntry.EntityState == EntityState.Added
- ? EntityState.Added
- : forceStateWhenUnknownKey.Value;
- }
+ entityState = ForceState(entityState, forceStateWhenUnknownKey, keyUnknown, principalEntry);
  }
 
  return entityState;
  }
 
+ private async Task<EntityState> PropagateToUnknownKeyAsync(
+ EntityState oldState,
+ EntityState entityState,
+ bool adding,
+ EntityState? forceStateWhenUnknownKey,
+ CancellationToken cancellationToken)
+ {
+ var keyUnknown = IsKeyUnknown;
+
+ if (adding || (oldState == EntityState.Detached && keyUnknown))
+ {
+ var principalEntry = await StateManager.ValueGenerationManager.PropagateAsync(this, cancellationToken).ConfigureAwait(false);
+
+ entityState = ForceState(entityState, forceStateWhenUnknownKey, keyUnknown, principalEntry);
+ }
+
+ return entityState;
+ }
+
+ private static EntityState ForceState(
+ EntityState entityState,
+ EntityState? forceStateWhenUnknownKey,
+ bool keyUnknown,
+ InternalEntityEntry? principalEntry)
+ => forceStateWhenUnknownKey.HasValue
+ && keyUnknown
+ && principalEntry != null
+ && principalEntry.EntityState != EntityState.Detached
+ && principalEntry.EntityState != EntityState.Deleted
+ ? principalEntry.EntityState == EntityState.Added
+ ? EntityState.Added
+ : forceStateWhenUnknownKey.Value
+ : entityState;
+
  private bool PrepareForAdd(EntityState newState)
  {
  if (newState != EntityState.Added

src/EFCore/ChangeTracking/Internal/KeyPropagator.cs

@@ -53,21 +53,7 @@ public KeyPropagator(
 
  if (valueGenerator != null)
  {
- var value = valueGenerator.Next(new EntityEntry(entry));
-
- if (valueGenerator.GeneratesTemporaryValues)
- {
- entry.SetTemporaryValue(property, value);
- }
- else
- {
- entry[property] = value;
- }
-
- if (!valueGenerator.GeneratesStableValues)
- {
- entry.MarkUnknown(property);
- }
+ SetValue(entry, property, valueGenerator, valueGenerator.Next(new EntityEntry(entry)));
  }
  }
 
@@ -101,28 +87,30 @@ public KeyPropagator(
 
  if (valueGenerator != null)
  {
- var value = await valueGenerator.NextAsync(new EntityEntry(entry), cancellationToken)
- .ConfigureAwait(false);
-
- if (valueGenerator.GeneratesTemporaryValues)
- {
- entry.SetTemporaryValue(property, value);
- }
- else
- {
- entry[property] = value;
- }
-
- if (!valueGenerator.GeneratesStableValues)
- {
- entry.MarkUnknown(property);
- }
+ SetValue(
+ entry,
+ property,
+ valueGenerator,
+ await valueGenerator.NextAsync(new EntityEntry(entry), cancellationToken).ConfigureAwait(false));
  }
  }
 
  return principalEntry;
  }
 
+ private static void SetValue(InternalEntityEntry entry, IProperty property, ValueGenerator valueGenerator, object? value)
+ {
+ if (valueGenerator.GeneratesStableValues)
+ {
+ entry[property] = value;
+ }
+ else
+ {
+ entry.SetTemporaryValue(property, value);
+ entry.MarkUnknown(property);
+ }
+ }
+
  private static InternalEntityEntry? TryPropagateValue(InternalEntityEntry entry, IProperty property, IProperty? generationProperty)
  {
  var entityType = entry.EntityType;

src/EFCore/ChangeTracking/Internal/ValueGenerationManager.cs

@@ -57,6 +57,29 @@ public ValueGenerationManager(
  return chosenPrincipal;
  }
 
+ /// <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>
+ public virtual async Task<InternalEntityEntry?> PropagateAsync(InternalEntityEntry entry, CancellationToken cancellationToken)
+ {
+ InternalEntityEntry? chosenPrincipal = null;
+ foreach (var property in entry.EntityType.GetForeignKeyProperties())
+ {
+ if (!entry.HasDefaultValue(property))
+ {
+ continue;
+ }
+
+ var principalEntry = await _keyPropagator.PropagateValueAsync(entry, property, cancellationToken).ConfigureAwait(false);
+ chosenPrincipal ??= principalEntry;
+ }
+
+ return chosenPrincipal;
+ }
+
  /// <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/Metadata/Internal/PropertyExtensions.cs

@@ -136,13 +136,13 @@ public static bool IsKey(this Property property)
  /// </summary>
  public static bool MayBeStoreGenerated(this IProperty property)
  {
- if (property.ValueGenerated != ValueGenerated.Never)
+ if (property.ValueGenerated != ValueGenerated.Never
+ || property.IsForeignKey())
  {
  return true;
  }
 
- if (property.IsKey()
- || property.IsForeignKey())
+ if (property.IsKey())
  {
  var generationProperty = property.FindGenerationProperty();
  return (generationProperty != null)

test/EFCore.Cosmos.FunctionalTests/KeysWithConvertersCosmosTest.cs

@@ -355,8 +355,8 @@ protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext con
  p => p.Value,
  p => new Key(p),
  new ValueComparer<Key>(
- (l, r) => l.Value == r.Value,
- v => v.Value.GetHashCode()));
+ (l, r) => (l == null && r == null) || (l != null && r != null && l.Value == r.Value),
+ v => v == null ? 0 : v.Value.GetHashCode()));
 
  entity.OwnsOne(p => p.Text);
  entity.Navigation(p => p.Text).IsRequired();

test/EFCore.InMemory.FunctionalTests/GraphUpdates/GraphUpdatesInMemoryTest.cs

@@ -10,6 +10,10 @@ public GraphUpdatesInMemoryTest(InMemoryFixture fixture)
  {
  }
 
+ // In-memory database does not have database default values
+ public override Task Can_insert_when_composite_FK_has_default_value_for_one_part(bool async)
+ => Task.CompletedTask;
+
  // In-memory database does not have database default values
  public override Task Can_insert_when_FK_has_default_value(bool async)
  => Task.CompletedTask;

test/EFCore.Specification.Tests/CustomConvertersTestBase.cs

@@ -845,11 +845,15 @@ protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext con
  {
  b.HasMany(e => e.Dependents).WithOne(e => e.Principal).HasForeignKey(e => e.PrincipalId);
  b.Property(e => e.Id).ValueGeneratedNever();
- b.Property(e => e.Id).HasConversion(v => v, v => (int)v);
+ b.Property(e => e.Id).HasConversion<int>(v => v ?? 0, v => v);
  });
 
  modelBuilder.Entity<NonNullableDependent>(
- b => b.Property(e => e.Id).ValueGeneratedNever());
+ b =>
+ {
+ b.Property(e => e.Id).ValueGeneratedNever();
+ b.Property(e => e.PrincipalId).HasConversion<int>(v => v, v => v);
+ });
 
  modelBuilder.Entity<User>(
  b =>

test/EFCore.Specification.Tests/DataAnnotationTestBase.cs

@@ -554,6 +554,25 @@ protected class Profile1
  public virtual Login1 User { get; set; }
  }
 
+ protected class PrincipalA
+ {
+ public int Id { get; set; }
+ public DependantA Dependant { get; set; }
+ }
+
+ protected class DependantA
+ {
+ public int Id { get; set; }
+ public int PrincipalId { get; set; }
+ public PrincipalA Principal { get; set; }
+ }
+
+ protected class PrincipalB
+ {
+ public int Id1 { get; set; }
+ public int Id2 { get; set; }
+ }
+
  [ConditionalFact]
  public virtual IModel Key_and_column_work_together()
  {