Continuing my theme of building various types of packages in code, this example shows how to building a package with package configurations. Incidentally it shows you how to add a variable, and a connection too. It covers
the five most common configurations: Configuration File Indirect Configuration File SQL Server Indirect SQL Server Environment Variable For a general overview try
the SQL Server Books Online Package Configurations topic.
The sample uses a a simple helper function ApplyConfig to create or update a configuration, although in
the example we will only
ever create.
The most useful knowledge is
the configuration string (Configuration.ConfigurationString) that you need to set. Configuration Type Configuration String Description Configuration File
The full path and file name of an XML configuration file.
The file can contain one or more configuration and includes
the target path and new value to set. Indirect Configuration File An environment variable
the value of which contains full path and file name of an XML configuration file as per
the Configuration File type described above. SQL Server A three part configuration string, with each part being quote delimited and separated by a semi-colon. --
The first part is
the connection manager name.
The connection tells you which server and database to look for
the configuration table. --
The second part is
the name of
the configuration table.
The table is of a standard format, use
the Package Configuration Wizard to help create an example, or see
the sample script files below.
The table contains one or more rows or configuration items each with a target path and new value. --
The third and final part is
the optional filter name. A configuration table can contain multiple configurations, and
the filter is literal value that can be used to group items together and act as a filter clause when configurations are being read. If you do not need a filter, just leave
the value empty. Indirect SQL Server An environment variable
the value of which is
the three part configuration string as per
the SQL Server type described above. Environment Variable An environment variable
the value of which is
the value to set in
the package. This is slightly different to
the other examples as
the configuration definition in
the package also includes
the target information. In our ApplyConfig function this is
the only example that actually supplies a target value for
the Configuration.PackagePath property.
The path is an XPath style path for
the target property, \Package.Variables[User::Variable].Properties[Value],
the equivalent of which can be seen in
the screenshot below, with
the object being our variable called Variable, and
the property to set is
the Value property of that variable object.
The configurations as seen when opening
the generated package in BIDS:
The sample code creates
the package, adds a variable and connection manager, enables configurations, and then adds our example configurations.
The package is then saved to disk, useful for checking
the package and testing, before finally executing, just to prove it is valid. There are some external resources used here, namely some environment variables and a table, see below for more details. namespace Konesans.Dts.Samples
{
using System;
using Microsoft.SqlServer.Dts.Runtime;
public class PackageConfigurations
{
public void CreatePackage()
{
// Create a new package
Package package = new Package();
package.Name = "ConfigurationSample";
// Add a variable,
the target for our configurations
package.Variables.Add("Variable", false, "User", 0);
// Add a connection, for SQL configurations
// Add
the SQL OLE-DB connection
ConnectionManager connectionManagerOleDb = package.Connections.Add("OLEDB");
connectionManagerOleDb.Name = "SQLConnection";
connectionManagerOleDb.ConnectionString =
"Provider=SQLOLEDB.1;Data Source=(local);Initial Catalog=master;Integrated Security=SSPI;";
// Add our example configurations, first must enable package setting
package.EnableConfigurations = true;
// Direct configuration file, see sample file
this.ApplyConfig(package, "Configuration File", DTSConfigurationType.ConfigFile,
"C:\\Temp\\XmlConfig.dtsConfig", string.Empty);
// Indirect configuration file,
the emvironment variable XmlConfigFileEnvironmentVariable
// contains
the path to
the configuration file, e.g. C:\Temp\XmlConfig.dtsConfig
this.ApplyConfig(package, "Indirect Configuration File", DTSConfigurationType.IConfigFile,
"XmlConfigFileEnvironmentVariable", string.Empty);
// Direct SQL Server configuration, uses
the SQLConnection package connection to read
// configurations from
the [dbo].[SSIS Configurations] table, with a filter of "SampleFilter"
this.ApplyConfig(package, "SQL Server", DTSConfigurationType.SqlServer,
"\"SQLConnection\";\"[dbo].[SSIS Configurations]\";\"SampleFilter\";", string.Empty);
// Indirect SQL Server configuration,
the environment variable "SQLServerEnvironmentVariable"
// contains
the configuration string e.g. "SQLConnection";"[dbo].[SSIS Configurations]";"SampleFilter";
this.ApplyConfig(package, "Indirect SQL Server", DTSConfigurationType.ISqlServer,
"SQLServerEnvironmentVariable", string.Empty);
// Direct environment variable,
the value of
the EnvironmentVariable environment variable is
// applied to
the target property,
the value of
the "User::Variable" package variable
this.ApplyConfig(package, "EnvironmentVariable", DTSConfigurationType.EnvVariable,
"EnvironmentVariable", "\\Package.Variables[User::Variable].Properties[Value]");
#if DEBUG
// Save package to disk, DEBUG only
new Application().SaveToXml(String.Format(@"C:\Temp\{0}.dtsx", package.Name), package, null);
Console.WriteLine(@"C:\Temp\{0}.dtsx", package.Name);
#endif
// Execute package
package.Execute();
// Basic check for warnings
foreach (DtsWarning warning in package.Warnings)
{
Console.WriteLine("WarningCode : {0}", warning.WarningCode);
Console.WriteLine(" SubComponent : {0}", warning.SubComponent);
Console.WriteLine(" Description : {0}", warning.Description);
Console.WriteLine();
}
// Basic check for errors
foreach (DtsError error in package.Errors)
{
Console.WriteLine("ErrorCode : {0}", error.ErrorCode);
Console.WriteLine(" SubComponent : {0}", error.SubComponent);
Console.WriteLine(" Description : {0}", error.Description);
Console.WriteLine();
}
package.Dispose();
}
/// <summary>
/// Add or update an package configuration.
/// </summary>
/// <param name="package">The package.</param>
/// <param name="name">The configuration name.</param>
/// <param name="type">The type of configuration</param>
/// <param name="setting">The configuration setting.</param>
/// <param name="target">The target of
the configuration, leave blank if not required.</param>
internal void ApplyConfig(Package package, string name, DTSConfigurationType type, string setting, string target)
{
Configurations configurations = package.Configurations;
Configuration configuration;
if (configurations.Contains(name))
{
configuration = configurations[name];
}
else
{
configuration = configurations.Add();
}
configuration.Name = name;
configuration.ConfigurationType = type;
configuration.ConfigurationString = setting;
configuration.PackagePath = target;
}
}
}
The following table lists
the environment variables required for
the full example to work along with some sample values.
Variable
Sample value
EnvironmentVariable
1
SQLServerEnvironmentVariable
"SQLConnection";"[dbo].[SSIS Configurations]";"SampleFilter";
XmlConfigFileEnvironmentVariable
C:\Temp\XmlConfig.dtsConfig
Sample code, package and configuration file.
ConfigurationApplication.cs ConfigurationSample.dtsx XmlConfig.dtsConfig
