Migration from Core 2 to Core 5

src/EFCore.OpenEdge/EFCore.OpenEdge.csproj

@@ -1,12 +1,10 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <AssemblyName>EntityFrameworkCore.OpenEdge</AssemblyName>
+    <TargetFramework>net5.0</TargetFramework>
+	<AssemblyName>EntityFrameworkCore.OpenEdge</AssemblyName>
     <RootNamespace>EntityFrameworkCore.OpenEdge</RootNamespace>
-    <LangVersion>7.2</LangVersion>
-    <VersionPrefix>1.0.0</VersionPrefix>
-    <SignAssembly>true</SignAssembly>
+	<SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>../../efcoreoe.snk</AssemblyOriginatorKeyFile>
     <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
     <Authors>Alex Wiese</Authors>
@@ -16,7 +14,7 @@
     <RepositoryType>git</RepositoryType>
     <PackageTags>openedge;progress;Entity Framework Core;entity-framework-core;ef;efcore;orm;sql</PackageTags>
   </PropertyGroup>
-
+  
   <PropertyGroup>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <WarningsAsErrors />
@@ -28,9 +26,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="[2.1.4,2.2)" PrivateAssets="none" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="[2.1.4,2.2)" PrivateAssets="none" />
-    <PackageReference Include="System.Data.Odbc" Version="4.5.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="5.0.11" PrivateAssets="none" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="5.0.11" PrivateAssets="none" />
+    <PackageReference Include="System.Data.Odbc" Version="5.0.0" />
   </ItemGroup>
 
 </Project>

src/EFCore.OpenEdge/Extensions/OpenEdgeDbContextOptionsBuilderExtensions.cs

@@ -1,18 +1,15 @@
-using System;
-using EntityFrameworkCore.OpenEdge.Infrastructure.Internal;
-using Microsoft.EntityFrameworkCore;
+using EntityFrameworkCore.OpenEdge.Infrastructure.Internal;
 using Microsoft.EntityFrameworkCore.Infrastructure;
