feat：适配10.0.0

Author: wangpengxpy

Directory.Build.props

@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <VersionPrefix>9.0.2</VersionPrefix>
+    <VersionPrefix>10.0.0</VersionPrefix>
     <LangVersion>latest</LangVersion>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <AnalysisLevel>latest</AnalysisLevel>

Directory.Packages.props

@@ -1,7 +1,7 @@
-  <Project>
+<Project>
   <PropertyGroup>
-    <EFCoreVersion>[9.0.0,10.0.0)</EFCoreVersion>
-    <MicrosoftExtensionsVersion>9.0.0</MicrosoftExtensionsVersion>
+    <EFCoreVersion>10.0.0</EFCoreVersion>
+    <MicrosoftExtensionsVersion>10.0.0</MicrosoftExtensionsVersion>
     <KdbndpVersion>9.0.2</KdbndpVersion>
   </PropertyGroup>
 

global.json

@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "9.0.100",
+    "version": "10.0.101",
     "rollForward": "latestMajor",
     "allowPrerelease": false
   }

src/EFCore.KingbaseES/EFCore.KingbaseES.csproj

@@ -4,8 +4,8 @@
     <AssemblyName>DotNetCore.EntityFrameworkCore.KingbaseES</AssemblyName>
     <RootNamespace>DotNetCore.EntityFrameworkCore.KingbaseES</RootNamespace>
     <PackageId>DotNetCore.EntityFrameworkCore.KingbaseES</PackageId>
-    <TargetFramework>net9.0</TargetFramework>
-    <Version>9.0.0</Version>
+    <TargetFramework>net10.0</TargetFramework>
+    <Version>10.0.0</Version>
     <Authors>NCC;Jeffcky</Authors>
     <RepositoryType>git</RepositoryType>
     <RepositoryUrl>https://github.com/dotnetcore/EntityFrameworkCore.KingbaseES</RepositoryUrl>

src/EFCore.KingbaseES/Query/Internal/KdbndpDeleteConvertingExpressionVisitor.cs

@@ -3,7 +3,7 @@
 namespace Kdbndp.EntityFrameworkCore.KingbaseES.Query.Internal;
 
 /// <summary>
-///     Converts the relational <see cref="NonQueryExpression" /> into a PG-specific <see cref="PgDeleteExpression" />, which
+///     Converts the relational <see cref="DeleteExpression" /> into a PG-specific <see cref="PgDeleteExpression" />, which
 ///     precisely models a DELETE statement in KingbaseES. This is done to handle the PG-specific USING syntax for table joining.
 /// </summary>
 public class KdbndpDeleteConvertingExpressionVisitor : ExpressionVisitor

src/EFCore.KingbaseES/Query/Internal/KdbndpParameterBasedSqlProcessor.cs

@@ -27,28 +27,17 @@ public KdbndpParameterBasedSqlProcessor(
     ///     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 Expression Optimize(
-        Expression queryExpression,
-        IReadOnlyDictionary<string, object?> parametersValues,
-        out bool canCache)
+    public override Expression Process(Expression queryExpression, ParametersCacheDecorator parametersDecorator)
     {
-        queryExpression = base.Optimize(queryExpression, parametersValues, out canCache);
+        queryExpression = base.Process(queryExpression, parametersDecorator);
 
         queryExpression = new KdbndpDeleteConvertingExpressionVisitor().Process(queryExpression);
 
         return queryExpression;
     }
 
-    /// <inheritdoc />
-    protected override Expression ProcessSqlNullability(
-        Expression selectExpression,
-        IReadOnlyDictionary<string, object?> parametersValues,
-        out bool canCache)
-    {
-        Check.NotNull(selectExpression, nameof(selectExpression));
-        Check.NotNull(parametersValues, nameof(parametersValues));
 
-        return new KdbndpSqlNullabilityProcessor(Dependencies, Parameters).Process(
-            selectExpression, parametersValues, out canCache);
-    }
+    /// <inheritdoc />
+    protected override Expression ProcessSqlNullability(Expression selectExpression, ParametersCacheDecorator parametersDecorator)
+        => new KdbndpSqlNullabilityProcessor(Dependencies, Parameters).Process(selectExpression, parametersDecorator);
 }

src/EFCore.KingbaseES/Query/Internal/KdbndpQueryCompilationContext.cs

