public void DbDebployCanExecuteEmbeddedScripts()
{
var assembly = Assembly.LoadFrom("Test.Net.Sf.DbDeploy.EmbeddedScripts.dll");
using (var tw = File.CreateText("database_" + DateTime.Now.ToString("yyyy-MM-dd_hh-mm-ss") + ".txt"))
{
var dbDeployer = new DbDeployer();
var config = new DbDeployConfig
{
ConnectionString = ConnectionString,
Dbms = SupportedDbms.MSSQL,
Delimiter = "GO",
ScriptDirectory = null,
ScriptAssemblies = new List <Assembly> {
assembly
},
DelimiterType = Parser.ParseDelimiterType("row"),
UseSqlCmd = false,
AssemblyResourceNameFilter = resourceName => resourceName.Contains("db.MsSql.")
};
dbDeployer.Execute(config, tw);
}
AssertTableExists(ChangeLogTableName);
AssertTableExists("Customer");
}
protected override void ProcessRecord()
{
var configurationFile = this.ToAbsolutePath(ConfigurationFile);
this.deltasDirectory = this.ToAbsolutePath(DeltasDirectory);
if (!string.IsNullOrEmpty(configurationFile) && File.Exists(configurationFile))
{
var configurationManager = new DbDeployConfigurationManager();
this.config = configurationManager.ReadConfiguration(configurationFile).Deployments.FirstOrDefault();
if (string.IsNullOrEmpty(this.DatabaseType) || this.DatabaseType == DbDeployDefaults.Dbms)
{
this.DatabaseType = this.config.Dbms;
}
if (string.IsNullOrEmpty(this.ConnectionString))
{
this.ConnectionString = this.config.ConnectionString;
}
if (string.IsNullOrEmpty(this.TableName) || this.TableName == DbDeployDefaults.ChangeLogTableName)
{
this.TableName = this.config.ChangeLogTableName;
}
}
if (string.IsNullOrEmpty(this.ConnectionString))
{
throw new InvalidDataException(
"Missing connection string. It must either be in the config file or passed as a parameter");
}
}
/// <summary>
/// Validates the specified config.
/// </summary>
/// <param name="config">The config.</param>
/// <param name="infoWriter">The info writer.</param>
/// <exception cref="UsageException">Script directory must point to a valid directory</exception>
private void Validate(DbDeployConfig config, TextWriter infoWriter)
{
this.CheckForRequiredParameter(config.Dbms, "dbms");
this.CheckForRequiredParameter(config.ConnectionString, "connectionString");
this.CheckForRequiredParameter(config.ScriptDirectory, "dir");
this.CheckForRequiredParameter(infoWriter, "infoWriter");
if (config.ScriptDirectory == null || !config.ScriptDirectory.Exists)
{
throw new UsageException(string.Format("The directory '{0}' does not exist.\nScript directory must point to a valid directory", config.ScriptDirectory));
}
}
public void SetUp()
{
EnsureTableDoesNotExist(ChangeLogTableName);
EnsureTableDoesNotExist("Product");
EnsureTableDoesNotExist("Customer");
EnsureTableDoesNotExist("Teste");
EnsureTableDoesNotExist("Teste2");
EnsureTableDoesNotExist("tabelaTeste");
dbDeployConfig = new DbDeployConfig {
ConnectionString = @"Server=.\SQLEXPRESS;Initial Catalog=dbdeploy;User Id=sa;Password=sa"
};
executorScriptsIndividuais = new ExecutorScriptsIndividuais(dbDeployConfig, new StringWriter());
}
public void retornar_change_script_repository()
{
var dbDeployConfig = new DbDeployConfig
{
ScriptDirectory = new List <DirectoryInfo> {
new DirectoryInfo(@"Mocks\Versioned")
},
};
var changeScriptRepositoryFactory = new ChangeScriptRepositoryFactory(dbDeployConfig, new StringWriter());
var changeScriptRepository = changeScriptRepositoryFactory.Obter();
changeScriptRepository.Should().NotBeNull();
changeScriptRepository.Should().BeOfType <ChangeScriptRepository>();
}
protected override void ProcessRecord()
{
base.ProcessRecord();
var config = new DbDeployConfig
{
Dbms = DatabaseType,
ConnectionString = ConnectionString,
ChangeLogTableName = TableName,
ScriptDirectory = Parser.ParseDirectory(deltasDirectory),
};
var deployer = new DbDeployer();
deployer.Execute(config, new LambdaTextWriter(WriteVerbose));
}
/// <summary>
/// Validates the specified config.
/// </summary>
/// <param name="config">The config.</param>
/// <param name="infoWriter">The info writer.</param>
/// <exception cref="UsageException">Script directory must point to a valid directory</exception>
private void Validate(DbDeployConfig config, TextWriter infoWriter)
{
this.CheckForRequiredParameter(config.Dbms, "dbms");
this.CheckForRequiredParameter(config.ConnectionString, "connectionString");
this.CheckForRequiredParameter(infoWriter, "infoWriter");
if (config.ScriptAssemblies == null)
{
this.CheckForRequiredParameter(config.ScriptDirectory, "dir");
}
if (config.ScriptDirectory == null)
{
this.CheckForRequiredParameter(config.ScriptAssemblies, "assembly");
}
}
public void LineEndingWorksOk()
{
var config = new DbDeployConfig();
Assert.AreEqual(DbDeployDefaults.LineEnding, config.LineEnding);
config = OptionsManager.ParseOptions("--lineending cr".Split(' ')).Deployments.First();
Assert.AreEqual(LineEnding.Cr, config.LineEnding);
config = OptionsManager.ParseOptions("--lineending crlf".Split(' ')).Deployments.First();
Assert.AreEqual(LineEnding.CrLf, config.LineEnding);
config = OptionsManager.ParseOptions("--lineending lf".Split(' ')).Deployments.First();
Assert.AreEqual(LineEnding.Lf, config.LineEnding);
config = OptionsManager.ParseOptions("--lineending platform".Split(' ')).Deployments.First();
Assert.AreEqual(LineEnding.Platform, config.LineEnding);
}
public void buscar_scripts_dos_diretorios()
{
var dbDeployConfig = new DbDeployConfig
{
ScriptDirectory = new List <DirectoryInfo> {
new DirectoryInfo(@"Mocks\Versioned")
},
};
var changeScriptRepositoryFactory = new ChangeScriptRepositoryFactory(dbDeployConfig, new StringWriter());
var changeScriptRepository = changeScriptRepositoryFactory.Obter();
var availableChangeScripts = changeScriptRepository.GetAvailableChangeScripts();
availableChangeScripts.Should().NotBeEmpty();
availableChangeScripts.Count.Should().BeGreaterOrEqualTo(6);
availableChangeScripts.Should().Contain(x => x.ScriptName == "10.Add Sold Column.sql" && x.Folder == "2.0.0.0");
availableChangeScripts.Should().Contain(x => x.ScriptName == "2.SQLCMD Add Email Column Table.sql" && x.Folder == "v2.0.10.0");
}
/// <summary>
/// Parses the specified args into a deployments configuration.
/// </summary>
/// <param name="args">The args.</param>
/// <returns>
/// Configuration set.
/// </returns>
/// <exception cref="UsageException">Throws when unknown or invalid parameters are found.</exception>
public static DbDeploymentsConfig ParseOptions(string[] args)
{
// Initialize configuration with a single deployment.
var deploymentsConfig = new DbDeploymentsConfig();
try
{
var configFile = new ConfigFileInfo();
var config = new DbDeployConfig();
OptionSet options = Initialize(config, configFile);
deploymentsConfig.Deployments.Add(config);
List <string> unknown = options.Parse(args);
if (unknown != null && unknown.Count != 0)
{
foreach (var s in unknown)
{
// empty "unkown" parameters are allowed
if (s != null && !string.IsNullOrEmpty(s.Trim()))
{
throw new UsageException("Unkown parameter(s): " + string.Join(", ", unknown.ToArray()));
}
}
}
// If a configuration file was specified in the command, use that instead of options.
if (configFile.FileInfo != null)
{
var configurationManager = new DbDeployConfigurationManager();
deploymentsConfig = configurationManager.ReadConfiguration(configFile.FileInfo.FullName);
}
}
catch (OptionException e)
{
throw new UsageException(e.Message, e);
}
return(deploymentsConfig);
}
public void DbDebployCanExecuteDirectoryScripts()
{
using (var tw = File.CreateText("database_" + DateTime.Now.ToString("yyyy-MM-dd_hh-mm-ss") + ".txt"))
{
var dbDeployer = new DbDeployer();
var config = new DbDeployConfig
{
ConnectionString = ConnectionString,
Dbms = SupportedDbms.MSSQL,
Delimiter = "GO",
ScriptDirectory = new List <DirectoryInfo> {
new DirectoryInfo(@"Mocks\Versioned\2.0.0.0")
},
DelimiterType = Parser.ParseDelimiterType("row"),
UseSqlCmd = false
};
dbDeployer.Execute(config, tw);
}
AssertTableExists(ChangeLogTableName);
AssertTableExists("Product");
}
protected override void ProcessRecord()
{
base.ProcessRecord();
if (string.IsNullOrEmpty(this.OutputFile))
{
this.WriteError(new ErrorRecord(new PSInvalidOperationException(
"Missing a file for output"),
"NoOutputFile",
ErrorCategory.MetadataError,
null));
return;
}
var config = new DbDeployConfig
{
Dbms = this.DatabaseType,
ConnectionString = this.ConnectionString,
ChangeLogTableName = this.TableName,
ScriptDirectory = new DirectoryInfo(this.deltasDirectory),
AutoCreateChangeLogTable = this.AutoCreateChangeLogTable,
ForceUpdate = this.ForceUpdate,
UseSqlCmd = this.UseSqlCmd,
OutputFile = new FileInfo(this.ToAbsolutePath(this.OutputFile))
};
if (!string.IsNullOrEmpty(this.UndoOutputFile))
{
config.OutputFile = new FileInfo(this.ToAbsolutePath(UndoOutputFile));
}
var deployer = new DbDeployer();
deployer.Execute(config, new LambdaTextWriter(WriteVerbose));
}
public ChangeScriptRepositoryFactory(DbDeployConfig dbDeployConfig, TextWriter infoWriter)
{
this.dbDeployConfig = dbDeployConfig;
this.infoWriter = infoWriter;
}
public NAntTask()
{
this.config = new DbDeployConfig();
}
/// <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();
}
}
}
/// <summary>
/// Validates the specified config.
/// </summary>
/// <param name="config">The config.</param>
/// <param name="infoWriter">The info writer.</param>
/// <exception cref="UsageException">Script directory must point to a valid directory</exception>
private void Validate(DbDeployConfig config, TextWriter infoWriter)
{
this.CheckForRequiredParameter(config.Dbms, "dbms");
this.CheckForRequiredParameter(config.ConnectionString, "connectionString");
this.CheckForRequiredParameter(infoWriter, "infoWriter");
if (config.ScriptAssemblies == null)
{
this.CheckForRequiredParameter(config.ScriptDirectory, "dir");
}
if (config.ScriptDirectory == null)
{
this.CheckForRequiredParameter(config.ScriptAssemblies, "assembly");
}
}
/// <summary>
/// Initializes the specified config.
/// </summary>
/// <param name="config">The config.</param>
/// <param name="configFile">The config file to read if found.</param>
/// <returns>
/// Option set for the config.
/// </returns>
private static OptionSet Initialize(DbDeployConfig config, ConfigFileInfo configFile)
{
var options = new OptionSet();
options
.Add(
"d|dbms=",
"DBMS type ('mssql', 'mysql', 'ora', 'firebird' or 'postgre')",
s => config.Dbms = s)
.Add(
"c|connectionstring=",
"connection string for database",
s => config.ConnectionString = StripQuotes(s))
.Add(
"s|scriptdirectory=",
"directory containing change scripts (default: .)",
s => config.ScriptDirectory = Parser.ParseDirectory(StripQuotes(s)))
.Add(
"o|outputfile=",
"output file",
s => config.OutputFile = new FileInfo(StripQuotes(s)))
.Add(
"an|assembly=",
"script assembly fullname",
s => config.ScriptAssemblies = Parser.ParseAssembly(StripQuotes(s)))
.Add(
"fbn|filterbyname=",
"filter assembly resource by name",
s => config.AssemblyResourceNameFilter = Parser.ParseAssemblyFilterByName(StripQuotes(s)))
.Add(
"t|changelogtablename=",
"name of change log table to use (default: ChangeLog)",
s => config.ChangeLogTableName = StripQuotes(s))
.Add(
"a|autocreatechangelogtable=",
"automatically creates the change log table if it does not exist (true or false). Defaults to true.",
s => config.AutoCreateChangeLogTable = s.ToLowerInvariant() != "false")
.Add(
"f|forceupdate=",
"forces previously failed scripts to be run again (true or false). Defaults to false.",
s => config.ForceUpdate = s.ToLowerInvariant() == "true")
.Add(
"u|usesqlcmd=",
"runs scripts in SQLCMD mode (true or false). Defaults to false.",
s => config.UseSqlCmd = s.ToLowerInvariant() == "true")
.Add(
"l|lastchangetoapply=",
"sets the last change to apply in the form of folder/scriptnumber (v1.0.0/4).",
s => config.LastChangeToApply = !string.IsNullOrWhiteSpace(s) ? new UniqueChange(s) : null)
.Add(
"e|encoding=",
"encoding for input and output files (default: UTF-8)",
s => config.Encoding = new OutputFileEncoding(StripQuotes(s)).AsEncoding())
.Add(
"templatedirectory=",
"template directory",
s => config.TemplateDirectory = new DirectoryInfo(StripQuotes(s)))
.Add(
"delimiter=",
"delimiter to separate sql statements",
s => config.Delimiter = s)
.Add(
"delimitertype=",
"delimiter type to separate sql statements (row or normal)",
s => config.DelimiterType = Parser.ParseDelimiterType(s))
.Add(
"lineending=",
"line ending to use when applying scripts direct to db (platform, cr, crlf, lf)",
s => config.LineEnding = Parser.ParseLineEnding(s))
.Add(
"config=",
"configuration file to use for all settings.",
s => configFile.FileInfo = !string.IsNullOrWhiteSpace(s) ? new FileInfo(StripQuotes(s)) : null)
.Add(
"dllPathConnector=",
"Database Connector Dll Path",
s => config.DllPathConnector = s
);
return(options);
}
public ExecutorScriptsIndividuais(DbDeployConfig dbDeployConfig, TextWriter textWriter)
{
this.dbDeployConfig = dbDeployConfig;
this.textWriter = textWriter;
}
public Dbdeploy()
{
this.config = new DbDeployConfig();
}
/// <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, config.DllPathConnector);
var dbmsSyntax = factory.CreateDbmsSyntax();
var queryExecuter = new QueryExecuter(factory);
var databaseSchemaVersionManager = new DatabaseSchemaVersionManager(queryExecuter, dbmsSyntax, config.ChangeLogTableName);
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, SupportedDbms.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 changeScriptRepositoryFactory = new ChangeScriptRepositoryFactory(config, infoWriter);
var changeScriptRepository = changeScriptRepositoryFactory.Obter();
var repositorioScripts = new RepositorioScripts(databaseSchemaVersionManager, changeScriptRepository);
var controller = new Controller(
repositorioScripts,
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();
}
}
}
