Allow excluding foreign key from migrations

src/EFCore.Relational/Design/AnnotationCodeGenerator.cs

@@ -435,6 +435,12 @@ public virtual IReadOnlyList<MethodCallCodeFragment> GenerateFluentApiCalls(
             nameof(RelationalForeignKeyBuilderExtensions.HasConstraintName),
             methodCallCodeFragments);
 
+        GenerateSimpleFluentApiCall(
+            annotations,
+            RelationalAnnotationNames.IsForeignKeyExcludedFromMigrations,
+            nameof(RelationalForeignKeyBuilderExtensions.ExcludeFromMigrations),
+            methodCallCodeFragments);
+
         methodCallCodeFragments.AddRange(GenerateFluentApiCallsHelper(foreignKey, annotations, GenerateFluentApi));
 
         return methodCallCodeFragments;
@@ -1051,6 +1057,7 @@ private static void GenerateSimpleFluentApiCall(
         if (annotations.TryGetValue(annotationName, out var annotation))
         {
             annotations.Remove(annotationName);
+
             if (annotation.Value is { } annotationValue)
             {
                 methodCallCodeFragments.Add(

src/EFCore.Relational/Design/Internal/RelationalCSharpRuntimeAnnotationCodeGenerator.cs

@@ -2167,6 +2167,7 @@ public override void Generate(IForeignKey foreignKey, CSharpRuntimeAnnotationCod
         if (parameters.IsRuntime)
         {
             parameters.Annotations.Remove(RelationalAnnotationNames.ForeignKeyMappings);
+            parameters.Annotations.Remove(RelationalAnnotationNames.IsForeignKeyExcludedFromMigrations);
         }
 
         base.Generate(foreignKey, parameters);

src/EFCore.Relational/Extensions/RelationalForeignKeyBuilderExtensions.cs

@@ -173,4 +173,166 @@ public static bool CanSetConstraintName(
         string? name,
         bool fromDataAnnotation = false)
         => relationship.CanSetAnnotation(RelationalAnnotationNames.Name, name, fromDataAnnotation);
+
+    /// <summary>
+    ///     Configures whether the foreign key constraint is excluded from migrations
+    ///     when targeting a relational database.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see> for more information and examples.
+    /// </remarks>
+    /// <param name="referenceCollectionBuilder">The builder being used to configure the relationship.</param>
+    /// <param name="excluded">A value indicating whether the foreign key constraint is excluded from migrations.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    public static ReferenceCollectionBuilder ExcludeFromMigrations(
+        this ReferenceCollectionBuilder referenceCollectionBuilder,
+        bool excluded = true)
+    {
+        referenceCollectionBuilder.Metadata.SetIsExcludedFromMigrations(excluded);
+
+        return referenceCollectionBuilder;
+    }
+
+    /// <summary>
+    ///     Configures whether the foreign key constraint is excluded from migrations
+    ///     when targeting a relational database.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see> for more information and examples.
+    /// </remarks>
+    /// <param name="referenceCollectionBuilder">The builder being used to configure the relationship.</param>
+    /// <param name="excluded">A value indicating whether the foreign key constraint is excluded from migrations.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    /// <typeparam name="TEntity">The principal entity type in this relationship.</typeparam>
+    /// <typeparam name="TRelatedEntity">The dependent entity type in this relationship.</typeparam>
+    public static ReferenceCollectionBuilder<TEntity, TRelatedEntity> ExcludeFromMigrations<TEntity, TRelatedEntity>(
+        this ReferenceCollectionBuilder<TEntity, TRelatedEntity> referenceCollectionBuilder,
+        bool excluded = true)
+        where TEntity : class
+        where TRelatedEntity : class
+        => (ReferenceCollectionBuilder<TEntity, TRelatedEntity>)ExcludeFromMigrations(
+            (ReferenceCollectionBuilder)referenceCollectionBuilder, excluded);
+
+    /// <summary>
+    ///     Configures whether the foreign key constraint is excluded from migrations
+    ///     when targeting a relational database.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see> for more information and examples.
+    /// </remarks>
+    /// <param name="referenceReferenceBuilder">The builder being used to configure the relationship.</param>
+    /// <param name="excluded">A value indicating whether the foreign key constraint is excluded from migrations.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    public static ReferenceReferenceBuilder ExcludeFromMigrations(
+        this ReferenceReferenceBuilder referenceReferenceBuilder,
+        bool excluded = true)
+    {
+        referenceReferenceBuilder.Metadata.SetIsExcludedFromMigrations(excluded);
+
+        return referenceReferenceBuilder;
+    }
+
+    /// <summary>
+    ///     Configures whether the foreign key constraint is excluded from migrations
+    ///     when targeting a relational database.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see> for more information and examples.
+    /// </remarks>
+    /// <param name="referenceReferenceBuilder">The builder being used to configure the relationship.</param>
+    /// <param name="excluded">A value indicating whether the foreign key constraint is excluded from migrations.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    /// <typeparam name="TEntity">The entity type on one end of the relationship.</typeparam>
+    /// <typeparam name="TRelatedEntity">The entity type on the other end of the relationship.</typeparam>
+    public static ReferenceReferenceBuilder<TEntity, TRelatedEntity> ExcludeFromMigrations<TEntity, TRelatedEntity>(
+        this ReferenceReferenceBuilder<TEntity, TRelatedEntity> referenceReferenceBuilder,
+        bool excluded = true)
+        where TEntity : class
+        where TRelatedEntity : class
+        => (ReferenceReferenceBuilder<TEntity, TRelatedEntity>)ExcludeFromMigrations(
+            (ReferenceReferenceBuilder)referenceReferenceBuilder, excluded);
+
+    /// <summary>
+    ///     Configures whether the foreign key constraint is excluded from migrations
+    ///     when targeting a relational database.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see> for more information and examples.
+    /// </remarks>
+    /// <param name="ownershipBuilder">The builder being used to configure the relationship.</param>
+    /// <param name="excluded">A value indicating whether the foreign key constraint is excluded from migrations.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    public static OwnershipBuilder ExcludeFromMigrations(
+        this OwnershipBuilder ownershipBuilder,
+        bool excluded = true)
+    {
+        ownershipBuilder.Metadata.SetIsExcludedFromMigrations(excluded);
+
+        return ownershipBuilder;
+    }
+
+    /// <summary>
+    ///     Configures whether the foreign key constraint is excluded from migrations
+    ///     when targeting a relational database.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see> for more information and examples.
+    /// </remarks>
+    /// <param name="ownershipBuilder">The builder being used to configure the relationship.</param>
+    /// <param name="excluded">A value indicating whether the foreign key constraint is excluded from migrations.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    /// <typeparam name="TEntity">The entity type on one end of the relationship.</typeparam>
+    /// <typeparam name="TDependentEntity">The entity type on the other end of the relationship.</typeparam>
+    public static OwnershipBuilder<TEntity, TDependentEntity> ExcludeFromMigrations<TEntity, TDependentEntity>(
+        this OwnershipBuilder<TEntity, TDependentEntity> ownershipBuilder,
+        bool excluded = true)
+        where TEntity : class
+        where TDependentEntity : class
+        => (OwnershipBuilder<TEntity, TDependentEntity>)ExcludeFromMigrations(
+            (OwnershipBuilder)ownershipBuilder, excluded);
+
+    /// <summary>
+    ///     Configures whether the foreign key constraint is excluded from migrations
+    ///     when targeting a relational database.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see> for more information and examples.
+    /// </remarks>
+    /// <param name="relationship">The builder being used to configure the relationship.</param>
+    /// <param name="excluded">A value indicating whether the foreign key constraint is excluded from migrations.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns>
+    ///     The same builder instance if the configuration was applied,
+    ///     <see langword="null" /> otherwise.
+    /// </returns>
+    public static IConventionForeignKeyBuilder? ExcludeFromMigrations(
+        this IConventionForeignKeyBuilder relationship,
+        bool? excluded,
+        bool fromDataAnnotation = false)
+    {
+        if (!relationship.CanSetExcludeFromMigrations(excluded, fromDataAnnotation))
+        {
+            return null;
+        }
+
+        relationship.Metadata.SetIsExcludedFromMigrations(excluded, fromDataAnnotation);
+        return relationship;
+    }
+
+    /// <summary>
+    ///     Returns a value indicating whether the foreign key constraint exclusion from migrations can be set
+    ///     from the current configuration source.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see> for more information and examples.
+    /// </remarks>
+    /// <param name="relationship">The builder being used to configure the relationship.</param>
+    /// <param name="excluded">A value indicating whether the foreign key constraint is excluded from migrations.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns><see langword="true" /> if the configuration can be applied.</returns>
+    public static bool CanSetExcludeFromMigrations(
+        this IConventionForeignKeyBuilder relationship,
+        bool? excluded,
+        bool fromDataAnnotation = false)
+        => relationship.CanSetAnnotation(RelationalAnnotationNames.IsForeignKeyExcludedFromMigrations, excluded, fromDataAnnotation);
 }

src/EFCore.Relational/Extensions/RelationalForeignKeyExtensions.cs

@@ -288,4 +288,45 @@ static bool IsMapped(IReadOnlyForeignKey foreignKey, StoreObjectIdentifier store
         this IForeignKey foreignKey,
         in StoreObjectIdentifier storeObject)
         => (IForeignKey?)((IReadOnlyForeignKey)foreignKey).FindSharedObjectRootForeignKey(storeObject);
+
+    /// <summary>
+    ///     Returns a value indicating whether the foreign key constraint is excluded from migrations.
+    /// </summary>
+    /// <param name="foreignKey">The foreign key.</param>
+    /// <returns><see langword="true" /> if the foreign key constraint is excluded from migrations.</returns>
+    public static bool IsExcludedFromMigrations(this IReadOnlyForeignKey foreignKey)
+        => (bool?)foreignKey[RelationalAnnotationNames.IsForeignKeyExcludedFromMigrations] ?? false;
+
+    /// <summary>
+    ///     Sets a value indicating whether the foreign key constraint is excluded from migrations.
+    /// </summary>
+    /// <param name="foreignKey">The foreign key.</param>
+    /// <param name="excluded">The value to set.</param>
+    public static void SetIsExcludedFromMigrations(this IMutableForeignKey foreignKey, bool? excluded)
+        => foreignKey.SetOrRemoveAnnotation(RelationalAnnotationNames.IsForeignKeyExcludedFromMigrations, excluded);
+
+    /// <summary>
+    ///     Sets a value indicating whether the foreign key constraint is excluded from migrations.
+    /// </summary>
+    /// <param name="foreignKey">The foreign key.</param>
+    /// <param name="excluded">The value to set.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns>The configured value.</returns>
+    public static bool? SetIsExcludedFromMigrations(
+        this IConventionForeignKey foreignKey,
+        bool? excluded,
+        bool fromDataAnnotation = false)
+        => (bool?)foreignKey.SetOrRemoveAnnotation(
+            RelationalAnnotationNames.IsForeignKeyExcludedFromMigrations,
+            excluded,
+            fromDataAnnotation)?.Value;
+
+    /// <summary>
+    ///     Gets the <see cref="ConfigurationSource" /> for the foreign key exclusion from migrations.
+    /// </summary>
+    /// <param name="foreignKey">The foreign key.</param>
+    /// <returns>The <see cref="ConfigurationSource" /> for the foreign key exclusion from migrations.</returns>
+    public static ConfigurationSource? GetIsExcludedFromMigrationsConfigurationSource(this IConventionForeignKey foreignKey)
+        => foreignKey.FindAnnotation(RelationalAnnotationNames.IsForeignKeyExcludedFromMigrations)
+            ?.GetConfigurationSource();
 }

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

