MVP of Entity Framework

.github/scripts/format-all-dotnet-code.sh

@@ -4,7 +4,6 @@ set -eu
 
 DIR="$1"
 SLN_FILE="$2"
-PROFILE="$3"
 
 cd "$DIR"
 

.github/workflows/lint.yml

@@ -27,13 +27,13 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: '8.0.x'
+          dotnet-version: 9.0.x
       - name: Restore
         run: dotnet restore ${{ matrix.source-dir }}${{ matrix.solutionFile }}
       - name: Install ReSharper
         run: dotnet tool install -g JetBrains.ReSharper.GlobalTools
       - name: format all files with auto-formatter
-        run: bash ./.github/scripts/format-all-dotnet-code.sh ${{ matrix.source-dir }} ${{ matrix.solutionFile }} "Custom Cleanup"
+        run: bash ./.github/scripts/format-all-dotnet-code.sh ${{ matrix.source-dir }} ${{ matrix.solutionFile }}
       - name: Check repository diff
         run: bash ./.github/scripts/check-work-copy-equals-to-committed.sh "auto-format broken"
 
@@ -48,20 +48,21 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Setup .NET
+        id: setup-dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: '8.0.x'
+          dotnet-version: 9.0.x
       - name: Restore
         run: dotnet restore ${{ matrix.solutionPath }}
       - name: Inspect code
         uses: muno92/resharper_inspectcode@v1
         with:
           solutionPath: ${{ matrix.solutionPath }}
-          version: 2023.2.1
           include: |
             **.cs
             **.cshtml
           minimumReportSeverity: WARNING
+          dotnetVersion: ${{ steps.setup-dotnet.outputs.dotnet-version }}
           ignoreIssueType: | 
             UnusedField.Compiler,
             UnusedVariable.Compiler,

src/EfCore.Ydb/src/Abstractions/YdbStringAttribute.cs

@@ -0,0 +1,6 @@
+using System;
+
+namespace EfCore.Ydb.Abstractions;
+
+[AttributeUsage(AttributeTargets.Property)]
+public class YdbStringAttribute : Attribute;

src/EfCore.Ydb/src/Design/Internal/YdbDesignTimeServices.cs

@@ -0,0 +1,16 @@
+using EfCore.Ydb.Extensions;
+using Microsoft.EntityFrameworkCore.Design;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EfCore.Ydb.Design.Internal;
+
+public class YdbDesignTimeServices : IDesignTimeServices
+{
+    public void ConfigureDesignTimeServices(IServiceCollection serviceCollection)
+    {
+        serviceCollection.AddEntityFrameworkYdb();
+
+        new EntityFrameworkRelationalDesignServicesBuilder(serviceCollection)
+            .TryAddCoreServices();
+    }
+}

src/EfCore.Ydb/src/Diagnostics/Internal/YdbCommandInterceptor.cs

@@ -0,0 +1,14 @@
+using System.Data.Common;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+
+namespace EfCore.Ydb.Diagnostics.Internal;
+
+// Temporary for debugging
+public class YdbCommandInterceptor : DbCommandInterceptor
+{
+    public override InterceptionResult<DbDataReader> ReaderExecuting(
+        DbCommand command,
+        CommandEventData eventData,
+        InterceptionResult<DbDataReader> result
+    ) => result;
+}

src/EfCore.Ydb/src/Diagnostics/Internal/YdbLoggingDefinitions.cs

@@ -0,0 +1,5 @@
+using Microsoft.EntityFrameworkCore.Diagnostics;
+
+namespace EfCore.Ydb.Diagnostics.Internal;
+
+public class YdbLoggingDefinitions : RelationalLoggingDefinitions;

src/EfCore.Ydb/src/EfCore.Ydb.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <RootNamespace>EfCore.Ydb</RootNamespace>
+        <Nullable>enable</Nullable>
+        <PackageId>EfCore.Ydb</PackageId>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.0"/>
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.0"/>
+        <PackageReference Include="Ydb.Sdk" Version="0.15.3"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <Reference Include="Microsoft.EntityFrameworkCore.Relational">
+            <HintPath>..\..\..\..\..\.nuget\packages\microsoft.entityframeworkcore.relational\9.0.0\lib\net8.0\Microsoft.EntityFrameworkCore.Relational.dll</HintPath>
+        </Reference>
+    </ItemGroup>
+</Project>