@@ -19,8 +19,7 @@ public KdbndpQueryCompilationContext(
         RelationalQueryCompilationContextDependencies relationalDependencies,
         bool async)
         : this(
-            dependencies, relationalDependencies, async, precompiling: false,
-            nonNullableReferenceTypeParameters: null)
+            dependencies, relationalDependencies, async, precompiling: false)
     {
     }
 
@@ -34,9 +33,8 @@ public KdbndpQueryCompilationContext(
         QueryCompilationContextDependencies dependencies,
         RelationalQueryCompilationContextDependencies relationalDependencies,
         bool async,
-        bool precompiling,
-        IReadOnlySet<string>? nonNullableReferenceTypeParameters)
-        : base(dependencies, relationalDependencies, async, precompiling, nonNullableReferenceTypeParameters)
+        bool precompiling)
+        : base(dependencies, relationalDependencies, async, precompiling)
     {
     }
 

src/EFCore.KingbaseES/Query/Internal/KdbndpQueryCompilationContextFactory.cs

@@ -45,6 +45,5 @@ public virtual QueryCompilationContext Create(bool async)
     /// </summary>
     public virtual QueryCompilationContext CreatePrecompiled(bool async, IReadOnlySet<string> nonNullableReferenceTypeParameters)
         => new KdbndpQueryCompilationContext(
-            _dependencies, _relationalDependencies, async, precompiling: true,
-            nonNullableReferenceTypeParameters);
+            _dependencies, _relationalDependencies, async, precompiling: true);
 }

src/EFCore.KingbaseES/Query/Internal/KdbndpQueryableMethodTranslatingExpressionVisitor.cs

