Solve #245 without new command-line parameter (#256)

* Solve #245 without new command-line parameter
* Ignore the standard tables casing issue for Oracle, as it has never been case sensitive
* Fixed casing of INFORMATION_SCHEMA in unit tests

grate.unittests/Generic/GenericMigrationTables.cs

@@ -98,7 +98,90 @@ public async Task Migration_does_not_fail_if_table_already_exists(string tableNa
             Assert.DoesNotThrowAsync(() => migrator.Migrate());
         }
     }
+
+    [TestCase("version")]
+    [TestCase("vErSiON")]
+    public async Task Does_not_create_Version_table_if_it_exists_with_another_casing(string existingTable)
+    {
+        await CheckTableCasing("Version", existingTable, (config, name) => config.VersionTableName = name);
+    }
+
+    [TestCase("scriptsrun")]
+    [TestCase("SCRiptSrUN")]
+    public async Task Does_not_create_ScriptsRun_table_if_it_exists_with_another_casing(string existingTable)
+    {
+        await CheckTableCasing("ScriptsRun", existingTable, (config, name) => config.ScriptsRunTableName = name);
+    }
+
+    [TestCase("scriptsrunerrors")]
+    [TestCase("ScripTSRunErrors")]
+    public async Task Does_not_create_ScriptsRunErrors_table_if_it_exists_with_another_casing(string existingTable)
+    {
+        await CheckTableCasing("ScriptsRunErrors", existingTable, (config, name) => config.ScriptsRunErrorsTableName = name);
+    }
+
+    protected virtual async Task CheckTableCasing(string tableName, string funnyCasing, Action<GrateConfiguration, string> setTableName)
+    {
+        var db = TestConfig.RandomDatabase();
+
+        var parent = TestConfig.CreateRandomTempDirectory();
+        var knownFolders = FoldersConfiguration.Default();
+
+        // Set the version table name to be lower-case first, and run one migration.
+        var config = Context.GetConfiguration(db, parent, knownFolders);
+
+        setTableName(config, funnyCasing);
+
+        await using (var migrator = Context.GetMigrator(config))
+        {
+            await migrator.Migrate();
+        }
+
+        // Check that the table is indeed created with lower-case
+        var errorCaseCountAfterFirstMigration = await TableCountIn(db, funnyCasing);
+        var normalCountAfterFirstMigration = await TableCountIn(db, tableName);
+        Assert.Multiple(() =>
+        {
+            errorCaseCountAfterFirstMigration.Should().Be(1);
+            normalCountAfterFirstMigration.Should().Be(0);
+        });
+
+        // Run migration again - make sure it does not create the table with different casing too
+        setTableName(config, tableName);
+        await using (var migrator = Context.GetMigrator(config))
+        {
+            await migrator.Migrate();
+        }
+
+        var errorCaseCountAfterSecondMigration = await TableCountIn(db, funnyCasing);
+        var normalCountAfterSecondMigration = await TableCountIn(db, tableName);
+        Assert.Multiple(() =>
+        {
+            errorCaseCountAfterSecondMigration.Should().Be(1);
+            normalCountAfterSecondMigration.Should().Be(0);
+        });
+
+    }
+
+    private async Task<int> TableCountIn(string db, string tableName)
+    {
+        var schemaName = Context.DefaultConfiguration.SchemaName;
+        var supportsSchemas = Context.DatabaseMigrator.SupportsSchemas;
 
+        var fullTableName = supportsSchemas ? tableName : Context.Syntax.TableWithSchema(schemaName, tableName);
+        var tableSchema = supportsSchemas ? schemaName : db;
+
+        int count;
+        string countSql = CountTableSql(tableSchema, fullTableName);
+
+        await using (var conn = Context.GetDbConnection(Context.ConnectionString(db)))
+        {
+            count = await conn.ExecuteScalarAsync<int>(countSql);
+        }
+
+        return count;
+    }
+
     [Test()]
     public async Task Inserts_version_in_version_table()
     {
@@ -156,4 +239,14 @@ protected static DirectoryInfo MakeSurePathExists(DirectoryInfo? path)
     private static DirectoryInfo Wrap(DirectoryInfo root, string? relativePath) =>
         new(Path.Combine(root.ToString(), relativePath ?? ""));
 
+    protected virtual string CountTableSql(string schemaName, string tableName)
+    {
+        return $@"
+SELECT count(table_name) FROM INFORMATION_SCHEMA.TABLES
+WHERE 
+table_schema = '{schemaName}' AND
+table_name = '{tableName}'
+";
+    }
+
 }

