From a8af47a8a8d404fd7c1568122ed6c9c008bd1826 Mon Sep 17 00:00:00 2001 From: Shay Rojansky Date: Tue, 17 Nov 2026 15:56:46 +0100 Subject: [PATCH 1/2] Fix nullability metadata for PostgreSQL translations Correct nullable range, date-part, LTree and spatial translations. Fix array_remove propagation and give array concatenation PostgreSQL-specific nullability handling. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- ...lNetTopologySuiteMemberTranslatorPlugin.cs | 5 +- ...TopologySuiteMethodCallTranslatorPlugin.cs | 7 +- .../NpgsqlNodaTimeMemberTranslatorPlugin.cs | 6 +- .../NpgsqlDateTimeMemberTranslator.cs | 2 +- .../Internal/NpgsqlLTreeTranslator.cs | 2 +- .../Internal/NpgsqlRangeTranslator.cs | 2 +- .../Internal/PgBinaryExpression.cs | 2 + .../Query/Expressions/PgExpressionType.cs | 9 ++ .../Query/Internal/NpgsqlQuerySqlGenerator.cs | 3 + ...yableMethodTranslatingExpressionVisitor.cs | 5 +- .../Internal/NpgsqlSqlNullabilityProcessor.cs | 3 + .../Query/NpgsqlSqlExpressionFactory.cs | 1 + .../PrimitiveCollectionsQueryNpgsqlTest.cs | 75 +++++++++++++++- .../Query/SpatialQueryNpgsqlGeometryTest.cs | 87 +++++++++++++++++++ .../Translations/LTreeTranslationsTest.cs | 17 ++++ .../NodaTime/DateIntervalTranslationsTest.cs | 31 +++++++ .../NodaTime/LocalDateTranslationsTest.cs | 28 ++++++ .../Translations/RangeTranslationsTest.cs | 50 +++++++++++ .../DateTimeTranslationsNpgsqlTest.cs | 33 +++++++ 19 files changed, 355 insertions(+), 13 deletions(-) diff --git a/src/EFCore.PG.NTS/Query/ExpressionTranslators/Internal/NpgsqlNetTopologySuiteMemberTranslatorPlugin.cs b/src/EFCore.PG.NTS/Query/ExpressionTranslators/Internal/NpgsqlNetTopologySuiteMemberTranslatorPlugin.cs index e9fb5ac9f9..a3d0298cf9 100644 --- a/src/EFCore.PG.NTS/Query/ExpressionTranslators/Internal/NpgsqlNetTopologySuiteMemberTranslatorPlugin.cs +++ b/src/EFCore.PG.NTS/Query/ExpressionTranslators/Internal/NpgsqlNetTopologySuiteMemberTranslatorPlugin.cs @@ -175,7 +175,10 @@ public NpgsqlGeometryMemberTranslator( SqlExpression Function(string name, SqlExpression[] arguments, Type returnType, RelationalTypeMapping? typeMapping = null) => _sqlExpressionFactory.Function( name, arguments, - nullable: true, argumentsPropagateNullability: TrueArrays[arguments.Length], + nullable: true, + argumentsPropagateNullability: name is "ST_X" or "ST_Y" or "ST_Z" or "ST_M" or "ST_StartPoint" or "ST_EndPoint" + ? [false] + : TrueArrays[arguments.Length], returnType, typeMapping); RelationalTypeMapping ResultGeometryMapping() diff --git a/src/EFCore.PG.NTS/Query/ExpressionTranslators/Internal/NpgsqlNetTopologySuiteMethodCallTranslatorPlugin.cs b/src/EFCore.PG.NTS/Query/ExpressionTranslators/Internal/NpgsqlNetTopologySuiteMethodCallTranslatorPlugin.cs index 4f2fbb62e4..4f942772e4 100644 --- a/src/EFCore.PG.NTS/Query/ExpressionTranslators/Internal/NpgsqlNetTopologySuiteMethodCallTranslatorPlugin.cs +++ b/src/EFCore.PG.NTS/Query/ExpressionTranslators/Internal/NpgsqlNetTopologySuiteMethodCallTranslatorPlugin.cs @@ -94,7 +94,7 @@ var t when typeof(Geometry).IsAssignableFrom(t) && instance is not null "ST_GeometryN", [collection, OneBased(index)], nullable: true, - argumentsPropagateNullability: TrueArrays[2], + argumentsPropagateNullability: [false, false], method.ReturnType, geometryTypeMapping), @@ -260,7 +260,10 @@ var t when typeof(Geometry).IsAssignableFrom(t) && instance is not null SqlExpression Function(string name, SqlExpression[] arguments, Type returnType, RelationalTypeMapping? typeMapping = null) => _sqlExpressionFactory.Function( name, arguments, - nullable: true, argumentsPropagateNullability: TrueArrays[arguments.Length], + nullable: true, + argumentsPropagateNullability: name is "ST_GeometryN" or "ST_InteriorRingN" or "ST_PointN" + ? [false, false] + : TrueArrays[arguments.Length], returnType, typeMapping); RelationalTypeMapping ResultGeometryMapping() diff --git a/src/EFCore.PG.NodaTime/Query/Internal/NpgsqlNodaTimeMemberTranslatorPlugin.cs b/src/EFCore.PG.NodaTime/Query/Internal/NpgsqlNodaTimeMemberTranslatorPlugin.cs index f1c15a1b6f..4ffbcf159b 100644 --- a/src/EFCore.PG.NodaTime/Query/Internal/NpgsqlNodaTimeMemberTranslatorPlugin.cs +++ b/src/EFCore.PG.NodaTime/Query/Internal/NpgsqlNodaTimeMemberTranslatorPlugin.cs @@ -208,7 +208,7 @@ SqlExpression Lower() "lower", [instance], nullable: true, - argumentsPropagateNullability: TrueArrays[1], + argumentsPropagateNullability: [false], typeof(LocalDate), _dateTypeMapping); @@ -217,7 +217,7 @@ SqlExpression Upper() "upper", [instance], nullable: true, - argumentsPropagateNullability: TrueArrays[1], + argumentsPropagateNullability: [false], typeof(LocalDate), _dateTypeMapping); } @@ -300,7 +300,7 @@ private SqlExpression GetDatePartExpressionDouble( "date_part", [_sqlExpressionFactory.Constant(partName), instance], nullable: true, - argumentsPropagateNullability: TrueArrays[2], + argumentsPropagateNullability: [false, false], typeof(double)); if (floor) diff --git a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlDateTimeMemberTranslator.cs b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlDateTimeMemberTranslator.cs index 11c116ba27..dab29c28aa 100644 --- a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlDateTimeMemberTranslator.cs +++ b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlDateTimeMemberTranslator.cs @@ -186,7 +186,7 @@ SqlExpression LocalNow() "date_part", [_sqlExpressionFactory.Constant(partName), instance], nullable: true, - argumentsPropagateNullability: TrueArrays[2], + argumentsPropagateNullability: FalseArrays[2], typeof(double)); if (floor) diff --git a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlLTreeTranslator.cs b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlLTreeTranslator.cs index 4875c22752..2b515fcbbd 100644 --- a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlLTreeTranslator.cs +++ b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlLTreeTranslator.cs @@ -114,7 +114,7 @@ public NpgsqlLTreeTranslator( "lca", [arguments[0]], nullable: true, - TrueArrays[1], + FalseArrays[1], typeof(LTree), _ltreeTypeMapping), diff --git a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlRangeTranslator.cs b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlRangeTranslator.cs index 3a722b1d7c..d9393a06d9 100644 --- a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlRangeTranslator.cs +++ b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlRangeTranslator.cs @@ -151,7 +151,7 @@ public NpgsqlRangeTranslator( member.Name == nameof(NpgsqlRange.LowerBound) ? "lower" : "upper", [instance], nullable: true, - argumentsPropagateNullability: TrueArrays[1], + argumentsPropagateNullability: FalseArrays[1], returnType, typeMapping); } diff --git a/src/EFCore.PG/Query/Expressions/Internal/PgBinaryExpression.cs b/src/EFCore.PG/Query/Expressions/Internal/PgBinaryExpression.cs index 47aa666ea5..dec6261727 100644 --- a/src/EFCore.PG/Query/Expressions/Internal/PgBinaryExpression.cs +++ b/src/EFCore.PG/Query/Expressions/Internal/PgBinaryExpression.cs @@ -158,6 +158,8 @@ PgExpressionType.Contains when Left.TypeMapping is NpgsqlHstoreTypeMapping && Ri PgExpressionType.HstoreGetValue => "->", + PgExpressionType.ArrayConcat => "||", + _ => throw new ArgumentOutOfRangeException($"Unhandled operator type: {OperatorType}") }) .Append(" "); diff --git a/src/EFCore.PG/Query/Expressions/PgExpressionType.cs b/src/EFCore.PG/Query/Expressions/PgExpressionType.cs index 59c82ee712..28edd6c091 100644 --- a/src/EFCore.PG/Query/Expressions/PgExpressionType.cs +++ b/src/EFCore.PG/Query/Expressions/PgExpressionType.cs @@ -192,4 +192,13 @@ public enum PgExpressionType HstoreGetValue, // -> #endregion Hstore + + #region Array + + /// + /// Represents a PostgreSQL operator for concatenating arrays. + /// + ArrayConcat, // || + + #endregion Array } diff --git a/src/EFCore.PG/Query/Internal/NpgsqlQuerySqlGenerator.cs b/src/EFCore.PG/Query/Internal/NpgsqlQuerySqlGenerator.cs index 2a32637cda..f46408d6c4 100644 --- a/src/EFCore.PG/Query/Internal/NpgsqlQuerySqlGenerator.cs +++ b/src/EFCore.PG/Query/Internal/NpgsqlQuerySqlGenerator.cs @@ -558,6 +558,8 @@ when binaryExpression.Left.TypeMapping is NpgsqlHstoreTypeMapping PgExpressionType.HstoreGetValue => "->", + PgExpressionType.ArrayConcat => "||", + PgExpressionType.CubeNthCoordinate => "->", PgExpressionType.CubeNthCoordinateKnn => "~>", PgExpressionType.CubeDistanceTaxicab => "<#>", @@ -1644,6 +1646,7 @@ ExpressionType.Add when GetOperator(sqlBinaryExpression) == " || " => (1000, tru // There's an "any other operator" category in the PG operator precedence table, we assign that a numeric value of 1000. // TODO: Some operators here may be associative + PgBinaryExpression { OperatorType: PgExpressionType.ArrayConcat } => (1000, true), PgBinaryExpression or PgRegexMatchExpression => (1000, false), CollateExpression => (1000, false), diff --git a/src/EFCore.PG/Query/Internal/NpgsqlQueryableMethodTranslatingExpressionVisitor.cs b/src/EFCore.PG/Query/Internal/NpgsqlQueryableMethodTranslatingExpressionVisitor.cs index ceb1f13bdd..d586c41043 100644 --- a/src/EFCore.PG/Query/Internal/NpgsqlQueryableMethodTranslatingExpressionVisitor.cs +++ b/src/EFCore.PG/Query/Internal/NpgsqlQueryableMethodTranslatingExpressionVisitor.cs @@ -891,7 +891,8 @@ protected override ShapedQueryExpression TranslateConcat(ShapedQueryExpression s #pragma warning disable EF1001 // SelectExpression constructors are currently internal var tableAlias = ((SelectExpression)source1.QueryExpression).Tables.Single().Alias!; var selectExpression = new SelectExpression( - [new PgUnnestExpression(tableAlias, _sqlExpressionFactory.Add(array1, array2), "value")], + [new PgUnnestExpression( + tableAlias, _sqlExpressionFactory.MakePostgresBinary(PgExpressionType.ArrayConcat, array1, array2), "value")], new ColumnExpression("value", tableAlias, projectedColumn1.Type, inferredTypeMapping, projectedColumn1.IsNullable || projectedColumn2.IsNullable), identifier: [GenerateOrdinalityIdentifier(tableAlias)], _queryCompilationContext.SqlAliasManager); @@ -1203,7 +1204,7 @@ [new PgUnnestExpression(tableAlias, sliceExpression, "value")], "array_remove", [array, translatedItemToFilterOut], nullable: true, - argumentsPropagateNullability: TrueArrays[2], + argumentsPropagateNullability: [true, false], array.Type, array.TypeMapping); diff --git a/src/EFCore.PG/Query/Internal/NpgsqlSqlNullabilityProcessor.cs b/src/EFCore.PG/Query/Internal/NpgsqlSqlNullabilityProcessor.cs index 2355493c2d..6f9e825a14 100644 --- a/src/EFCore.PG/Query/Internal/NpgsqlSqlNullabilityProcessor.cs +++ b/src/EFCore.PG/Query/Internal/NpgsqlSqlNullabilityProcessor.cs @@ -386,6 +386,9 @@ protected virtual SqlExpression VisitPostgresBinary( nullable = binaryExpression.OperatorType switch { + // Array concatenation treats a null operand as an empty array. + PgExpressionType.ArrayConcat => leftNullable && rightNullable, + // Missing keys and stored null values produce null even for non-null operands. PgExpressionType.HstoreGetValue => true, diff --git a/src/EFCore.PG/Query/NpgsqlSqlExpressionFactory.cs b/src/EFCore.PG/Query/NpgsqlSqlExpressionFactory.cs index fae0f797b3..3229f4f0e9 100644 --- a/src/EFCore.PG/Query/NpgsqlSqlExpressionFactory.cs +++ b/src/EFCore.PG/Query/NpgsqlSqlExpressionFactory.cs @@ -840,6 +840,7 @@ private SqlExpression ApplyTypeMappingOnPostgresBinary( case PgExpressionType.RangeExcept: case PgExpressionType.TextSearchAnd: case PgExpressionType.TextSearchOr: + case PgExpressionType.ArrayConcat: { inferredTypeMapping = typeMapping ?? ExpressionExtensions.InferTypeMapping(left, right); resultType = inferredTypeMapping?.ClrType ?? left.Type; diff --git a/test/EFCore.PG.FunctionalTests/Query/PrimitiveCollectionsQueryNpgsqlTest.cs b/test/EFCore.PG.FunctionalTests/Query/PrimitiveCollectionsQueryNpgsqlTest.cs index 053df85708..d305e5dbae 100644 --- a/test/EFCore.PG.FunctionalTests/Query/PrimitiveCollectionsQueryNpgsqlTest.cs +++ b/test/EFCore.PG.FunctionalTests/Query/PrimitiveCollectionsQueryNpgsqlTest.cs @@ -2680,7 +2680,7 @@ public override async Task Project_collection_of_datetimes_filtered() LEFT JOIN LATERAL ( SELECT d.value, d.ordinality FROM unnest(p."DateTimes") WITH ORDINALITY AS d(value) - WHERE date_part('day', d.value AT TIME ZONE 'UTC')::int <> 1 + WHERE date_part('day', d.value AT TIME ZONE 'UTC')::int <> 1 OR date_part('day', d.value AT TIME ZONE 'UTC') IS NULL ) AS d0 ON TRUE ORDER BY p."Id" NULLS FIRST, d0.ordinality NULLS FIRST """); @@ -2823,7 +2823,7 @@ LEFT JOIN LATERAL unnest(p."Ints") WITH ORDINALITY AS i0(value) ON TRUE LEFT JOIN LATERAL ( SELECT d.value, d.ordinality FROM unnest(p."DateTimes") WITH ORDINALITY AS d(value) - WHERE date_part('day', d.value AT TIME ZONE 'UTC')::int <> 1 + WHERE date_part('day', d.value AT TIME ZONE 'UTC')::int <> 1 OR date_part('day', d.value AT TIME ZONE 'UTC') IS NULL ) AS d1 ON TRUE LEFT JOIN LATERAL ( SELECT d0.value, d0.ordinality @@ -3015,6 +3015,77 @@ WHERE cardinality(array_remove(p."Ints", 1)) = 1 """); } + [ConditionalFact] + public async Task Array_remove_with_nullable_item() + { + await AssertQuery( + ss => ss.Set().Select(e => new + { + e.Id, + NotEqual = e.Strings.Where(s => s != e.NullableString).Count() != e.Strings.Length + })); + + AssertSql( + """ +SELECT p."Id", cardinality(array_remove(p."Strings", p."NullableString")) <> cardinality(p."Strings") AS "NotEqual" +FROM "PrimitiveCollectionsEntity" AS p +"""); + } + + [ConditionalFact] + public async Task Concat_nullable_arrays() + { + var contextFactory = await InitializeNonSharedTest( + seed: context => + { + context.AddRange(new TestEntity { Id = 1 }, new TestEntity { Id = 2, Ints = [7, 8] }); + return context.SaveChangesAsync(); + }); + + await using var context = contextFactory.CreateDbContext(); + + int[] ints = [7, 8]; + + var query = + from left in context.Set() + from right in context.Set() + orderby left.Id, right.Id + select new + { + Count = (int?)left.Ints!.Concat(right.Ints!).Count(), + LeftNotEqual = left.Ints!.Concat(ints).Count() != 2, + RightNotEqual = ints.Concat(right.Ints!).Count() != 2 + }; + + var results = await query.Select(e => new + { + e.Count, + e.LeftNotEqual, + e.RightNotEqual, + IsNull = e.Count == null, + Equal = e.Count == 2, + NotEqual = e.Count != 2 + }).ToListAsync(); + + Assert.Equal([null, 2, 2, 4], results.Select(e => e.Count)); + Assert.Equal([false, false, true, true], results.Select(e => e.LeftNotEqual)); + Assert.Equal([false, true, false, true], results.Select(e => e.RightNotEqual)); + Assert.Equal([true, false, false, false], results.Select(e => e.IsNull)); + Assert.Equal([false, true, true, false], results.Select(e => e.Equal)); + Assert.Equal([true, false, false, true], results.Select(e => e.NotEqual)); + + AssertSql( + """ +@ints={ '7' +'8' } (DbType = Object) + +SELECT cardinality(t."Ints" || t0."Ints") AS "Count", cardinality(t."Ints" || @ints) <> 2 AS "LeftNotEqual", cardinality(@ints || t0."Ints") <> 2 AS "RightNotEqual", t."Ints" || t0."Ints" IS NULL AS "IsNull", cardinality(t."Ints" || t0."Ints") = 2 AND t."Ints" || t0."Ints" IS NOT NULL AS "Equal", cardinality(t."Ints" || t0."Ints") <> 2 OR t."Ints" || t0."Ints" IS NULL AS "NotEqual" +FROM "TestEntity" AS t +CROSS JOIN "TestEntity" AS t0 +ORDER BY t."Id" NULLS FIRST, t0."Id" NULLS FIRST +"""); + } + public override async Task Parameter_collection_of_structs_Contains_nullable_struct() { await base.Parameter_collection_of_structs_Contains_nullable_struct(); diff --git a/test/EFCore.PG.FunctionalTests/Query/SpatialQueryNpgsqlGeometryTest.cs b/test/EFCore.PG.FunctionalTests/Query/SpatialQueryNpgsqlGeometryTest.cs index c12f1847e9..09fc4c47d8 100644 --- a/test/EFCore.PG.FunctionalTests/Query/SpatialQueryNpgsqlGeometryTest.cs +++ b/test/EFCore.PG.FunctionalTests/Query/SpatialQueryNpgsqlGeometryTest.cs @@ -1078,6 +1078,93 @@ await AssertQuery( """); } + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task Missing_point_ordinates_not_equal(bool async) + { + await AssertQuery( + async, + ss => ss.Set() + .Where(e => e.Point != null && e.Point.Z != 0 && e.Point.M != 0) + .Select(e => e.Id)); + + AssertSql( + """ +SELECT p."Id" +FROM "PointEntity" AS p +WHERE p."Point" IS NOT NULL AND (ST_Z(p."Point") <> 0.0 OR ST_Z(p."Point") IS NULL) AND (ST_M(p."Point") <> 0.0 OR ST_M(p."Point") IS NULL) +"""); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task Empty_line_endpoints_are_null(bool async) + { + await using var context = Fixture.CreateContext(); + await context.Database.CreateExecutionStrategy().ExecuteAsync( + async () => + { + await using var transaction = await context.Database.BeginTransactionAsync(); + + var entity = await context.Set().AsTracking().SingleAsync(e => e.Id == 1); + entity.LineString = Fixture.GeometryFactory.CreateLineString(); + await context.SaveChangesAsync(); + Fixture.TestSqlLoggerFactory.Clear(); + + var query = context.Set() + .Where(e => e.LineString != null && e.LineString.StartPoint == null && e.LineString.EndPoint == null) + .Select(e => e.Id); + + Assert.Equal(1, async ? await query.SingleAsync() : query.Single()); + + AssertSql( + """ +SELECT l."Id" +FROM "LineStringEntity" AS l +WHERE l."LineString" IS NOT NULL AND ST_StartPoint(l."LineString") IS NULL AND ST_EndPoint(l."LineString") IS NULL +LIMIT 2 +"""); + }); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task GetGeometryN_out_of_range_is_null(bool async) + { + await AssertQuery( + async, + ss => ss.Set() + .Where(e => e.MultiLineString != null && e.MultiLineString.GetGeometryN(99) == null) + .Select(e => e.Id), + expectedQuery: ss => ss.Set().Where(e => e.MultiLineString != null).Select(e => e.Id)); + + AssertSql( + """ +SELECT m."Id" +FROM "MultiLineStringEntity" AS m +WHERE m."MultiLineString" IS NOT NULL AND ST_GeometryN(m."MultiLineString", 100) IS NULL +"""); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task Geometry_collection_indexer_out_of_range_is_null(bool async) + { + await AssertQuery( + async, + ss => ss.Set() + .Where(e => e.MultiLineString != null && e.MultiLineString[99] == null) + .Select(e => e.Id), + expectedQuery: ss => ss.Set().Where(e => e.MultiLineString != null).Select(e => e.Id)); + + AssertSql( + """ +SELECT m."Id" +FROM "MultiLineStringEntity" AS m +WHERE m."MultiLineString" IS NOT NULL AND ST_GeometryN(m."MultiLineString", 100) IS NULL +"""); + } + private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); diff --git a/test/EFCore.PG.FunctionalTests/Query/Translations/LTreeTranslationsTest.cs b/test/EFCore.PG.FunctionalTests/Query/Translations/LTreeTranslationsTest.cs index 34c5b4141b..ca2ca63076 100644 --- a/test/EFCore.PG.FunctionalTests/Query/Translations/LTreeTranslationsTest.cs +++ b/test/EFCore.PG.FunctionalTests/Query/Translations/LTreeTranslationsTest.cs @@ -502,6 +502,23 @@ WHERE lca(ARRAY[l."LTree",'Top.Hobbies']::ltree[]) = 'Top' """); } + [ConditionalFact] + public void LongestCommonAncestor_is_null() + { + using var context = CreateContext(); + + Assert.Equal( + 7, + context.LTreeEntities.Select(l => (LTree?)LTree.LongestCommonAncestor(l.LTree, "")).Count(l => l == null)); + + AssertSql( + """ +SELECT count(*)::int +FROM "LTreeEntities" AS l +WHERE lca(ARRAY[l."LTree",'']::ltree[]) IS NULL +"""); + } + #region Support protected LTreeQueryContext CreateContext() diff --git a/test/EFCore.PG.FunctionalTests/Query/Translations/NodaTime/DateIntervalTranslationsTest.cs b/test/EFCore.PG.FunctionalTests/Query/Translations/NodaTime/DateIntervalTranslationsTest.cs index 35fc4cf586..6ba88d3fd9 100644 --- a/test/EFCore.PG.FunctionalTests/Query/Translations/NodaTime/DateIntervalTranslationsTest.cs +++ b/test/EFCore.PG.FunctionalTests/Query/Translations/NodaTime/DateIntervalTranslationsTest.cs @@ -75,6 +75,37 @@ SELECT CAST(upper(n."DateInterval") - INTERVAL 'P1D' AS date) """); } + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task Bounds_of_unbounded_daterange_are_null(bool async) + { + await using var context = Fixture.CreateContext(); + await context.Database.CreateExecutionStrategy().ExecuteAsync( + async () => + { + await using var transaction = await context.Database.BeginTransactionAsync(); + + await context.Database.ExecuteSqlRawAsync("""UPDATE "NodaTimeTypes" SET "DateInterval" = '(,)'::daterange"""); + Fixture.TestSqlLoggerFactory.Clear(); + + var query = context.NodaTimeTypes + .Select(e => new { Start = (LocalDate?)e.DateInterval.Start, End = (LocalDate?)e.DateInterval.End }) + .Where(e => e.Start == null && e.End == null); + + var result = async ? await query.SingleAsync() : query.Single(); + Assert.Null(result.Start); + Assert.Null(result.End); + + AssertSql( + """ +SELECT lower(n."DateInterval") AS "Start", CAST(upper(n."DateInterval") - INTERVAL 'P1D' AS date) AS "End" +FROM "NodaTimeTypes" AS n +WHERE lower(n."DateInterval") IS NULL AND upper(n."DateInterval") IS NULL +LIMIT 2 +"""); + }); + } + [ConditionalTheory] [MemberData(nameof(IsAsyncData))] public async Task Contains_LocalDate(bool async) diff --git a/test/EFCore.PG.FunctionalTests/Query/Translations/NodaTime/LocalDateTranslationsTest.cs b/test/EFCore.PG.FunctionalTests/Query/Translations/NodaTime/LocalDateTranslationsTest.cs index 1e855cbac6..f87973058e 100644 --- a/test/EFCore.PG.FunctionalTests/Query/Translations/NodaTime/LocalDateTranslationsTest.cs +++ b/test/EFCore.PG.FunctionalTests/Query/Translations/NodaTime/LocalDateTranslationsTest.cs @@ -210,6 +210,34 @@ WHERE date_part('month', n."LocalDate")::int = 4 """); } + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task Month_infinite_date_not_equal(bool async) + { + await using var context = CreateContext(); + await context.Database.CreateExecutionStrategy().ExecuteAsync( + async () => + { + await using var transaction = await context.Database.BeginTransactionAsync(); + + var entity = await context.NodaTimeTypes.SingleAsync(); + entity.LocalDate = LocalDate.MaxIsoValue; + await context.SaveChangesAsync(); + Fixture.TestSqlLoggerFactory.Clear(); + + var query = context.NodaTimeTypes.Where(e => e.LocalDate.Month != 6).Select(e => e.Id); + Assert.Equal(entity.Id, async ? await query.SingleAsync() : query.Single()); + + AssertSql( + """ +SELECT n."Id" +FROM "NodaTimeTypes" AS n +WHERE date_part('month', n."LocalDate")::int <> 6 OR date_part('month', n."LocalDate") IS NULL +LIMIT 2 +"""); + }); + } + [ConditionalTheory] [MemberData(nameof(IsAsyncData))] public async Task DayOrYear(bool async) diff --git a/test/EFCore.PG.FunctionalTests/Query/Translations/RangeTranslationsTest.cs b/test/EFCore.PG.FunctionalTests/Query/Translations/RangeTranslationsTest.cs index 9c5d53b176..0d621e7e5e 100644 --- a/test/EFCore.PG.FunctionalTests/Query/Translations/RangeTranslationsTest.cs +++ b/test/EFCore.PG.FunctionalTests/Query/Translations/RangeTranslationsTest.cs @@ -374,6 +374,56 @@ LIMIT 2 """); } + [ConditionalTheory] + [InlineData(false, false)] + [InlineData(true, false)] + [InlineData(false, true)] + [InlineData(true, true)] + public async Task Bounds_of_empty_or_unbounded_range(bool async, bool empty) + { + await using var context = CreateContext(); + await context.Database.CreateExecutionStrategy().ExecuteAsync( + async () => + { + await using var transaction = await context.Database.BeginTransactionAsync(); + + var entity = await context.RangeTestEntities.SingleAsync(e => e.Id == 1); + entity.IntRange = empty ? NpgsqlRange.Empty : new NpgsqlRange(0, false, true, 0, false, true); + await context.SaveChangesAsync(); + Fixture.TestSqlLoggerFactory.Clear(); + + var bounds = context.RangeTestEntities + .Where(e => e.Id == 1) + .Select(e => new { Lower = (int?)e.IntRange.LowerBound, Upper = (int?)e.IntRange.UpperBound }) + .Where(e => e.Lower == null && e.Upper == null); + + var result = async ? await bounds.SingleAsync() : bounds.Single(); + Assert.Null(result.Lower); + Assert.Null(result.Upper); + + var query = context.RangeTestEntities + .Where(e => e.Id == 1 && e.IntRange.LowerBound != 5 && e.IntRange.UpperBound != 5) + .Select(e => e.Id); + + Assert.Equal(1, async ? await query.SingleAsync() : query.Single()); + + AssertSql( + """ +SELECT lower(r."IntRange") AS "Lower", upper(r."IntRange") AS "Upper" +FROM "RangeTestEntities" AS r +WHERE r."Id" = 1 AND lower(r."IntRange") IS NULL AND upper(r."IntRange") IS NULL +LIMIT 2 +""", + // + """ +SELECT r."Id" +FROM "RangeTestEntities" AS r +WHERE r."Id" = 1 AND (lower(r."IntRange") <> 5 OR lower(r."IntRange") IS NULL) AND (upper(r."IntRange") <> 5 OR upper(r."IntRange") IS NULL) +LIMIT 2 +"""); + }); + } + [ConditionalFact] public void IsEmpty() { diff --git a/test/EFCore.PG.FunctionalTests/Query/Translations/Temporal/DateTimeTranslationsNpgsqlTest.cs b/test/EFCore.PG.FunctionalTests/Query/Translations/Temporal/DateTimeTranslationsNpgsqlTest.cs index 85742bd94b..adcaf37aee 100644 --- a/test/EFCore.PG.FunctionalTests/Query/Translations/Temporal/DateTimeTranslationsNpgsqlTest.cs +++ b/test/EFCore.PG.FunctionalTests/Query/Translations/Temporal/DateTimeTranslationsNpgsqlTest.cs @@ -71,6 +71,39 @@ WHERE date_trunc('day', b."DateTime", 'UTC') = @myDatetime """); } + [ConditionalTheory] + [InlineData(false)] + [InlineData(true)] + public async Task Month_infinite_timestamp_not_equal(bool negativeInfinity) + { + await using var context = Fixture.CreateContext(); + await context.Database.CreateExecutionStrategy().ExecuteAsync( + async () => + { + await using var transaction = await context.Database.BeginTransactionAsync(); + + var entity = await context.Set().SingleAsync(e => e.Id == 1); + entity.DateTime = negativeInfinity ? DateTime.MinValue : DateTime.MaxValue; + await context.SaveChangesAsync(); + Fixture.TestSqlLoggerFactory.Clear(); + + Assert.Equal( + 1, + await context.Set() + .Where(e => e.Id == 1 && e.DateTime.Month != 6) + .Select(e => e.Id) + .SingleAsync()); + + AssertSql( + """ +SELECT b."Id" +FROM "BasicTypesEntities" AS b +WHERE b."Id" = 1 AND (date_part('month', b."DateTime" AT TIME ZONE 'UTC')::int <> 6 OR date_part('month', b."DateTime" AT TIME ZONE 'UTC') IS NULL) +LIMIT 2 +"""); + }); + } + public override async Task AddYear() { await base.AddYear(); From 2017befada1ab93871d4c1f76c12a56023e7800b Mon Sep 17 00:00:00 2001 From: Shay Rojansky Date: Tue, 17 Nov 2026 16:05:29 +0100 Subject: [PATCH 2/2] Update GroupBy baseline for date-part nullability Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../Query/NorthwindGroupByQueryNpgsqlTest.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/EFCore.PG.FunctionalTests/Query/NorthwindGroupByQueryNpgsqlTest.cs b/test/EFCore.PG.FunctionalTests/Query/NorthwindGroupByQueryNpgsqlTest.cs index ca2aefba56..b22368a762 100644 --- a/test/EFCore.PG.FunctionalTests/Query/NorthwindGroupByQueryNpgsqlTest.cs +++ b/test/EFCore.PG.FunctionalTests/Query/NorthwindGroupByQueryNpgsqlTest.cs @@ -1618,7 +1618,7 @@ public override async Task GroupBy_complex_key_aggregate_2(bool async) SELECT o0."Key" AS "Month", COALESCE(sum(o0."OrderID"), 0)::int AS "Total", ( SELECT COALESCE(sum(o1."OrderID"), 0)::int FROM "Orders" AS o1 - WHERE date_part('month', o1."OrderDate")::int = o0."Key" OR (o1."OrderDate" IS NULL AND o0."Key" IS NULL)) AS "Payment" + WHERE date_part('month', o1."OrderDate")::int = o0."Key" OR (date_part('month', o1."OrderDate") IS NULL AND o0."Key" IS NULL)) AS "Payment" FROM ( SELECT o."OrderID", date_part('month', o."OrderDate")::int AS "Key" FROM "Orders" AS o