implementation of schema generation (without scaffolding)

Author: messieurMe

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/Migrations/Internal/YdbHistoryRepository.cs

@@ -1,38 +1,62 @@
 using System;
+using System.Data;
+using System.Diagnostics;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using EfCore.Ydb.Storage.Internal;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage;
+using Ydb.Sdk.Ado;
 
 namespace EfCore.Ydb.Migrations.Internal;
 
-// TODO: For migrations only. Not required for mvp
 public class YdbHistoryRepository : HistoryRepository
 {
-    public YdbHistoryRepository(
-        HistoryRepositoryDependencies dependencies
-    ) : base(dependencies)
+    public YdbHistoryRepository(HistoryRepositoryDependencies dependencies) : base(dependencies)
     {
     }
 
     protected override bool InterpretExistsResult(object? value)
-    {
-        throw new NotImplementedException();
-    }
+        => throw new InvalidOperationException("Shouldn't be called");
 
     public override IMigrationsDatabaseLock AcquireDatabaseLock()
     {
-        throw new NotImplementedException();
+        Dependencies.MigrationsLogger.AcquiringMigrationLock();
+        return new YdbMigrationDatabaseLock(this, Dependencies.Connection);
     }
 
     public override Task<IMigrationsDatabaseLock> AcquireDatabaseLockAsync(
-        CancellationToken cancellationToken = new CancellationToken())
+        CancellationToken cancellationToken = default
+    )
     {
         throw new NotImplementedException();
     }
 
     public override string GetCreateIfNotExistsScript()
+        => GetCreateScript().Replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS");
+
+    public override LockReleaseBehavior LockReleaseBehavior => LockReleaseBehavior.Transaction;
+
+    protected override string ExistsSql
+        => throw new UnreachableException("Shouldn't be called. We check if exists using different approach");
+
+    public override bool Exists()
+        => ExistsAsync().ConfigureAwait(false).GetAwaiter().GetResult();
+
+    public override Task<bool> ExistsAsync(CancellationToken cancellationToken = default)
     {
-        throw new NotImplementedException();
+        var connection = (YdbRelationalConnection)Dependencies.Connection;
+        var schema = (YdbConnection)connection.DbConnection;
+        var tables = schema.GetSchema("tables");
+
+        var foundTables =
+            from table in tables.AsEnumerable()
+            where table.Field<string>("table_type") == "TABLE"
+                  && table.Field<string>("table_name") == TableName
+            select table;
+        return Task.FromResult(foundTables.Count() == 1);
     }
 
     public override string GetBeginIfNotExistsScript(string migrationId)
@@ -50,6 +74,27 @@ public override string GetEndIfScript()
         throw new NotImplementedException();
     }
 
-    public override LockReleaseBehavior LockReleaseBehavior { get; }
-    protected override string ExistsSql { get; }
+    // TODO Implement lock
+    private sealed class YdbMigrationDatabaseLock : IMigrationsDatabaseLock
+    {
+        private YdbRelationalConnection _connection;
+
+        public YdbMigrationDatabaseLock(
+            IHistoryRepository historyRepository,
+            IRelationalConnection connection
+        )
+        {
+            HistoryRepository = historyRepository;
+            _connection = (YdbRelationalConnection)connection;
+        }
+
+        public void Dispose()
+        {
+        }
+
+        public ValueTask DisposeAsync()
+            => default;
+
+        public IHistoryRepository HistoryRepository { get; }
+    }
 }

src/EfCore.Ydb/src/Migrations/YdbMigrationsSqlGenerator.cs

@@ -1,12 +1,85 @@
+using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Migrations.Operations;
 
 namespace EfCore.Ydb.Migrations;
 
 public class YdbMigrationsSqlGenerator : MigrationsSqlGenerator
 {
-    public YdbMigrationsSqlGenerator(
-        MigrationsSqlGeneratorDependencies dependencies
-    ) : base(dependencies)
+    public YdbMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies) : base(dependencies)
     {
     }
