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 MigrationContext(IMigrationConventions conventions, IQuerySchema querySchema, Assembly migrationAssembly)
 {
     Conventions = conventions;
     Expressions = new List<IMigrationExpression>();
     QuerySchema = querySchema;
     MigrationAssembly = migrationAssembly;
 }

 public override void ApplyConventions( IMigrationConventions conventions )
 {
     if (string.IsNullOrEmpty(SchemaName)) {
         SchemaName = conventions.GetDefaultSchemaName();
     }
     Column.ApplyConventions(conventions);
 }

        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 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, 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 ProfileLoader(IRunnerContext runnerContext, IMigrationRunner runner, IMigrationConventions conventions, bool isBeforeProfile)
        {
            Runner = runner;
            Assembly = runner.MigrationAssembly;
            Profile = isBeforeProfile ? runnerContext.BeforeProfile : runnerContext.Profile;
            Conventions = conventions;

            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, Assembly assembly, string @namespace, IEnumerable<string> tagsToMatch)
        {
            Conventions = conventions;
            Assembly = assembly;
            Namespace = @namespace;
            TagsToMatch = tagsToMatch ?? new string[] { };

            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 void ApplyConventions(IMigrationConventions conventions)
        {
            if (String.IsNullOrEmpty(SchemaName)) {
                SchemaName = conventions.GetDefaultSchemaName();
            }

            if (String.IsNullOrEmpty(Name))
                Name = conventions.GetIndexName(this);
        }

        public ProfileLoader(IRunnerContext runnerContext, IMigrationRunner runner, IMigrationConventions conventions)
        {
            Runner = runner;
            Assembly = runner.MigrationAssembly;
            Profile = runnerContext.Profile;
            Conventions = conventions;

            Initialize();
        }

 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 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 VersionLoader(IMigrationRunner runner, Assembly assembly, IMigrationConventions conventions)
        {
            Runner = runner;
            Processor = runner.Processor;
            Assembly = assembly;

            Conventions = conventions;
            VersionTableMetaData = GetVersionTableMetaData();
            VersionMigration = new VersionMigration(VersionTableMetaData);

            LoadVersionInfo();
        }

 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);
 }