public DirectToDbApplier( QueryExecuter queryExecuter, DatabaseSchemaVersionManager schemaVersionManager, QueryStatementSplitter splitter, IDbmsSyntax dbmsSyntax, string changeLogTableName, TextWriter infoTextWriter) { if (queryExecuter == null) throw new ArgumentNullException("queryExecuter"); if (schemaVersionManager == null) throw new ArgumentNullException("schemaVersionManager"); if (splitter == null) throw new ArgumentNullException("splitter"); if (infoTextWriter == null) throw new ArgumentNullException("infoTextWriter"); this.queryExecuter = queryExecuter; this.schemaVersionManager = schemaVersionManager; this.splitter = splitter; this.dbmsSyntax = dbmsSyntax; this.changeLogTableName = changeLogTableName; this.infoTextWriter = infoTextWriter; }
public void IfCurrentDbVersionIsSpecifiedShouldGenerateAppliedChangesUpToAndIncludingCurrentDbVersion() { List<int> appliedChanges = new DatabaseSchemaVersionManager(null, "Main", 10).GetAppliedChangeNumbers(); Assert.AreEqual(10, appliedChanges.Count); Assert.AreEqual(1, appliedChanges[0]); Assert.AreEqual(10, appliedChanges[9]); }
protected void SetUp() { var factory = new DbmsFactory(Dbms, ConnectionString); var executer = new QueryExecuter(factory); databaseSchemaVersion = new DatabaseSchemaVersionManager(executer, factory.CreateDbmsSyntax(), TableName); }
public void SetUp() { this.changeLogTableName = "changelog"; this.expectedResultSet = new Mock <IDataReader>(); var connection = new Mock <IDbConnection>(); var factory = new Mock <DbmsFactory>("mssql", string.Empty); factory.Setup(f => f.CreateConnection()).Returns(connection.Object); this.queryExecuter = new Mock <QueryExecuter>(factory.Object); this.syntax = new Mock <IDbmsSyntax>(); this.queryExecuter .Setup(e => e.ExecuteQuery(It.IsAny <string>())) .Returns(this.expectedResultSet.Object); var checkForChangeLogDataReader = new Mock <IDataReader>(); checkForChangeLogDataReader .Setup(r => r.Read()) .Returns(true); this.queryExecuter .Setup(e => e.ExecuteQuery(It.Is <string>(v => v.Contains("INFORMATION_SCHEMA")), It.Is <string>(s => s.Equals(changeLogTableName)))) .Returns(() => checkForChangeLogDataReader.Object); this.schemaVersionManager = new DatabaseSchemaVersionManager(this.queryExecuter.Object, this.syntax.Object, changeLogTableName); }
protected override void ProcessRecord() { var configurationFile = ToAbsolutePath(ConfigurationFile); _deltasDirectory = ToAbsolutePath(DeltasDirectory); if (!string.IsNullOrEmpty(configurationFile) && File.Exists(configurationFile)) { _config = new XmlConfiguration(configurationFile); if(string.IsNullOrEmpty(DatabaseType)) DatabaseType = _config.DbType; if(string.IsNullOrEmpty(ConnectionString)) ConnectionString = _config.DbConnectionString; if(string.IsNullOrEmpty(DeltaSet)) DeltaSet = _config.DbDeltaSet; if(string.IsNullOrEmpty(TableName)) TableName = _config.TableName; if(!CurrentDbVersion.HasValue) CurrentDbVersion = _config.CurrentDbVersion; } if(string.IsNullOrEmpty(ConnectionString)) { throw new InvalidDataException( "Missing connection string. It must either be in the config file or passed as a parameter"); } _dbmsFactory = new DbmsFactory(DatabaseType, ConnectionString, ForDirectExecution); _databaseSchemaVersion = new DatabaseSchemaVersionManager(_dbmsFactory, DeltaSet, CurrentDbVersion, TableName); }
public void SetUp() { this.changeLogTableName = "changelog"; this.expectedResultSet = new Mock<IDataReader>(); var connection = new Mock<IDbConnection>(); var factory = new Mock<DbmsFactory>("mssql", string.Empty); factory.Setup(f => f.CreateConnection()).Returns(connection.Object); this.queryExecuter = new Mock<QueryExecuter>(factory.Object); this.syntax = new Mock<IDbmsSyntax>(); this.queryExecuter .Setup(e => e.ExecuteQuery(It.IsAny<string>())) .Returns(this.expectedResultSet.Object); var checkForChangeLogDataReader = new Mock<IDataReader>(); checkForChangeLogDataReader .Setup(r => r.Read()) .Returns(true); this.queryExecuter .Setup(e => e.ExecuteQuery(It.Is<string>(v => v.Contains("INFORMATION_SCHEMA")), It.Is<string>(s => s.Equals(changeLogTableName)))) .Returns(() => checkForChangeLogDataReader.Object); this.schemaVersionManager = new DatabaseSchemaVersionManager(this.queryExecuter.Object, this.syntax.Object, changeLogTableName); }
protected override void ProcessRecord() { base.ProcessRecord(); var infoTextWriter = new LambdaTextWriter(WriteVerbose); List<ChangeScript> allChangeScripts = new DirectoryScanner(infoTextWriter, Encoding.UTF8, new DirectoryInfo(this.deltasDirectory)) .GetChangeScripts(); var repository = new ChangeScriptRepository(allChangeScripts); var changeScripts = repository.GetAvailableChangeScripts(); DbmsFactory factory = new DbmsFactory(this.DatabaseType, this.ConnectionString); var queryExecuter = new QueryExecuter(factory); var schemaManager = new DatabaseSchemaVersionManager(queryExecuter, factory.CreateDbmsSyntax(), this.TableName); var appliedChanges = schemaManager.GetAppliedChanges(); var notAppliedChangeScripts = changeScripts.Where(c => appliedChanges.All(a => a.ScriptNumber != c.ScriptNumber)); var descriptionPrettyPrinter = new DescriptionPrettyPrinter(); var objects = notAppliedChangeScripts .Select(script => new { Id = script.ScriptNumber, Description = descriptionPrettyPrinter.Format(script.ScriptName), File = script.FileInfo }); this.WriteObject(objects, true); }
public DirectToDbApplierAccessor( QueryExecuter queryExecuter, DatabaseSchemaVersionManager schemaVersionManager, QueryStatementSplitter splitter, TextWriter infoTextWriter) : base(queryExecuter, schemaVersionManager, splitter, infoTextWriter) { }
public void IfCurrentDbVersionIsSpecifiedShouldGenerateAppliedChangesUpToAndIncludingCurrentDbVersion() { List <Int64> appliedChanges = new DatabaseSchemaVersionManager(null, "Main", 10).GetAppliedChangeNumbers(); Assert.AreEqual(10, appliedChanges.Count); Assert.AreEqual(1, appliedChanges[0]); Assert.AreEqual(10, appliedChanges[9]); }
public virtual void TestCanSetChangeLogTableName() { const string expectedTableName = "FooTable"; const string expectedChangeOwner = "FooOwner"; DatabaseSchemaVersionManager databaseSchemaVersionManager = new DatabaseSchemaVersionManager(new DbmsFactory(Dbms, ConnectionString), DeltaSet, null, expectedTableName, expectedChangeOwner); Assert.AreEqual(expectedTableName, databaseSchemaVersionManager.TableName); }
public Controller(DatabaseSchemaVersionManager schemaManager, ChangeScriptRepository changeScriptRepository, ChangeScriptExecuter changeScriptExecuter) { this.schemaManager = schemaManager; this.changeScriptRepository = changeScriptRepository; this.changeScriptExecuter = changeScriptExecuter; }
protected override void SetUp() { var factory = new DbmsFactory(Dbms, ConnectionString, postGreDataDll); var executer = new QueryExecuter(factory); this.syntax = factory.CreateDbmsSyntax(); databaseSchemaVersion = new DatabaseSchemaVersionManager(executer, this.syntax, TableName); }
protected override void SetUp() { var factory = new DbmsFactory(Dbms, firebirdConnectionString, firebirdSqlDataFirebirdClient); var executer = new QueryExecuter(factory); this.syntax = factory.CreateDbmsSyntax(); databaseSchemaVersion = new DatabaseSchemaVersionManager(executer, this.syntax, TableName); }
public void ShouldGenerateSqlStringContainingSpecifiedChangelogTableNameOnDelete() { var schemaVersionManagerWithDifferentTableName = new DatabaseSchemaVersionManager(this.queryExecuter.Object, this.syntax.Object, "user_specified_changelog"); string updateSql = schemaVersionManagerWithDifferentTableName.GetChangelogDeleteSql(this.script); Assert.IsTrue(updateSql.StartsWith("DELETE FROM user_specified_changelog ")); }
public DirectToDbApplierAccessor( QueryExecuter queryExecuter, DatabaseSchemaVersionManager schemaVersionManager, QueryStatementSplitter splitter, IDbmsSyntax dbmsSyntax, string changeLogTableName, TextWriter infoTextWriter) : base(queryExecuter, schemaVersionManager, splitter, dbmsSyntax, changeLogTableName, infoTextWriter) { }
protected override void SetUp() { var factory = new DbmsFactory(Dbms, ConnectionString, mySqlDataDll); var executer = new QueryExecuter(factory); this.syntax = factory.CreateDbmsSyntax(); syntax.SetDefaultDatabaseName(connectionString); databaseSchemaVersion = new DatabaseSchemaVersionManager(executer, this.syntax, TableName); }
public void ShouldGetAppliedChangesFromSpecifiedChangelogTableName() { changeLogTableName = "user_specified_changelog"; var schemaVersionManagerWithDifferentTableName = new DatabaseSchemaVersionManager(this.queryExecuter.Object, this.syntax.Object, changeLogTableName); schemaVersionManagerWithDifferentTableName.GetAppliedChanges(); this.queryExecuter.Verify(e => e.ExecuteQuery(It.Is <string>(s => s.StartsWith("SELECT change_number FROM user_specified_changelog ")))); }
public ToPrintStreamDeployer(DatabaseSchemaVersionManager schemaManager, DirectoryInfo dir, TextWriter outputPrintStream, IDbmsSyntax dbmsSyntax, bool useTransaction, TextWriter undoOutputPrintStream) { this.schemaManager = schemaManager; this.dir = dir; doOutputPrintStream = outputPrintStream; this.dbmsSyntax = dbmsSyntax; this.useTransaction = useTransaction; this.undoOutputPrintStream = undoOutputPrintStream; }
public void TestShouldHandleCreatingChangeLogTableWithSchema() { this.EnsureTableDoesNotExist("log.Installs"); var factory = new DbmsFactory(this.Dbms, this.ConnectionString); var executer = new QueryExecuter(factory); var databaseSchemaManager = new DatabaseSchemaVersionManager(executer, factory.CreateDbmsSyntax(), "log.Installs", true); // Table should be created when attempted now; if table does not exist. databaseSchemaManager.GetAppliedChanges(); this.AssertTableExists("log.Installs"); }
public void SetUp() { var dbmsFactory = new DbmsFactory(Dbms, ConnectionString); var queryExecuter = new QueryExecuter(dbmsFactory); var dbmsSyntax = dbmsFactory.CreateDbmsSyntax(); var schemaVersionManager = new DatabaseSchemaVersionManager(queryExecuter, dbmsSyntax, ChangeLogTableName); this.sqlCmdApplier = new SqlCmdApplier(ConnectionString, schemaVersionManager, dbmsSyntax, ChangeLogTableName, System.Console.Out); // Remove any existing changelog and customers test table. this.EnsureTableDoesNotExist(ChangeLogTableName); this.EnsureTableDoesNotExist("Customer"); }
public void TestCanGenerateVersionCheck() { databaseSchemaVersion = new DatabaseSchemaVersionManager(new DbmsFactory(DBMS, CONNECTION_STRING), "Main", 5); Assert.AreEqual(@"DECLARE @currentDatabaseVersion INTEGER, @errMsg VARCHAR(1000) SELECT @currentDatabaseVersion = MAX(ChangeNumber) FROM changelog WHERE Project = 'Main' IF (@currentDatabaseVersion <> 5) BEGIN SET @errMsg = 'Error: current database version on Project <Main> is not 5, but ' + CONVERT(VARCHAR, @currentDatabaseVersion) RAISERROR (@errMsg, 16, 1) END GO ", databaseSchemaVersion.GenerateVersionCheck()); }
public void TestCanGenerateVersionCheck() { databaseSchemaVersion = new DatabaseSchemaVersionManager(new DbmsFactory(DBMS, CONNECTION_STRING), "Main", 5); Assert.AreEqual(@"DECLARE @currentDatabaseVersion INTEGER, @errMsg VARCHAR(1000) SELECT @currentDatabaseVersion = MAX(ChangeNumber) FROM changelog WHERE Project = 'Main' IF (@currentDatabaseVersion <> 5) BEGIN SET @errMsg = 'Error: current database version on Project <Main> is not 5, but ' + CONVERT(VARCHAR, @currentDatabaseVersion) RAISERROR (@errMsg, 16, 1) END GO ", databaseSchemaVersion.GenerateVersionCheck()); }
public PowershellPrintStreamDeployer(DatabaseSchemaVersionManager schemaManager, ChangeScriptRepository repository, TextWriter outputPrintStream, IDbmsSyntax dbmsSyntax, bool useTransaction, TextWriter undoOutputPrintStream, TextWriter infoPrintStream) { this.schemaManager = schemaManager; this.doOutputPrintStream = outputPrintStream; this.dbmsSyntax = dbmsSyntax; this.useTransaction = useTransaction; this.undoOutputPrintStream = undoOutputPrintStream; this.infoPrintStream = infoPrintStream; this.repository = repository; }
public void TestShouldHandleCreatingChangeLogTableWithSchema() { this.EnsureTableDoesNotExist("log.Installs"); var factory = new DbmsFactory(this.Dbms, this.ConnectionString); var executer = new QueryExecuter(factory); var databaseSchemaManager = new DatabaseSchemaVersionManager(executer, factory.CreateDbmsSyntax(), "log.Installs"); var applier = new DirectToDbApplier(executer, databaseSchemaManager, new QueryStatementSplitter(), factory.CreateDbmsSyntax(), "log.Installs", new NullWriter()); applier.Apply(new ChangeScript[] {}, createChangeLogTable: true); this.AssertTableExists("log.Installs"); }
public void SetUp() { this.changeLogTableName = "ChangeLog"; this.expectedResultSet = new Mock <IDataReader>(); var connection = new Mock <IDbConnection>(); var factory = new Mock <DbmsFactory>("mssql", string.Empty, null); factory.Setup(f => f.CreateConnection()).Returns(connection.Object); this.queryExecuter = new Mock <QueryExecuter>(factory.Object); this.syntax = new Mock <IDbmsSyntax>(); this.syntax.Setup(s => s.TableExists(It.IsAny <string>())) .Returns <string>(t => string.Format(CultureInfo.InvariantCulture, @"SELECT table_schema FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{0}'", t)); this.executedQueries = new List <string>(); var checkForChangeLogDataReader = new Mock <IDataReader>(); checkForChangeLogDataReader .Setup(r => r.Read()) .Returns(true); this.queryExecuter .Setup(e => e.ExecuteQuery(It.Is <string>(v => v.Contains("INFORMATION_SCHEMA")))) .Returns(() => checkForChangeLogDataReader.Object); this.queryExecuter .Setup(e => e.ExecuteQuery(It.Is <string>(v => !v.Contains("INFORMATION_SCHEMA")), It.IsAny <object[]>())) .Returns(this.expectedResultSet.Object) .Callback <string, object[]>((query, args) => this.executedQueries.Add(query)); this.schemaVersionManager = new DatabaseSchemaVersionManager(this.queryExecuter.Object, this.syntax.Object, changeLogTableName); }
public static void Main(string[] args) { try { var commandLineArgumentsParser = new CommandLineArgumentsParser(); ParsedArguments parsedArguments = commandLineArgumentsParser.ParseArgs(args); var printScreenFactory = new PrintScreenFactory(); var config = new CommandLineArgsConfiguration(parsedArguments); var factory = new DbmsFactory(config.DbType, config.DbConnectionString); var databaseSchemaVersion = new DatabaseSchemaVersionManager(factory, config.DbDeltaSet, config.CurrentDbVersion, config.TableName, config.ChangeOwner); var directoryInfo = new DirectoryInfo(parsedArguments.GetScriptFilesFolderOrDefaultFolder()); TextWriter outputPrintStream = printScreenFactory.GetDoPrintStream(parsedArguments); var dbmsSyntax = factory.CreateDbmsSyntax(config.ChangeOwner); var useTransaction = config.UseTransaction; TextWriter undoOutputPrintStream = printScreenFactory.GetUndoPrintStream(parsedArguments); var toPrintStreamDeployer = new ToPrintStreamDeployer(databaseSchemaVersion, directoryInfo, outputPrintStream, dbmsSyntax, useTransaction, undoOutputPrintStream); toPrintStreamDeployer.DoDeploy(LastVersionChangeToApply); printScreenFactory.ClosePrintStream(outputPrintStream); printScreenFactory.ClosePrintStream(undoOutputPrintStream); } catch (DbDeployException ex) { Console.Error.WriteLine(ex.Message); Environment.Exit(1); } catch (Exception ex) { Console.Error.WriteLine("Failed to apply changes: " + ex); Console.Error.WriteLine(ex.StackTrace); Environment.Exit(2); } }
public void SetUp() { this.changeLogTableName = "ChangeLog"; this.expectedResultSet = new Mock<IDataReader>(); var connection = new Mock<IDbConnection>(); var factory = new Mock<DbmsFactory>("mssql", string.Empty, null); factory.Setup(f => f.CreateConnection()).Returns(connection.Object); this.queryExecuter = new Mock<QueryExecuter>(factory.Object); this.syntax = new Mock<IDbmsSyntax>(); this.syntax.Setup(s => s.TableExists(It.IsAny<string>())) .Returns<string>(t => string.Format(CultureInfo.InvariantCulture, @"SELECT table_schema FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{0}'", t)); this.executedQueries = new List<string>(); var checkForChangeLogDataReader = new Mock<IDataReader>(); checkForChangeLogDataReader .Setup(r => r.Read()) .Returns(true); this.queryExecuter .Setup(e => e.ExecuteQuery(It.Is<string>(v => v.Contains("INFORMATION_SCHEMA")))) .Returns(() => checkForChangeLogDataReader.Object); this.queryExecuter .Setup(e => e.ExecuteQuery(It.Is<string>(v => !v.Contains("INFORMATION_SCHEMA")), It.IsAny<object[]>())) .Returns(this.expectedResultSet.Object) .Callback<string, object[]>((query, args) => this.executedQueries.Add(query)); this.schemaVersionManager = new DatabaseSchemaVersionManager(this.queryExecuter.Object, this.syntax.Object, changeLogTableName); }
/// <summary> /// Initializes a new instance of the <see cref="SqlCmdApplier" /> class. /// </summary> /// <param name="connectionString">The database connection string.</param> /// <param name="schemaVersionManager">The schema version manager.</param> /// <param name="dbmsSyntax">Database syntax</param> /// <param name="changeLogTableName">ChangeLog table name</param> /// <param name="infoTextWriter">The info text writer.</param> public SqlCmdApplier( string connectionString, DatabaseSchemaVersionManager schemaVersionManager, IDbmsSyntax dbmsSyntax, string changeLogTableName, TextWriter infoTextWriter) { if (string.IsNullOrWhiteSpace(connectionString)) { throw new ArgumentNullException("connectionString"); } if (schemaVersionManager == null) { throw new ArgumentNullException("schemaVersionManager"); } if (dbmsSyntax == null) { throw new ArgumentNullException("dbmsSyntax"); } if (changeLogTableName == null) { throw new ArgumentNullException("changeLogTableName"); } if (infoTextWriter == null) { throw new ArgumentNullException("infoTextWriter"); } this.schemaVersionManager = schemaVersionManager; this.dbmsSyntax = dbmsSyntax; this.changeLogTableName = changeLogTableName; this.infoTextWriter = infoTextWriter; this.connectionString = connectionString; }
public static void Main(string[] args) { try { IConfiguration config = new ConfigurationFile(); DbmsFactory factory = new DbmsFactory(config.DbType, config.DbConnectionString); DatabaseSchemaVersionManager databaseSchemaVersion = new DatabaseSchemaVersionManager(factory, config.DbDeltaSet, config.CurrentDbVersion, config.TableName); new ToPrintStreamDeployer(databaseSchemaVersion, new DirectoryInfo("."), Console.Out, factory.CreateDbmsSyntax(), config.UseTransaction, null).DoDeploy(Int32.MaxValue); } catch (DbDeployException ex) { Console.Error.WriteLine(ex.Message); Environment.Exit(1); } catch (Exception ex) { Console.Error.WriteLine("Failed to apply changes: " + ex); Console.Error.WriteLine(ex.StackTrace); Environment.Exit(2); } }
public DirectToDbApplier( QueryExecuter queryExecuter, DatabaseSchemaVersionManager schemaVersionManager, QueryStatementSplitter splitter, TextWriter infoTextWriter) { if (queryExecuter == null) throw new ArgumentNullException("queryExecuter"); if (schemaVersionManager == null) throw new ArgumentNullException("schemaVersionManager"); if (splitter == null) throw new ArgumentNullException("splitter"); if (infoTextWriter == null) throw new ArgumentNullException("infoTextWriter"); this.queryExecuter = queryExecuter; this.schemaVersionManager = schemaVersionManager; this.splitter = splitter; this.infoTextWriter = infoTextWriter; }
public override bool Execute() { bool result = false; try { LogTaskProperties(); using (TextWriter outputPrintStream = new StreamWriter(outputfile.FullName)) { TextWriter undoOutputPrintStream = null; if (undoOutputfile != null) { undoOutputPrintStream = new StreamWriter(undoOutputfile.FullName); } DbmsFactory factory = new DbmsFactory(dbType, dbConnection); IDbmsSyntax dbmsSyntax = factory.CreateDbmsSyntax(); DatabaseSchemaVersionManager databaseSchemaVersion = new DatabaseSchemaVersionManager(factory, deltaSet, null); ToPrintStreamDeployer toPrintSteamDeployer = new ToPrintStreamDeployer(databaseSchemaVersion, dir, outputPrintStream, dbmsSyntax, useTransaction, undoOutputPrintStream); toPrintSteamDeployer.DoDeploy(lastChangeToApply); if (undoOutputPrintStream != null) { undoOutputPrintStream.Close(); } } result = true; } catch (DbDeployException ex) { Log.LogErrorFromException(ex, true); Console.Error.WriteLine(ex.Message); } catch (Exception ex) { Log.LogErrorFromException(ex, true); Console.Error.WriteLine("Failed to apply changes: " + ex.Message); Console.Error.WriteLine("Stack Trace:"); Console.Error.Write(ex.StackTrace); } return result; }
public void ShouldGenerateSqlStringContainingSpecifiedChangelogTableNameOnDelete() { var schemaVersionManagerWithDifferentTableName = new DatabaseSchemaVersionManager(this.queryExecuter.Object, this.syntax.Object, "user_specified_changelog"); string updateSql = schemaVersionManagerWithDifferentTableName.GetChangelogDeleteSql(this.script); Assert.IsTrue(updateSql.StartsWith("DELETE FROM user_specified_changelog ")); }
public void ShouldGetAppliedChangesFromSpecifiedChangelogTableName() { changeLogTableName = "user_specified_changelog"; var schemaVersionManagerWithDifferentTableName = new DatabaseSchemaVersionManager(this.queryExecuter.Object, this.syntax.Object, changeLogTableName); schemaVersionManagerWithDifferentTableName.GetAppliedChanges(); this.queryExecuter.Verify(e => e.ExecuteQuery(It.Is<string>(s => s.StartsWith("SELECT ChangeId, Folder, ScriptNumber, ScriptName, ScriptStatus, ScriptOutput FROM user_specified_changelog")))); }
public virtual void TestCanSetChangeLogTableName() { const string expectedTableName = "FooTable"; DatabaseSchemaVersionManager databaseSchemaVersionManager = new DatabaseSchemaVersionManager(new DbmsFactory(Dbms, ConnectionString), DeltaSet, null, expectedTableName); Assert.AreEqual(expectedTableName, databaseSchemaVersionManager.TableName); }
protected void SetUp() { databaseSchemaVersion = new DatabaseSchemaVersionManager(new DbmsFactory(Dbms, ConnectionString), DeltaSet, null); }
public void TestShouldHandleCreatingChangeLogTableWithSchema() { this.EnsureTableDoesNotExist("log.Installs"); var factory = new DbmsFactory(this.Dbms, this.ConnectionString); var executer = new QueryExecuter(factory); var databaseSchemaManager = new DatabaseSchemaVersionManager(executer, factory.CreateDbmsSyntax(), "log.Installs"); var applier = new DirectToDbApplier(executer, databaseSchemaManager, new QueryStatementSplitter(), factory.CreateDbmsSyntax(), "log.Installs", new NullWriter()); applier.Apply(new ChangeScript[] {}, createChangeLogTable: true); this.AssertTableExists("log.Installs"); }
protected void SetUp() { databaseSchemaVersion = new DatabaseSchemaVersionManager(new DbmsFactory(Dbms, ConnectionString), DeltaSet, null); }
public void TestCanGenerateVersionCheck() { databaseSchemaVersion = new DatabaseSchemaVersionManager(new DbmsFactory(DBMS, CONNECTION_STRING), "Main", 5); Assert.AreEqual(@"execute versionCheck('Main', 5, 'changelog');" , databaseSchemaVersion.GenerateVersionCheck()); }
public void TestCanGenerateVersionCheck() { databaseSchemaVersion = new DatabaseSchemaVersionManager(new DbmsFactory(DBMS, CONNECTION_STRING), "Main", 5); Assert.AreEqual(@"execute versionCheck('Main', 5, 'changelog');" , databaseSchemaVersion.GenerateVersionCheck()); }
public void Go() { this.Validate(); this.InfoWriter.WriteLine(this.GenerateWelcomeString()); var factory = new DbmsFactory(this.Dbms, this.ConnectionString); var dbmsSyntax = factory.CreateDbmsSyntax(); QueryExecuter queryExecuter = new QueryExecuter(factory); var databaseSchemaVersionManager = new DatabaseSchemaVersionManager(queryExecuter, dbmsSyntax, this.ChangeLogTableName); var scanner = new DirectoryScanner(this.InfoWriter, this.Encoding); var changeScriptRepository = new ChangeScriptRepository(scanner.GetChangeScriptsForDirectory(this.ScriptDirectory)); IChangeScriptApplier doScriptApplier; TextWriter doWriter = null; if (this.OutputFile != null) { doWriter = new StreamWriter(this.OutputFile.OpenWrite(), this.Encoding); doScriptApplier = new TemplateBasedApplier( doWriter, this.Dbms, this.ChangeLogTableName, this.Delimiter, this.DelimiterType, this.TemplateDir); } else { QueryStatementSplitter splitter = new QueryStatementSplitter { Delimiter = this.Delimiter, DelimiterType = this.DelimiterType, LineEnding = this.LineEnding, }; doScriptApplier = new DirectToDbApplier( queryExecuter, databaseSchemaVersionManager, splitter, this.InfoWriter); } IChangeScriptApplier undoScriptApplier = null; TextWriter undoWriter = null; if (this.UndoOutputFile != null) { undoWriter = new StreamWriter(this.UndoOutputFile.OpenWrite(), this.Encoding); undoScriptApplier = new UndoTemplateBasedApplier( undoWriter, this.Dbms, this.ChangeLogTableName, this.Delimiter, this.DelimiterType, this.TemplateDir); } try { Controller controller = new Controller( changeScriptRepository, databaseSchemaVersionManager, doScriptApplier, undoScriptApplier, this.InfoWriter); controller.ProcessChangeScripts(this.LastChangeToApply); queryExecuter.Close(); } finally { if (doWriter != null) doWriter.Dispose(); if (undoWriter != null) undoWriter.Dispose(); } }
/// <summary> /// Executes the a database deployment with the specified config. /// </summary> /// <param name="config">The config.</param> /// <param name="infoWriter">The info writer.</param> /// <exception cref="System.InvalidOperationException">SQLCMD mode can only be applied against an mssql database.</exception> public void Execute(DbDeployConfig config, TextWriter infoWriter) { this.Validate(config, infoWriter); infoWriter.WriteLine(); infoWriter.WriteLine("=========================================================="); infoWriter.WriteLine(this.GenerateWelcomeString()); var factory = new DbmsFactory(config.Dbms, config.ConnectionString); var dbmsSyntax = factory.CreateDbmsSyntax(); var queryExecuter = new QueryExecuter(factory); var databaseSchemaVersionManager = new DatabaseSchemaVersionManager(queryExecuter, dbmsSyntax, config.ChangeLogTableName); var scanner = new DirectoryScanner(infoWriter, config.Encoding); var changeScriptRepository = new ChangeScriptRepository(scanner.GetChangeScriptsForDirectory(config.ScriptDirectory)); IChangeScriptApplier doScriptApplier; TextWriter doWriter = null; QueryExecuter applierExecutor = null; if (config.OutputFile != null) { doWriter = new StreamWriter(config.OutputFile.OpenWrite(), config.Encoding); doScriptApplier = new TemplateBasedApplier( doWriter, dbmsSyntax, config.ChangeLogTableName, config.Delimiter, config.DelimiterType, config.TemplateDirectory); } else if (config.UseSqlCmd) { // Verify database is MSSQL. if (!string.Equals(config.Dbms, "mssql", StringComparison.InvariantCultureIgnoreCase)) { throw new InvalidOperationException("SQLCMD mode can only be applied against an mssql database."); } doScriptApplier = new SqlCmdApplier( config.ConnectionString, databaseSchemaVersionManager, dbmsSyntax, config.ChangeLogTableName, infoWriter); } else { var splitter = new QueryStatementSplitter { Delimiter = config.Delimiter, DelimiterType = config.DelimiterType, LineEnding = config.LineEnding, }; // Do not share query executor between schema manager and applier, since a failure in one will effect the other. applierExecutor = new QueryExecuter(factory); doScriptApplier = new DirectToDbApplier( applierExecutor, databaseSchemaVersionManager, splitter, dbmsSyntax, config.ChangeLogTableName, infoWriter); } IChangeScriptApplier undoScriptApplier = null; TextWriter undoWriter = null; if (config.UndoOutputFile != null) { undoWriter = new StreamWriter(config.UndoOutputFile.OpenWrite(), config.Encoding); undoScriptApplier = new UndoTemplateBasedApplier( undoWriter, dbmsSyntax, config.ChangeLogTableName, config.Delimiter, config.DelimiterType, config.TemplateDirectory); } try { var controller = new Controller( changeScriptRepository, databaseSchemaVersionManager, doScriptApplier, undoScriptApplier, config.AutoCreateChangeLogTable, infoWriter); controller.ProcessChangeScripts(config.LastChangeToApply, config.ForceUpdate); queryExecuter.Close(); if (applierExecutor != null) { applierExecutor.Close(); } } finally { if (doWriter != null) { doWriter.Dispose(); } if (undoWriter != null) { undoWriter.Dispose(); } } }
protected override void ExecuteTask() { try { using (TextWriter outputPrintStream = this.GetOutputStream(outputfile.FullName)) { TextWriter undoOutputPrintStream = null; if (undoOutputfile != null) undoOutputPrintStream = this.GetOutputStream(undoOutputfile.FullName); DbmsFactory factory = new DbmsFactory(dbType, dbConnection); IDbmsSyntax dbmsSyntax = factory.CreateDbmsSyntax(); DatabaseSchemaVersionManager databaseSchemaVersion = new DatabaseSchemaVersionManager(factory, deltaSet, GetCurrentDbVersion(), changeLogTable); ToPrintStreamDeployer toPrintSteamDeployer = new ToPrintStreamDeployer(databaseSchemaVersion, dir, outputPrintStream, dbmsSyntax, useTransaction, undoOutputPrintStream); toPrintSteamDeployer.DoDeploy(lastChangeToApply); if (undoOutputPrintStream != null) undoOutputPrintStream.Close(); } } catch (DbDeployException ex) { Console.Error.WriteLine(ex.Message); throw new BuildException(ex.Message); } catch (Exception ex) { Console.Error.WriteLine("Failed to apply changes: " + ex); Console.Error.WriteLine("Stack Trace:"); Console.Error.Write(ex.StackTrace); throw new BuildException(ex.Message); } }