Fk match strategy

src/EFCore.PG/Extensions/BuilderExtensions/NpgsqlForeignKeyBuilderExtensions.cs

@@ -0,0 +1,72 @@
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+// ReSharper disable once CheckNamespace
+namespace Microsoft.EntityFrameworkCore;
+
+/// <summary>
+///     Npgsql specific extension methods for configuring foreign keys.
+/// </summary>
+public static class NpgsqlForeignKeyBuilderExtensions
+{
+    /// <summary>
+    ///     Configure the matching strategy to be used with the foreign key.
+    /// </summary>
+    /// <param name="builder">The builder for the foreign key being configured.</param>
+    /// <param name="matchStrategy">The <see cref="PostgresMatchStrategy" /> defining the used matching strategy.</param>
+    /// <remarks>
+    ///     <see href="https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-PARMS-REFERENCES" />
+    /// </remarks>
+    public static ReferenceReferenceBuilder UsesMatchStrategy(this ReferenceReferenceBuilder builder, PostgresMatchStrategy matchStrategy)
+    {
+        Check.NotNull(builder, nameof(builder));
+        Check.IsDefined(matchStrategy, nameof(matchStrategy));
+        builder.Metadata.SetMatchStrategy(matchStrategy);
+        return builder;
+    }
+
+    /// <summary>
+    ///     Configure the matching strategy to be used with the foreign key.
+    /// </summary>
+    /// <param name="builder">The builder for the foreign key being configured.</param>
+    /// <param name="matchStrategy">The <see cref="PostgresMatchStrategy" /> defining the used matching strategy.</param>
+    /// <remarks>
+    ///     <see href="https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-PARMS-REFERENCES" />
+    /// </remarks>
+    public static ReferenceReferenceBuilder<TEntity, TRelatedEntity> UsesMatchStrategy<TEntity, TRelatedEntity>(
+        this ReferenceReferenceBuilder<TEntity, TRelatedEntity> builder,
+        PostgresMatchStrategy matchStrategy)
+        where TEntity : class
+        where TRelatedEntity : class
+        => (ReferenceReferenceBuilder<TEntity, TRelatedEntity>)UsesMatchStrategy((ReferenceReferenceBuilder)builder, matchStrategy);
+
+    /// <summary>
+    ///     Configure the matching strategy to be used with the foreign key.
+    /// </summary>
+    /// <param name="builder">The builder for the foreign key being configured.</param>
+    /// <param name="matchStrategy">The <see cref="PostgresMatchStrategy" /> defining the used matching strategy.</param>
+    /// <remarks>
+    ///     <see href="https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-PARMS-REFERENCES" />
+    /// </remarks>
+    public static ReferenceCollectionBuilder UsesMatchStrategy(this ReferenceCollectionBuilder builder, PostgresMatchStrategy matchStrategy)
+    {
+        Check.NotNull(builder, nameof(builder));
+        Check.IsDefined(matchStrategy, nameof(matchStrategy));
+        builder.Metadata.SetMatchStrategy(matchStrategy);
+        return builder;
+    }
+
+    /// <summary>
+    ///     Configure the matching strategy to be used with the foreign key.
+    /// </summary>
+    /// <param name="builder">The builder for the foreign key being configured.</param>
+    /// <param name="matchStrategy">The <see cref="PostgresMatchStrategy" /> defining the used matching strategy.</param>
+    /// <remarks>
+    ///     <see href="https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-PARMS-REFERENCES" />
+    /// </remarks>
+    public static ReferenceCollectionBuilder UsesMatchStrategy<TEntity, TRelatedEntity>(
+        this ReferenceCollectionBuilder<TEntity, TRelatedEntity> builder,
+        PostgresMatchStrategy matchStrategy)
+        where TEntity : class
+        where TRelatedEntity : class
+        => (ReferenceCollectionBuilder<TEntity, TRelatedEntity>)UsesMatchStrategy((ReferenceCollectionBuilder)builder, matchStrategy);
+}

src/EFCore.PG/Extensions/MetadataExtensions/NpgsqlForeignKeyExtensions.cs

@@ -0,0 +1,30 @@
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata.Internal;
+// ReSharper disable once CheckNamespace
+
+namespace Microsoft.EntityFrameworkCore;
+
+/// <summary>
+///     Npgsql specific extension methods for <see cref="IForeignKey" />.
+/// </summary>
+public static class NpgsqlForeignKeyExtensions
+{
+    /// <summary>
+    ///     Sets the <see cref="PostgresMatchStrategy" /> for a foreign key.
+    /// </summary>
+    /// <param name="foreignKey">the foreign key being configured.</param>
+    /// <param name="matchStrategy">the <see cref="PostgresMatchStrategy" /> defining the used matching strategy.</param>
+    /// <remarks>
+    ///     <see href="https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-PARMS-REFERENCES" />
+    /// </remarks>
+    public static void SetMatchStrategy(this IMutableForeignKey foreignKey, PostgresMatchStrategy matchStrategy)
+        => foreignKey.SetOrRemoveAnnotation(NpgsqlAnnotationNames.MatchStrategy, matchStrategy);
+
+    /// <summary>
+    ///     Returns the assigned <see cref="PostgresMatchStrategy" /> for the provided foreign key
+    /// </summary>
+    /// <param name="foreignKey">the foreign key</param>
+    /// <returns>the <see cref="PostgresMatchStrategy" /> if assigned, null otherwise</returns>
+    public static PostgresMatchStrategy? GetMatchStrategy(this IReadOnlyForeignKey foreignKey)
+        => (PostgresMatchStrategy?)foreignKey[NpgsqlAnnotationNames.MatchStrategy];
+}