+using System;
 
 namespace Microsoft.EntityFrameworkCore
 {
     public static class OpenEdgeDbContextOptionsBuilderExtensions
     {
-        public static DbContextOptionsBuilder UseOpenEdge(
-            this DbContextOptionsBuilder optionsBuilder,
-            string connectionString,
-            Action<DbContextOptionsBuilder> optionsAction = null)
+        public static DbContextOptionsBuilder UseOpenEdge(this DbContextOptionsBuilder optionsBuilder,
+                                                          string connectionString,
+                                                          Action<DbContextOptionsBuilder> optionsAction = null)
         {
-
             var extension = GetOrCreateExtension(optionsBuilder).WithConnectionString(connectionString);
             ((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(extension);
 
@@ -21,15 +18,14 @@ public static DbContextOptionsBuilder UseOpenEdge(
             return optionsBuilder;
         }
 
-        public static DbContextOptionsBuilder<TContext> UseOpenEdge<TContext>(
-            this DbContextOptionsBuilder<TContext> optionsBuilder,
-            string connectionString,
-            Action<DbContextOptionsBuilder> optionsAction = null)
+        public static DbContextOptionsBuilder<TContext> UseOpenEdge<TContext>(this DbContextOptionsBuilder<TContext> optionsBuilder,
+                                                                              string connectionString,
+                                                                              Action<DbContextOptionsBuilder> optionsAction = null)
             where TContext : DbContext
             => (DbContextOptionsBuilder<TContext>)UseOpenEdge(
                 (DbContextOptionsBuilder)optionsBuilder, connectionString, optionsAction);
 
         private static OpenEdgeOptionsExtension GetOrCreateExtension(DbContextOptionsBuilder optionsBuilder) 
             => optionsBuilder.Options.FindExtension<OpenEdgeOptionsExtension>() ?? new OpenEdgeOptionsExtension();
     }
-}
+}

src/EFCore.OpenEdge/Extensions/OpenEdgeServiceCollectionExtensions.cs

@@ -8,12 +8,11 @@
 using EntityFrameworkCore.OpenEdge.Storage.Internal.Mapping;
 using EntityFrameworkCore.OpenEdge.Update;
 using EntityFrameworkCore.OpenEdge.Update.Internal;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Metadata.Conventions.Internal;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
 using Microsoft.EntityFrameworkCore.Query;
-using Microsoft.EntityFrameworkCore.Query.ExpressionTranslators;
 using Microsoft.EntityFrameworkCore.Query.Internal;
-using Microsoft.EntityFrameworkCore.Query.Sql;
 using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.EntityFrameworkCore.Update;
 using Microsoft.EntityFrameworkCore.Update.Internal;
@@ -25,31 +24,91 @@ public static class OpenEdgeServiceCollectionExtensions
     {
         public static IServiceCollection AddEntityFrameworkOpenEdge(this IServiceCollection serviceCollection)
         {
+#pragma warning disable EF1001 // Internal EF Core API usage.
             var builder = new EntityFrameworkRelationalServicesBuilder(serviceCollection)
+                .TryAdd<IBatchExecutor, BatchExecutor>()
+#pragma warning restore EF1001 // Internal EF Core API usage.
                 .TryAdd<IDatabaseProvider, DatabaseProvider<OpenEdgeOptionsExtension>>()
                 .TryAdd<IRelationalTypeMappingSource, OpenEdgeTypeMappingSource>()
                 .TryAdd<ISqlGenerationHelper, OpenEdgeSqlGenerationHelper>()
                 .TryAdd<IConventionSetBuilder, OpenEdgeRelationalConventionSetBuilder>()
                 .TryAdd<IUpdateSqlGenerator, OpenEdgeUpdateSqlGenerator>()
-                .TryAdd<ISingletonUpdateSqlGenerator, OpenEdgeUpdateSqlGenerator>()
                 .TryAdd<IModificationCommandBatchFactory, OpenEdgeModificationCommandBatchFactory>()
                 .TryAdd<IRelationalConnection>(p => p.GetService<IOpenEdgeRelationalConnection>())
-                .TryAdd<IRelationalResultOperatorHandler, OpenEdgeResultOperatorHandler>()
-                .TryAdd<IQueryModelGenerator, OpenEdgeQueryModelGenerator>()
+                //.TryAdd<IRelationalResultOperatorHandler, OpenEdgeResultOperatorHandler>()
+                //.TryAdd<IQueryModelGenerator, OpenEdgeQueryModelGenerator>()
+                .TryAdd<IQueryTranslationPreprocessorFactory, OpenEdgeQueryTranslationPreprocessorFactory>()
 
-                .TryAdd<IBatchExecutor, BatchExecutor>()
+                /* TESTING */
+
+                .TryAdd<IAsyncQueryProvider, EntityQueryProvider>()
+                .TryAdd<IQueryCompiler, QueryCompiler>()
+                .TryAdd<IEvaluatableExpressionFilter, RelationalEvaluatableExpressionFilter>()
+
+                /* TESTING */
 
-                .TryAdd<IMemberTranslator, OpenEdgeCompositeMemberTranslator>()
-                .TryAdd<ICompositeMethodCallTranslator, OpenEdgeCompositeMethodCallTranslator>()
+
+                .TryAdd<LoggingDefinitions, OpenEdgeLoggingDefinitions>()
+                .TryAdd<IMemberTranslatorProvider, OpenEdgeCompositeMemberTranslator>()
+                .TryAdd<IMethodCallTranslatorProvider, OpenEdgeCompositeMethodCallTranslator>()
                 .TryAdd<IQuerySqlGeneratorFactory, OpenEdgeSqlGeneratorFactory>()
-                
+
                 .TryAddProviderSpecificServices(b => b
                     .TryAddScoped<IOpenEdgeUpdateSqlGenerator, OpenEdgeUpdateSqlGenerator>()
-                    .TryAddScoped<IOpenEdgeRelationalConnection, OpenEdgeRelationalConnection>()); ;
+                    .TryAddScoped<IOpenEdgeRelationalConnection, OpenEdgeRelationalConnection>());
 
             builder.TryAddCoreServices();
             return serviceCollection;
         }
-
     }
-}
+}
+
+
+/*
+== FROM EFCore
+
+public static IServiceCollection AddEntityFrameworkSqlServer(this IServiceCollection serviceCollection)
+{
+    Check.NotNull(serviceCollection, nameof(serviceCollection));
+
+    new EntityFrameworkRelationalServicesBuilder(serviceCollection)
+        .TryAdd<LoggingDefinitions, SqlServerLoggingDefinitions>()
+        .TryAdd<IDatabaseProvider, DatabaseProvider<SqlServerOptionsExtension>>()
+        .TryAdd<IValueGeneratorCache>(p => p.GetRequiredService<ISqlServerValueGeneratorCache>())
+        .TryAdd<IRelationalTypeMappingSource, SqlServerTypeMappingSource>()
+        .TryAdd<ISqlGenerationHelper, SqlServerSqlGenerationHelper>()
+        .TryAdd<IRelationalAnnotationProvider, SqlServerAnnotationProvider>()
+        .TryAdd<IMigrationsAnnotationProvider, SqlServerMigrationsAnnotationProvider>()
+        .TryAdd<IModelValidator, SqlServerModelValidator>()
+        .TryAdd<IProviderConventionSetBuilder, SqlServerConventionSetBuilder>()
+        .TryAdd<IUpdateSqlGenerator>(p => p.GetRequiredService<ISqlServerUpdateSqlGenerator>())
+        .TryAdd<IEvaluatableExpressionFilter, SqlServerEvaluatableExpressionFilter>()
+        .TryAdd<IRelationalTransactionFactory, SqlServerTransactionFactory>()
+        .TryAdd<IModificationCommandBatchFactory, SqlServerModificationCommandBatchFactory>()
+        .TryAdd<IValueGeneratorSelector, SqlServerValueGeneratorSelector>()
+        .TryAdd<IRelationalConnection>(p => p.GetRequiredService<ISqlServerConnection>())
+        .TryAdd<IMigrationsSqlGenerator, SqlServerMigrationsSqlGenerator>()
+        .TryAdd<IRelationalDatabaseCreator, SqlServerDatabaseCreator>()
+        .TryAdd<IHistoryRepository, SqlServerHistoryRepository>()
+        .TryAdd<IExecutionStrategyFactory, SqlServerExecutionStrategyFactory>()
+        .TryAdd<IRelationalQueryStringFactory, SqlServerQueryStringFactory>()
+        .TryAdd<ICompiledQueryCacheKeyGenerator, SqlServerCompiledQueryCacheKeyGenerator>()
+        .TryAdd<IQueryCompilationContextFactory, SqlServerQueryCompilationContextFactory>()
+        .TryAdd<IMethodCallTranslatorProvider, SqlServerMethodCallTranslatorProvider>()
+        .TryAdd<IMemberTranslatorProvider, SqlServerMemberTranslatorProvider>()
+        .TryAdd<IQuerySqlGeneratorFactory, SqlServerQuerySqlGeneratorFactory>()
+        .TryAdd<IRelationalSqlTranslatingExpressionVisitorFactory, SqlServerSqlTranslatingExpressionVisitorFactory>()
+        .TryAdd<IRelationalParameterBasedSqlProcessorFactory, SqlServerParameterBasedSqlProcessorFactory>()
+        .TryAdd<IQueryRootCreator, SqlServerQueryRootCreator>()
+        .TryAdd<IQueryableMethodTranslatingExpressionVisitorFactory, SqlServerQueryableMethodTranslatingExpressionVisitorFactory>()
+        .TryAddProviderSpecificServices(
+            b => b
+                .TryAddSingleton<ISqlServerValueGeneratorCache, SqlServerValueGeneratorCache>()
+                .TryAddSingleton<ISqlServerUpdateSqlGenerator, SqlServerUpdateSqlGenerator>()
+                .TryAddSingleton<ISqlServerSequenceValueGeneratorFactory, SqlServerSequenceValueGeneratorFactory>()
+                .TryAddScoped<ISqlServerConnection, SqlServerConnection>())
+        .TryAddCoreServices();
+
+    return serviceCollection;
+}
+*/

