/// <summary>
/// Initialize object from the <see cref="RenameTableExpressionBuilder"/> object
/// </summary>
/// <param name="builder">The <see cref="RenameTableExpressionBuilder"/> object</param>
/// <param name="changeLog">The <see cref="ChangeLogContext"/> object</param>
public ChangeLogLinkedExpression(RenameTableExpressionBuilder builder, ChangeLogContext changeLog)
: this(changeLog, builder.Expression)
{
SchemaName = builder.Expression.SchemaName;
TableName = builder.Expression.NewName;
OldRenamedName = builder.Expression.OldName;
}
public UserService(
ChangeLogContext context,
ITokenGeneration iTokenGeneration)
{
_context = context;
_iTokenGeneration = iTokenGeneration;
}
private static T AddChangeLogDynamicSyntax <T>(T syntax, ChangeLogContext changeLog, IMigrationModel migration)
{
var expressions = migration?.GetExpressions();
if (syntax is RenameTableExpressionBuilder renameTableBuilder)
{
expressions?.Insert(renameTableBuilder.Expression, new ChangeLogLinkedExpression(renameTableBuilder, changeLog), true);
return(syntax);
}
if (syntax is RenameColumnExpressionBuilder renameColumnBuilder)
{
expressions?.Insert(renameColumnBuilder.Expression, new ChangeLogLinkedExpression(renameColumnBuilder, changeLog), true);
return(syntax);
}
if (syntax is DeleteTableExpressionBuilder deleteTableBuilder)
{
expressions.Insert(deleteTableBuilder.Expression, new ChangeLogLinkedExpression(deleteTableBuilder, changeLog), true);
return(syntax);
}
if (syntax is DeleteColumnExpressionBuilder deleteColumnBuilder)
{
expressions?.Insert(deleteColumnBuilder.Expression, new ChangeLogLinkedExpression(deleteColumnBuilder, changeLog), true);
return(syntax);
}
return(syntax);
}
/// <summary>
/// Common constructor
/// </summary>
/// <param name="changeLog">The <see cref="ChangeLogContext"/> object</param>
/// <param name="expression">The <see cref="IMigrationExpression"/> object</param>
protected ChangeLogLinkedExpression(ChangeLogContext changeLog, IMigrationExpression expression)
{
Operation = (connection, transaction) => { };
Expression = expression;
ChangeLogContext = changeLog;
DbOperation = Expression.GetDbOperationFromExpression();
GetColumns = () => new List <ColumnDefinition>();
}
/// <summary>
/// Initialize object from the <see cref="AlterTableExpressionBuilder"/> object
/// </summary>
/// <param name="builder">The <see cref="AlterTableExpressionBuilder"/> object</param>
/// <param name="changeLog">The <see cref="ChangeLogContext"/> object</param>
public ChangeLogLinkedExpression(AlterTableExpressionBuilder builder, ChangeLogContext changeLog)
: this(changeLog, builder.Expression)
{
GetColumns = () => builder.GetMigrationExpressions().GetAlterColumns(builder.Expression.TableName);
SchemaName = builder.Expression.SchemaName;
TableName = builder.Expression.TableName;
TableDescription = builder.Expression.TableDescription;
}
/// <summary>
/// Initialize object from the <see cref="CreateTableExpressionBuilder"/> object
/// </summary>
/// <param name="builder">The <see cref="CreateTableExpressionBuilder"/> object</param>
/// <param name="changeLog">The <see cref="ChangeLogContext"/> object</param>
public ChangeLogLinkedExpression(CreateTableExpressionBuilder builder, ChangeLogContext changeLog)
: this(changeLog, builder.Expression)
{
GetColumns = () => builder.Expression.Columns;
SchemaName = builder.Expression.SchemaName;
TableName = builder.Expression.TableName;
TableDescription = builder.Expression.TableDescription;
}
/// <summary>
/// Initialize object from the <see cref="CreateColumnExpressionBuilder"/> object
/// </summary>
/// <param name="builder">The <see cref="CreateColumnExpressionBuilder"/> object</param>
/// <param name="changeLog">The <see cref="ChangeLogContext"/> object</param>
public ChangeLogLinkedExpression(CreateColumnExpressionBuilder builder, ChangeLogContext changeLog)
: this(changeLog, builder.Expression)
{
GetColumns = () => new List <ColumnDefinition> {
builder.Expression.Column
};
SchemaName = builder.Expression.SchemaName;
TableName = builder.Expression.TableName;
}
private static T AddChangeLogAlterTableSyntax <T>(T syntax, ChangeLogContext changeLog) where T : IAlterTableAddColumnOrAlterColumnSyntax
{
if (syntax is AlterTableExpressionBuilder alterTableBuilder)
{
var expressions = alterTableBuilder.GetMigrationExpressions();
expressions.Insert(alterTableBuilder.Expression, new ChangeLogLinkedExpression(alterTableBuilder, changeLog), true);
}
return(syntax);
}
/// <summary>
/// Initialize object from the <see cref="DeleteColumnExpressionBuilder"/> object
/// </summary>
/// <param name="builder">The <see cref="DeleteColumnExpressionBuilder"/> object</param>
/// <param name="changeLog">The <see cref="ChangeLogContext"/> object</param>
public ChangeLogLinkedExpression(DeleteColumnExpressionBuilder builder, ChangeLogContext changeLog)
: this(changeLog, builder.Expression)
{
GetColumns = () => builder.Expression.ColumnNames.Select(x => new ColumnDefinition {
Name = x, TableName = TableName
}).ToList();
SchemaName = builder.Expression.SchemaName;
TableName = builder.Expression.TableName;
}
private static T AddChangeLogCreateTableSyntax <T>(T syntax, ChangeLogContext changeLog) where T : ICreateTableWithColumnSyntax
{
if (syntax is CreateTableExpressionBuilder createTableBuilder)
{
var expressions = createTableBuilder.GetMigrationExpressions();
expressions.Insert(createTableBuilder.Expression, new ChangeLogLinkedExpression(createTableBuilder, changeLog), true);
}
return(syntax);
}
/// <inheritdoc />
public override void Down()
{
var testChangeLogContext = new ChangeLogContext(this, Table.Testing);
Delete.Table(GetPrefixedName(Table.Person))
.WithChangeLog(PersonLogContext, this)
.InSchema(SchemaName);
Delete.Table(Table.Parent, this)
.WithChangeLog(ParentLogContext, this);
Delete.Table(Table.Testing, this)
.WithChangeLog(testChangeLogContext, this);
}
/// <summary>
/// Initialize object from the <see cref="RenameColumnExpressionBuilder"/> object
/// </summary>
/// <param name="builder">The <see cref="RenameColumnExpressionBuilder"/> object</param>
/// <param name="changeLog">The <see cref="ChangeLogContext"/> object</param>
public ChangeLogLinkedExpression(RenameColumnExpressionBuilder builder, ChangeLogContext changeLog)
: this(changeLog, builder.Expression)
{
OldRenamedName = builder.Expression.OldName;
GetColumns = () => new List <ColumnDefinition>
{
new ColumnDefinition()
{
Name = builder.Expression.NewName, TableName = builder.Expression.TableName
}
};
SchemaName = builder.Expression.SchemaName;
TableName = builder.Expression.NewName;
}
public ProducerService(ChangeLogContext ctx, IEventBus bus)
{
_ctx = ctx;
_bus = bus;
}
/// <summary>
/// ChangeLog activation for Alter.Table(..) syntax <br/>
/// -------------------------------------------------<br/>
/// It will be possible to add custom logging on all table operations.<br/>
/// The interface <see cref="ICustomMigrationProcessor{T}"/> must be implemented and registered in the IoC container (<see cref="IServiceCollection"/> )<br/>
/// Method <see cref="ICustomMigrationProcessor.Process(IChangeLogTabledExpression)"/><br/>
/// can be used to implementing your preferred custom logging <br/>
/// <br/>
/// See the example of a implementation of <see cref="ICustomMigrationProcessor{T}"/>:<br/>
/// <a href="https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs">https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs</a><br/>
/// <br/>
/// Can be registered like this:<br/>
/// <code type="csharp">
/// <see cref="IServiceCollection">serviceCollection</see>.AddSingleton<ICustomMigrationProcessor<OracleProcessor>,TestOracleCustomMigrationProcessor>();
/// </code>
/// </summary>
/// <param name="syntax"></param>
/// <param name="changeLog"></param>
/// <returns><see cref="IAlterTableAddColumnOrAlterColumnSyntax"/></returns>
public static IAlterTableAddColumnOrAlterColumnSyntax WithChangeLog(this IAlterTableAddColumnOrAlterColumnSyntax syntax, ChangeLogContext changeLog)
{
return(AddChangeLogAlterTableSyntax(syntax, changeLog));
}
/// <summary>
/// ChangeLog activation for Delete.Table(..) syntax <br/>
/// ----------------------------------------------------<br/>
/// It will be possible to add custom logging on all table operations.<br/>
/// The interface <see cref="ICustomMigrationProcessor{T}"/> must be implemented and registered in the IoC container (<see cref="IServiceCollection"/> )<br/>
/// Method <see cref="ICustomMigrationProcessor.Process(IChangeLogTabledExpression)"/><br/>
/// can be used to implementing your preferred custom logging <br/>
/// <br/>
/// See the example of a implementation of <see cref="ICustomMigrationProcessor{T}"/>:<br/>
/// <a href="https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs">https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs</a><br/>
/// <br/>
/// Can be registered like this:<br/>
/// <code type="csharp">
/// <see cref="IServiceCollection">serviceCollection</see>.AddSingleton<ICustomMigrationProcessor<OracleProcessor>,TestOracleCustomMigrationProcessor>();
/// </code>
/// </summary>
/// <param name="syntax"></param>
/// <param name="changeLog"></param>
/// <param name="migration"></param>
/// <returns><see cref="IInSchemaSyntax"/></returns>
public static IInSchemaSyntax WithChangeLog(this IInSchemaSyntax syntax, ChangeLogContext changeLog, IMigrationModel migration)
{
return(AddChangeLogDynamicSyntax(syntax, changeLog, migration));
}
/// <summary>
/// ChangeLog activation for Rename.Table(..) syntax <br/>
/// ----------------------------------------------------<br/>
/// It will be possible to add custom logging on all table operations.<br/>
/// The interface <see cref="ICustomMigrationProcessor{T}"/> must be implemented and registered in the IoC container (<see cref="IServiceCollection"/> )<br/>
/// Method <see cref="ICustomMigrationProcessor.Process(IChangeLogTabledExpression)"/><br/>
/// can be used to implementing your preferred custom logging <br/>
/// <br/>
/// See the example of a implementation of <see cref="ICustomMigrationProcessor{T}"/>:<br/>
/// <a href="https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs">https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs</a><br/>
/// <br/>
/// Can be registered like this:<br/>
/// <code type="csharp">
/// <see cref="IServiceCollection">serviceCollection</see>.AddSingleton<ICustomMigrationProcessor<OracleProcessor>,TestOracleCustomMigrationProcessor>();
/// </code>
/// </summary>
/// <param name="syntax"></param>
/// <param name="changeLog"></param>
/// <param name="migration"></param>
/// <returns><see cref="IRenameTableToSyntax"/></returns>
public static T WithChangeLog <T>(this T syntax, ChangeLogContext changeLog, IMigrationModel migration) where T : IRenameTableToSyntax
{
return(AddChangeLogDynamicSyntax(syntax, changeLog, migration));
}
/// <summary>
/// ChangeLog activation for Create.Table(..) syntax or Create.Column(..) syntax <br/>
/// -------------------------------------------------<br/>
/// It will be possible to add custom logging on all table operations.<br/>
/// The interface <see cref="ICustomMigrationProcessor{T}"/> must be implemented and registered in the IoC container (<see cref="IServiceCollection"/> )<br/>
/// Method <see cref="ICustomMigrationProcessor.Process(IChangeLogTabledExpression)"/><br/>
/// can be used to implementing your preferred custom logging <br/>
/// <br/>
/// See the example of a implementation of <see cref="ICustomMigrationProcessor{T}"/>:<br/>
/// <a href="https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs">https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs</a><br/>
/// <br/>
/// Can be registered like this:<br/>
/// <code type="csharp">
/// <see cref="IServiceCollection">serviceCollection</see>.AddSingleton<ICustomMigrationProcessor<OracleProcessor>,TestOracleCustomMigrationProcessor>();
/// </code>
/// </summary>
/// <param name="syntax"></param>
/// <param name="changeLog"></param>
/// <typeparam name="T"></typeparam>
/// <returns><typeparamref name="T"/></returns>
public static T WithChangeLog <T>(this T syntax, ChangeLogContext changeLog) where T : ICreateTableWithColumnSyntax
{
return(AddChangeLogCreateTableSyntax(syntax, changeLog));
}
/// <summary>
/// ChangeLog activation for Create.Column(..) syntax <br/>
/// -------------------------------------------------<br/>
/// It will be possible to add custom logging on all table operations.<br/>
/// The interface <see cref="ICustomMigrationProcessor{T}"/> must be implemented and registered in the IoC container (<see cref="IServiceCollection"/> )<br/>
/// Method <see cref="ICustomMigrationProcessor.Process(IChangeLogTabledExpression)"/><br/>
/// can be used to implementing your preferred custom logging <br/>
/// <br/>
/// See the example of a implementation of <see cref="ICustomMigrationProcessor{T}"/>:<br/>
/// <a href="https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs">https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs</a><br/>
/// <br/>
/// Can be registered like this:<br/>
/// <code type="csharp">
/// <see cref="IServiceCollection">serviceCollection</see>.AddSingleton<ICustomMigrationProcessor<OracleProcessor>,TestOracleCustomMigrationProcessor>();
/// </code>
/// </summary>
/// <param name="syntax"></param>
/// <param name="changeLog"></param>
/// <returns><see cref="ICreateColumnOptionSyntax"/></returns>
public static ICreateColumnOptionSyntax WithChangeLog(
this ICreateColumnOptionSyntax syntax, ChangeLogContext changeLog)
{
return(AddChangeLogCreateColumnSyntax(syntax, changeLog));
}
/// <summary>
/// Initialize object from the <see cref="DeleteTableExpressionBuilder"/> object
/// </summary>
/// <param name="builder">The <see cref="DeleteTableExpressionBuilder"/> object</param>
/// <param name="changeLog">The <see cref="ChangeLogContext"/> object</param>
public ChangeLogLinkedExpression(DeleteTableExpressionBuilder builder, ChangeLogContext changeLog)
: this(changeLog, builder.Expression)
{
SchemaName = builder.Expression.SchemaName;
TableName = builder.Expression.TableName;
}
public HomeController(ILogger <HomeController> logger, ChangeLogContext changeLogContext)
{
_logger = logger;
_changeLogContext = changeLogContext;
}
/// <inheritdoc />
public override void Up()
{
// Create the ChangeLogContext with values from this.GetMigrationConfig()
// -
// SchemaPrefixId is fetched from database:migration:schemaPrefix:id or database:schemaPrefix:id<br/>
// SchemaPrefixUniqueId is fetched from database:migration:schemaPrefix:UniqueId or database:schemaPrefix:UniqueId<br/>
// -
// GlobalId is fetched from database:migration:schemaPrefix:tables:testing:GlobalId or database:schemaPrefix:tables:testing:GlobalId<br/>
// ShortName is fetched from database:migration:schemaPrefix:tables:testing:ShortName or database:schemaPrefix:tables:testing:ShortName<br/>
var testChangeLogContext = new ChangeLogContext(this, Table.Testing)
{
EnabledTriggersAndViewsGeneration = TriggersAndViewsGeneration.Both
};
CreateParent();
// If "database:schemaPrefix:Id" or "database:migration:schemaPrefix:Id" have a value,
// the tableName Person will be created as {SchemaPrefixId}Person.
//
// i.e: "database:schemaPrefix:Id" = "EX" => will create table EXPerson
// If both "database:schemaPrefix:Id" and "database:migration:schemaPrefix:Id" is missing,
// the tableName Person will be created.
var syntax = Create
.Table(Table.Person.GetPrefixedName(SchemaPrefixId)).InSchema(SchemaName)
.WithErrorFilter(1001, 2275)
.WithChangeLog(PersonLogContext)
.WithColumn(Table.Person + "Id").AsGuid().WithColumnDescription("Unique id.");
if (IsOracle())
{
syntax.WithDefault(SystemMethods.NewGuid);
}
else
{
syntax.WithDefaultValue(Guid.NewGuid());
}
syntax
.WithErrorFilter(2275)
.WithChangeLog(PersonLogContext) // ChangeLog activation for Create.Table(..)
.WithColumn(Column.SequenceNumber).AsInt32().NotNullable().WithColumnDescription("sequence number.")
.WithColumn(Column.Alive).AsBoolean().NotNullable().WithColumnDescription("Alive flag.")
.WithColumn(Column.Username).AsString().WithColumnDescription("username.")
.WithColumn(Column.ExtraInformation).AsDatabaseBlob(this).Nullable().WithColumnDescription("Extra Information as blob.")
.WithColumn("TestCol").AsGuid().WithColumnDescription("TestCol Guid")
.WithColumn(Column.Password).AsString().WithChangeLog(PersonLogContext).WithColumnDescription("password.")
.WithErrorFilter(1002)
.WithDefaultColumns() // Enable DefaultColumns functionality
.WithChangeLog(PersonLogContext)
.WithErrorFilter(2275)
.WithForeignKeyColumn("Parent".GetPrefixedName(SchemaPrefixId), this, "ParentId_FK", "ParentId", errors: 2275).AsGuid().Nullable()
.WithDefaultColumns()
.WithChangeLog(PersonLogContext)
.WithChangeLog(PersonLogContext)
.WithTableSequence(this);
Alter.Table(Table.Person, this).WithDescription("description of " + PersonTableName).InSchema(SchemaName)
.WithErrorFilter(2001)
.WithChangeLog(PersonLogContext)
.AddColumn("NewCol").AsInt64().Nullable().WithColumnDescription("NewCol description")
.AlterColumn(Column.Password).AsFixedLengthString(255).Nullable()
.AlterColumn("TestCol").AsString(255).Nullable().WithColumnDescription("TestCol String(255)")
.WithErrorFilter(2002)
.WithChangeLog(PersonLogContext);
Create.Table("Test", this)
.WithDescription("Hei hei")
.WithColumn("TestId").AsInt32().PrimaryKey().WithColumnDescription("Unique id.")
.WithColumn("TestDescription").AsAnsiString().WithColumnDescription("Description")
.WithDefaultColumns()
.WithChangeLog(testChangeLogContext);
Rename.Table("Test", this)
.WithChangeLog(testChangeLogContext, this)
.ToTable(Table.Testing, this)
.WithChangeLog(testChangeLogContext, this);
Rename
.Column("TestDescription").OnTable(Table.Testing, this)
.To("TestIngDescription", this)
.WithChangeLog(testChangeLogContext, this);
//CreateOrReplace.View("").WithColumn("ss").WithColumns("sds", "sss").WithSqlScript("");
Create.Column("CreateColumn")
.OnTable(Table.Person, this).AsInt16().Nullable()
.WithErrorFilter(3001, 1430)
.WithChangeLog(PersonLogContext);
if (IsOracle())
{
Execute.Sql($"create or replace synonym {SchemaName}.{Table.Testing}1 for {SchemaName}.{Table.Testing.GetPrefixedName(SchemaPrefixId)}");
}
if (IsOracle())
{
var sql =
@"
-- Title = Testing ErrorFilter parsing
-- ErrorFilter = 6512, 955
BEGIN
EXECUTE IMMEDIATE 'CREATE TABLE {SchemaName}.{SchemaPrefixId}Person (PersonId RAW(16) DEFAULT sys_guid() NOT NULL, SequenceNumber NUMBER(10,0) NOT NULL, Alive NUMBER(1,0) NOT NULL, Username NVARCHAR2(255) NOT NULL, ExtraInformation BLOB, TestCol RAW(16) NOT NULL, Password NVARCHAR2(255) NOT NULL, ParentId_FK RAW(16))';
EXECUTE IMMEDIATE 'COMMENT ON COLUMN {SchemaName}.{SchemaPrefixId}Person.PersonId IS ''Unique id.''';
EXECUTE IMMEDIATE 'COMMENT ON COLUMN {SchemaName}.{SchemaPrefixId}Person.SequenceNumber IS ''sequence number.''';
EXECUTE IMMEDIATE 'COMMENT ON COLUMN {SchemaName}.{SchemaPrefixId}Person.Alive IS ''Alive flag.''';
EXECUTE IMMEDIATE 'COMMENT ON COLUMN {SchemaName}.{SchemaPrefixId}Person.Username IS ''username.''';
EXECUTE IMMEDIATE 'COMMENT ON COLUMN {SchemaName}.{SchemaPrefixId}Person.ExtraInformation IS ''Extra Information as blob.''';
EXECUTE IMMEDIATE 'COMMENT ON COLUMN {SchemaName}.{SchemaPrefixId}Person.TestCol IS ''TestCol Guid''';
EXECUTE IMMEDIATE 'COMMENT ON COLUMN {SchemaName}.{SchemaPrefixId}Person.Password IS ''password.''';
END;";
sql = sql.ReplaceIgnoreCase("{SchemaName}", SchemaName).ReplaceIgnoreCase("{SchemaPrefixId}", SchemaPrefixId ?? string.Empty);
Execute.Sql(sql);
Execute.Script(Path.Combine("..", "..", "..", "..", "..", "Example", "Example.FluentDbTools.Migration", "MigrationModels", "ExecuteSql.txt"));
//Execute.EmbeddedScript("ExecuteEmbeddedSql.txt");
}
}
public ChangeLogRepository(ChangeLogContext context)
{
_changeLogContext = context;
}
/// <summary>
/// ChangeLog activation for Rename.Column(..) syntax <br/>
/// ----------------------------------------------------<br/>
/// It will be possible to add custom logging on all table operations.<br/>
/// The interface <see cref="ICustomMigrationProcessor{T}"/> must be implemented and registered in the IoC container (<see cref="IServiceCollection"/> )<br/>
/// Method <see cref="ICustomMigrationProcessor.Process(IChangeLogTabledExpression)"/><br/>
/// can be used to implementing your preferred custom logging <br/>
/// <br/>
/// See the example of a implementation of <see cref="ICustomMigrationProcessor{T}"/>:<br/>
/// <a href="https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs">https://github.com/DIPSAS/FluentDbTools/blob/master/src/FluentDbTools/Tests/Test.FluentDbTools.Migration/TestOracleCustomMigrationProcessor.cs</a><br/>
/// <br/>
/// Can be registered like this:<br/>
/// <code type="csharp">
/// <see cref="IServiceCollection">serviceCollection</see>.AddSingleton<ICustomMigrationProcessor<OracleProcessor>,TestOracleCustomMigrationProcessor>();
/// </code>
/// </summary>
/// <param name="syntax"></param>
/// <param name="changeLog"></param>
/// <param name="migration"></param>
/// <returns><see cref="IRenameColumnToSyntax"/></returns>
public static IRenameColumnToSyntax WithChangeLog(this IRenameColumnToSyntax syntax, ChangeLogContext changeLog, IMigrationModel migration)
{
return(AddChangeLogDynamicSyntax(syntax, changeLog, migration));
}
public void OracleMigration_SchemaPrefixHasExpectedValueAndMigrationSucceed()
{
FluentMigrationLoggingExtensions.UseLogFileAppendFluentMigratorLoggerProvider = true;
var schemaPrefixId = "EX";
var schemaPrefixUniqueId = "exabcd-0000000001000";
var databaseType = SupportedDatabaseTypes.Oracle;
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
inMemoryOverrideConfig.TryGetValue("database:schema", out var schema);
var logFile = $"Migration_Success_{schema}_{databaseType}.sql";
inMemoryOverrideConfig.Add("Logging:Migration:ShowSql", "True");
inMemoryOverrideConfig.Add("Logging:Migration:ShowElapsedTime", "True");
inMemoryOverrideConfig.Add("Logging:Migration:File", logFile);
inMemoryOverrideConfig.Add("database:schemaprefix:id", schemaPrefixId);
inMemoryOverrideConfig.Add("database:migration:schemaprefix:uniqueId", schemaPrefixUniqueId);
inMemoryOverrideConfig.Add("database:schemaprefix:tables:person:shortName", "sn");
inMemoryOverrideConfig.Add("database:schemaprefix:tables:person:globalId", "glob");
//inMemoryOverrideConfig.Add("database:migration:migrationName", "migrationName");
inMemoryOverrideConfig.Add("database:migration:name", "name");
inMemoryOverrideConfig.Add("database:migration:schemaprefix:triggersAndViewsGeneration:tables:person", "both");
inMemoryOverrideConfig.Add("database:migration:schemaprefix:triggersAndViewsGeneration:tables:exparent", "triggers");
File.Delete(logFile);
var provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle, inMemoryOverrideConfig, sc => sc.RegisterCustomMigrationProcessor());
using (provider as ServiceProvider)
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
var dbMigrationConfig = scope.ServiceProvider.GetDbMigrationConfig();
dbMigrationConfig.GetSchemaPrefixId().Should().Be(schemaPrefixId);
dbMigrationConfig.GetSchemaPrefixUniqueId().Should().Be("exabcd-0000000001000");
var personLog = new ChangeLogContext(dbMigrationConfig, Table.Person);
var parentLog = new ChangeLogContext(dbMigrationConfig, Table.Parent);
var unknownLog = new ChangeLogContext(dbMigrationConfig, "Unknown")
{
EnabledTriggersAndViewsGeneration = TriggersAndViewsGeneration.Disabled
};
var unknown2Log = new ChangeLogContext(dbMigrationConfig, "Unknown2");
personLog.SchemaPrefixId.Should().Be(schemaPrefixId);
personLog.SchemaPrefixUniqueId.Should().Be(schemaPrefixUniqueId);
personLog.ShortName.Should().Be($"{schemaPrefixId}sn");
personLog.GlobalId.Should().Be("glob");
personLog.EnabledTriggersAndViewsGeneration.Should().Be(TriggersAndViewsGeneration.Both);
parentLog.SchemaPrefixId.Should().Be(schemaPrefixId);
parentLog.SchemaPrefixUniqueId.Should().Be(schemaPrefixUniqueId);
parentLog.ShortName.Should().BeNullOrEmpty();
parentLog.GlobalId.Should().BeNullOrEmpty();
parentLog.EnabledTriggersAndViewsGeneration.Should().Be(TriggersAndViewsGeneration.Triggers);
unknownLog.SchemaPrefixId.Should().Be(schemaPrefixId);
unknownLog.SchemaPrefixUniqueId.Should().Be(schemaPrefixUniqueId);
unknownLog.ShortName.Should().BeNullOrEmpty();
unknownLog.GlobalId.Should().BeNullOrEmpty();
unknownLog.EnabledTriggersAndViewsGeneration.Should().Be(TriggersAndViewsGeneration.Disabled);
unknown2Log.SchemaPrefixId.Should().Be(schemaPrefixId);
unknown2Log.SchemaPrefixUniqueId.Should().Be(schemaPrefixUniqueId);
unknown2Log.ShortName.Should().BeNullOrEmpty();
unknown2Log.GlobalId.Should().BeNullOrEmpty();
unknown2Log.EnabledTriggersAndViewsGeneration.Should().BeNull();
migrationRunner.MigrateUp();
var oracleProcessor = scope.ServiceProvider.GetService <IExtendedMigrationProcessorOracle>();
oracleProcessor.TableExists(dbMigrationConfig.Schema, Table.Person).Should().BeFalse();
oracleProcessor.TableExists(dbMigrationConfig.Schema, Table.Parent).Should().BeFalse();
oracleProcessor.TableExists(dbMigrationConfig.Schema, "Unknown").Should().BeFalse();
oracleProcessor.TableExists(dbMigrationConfig.Schema, Table.Person.GetPrefixedName(schemaPrefixId)).Should().BeTrue();
oracleProcessor.TableExists(dbMigrationConfig.Schema, Table.Parent.GetPrefixedName(schemaPrefixId)).Should().BeTrue();
oracleProcessor.TableExists(dbMigrationConfig.Schema, "Unknown".GetPrefixedName(schemaPrefixId)).Should().BeFalse();
oracleProcessor.SequenceExists(dbMigrationConfig.Schema, $"{Table.Person.GetPrefixedName(schemaPrefixId)}_seq");
migrationRunner.MigrateDown(0);
migrationRunner.DropSchema(scope.ServiceProvider.GetVersionTableMetaData());
}
provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle, inMemoryOverrideConfig, sc => sc.RegisterCustomMigrationProcessor());
using (provider as ServiceProvider)
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
migrationRunner.MigrateDown(0);
}
provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle, inMemoryOverrideConfig, sc => sc.RegisterCustomMigrationProcessor());
using (provider as ServiceProvider)
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
migrationRunner.DropSchema(scope.ServiceProvider.GetVersionTableMetaData());
}
ShowLogFileContent(logFile);
FluentMigrationLoggingExtensions.UseLogFileAppendFluentMigratorLoggerProvider = false;
}
public CategoryLogService(IOptions <Settings> settings, IContextBase <SysUser> userContext)
{
mongoContext = new ChangeLogContext(settings);
sysUserContext = userContext;
}
