protected override void ProcessRecord()
{
base.ProcessRecord();
var infoTextWriter = new LambdaTextWriter(WriteVerbose);
List <ChangeScript> allChangeScripts = new DirectoryScanner(infoTextWriter, Encoding.UTF8)
.GetChangeScriptsForDirectory(new DirectoryInfo(this.deltasDirectory));
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, true);
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);
}
private void RunIntegratedTestAndConfirmOutputResults(string syntaxName, DirectoryInfo templateDirectory)
{
StringWriter writer = new StringWriter();
ChangeScript changeOne = new StubChangeScript(1, "001_change.sql", "-- contents of change script 1");
ChangeScript changeTwo = new StubChangeScript(2, "002_change.sql", "-- contents of change script 2");
List <ChangeScript> changeScripts = new List <ChangeScript> {
changeOne, changeTwo
};
ChangeScriptRepository changeScriptRepository = new ChangeScriptRepository(changeScripts);
var factory = new DbmsFactory(syntaxName, string.Empty);
StubSchemaManager schemaManager = new StubSchemaManager(factory.CreateDbmsSyntax());
IChangeScriptApplier applier = new TemplateBasedApplier(writer, syntaxName, "ChangeLog", ";", new NormalDelimiter(), templateDirectory);
Controller controller = new Controller(changeScriptRepository, schemaManager, applier, null, System.Console.Out);
controller.ProcessChangeScripts(null);
var actual = writer.ToString();
try
{
Assert.AreEqual(this.ReadExpectedFileContents(this.GetExpectedFilename(syntaxName)), actual);
}
catch (Exception)
{
// Output actual template on failure.
Console.WriteLine("\n\nActual Template ({0}):", syntaxName);
Console.WriteLine(actual);
throw;
}
}
private void GenerateUndoChangeScripts(ChangeScriptRepository repository, Int64 lastChangeToApply, List <Int64> appliedChanges)
{
ChangeScriptExecuter undoScriptExecuter = new ChangeScriptExecuter(undoOutputPrintStream, dbmsSyntax, useTransaction);
Controller undoController = new Controller(schemaManager, repository, undoScriptExecuter);
undoController.ProcessUndoChangeScripts(lastChangeToApply, appliedChanges);
undoOutputPrintStream.Flush();
}
public Controller(DatabaseSchemaVersionManager schemaManager,
ChangeScriptRepository changeScriptRepository,
ChangeScriptExecuter changeScriptExecuter)
{
this.schemaManager = schemaManager;
this.changeScriptRepository = changeScriptRepository;
this.changeScriptExecuter = changeScriptExecuter;
}
private void RunIntegratedTestAndConfirmOutputResults(string syntaxName, DirectoryInfo templateDirectory)
{
var writer = new StringWriter();
var listReplaces = new List<string>() { "$script.Guid", "$script.Folder", "$script.ScriptNumber", "$script.ScriptName" };
var listExpecteds = new List<string>()
{
"START CHANGE SCRIPT v1.0/001_change.sql",
"END CHANGE SCRIPT v1.0/001_change.sql",
"START CHANGE SCRIPT v1.0/002_change.sql",
"END CHANGE SCRIPT v1.0/002_change.sql",
"INSERT INTO ChangeLog (ChangeId, Folder, ScriptNumber, ScriptName, StartDate, AppliedBy, ScriptStatus, ScriptOutput)",
"UPDATE ChangeLog"
};
ChangeScript changeOne = new StubChangeScript(1, "001_change.sql", "-- contents of change script 1");
ChangeScript changeTwo = new StubChangeScript(2, "002_change.sql", "-- contents of change script 2");
var changeScripts = new List<ChangeScript> { changeOne, changeTwo };
var changeScriptRepository = new ChangeScriptRepository(changeScripts);
var factory = new DbmsFactory(syntaxName, string.Empty);
var dbmsSyntax = factory.CreateDbmsSyntax();
const bool createChangeLogTable = false;
var schemaManager = new StubSchemaManager(dbmsSyntax, createChangeLogTable);
IChangeScriptApplier applier = new TemplateBasedApplier(writer, dbmsSyntax, "ChangeLog", ";", new NormalDelimiter(), templateDirectory);
var controller = new Controller(new RepositorioScripts(schemaManager,changeScriptRepository), schemaManager, applier, null, createChangeLogTable, Console.Out);
controller.ProcessChangeScripts(null);
var actual = writer.ToString();
try
{
var expected = ReadExpectedFileContents(GetExpectedFilename(syntaxName));
foreach (var currentExpected in listExpecteds)
{
expected.Should().Contain(currentExpected, string.Format("The expected script does not contain {0}", currentExpected));
}
foreach (var replace in listReplaces)
{
if (actual.Contains(replace))
Assert.Fail("A regex from template does not were replaced. \n\rRegex: {0} ", replace);
}
}
catch (Exception)
{
// Output actual template on failure.
Console.WriteLine("\n\nActual Template ({0}):", syntaxName);
Console.WriteLine(actual);
throw;
}
}
public void DoDeploy(Int64 lastChangeToApply)
{
Console.Out.WriteLine("dbdeploy v2.12");
List <ChangeScript> changeScripts = new DirectoryScanner().GetChangeScriptsForDirectory(dir);
ChangeScriptRepository repository = new ChangeScriptRepository(changeScripts);
List <Int64> appliedChanges = schemaManager.GetAppliedChangeNumbers();
GenerateChangeScripts(repository, lastChangeToApply, appliedChanges);
if (undoOutputPrintStream != null)
{
GenerateUndoChangeScripts(repository, lastChangeToApply, appliedChanges);
}
}
/// <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, config.AutoCreateChangeLogTable);
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,
config.Dbms,
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, 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,
infoWriter);
}
IChangeScriptApplier undoScriptApplier = null;
TextWriter undoWriter = null;
if (config.UndoOutputFile != null)
{
undoWriter = new StreamWriter(config.UndoOutputFile.OpenWrite(), config.Encoding);
undoScriptApplier = new UndoTemplateBasedApplier(
undoWriter,
config.Dbms,
config.ChangeLogTableName,
config.Delimiter,
config.DelimiterType,
config.TemplateDirectory);
}
try
{
var controller = new Controller(
changeScriptRepository,
databaseSchemaVersionManager,
doScriptApplier,
undoScriptApplier,
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();
}
}
}
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();
}
}
}
private void RunIntegratedTestAndConfirmOutputResults(string syntaxName, DirectoryInfo templateDirectory)
{
var writer = new StringWriter();
var listReplaces = new List <string>()
{
"$script.Guid", "$script.Folder", "$script.ScriptNumber", "$script.ScriptName"
};
var listExpecteds = new List <string>()
{
"START CHANGE SCRIPT v1.0/001_change.sql",
"END CHANGE SCRIPT v1.0/001_change.sql",
"START CHANGE SCRIPT v1.0/002_change.sql",
"END CHANGE SCRIPT v1.0/002_change.sql",
"INSERT INTO ChangeLog (ChangeId, Folder, ScriptNumber, ScriptName, StartDate, AppliedBy, ScriptStatus, ScriptOutput)",
"UPDATE ChangeLog"
};
ChangeScript changeOne = new StubChangeScript(1, "001_change.sql", "-- contents of change script 1");
ChangeScript changeTwo = new StubChangeScript(2, "002_change.sql", "-- contents of change script 2");
var changeScripts = new List <ChangeScript> {
changeOne, changeTwo
};
var changeScriptRepository = new ChangeScriptRepository(changeScripts);
var factory = new DbmsFactory(syntaxName, string.Empty);
var dbmsSyntax = factory.CreateDbmsSyntax();
const bool createChangeLogTable = false;
var schemaManager = new StubSchemaManager(dbmsSyntax, createChangeLogTable);
IChangeScriptApplier applier = new TemplateBasedApplier(writer, dbmsSyntax, "ChangeLog", ";", new NormalDelimiter(), templateDirectory);
var controller = new Controller(new RepositorioScripts(schemaManager, changeScriptRepository), schemaManager, applier, null, createChangeLogTable, Console.Out);
controller.ProcessChangeScripts(null);
var actual = writer.ToString();
try
{
var expected = ReadExpectedFileContents(GetExpectedFilename(syntaxName));
foreach (var currentExpected in listExpecteds)
{
expected.Should().Contain(currentExpected, string.Format("The expected script does not contain {0}", currentExpected));
}
foreach (var replace in listReplaces)
{
if (actual.Contains(replace))
{
Assert.Fail("A regex from template does not were replaced. \n\rRegex: {0} ", replace);
}
}
}
catch (Exception)
{
// Output actual template on failure.
Console.WriteLine("\n\nActual Template ({0}):", syntaxName);
Console.WriteLine(actual);
throw;
}
}