src/EFCore.OpenEdge/Infrastructure/Internal/OpenEdgeOptionsExtension.cs

@@ -1,20 +1,46 @@
 using EntityFrameworkCore.OpenEdge.Extensions;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.Extensions.DependencyInjection;
+using System.Collections.Generic;
 
 namespace EntityFrameworkCore.OpenEdge.Infrastructure.Internal
 {
     public class OpenEdgeOptionsExtension : RelationalOptionsExtension
     {
+        private DbContextOptionsExtensionInfo _info;
+
+        public override DbContextOptionsExtensionInfo Info
+        {
+            get
+            {
+                return this._info ??= (new OpenEdgeDbContextOptionsExtensionInfo(this));
+            }
+        }
+
         protected override RelationalOptionsExtension Clone()
         {
             return new OpenEdgeOptionsExtension();
         }
 
-        public override bool ApplyServices(IServiceCollection services)
+        public override void ApplyServices(IServiceCollection services)
         {
             services.AddEntityFrameworkOpenEdge();
-            return true;
+        }
+
+        private sealed class OpenEdgeDbContextOptionsExtensionInfo : DbContextOptionsExtensionInfo
+        {
+            public OpenEdgeDbContextOptionsExtensionInfo(IDbContextOptionsExtension instance) : 
+                base(instance)
+            {
+            }
+
+            public override bool IsDatabaseProvider => true;
+
+            public override string LogFragment => "";
+
+            public override void PopulateDebugInfo(IDictionary<string, string> debugInfo) {}
+
+            public override long GetServiceProviderHashCode() => 0;
         }
     }
-}
+}

