private NamingConventionSet(IConventionSet innerConventionSet,
IColumnsConvention snakeCaseColumnsConvention,
IForeignKeyConvention snakeCaseForeignKeyConvention,
IConstraintConvention snakeCaseConstraintConvention)
{
ColumnsConventions = new List <IColumnsConvention>()
{
snakeCaseColumnsConvention,
};
ForeignKeyConventions = new List <IForeignKeyConvention>()
{
snakeCaseForeignKeyConvention,
};
ConstraintConventions = new List <IConstraintConvention>()
{
snakeCaseConstraintConvention,
};
SequenceConventions = innerConventionSet.SequenceConventions;
AutoNameConventions = innerConventionSet.AutoNameConventions;
SchemaConvention = innerConventionSet.SchemaConvention;
RootPathConvention = innerConventionSet.RootPathConvention;
IndexConventions = innerConventionSet.IndexConventions;
}
internal FxVersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies,
IConventionSet conventionSet,
IMigrationRunnerConventions conventions,
IRunnerContext runnerContext,
IVersionTableMetaData versionTableMetaData = null,
string resource = "")
{
_conventionSet = conventionSet;
_processor = runner.Processor;
Runner = runner;
Assemblies = assemblies;
Conventions = conventions;
VersionTableMetaData = versionTableMetaData ?? CreateVersionTableMetaData(runnerContext);
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
VersionResourceMigration = new VersionResourceMigration(VersionTableMetaData);
VersionTableMetaData.ApplicationContext = runnerContext.ApplicationContext;
Resource = resource;
LoadVersionInfo();
}
public FxVersionLoader(
IProcessorAccessor processorAccessor,
IConventionSet conventionSet,
IMigrationRunnerConventions conventions,
IVersionTableMetaData versionTableMetaData,
IMigrationRunner runner,
string resource = "")
{
_conventionSet = conventionSet;
_processor = processorAccessor.Processor;
Runner = runner;
Conventions = conventions;
VersionTableMetaData = versionTableMetaData;
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
VersionResourceMigration = new VersionResourceMigration(VersionTableMetaData);
Resource = resource;
LoadVersionInfo();
}
internal ConnectionlessVersionLoader(
IMigrationRunner runner,
IAssemblyCollection assemblies,
IConventionSet conventionSet,
IMigrationRunnerConventions conventions,
IRunnerContext runnerContext,
IVersionTableMetaData versionTableMetaData = null)
{
_migrationInformationLoader = runner.MigrationLoader;
_processor = runner.Processor;
Runner = runner;
Assemblies = assemblies;
Conventions = conventions;
StartVersion = runnerContext.StartVersion;
TargetVersion = runnerContext.Version;
VersionInfo = new VersionInfo();
VersionTableMetaData = versionTableMetaData ??
(IVersionTableMetaData)Activator.CreateInstance(assemblies.Assemblies.GetVersionTableMetaDataType(
Conventions, runnerContext));
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
if (VersionTableMetaData is DefaultVersionTableMetaData defaultMetaData)
{
conventionSet.SchemaConvention?.Apply(defaultMetaData);
}
LoadVersionInfo();
}
// https://github.com/fluentmigrator/fluentmigrator/issues/933
public VersionTableMetaData(
IConventionSet conventionSet,
IOptions <RunnerOptions> runnerOptions
)
: base(conventionSet, runnerOptions)
{
}
internal FxVersionLoader(
IMigrationRunner runner,
Assembly assembly,
IConventionSet conventionSet,
IMigrationRunnerConventions conventions,
IRunnerContext runnerContext)
: this(runner, new SingleAssembly(assembly), conventionSet, conventions, runnerContext)
{
}
/// <summary>
/// Applies all conventions in a <paramref name="conventionSet"/> to the given <paramref name="expressions"/>.
/// </summary>
/// <param name="expressions">The expression to apply the convention set to</param>
/// <param name="conventionSet">The convention set to apply to the expressions</param>
/// <returns>A sequence of expressions where the conventions have been applied to</returns>
public static IEnumerable <IMigrationExpression> Apply(this IEnumerable <IMigrationExpression> expressions,
IConventionSet conventionSet)
{
foreach (var expression in expressions)
{
var expr = expression.Apply(conventionSet);
yield return(expr);
}
}
public DefaultVersionTableMetaData(IConventionSet conventionSet, IOptions <RunnerOptions> runnerOptions)
{
#pragma warning disable 618
#pragma warning disable 612
ApplicationContext = runnerOptions.Value.ApplicationContext;
#pragma warning restore 612
#pragma warning restore 618
conventionSet.SchemaConvention?.Apply(this);
}
// ReSharper disable once UnusedMember.Global
public MigrationValidator(
[NotNull] ILogger <MigrationValidator> logger,
[NotNull] IConventionSet conventions,
[CanBeNull] IMigrationExpressionValidator validator = null)
{
_logger = logger;
_conventions = conventions;
_validator = validator ?? new DefaultMigrationExpressionValidator(serviceProvider: null);
}
internal VersionLoader(
[NotNull] IMigrationRunner runner,
[NotNull] Assembly assembly,
[NotNull] IConventionSet conventionSet,
[NotNull] IMigrationRunnerConventions conventions,
[NotNull] IRunnerContext runnerContext)
: this(runner, new SingleAssembly(assembly), conventionSet, conventions, runnerContext)
{
}
public ValidatingVersionLoader(
IProcessorAccessor processorAccessor, IConventionSet conventionSet, IMigrationRunnerConventions conventions,
IVersionTableMetaData versionTableMetaData, IMigrationRunner runner
) : base(processorAccessor, conventionSet, conventions, versionTableMetaData, runner)
{
m_processor = processorAccessor.Processor;
LoadVersionInfo();
}
public MigrationRunner(
[NotNull] IAssemblyCollection assemblies, [NotNull] IRunnerContext runnerContext,
[NotNull] IMigrationProcessor processor, [CanBeNull] IVersionTableMetaData versionTableMetaData,
[CanBeNull] IMigrationRunnerConventions migrationRunnerConventions, [CanBeNull] IConventionSet conventionSet,
[CanBeNull] IMigrationScopeManager migrationScopeHandler = null)
{
_migrationAssemblies = assemblies;
_logger = new AnnouncerFluentMigratorLogger(runnerContext.Announcer);
_stopWatch = runnerContext.StopWatch;
_processorOptions = new ProcessorOptions(runnerContext);
Processor = processor;
RunnerContext = runnerContext;
var migrationRunnerConventionsAccessor = new AssemblySourceMigrationRunnerConventionsAccessor(
serviceProvider: null,
new AssemblySource(() => assemblies));
Conventions = migrationRunnerConventions ?? migrationRunnerConventionsAccessor.MigrationRunnerConventions;
var convSet = conventionSet ?? new DefaultConventionSet(runnerContext);
_migrationScopeManager = migrationScopeHandler ?? new MigrationScopeHandler(Processor);
_migrationValidator = new MigrationValidator(_logger, convSet);
MigrationLoader = new DefaultMigrationInformationLoader(Conventions, _migrationAssemblies,
runnerContext.Namespace,
runnerContext.NestedNamespaces, runnerContext.Tags);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
MaintenanceLoader = new MaintenanceLoader(_migrationAssemblies, runnerContext.Tags, Conventions);
if (runnerContext.NoConnection)
{
_versionLoader = new Lazy <IVersionLoader>(
() => new ConnectionlessVersionLoader(
this,
_migrationAssemblies,
convSet,
Conventions,
runnerContext,
versionTableMetaData));
}
else
{
_versionLoader = new Lazy <IVersionLoader>(
() => new VersionLoader(this, _migrationAssemblies, convSet, Conventions, runnerContext, versionTableMetaData));
}
}
public VersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies,
IConventionSet conventionSet,
IMigrationRunnerConventions conventions,
IVersionTableMetaData versionTableMetaData = null)
{
_conventionSet = conventionSet;
Runner = runner;
Processor = runner.Processor;
Assemblies = assemblies;
Conventions = conventions;
VersionTableMetaData = versionTableMetaData ?? GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
LoadVersionInfo();
}
public SmiConventionSet(IConventionSet innerConventionSet, SmiForeignKeyConvention foreignKeyConvention, SmiIndexConvention indexConvention)
{
ForeignKeyConventions = new List <IForeignKeyConvention>
{
foreignKeyConvention,
innerConventionSet.SchemaConvention,
};
IndexConventions = new List <IIndexConvention>
{
indexConvention
};
ColumnsConventions = innerConventionSet.ColumnsConventions;
ConstraintConventions = innerConventionSet.ConstraintConventions;
SequenceConventions = innerConventionSet.SequenceConventions;
AutoNameConventions = innerConventionSet.AutoNameConventions;
SchemaConvention = innerConventionSet.SchemaConvention;
RootPathConvention = innerConventionSet.RootPathConvention;
}
public VersionLoader(
[NotNull] IProcessorAccessor processorAccessor,
[NotNull] IConventionSet conventionSet,
[NotNull] IMigrationRunnerConventions conventions,
[NotNull] IVersionTableMetaData versionTableMetaData,
[NotNull] IMigrationRunner runner)
{
_conventionSet = conventionSet;
_processor = processorAccessor.Processor;
Runner = runner;
Conventions = conventions;
VersionTableMetaData = versionTableMetaData;
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
LoadVersionInfo();
}
internal VersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies,
[NotNull] IConventionSet conventionSet,
[NotNull] IMigrationRunnerConventions conventions,
[NotNull] IRunnerContext runnerContext,
[CanBeNull] IVersionTableMetaData versionTableMetaData = null)
{
_conventionSet = conventionSet;
_processor = runner.Processor;
Runner = runner;
Assemblies = assemblies;
Conventions = conventions;
VersionTableMetaData = versionTableMetaData ?? CreateVersionTableMetaData(runnerContext);
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
VersionTableMetaData.ApplicationContext = runnerContext.ApplicationContext;
LoadVersionInfo();
}
public MigrationRunner(
IAssemblyCollection assemblies, IRunnerContext runnerContext,
IMigrationProcessor processor, IVersionTableMetaData versionTableMetaData,
IMigrationRunnerConventions migrationRunnerConventions, IConventionSet conventionSet)
{
_migrationAssemblies = assemblies;
_announcer = runnerContext.Announcer;
Processor = processor;
_stopWatch = runnerContext.StopWatch;
RunnerContext = runnerContext;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = migrationRunnerConventions ?? GetMigrationRunnerConventions(runnerContext);
var convSet = conventionSet ?? new DefaultConventionSet(runnerContext);
_migrationScopeHandler = new MigrationScopeHandler(Processor);
_migrationValidator = new MigrationValidator(_announcer, convSet);
MigrationLoader = new DefaultMigrationInformationLoader(Conventions, _migrationAssemblies,
runnerContext.Namespace,
runnerContext.NestedNamespaces, runnerContext.Tags);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
MaintenanceLoader = new MaintenanceLoader(_migrationAssemblies, runnerContext.Tags, Conventions);
if (runnerContext.NoConnection)
{
VersionLoader = new ConnectionlessVersionLoader(
this, _migrationAssemblies, convSet, Conventions,
runnerContext.StartVersion, runnerContext.Version, versionTableMetaData);
}
else
{
VersionLoader = new VersionLoader(this, _migrationAssemblies, convSet, Conventions, versionTableMetaData);
}
}
public MigrationValidator(IAnnouncer announcer, IConventionSet conventions)
{
_validator = new DefaultMigrationExpressionValidator(null);
_logger = new AnnouncerFluentMigratorLogger(announcer);
_conventions = conventions;
}
public MigrationRunner([NotNull] Assembly assembly, [NotNull] IRunnerContext runnerContext, [NotNull] IMigrationProcessor processor, [CanBeNull] IConventionSet conventionSet)
: this(new SingleAssembly(assembly), runnerContext, processor, versionTableMetaData : null, migrationRunnerConventions : null, conventionSet)
{
}
public MigrationValidator(IAnnouncer announcer, IConventionSet conventions)
{
_announcer = announcer;
_conventions = conventions;
}
/// <summary>
/// Apply all conventions in a <paramref name="conventionSet"/> to the given <paramref name="expression"/>.
/// </summary>
/// <typeparam name="T">The expression type, derived from <see cref="IMigrationExpression"/></typeparam>
/// <param name="expression">The expression to apply the <paramref name="conventionSet"/> to</param>
/// <param name="conventionSet">The convention set to apply to the <paramref name="expression"/></param>
/// <returns>The same or a new instance of the expression. The underlying type of the expression must
/// not be changed.</returns>
public static T Apply <T>(this T expression, IConventionSet conventionSet)
where T : IMigrationExpression
{
if (conventionSet.SchemaConvention != null && expression is ISchemaExpression schemaExpression)
{
expression = (T)conventionSet.SchemaConvention.Apply(schemaExpression);
}
if (conventionSet.RootPathConvention != null && expression is IFileSystemExpression fileSystemExpression)
{
expression = (T)conventionSet.RootPathConvention.Apply(fileSystemExpression);
}
if (expression is IColumnsExpression columnsExpression)
{
foreach (var convention in conventionSet.ColumnsConventions)
{
columnsExpression = convention.Apply(columnsExpression);
}
expression = (T)columnsExpression;
}
if (expression is IConstraintExpression constraintExpression)
{
foreach (var convention in conventionSet.ConstraintConventions)
{
constraintExpression = convention.Apply(constraintExpression);
}
expression = (T)constraintExpression;
}
if (expression is IForeignKeyExpression foreignKeyExpression)
{
foreach (var convention in conventionSet.ForeignKeyConventions)
{
foreignKeyExpression = convention.Apply(foreignKeyExpression);
}
expression = (T)foreignKeyExpression;
}
if (expression is IIndexExpression indexExpression)
{
foreach (var convention in conventionSet.IndexConventions)
{
indexExpression = convention.Apply(indexExpression);
}
expression = (T)indexExpression;
}
if (expression is ISequenceExpression sequenceExpression)
{
foreach (var convention in conventionSet.SequenceConventions)
{
sequenceExpression = convention.Apply(sequenceExpression);
}
expression = (T)sequenceExpression;
}
if (expression is IAutoNameExpression autoNameExpression)
{
foreach (var convention in conventionSet.AutoNameConventions)
{
autoNameExpression = convention.Apply(autoNameExpression);
}
expression = (T)autoNameExpression;
}
return(expression);
}
public MigrationRunner(Assembly assembly, IRunnerContext runnerContext, IMigrationProcessor processor, IConventionSet conventionSet)
: this(new SingleAssembly(assembly), runnerContext, processor, versionTableMetaData : null, migrationRunnerConventions : null, conventionSet)
{
}
public VersionLoader(IMigrationRunner runner, Assembly assembly, IConventionSet conventionSet, IMigrationRunnerConventions conventions)
: this(runner, new SingleAssembly(assembly), conventionSet, conventions)
{
}
