public void Gets_Column_Definition()
{
var path = Path.Combine(Environment.CurrentDirectory, "dacServicesTest.dac");
if (File.Exists(path))
{
File.Delete(path);
}
using (TSqlModel model = new TSqlModel(SqlServerVersion.Sql110, new TSqlModelOptions {
}))
{
model.AddObjects("CREATE TABLE t1 (c1 NVARCHAR(30) NOT NULL, id int primary key clustered)", new TSqlObjectOptions());
DacPackageExtensions.BuildPackage(path, model,
new PackageMetadata()
{
Description = "Test Package", Name = "ssss", Version = "1"
});
}
var dac = new DacServices.DacParser(path);
Assert.AreEqual(1, dac.GetTableDefinitions().Count);
var table = dac.GetTableDefinitions().FirstOrDefault();
Assert.AreEqual("c1", table.Columns.FirstOrDefault().Name.Value);
Assert.AreEqual(LiteralType.String, table.Columns.FirstOrDefault().LiteralType);
}
public void Build(string dacpacPath, string packageName, IEnumerable <string> scripts)
{
using (var model = new TSqlModel(SqlServerVersion.Sql110, new TSqlModelOptions {
})) {
// Adding objects to the model.
foreach (string script in scripts)
{
model.AddObjects(script);
}
try {
// save the model to a new .dacpac
// Note that the PackageOptions can be used to specify RefactorLog and contributors to include
DacPackageExtensions.BuildPackage(dacpacPath, model,
new PackageMetadata {
Name = packageName, Description = string.Empty, Version = "1.0"
},
new PackageOptions());
var message = Environment.NewLine +
string.Format(CultureInfo.InvariantCulture, Resources.SqlPublish_PublishDacpacSuccess, dacpacPath) +
Environment.NewLine;
_outputWindow.WriteAsync(MessageCategory.General, message).DoNotWait();
} catch (DacServicesException ex) {
var error = Environment.NewLine +
string.Format(CultureInfo.InvariantCulture, Resources.SqlPublishDialog_UnableToBuildDacPac, ex.Message) +
Environment.NewLine;
_outputWindow.WriteAsync(MessageCategory.Error, error).DoNotWait();
// _coreShell.ShowErrorMessage(error);
}
}
}
protected override void ProcessRecord()
{
string script = string.Empty;
try
{
// create an instance of a tsqmodel to store the sql records
using (TSqlModel model = new TSqlModel(SqlServerVersion.Sql130, new TSqlModelOptions()))
{
// iterate through each file and add the sql script to the model
foreach (string file in System.IO.Directory.GetFiles(FileDirectory, "*.sql", SearchOption.AllDirectories))
{
using (StreamReader sr = new StreamReader(file))
{
script = sr.ReadToEnd();
model.AddObjects(script);
}
}
// build the sql directory and add to the output path
DacPackageExtensions.BuildPackage(
OutputPath,
model,
new PackageMetadata(), // Describes the dacpac.
new PackageOptions()); // Use this to specify the deployment contributors, refactor log to include in package
}
}
catch (Exception ex)
{
WriteWarning(ex.ToString());
WriteWarning(script);
throw (ex);
}
}
public void Sets_KeyColumns_To_Empty_List_When_No_Primary_Key()
{
var path = Path.Combine(Environment.CurrentDirectory, "dacServicesTest.dac");
if (File.Exists(path))
{
File.Delete(path);
}
using (TSqlModel model = new TSqlModel(SqlServerVersion.Sql110, new TSqlModelOptions {
}))
{
model.AddObjects("CREATE TABLE t1 (c1 NVARCHAR(30) NOT NULL, id int)", new TSqlObjectOptions());
DacPackageExtensions.BuildPackage(path, model,
new PackageMetadata()
{
Description = "Test Package", Name = "ssss", Version = "1"
});
}
var dac = new DacServices.DacParser(path);
Assert.AreEqual(1, dac.GetTableDefinitions().Count);
var table = dac.GetTableDefinitions().FirstOrDefault();
Assert.AreEqual(0, table.KeyColumns.Count);
}
public static void GeneratePackage()
{
try
{
//TSqlModel sqlModel = TSqlModel.LoadFromDacpac(@"D:\testdb.dacpac", new ModelLoadOptions());
TSqlModel sqlModel1 = new TSqlModel(SqlServerVersion.Sql150, new TSqlModelOptions());
var files = Directory.GetFiles(@"D:\Visual Studio Projects\DacPacSample\Oracle", "regions.sql", SearchOption.AllDirectories);
foreach (var file in files)
{
var model = new TSqlModel(file, DacSchemaModelStorageType.File);
model.Validate();
}
var messages = sqlModel1.Validate();
foreach (var item in messages)
{
Console.WriteLine(item.Message);
}
DacPackageExtensions.BuildPackage(@"D:\test.dacpac", sqlModel1, new PackageMetadata {
Name = "TestDacPac"
}, new PackageOptions {
TreatWarningsAsErrors = false
});
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
public static void Run()
{
string dacpacPath = "relativePath.dacpac";
// Note that you could read scripts from a file or use TSqlScript objects that are taken from other models.
// Hand-crafting TSqlScript is quite awkard but could be done programmatically (we do it internally).
// If you need examples for this let us know and we can look into that too.
string[] scripts = new[]
{
"CREATE TABLE t1 (c1 NVARCHAR(30) NOT NULL)",
"CREATE TABLE t2 (c2 INT NOT NULL)",
"CREATE TABLE t3 (c3 INT NOT NULL)",
"CREATE TABLE t4 (c4 INT NOT NULL)",
};
using (TSqlModel model = new TSqlModel(SqlServerVersion.Sql110, new TSqlModelOptions {
}))
{
// Adding objects to the model.
foreach (string script in scripts)
{
model.AddObjects(script);
}
ReadTheModel(model);
CopyFromTheModel(model);
// save the model to a new .dacpac
// Note that the PackageOptions can be used to specify RefactorLog and contributors to include
DacPackageExtensions.BuildPackage(
dacpacPath,
model,
new PackageMetadata {
Name = "MyPackageName", Description = "This is usually ignored", Version = "1.0"
},
new PackageOptions()
);
}
// Load from a dacpac
using (TSqlModel modelFromDacpac = new TSqlModel(dacpacPath))
{
// Show that all the elements were saved successfully
ReadTheModel(modelFromDacpac);
// You can update the model in the dacpac. Other parts of a dacpac can't be updated yet (pre/post deployment scripts)
modelFromDacpac.AddObjects("CREATE VIEW V1 AS SELECT * FROM T1");
using (DacPackage dacPackage = DacPackage.Load(dacpacPath,
DacSchemaModelStorageType.Memory,
FileAccess.ReadWrite))
{
DacPackageExtensions.UpdateModel(dacPackage, modelFromDacpac, null);
}
}
Console.WriteLine("Press any key to finish");
Console.ReadKey();
}
private void WriteFinalDacpac(TSqlModel model, string preScript, string postScript)
{
var metadata = new PackageMetadata();
metadata.Name = "dacpac";
DacPackageExtensions.BuildPackage(_targetPath, model, metadata);
AddScripts(preScript, postScript, _targetPath);
}
public void Build()
{
Stopwatch stopwatch = Stopwatch.StartNew();
_log.Info("Build started.");
LoadDacProfile();
if (!Enum.TryParse(_options.SqlServerVersion, out SqlServerVersion sqlServerVersion))
{
sqlServerVersion = SqlServerVersion.Sql150;
}
TSqlModel model = new TSqlModel(sqlServerVersion, new TSqlModelOptions {
});
//model.EngineVersion = _options.EngineVersion;
PackageMetadata meta = new PackageMetadata {
Name = _options.TargetDacVersion,
Version = _options.TargetDacVersion,
};
_log.Info("Loading build files...");
var sqlFiles = _project.GetBuildFiles().ToList();
foreach (var sqlFile in sqlFiles)
{
var sql = File.ReadAllText(sqlFile.PhysicalPath);
model.AddObjects(sql);
}
_log.Info("{0} file(s) added to build queue.", sqlFiles.Count);
using (Stream buffer = GetDacpacStream())
{
_log.Info("Building dacpac...");
DacPackageExtensions.BuildPackage(buffer, model, meta);
buffer.Seek(0, SeekOrigin.Begin);
_log.Success("Dacpac generated ({0}).", _options.GenerateDacPac ? "file" : "in-memory");
if (_options.GenerateScript)
{
GenerateScript(buffer);
}
}
_log.Success("\nBuild complete. Elapsed {0:F3}s.", stopwatch.Elapsed.TotalSeconds);
if (_options.GenerateDacPac)
{
_log.Success(" Dacpac: " + _dacpacFilename ?? "N/A");
}
if (_options.GenerateScript)
{
_log.Success(" Script: " + _scriptFileName ?? "N/A");
}
Environment.ExitCode = 0;
}
public void TestStopDeployment()
{
// Given database name
string dbName = TestContext.TestName;
// Delete any existing artifacts from a previous run
TestUtils.DropDatabase(TestUtils.ServerConnectionString, dbName);
// When deploying using the deployment stopping contributor
try
{
DacDeployOptions options = new DacDeployOptions
{
AdditionalDeploymentContributors = DeploymentStoppingContributor.ContributorId
};
// Deploy initial schema, should pass as no data motion
using (DacPackage dacpac = DacPackage.Load(_dacpacPath, DacSchemaModelStorageType.Memory))
{
DacServices dacServices = new DacServices(TestUtils.ServerConnectionString);
dacServices.Deploy(dacpac, dbName, false, options);
}
// Create schema that will cause data motion by adding column before existing one
using (TSqlModel model = new TSqlModel(SqlServerVersion.Sql110, null))
{
model.AddObjects("CREATE TABLE [dbo].[t1] (motion int NOT NULL, c1 INT NOT NULL PRIMARY KEY)");
DacPackageExtensions.BuildPackage(_dacpacPath, model, new PackageMetadata());
}
// Attempt to deploy and verify it fails as there's now data motion blocking it
using (DacPackage dacpac = DacPackage.Load(_dacpacPath, DacSchemaModelStorageType.Memory))
{
DacServices dacServices = new DacServices(TestUtils.ServerConnectionString);
try
{
dacServices.GenerateDeployScript(dacpac, dbName, options);
Assert.Fail("Expected Deployment to fail and exception to be thrown");
}
catch (DacServicesException expectedException)
{
Assert.IsTrue(expectedException.Message.Contains(DeploymentStoppingContributor.ErrorViaPublishMessage),
"Expected Severity.Error message passed to base.PublishMessage to block deployment");
Assert.IsTrue(expectedException.Message.Contains(DeploymentStoppingContributor.ErrorViaThrownException),
"Expected thrown exception to block deployment");
}
}
}
finally
{
TestUtils.DropDatabase(TestUtils.ServerConnectionString, dbName);
}
}
public void TestIncludePlanFiltererInDacpac()
{
// Given a model with objects that use "dev", "test" and "prod" schemas
// and the contributor information built in
var model = CreateTestModel();
string existingPackagePath = GetTestFilePath("includesContributor.dacpac");
Console.WriteLine("Build dacpac to \n" + existingPackagePath);
DacPackageExtensions.BuildPackage(existingPackagePath, model, new PackageMetadata(), new PackageOptions()
{
DeploymentContributors = new[] { new DeploymentContributorInformation()
{
ExtensionId = PlanFilterer.PlanFiltererContributorId
} }
});
DacServices services = new DacServices("Server=(localdb)\\MSSQLLocalDB;Integrated Security=true;");
// When publishing to production (filtering to exclude "dev" and "test" schemas)
string productionDbName = "ProductionDB";
using (DacPackage package = DacPackage.Load(existingPackagePath, DacSchemaModelStorageType.Memory))
{
DacDeployOptions options = new DacDeployOptions();
// Specify the filter to use and what arguments it needs. Note that this is a little limited by
// having to pass string-based arguments. This could be worked around by serializing arguments to a
// file and passing the file path to the contributor if you need to do anything advanced.
options.AdditionalDeploymentContributorArguments =
PlanFilterer.BuildPlanFiltererArgumentString("SchemaBasedFilter", new Dictionary <string, string>()
{
{ "Schema1", "dev" },
{ "Schema2", "test" },
});
// For test purposes, always create a new database (otherwise previous failures might mess up our result)
options.CreateNewDatabase = true;
// Run the deployment with the options as specified
services.Deploy(package, productionDbName, upgradeExisting: true, options: options);
}
// Then expect only the "prod" schema objects to remain in the new package
// Extract the dacpac back from the database and ensure that only production elements are there
string extractedPackagePath = GetTestFilePath("extracted.dacpac");
services.Extract(extractedPackagePath, productionDbName, "AppName", new Version(1, 0));
var extractedModel = _trash.Add(new TSqlModel(extractedPackagePath, DacSchemaModelStorageType.Memory));
Assert.AreEqual(TopLevelProdElementCount, CountTablesViewsAndSchemas(extractedModel));
AssertAllObjectsHaveSchemaName(extractedModel, "prod");
}
public void InitializeTest()
{
Directory.CreateDirectory(GetTestDir());
_trash = new DisposableList();
_dacpacPath = GetTestFilePath("myDatabase.dacpac");
using (TSqlModel model = new TSqlModel(SqlServerVersion.Sql110, null))
{
model.AddObjects(CreateOneTable);
DacPackageExtensions.BuildPackage(_dacpacPath, model, new PackageMetadata());
}
}
public void InitializeTest()
{
Directory.CreateDirectory(GetTestDir());
_trash = new DisposableList();
_dacpacPath = GetTestFilePath("myDatabase.dacpac");
using (TSqlModel model = new TSqlModel(SqlServerVersion.Sql110, null))
{
model.AddObjects("CREATE TABLE [dbo].[t1] (c1 INT NOT NULL PRIMARY KEY)");
DacPackageExtensions.BuildPackage(_dacpacPath, model, new PackageMetadata());
}
}
public void Save(string fileName)
{
DacPackageExtensions.BuildPackage(fileName, _model, Metadata);
if (_package.PreDeploymentScript != null || _package.PostDeploymentScript != null)
{
using (var package = System.IO.Packaging.Package.Open(fileName, FileMode.Open, FileAccess.ReadWrite))
{
AddScript(package, _package.PreDeploymentScript, "predeploy");
AddScript(package, _package.PostDeploymentScript, "postdeploy");
}
}
}
public void SaveToDisk(FileInfo outputFile, PackageOptions packageOptions = null)
{
// Ensure that the model has been created and metadata has been set
EnsureModelCreated();
EnsureModelValidated();
EnsureMetadataCreated();
// Check if the file already exists
if (outputFile.Exists)
{
// Delete the existing file
Console.WriteLine($"Deleting existing file {outputFile.FullName}");
outputFile.Delete();
}
Console.WriteLine($"Writing model to {outputFile.FullName}");
DacPackageExtensions.BuildPackage(outputFile.FullName, Model, Metadata, packageOptions ?? new PackageOptions { });
}
private void WriteFinalDacpac(TSqlModel model, string preScript, string postScript)
{
var metadata = new PackageMetadata();
metadata.Name = "dacpac";
DacPackageExtensions.BuildPackage(_targetPath, model, metadata);
var writer = new HeaderWriter(_targetPath, new DacHacFactory());
foreach (var customData in _globalHeaders)
{
writer.AddCustomData(customData);
}
writer.Close();
AddScripts(preScript, postScript, _targetPath);
model.Dispose();
}
/// <summary>
/// Runs the model filtering example. This shows how to filter a model and save a new
/// dacpac with the updated model. You can also update the model in the existing dacpac;
/// the unit tests in TestFiltering.cs show how this is performed.
/// </summary>
public static void RunFilteringExample()
{
// Given a model with objects that use "dev", "test" and "prod" schemas
string devPackagePath = GetFilePathInCurrentDirectory("dev.dacpac");
var scripts = SampleScripts;
string productionPackagePath;
using (TSqlModel model = new TSqlModel(SqlServerVersion.Sql110, new TSqlModelOptions()))
{
AddScriptsToModel(model, scripts);
Console.WriteLine("Saving test scripts to package '" + devPackagePath + "'");
DacPackageExtensions.BuildPackage(devPackagePath, model, new PackageMetadata());
Console.WriteLine("Objects found in original package: '" + devPackagePath + "'");
PrintTablesViewsAndSchemas(model);
productionPackagePath = GetFilePathInCurrentDirectory("production.dacpac");
// When saving a dacpac for deployment to production (filtering to exclude "dev" and "test" schemas)
var schemaFilter = new SchemaBasedFilter(model.CollationComparer, new [] { "dev", "test" });
ModelFilterer modelFilterer = new ModelFilterer(schemaFilter);
Console.WriteLine("Creating filtered 'production' package: '" + productionPackagePath + "'");
modelFilterer.CreateFilteredDacpac(devPackagePath, productionPackagePath);
}
// Then expect only the "prod" schema objects to remain in the new package
using (TSqlModel filteredModel = new TSqlModel(productionPackagePath))
{
Console.WriteLine("Objects found in filtered package: '" + productionPackagePath + "'");
PrintTablesViewsAndSchemas(filteredModel);
}
// If we publish the dacpac to a database, we can see that only the production schema is
// present (debug into this method or view the console output listing only production elements)
PublishProductionDacpacAndVerifyContents(productionPackagePath);
}
public void Run()
{
TSqlModel tm01 = new TSqlModel(folderPath01 + file01);
TSqlModel newModel = new TSqlModel(tm01.Version, tm01.CopyModelOptions());
List <TSqlObject> objs = tm01.GetObjects(DacQueryScopes.UserDefined).ToList();
List <TSqlObject> delt = new List <TSqlObject>();
foreach (var r in objs.Where(x => x.ObjectType.Name == "Schema"))
{
delt.Add(r);
AddChildren(r, delt);
}
objs.RemoveAll(z => delt.Contains(z));
foreach (TSqlObject o in objs.Where(z => !delt.Contains(z)))
{
if (o.TryGetScript(out string s))
{
newModel.AddObjects(s);
}
}
PackageMetadata m = new PackageMetadata()
{
Name = "Nazwa",
Version = "1.0",
Description = ""
};
DacPackageExtensions.BuildPackage
(
@"C:\Users\XTOKO\Desktop\NewDacpacSchemaFilter.dacpac"
, newModel
, m
);
Console.WriteLine("==> koniec");
Console.ReadLine();
}
/// <summary>
/// Builds a dacpac and returns the path to that dacpac.
/// If the file already exists it will be deleted
/// </summary>
private string BuildDacpacFromModel(TSqlModel model)
{
string path = this.DacpacPath;
Assert.IsFalse(string.IsNullOrWhiteSpace(this.DacpacPath), "DacpacPath must be set if target for analysis is a Dacpac");
if (File.Exists(path))
{
File.Delete(path);
}
string dacpacDir = Path.GetDirectoryName(path);
if (!Directory.Exists(dacpacDir))
{
Directory.CreateDirectory(dacpacDir);
}
DacPackageExtensions.BuildPackage(path, model, new PackageMetadata());
return(path);
}
public static void Run()
{
Directory.CreateDirectory(GetTestDir(_ModelCompareDacsPath));
Directory.CreateDirectory(GetTestDir(_compareResultsPath));
_sourceDacpacPath = GetTestFilePath(_ModelCompareDacsPath, "sourceDatabase.dacpac");
DacPackageExtensions.BuildPackage(_sourceDacpacPath, CreateTestModel(_testSourceScripts), new PackageMetadata());
_destinationDacPacPath = GetTestFilePath(_ModelCompareDacsPath, "destinationDatabase.dacpac");
DacPackageExtensions.BuildPackage(_destinationDacPacPath, CreateTestModel(_testDestinationScripts), new PackageMetadata());
using (TSqlModel sourcemodel = new TSqlModel(_sourceDacpacPath),
destmodel = new TSqlModel(_destinationDacPacPath))
{
// Filtering to exclude log schema
var schemaFilter = new SchemaBasedFilter("log");
ModelFilterer modelFilterer = new ModelFilterer(schemaFilter);
TSqlModel smodel = modelFilterer.CreateFilteredModel(sourcemodel);
TSqlModel dmodel = modelFilterer.CreateFilteredModel(destmodel);
CompareTSqlModels(smodel, dmodel);
}
}
private static void Build(string projectPath, string outputPath, SqlServerVersion targetVersion)
{
var outputFilePath = EnusreOutputPath(projectPath, outputPath);
IEnumerable <string> dbFiles = GetInputFiles(projectPath);
var sqlModel = new TSqlModel(targetVersion, new TSqlModelOptions()
{
});
foreach (var scriptFile in dbFiles)
{
Console.WriteLine($"Loading file into model: {scriptFile}");
var script = File.ReadAllText(scriptFile);
sqlModel.AddObjects(script);
}
Console.WriteLine($"Building Dac Package to {outputFilePath}");
DacPackageExtensions.BuildPackage(outputFilePath, sqlModel, new PackageMetadata()
{
});
}
public bool Write(TSqlModel model)
{
try
{
var dummyModel = BuildInitialEmptyModel();
DacPackageExtensions.BuildPackage(_outputPath, dummyModel, new PackageMetadata());
AddReferences();
AddPrePostScripts();
WriteFinalDacpac(model);
}
catch (Exception e)
{
Console.WriteLine(e);
return(false);
}
return(true);
}
/// <summary>
/// Creates a new dacpac based on the filtered model. This implementation loads from and saves to
/// disk, but the API supports loading from and saving to a memory stream. This can be useful if you
/// want to support a scenario where you load a dacpac, filter its model, then immediately deploy the filtered
/// model to a database.
/// </summary>
public void CreateFilteredDacpac(string dacpacPath, string filteredDacpacPath)
{
DisposableList disposables = new DisposableList();
try
{
TSqlModel model = disposables.Add(new TSqlModel(dacpacPath, DacSchemaModelStorageType.Memory));
TSqlModel filteredModel = disposables.Add(CreateFilteredModel(model));
DacPackageExtensions.BuildPackage(
filteredDacpacPath,
filteredModel,
new PackageMetadata(), // Describes the dacpac.
new PackageOptions()); // Use this to specify the deployment contributors, refactor log to include in package
}
finally
{
// Models and DacPackage objects are disposable - either use a "using" statement or dispose of them in a finally block.
// In these examples we'd end up with a large amount of indentation and to avoid that I'm using a try/finally block.
disposables.Dispose();
}
}
public void Build(string dacpacPath, string packageName, IEnumerable <string> scripts)
{
using (var model = new TSqlModel(SqlServerVersion.Sql130, new TSqlModelOptions {
})) {
// Adding objects to the model.
foreach (string script in scripts)
{
model.AddObjects(script);
}
try {
// save the model to a new .dacpac
// Note that the PackageOptions can be used to specify RefactorLog and contributors to include
DacPackageExtensions.BuildPackage(dacpacPath, model,
new PackageMetadata {
Name = packageName, Description = string.Empty, Version = "1.0"
},
new PackageOptions());
} catch (DacServicesException ex) {
throw new SqlPublishException(ex.Message);
}
}
}
/// <summary>
/// Runs the model filtering example. This shows how to filter a model and save a new
/// dacpac with the updated model. You can also update the model in the existing dacpac;
/// the unit tests in TestFiltering.cs show how this is performed.
/// </summary>
public static void RunAnalysisExample()
{
// Given a model with objects that use "dev", "test" and "prod" schemas
string scaPackagePath = GetFilePathInCurrentDirectory("sca.dacpac");
string scriptAnalysisPath = GetFilePathInCurrentDirectory("scriptResults.xml");
string dacpacAnalysisPath = GetFilePathInCurrentDirectory("dacpacResults.xml");
string dbAnalysisPath = GetFilePathInCurrentDirectory("databaseResults.xml");
var scripts = SampleScripts;
using (TSqlModel model = new TSqlModel(SqlServerVersion.Sql120, new TSqlModelOptions()))
{
AddScriptsToModel(model, scripts);
// Analyze scripted model
RunAnalysis(model, scriptAnalysisPath);
// Save dacpac to
Console.WriteLine("Saving scripts to package '" + scaPackagePath + "'");
DacPackageExtensions.BuildPackage(scaPackagePath, model, new PackageMetadata());
}
RunDacpacAnalysis(scaPackagePath, dacpacAnalysisPath);
RunAnalysisAgainstDatabase(scaPackagePath, dbAnalysisPath);
}
static void BuildDac(string dacpacPath, DacPacVersion dacpacVersion)
{
Console.WriteLine("\n------- Building DacPac -------");
if (mySQLScripts.Scripts.Count >= 0)
{
// Figure out which version we want to build.
Microsoft.SqlServer.Dac.Model.SqlServerVersion modelVersion;
switch (dacpacVersion)
{
case DacPacVersion.SQL2012:
modelVersion = Microsoft.SqlServer.Dac.Model.SqlServerVersion.Sql110;
break;
case DacPacVersion.SQL2014:
modelVersion = Microsoft.SqlServer.Dac.Model.SqlServerVersion.Sql120;
break;
case DacPacVersion.SQL2016:
modelVersion = Microsoft.SqlServer.Dac.Model.SqlServerVersion.Sql130;
break;
default:
modelVersion = Microsoft.SqlServer.Dac.Model.SqlServerVersion.Sql110;
break;
}
using (TSqlModel model = new TSqlModel(modelVersion, new TSqlModelOptions {
}))
{
foreach (string SQLScript in mySQLScripts.Scripts)
{
// Add it to the model
model.AddObjects(SQLScript);
}
// Now write the model
try
{
DacPackageExtensions.BuildPackage(
dacpacPath,
model,
new PackageMetadata {
Name = "Mini_DacPac", Description = "Built by DacMini.", Version = "1.0"
},
new PackageOptions()
);
Console.WriteLine("DAC package created.");
}
catch (Microsoft.SqlServer.Dac.DacServicesException e)
{
Console.WriteLine("DAC creation failed:");
Console.WriteLine("Error: " + e.Message);
}
catch (Exception e)
{
Console.WriteLine("DAC creation may have failed:");
Console.WriteLine("Error: " + e.Message);
}
}
}
else
{
Console.WriteLine("Warning - No scripts were found to package into DacPac.");
}
}
private void BuildPackage(TSqlModel model, string path)
{
DacPackageExtensions.BuildPackage(path, model, new PackageMetadata());
}
