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