+
+    protected override void Generate(
+        CreateTableOperation operation,
+        IModel? model,
+        MigrationCommandListBuilder builder,
+        bool terminate = true
+    )
+    {
+        if (!terminate && operation.Comment is not null)
+        {
+            // TODO: Handle comments
+        }
+
+        builder.Append("CREATE ");
+        // TODO: Support EXTERNAL tables?
+        builder
+            .Append("TABLE ")
+            .Append(DelimitIdentifier(operation.Name, operation.Schema))
+            .AppendLine(" (");
+
+        using (builder.Indent())
+        {
+            CreateTableColumns(operation, model, builder);
+            CreateTableConstraints(operation, model, builder);
+            builder.AppendLine();
+        }
+
+        builder.Append(")");
+
+        // TODO: Support `WITH {}` block
+
+        if (terminate)
+        {
+            builder.Append(";");
+            EndStatement(builder, suppressTransaction: true);
+        }
+    }
+    
+    protected override void CreateTablePrimaryKeyConstraint(
+        CreateTableOperation operation,
+        IModel? model,
+        MigrationCommandListBuilder builder
+    )
+    {
+        if (operation.PrimaryKey == null) return;
+
+        builder.AppendLine(",");
+        PrimaryKeyConstraint(operation.PrimaryKey, model, builder);
+    }
+
+    protected override void PrimaryKeyConstraint(
+        AddPrimaryKeyOperation operation,
+        IModel? model,
+        MigrationCommandListBuilder builder
+    )
+    {
+        builder
+            .Append("PRIMARY KEY (")
+            .Append(ColumnList(operation.Columns))
+            .Append(")");
+        IndexOptions(operation, model, builder);
+    }
+
+    protected override void Generate(SqlOperation operation, IModel? model, MigrationCommandListBuilder builder)
+    {
+        builder.AppendLine(operation.Sql);
+        // TODO: Find out how to apply migration without suppressing transaction
+        // We suppress transaction because CREATE/DROP operations cannot be executed during them
+        EndStatement(builder, suppressTransaction: true);
+    }
+
+    private string DelimitIdentifier(string name, string? schema)
+        => Dependencies.SqlGenerationHelper.DelimitIdentifier(name, schema);
 }

src/EfCore.Ydb/src/Properties/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using Microsoft.EntityFrameworkCore.Design;
+
+[assembly: DesignTimeProviderServices("EfCore.Ydb.Design.Internal.YdbDesignTimeServices")]

src/EfCore.Ydb/src/Storage/Internal/IYdbRelationalConnection.cs

@@ -4,4 +4,6 @@ namespace EfCore.Ydb.Storage.Internal;
 
 public interface IYdbRelationalConnection : IRelationalConnection
 {
+
+    IYdbRelationalConnection Clone();
 }

src/EfCore.Ydb/src/Storage/Internal/YdbDatabaseCreator.cs

@@ -1,19 +1,51 @@
 using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Storage;
+using Ydb.Sdk.Ado;
 
 namespace EfCore.Ydb.Storage.Internal;
 
 public class YdbDatabaseCreator : RelationalDatabaseCreator
 {
+    private readonly IYdbRelationalConnection _connection;
+    private readonly IRelationalConnectionDiagnosticsLogger _connectionLogger;
+
     public YdbDatabaseCreator(
-        RelationalDatabaseCreatorDependencies dependencies
+        RelationalDatabaseCreatorDependencies dependencies,
+        IYdbRelationalConnection connection,
+        IRawSqlCommandBuilder rawSqlCommandBuilder,
+        IRelationalConnectionDiagnosticsLogger connectionLogger
     ) : base(dependencies)
     {
+        _connection = connection;
+        _connectionLogger = connectionLogger;
     }
 
     public override bool Exists()
+        => ExistsInternal().GetAwaiter().GetResult();
+
+    public override Task<bool> ExistsAsync(CancellationToken cancellationToken = new CancellationToken())
+        => ExistsInternal(cancellationToken);
+
+    private async Task<bool> ExistsInternal(CancellationToken cancellationToken = default)
     {
-        throw new NotImplementedException();
+        var connection = _connection.Clone();
+        try
+        {
+            await connection.OpenAsync(cancellationToken, errorsExpected: true);
+            return true;
+        }
+        catch (YdbException)
+        {
+            return false;
+        }
+        finally
+        {
+            await connection.CloseAsync().ConfigureAwait(false);
+            await connection.DisposeAsync().ConfigureAwait(false);
+        }
     }
 
     public override bool HasTables()
@@ -22,12 +54,8 @@ public override bool HasTables()
     }
 
     public override void Create()
-    {
-        throw new NotImplementedException();
-    }
+        => throw new NotSupportedException("Ydb does not support database creation");
 
     public override void Delete()
-    {
-        throw new NotImplementedException();
-    }
+        => throw new NotSupportedException("Ydb does not support database deletion");
 }

src/EfCore.Ydb/src/Storage/Internal/YdbRelationalConnection.cs

@@ -1,4 +1,6 @@
 using System.Data.Common;
+using EfCore.Ydb.Extensions;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Storage;
 using Ydb.Sdk.Ado;
 
@@ -24,4 +26,11 @@ protected override DbConnection CreateDbConnection()
         var connection = new YdbConnection(GetValidatedConnectionString());
         return connection;
     }
+
+    public IYdbRelationalConnection Clone()
+    {
+        var connectionStringBuilder = new YdbConnectionStringBuilder(GetValidatedConnectionString());
+        var options = new DbContextOptionsBuilder().UseEfYdb(connectionStringBuilder.ToString()).Options;
+        return new YdbRelationalConnection(Dependencies with { ContextOptions = options });
+    }
 }