Oracle: Handle "NULL" as default value

Author: JaBistDuNarrisch

src/Migrator.Tests/Database/DatabaseName/DatabaseNameService.cs

@@ -1,16 +1,15 @@
 using System;
 using System.Globalization;
 using System.IO;
-using System.Linq;
+using System.Security.Cryptography;
 using System.Text.RegularExpressions;
 using Migrator.Tests.Database.DatabaseName.Interfaces;
-using Migrator.Tests.Database.GuidServices.Interfaces;
 
 namespace Migrator.Test.Shared.Database;
 
-public partial class DatabaseNameService(TimeProvider timeProvider, IGuidService guidService) : IDatabaseNameService
+public partial class DatabaseNameService(TimeProvider timeProvider) : IDatabaseNameService
 {
-    private const string TestDatabaseString = "Test";
+    private const string TestDatabaseString = "T";
     private const string TimeStampPattern = "yyyyMMddHHmmssfff";
 
     public DateTime? ReadTimeStampFromString(string name)
@@ -33,14 +32,25 @@ public string CreateDatabaseName()
         var dateTimePattern = timeProvider.GetUtcNow()
             .ToString(TimeStampPattern);
 
-        var randomString = string.Concat(guidService.NewGuid()
-            .ToString("N")
-            .Reverse()
-            .Take(9));
+        var randomString = CreateRandomChars(7);
 
         return $"{dateTimePattern}{TestDatabaseString}{randomString}";
     }
 
-    [GeneratedRegex(@"^(\d+)(?=Test.{9}$)")]
+    private string CreateRandomChars(int length)
+    {
+        var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+        var stringChars = new char[length];
+
+        for (var i = 0; i < length; i++)
+        {
+            var index = RandomNumberGenerator.GetInt32(chars.Length);
+            stringChars[i] = chars[index];
+        }
+
+        return new string(stringChars);
+    }
+
+    [GeneratedRegex(@"^([\d]+)(?=T.{7}$)")]
     private static partial Regex DateTimeRegex();
-}
+}

src/Migrator.Tests/Database/DerivedDatabaseIntegrationTestServices/OracleDatabaseIntegrationTestService.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -19,7 +19,7 @@
 
 namespace Migrator.Tests.Database.DerivedDatabaseIntegrationTestServices;
 