grate.unittests/Oracle/MigrationTables.cs

@@ -1,11 +1,28 @@
+using System;
+using System.Threading.Tasks;
+using grate.Configuration;
 using grate.unittests.TestInfrastructure;
 using NUnit.Framework;
 
 namespace grate.unittests.Oracle;
 
 [TestFixture]
 [Category("Oracle")]
-public class MigrationTables: Generic.GenericMigrationTables
+public class MigrationTables : Generic.GenericMigrationTables
 {
     protected override IGrateTestContext Context => GrateTestContext.Oracle;
-}
+
+    protected override Task CheckTableCasing(string tableName, string funnyCasing, Action<GrateConfiguration, string> setTableName)
+    {
+        Assert.Ignore("Oracle has never been case-sensitive for grate. No need to introduce that now.");
+        return Task.CompletedTask;
+    }
+
+    protected override string CountTableSql(string schemaName, string tableName)
+    {
+        return $@"
+SELECT COUNT(table_name) FROM user_tables
+WHERE 
+lower(table_name) = '{tableName.ToLowerInvariant()}'";
+    }
+}

grate.unittests/SqLite/MigrationTables.cs

@@ -8,4 +8,13 @@ namespace grate.unittests.Sqlite;
 public class MigrationTables: Generic.GenericMigrationTables
 {
     protected override IGrateTestContext Context => GrateTestContext.Sqlite;
-}
+
+    protected override string CountTableSql(string schemaName, string tableName)
+    {
+        return $@"
+SELECT COUNT(name) FROM sqlite_master 
+WHERE type ='table' AND 
+name = '{tableName}';
+";
+    }
+}

grate.unittests/SqlServer/MigrationTables.cs

@@ -8,4 +8,14 @@ namespace grate.unittests.SqlServer;
 public class MigrationTables: Generic.GenericMigrationTables
 {
     protected override IGrateTestContext Context => GrateTestContext.SqlServer;
-}
+
+    protected override string CountTableSql(string schemaName, string tableName)
+    {
+        return $@"
+SELECT count(table_name) FROM INFORMATION_SCHEMA.TABLES
+WHERE
+TABLE_SCHEMA = '{schemaName}' AND
+TABLE_NAME = '{tableName}' COLLATE Latin1_General_CS_AS
+";
+    }
+}

grate.unittests/TestContext.cs

@@ -1,4 +1,8 @@
 using grate.unittests.TestInfrastructure;
+using NUnit.Framework;
+
+// There are some parallelism issues, but this does not solve it
+//[assembly:LevelOfParallelism(1)]
 
 namespace grate.unittests;
 

grate.unittests/TestInfrastructure/IGrateTestContext.cs

@@ -56,6 +56,17 @@ DefaultConfiguration with
             SqlFilesDirectory = sqlFilesDirectory
         };
 
