public MigrationContext(IMigrationConventions conventions, IQuerySchema querySchema, Assembly migrationAssembly)
{
Conventions = conventions;
Expressions = new List<IMigrationExpression>();
QuerySchema = querySchema;
MigrationAssembly = migrationAssembly;
}
public VersionLoader(IMigrationRunner runner, Assembly assembly, IMigrationConventions conventions)
{
Runner = runner;
Processor = runner.Processor;
Assembly = assembly;
Conventions = conventions;
}
public MigrationLoader(IMigrationConventions conventions, Assembly assembly, string @namespace, IEnumerable<string> tagsToMatch)
: this(conventions,
new List<MigrationAssemblyInfo>() { new MigrationAssemblyInfo() { Assembly = assembly, Namespace = @namespace } },
false,
tagsToMatch ?? new string[] { })
{
}
public MigrationLoader(IMigrationConventions conventions, Assembly assembly, string @namespace, bool loadNestedNamespaces)
: this(conventions,
new List<MigrationAssemblyInfo>() {new MigrationAssemblyInfo() { Assembly = assembly, Namespace = @namespace } },
loadNestedNamespaces,
new string[] { })
{
}
public override void ApplyConventions( IMigrationConventions conventions )
{
if (string.IsNullOrEmpty(SchemaName)) {
SchemaName = conventions.GetDefaultSchemaName();
}
Column.ApplyConventions(conventions);
}
public MigrationContext(IMigrationConventions conventions, IQuerySchema querySchema, Assembly migrationAssembly, object context)
{
Conventions = conventions;
Expressions = new List<IMigrationExpression>();
QuerySchema = querySchema;
MigrationAssembly = migrationAssembly;
this.ApplicationContext = context;
}
public MigrationLoader(IMigrationConventions conventions, Assembly assembly, string @namespace)
{
Conventions = conventions;
Assembly = assembly;
Namespace = @namespace;
Initialize();
}
public MigrationContext(IMigrationConventions conventions, IMigrationProcessor migrationProcessor, Assembly migrationAssembly)
{
Conventions = conventions;
Expressions = new List<IMigrationExpression>();
QuerySchema = migrationProcessor;
PreviewOnly = migrationProcessor.Options.PreviewOnly;
MigrationAssembly = migrationAssembly;
}
public ProfileLoader(IRunnerContext runnerContext, IMigrationRunner runner, IMigrationConventions conventions, bool isBeforeProfile)
{
Runner = runner;
Assembly = runner.MigrationAssembly;
Profile = isBeforeProfile ? runnerContext.BeforeProfile : runnerContext.Profile;
Conventions = conventions;
Initialize();
}
public MigrationLoader(IMigrationConventions conventions, Assembly assembly, string @namespace, IEnumerable<string> tagsToMatch)
{
Conventions = conventions;
Assembly = assembly;
Namespace = @namespace;
TagsToMatch = tagsToMatch ?? new string[] { };
Initialize();
}
public ProfileLoader(IRunnerContext runnerContext, IMigrationRunner runner, IEnumerable<Assembly> assemblies, IMigrationConventions conventions)
{
Runner = runner;
Assemblies = assemblies.ToList();
Profile = runnerContext.Profile;
Conventions = conventions;
Initialize();
}
public MigrationLoader(IMigrationConventions conventions, IEnumerable<Assembly> assemblies, string @namespace, bool loadNestedNamespaces)
{
Conventions = conventions;
Assemblies = assemblies.ToList();
Namespace = @namespace;
LoadNestedNamespaces = loadNestedNamespaces;
Initialize();
}
public MigrationRunner(IMigrationConventions conventions, IMigrationProcessor processor, IAnnouncer announcer, IStopWatch stopWatch)
{
_announcer = announcer;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = conventions;
Processor = processor;
_stopWatch = stopWatch;
}
public void ApplyConventions(IMigrationConventions conventions)
{
if (String.IsNullOrEmpty(SchemaName)) {
SchemaName = conventions.GetDefaultSchemaName();
}
if (String.IsNullOrEmpty(Name))
Name = conventions.GetIndexName(this);
}
public MigrationContext(IMigrationConventions conventions, IQuerySchema querySchema, IAssemblyCollection migrationAssemblies, object context, string connection)
{
Conventions = conventions;
Expressions = new List<IMigrationExpression>();
QuerySchema = querySchema;
MigrationAssemblies = migrationAssemblies;
this.ApplicationContext = context;
this.Connection = connection;
}
public MigrationLoader(IMigrationConventions conventions, Assembly assembly, string @namespace, bool loadNestedNamespaces)
{
Conventions = conventions;
Assembly = assembly;
Namespace = @namespace;
LoadNestedNamespaces = loadNestedNamespaces;
Initialize();
}
public ProfileLoader(IRunnerContext runnerContext, IMigrationRunner runner, IMigrationConventions conventions)
{
Runner = runner;
Assembly = runner.MigrationAssembly;
Profile = runnerContext.Profile;
Conventions = conventions;
Initialize();
}
public MigrationLoader(IMigrationConventions conventions, ICollection<MigrationAssemblyInfo> assemblies, bool loadNestedNamespaces , IEnumerable<string> tagsToMatch)
{
Conventions = conventions;
Assemblies = assemblies;
LoadNestedNamespaces = loadNestedNamespaces;
TagsToMatch = tagsToMatch;
Initialize();
}
public DefaultMigrationInformationLoader(IMigrationConventions conventions, IAssemblyCollection assemblies, string @namespace,
bool loadNestedNamespaces, IEnumerable<string> tagsToMatch)
{
Conventions = conventions;
Assemblies = assemblies;
Namespace = @namespace;
LoadNestedNamespaces = loadNestedNamespaces;
TagsToMatch = tagsToMatch ?? new string[] {};
}
public MigrationVersionRunner(IMigrationConventions conventions, IMigrationProcessor processor, IMigrationLoader loader, Assembly assembly, string @namespace)
{
_migrationConventions = conventions;
_migrationProcessor = processor;
_migrationAssembly = assembly;
_migrationLoader = loader;
_namespace = @namespace;
_migrationRunner = new MigrationRunner(conventions, processor);
_versionMigration = new VersionMigration();
}
public MigrationLoader(IMigrationConventions conventions, Assembly assembly, string @namespace, bool loadNestedNamespaces, IEnumerable<string> tagsToMatch, IAppliedVersions appliedVersions)
{
Conventions = conventions;
Assembly = assembly;
Namespace = @namespace;
LoadNestedNamespaces = loadNestedNamespaces;
AppliedVersions = appliedVersions;
TagsToMatch = tagsToMatch ?? new string[] { };
Initialize();
}
public MigrationVersionRunner(IMigrationConventions conventions, IMigrationProcessor processor, IMigrationLoader loader, Assembly assembly, string @namespace, IAnnouncer announcer)
{
_migrationConventions = conventions;
_migrationProcessor = processor;
_migrationAssembly = assembly;
_migrationLoader = loader;
_namespace = @namespace;
_announcer = announcer;
_migrationRunner = new MigrationRunner(conventions, processor, announcer, new StopWatch());
_versionTableMetaData = loader.GetVersionTableMetaData(assembly);
_versionMigration = new VersionMigration(_versionTableMetaData);
}
public VersionLoader(IMigrationRunner runner, Assembly assembly, IMigrationConventions conventions)
{
Runner = runner;
Processor = runner.Processor;
Assembly = assembly;
Conventions = conventions;
VersionTableMetaData = GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
LoadVersionInfo();
}
public VersionLoader(IMigrationRunner runner, IEnumerable<Assembly> assemblies, IMigrationConventions conventions)
{
Runner = runner;
Processor = runner.Processor;
Assemblies = assemblies.ToList();
Conventions = conventions;
VersionTableMetaData = GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
LoadVersionInfo();
}
public VersionLoader(IMigrationRunner runner, ICollection<MigrationAssemblyInfo> assemblies, IMigrationConventions conventions)
{
Runner = runner;
Processor = runner.Processor;
Assemblies = assemblies;
Conventions = conventions;
VersionTableMetaData = GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
LoadVersionInfo();
}
public MaintenanceLoader(IMigrationRunner runner, IMigrationConventions conventions)
{
_runner = runner;
_maintenance = (
from type in runner.MigrationAssembly.GetExportedTypes()
let stage = conventions.GetMaintenanceStage(type)
where stage != null
let migration = (IMigration)Activator.CreateInstance(type)
group migration by stage
).ToDictionary(
g => g.Key.Value,
g => (IList<IMigration>)g.OrderBy(m => m.GetType().Name).ToArray()
);
}
public MaintenanceLoader(IAssemblyCollection assemblyCollection, IEnumerable<string> tags, IMigrationConventions conventions)
{
tags = tags ?? new string[] {};
_maintenance = (
from a in assemblyCollection.Assemblies
from type in a.GetExportedTypes()
let stage = conventions.GetMaintenanceStage(type)
where stage != null
where conventions.TypeHasMatchingTags(type, tags)
let migration = (IMigration)Activator.CreateInstance(type)
group migration by stage
).ToDictionary(
g => g.Key.Value,
g => (IList<IMigration>)g.OrderBy(m => m.GetType().Name).ToArray()
);
}
public ConnectionlessVersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies, IMigrationConventions conventions, long startVersion, long targetVersion)
{
Runner = runner;
Assemblies = assemblies;
Conventions = conventions;
StartVersion = startVersion;
TargetVersion = targetVersion;
Processor = Runner.Processor;
VersionInfo = new VersionInfo();
VersionTableMetaData = GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
LoadVersionInfo();
}
public override void ApplyConventions(IMigrationConventions conventions)
{
SqlScript = Path.Combine(conventions.GetWorkingDirectory(), SqlScript);
}
public override void ApplyConventions(IMigrationConventions conventions)
{
ForeignKey.ApplyConventions(conventions);
}
public ConnectionlessVersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies, IMigrationConventions conventions, long startVersion, long targetVersion)
{
Runner = runner;
Assemblies = assemblies;
Conventions = conventions;
StartVersion = startVersion;
TargetVersion = targetVersion;
Processor = Runner.Processor;
VersionInfo = new VersionInfo();
VersionTableMetaData = GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
LoadVersionInfo();
}
public void ApplyConventions(IMigrationConventions conventions)
{
throw new NotImplementedException();
}
public ProfileLoader(IRunnerContext runnerContext, IMigrationRunner runner, Assembly assembly, IMigrationConventions conventions)
: this(runnerContext, runner, new[] { assembly }, conventions)
{
}
public override void ApplyConventions(IMigrationConventions conventions)
{
Column.ApplyConventions(conventions);
}
public DefaultMigrationInformationLoader(IMigrationConventions conventions, IAssemblyCollection assemblies, string @namespace,
IEnumerable <string> tagsToMatch)
: this(conventions, assemblies, @namespace, false, tagsToMatch)
{
}
public void ApplyConventions(IMigrationConventions conventions)
{
}
public MaintenanceLoader(IAssemblyCollection assemblyCollection, IEnumerable <string> tags, IMigrationConventions conventions)
{
tags = tags ?? new string[] {};
_maintenance = (
from a in assemblyCollection.Assemblies
from type in a.GetExportedTypes()
let stage = conventions.GetMaintenanceStage(type)
where stage != null
where conventions.TypeHasMatchingTags(type, tags)
let migration = (IMigration)Activator.CreateInstance(type)
group migration by stage
).ToDictionary(
g => g.Key.Value,
g => (IList <IMigration>)g.OrderBy(m => m.GetType().Name).ToArray()
);
}
public DefaultMigrationInformationLoader(IMigrationConventions conventions, Assembly assembly, string @namespace,
bool loadNestedNamespaces, IEnumerable <string> tagsToMatch)
: this(conventions, new SingleAssembly(assembly), @namespace, loadNestedNamespaces, tagsToMatch)
{
}
public VersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies, IMigrationConventions conventions)
{
Runner = runner;
Processor = runner.Processor;
Assemblies = assemblies;
Conventions = conventions;
VersionTableMetaData = GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
LoadVersionInfo();
}
public virtual void ApplyConventions(IMigrationConventions conventions)
{
// By default do nothing, if an expression convention supports this, they should override
}
public override void ApplyConventions(IMigrationConventions conventions)
{
Constraint.ApplyConventions(conventions);
}
public override void ApplyConventions(IMigrationConventions conventions)
{
ForeignKey.ApplyConventions(conventions);
}
public override void ApplyConventions(IMigrationConventions conventions)
{
}
public MultiAssemblyMigrationLoader(IMigrationConventions conventions, IEnumerable <Assembly> assemblies, string @namespace, IEnumerable <string> tagsToMatch)
: this(conventions, assemblies, @namespace, false, tagsToMatch)
{
}
public VersionLoader(IMigrationRunner runner, Assembly assembly, IMigrationConventions conventions)
: this(runner, new SingleAssembly(assembly), conventions)
{
}