public void MigrateToLatest() { var announcer = new TextWriterAnnouncer(s => SharpStarLogger.DefaultLogger.Debug(s)); var assembly = Assembly.GetExecutingAssembly(); var migrationContext = new RunnerContext(announcer) { Namespace = "SharpStar.Database.Migrations" }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; ReflectionBasedDbFactory factory; if (MonoHelper.IsRunningOnMono()) { factory = new MonoSQLiteDbFactory(); } else { factory = new SqliteDbFactory(); } var connection = factory.CreateConnection(_config.GetProperty(NHibernate.Cfg.Environment.ConnectionString)); var processor = new SqliteProcessor(connection, new SqliteGenerator(), announcer, options, factory); var runner = new MigrationRunner(assembly, migrationContext, processor); runner.MigrateUp(true); }
public AutoMigration(IServiceProvider serviceProvider, IHostEnvironment env, MigrationOptions migrationOptions) { _logger = serviceProvider.GetService <ILogger <AutoMigration> >(); _assemblyLoadContext = new MigrationAssemblyLoadContext(); this._migrationOptions = migrationOptions; _serviceProvider = serviceProvider; _env = env; daoFactories = _serviceProvider.GetServices <IDaoFactory>(); foreach (var item in daoFactories) { var factory = item as EFCoreDaoFactory; var extensions = factory.dbContextOptions.Extensions; var extension = extensions.FirstOrDefault(e => typeof(RelationalOptionsExtension).IsAssignableFrom(e.GetType())); if (extension == null) { throw new ServiceFrameworkException($"DbContextOptions error,could not find RelationalOptionsExtension for {factory.FactoryName}"); } if (!_providerAssemblies.ContainsKey(factory.FactoryName)) { _providerAssemblies.Add(factory.FactoryName, new List <Assembly>()); } _providerAssemblies[factory.FactoryName].Add(extension.GetType().Assembly); } }
private static void ScriptTo(string dir, long timestamp = -1) { Directory.CreateDirectory(dir); var options = new MigrationOptions(); options.OnlyScriptSqlTo(dir); var migrator = new Migrator(_connectionString, DbPlatform.SqlServer2014, options); IMigrationBatch migrations = null; if (timestamp != -1) { migrations = migrator.FetchMigrationsTo(_assembly, timestamp); } else { migrations = migrator.FetchMigrations(_assembly); } if (migrations.Steps.First().Direction == MigrationDirection.Down) { Console.WriteLine("Migration direction = down"); } Console.WriteLine($"{migrations.Steps.Count} pending migrations"); Console.WriteLine("Writing migration SQL scripts to {dir}"); migrations.Execute(); Console.WriteLine("Done"); }
public void Migrate(Action <IMigrationRunner> runnerAction) { var before = Stopwatch.StartNew(); if (ApplicationConfiguration.IsLocal() && !ApplicationConfiguration.IsLocalHostSWDB()) { Log.Debug("Ignoring Migration on remoteDB"); //avoid misconfiguration to change the schema of a remote database return; } var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 }; var factory = GetFactory(); var assembly = Assembly.GetExecutingAssembly(); //using (var announcer = new NullAnnouncer()) var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s)); var migrationContext = new RunnerContext(announcer) { #if DEBUG // will create testdata Profile = "development" #endif }; var processor = factory.Create(connectionString, announcer, options); var runner = new MigrationRunner(assembly, migrationContext, processor); runnerAction(runner); Log.Info(String.Format("Migration execution finished in {0}", LoggingUtil.MsDelta(before))); }
private void Do(Action <IMigrationRunner> runnerAct) { var dir = new DirectoryInfo(outputDir); if (!dir.Exists) { dir.Create(); } var filename = Path.Combine(outputDir, string.Format("migrated-{0:yyyy-MM-dd-HH-mm-ss}.sql", DateTime.Now)); using (var fs = File.CreateText(filename)) { var announcer = new TextWriterAnnouncer(fs); var assembly = typeof(CreateClientDb).Assembly; var migrationContext = MakeContext(announcer); var options = new MigrationOptions { PreviewOnly = false, Timeout = 15 }; var processor = MakeProcessor(announcer, options); var runner = new MigrationRunner(assembly, migrationContext, processor); runnerAct(runner); } if (new FileInfo(filename).Length == 0) { File.Delete(filename); } }
public void Can_get_migration_id_from_migration_and_correct_leading_or_multiple_underscores() { var options = new MigrationOptions(); var id = options.Conventions.MigrationDocumentId(new _has_problems__with_underscores___(), '/'); id.Should().Be("migrationrecord/has/problems/with/underscores/5"); }
private MigrationOptions GetMigrationOptions() { var options = new MigrationOptions(); options.Assemblies.Add(Assembly.GetExecutingAssembly()); return(options); }
public void Can_get_migration_id_from_migration() { var options = new MigrationOptions(); var id = options.Conventions.MigrationDocumentId(new First_Migration(), '/'); id.Should().Be("migrationrecord/first/migration/1"); }
public void Can_change_migration_document_seperator_to_dash() { var options = new MigrationOptions(); options.Conventions.MigrationDocumentId(new First_Migration(), '-') .Should().Be("migrationrecord-first-migration-1"); }
public void Default_resolver_should_be_DefaultMigrationResolver() { var options = new MigrationOptions(); options.MigrationResolver.Should().NotBeNull(); options.MigrationResolver.Should().BeOfType <DefaultMigrationResolver>(); }
private void MigrateButton_Click(object sender, EventArgs e) { MigrationOptions options; Uri.TryCreate(svnBranchUrlComboBox.Text, UriKind.Absolute, out Uri svnUri); options = new MigrationOptions { SvnUri = svnUri, RepositoryPath = gitRepositoryPathTextBox.Text, WorkingPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()), Authors = this.GetAuthorMapping(), Revisions = this.GetOrderedRevisions(), UseExistingRepository = useExistingRepositoryCheckBox.Checked }; if (this.ValidateOptions(options)) { this.PrepareProgressUi("Migrating..."); tabList.SelectedPage = gitTabListPage; migrateBackgroundWorker.RunWorkerAsync(options); } }
public static void MigrateUp(string connectionString, string MigrationNamespace, long?toVersion = null) { var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s)); var assembly = Assembly.GetExecutingAssembly(); var migrationContext = new RunnerContext(announcer) { Namespace = MigrationNamespace }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var factory = new FluentMigrator.Runner.Processors.Postgres.PostgresProcessorFactory(); using (var processor = factory.Create(connectionString, announcer, options)) { var runner = new MigrationRunner(assembly, migrationContext, processor); if (toVersion == null) { runner.MigrateUp(true); } else { runner.MigrateUp(toVersion.Value); } } }
public static void MigrateToLatest(string connectionString, string clientId, string certThumbPrint, string authority) { var announcer = new TextWriterAnnouncer(s => { System.Console.WriteLine(s); System.Diagnostics.Debug.WriteLine(s); }); var assembly = Assembly.Load("MyAppMigrations"); var migrationContext = new RunnerContext(announcer) { Namespace = "MyAppMigrations" }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var factory = new AzureSqlProcessorFactory(clientId, certThumbPrint, authority); using (var processor = factory.Create(connectionString, announcer, options)) { var runner = new MigrationRunner(assembly, migrationContext, processor); runner.ListMigrations(); runner.MigrateUp(true); } }
public Migration(MigrationOptions migrationOptions, ILogger logger) { _options = migrationOptions; _logger = logger; if (migrationOptions.IgnoreFile != null) { if (!migrationOptions.IgnoreFile.Contains(":")) { string basePath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location); migrationOptions.IgnoreFile = Path.Combine(basePath, migrationOptions.IgnoreFile); } try { migrationOptions.IgnoreTableList = File.ReadAllLines(migrationOptions.IgnoreFile); logger.Log("Reading ignore file: " + migrationOptions.IgnoreFile + ". " + migrationOptions.IgnoreTableList.Length + " lines found.", EventType.Info); } catch (Exception ex) { logger.Log("Error reading ignore file: " + migrationOptions.IgnoreFile + ". " + ex.Message, EventType.Error); } } if (migrationOptions.OutputFile != null) { if (!migrationOptions.OutputFile.Contains(":")) { string basePath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location); migrationOptions.OutputFile = Path.Combine(basePath, migrationOptions.OutputFile); } } }
/// <summary> /// Creates a migration runner for the specified migration assembly against the given connection string. /// </summary> /// <param name="assembly">The assembly with migrations.</param> /// <param name="connectionString">The connection string of the database to migrate.</param> /// <param name="outputWriter"> /// The writer where output messages should be written (optional - defaults to /// System.Diagnostics.Debug output). /// </param> /// <returns>A Fluent MigrationRunner instance.</returns> public static MigrationRunner Create(Assembly assembly, string connectionString, Action <string> outputWriter = null) { if (assembly == null) { throw new ArgumentNullException("assembly"); } if (connectionString == null) { throw new ArgumentNullException("connectionString"); } if (outputWriter == null) { outputWriter = s => Debug.WriteLine(s); } var options = new MigrationOptions { PreviewOnly = false }; var announcer = new TextWriterAnnouncer(outputWriter); var migrationContext = new RunnerContext(announcer); var processorFactory = new SqlServerProcessorFactory(); var processor = processorFactory.Create(connectionString, announcer, options); var runner = new MigrationRunner(assembly, migrationContext, processor); return(runner); }
/// <summary> /// /// </summary> /// <param name="runnerAction"></param> public void Migrate(Action <IMigrationRunner> runnerAction) { var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s)); var options = new MigrationOptions { PreviewOnly = false, Timeout = 7200 }; string dbType = ""; if (_dbType.Contains("MySql")) { dbType = "MySql"; } else if (_dbType.Contains("SqlClient")) { dbType = "SqlServer"; } else if (_dbType.Contains("SQLite")) { dbType = "SQLite"; } var factory = new FluentMigrator.Runner.Processors.MigrationProcessorFactoryProvider().GetFactory(dbType); //var assembly = Assembly.GetExecutingAssembly(); var migrationContext = new RunnerContext(announcer); var processor = factory.Create(_connectionString, announcer, options); var runner = new MigrationRunner(_assembly, migrationContext, processor); runnerAction(runner); }
public static void MigrateDown(string connectionString, long?migrationId) { var announcer = GetAnnouncer(); var assembly = Assembly.GetAssembly(typeof(Seed)); var migrationContext = new RunnerContext(announcer) { Namespace = typeof(Seed).Namespace }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory(); using (var processor = factory.Create(connectionString, announcer, options)) { var runner = new MigrationRunner(assembly, migrationContext, processor); if (migrationId.HasValue) { runner.RollbackToVersion(migrationId.Value); } else { runner.Rollback(int.MaxValue); } } }
private Migrator GetMigrator() { var options = new MigrationOptions(); options.SupportedProviders.Set(new [] { ProviderNames.SqlServer2008 }); return(new Migrator(_connectionString, ProviderNames.SqlServer2008, options)); }
public static void RunMigrations(string connectionString, string migration) { // var announcer = new NullAnnouncer(); var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s)); var assembly = Assembly.GetExecutingAssembly(); var migrationContext = new RunnerContext(announcer) { Namespace = "Azimuth.Migrations", WorkingDirectory = "Migrations" }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory(); var processor = factory.Create(connectionString, announcer, options); var runner = new MigrationRunner(assembly, migrationContext, processor); switch (migration) { case "Run migrations": runner.MigrateUp(true); break; case "Drop all tables": runner.RollbackToVersion(201408091845); runner.Rollback(1); break; } }
public void VerityIsWarningSuppressedIsFalseByDefault() { var options = new MigrationOptions(); Assert.IsFalse(options.IsWarningSuppressed(ProviderName, Type, 0, 0)); Assert.IsFalse(options.IsWarningSuppressed(ProviderName, Type, 1, 0)); Assert.IsFalse(options.IsWarningSuppressed(ProviderName, Type, 1, 1)); }
public static void AddNetCleanDbContext <T>( this IServiceCollection services, Action <DbContextOptionsBuilder> options, MigrationOptions migration = MigrationOptions.Migrate) where T : DbContext { services.AddDbContextPool <T>(options); services.AddScoped <DbContext>(provider => provider.GetRequiredService <T>()); services.AddScoped <IUnitOfWork>(provider => provider.GetRequiredService <T>() as IUnitOfWork); switch (migration) { case MigrationOptions.EnsureDeleteAndCreated: { services.BuildServiceProvider().GetRequiredService <T>().Database.EnsureDeleted(); services.BuildServiceProvider().GetRequiredService <T>().Database.EnsureCreated(); } break; case MigrationOptions.EnsureCreated: services.BuildServiceProvider().GetRequiredService <T>().Database.EnsureCreated(); break; case MigrationOptions.Migrate: services.BuildServiceProvider().GetRequiredService <T>().Database.Migrate(); break; default: break; } }
public void VerifyIsWarningSuppressedIsFalseByDefault() { var options = new MigrationOptions(); Assert.IsFalse(options.IsWarningSuppressed(Platform, Type, 0, 0)); Assert.IsFalse(options.IsWarningSuppressed(Platform, Type, 1, 0)); Assert.IsFalse(options.IsWarningSuppressed(Platform, Type, 1, 1)); }
private static void Validate(IMigrationReport report, out string errors, out string warnings) { IEnumerable <ProviderInfo> providerInfos; MigrationOptions options = GetOptions(out providerInfos); Validate(providerInfos, options, report, out errors, out warnings); }
public void MigrateToLatest() { try { var connectionString = _settingsService.ConnectionString(DatabaseContext.DefaultConnectionString); var announcer = new NullAnnouncer(); var assembly = Assembly.GetExecutingAssembly(); var migrationContext = new RunnerContext(announcer) { NestedNamespaces = true, Namespace = "Database.Migrations", Connection = connectionString }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2014ProcessorFactory(); using (var processor = factory.Create(connectionString, announcer, options)) { var runner = new MigrationRunner(assembly, migrationContext, processor); runner.MigrateUp(true); } } catch (Exception e) { } }
public static void AssertNotFrozen(this MigrationOptions opts, string action) { if (opts.Freeze) { throw new InvalidOperationException($"Can't {action}, schema is frozen"); } }
public void VerifySuppressWarningWithSize() { var options = new MigrationOptions(); options.SuppressWarning(Platform, Type, SuppressCondition.WhenSpecifiedWithSize); Assert.IsFalse(options.IsWarningSuppressed(Platform, Type, null, null)); Assert.IsTrue(options.IsWarningSuppressed(Platform, Type, 1, null)); Assert.IsFalse(options.IsWarningSuppressed(Platform, Type, 1, 1)); }
public void VerifySuppressWarningAlways() { var options = new MigrationOptions(); options.SuppressWarning(Platform, Type, SuppressCondition.Always); Assert.IsTrue(options.IsWarningSuppressed(Platform, Type, null, null)); Assert.IsTrue(options.IsWarningSuppressed(Platform, Type, 1, null)); Assert.IsTrue(options.IsWarningSuppressed(Platform, Type, 1, 1)); }
/// <summary> /// Adds configuration for <see cref="MigrationsMiddleware"/> into <see cref="IServiceCollection"/>. /// </summary> /// <param name="setupAction">Setup migration options.</param> /// <returns>This instance of <see cref="KormBuilder"/>.</returns> public KormBuilder AddKormMigrations(Action <MigrationOptions> setupAction = null) { Services.AddMemoryCache(); MigrationOptions options = SetupMigrationOptions(setupAction); _migrationsRunner = new MigrationsRunner(ConnectionSettings.ConnectionString, options); return(this); }
public static void AssertColumnDeleteAllowed(this MigrationOptions opts, string table, string column, string field) { opts.AssertNotFrozen($"change '{field}' of '{column}' of '{table}'"); if (!opts.AllowDataloss) { throw new InvalidOperationException($"Can't migrate column '{column}' of '{table}', {field} can't be changed without dataloss"); } }
public void VerifySuppressWarningWithSizeAndScale() { var options = new MigrationOptions(); options.SuppressWarning(ProviderName, Type, SuppressCondition.WhenSpecifiedWithSizeAndScale); Assert.IsFalse(options.IsWarningSuppressed(ProviderName, Type, 0, 0)); Assert.IsFalse(options.IsWarningSuppressed(ProviderName, Type, 1, 0)); Assert.IsTrue(options.IsWarningSuppressed(ProviderName, Type, 1, 1)); }
public static void AssertColumnDeleteAllowed(this MigrationOptions opts, string table, string column) { opts.AssertNotFrozen($"delete '{column}' of '{table}'"); if (!opts.AllowDataloss) { throw new InvalidOperationException($"Can't delete column '{column}' of '{table}', dataloss is not allowed"); } }
public void VerifySuppressWarningAlways() { var options = new MigrationOptions(); options.SuppressWarning(ProviderName, Type, SuppressCondition.Always); Assert.IsTrue(options.IsWarningSuppressed(ProviderName, Type, 0, 0)); Assert.IsTrue(options.IsWarningSuppressed(ProviderName, Type, 1, 0)); Assert.IsTrue(options.IsWarningSuppressed(ProviderName, Type, 1, 1)); }
private static void Validate(IEnumerable <ProviderInfo> providerInfos, MigrationOptions options, IMigrationReport report, out string errors, out string warnings) { var validator = new Validator(providerInfos, options); IMigrationReporter reporter = A.Fake <IMigrationReporter>(); A.CallTo(() => reporter.Report(A <IMigrationContext> ._)).Returns(report); IMigrationReporter[] reporters = new[] { reporter }; validator.Validate(reporters, out errors, out warnings); }
private static void AssertModulesAreNotSelected(MigrationOptions options, params string[] moduleNames) { foreach (string moduleName in moduleNames) { var metadata = A.Fake<IMigrationMetadata>(); A.CallTo(() => metadata.ModuleName).Returns(moduleName); Assert.IsFalse(options.MigrationSelector(metadata), "Module '{0}' should not be selected.", moduleName); } }
private static void Validate(MigrationOptions options, IMigrationReport report, out string errors, out string warnings) { var validator = new Validator(options); IMigrationReporter reporter = MockRepository.GenerateStub <IMigrationReporter>(); reporter.Expect(r => r.Report(null)).IgnoreArguments().Return(report); IMigrationReporter[] reporters = new[] { reporter }; validator.Validate(reporters, out errors, out warnings); }
private static MigrationRunner GetRunner(string connectionString, IMigrationProcessorFactory factory) { var announcer = new NullAnnouncer(); var assembly = Assembly.GetExecutingAssembly(); var migrationContext = new RunnerContext(announcer) { Namespace = "Migrations" }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var processor = factory.Create(connectionString, announcer, options); return new MigrationRunner(assembly, migrationContext, processor); }
public void Migrate(Action<IMigrationRunner> runnerAction) { var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 }; var factory = new FluentMigrator.Runner.Processors.MigrationProcessorFactoryProvider().GetFactory(_dbType); var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s)); var migrationContext = new RunnerContext(announcer); var processor = factory.Create(_connectionString, announcer, options); var runner = new MigrationRunner(_migrationAssembly, migrationContext, processor); runnerAction(runner); }
public virtual void Setup() { _options = new MigrationOptions(); _options.SupportedProviders.Set(new[] { ProviderName }); // avoid validation errors/warnings from other providers // initialize IntegrationTestContext IProviderMetadata providerMetadata; IProvider provider = _options.SupportedProviders.GetProvider(ProviderName, out providerMetadata); IntegrationTestContext.Initialize(_options, provider.GetSupportsAttributes()); }
public void VerifySuppressWarningCombined() { var options = new MigrationOptions(); options.SuppressWarning(ProviderName, Type, SuppressCondition.WhenSpecifiedWithoutSize); options.SuppressWarning(ProviderName, Type, SuppressCondition.WhenSpecifiedWithSize); options.SuppressWarning(ProviderName, Type, SuppressCondition.WhenSpecifiedWithSizeAndScale); Assert.IsTrue(options.IsWarningSuppressed(ProviderName, Type, null, null)); Assert.IsTrue(options.IsWarningSuppressed(ProviderName, Type, 1, null)); Assert.IsTrue(options.IsWarningSuppressed(ProviderName, Type, 1, 1)); }
public MigrationBatch( IEnumerable<IMigrationStep> upMigrations, IEnumerable<IMigrationStep> downMigrations, IVersioning versioning, MigrationOptions options) { _upMigrations = upMigrations; _downMigrations = downMigrations; _versioning = versioning; _options = options; }
public void Migrate(Action<IMigrationRunner> runnerAction) { var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 }; var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory(); var assembly = Assembly.GetExecutingAssembly(); var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s)); var migrationContext = new RunnerContext(announcer); var processor = factory.Create(this._connectionString, announcer, options); var runner = new MigrationRunner(assembly, migrationContext, processor); runnerAction(runner); }
public MigrationBatch( IEnumerable<IMigrationStep> migrations, IEnumerable<IMigrationMetadata> unidentifiedMigrations, IVersioning versioning, MigrationOptions options) { _migrations = migrations; _scheduledMigrations = new ReadOnlyCollection<IScheduledMigrationMetadata>(_migrations.Select(s => s.Metadata).ToList()); _unidentifiedMigrations = new ReadOnlyCollection<IMigrationMetadata>(unidentifiedMigrations.ToList()); _versioning = versioning; _options = options; }
public static void MigrateToLatest() { var connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString; var migrationAssembly= Assembly.GetExecutingAssembly(); var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s)); var migrationContext = new RunnerContext(announcer); var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory(); var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 }; var processor = factory.Create(connectionString, announcer, options); var runner = new MigrationRunner(migrationAssembly, migrationContext, processor); runner.MigrateUp(); }
public void MigrateToLatest() { var announcer = new TextWriterAnnouncer(s => Debug.WriteLine(s)); var assembly = Assembly.GetExecutingAssembly(); var migrationContext = new RunnerContext(announcer); var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory(); using (var processor = factory.Create(connectionString, announcer, options)) { var runner = new MigrationRunner(assembly, migrationContext, processor); runner.MigrateUp(true); } }
public void MigrateToLatest() { var asm = Assembly.GetExecutingAssembly(); var announcer = new TextWriterAnnouncer((str) => { Debug.WriteLine(str); }); var context = new RunnerContext(announcer); var options = new MigrationOptions(); var factory = new SqlServer2012ProcessorFactory(); var processor = factory.Create(this._connectionString, announcer, options); var runner = new MigrationRunner(asm, context, processor); runner.MigrateUp(true); }
public static void MigrateToLatest(string connectionString) { var announcer = new NullAnnouncer(); var assembly = Assembly.GetExecutingAssembly(); var migrationContext = new RunnerContext(announcer) { Namespace = "Hinata.Data.Migrations" }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory(); var processor = factory.Create(connectionString, announcer, options); var runner = new MigrationRunner(assembly, migrationContext, processor); runner.MigrateUp(true); }
public static void MigrateToLatest(string connectionString) { // var announcer = new NullAnnouncer(); var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s)); var assembly = Assembly.GetExecutingAssembly(); var migrationContext = new RunnerContext(announcer) { Namespace = "Zoo.Models.Migrations" }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory(); var processor = factory.Create(connectionString, announcer, options); var runner = new MigrationRunner(assembly, migrationContext, processor); runner.MigrateUp(true); }
private static MigrationRunner GetRunner(string connectionString) { var announcer = new TextWriterAnnouncer(Console.WriteLine); var assembly = Assembly.GetExecutingAssembly(); var migrationContext = new RunnerContext(announcer) { Namespace = "Rainfall.Integration.Migrations" }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var factory = new SqlServer2008ProcessorFactory(); var processor = factory.Create(connectionString, announcer, options); var runner = new MigrationRunner(assembly, migrationContext, processor); return runner; }
/// <summary> /// Migrate the database to the latest version. /// </summary> /// <param name="connectionStringName">The name of the connection string.</param> public static void MigrateToLatest(string connectionStringName) { var announcer = new NullAnnouncer(); var assembly = Assembly.GetAssembly(typeof(CreateCountriesTable)); var migrationContext = new RunnerContext(announcer) { Namespace = "ExampleApplication.Database.Migrations" }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2014ProcessorFactory(); using (var processor = factory.Create(connectionStringName, announcer, options)) { var runner = new MigrationRunner(assembly, migrationContext, processor); runner.MigrateUp(true); } }
public void Migrate(Action<IMigrationRunner> runnerAction) { var options = new MigrationOptions { PreviewOnly = false, Timeout = 0 }; var factory = new FluentMigrator.Runner.Processors.Sqlite.SqliteProcessorFactory(); var assembly = Assembly.GetExecutingAssembly(); //using (var announcer = new NullAnnouncer()) var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s)); var migrationContext = new RunnerContext(announcer) { #if DEBUG // will create testdata Profile = "development" #endif }; var processor = factory.Create(this.connectionString, announcer, options); var runner = new MigrationRunner(assembly, migrationContext, processor); runnerAction(runner); }
public static void MigrateDownOne(string connectionString) { var announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s)); var assembly = Assembly.GetExecutingAssembly(); var migrationContext = new RunnerContext(announcer) { Namespace = "Parakeet.Data.Migrator" }; var options = new MigrationOptions { PreviewOnly = false, Timeout = 60 }; var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2012ProcessorFactory(); using (var processor = factory.Create(connectionString, announcer, options)) { var runner = new MigrationRunner(assembly, migrationContext, processor); runner.VersionLoader.LoadVersionInfo(); runner.ListMigrations(); runner.MigrateDown(runner.VersionLoader.VersionInfo.Latest() - 1); } }
public IMigrationBatch Prepare(long timestamp, MigrationOptions options) { // import all migrations IReadOnlyCollection<ImportedMigration> availableMigrations; IReadOnlyCollection<ImportedAggregateMigration> availableAggregateMigrations; _importer.ImportAll(out availableMigrations, out availableAggregateMigrations); // create migration batch var executedMigrations = new List<IMigrationMetadata>(_versioning.ExecutedMigrations); var migrationSelector = new MigrationSelector(availableMigrations, executedMigrations); IEnumerable<ApplicableMigration> applicableMigrations; IEnumerable<IMigrationMetadata> unidentifiedMigrations; migrationSelector.GetMigrationsTo(timestamp, options.MigrationSelector, out applicableMigrations, out unidentifiedMigrations); var migrationAggregator = new MigrationAggregator(applicableMigrations, availableMigrations, availableAggregateMigrations); var migrationSteps = migrationAggregator.Aggregate(); return new MigrationBatch( migrationSteps, unidentifiedMigrations, _versioning, _configuration); }
public Validator(MigrationOptions options) { _options = options; }
private static void ExecuteMigration(string connectionString, DbPlatform dbPlatform, MigrationOptions options, string assemblyPath, long timestamp, string[] additionalAssemblyPaths) { var migrator = new Migrator(connectionString, dbPlatform, options); IMigrationBatch batch = migrator.FetchMigrationsTo(assemblyPath, timestamp, additionalAssemblyPaths); batch.Execute(); }
internal static void Initialize(MigrationOptions options, IEnumerable<SupportsAttribute> supportsAttributes) { _options = options; _supportsAttributes = supportsAttributes; }
internal static void Initialize(MigrationOptions options, ProviderInfo providerInfo) { _options = options; _providerInfo = providerInfo; }
public virtual void Setup() { _options = new MigrationOptions(); _options.SupportedPlatforms.Set(new[] { DbPlatform }); // avoid validation errors/warnings from other providers // initialize IntegrationTestContext IProviderFactory providerFactory = new ProviderFactory(); var providerLocator = new ProviderLocator(providerFactory); ProviderInfo providerInfo = providerLocator.GetExactly(DbPlatform); IntegrationTestContext.Initialize(_options, providerInfo); }