-public class OracleDatabaseIntegrationTestService(
+public partial class OracleDatabaseIntegrationTestService(
     TimeProvider timeProvider,
     IDatabaseNameService databaseNameService)
         : DatabaseIntegrationTestServiceBase(databaseNameService), IDatabaseIntegrationTestService
@@ -61,8 +61,6 @@ public class OracleDatabaseIntegrationTestService(
     /// <exception cref="NotImplementedException"></exception>
     public override async Task<DatabaseInfo> CreateTestDatabaseAsync(DatabaseConnectionConfig databaseConnectionConfig, CancellationToken cancellationToken)
     {
-        DataConnection context;
-
         var tempDatabaseConnectionConfig = databaseConnectionConfig.Adapt<DatabaseConnectionConfig>();
 
         var connectionStringBuilder = new OracleConnectionStringBuilder()
@@ -82,15 +80,12 @@ public override async Task<DatabaseInfo> CreateTestDatabaseAsync(DatabaseConnect
 
         var tempUserName = DatabaseNameService.CreateDatabaseName();
 
-        List<string> userNames;
-
         var dataOptions = new DataOptions().UseOracle(databaseConnectionConfig.ConnectionString)
             .UseMappingSchema(_mappingSchema);
 
-        using (context = new DataConnection(dataOptions))
-        {
-            userNames = await context.QueryToListAsync<string>("SELECT username FROM all_users", cancellationToken);
-        }
+        using var context = new DataConnection(dataOptions);
+
+        var userNames = await context.GetTable<AllUsers>().Select(x => x.UserName).ToListAsync(cancellationToken);
 
         var toBeDeletedUsers = userNames.Where(x =>
         {
@@ -112,49 +107,84 @@ await Parallel.ForEachAsync(
                 };
 
                 await DropDatabaseAsync(databaseInfoToBeDeleted, cancellationTokenInner);
+            });
+
+        // To be on the safe side we check for table spaces used in tests that have not been deleted for any reason (possible connection issues/concurrent deletion attempts - there is
+        // no transaction for DDL in Oracle etc.).
+        var tableSpaceNames = await context.GetTable<DBADataFiles>()
+            .Select(x => x.TablespaceName)
+            .ToListAsync(cancellationToken);
 
+        var toBeDeletedTableSpaces = tableSpaceNames
+            .Where(x =>
+            {
+                var replacedTablespaceString = TableSpacePrefixRegex().Replace(x, "");
+                var creationDate = DatabaseNameService.ReadTimeStampFromString(replacedTablespaceString);
+                return creationDate.HasValue && creationDate.Value < timeProvider.GetUtcNow().Subtract(_MinTimeSpanBeforeDatabaseDeletion);
             });
 
-        using (context = new DataConnection(dataOptions))
+        foreach (var toBeDeletedTableSpace in toBeDeletedTableSpaces)
         {
-            // To be on the safe side we check for table spaces used in tests that have not been deleted for any reason (possible connection issues/concurrent deletion attempts - there is
-            // no transaction for DDL in Oracle etc.).
-            var tableSpaceNames = await context.GetTable<DBADataFiles>()
-                .Select(x => x.TablespaceName)
-                .ToListAsync(cancellationToken);
-
-            var toBeDeletedTableSpaces = tableSpaceNames
-                .Where(x =>
-                {
-                    var replacedTablespaceString = _tablespaceRegex.Replace(x, "");
-                    var creationDate = DatabaseNameService.ReadTimeStampFromString(replacedTablespaceString);
-                    return creationDate.HasValue && creationDate.Value < timeProvider.GetUtcNow().Subtract(_MinTimeSpanBeforeDatabaseDeletion);
-                });
+            var maxAttempts = 4;
+            var delayBetweenAttempts = TimeSpan.FromSeconds(1);
 
-            foreach (var toBeDeletedTableSpace in toBeDeletedTableSpaces)
+            for (var i = 0; i < maxAttempts; i++)
             {
-                await context.ExecuteAsync($"DROP TABLESPACE {toBeDeletedTableSpace} INCLUDING CONTENTS AND DATAFILES", cancellationToken);
-            }
+                try
+                {
+                    await context.ExecuteAsync($"DROP TABLESPACE {toBeDeletedTableSpace} INCLUDING CONTENTS AND DATAFILES", cancellationToken);
+                }
+                catch
+                {
+                    var exists = await context.GetTable<DBADataFiles>().AnyAsync(x => x.TablespaceName == toBeDeletedTableSpace, cancellationToken);
 
-            await context.ExecuteAsync($"CREATE USER \"{tempUserName}\" IDENTIFIED BY \"{tempUserName}\"", cancellationToken);
+                    if (!exists)
+                    {
+                        break;
+                    }
 
-            var privileges = new[]
-            {
-                "CONNECT",
-                "CREATE SESSION",
-                "RESOURCE",
-                "UNLIMITED TABLESPACE"
-            };
-
-            await context.ExecuteAsync($"GRANT {string.Join(", ", privileges)} TO \"{tempUserName}\"", cancellationToken);
-            await context.ExecuteAsync($"GRANT SELECT ON SYS.V_$SESSION TO \"{tempUserName}\"", cancellationToken);
+                    if (i + 1 == maxAttempts)
+                    {
+                        throw;
+                    }
+
+                    await Task.Delay(delayBetweenAttempts, cancellationToken);
+
+                    delayBetweenAttempts = delayBetweenAttempts.Add(TimeSpan.FromSeconds(1));
+                }
+            }
         }
 
+        var tableSpaceName = $"{TableSpacePrefix}{tempUserName}";
+
+        var createTablespaceSql = $"CREATE TABLESPACE {tableSpaceName}";
+        await context.ExecuteAsync(createTablespaceSql, cancellationToken: cancellationToken);
+
+        var stringBuilder = new StringBuilder();
+        stringBuilder.Append($"CREATE USER \"{tempUserName}\" IDENTIFIED BY \"{tempUserName}\"");
+        stringBuilder.AppendLine($"DEFAULT TABLESPACE {tableSpaceName}");
+        stringBuilder.AppendLine($"TEMPORARY TABLESPACE TEMP");
+        stringBuilder.AppendLine($"QUOTA UNLIMITED ON {tableSpaceName}");
+
+        await context.ExecuteAsync(stringBuilder.ToString(), cancellationToken);
+
+        var privileges = new[]
+        {
+            "CONNECT",
+            "CREATE SESSION",
+            "RESOURCE",
+            "UNLIMITED TABLESPACE"
+        };
+
+        await context.ExecuteAsync($"GRANT {string.Join(", ", privileges)} TO \"{tempUserName}\"", cancellationToken);
+        await context.ExecuteAsync($"GRANT SELECT ON SYS.GV_$SESSION TO \"{tempUserName}\"", cancellationToken);
+
         connectionStringBuilder.Add(UserStringKey, ReplaceString);
         connectionStringBuilder.Add(PasswordStringKey, ReplaceString);
 
         tempDatabaseConnectionConfig.ConnectionString = connectionStringBuilder.ConnectionString;
         tempDatabaseConnectionConfig.ConnectionString = tempDatabaseConnectionConfig.ConnectionString.Replace(ReplaceString, $"\"{tempUserName}\"");
+        tempDatabaseConnectionConfig.Schema = tempUserName;
 
         var databaseInfo = new DatabaseInfo
         {
@@ -168,16 +198,18 @@ await Parallel.ForEachAsync(
 
     public override async Task DropDatabaseAsync(DatabaseInfo databaseInfo, CancellationToken cancellationToken)
     {
+        ArgumentNullException.ThrowIfNull(databaseInfo);
+
         var creationDate = ReadTimeStampFromDatabaseName(databaseInfo.SchemaName);
 
         var dataOptions = new DataOptions().UseOracle(databaseInfo.DatabaseConnectionConfigMaster.ConnectionString)
             .UseMappingSchema(_mappingSchema);
 
+        using var context = new DataConnection(dataOptions);
+
         var maxAttempts = 4;
         var delayBetweenAttempts = TimeSpan.FromSeconds(1);
 
-        using var context = new DataConnection(dataOptions);
-
         for (var i = 0; i < maxAttempts; i++)
         {
             try
@@ -192,6 +224,13 @@ public override async Task DropDatabaseAsync(DatabaseInfo databaseInfo, Cancella
                     await context.ExecuteAsync(killStatement, cancellationToken);
                 }
 
+                var userExists = context.GetTable<AllUsers>().Any(x => x.UserName == databaseInfo.SchemaName);
+
+                if (!userExists)
+                {
+                    break;
+                }
+
                 await context.ExecuteAsync($"DROP USER \"{databaseInfo.SchemaName}\" CASCADE", cancellationToken);
             }
             catch
@@ -207,19 +246,47 @@ public override async Task DropDatabaseAsync(DatabaseInfo databaseInfo, Cancella
                 {
                     break;
                 }
-            }
 
-            await Task.Delay(delayBetweenAttempts, cancellationToken);
+                await Task.Delay(delayBetweenAttempts, cancellationToken);
 
-            delayBetweenAttempts = delayBetweenAttempts.Add(TimeSpan.FromSeconds(1));
+                delayBetweenAttempts = delayBetweenAttempts.Add(TimeSpan.FromSeconds(1));
+            }
         }
 
         var tablespaceName = $"{TableSpacePrefix}{databaseInfo.SchemaName}";
 
-        var tablespaces = await context.GetTable<DBADataFiles>().ToListAsync(cancellationToken);
+        maxAttempts = 4;
+        delayBetweenAttempts = TimeSpan.FromSeconds(1);
+
+        for (var i = 0; i < maxAttempts; i++)
+        {
+            try
+            {
+                await context.ExecuteAsync($"DROP TABLESPACE {tablespaceName} INCLUDING CONTENTS AND DATAFILES", cancellationToken);
+            }
+            catch
+            {
+                var exists = await context.GetTable<DBADataFiles>().AnyAsync(x => x.TablespaceName == tablespaceName, cancellationToken);
+
+                if (!exists)
+                {
+                    break;
+                }
 
-        await context.ExecuteAsync($"DROP TABLESPACE {tablespaceName} INCLUDING CONTENTS AND DATAFILES", cancellationToken);
+                if (i + 1 == maxAttempts)
+                {
+                    throw;
+                }
+
+                await Task.Delay(delayBetweenAttempts, cancellationToken);
+
+                delayBetweenAttempts = delayBetweenAttempts.Add(TimeSpan.FromSeconds(1));
+            }
+        }
 
         await context.ExecuteAsync($"PURGE RECYCLEBIN", cancellationToken);
     }
-}
+
+    [GeneratedRegex("^TS_TESTS_")]
+    private static partial Regex TableSpacePrefixRegex();
+}

src/Migrator.Tests/Providers/Generic/Generic_AddTableTestsBase.cs

@@ -1,4 +1,6 @@
+using System.Collections.Generic;
 using System.Data;
+using System.Linq;
 using DotNetProjects.Migrator.Framework;
 using Migrator.Tests.Providers.Base;
 using NUnit.Framework;
@@ -30,6 +32,86 @@ public void AddTable_PrimaryKeyWithIdentity_Success()
         Assert.That(column2.ColumnProperty.HasFlag(ColumnProperty.NotNull), Is.True);
     }
 