src/EfCore.Ydb/src/Extensions/YdbContextOptionsBuilderExtensions.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Data.Common;
+using EfCore.Ydb.Infrastructure;
+using EfCore.Ydb.Infrastructure.Internal;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace EfCore.Ydb.Extensions;
+
+public static class YdbContextOptionsBuilderExtensions
+{
+    public static DbContextOptionsBuilder UseEfYdb(
+        this DbContextOptionsBuilder optionsBuilder,
+        string? connectionString,
+        Action<YdbDbContextOptionsBuilder>? efYdbOptionsAction = null
+    )
+    {
+        var extension = GetOrCreateExtension(optionsBuilder).WithConnectionString(connectionString);
+        ((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(extension);
+
+        ConfigureWarnings(optionsBuilder);
+
+        efYdbOptionsAction?.Invoke(new YdbDbContextOptionsBuilder(optionsBuilder));
+        return optionsBuilder;
+    }
+
+    public static DbContextOptionsBuilder UseEfYdb(
+        this DbContextOptionsBuilder optionsBuilder,
+        DbConnection connection,
+        Action<YdbDbContextOptionsBuilder>? efYdbOptionsAction = null
+    )
+    {
+        var extension = GetOrCreateExtension(optionsBuilder).WithConnection(connection);
+        ((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(extension);
+
+        ConfigureWarnings(optionsBuilder);
+
+        efYdbOptionsAction?.Invoke(new YdbDbContextOptionsBuilder(optionsBuilder));
+        return optionsBuilder;
+    }
+
+    // TODO: Right now there are no arguments for constructor, so probably it's ok
+    private static YdbOptionsExtension GetOrCreateExtension(DbContextOptionsBuilder options)
+        => options.Options.FindExtension<YdbOptionsExtension>() ?? new YdbOptionsExtension();
+
+    private static void ConfigureWarnings(DbContextOptionsBuilder optionsBuilder)
+    {
+        var coreOptionsExtension = optionsBuilder.Options.FindExtension<CoreOptionsExtension>()
+                                   ?? new CoreOptionsExtension();
+
+        coreOptionsExtension = RelationalOptionsExtension.WithDefaultWarningConfiguration(coreOptionsExtension);
+        ((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(coreOptionsExtension);
+    }
+}

src/EfCore.Ydb/src/Extensions/YdbServiceCollectionExtensions.cs

@@ -0,0 +1,61 @@
+using EfCore.Ydb.Diagnostics.Internal;
+using EfCore.Ydb.Infrastructure;
+using EfCore.Ydb.Infrastructure.Internal;
+using EfCore.Ydb.Metadata.Conventions;
+using EfCore.Ydb.Metadata.Internal;
+using EfCore.Ydb.Migrations;
+using EfCore.Ydb.Migrations.Internal;
+using EfCore.Ydb.Query.Internal;
+using EfCore.Ydb.Storage.Internal;
+using EfCore.Ydb.Update.Internal;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.EntityFrameworkCore.Update;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EfCore.Ydb.Extensions;
+
+public static class YdbServiceCollectionExtensions
+{
+    public static IServiceCollection AddEntityFrameworkYdb(this IServiceCollection serviceCollection)
+    {
+        new EntityFrameworkYdbServicesBuilder(serviceCollection)
+            .TryAdd<LoggingDefinitions, YdbLoggingDefinitions>()
+            .TryAdd<IDatabaseProvider, DatabaseProvider<YdbOptionsExtension>>()
+            .TryAdd<IRelationalTypeMappingSource, YdbTypeMappingSource>()
+            .TryAdd<ISqlGenerationHelper, YdbSqlGenerationHelper>()
+            .TryAdd<IRelationalAnnotationProvider, YdbAnnotationProvider>()
+            .TryAdd<IModelValidator, YdbModelValidator>()
+            .TryAdd<IProviderConventionSetBuilder, YdbConventionSetBuilder>()
+            .TryAdd<IUpdateSqlGenerator, YdbUpdateSqlGenerator>()
+            .TryAdd<IModificationCommandFactory, YdbModificationCommandFactory>()
+            .TryAdd<IRelationalTransactionFactory, YdbRelationalTransactionFactory>()
+            .TryAdd<IModificationCommandBatchFactory, YdbModificationCommandBatchFactory>()
+            .TryAdd<IRelationalConnection>(p => p.GetRequiredService<IYdbRelationalConnection>())
+            .TryAdd<IMigrationsSqlGenerator, YdbMigrationsSqlGenerator>()
+            .TryAdd<IRelationalDatabaseCreator, YdbDatabaseCreator>()
+            .TryAdd<IHistoryRepository, YdbHistoryRepository>()
+            .TryAdd<IQueryableMethodTranslatingExpressionVisitorFactory,
+                YdbQueryableMethodTranslatingExpressionVisitorFactory>()
+            .TryAdd<IMethodCallTranslatorProvider, YdbMethodCallTranslatorProvider>()
+            .TryAdd<IAggregateMethodCallTranslatorProvider, YdbAggregateMethodCallTranslatorProvider>()
+            .TryAdd<IMemberTranslatorProvider, YdbMemberTranslatorProvider>()
+            .TryAdd<IQuerySqlGeneratorFactory, YdbQuerySqlGeneratorFactory>()
+            .TryAdd<IRelationalSqlTranslatingExpressionVisitorFactory, YdbSqlTranslatingExpressionVisitorFactory>()
+            .TryAdd<IQueryTranslationPostprocessorFactory, YdbQueryTranslationPostprocessorFactory>()
+            .TryAdd<IRelationalParameterBasedSqlProcessorFactory, YdbParameterBasedSqlProcessorFactory>()
+            .TryAdd<ISqlExpressionFactory, YdbSqlExpressionFactory>()
+            .TryAdd<IQueryCompilationContextFactory, YdbQueryCompilationContextFactory>()
+            .TryAddProviderSpecificServices(b => b
+                .TryAddScoped<IYdbRelationalConnection, YdbRelationalConnection>()
+                .TryAddScoped<IDbCommandInterceptor, YdbCommandInterceptor>())
+            .TryAddCoreServices();
+
+        return serviceCollection;
+    }
+}

src/EfCore.Ydb/src/Infrastructure/EntityFrameworkYdbServicesBuilder.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EfCore.Ydb.Infrastructure;
+
+public class EntityFrameworkYdbServicesBuilder(IServiceCollection serviceCollection)
+    : EntityFrameworkRelationalServicesBuilder(serviceCollection)
+{
+    // ReSharper disable once CollectionNeverUpdated.Local
+#pragma warning disable CA1859
+    private static readonly IDictionary<Type, ServiceCharacteristics> YdbServices
+#pragma warning restore CA1859
+        = new Dictionary<Type, ServiceCharacteristics>
+        {
+            // TODO: Add items if required
+        };
+
+    protected override ServiceCharacteristics GetServiceCharacteristics(Type serviceType)
+    {
+        var contains = YdbServices.TryGetValue(serviceType, out var characteristics);
+        return contains
+            ? characteristics
+            : base.GetServiceCharacteristics(serviceType);
+    }
+}

src/EfCore.Ydb/src/Infrastructure/Internal/YdbModelValidator.cs

@@ -0,0 +1,9 @@
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace EfCore.Ydb.Infrastructure.Internal;
+
+// TODO: Not required for mvp
+public class YdbModelValidator(
+    ModelValidatorDependencies dependencies,
+    RelationalModelValidatorDependencies relationalDependencies
+) : RelationalModelValidator(dependencies, relationalDependencies);

src/EfCore.Ydb/src/Infrastructure/Internal/YdbOptionsExtension.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using EfCore.Ydb.Extensions;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EfCore.Ydb.Infrastructure.Internal;
+
+public class YdbOptionsExtension : RelationalOptionsExtension
+{
+    private DbContextOptionsExtensionInfo? _info;
+
+    public YdbOptionsExtension()
+    {
+    }
+
+    protected YdbOptionsExtension(YdbOptionsExtension copyFrom) : base(copyFrom)
+    {
+    }
+
+    protected override RelationalOptionsExtension Clone()
+        => new YdbOptionsExtension(this);
+
+    public override void ApplyServices(IServiceCollection services)
+        => services.AddEntityFrameworkYdb();
+
+    public override DbContextOptionsExtensionInfo Info
+        => _info ??= new ExtensionInfo(this);
+
+    private sealed class ExtensionInfo(IDbContextOptionsExtension extension) : RelationalExtensionInfo(extension)
+    {
+        public override bool IsDatabaseProvider => true;
+
+        // TODO: Right now it's stub
+        public override void PopulateDebugInfo(IDictionary<string, string> debugInfo) => debugInfo["Hello"] = "World!";
+    }
+}

src/EfCore.Ydb/src/Infrastructure/YdbDbContextOptionsBuilder.cs

@@ -0,0 +1,8 @@
+using EfCore.Ydb.Infrastructure.Internal;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace EfCore.Ydb.Infrastructure;
+
+public class YdbDbContextOptionsBuilder(DbContextOptionsBuilder optionsBuilder)
+    : RelationalDbContextOptionsBuilder<YdbDbContextOptionsBuilder, YdbOptionsExtension>(optionsBuilder);

src/EfCore.Ydb/src/Metadata/Conventions/YdbConventionSetBuilder.cs

@@ -0,0 +1,18 @@
+using Microsoft.EntityFrameworkCore.Metadata.Conventions;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
+
+namespace EfCore.Ydb.Metadata.Conventions;
+
+// ReSharper disable once ClassNeverInstantiated.Global
+public class YdbConventionSetBuilder(
+    ProviderConventionSetBuilderDependencies dependencies,
+    RelationalConventionSetBuilderDependencies relationalDependencies
+) : RelationalConventionSetBuilder(dependencies, relationalDependencies)
+{
+    public override ConventionSet CreateConventionSet()
+    {
+        var coreConventions = base.CreateConventionSet();
+        coreConventions.Add(new YdbStringAttributeConvention(Dependencies));
+        return coreConventions;
+    }
+}

src/EfCore.Ydb/src/Metadata/Conventions/YdbStringAttributeConvention.cs

@@ -0,0 +1,19 @@
+using System.Reflection;
+using EfCore.Ydb.Abstractions;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
+
+namespace EfCore.Ydb.Metadata.Conventions;
+
+public class YdbStringAttributeConvention(ProviderConventionSetBuilderDependencies dependencies)
+    : PropertyAttributeConventionBase<YdbStringAttribute>(dependencies)
+{
+    protected override void ProcessPropertyAdded(
+        IConventionPropertyBuilder propertyBuilder,
+        YdbStringAttribute attribute,
+        MemberInfo clrMember,
+        IConventionContext context
+    ) => propertyBuilder.HasColumnType("string");
+}

src/EfCore.Ydb/src/Metadata/Internal/YdbAnnotationNames.cs

@@ -0,0 +1,8 @@
+namespace EfCore.Ydb.Metadata.Internal;
+
+public static class YdbAnnotationNames
+{
+    private const string Prefix = "Ydb";
+
+    public const string Serial = Prefix + "Serial";
+}

src/EfCore.Ydb/src/Metadata/Internal/YdbAnnotationProvider.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+
+namespace EfCore.Ydb.Metadata.Internal;
+
+public class YdbAnnotationProvider(RelationalAnnotationProviderDependencies dependencies)
+    : RelationalAnnotationProvider(dependencies)
+{
+    public override IEnumerable<IAnnotation> For(IColumn column, bool designTime)
+    {
+        if (!designTime)
+        {
+            yield break;
+        }
+
+        // TODO: Add Yson here too?
+        if (column is JsonColumn)
+        {
+            yield break;
+        }
+
+        var property = column.PropertyMappings[0].Property;
+
+        if (property.ValueGenerated == ValueGenerated.OnAdd
+            && property.ClrType == typeof(int)
+            && property.FindTypeMapping()?.Converter == null)
+        {
+            yield return new Annotation(YdbAnnotationNames.Serial, true);
+        }
+    }
+}