src/EFCore.OpenEdge/Metadata/Conventions/Internal/OpenEdgeRelationalConventionSetBuilder.cs

@@ -1,11 +1,13 @@
-using Microsoft.EntityFrameworkCore.Metadata.Conventions.Internal;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
 
 namespace EntityFrameworkCore.OpenEdge.Metadata.Conventions.Internal
 {
-    public class OpenEdgeRelationalConventionSetBuilder : RelationalConventionSetBuilder
+    public class OpenEdgeRelationalConventionSetBuilder : RelationalConventionSetBuilder, IConventionSetBuilder
     {
-        public OpenEdgeRelationalConventionSetBuilder(RelationalConventionSetBuilderDependencies dependencies) : base(dependencies)
+        public OpenEdgeRelationalConventionSetBuilder(ProviderConventionSetBuilderDependencies dependencies, 
+                                                      RelationalConventionSetBuilderDependencies relationalDependencies) : 
+            base(dependencies, relationalDependencies)
         {
         }
     }
-}
+}

src/EFCore.OpenEdge/Query/ExpressionTranslators/Internal/OpenEdgeCompositeMemberTranslator.cs

@@ -1,17 +1,19 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.EntityFrameworkCore.Query.ExpressionTranslators;
+using Microsoft.EntityFrameworkCore.Query;
+//using Microsoft.EntityFrameworkCore.Query.ExpressionTranslators;
 
 namespace EntityFrameworkCore.OpenEdge.Query.ExpressionTranslators.Internal
 {
-    public class OpenEdgeCompositeMemberTranslator : RelationalCompositeMemberTranslator
+    public class OpenEdgeCompositeMemberTranslator : RelationalMemberTranslatorProvider // RelationalCompositeMemberTranslator
     {
         private static readonly List<Type> _translatorsMethods
             = OpenEdgeCompositeMethodCallTranslator.GetTranslatorMethods<IMemberTranslator>().ToList();
 
-        public OpenEdgeCompositeMemberTranslator(RelationalCompositeMemberTranslatorDependencies dependencies)
-            : base(dependencies)
-            => AddTranslators(_translatorsMethods.Select(type => (IMemberTranslator)Activator.CreateInstance(type)));
+        public OpenEdgeCompositeMemberTranslator(RelationalMemberTranslatorProviderDependencies dependencies) : base(dependencies)
+        {
+            AddTranslators(_translatorsMethods.Select(type => (IMemberTranslator)Activator.CreateInstance(type)));
+        }
     }
 }