+    [Test]
+    public void AddTable_PrimaryKeyAndIdentity_Success()
+    {
+        // Arrange
+        var tableName = "TableName";
+        var column1Name = "Column1";
+        var column2Name = "Column2";
+
+        // Act
+        Provider.AddTable(tableName,
+            new Column(column1Name, DbType.Int32, ColumnProperty.NotNull | ColumnProperty.PrimaryKey | ColumnProperty.Identity),
+            new Column(column2Name, DbType.Int32, ColumnProperty.NotNull)
+        );
+
+        // Assert
+        var column1 = Provider.GetColumnByName(tableName, column1Name);
+        var column2 = Provider.GetColumnByName(tableName, column2Name);
+
+        Assert.That(column1.ColumnProperty.HasFlag(ColumnProperty.PrimaryKeyWithIdentity), Is.True);
+        Assert.That(column2.ColumnProperty.HasFlag(ColumnProperty.NotNull), Is.True);
+    }
+
+    [Test]
+    public void AddTable_PrimaryKeyAndIdentityWithInsertNull_Success()
+    {
+        // Arrange
+        var tableName = "TableName";
+        var column1Name = "Column1";
+        var column2Name = "Column2";
+
+        // Act
+        Provider.AddTable(tableName,
+            new Column(column1Name, DbType.Int32, ColumnProperty.NotNull | ColumnProperty.PrimaryKey | ColumnProperty.Identity),
+            new Column(column2Name, DbType.Int32, ColumnProperty.NotNull)
+        );
+
+        Provider.Insert(table: tableName, [column2Name], [999]);
+
+        // Assert
+        var column1 = Provider.GetColumnByName(tableName, column1Name);
+        var column2 = Provider.GetColumnByName(tableName, column2Name);
+
+        using var cmd = Provider.CreateCommand();
+        using var reader = Provider.Select(cmd: cmd, table: tableName, columns: [column1Name, column2Name]);
+
+        List<(int, int)> records = [];
+
+        while (reader.Read())
+        {
+            records.Add((reader.GetInt32(0), reader.GetInt32(1)));
+        }
+
+        Assert.That(records.Single().Item1, Is.EqualTo(1));
+
+        Assert.That(column1.ColumnProperty.HasFlag(ColumnProperty.PrimaryKeyWithIdentity), Is.True);
+        Assert.That(column2.ColumnProperty.HasFlag(ColumnProperty.NotNull), Is.True);
+    }
+
+    [Test]
+    public void AddTable_PrimaryKeyAndIdentityWithoutNotNull_Success()
+    {
+        // Arrange
+        var tableName = "TableName";
+        var column1Name = "Column1";
+        var column2Name = "Column2";
+
+        // Act
+        Provider.AddTable(tableName,
+            new Column(column1Name, DbType.Int32, ColumnProperty.PrimaryKey | ColumnProperty.Identity),
+            new Column(column2Name, DbType.Int32, ColumnProperty.NotNull)
+        );
+
+        // Assert
+        var column1 = Provider.GetColumnByName(tableName, column1Name);
+        var column2 = Provider.GetColumnByName(tableName, column2Name);
+
+        Assert.That(column1.ColumnProperty.HasFlag(ColumnProperty.PrimaryKeyWithIdentity), Is.True);
+        Assert.That(column2.ColumnProperty.HasFlag(ColumnProperty.NotNull), Is.True);
+    }
+
     [Test]
     public void AddTable_NotNull_Success()
     {