@@ -206,30 +206,50 @@ protected override ShapedQueryExpression TransformJsonQueryToTable(JsonQueryExpr
         var columnInfos = new List<PgTableValuedFunctionExpression.ColumnInfo>();
 
         // We're only interested in properties which actually exist in the JSON, filter out uninteresting shadow keys
-        foreach (var property in GetAllPropertiesInHierarchy(jsonQueryExpression.EntityType))
+        foreach (var property in jsonQueryExpression.StructuralType.GetPropertiesInHierarchy())
         {
             if (property.GetJsonPropertyName() is string jsonPropertyName)
             {
                 columnInfos.Add(
                     new PgTableValuedFunctionExpression.ColumnInfo
                     {
-                        Name = jsonPropertyName, TypeMapping = property.GetRelationalTypeMapping()
+                        Name = jsonPropertyName,
+                        TypeMapping = property.GetRelationalTypeMapping()
                     });
             }
         }
 
-        // Navigations represent nested JSON owned entities, which we also add to the AS clause, but with the JSON type.
-        foreach (var navigation in GetAllNavigationsInHierarchy(jsonQueryExpression.EntityType)
-                     .Where(
-                         n => n.ForeignKey.IsOwnership
-                             && n.TargetEntityType.IsMappedToJson()
-                             && n.ForeignKey.PrincipalToDependent == n))
+        switch (jsonQueryExpression.StructuralType)
         {
-            var jsonNavigationName = navigation.TargetEntityType.GetJsonPropertyName();
-            Check.DebugAssert(jsonNavigationName is not null, $"No JSON property name for navigation {navigation.Name}");
+            case IEntityType entityType:
+                foreach (var navigation in entityType.GetNavigationsInHierarchy()
+                    .Where(n => n.ForeignKey.IsOwnership
+                        && n.TargetEntityType.IsMappedToJson()
+                        && n.ForeignKey.PrincipalToDependent == n))
+                {
+                    var jsonNavigationName = navigation.TargetEntityType.GetJsonPropertyName();
+                    Check.DebugAssert(jsonNavigationName is not null, $"No JSON property name for navigation {navigation.Name}");
+
+                    columnInfos.Add(
+                        new PgTableValuedFunctionExpression.ColumnInfo { Name = jsonNavigationName, TypeMapping = jsonTypeMapping });
+                }
+
+                break;
+
+            case IComplexType complexType:
+                foreach (var complexProperty in complexType.GetComplexProperties())
+                {
+                    var jsonPropertyName = complexProperty.ComplexType.GetJsonPropertyName();
+                    Check.DebugAssert(jsonPropertyName is not null, $"No JSON property name for complex property {complexProperty.Name}");
+
+                    columnInfos.Add(
+                        new PgTableValuedFunctionExpression.ColumnInfo { Name = jsonPropertyName, TypeMapping = jsonTypeMapping });
+                }
 
-            columnInfos.Add(
-                new PgTableValuedFunctionExpression.ColumnInfo { Name = jsonNavigationName, TypeMapping = jsonTypeMapping });
+                break;
+
+            default:
+                throw new UnreachableException();
         }
 
         // json_to_recordset requires the nested JSON document - it does not accept a path within a containing JSON document (like SQL
@@ -254,21 +274,12 @@ protected override ShapedQueryExpression TransformJsonQueryToTable(JsonQueryExpr
         return new ShapedQueryExpression(
             selectExpression,
             new RelationalStructuralTypeShaperExpression(
-                jsonQueryExpression.EntityType,
+                jsonQueryExpression.StructuralType,
                 new ProjectionBindingExpression(
                     selectExpression,
                     new ProjectionMember(),
                     typeof(ValueBuffer)),
                 false));
-
-        // TODO: Move these to IEntityType?
-        static IEnumerable<IProperty> GetAllPropertiesInHierarchy(IEntityType entityType)
-            => entityType.GetAllBaseTypes().Concat(entityType.GetDerivedTypesInclusive())
-                .SelectMany(t => t.GetDeclaredProperties());
-
-        static IEnumerable<INavigation> GetAllNavigationsInHierarchy(IEntityType entityType)
-            => entityType.GetAllBaseTypes().Concat(entityType.GetDerivedTypesInclusive())
-                .SelectMany(t => t.GetDeclaredNavigations());
     }
 
     /// <summary>
@@ -1096,46 +1107,18 @@ protected override bool IsValidSelectExpressionForExecuteUpdate(
     ///     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>
-    protected override bool IsValidSelectExpressionForExecuteDelete(
-        SelectExpression selectExpression,
-        StructuralTypeShaperExpression shaper,
-        [NotNullWhen(true)] out TableExpression? tableExpression)
-    {
-        // The default relational behavior is to allow only single-table expressions, and the only permitted feature is a predicate.
-        // Here we extend this to also inner joins to tables, which we generate via the KingbaseES-specific USING construct.
-        if (selectExpression is
-            {
-                Orderings: [],
-                Offset: null,
-                Limit: null,
-                GroupBy: [],
-                Having: null
-            })
-        {
-            TableExpressionBase? table = null;
-            if (selectExpression.Tables.Count == 1)
-            {
-                table = selectExpression.Tables[0];
-            }
-            else if (selectExpression.Tables.All(t => t is TableExpression or InnerJoinExpression))
-            {
-                var projectionBindingExpression = (ProjectionBindingExpression)shaper.ValueBufferExpression;
-                var entityProjectionExpression =
-                    (StructuralTypeProjectionExpression)selectExpression.GetProjection(projectionBindingExpression);
-                var column = entityProjectionExpression.BindProperty(shaper.StructuralType.GetProperties().First());
-                table = selectExpression.Tables.Select(t => t.UnwrapJoin()).Single(t => t.Alias == column.TableAlias);
-            }
-
-            if (table is TableExpression te)
-            {
-                tableExpression = te;
-                return true;
-            }
-        }
-
-        tableExpression = null;
-        return false;
-    }
+    protected override bool IsValidSelectExpressionForExecuteDelete(SelectExpression selectExpression)
+       // The default relational behavior is to allow only single-table expressions, and the only permitted feature is a predicate.
+       // Here we extend this to also inner joins to tables, which we generate via the PostgreSQL-specific USING construct.
+       => selectExpression is
+       {
+           Orderings: [],
+           Offset: null,
+           Limit: null,
+           GroupBy: [],
+           Having: null
+       }
+       && selectExpression.Tables[0] is TableExpression && selectExpression.Tables.Skip(1).All(t => t is InnerJoinExpression);
 
     // KingbaseES unnest is guaranteed to return output rows in the same order as its input array,
     // https://www.KingbaseES.org/docs/current/functions-array.html.

src/EFCore.KingbaseES/Query/Internal/KdbndpSqlNullabilityProcessor.cs

@@ -737,5 +737,5 @@ private static bool MayContainNulls(SqlExpression arrayExpression)
     // Note that we can check parameter values for null since we cache by the parameter nullability; but we cannot do the same for bool.
     private bool IsNull(SqlExpression? expression)
         => expression is SqlConstantExpression { Value: null }
-            || expression is SqlParameterExpression { Name: string parameterName } && ParameterValues[parameterName] is null;
+            || expression is SqlParameterExpression { Name: string parameterName } && ParametersDecorator.IsNull(parameterName);
 }