src/EFCore.OpenEdge/Query/ExpressionTranslators/Internal/OpenEdgeCompositeMethodCallTranslator.cs

@@ -2,18 +2,21 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using Microsoft.EntityFrameworkCore.Query.ExpressionTranslators;
+using Microsoft.EntityFrameworkCore.Query;
+//using Microsoft.EntityFrameworkCore.Query.ExpressionTranslators;
 
 namespace EntityFrameworkCore.OpenEdge.Query.ExpressionTranslators.Internal
 {
-    public class OpenEdgeCompositeMethodCallTranslator : RelationalCompositeMethodCallTranslator
+    public class OpenEdgeCompositeMethodCallTranslator : RelationalMethodCallTranslatorProvider //RelationalCompositeMethodCallTranslator
     {
         private static readonly List<Type> _translatorsMethods
             = GetTranslatorMethods<IMethodCallTranslator>().ToList();
 
-        public OpenEdgeCompositeMethodCallTranslator(RelationalCompositeMethodCallTranslatorDependencies dependencies)
+        public OpenEdgeCompositeMethodCallTranslator(RelationalMethodCallTranslatorProviderDependencies dependencies)
             : base(dependencies)
-            => AddTranslators(_translatorsMethods.Select(type => (IMethodCallTranslator)Activator.CreateInstance(type)));
+        {
+            AddTranslators(_translatorsMethods.Select(type => (IMethodCallTranslator)Activator.CreateInstance(type)));
+        }
 
         public static IEnumerable<Type> GetTranslatorMethods<TInteface>()
             => Assembly

src/EFCore.OpenEdge/Query/ExpressionVisitors/Internal/OpenEdgeExtractingExpressionVisitor.cs

@@ -0,0 +1,62 @@
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace EntityFrameworkCore.OpenEdge.Query.ExpressionVisitors.Internal
+{
+    public class OpenEdgeExtractingExpressionVisitor : ExpressionVisitor
+    {
+
+        protected override Expression VisitNew(NewExpression node)
+        {
+            var memberArguments = node.Arguments
+#pragma warning disable EF1001 // Internal EF Core API usage.
+                .Select(m => m is MemberExpression mem ? VisitNewMember(mem) : Visit(m))
+#pragma warning restore EF1001 // Internal EF Core API usage.
+                .ToList();
+
+            var newNode = node.Update(memberArguments);
+
+            return newNode;
+        }
+
+        protected override Expression VisitMethodCall(MethodCallExpression methodCallExpression)
+        {
+            if (methodCallExpression.Method.Name == "Take")
+            {
+                return methodCallExpression;
+            }
+
+            if (methodCallExpression.Method.Name == "Skip")
+            {
+                return methodCallExpression;
+            }
+
+            return base.VisitMethodCall(methodCallExpression);
+        }
+
+        protected Expression VisitNewMember(MemberExpression memberExpression)
+        {
+            if (memberExpression.Expression is ConstantExpression constant
+                && constant.Value != null)
+            {
+                switch (memberExpression.Member.MemberType)
+                {
+                    case MemberTypes.Field:
+                        return Expression.Constant(constant.Value.GetType().GetField(memberExpression.Member.Name).GetValue(constant.Value));
+
+                    case MemberTypes.Property:
+                        var propertyInfo = constant.Value.GetType().GetProperty(memberExpression.Member.Name);
+                        if (propertyInfo == null)
+                        {
+                            break;
+                        }
+
+                        return Expression.Constant(propertyInfo.GetValue(constant.Value));
+                }
+            }
+
+            return base.VisitMember(memberExpression);
+        }
+    }
+}