src/EFCore.PG/Metadata/Internal/NpgsqlAnnotationNames.cs

@@ -271,4 +271,12 @@ public static class NpgsqlAnnotationNames
     /// </summary>
     // Replaced by IsDescending in EF Core 7.0
     public const string IndexSortOrder = Prefix + "IndexSortOrder";
+
+    /// <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 const string MatchStrategy = Prefix + "MatchStrategy";
 }

src/EFCore.PG/Metadata/Internal/NpgsqlAnnotationProvider.cs

@@ -200,6 +200,28 @@ public override IEnumerable<IAnnotation> For(ITableIndex index, bool designTime)
         }
     }
 
+    /// <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 override IEnumerable<IAnnotation> For(IForeignKeyConstraint foreignKey, bool designTime)
+    {
+        if (!designTime)
+        {
+            yield break;
+        }
+
+        foreach (var item in foreignKey.MappedForeignKeys)
+        {
+            if (item.GetMatchStrategy() is { } match)
+            {
+                yield return new Annotation(NpgsqlAnnotationNames.MatchStrategy, match);
+            }
+        }
+    }
+
     /// <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.PG/Metadata/PostgresMatchStrategy.cs

@@ -0,0 +1,25 @@
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+/// <summary>
+///     Matching strategies for a foreign key.
+/// </summary>
+/// <remarks>
+///     <see href="https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-PARMS-REFERENCES" />
+/// </remarks>
+public enum PostgresMatchStrategy
+{
+    /// <summary>
+    ///     The default matching strategy, allows any foreign key column to be NULL.
+    /// </summary>
+    Simple = 0,
+
+    /// <summary>
+    ///     Currently not implemented in PostgreSQL.
+    /// </summary>
+    Partial = 1,
+
+    /// <summary>
+    ///     Requires the foreign key to either have all columns to be set or all columns to be NULL.
+    /// </summary>
+    Full = 2
+}

src/EFCore.PG/Migrations/NpgsqlMigrationsSqlGenerator.cs

@@ -1,3 +1,4 @@
+using System.ComponentModel;
 using System.Globalization;
 using System.Text;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal;
@@ -1447,6 +1448,53 @@ protected virtual void GenerateDropRange(PostgresRange rangeType, IModel? model,
 
     #endregion Range management
 
+    #region MatchingStrategy management
+
+    /// <inheritdoc />
+    protected override void ForeignKeyConstraint(AddForeignKeyOperation operation, IModel? model, MigrationCommandListBuilder builder)
+    {
+        if (operation.Name != null)
+        {
+            builder.Append("CONSTRAINT ").Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name)).Append(" ");
+        }
+
+        builder.Append("FOREIGN KEY (").Append(ColumnList(operation.Columns)).Append(") REFERENCES ")
+            .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.PrincipalTable, operation.PrincipalSchema));
+        if (operation.PrincipalColumns != null)
+        {
+            builder.Append(" (").Append(ColumnList(operation.PrincipalColumns)).Append(")");
+        }
+
+        if (operation[NpgsqlAnnotationNames.MatchStrategy] is PostgresMatchStrategy matchStrategy)
+        {
+            builder.Append(" MATCH ")
+                .Append(TranslateMatchStrategy(matchStrategy));
+        }
+
+        if (operation.OnUpdate != 0)
+        {
+            builder.Append(" ON UPDATE ");
+            ForeignKeyAction(operation.OnUpdate, builder);
+        }
+
+        if (operation.OnDelete != 0)
+        {
+            builder.Append(" ON DELETE ");
+            ForeignKeyAction(operation.OnDelete, builder);
+        }
+    }
+
+    private static string TranslateMatchStrategy(PostgresMatchStrategy matchStrategy)
+        => matchStrategy switch
+        {
+            PostgresMatchStrategy.Simple => "SIMPLE",
+            PostgresMatchStrategy.Partial => "PARTIAL",
+            PostgresMatchStrategy.Full => "FULL",
+            _ => throw new InvalidEnumArgumentException(nameof(matchStrategy), (int)matchStrategy, typeof(PostgresMatchStrategy))
+        };
+
+    #endregion MatchingStrategy management
+
     /// <inheritdoc />
     protected override void Generate(
         DropIndexOperation operation,

src/Shared/Check.cs

@@ -1,3 +1,4 @@
+using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using JetBrains.Annotations;
 
@@ -127,4 +128,15 @@ public static void DebugAssert([DoesNotReturnIf(false)] bool condition, string m
     [DoesNotReturn]
     public static void DebugFail(string message)
         => throw new Exception($"Check.DebugFail failed: {message}");
+
+    public static void IsDefined<T>(
+        T value,
+        [InvokerParameterName] string parameterName)
+        where T : struct, Enum
+    {
+        if (!Enum.IsDefined(value))
+        {
+            throw new InvalidEnumArgumentException(parameterName, Convert.ToInt32(value), typeof(T));
+        }
+    }
 }

test/EFCore.PG.FunctionalTests/Migrations/MigrationsNpgsqlTest.cs

@@ -1147,7 +1147,8 @@ await Test(
                     e.Property<int>("Y");
                 }),
             builder => builder.Entity("People").Property<int>("Sum")