@@ -505,6 +505,7 @@ protected override void ProcessForeignKeyAnnotations(
         if (runtime)
         {
             annotations.Remove(RelationalAnnotationNames.ForeignKeyMappings);
+            annotations.Remove(RelationalAnnotationNames.IsForeignKeyExcludedFromMigrations);
         }
     }
 

src/EFCore.Relational/Metadata/IForeignKeyConstraint.cs

@@ -55,6 +55,11 @@ IReadOnlyList<IColumn> PrincipalColumns
     /// </summary>
     ReferentialAction OnDeleteAction { get; }
 
+    /// <summary>
+    ///     Gets a value indicating whether the foreign key constraint is excluded from migrations.
+    /// </summary>
+    bool IsExcludedFromMigrations { get; }
+
     /// <summary>
     ///     <para>
     ///         Creates a human-readable representation of the given metadata.

src/EFCore.Relational/Metadata/Internal/ForeignKeyConstraint.cs

@@ -102,6 +102,15 @@ public override bool IsReadOnly
     /// <inheritdoc />
     public virtual ReferentialAction OnDeleteAction { get; set; }
 
+    /// <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 bool IsExcludedFromMigrations
+        => ((IReadOnlyForeignKey)MappedForeignKeys.First()).IsExcludedFromMigrations();
+
     /// <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.Relational/Metadata/Internal/RelationalForeignKeyExtensions.cs

