/// <summary> /// Initializes a new instance of the <see cref="LiteMigration"/> class. /// </summary> /// <param name="databasePath">Path to the SQLite database.</param> /// <param name="baseNamespace">Namespace to scripts.</param> /// <param name="databaseType">Type of database connection.</param> public LiteMigration(string databasePath, string baseNamespace, DatabaseType databaseType, string baseAssembly = "") { ////RevisionTable = nameof(VersionInfo); // FUTURE // Set to current namespace, it's a something DatabasePath = databasePath; DatabaseType = databaseType; // Create version info table here // Initialize().Wait(); Migrations = new MigrationFactory(); Migrations.BaseAssemblyFile = baseAssembly; Migrations.BaseNamespace = baseNamespace; switch (databaseType) { case DatabaseType.SQLiteCipher: _sqlEngine = new Engines.SqlitePclEngine(); // In-testing //// _sqlEngine = new Engines.SqlcipherEngine(); break; case DatabaseType.SQLite: default: _sqlEngine = new Engines.SqlitePclEngine(); break; } // The next operation may begin before this is finished being created VersionInitialize(); //// Task.Run(async () => await VersionInitializeAsync().ConfigureAwait(false)); _isInitialized = true; }
/// <summary> /// Applies the provided migrations to the target system. The engine does not check /// if the specified migrations were already applied. /// PLEASE NOTE: this method will not throw. You must check the resulting summary for errors that might have occurred. /// </summary> /// <param name="pendingMigrations">The list of migrations that should be applied.</param> /// <param name="now"> /// The current time when the migration engine starts to execute (optional). Please use a UTC time stamp if possible. If /// you do not provide a value, <see cref="DateTime.UtcNow" /> will be used. /// </param> /// <param name="cancellationToken">The token to cancel this asynchronous operation (optional).</param> /// <returns>A summary of all migrations that have been applied in this run.</returns> public virtual async Task <MigrationSummary <TMigrationInfo> > ApplyMigrationsAsync(List <PendingMigration <TMigrationVersion> >?pendingMigrations, DateTime?now = null, CancellationToken cancellationToken = default) { if (pendingMigrations.IsNullOrEmpty()) { return(MigrationSummary <TMigrationInfo> .Empty); } var timeStamp = now ?? DateTime.UtcNow; var appliedMigrations = new List <TMigrationInfo>(pendingMigrations.Count); for (var i = 0; i < pendingMigrations.Count; i++) { var pendingMigration = pendingMigrations[i]; IMigrationSession <TMigrationContext, TMigrationInfo>?session = null; TMigration?migration = default; try { migration = MigrationFactory.CreateMigration(pendingMigration.MigrationType); session = await SessionFactory.CreateSessionForMigrationAsync(migration, cancellationToken); await migration.ApplyAsync(session.Context, cancellationToken); var migrationInfo = CreateMigrationInfo(migration, timeStamp); await session.StoreMigrationInfoAsync(migrationInfo, cancellationToken); await session.SaveChangesAsync(cancellationToken); appliedMigrations.Add(migrationInfo); } catch (Exception exception) { var error = new MigrationError <TMigrationVersion>(pendingMigration.MigrationVersion, exception); return(new MigrationSummary <TMigrationInfo>(error, appliedMigrations)); } finally { // ReSharper disable SuspiciousTypeConversion.Global -- clients of the library should be allowed to write disposable migrations if (migration is IAsyncDisposable asyncDisposableMigration) { await asyncDisposableMigration.DisposeAsync(); } else if (migration is IDisposable disposableMigration) { disposableMigration.Dispose(); } // ReSharper restore SuspiciousTypeConversion.Global if (session != null) { await session.DisposeAsync(); } } } return(new MigrationSummary <TMigrationInfo>(appliedMigrations)); }
static void Main(string[] args) { var p = new Params(args); var tableName = p.Get("table name", "-t"); var idColumnName = p.Get("id column name", "-i"); var parentIdColumnName = p.Get("parent id column name", "-p"); File.WriteAllText("out.sql", MigrationFactory.CreateScript(tableName, idColumnName, parentIdColumnName).ToString()); }
public Runner(IDataClient dataClient, Assembly targetAssembly, IVersionRepository versionRepository) { _dataClient = dataClient; _databaseKind = _dataClient.Database.Provider.DatabaseKind; _targetAssembly = targetAssembly; _versionRepository = versionRepository; _migrationFactory = new MigrationFactory(_dataClient); _initialVersion = -1; }
public void InstantiateNonMigrationClass_Skip() { var sut = new MigrationFactory(); var result = sut.Create(new List <Type> { typeof(string) }) .ToList(); Assert.Empty(result); }
public void InstantiateMigration() { var sut = new MigrationFactory(); var result = sut.Create(new List <Type> { typeof(B1Migration) }) .ToList(); Assert.IsType <B1Migration>(result.Single()); }
protected async Task <LRTest> Test(string tree) { var tableName = CreateTableName(); await CreateTable.New("[%_Node_%]", SqlStuff.Escape(tableName)).ExecuteAsync(_connection); await Arrange(tree, SqlStuff.Escape(tableName), _connection); await MigrationFactory.CreateScript(tableName, "Id", "Parent_Id").ExecuteAsync(_connection); return(new LRTest(tableName, tree, _connection)); }
public void MigrateDataBase() { try { var migrater = MigrationFactory.Build(Connection); migrater.ExecuteCommand(); } catch (Exception e) { throw new Exception("Database migration failed." + e.Message); } }
public void UseActivatorToCreateFact() { // Arrange var factory = new MigrationFactory(); // Act var migration = factory.Create(typeof(MigrationStub)); // Assert migration.Should().NotBe(null); migration.Should().BeOfType <MigrationStub>(); }
public void Init() { _dataClient = new Mock <IDataClient>().Object; _factory = new MigrationFactory(_dataClient); }
public MigrationFactoryTests() { _dataClient = new Mock <IDataClient>().Object; _factory = new MigrationFactory(_dataClient); }