-                .HasComputedColumnSql("""
+                .HasComputedColumnSql(
+                    """
                     "X" + "Y"
                     """, stored: true),
             builder => builder.Entity("People").Property<int>("Sum"),
@@ -1671,7 +1672,8 @@ await Test(
                 "People", b =>
                 {
                     b.Property<string>("Name");
-                    b.Property<string>("Name2").HasComputedColumnSql("""
+                    b.Property<string>("Name2").HasComputedColumnSql(
+                        """
                         "Name"
                         """, stored: true);
                 }),
@@ -1681,7 +1683,8 @@ await Test(
             model =>
             {
                 var computedColumn = Assert.Single(Assert.Single(model.Tables).Columns, c => c.Name == "Name2");
-                Assert.Equal("""
+                Assert.Equal(
+                    """
                     "Name"
                     """, computedColumn.ComputedColumnSql);
                 Assert.Equal(NonDefaultCollation, computedColumn.Collation);
@@ -1938,7 +1941,8 @@ await Test(
             _ => { },
             builder => builder.Entity("People").HasIndex("Name")
                 .IncludeProperties("FirstName", "LastName")
-                .HasFilter("""
+                .HasFilter(
+                    """
                     "Name" IS NOT NULL
                     """),
             model =>
@@ -2031,7 +2035,8 @@ await Test(
             builder => builder.Entity("People").HasIndex("Name")
                 .IsUnique()
                 .IncludeProperties("FirstName", "LastName")
-                .HasFilter("""
+                .HasFilter(
+                    """
                     "Name" IS NOT NULL
                     """),
             model =>
@@ -2460,6 +2465,60 @@ public override async Task Drop_check_constraint()
         AssertSql("""ALTER TABLE "People" DROP CONSTRAINT "CK_People_Foo";""");
     }
 
+    [Theory]
+    [InlineData(PostgresMatchStrategy.Simple, "SIMPLE", false)]
+    [InlineData(PostgresMatchStrategy.Partial, "PARTIAL", true)]
+    [InlineData(PostgresMatchStrategy.Full, "FULL", false)]
+    public async Task Add_foreign_key_with_match_strategy(PostgresMatchStrategy strategy, string matchValue, bool throws)
+    {
+        var runningTest = Test(
+            builder =>
+            {
+                builder.Entity(
+                    "Customers", delegate(EntityTypeBuilder e)
+                    {
+                        e.Property<int>("Id");
+                        e.HasKey("Id");
+                        e.Property<int>("AddressId");
+                    });
+                builder.Entity(
+                    "Orders", delegate(EntityTypeBuilder e)
+                    {
+                        e.Property<int>("Id");
+                        e.Property<int>("CustomerId");
+                    });
+            },
+            _ => { },
+            builder =>
+            {
+                builder.Entity("Orders")
+                    .HasOne("Customers")
+                    .WithMany()
+                    .HasForeignKey("CustomerId")
+                    .UsesMatchStrategy(strategy)
+                    .HasConstraintName("FK_Foo");
+            },
+            asserter: null);
+
+        if (throws)
+        {
+            await Assert.ThrowsAsync<PostgresException>(() => runningTest);
+        }
+        else
+        {
+            await runningTest;
+        }
+
+        AssertSql(
+            """
+CREATE INDEX "IX_Orders_CustomerId" ON "Orders" ("CustomerId");
+""",
+            //
+            $"""
+ALTER TABLE "Orders" ADD CONSTRAINT "FK_Foo" FOREIGN KEY ("CustomerId") REFERENCES "Customers" ("Id") MATCH {matchValue} ON DELETE CASCADE;
+""");
+    }
+
     #endregion
 
     #region Sequence
@@ -2727,7 +2786,6 @@ SELECT setval(
 """);
     }
 
-
     #endregion Data seeding
 
     public override async Task Add_required_primitve_collection_with_custom_default_value_sql_to_existing_table()
@@ -3225,7 +3283,6 @@ public override async Task Add_required_primitve_collection_with_custom_converte
         AssertSql("""ALTER TABLE "Customers" ADD "Numbers" text NOT NULL DEFAULT 'some numbers';""");
     }
 
-
     protected override string NonDefaultCollation
         => "POSIX";