@@ -161,6 +161,23 @@ is not { } principalColumns
             return false;
         }
 
+        if (foreignKey.IsExcludedFromMigrations() != duplicateForeignKey.IsExcludedFromMigrations())
+        {
+            if (shouldThrow)
+            {
+                throw new InvalidOperationException(
+                    RelationalStrings.DuplicateForeignKeyExcludedFromMigrationsMismatch(
+                        foreignKey.Properties.Format(),
+                        foreignKey.DeclaringEntityType.DisplayName(),
+                        duplicateForeignKey.Properties.Format(),
+                        duplicateForeignKey.DeclaringEntityType.DisplayName(),
+                        foreignKey.DeclaringEntityType.GetSchemaQualifiedTableName(),
+                        foreignKey.GetConstraintName(storeObject, principalTable.Value)));
+            }
+
+            return false;
+        }
+
         return true;
     }
 

src/EFCore.Relational/Metadata/RelationalAnnotationNames.cs

@@ -174,6 +174,11 @@ public static class RelationalAnnotationNames
     /// </summary>
     public const string IsTableExcludedFromMigrations = Prefix + "IsTableExcludedFromMigrations";
 
+    /// <summary>
+    ///     The name for the annotation determining whether the foreign key constraint is excluded from migrations.
+    /// </summary>
+    public const string IsForeignKeyExcludedFromMigrations = Prefix + "IsForeignKeyExcludedFromMigrations";
+
     /// <summary>
     ///     The name for the annotation determining the mapping strategy for inherited properties.
     /// </summary>