+    public GrateConfiguration GetConfiguration(string databaseName, DirectoryInfo sqlFilesDirectory,
+        IFoldersConfiguration knownFolders, string? env, bool runInTransaction) =>
+        DefaultConfiguration with
+        {
+            ConnectionString = ConnectionString(databaseName),
+            Folders = knownFolders,
+            Environment = env != null ? new GrateEnvironment(env) : null,
+            Transaction = runInTransaction,
+            SqlFilesDirectory = sqlFilesDirectory
+        };
+
     public GrateMigrator GetMigrator(GrateConfiguration config)
     {
         var factory = Substitute.For<IFactory>();

grate/Configuration/GrateConfiguration.cs

@@ -26,6 +26,10 @@ public record GrateConfiguration
     public string? ConnectionString { get; init; } = null;
 
     public string SchemaName { get; init; } = "grate";
+
+    public string ScriptsRunTableName { get; set; } = "ScriptsRun";
+    public string ScriptsRunErrorsTableName { get; set; } = "ScriptsRunErrors";
+    public string VersionTableName { get; set; } = "Version";
 
     public string? AdminConnectionString
     {

grate/Migration/AnsiSqlDatabase.cs

@@ -46,26 +46,42 @@ protected AnsiSqlDatabase(ILogger logger, ISyntax syntax)
         .Split("=", TrimEntries | RemoveEmptyEntries).Last();
 
     public abstract bool SupportsDdlTransactions { get; }
-    protected abstract bool SupportsSchemas { get; }
+    public abstract bool SupportsSchemas { get; }
     public bool SplitBatchStatements => true;
 
     public string StatementSeparatorRegex => _syntax.StatementSeparatorRegex;
 
-    public string ScriptsRunTable => _syntax.TableWithSchema(SchemaName, "ScriptsRun");
-    public string ScriptsRunErrorsTable => _syntax.TableWithSchema(SchemaName, "ScriptsRunErrors");
-    public string VersionTable => _syntax.TableWithSchema(SchemaName, "Version");
+    public string ScriptsRunTable => _syntax.TableWithSchema(SchemaName, ScriptsRunTableName);
+    public string ScriptsRunErrorsTable => _syntax.TableWithSchema(SchemaName, ScriptsRunErrorsTableName);
+    public string VersionTable => _syntax.TableWithSchema(SchemaName, VersionTableName);
+
+    private string ScriptsRunTableName { get; set; }
+    private string ScriptsRunErrorsTableName { get; set; }
+    private string VersionTableName { get; set; }
 
     public virtual Task InitializeConnections(GrateConfiguration configuration)
     {
         Logger.LogInformation("Initializing connections.");
 
         ConnectionString = configuration.ConnectionString;
         AdminConnectionString = configuration.AdminConnectionString;
+
         SchemaName = configuration.SchemaName;
+
+        VersionTableName = configuration.VersionTableName;
+        ScriptsRunTableName = configuration.ScriptsRunTableName;
+        ScriptsRunErrorsTableName = configuration.ScriptsRunErrorsTableName;
+
         Config = configuration;
+
         return Task.CompletedTask;
     }
 
+    private async Task<string> ExistingOrDefault(string schemaName, string tableName) =>
+        await ExistingTable(schemaName, tableName) ?? tableName;
+
+
+
     private string? AdminConnectionString { get; set; }
     protected string? ConnectionString { get; set; }
 
@@ -266,6 +282,10 @@ private async Task<bool> RunSchemaExists()
 
     protected virtual async Task CreateScriptsRunTable()
     {
+        // Update scripts run table name with the correct casing, should it differ from the standard
+
+        ScriptsRunTableName = await ExistingOrDefault(SchemaName, ScriptsRunTableName);
+
         string createSql = $@"
 CREATE TABLE {ScriptsRunTable}(
 	{_syntax.PrimaryKeyColumn("id")},
@@ -288,6 +308,9 @@ protected virtual async Task CreateScriptsRunTable()
 
     protected virtual async Task CreateScriptsRunErrorsTable()
     {
+        // Update scripts run errors table name with the correct casing, should it differ from the standard
+        ScriptsRunErrorsTableName = await ExistingOrDefault(SchemaName, ScriptsRunErrorsTableName);
+
         string createSql = $@"
 CREATE TABLE {ScriptsRunErrorsTable}(
 	{_syntax.PrimaryKeyColumn("id")},
@@ -310,6 +333,9 @@ protected virtual async Task CreateScriptsRunErrorsTable()
 
     protected virtual async Task CreateVersionTable()
     {
+        // Update version table name with the correct casing, should it differ from the standard
+        VersionTableName = await ExistingOrDefault(SchemaName, VersionTableName);
+
         string createSql = $@"
 CREATE TABLE {VersionTable}(
 	{_syntax.PrimaryKeyColumn("id")},
@@ -320,6 +346,7 @@ protected virtual async Task CreateVersionTable()
 	entered_by {_syntax.VarcharType}(50) NULL
 	{_syntax.PrimaryKeyConstraint("Version", "id")}
 )";
+
         if (!await VersionTableExists())
         {
             await ExecuteNonQuery(ActiveConnection, createSql, Config?.CommandTimeout);
@@ -338,21 +365,25 @@ ALTER TABLE {VersionTable}
         }
     }
 
-    protected async Task<bool> ScriptsRunTableExists() => await TableExists(SchemaName, "ScriptsRun");
-    protected async Task<bool> ScriptsRunErrorsTableExists() => await TableExists(SchemaName, "ScriptsRunErrors");
-    public async Task<bool> VersionTableExists() => await TableExists(SchemaName, "Version");
-    protected async Task<bool> StatusColumnInVersionTableExists() => await ColumnExists(SchemaName, "Version", "status");
+    protected async Task<bool> ScriptsRunTableExists() => (await ExistingTable(SchemaName, ScriptsRunTableName) is not null) ;
+    protected async Task<bool> ScriptsRunErrorsTableExists() => (await ExistingTable(SchemaName, ScriptsRunErrorsTableName) is not null);
+    public async Task<bool> VersionTableExists() => (await ExistingTable(SchemaName, VersionTableName) is not null);
+
+    protected async Task<bool> StatusColumnInVersionTableExists() => await ColumnExists(SchemaName, VersionTableName, "status");
 
-    public async Task<bool> TableExists(string schemaName, string tableName)
+    public async Task<string?> ExistingTable(string schemaName, string tableName)
     {
         var fullTableName = SupportsSchemas ? tableName : _syntax.TableWithSchema(schemaName, tableName);
         var tableSchema = SupportsSchemas ? schemaName : DatabaseName;
-
+        
         string existsSql = ExistsSql(tableSchema, fullTableName);
 
         var res = await ExecuteScalarAsync<object>(ActiveConnection, existsSql);
 
-        return !DBNull.Value.Equals(res) && res is not null;
+        var name = (!DBNull.Value.Equals(res) && res is not null) ? (string) res : null;
+
+        var prefix = SupportsSchemas ? string.Empty : _syntax.TableWithSchema(schemaName, string.Empty);
+        return name?[prefix.Length..] ;
     }
 
     private async Task<bool> ColumnExists(string schemaName, string tableName, string columnName)
@@ -369,10 +400,10 @@ private async Task<bool> ColumnExists(string schemaName, string tableName, strin
     protected virtual string ExistsSql(string tableSchema, string fullTableName)
     {
         return $@"
-SELECT * FROM INFORMATION_SCHEMA.TABLES 
+SELECT table_name FROM INFORMATION_SCHEMA.TABLES 
 WHERE 
-TABLE_SCHEMA = '{tableSchema}' AND
-TABLE_NAME = '{fullTableName}'
+LOWER(TABLE_SCHEMA) = LOWER('{tableSchema}') AND
+LOWER(TABLE_NAME) = LOWER('{fullTableName}')
 ";
     }
 
@@ -381,9 +412,9 @@ protected virtual string ExistsSql(string tableSchema, string fullTableName, str
         return $@"
 SELECT * FROM INFORMATION_SCHEMA.COLUMNS 
 WHERE 
-TABLE_SCHEMA = '{tableSchema}' AND
-TABLE_NAME = '{fullTableName}' AND
-COLUMN_NAME = '{columnName}' 
+LOWER(TABLE_SCHEMA) = LOWER('{tableSchema}') AND
+LOWER(TABLE_NAME) = LOWER('{fullTableName}') AND
+LOWER(COLUMN_NAME) = LOWER('{columnName}') 
 ";
     }
 

grate/Migration/IDatabase.cs

@@ -17,6 +17,7 @@ public interface IDatabase : IAsyncDisposable
     public string ScriptsRunErrorsTable { get; }
     public string VersionTable { get; }
     DbConnection ActiveConnection { set; }
+    bool SupportsSchemas { get; }
 
     Task InitializeConnections(GrateConfiguration configuration);
     Task OpenConnection();
@@ -48,4 +49,5 @@ Task InsertScriptRun(string scriptName, string? sql, string hash, bool runOnce,
     void SetDefaultConnectionActive();
     Task<IDisposable> OpenNewActiveConnection();
     Task OpenActiveConnection();
+    Task<string?> ExistingTable(string schemaName, string tableName);
 }

grate/Migration/MariaDbDatabase.cs

@@ -15,7 +15,7 @@ public MariaDbDatabase(ILogger<MariaDbDatabase> logger)
     { }
 
     public override bool SupportsDdlTransactions => false;
-    protected override bool SupportsSchemas => false;
+    public override bool SupportsSchemas => false;
     protected override DbConnection GetSqlConnection(string? connectionString) => new MySqlConnection(connectionString);
 
     public override Task RestoreDatabase(string backupPath)

grate/Migration/OracleDatabase.cs

@@ -23,13 +23,13 @@ public OracleDatabase(ILogger<OracleDatabase> logger)
     }
 
     public override bool SupportsDdlTransactions => false;
-    protected override bool SupportsSchemas => false;
+    public override bool SupportsSchemas => false;
 
     protected override DbConnection GetSqlConnection(string? connectionString) => new OracleConnection(connectionString);
 
     protected override string ExistsSql(string tableSchema, string fullTableName) =>
         $@"
-SELECT * FROM user_tables
+SELECT table_name FROM user_tables
 WHERE 
 lower(table_name) = '{fullTableName.ToLowerInvariant()}'
 ";