Implement Precompiled Query Tests (#3289)

src/EFCore.PG/Query/Expressions/Internal/PgAnyExpression.cs

@@ -80,7 +80,7 @@ public virtual PgAnyExpression Update(SqlExpression item, SqlExpression array)
  public override Expression Quote()
  => New(
  _quotingConstructor ??= typeof(PgAnyExpression).GetConstructor(
- [typeof(SqlExpression), typeof(SqlExpression), typeof(PgAllOperatorType), typeof(RelationalTypeMapping)])!,
+ [typeof(SqlExpression), typeof(SqlExpression), typeof(PgAnyOperatorType), typeof(RelationalTypeMapping)])!,
  Item.Quote(),
  Array.Quote(),
  Constant(OperatorType),

src/EFCore.PG/Query/Internal/NpgsqlQueryCompilationContext.cs

@@ -18,7 +18,25 @@ public NpgsqlQueryCompilationContext(
  QueryCompilationContextDependencies dependencies,
  RelationalQueryCompilationContextDependencies relationalDependencies,
  bool async)
- : base(dependencies, relationalDependencies, async)
+ : this(
+ dependencies, relationalDependencies, async, precompiling: false,
+ nonNullableReferenceTypeParameters: null)
+ {
+ }
+
+ /// <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 NpgsqlQueryCompilationContext(
+ QueryCompilationContextDependencies dependencies,
+ RelationalQueryCompilationContextDependencies relationalDependencies,
+ bool async,
+ bool precompiling,
+ IReadOnlySet<string>? nonNullableReferenceTypeParameters)
+ : base(dependencies, relationalDependencies, async, precompiling, nonNullableReferenceTypeParameters)
  {
  }
 
@@ -30,4 +48,7 @@ public NpgsqlQueryCompilationContext(
  /// </summary>
  public override bool IsBuffering
  => base.IsBuffering || QuerySplittingBehavior == Microsoft.EntityFrameworkCore.QuerySplittingBehavior.SplitQuery;
+
+ /// <inheritdoc />
+ public override bool SupportsPrecompiledQuery => true;
 }

src/EFCore.PG/Query/Internal/NpgsqlQueryCompilationContextFactory.cs

@@ -36,4 +36,15 @@ public NpgsqlQueryCompilationContextFactory(
  /// </summary>
  public virtual QueryCompilationContext Create(bool async)
  => new NpgsqlQueryCompilationContext(_dependencies, _relationalDependencies, async);
+
+ /// <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 QueryCompilationContext CreatePrecompiled(bool async, IReadOnlySet<string> nonNullableReferenceTypeParameters)
+ => new NpgsqlQueryCompilationContext(
+ _dependencies, _relationalDependencies, async, precompiling: true,
+ nonNullableReferenceTypeParameters);
 }

src/EFCore.PG/Query/Internal/NpgsqlSqlTranslatingExpressionVisitor.cs

@@ -525,7 +525,13 @@ when patternParameter.Name.StartsWith(QueryCompilationContext.QueryParameterPref
  }
  }
 
- private static string? ConstructLikePatternParameter(
+ /// <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 static string? ConstructLikePatternParameter(
  QueryContext queryContext,
  string baseParameterName,
  StartsEndsWithContains methodType)
@@ -548,10 +554,36 @@ when patternParameter.Name.StartsWith(QueryCompilationContext.QueryParameterPref
  _ => throw new UnreachableException()
  };
 
- private enum StartsEndsWithContains
+ /// <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 enum StartsEndsWithContains
  {
+ /// <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>
  StartsWith,
+
+ /// <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>
  EndsWith,
+
+ /// <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>
  Contains
  }
 

test/EFCore.PG.FunctionalTests/NpgsqlComplianceTest.cs

@@ -10,11 +10,6 @@ public class NpgsqlComplianceTest : RelationalComplianceTestBase
  typeof(UdfDbFunctionTestBase<>),
  typeof(UpdateSqlGeneratorTestBase),
 
- // Precompiled query/NativeAOT (#3257)
- typeof(AdHocPrecompiledQueryRelationalTestBase),
- typeof(PrecompiledQueryRelationalTestBase),
- typeof(PrecompiledSqlPregenerationQueryRelationalTestBase),
-
  // Disabled
  typeof(GraphUpdatesTestBase<>),
  typeof(ProxyGraphUpdatesTestBase<>),

test/EFCore.PG.FunctionalTests/Query/AdHocPrecompiledQueryNpgsqlTest.cs

@@ -0,0 +1,91 @@
+using Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure;
+using Npgsql.EntityFrameworkCore.PostgreSQL.TestUtilities;
+
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Query;
+
+public class AdHocPrecompiledQueryNpgsqlTest(ITestOutputHelper testOutputHelper)
+ : AdHocPrecompiledQueryRelationalTestBase(testOutputHelper)
+{
+ protected override bool AlwaysPrintGeneratedSources
+ => false;
+
+ public override async Task Index_no_evaluatability()
+ {
+ await base.Index_no_evaluatability();
+
+ AssertSql(
+ """
+SELECT j."Id", j."IntList", j."JsonThing"
+FROM "JsonEntities" AS j
+WHERE j."IntList"[j."Id" + 1] = 2
+""");
+ }
+
+ public override async Task Index_with_captured_variable()
+ {
+ await base.Index_with_captured_variable();
+
+ AssertSql(
+ """
+@__id_0='1'
+
+SELECT j."Id", j."IntList", j."JsonThing"
+FROM "JsonEntities" AS j
+WHERE j."IntList"[@__id_0 + 1] = 2
+""");
+ }
+
+ public override async Task JsonScalar()
+ {
+ await base.JsonScalar();
+
+ AssertSql(
+ """
+SELECT j."Id", j."IntList", j."JsonThing"
+FROM "JsonEntities" AS j
+WHERE (j."JsonThing" ->> 'StringProperty') = 'foo'
+""");
+ }
+
+ public override async Task Materialize_non_public()
+ {
+ await base.Materialize_non_public();
+
+ AssertSql(
+ """
+@p0='10' (Nullable = true)
+@p1='9' (Nullable = true)
+@p2='8' (Nullable = true)
+
+INSERT INTO "NonPublicEntities" ("PrivateAutoProperty", "PrivateProperty", "_privateField")
+VALUES (@p0, @p1, @p2)
+RETURNING "Id";
+""",
+ //
+ """
+SELECT n."Id", n."PrivateAutoProperty", n."PrivateProperty", n."_privateField"
+FROM "NonPublicEntities" AS n
+LIMIT 2
+""");
+ }
+
+ [ConditionalFact]
+ public virtual void Check_all_tests_overridden()
+ => TestHelpers.AssertAllMethodsOverridden(GetType());
+
+ protected override ITestStoreFactory TestStoreFactory
+ => NpgsqlTestStoreFactory.Instance;
+
+ protected override PrecompiledQueryTestHelpers PrecompiledQueryTestHelpers
+ => NpgsqlPrecompiledQueryTestHelpers.Instance;
+
+ protected override DbContextOptionsBuilder AddOptions(DbContextOptionsBuilder builder)
+ {
+ builder = base.AddOptions(builder);
+
+ // TODO: Figure out if there's a nice way to continue using the retrying strategy
+ var sqlServerOptionsBuilder = new NpgsqlDbContextOptionsBuilder(builder);
+ sqlServerOptionsBuilder.ExecutionStrategy(d => new NonRetryingExecutionStrategy(d));
+ return builder;
+ }
+}