@@ -396,6 +401,7 @@ public static class RelationalAnnotationNames
         IsFixedLength,
         ViewDefinitionSql,
         IsTableExcludedFromMigrations,
+        IsForeignKeyExcludedFromMigrations,
         MappingStrategy,
         RelationalModel,
         RelationalModelFactory,

src/EFCore.Relational/Migrations/Internal/MigrationsModelDiffer.cs

@@ -1429,7 +1429,8 @@ protected virtual IEnumerable<MigrationOperation> Diff(
     protected virtual IEnumerable<MigrationOperation> Add(IForeignKeyConstraint target, DiffContext diffContext)
     {
         var targetTable = target.Table;
-        if (targetTable.IsExcludedFromMigrations)
+        if (targetTable.IsExcludedFromMigrations
+            || target.IsExcludedFromMigrations)
         {
             yield break;
         }
@@ -1456,7 +1457,8 @@ protected virtual IEnumerable<MigrationOperation> Add(IForeignKeyConstraint targ
     protected virtual IEnumerable<MigrationOperation> Remove(IForeignKeyConstraint source, DiffContext diffContext)
     {
         var sourceTable = source.Table;
-        if (sourceTable.IsExcludedFromMigrations)
+        if (sourceTable.IsExcludedFromMigrations
+            || source.IsExcludedFromMigrations)
         {
             yield break;
         }