Bump dependency versions

Author: roji

Directory.Packages.props

@@ -1,8 +1,8 @@
   <Project>
   <PropertyGroup>
-    <EFCoreVersion>8.0.0</EFCoreVersion>
+    <EFCoreVersion>8.0.2</EFCoreVersion>
     <MicrosoftExtensionsVersion>8.0.0</MicrosoftExtensionsVersion>
-    <NpgsqlVersion>8.0.0</NpgsqlVersion>
+    <NpgsqlVersion>8.0.2</NpgsqlVersion>
   </PropertyGroup>
 
   <ItemGroup>

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

@@ -760,6 +760,11 @@ protected override Expression VisitValues(ValuesExpression valuesExpression)
     /// </summary>
     protected override void GenerateValues(ValuesExpression valuesExpression)
     {
+        if (valuesExpression.RowValues.Count == 0)
+        {
+            throw new InvalidOperationException(RelationalStrings.EmptyCollectionNotSupportedAsInlineQueryRoot);
+        }
+
         // PostgreSQL supports providing the names of columns projected out of VALUES: (VALUES (1, 3), (2, 4)) AS x(a, b).
         // But since other databases sometimes don't, the default relational implementation is complex, involving a SELECT for the first row
         // and a UNION All on the rest. Override to do the nice simple thing.

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

@@ -267,14 +267,15 @@ protected override Expression ApplyInferredTypeMappings(
     {
         if (source.QueryExpression is SelectExpression
             {
-                Tables: [(PgUnnestExpression or ValuesExpression { ColumnNames: ["_ord", "Value"] }) and var sourceTable],
+                Tables: [var sourceTable],
                 Predicate: null,
                 GroupBy: [],
                 Having: null,
                 IsDistinct: false,
                 Limit: null,
                 Offset: null
             }
+            && TryGetArray(sourceTable, out var array)
             && TranslateLambdaExpression(source, predicate) is { } translatedPredicate)
         {
             switch (translatedPredicate)
@@ -291,7 +292,7 @@ protected override Expression ApplyInferredTypeMappings(
                 {
                     return BuildSimplifiedShapedQuery(
                         source,
-                        _sqlExpressionFactory.All(match, GetArray(sourceTable), PgAllOperatorType.Like));
+                        _sqlExpressionFactory.All(match, array, PgAllOperatorType.Like));
                 }
 
                 // Pattern match for: new[] { "a", "b", "c" }.All(p => EF.Functions.Like(e.SomeText, p)),
@@ -306,7 +307,7 @@ protected override Expression ApplyInferredTypeMappings(
                 {
                     return BuildSimplifiedShapedQuery(
                         source,
-                        _sqlExpressionFactory.All(match, GetArray(sourceTable), PgAllOperatorType.ILike));
+                        _sqlExpressionFactory.All(match, array, PgAllOperatorType.ILike));
                 }
 
                 // Pattern match for: e.SomeArray.All(p => ints.Contains(p)) over non-column,
@@ -318,7 +319,7 @@ protected override Expression ApplyInferredTypeMappings(
                     }
                     when sourceColumn.Table == sourceTable:
                 {
-                    return BuildSimplifiedShapedQuery(source, _sqlExpressionFactory.ContainedBy(GetArray(sourceTable), otherArray));
+                    return BuildSimplifiedShapedQuery(source, _sqlExpressionFactory.ContainedBy(array, otherArray));
                 }
 
                 // Pattern match for: new[] { 4, 5 }.All(p => e.SomeArray.Contains(p)) over column,
@@ -331,7 +332,7 @@ protected override Expression ApplyInferredTypeMappings(
                     }
                     when sourceColumn.Table == sourceTable:
                 {
-                    return BuildSimplifiedShapedQuery(source, _sqlExpressionFactory.ContainedBy(GetArray(sourceTable), otherArray));
+                    return BuildSimplifiedShapedQuery(source, _sqlExpressionFactory.ContainedBy(array, otherArray));
                 }
             }
         }
@@ -349,14 +350,15 @@ protected override Expression ApplyInferredTypeMappings(
     {
         if (source.QueryExpression is SelectExpression
             {
-                Tables: [(PgUnnestExpression or ValuesExpression { ColumnNames: ["_ord", "Value"] }) and var sourceTable],
+                Tables: [var sourceTable],
                 Predicate: null,
                 GroupBy: [],
                 Having: null,
                 IsDistinct: false,
                 Limit: null,
                 Offset: null
-            })
+            }
+            && TryGetArray(sourceTable, out var array))
         {
             // Pattern match: x.Array.Any()
             // Translation: cardinality(x.array) > 0 instead of EXISTS (SELECT 1 FROM FROM unnest(x.Array))
@@ -367,7 +369,7 @@ protected override Expression ApplyInferredTypeMappings(
                     _sqlExpressionFactory.GreaterThan(
                         _sqlExpressionFactory.Function(
                             "cardinality",
-                            new[] { GetArray(sourceTable) },
+                            new[] { array },
                             nullable: true,
                             argumentsPropagateNullability: TrueArrays[1],
                             typeof(int)),
@@ -392,7 +394,7 @@ protected override Expression ApplyInferredTypeMappings(
                     when pattern.Table == sourceTable:
                 {
                     return BuildSimplifiedShapedQuery(
-                        source, _sqlExpressionFactory.Any(match, GetArray(sourceTable), PgAnyOperatorType.Like));
+                        source, _sqlExpressionFactory.Any(match, array, PgAnyOperatorType.Like));
                 }
 
                 // Pattern match: new[] { "a", "b", "c" }.Any(p => EF.Functions.Like(e.SomeText, p))
@@ -406,7 +408,7 @@ protected override Expression ApplyInferredTypeMappings(
                     when pattern.Table == sourceTable:
                 {
                     return BuildSimplifiedShapedQuery(
-                        source, _sqlExpressionFactory.Any(match, GetArray(sourceTable), PgAnyOperatorType.ILike));
+                        source, _sqlExpressionFactory.Any(match, array, PgAnyOperatorType.ILike));
                 }
 
                 // Array overlap over non-column
@@ -419,7 +421,7 @@ protected override Expression ApplyInferredTypeMappings(
                     }
                     when sourceColumn.Table == sourceTable:
                 {
-                    return BuildSimplifiedShapedQuery(source, _sqlExpressionFactory.Overlaps(GetArray(sourceTable), otherArray));
+                    return BuildSimplifiedShapedQuery(source, _sqlExpressionFactory.Overlaps(array, otherArray));
                 }
 
                 // Array overlap over column
@@ -433,7 +435,7 @@ protected override Expression ApplyInferredTypeMappings(
                     }
                     when sourceColumn.Table == sourceTable:
                 {
-                    return BuildSimplifiedShapedQuery(source, _sqlExpressionFactory.Overlaps(GetArray(sourceTable), otherArray));
+                    return BuildSimplifiedShapedQuery(source, _sqlExpressionFactory.Overlaps(array, otherArray));
                 }
 
                 #region LTree translations
@@ -453,7 +455,7 @@ protected override Expression ApplyInferredTypeMappings(
                         new PgBinaryExpression(
                             PgExpressionType.LTreeMatchesAny,
                             ltree,
-                            _sqlExpressionFactory.ApplyTypeMapping(GetArray(sourceTable), _typeMappingSource.FindMapping("lquery[]")),
+                            _sqlExpressionFactory.ApplyTypeMapping(array, _typeMappingSource.FindMapping("lquery[]")),
                             typeof(bool),
                             typeMapping: _typeMappingSource.FindMapping(typeof(bool))));
                 }
@@ -475,7 +477,7 @@ protected override Expression ApplyInferredTypeMappings(
                         source,
                         new PgBinaryExpression(
                             operatorType,
-                            _sqlExpressionFactory.ApplyDefaultTypeMapping(GetArray(sourceTable)),
+                            _sqlExpressionFactory.ApplyDefaultTypeMapping(array),
                             ltree,
                             typeof(bool),
                             typeMapping: _typeMappingSource.FindMapping(typeof(bool))));
@@ -497,7 +499,7 @@ protected override Expression ApplyInferredTypeMappings(
                         source,
                         new PgBinaryExpression(
                             PgExpressionType.LTreeMatches,
-                            _sqlExpressionFactory.ApplyDefaultTypeMapping(GetArray(sourceTable)),
+                            _sqlExpressionFactory.ApplyDefaultTypeMapping(array),
                             lquery,
                             typeof(bool),
                             typeMapping: _typeMappingSource.FindMapping(typeof(bool))));
@@ -518,7 +520,7 @@ protected override Expression ApplyInferredTypeMappings(
                         source,
                         new PgBinaryExpression(
                             PgExpressionType.LTreeMatchesAny,
-                            _sqlExpressionFactory.ApplyDefaultTypeMapping(GetArray(sourceTable)),
+                            _sqlExpressionFactory.ApplyDefaultTypeMapping(array),
                             lqueries,
                             typeof(bool),
                             typeMapping: _typeMappingSource.FindMapping(typeof(bool))));
@@ -578,26 +580,20 @@ protected override Expression ApplyInferredTypeMappings(
     /// </summary>
     protected override ShapedQueryExpression? TranslateContains(ShapedQueryExpression source, Expression item)
     {
+        // Note that most other simplifications convert ValuesExpression to unnest over array constructor, but we avoid doing that
+        // here for Contains, since the relational translation for ValuesExpression is better.
         if (source.QueryExpression is SelectExpression
             {
-                Tables: [(PgUnnestExpression or ValuesExpression { ColumnNames: ["_ord", "Value"] }) and var sourceTable],
+                Tables: [PgUnnestExpression { Array: var array }],
                 Predicate: null,
                 GroupBy: [],
                 Having: null,
                 IsDistinct: false,
                 Limit: null,
                 Offset: null
-            })
-        {
-            if (TranslateExpression(item, applyDefaultTypeMapping: false) is not SqlExpression translatedItem)
-            {
-                return null;
             }
-
-            // Note that most other simplifications here convert ValuesExpression to unnest over array constructor, but we avoid doing that
-            // here, since the relational translation for ValuesExpression is better.
-            var array = GetArray(sourceTable);
-
+            && TranslateExpression(item, applyDefaultTypeMapping: false) is SqlExpression translatedItem)
+        {
             (translatedItem, array) = _sqlExpressionFactory.ApplyTypeMappingsOnItemAndArray(translatedItem, array);
 
             // When the array is a column, we translate Contains to array @> ARRAY[item]. GIN indexes on array are used, but null
@@ -823,7 +819,7 @@ protected override ShapedQueryExpression TranslateConcat(ShapedQueryExpression s
         // select expression should already contain our predicate.
         if (source.QueryExpression is SelectExpression
             {
-                Tables: [(PgUnnestExpression or ValuesExpression { ColumnNames: ["_ord", "Value"] }) and var sourceTable],
+                Tables: [var sourceTable],
                 Predicate: var translatedPredicate,
                 GroupBy: [],
                 Having: null,
@@ -832,6 +828,7 @@ protected override ShapedQueryExpression TranslateConcat(ShapedQueryExpression s
                 Offset: null,
                 Orderings: []
             }
+            && TryGetArray(sourceTable, out var array)
             && translatedPredicate is null ^ predicate is null)
         {
             if (translatedPredicate is null)
@@ -864,7 +861,7 @@ protected override ShapedQueryExpression TranslateConcat(ShapedQueryExpression s
                             operatorType == PgExpressionType.Contains
                                 ? PgExpressionType.LTreeFirstAncestor
                                 : PgExpressionType.LTreeFirstDescendent,
-                            _sqlExpressionFactory.ApplyDefaultTypeMapping(GetArray(sourceTable)),
+                            _sqlExpressionFactory.ApplyDefaultTypeMapping(array),
                             ltree,
                             typeof(LTree),
                             _typeMappingSource.FindMapping(typeof(LTree))));
@@ -886,7 +883,7 @@ protected override ShapedQueryExpression TranslateConcat(ShapedQueryExpression s
                         source,
                         new PgBinaryExpression(
                             PgExpressionType.LTreeFirstMatches,
-                            _sqlExpressionFactory.ApplyDefaultTypeMapping(GetArray(sourceTable)),
+                            _sqlExpressionFactory.ApplyDefaultTypeMapping(array),
                             lquery,
                             typeof(LTree),
                             _typeMappingSource.FindMapping(typeof(LTree))));
@@ -1226,18 +1223,17 @@ private ShapedQueryExpression BuildSimplifiedShapedQuery(ShapedQueryExpression s
     ///     Extracts the <see cref="PgUnnestExpression.Array" /> out of <see cref="PgUnnestExpression" />.
     ///     If a <see cref="ValuesExpression" /> is given, converts its literal values into a <see cref="PgNewArrayExpression" />.
     /// </summary>
-    private SqlExpression GetArray(TableExpressionBase tableExpression)
+    private bool TryGetArray(TableExpressionBase tableExpression, [NotNullWhen(true)] out SqlExpression? array)
     {
-        Check.DebugAssert(
-            tableExpression is PgUnnestExpression or ValuesExpression { ColumnNames: ["_ord", "Value"] },
-            "Bad tableExpression");
-
         switch (tableExpression)
         {
             case PgUnnestExpression unnest:
-                return unnest.Array;
+                array = unnest.Array;
+                return true;
 
-            case ValuesExpression valuesExpression:
+            // TODO: We currently don't have information type information on empty ValuesExpression, so we can't transform that into an
+            // array.
+            case ValuesExpression { ColumnNames: ["_ord", "Value"], RowValues.Count: > 0 } valuesExpression:
             {
                 // The source table was a constant collection, so translated by default to ValuesExpression. Convert it to an unnest over
                 // an array constructor.
@@ -1249,12 +1245,14 @@ private SqlExpression GetArray(TableExpressionBase tableExpression)
                     elements[i] = valuesExpression.RowValues[i].Values[1];
                 }
 
-                return new PgNewArrayExpression(
+                array = new PgNewArrayExpression(
                     elements, valuesExpression.RowValues[0].Values[1].Type.MakeArrayType(), typeMapping: null);
+                return true;
             }
 
             default:
-                throw new ArgumentException(nameof(tableExpression));
+                array = null;
+                return false;
         }
     }
 

test/EFCore.PG.FunctionalTests/BadDataJsonDeserializationNpgsqlTest.cs

@@ -0,0 +1,9 @@
+#nullable enable
+
+namespace Npgsql.EntityFrameworkCore.PostgreSQL;
+
+public class BadDataJsonDeserializationNpgsqlTest : BadDataJsonDeserializationTestBase
+{
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        => base.OnConfiguring(optionsBuilder.UseNpgsql(b => b.UseNetTopologySuite()));
+}

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

@@ -35,30 +35,6 @@ await AssertQuery(
             ss => ss.Set<FunkyCustomer>().Where(c => c.FirstName != null && c.FirstName.StartsWith(param)));
     }
 
-    [ConditionalTheory] // TODO: Remove, test was introduced upstream
-    [MemberData(nameof(IsAsyncData))]
-    public virtual async Task String_Contains_and_StartsWith_with_same_parameter(bool async)
-    {
-        var s = "B";
-
-        await AssertQuery(
-            async,
-            ss => ss.Set<FunkyCustomer>().Where(
-                c => c.FirstName.Contains(s) || c.LastName.StartsWith(s)),
-            ss => ss.Set<FunkyCustomer>().Where(
-                c => c.FirstName.MaybeScalar(f => f.Contains(s)) == true || c.LastName.MaybeScalar(l => l.StartsWith(s)) == true));
-
-        AssertSql(
-            """
-@__s_0_contains='%B%'
-@__s_0_startswith='B%'
-
-SELECT f."Id", f."FirstName", f."LastName", f."NullableBool"
-FROM "FunkyCustomers" AS f
-WHERE f."FirstName" LIKE @__s_0_contains ESCAPE '\' OR f."LastName" LIKE @__s_0_startswith ESCAPE '\'
-""");
-    }
-
     private void AssertSql(params string[] expected)
         => Fixture.TestSqlLoggerFactory.AssertBaseline(expected);
 

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

@@ -232,6 +232,14 @@ protected override void SeedJunkInJson(MyContextJunkInJson ctx)
 '{{"Name":"r1","JunkCollection":[{{"Foo":"junk value"}}],"JunkReference":{{"Something":"SomeValue" }},"Number":1.5,"NestedCollection":[{{"DoB":"2000-02-01T00:00:00","JunkReference":{{"Something":"SomeValue"}}}},{{"DoB":"2000-02-02T00:00:00"}}],"NestedReference":{{"DoB":"2000-01-01T00:00:00"}}}}',
 '{{"MyBool":true,"JunkCollection":[{{"Foo":"junk value"}}],"Name":"r1 ctor","JunkReference":{{"Something":"SomeValue" }},"NestedCollection":[{{"DoB":"2001-02-01T00:00:00"}},{{"DoB":"2001-02-02T00:00:00"}}],"NestedReference":{{"JunkCollection":[{{"Foo":"junk value"}}],"DoB":"2001-01-01T00:00:00"}}}}',
 1)
+""");
+
+    protected override void SeedTrickyBuffering(MyContextTrickyBuffering ctx)
+        => ctx.Database.ExecuteSqlRaw(
+            """
+INSERT INTO "Entities" ("Reference", "Id")
+VALUES(
+'{{"Name": "r1", "Number": 7, "JunkReference":{{"Something": "SomeValue" }}, "JunkCollection": [{{"Foo": "junk value"}}], "NestedReference": {{"DoB": "2000-01-01T00:00:00Z"}}, "NestedCollection": [{{"DoB": "2000-02-01T00:00:00Z", "JunkReference": {{"Something": "SomeValue"}}}}, {{"DoB": "2000-02-02T00:00:00Z"}}]}}',1)
 """);
 
     protected override void SeedShadowProperties(MyContextShadowProperties ctx)