public void AppendForeignKeyConstraintFromReference(AST.Table.AstTableNode table, string refNameOverride, string refName, AST.Table.AstTableNode refTable)
{
TemplatePlatformEmitter tpe = new TemplatePlatformEmitter("ForeignKeyConstraintTemplate");
tpe.Map("TableName", table.SchemaQualifiedName);
string constraintName;
if (!String.IsNullOrEmpty(refNameOverride))
{
constraintName = String.Format(CultureInfo.InvariantCulture, "[{0}]", refNameOverride);
}
else
{
constraintName = String.Format(
CultureInfo.InvariantCulture,
"[FK_{0}_{1}_{2}_{3}]",
table.Name,
refName,
refTable.Name,
refTable.PreferredKey.Columns[0].Column.Name);
}
if (constraintName.Length >= 128)
{
constraintName = String.Format(CultureInfo.InvariantCulture,"[{0}]",constraintName.Substring(0, 127));
}
tpe.Map("ConstraintName", constraintName);
tpe.Map("Column", refName);
tpe.Map("ForeignKeyTable", refTable.SchemaQualifiedName);
tpe.Map("ForeignKeyColumn", refTable.PreferredKey.Columns[0].Column.Name);
_foreignKeyBuilder.Append(tpe.Emit());
_foreignKeyBuilder.Append("\n\n");
}
public Package(AST.Task.AstPackageNode astNode)
: base(astNode)
{
_DTSApplication = new DTS.Application();
DtsPackage = new DTS.Package();
DtsPackage.Name = StringManipulation.NameCleaner(Name);
PackageType = String.IsNullOrEmpty(astNode.PackageType) ? "ETL" : astNode.PackageType;
PackageFolder = astNode.PackageFolder;
PackagePath = astNode.PackagePath;
PackageProtectionLevel = astNode.ProtectionLevel;
PackagePassword = astNode.PackagePassword;
// vsabella: We thought about adding this in the Lowering phase.
// The reason this was not placed in Lowering is that this variable must be available
// before any other lowering can take place. Additionally i needed a single place where the
// variable name could remain constant and other lowering phase engines could refer to it.
// PreEmit
PackageRootVariable =
new Variable(PackagePathRootVariableName)
{
InheritFromPackageParentConfigurationString = "User::" + PackagePathRootVariableName,
ValueString = PathManager.TargetPath,
TypeCode = TypeCode.String
};
Children.Add(PackageRootVariable);
}
public ForLoop(AST.Task.AstForLoopContainerTaskNode astNode)
: base(astNode)
{
_initializerExpression = astNode.InitializerExpression;
_loopTestExpression = astNode.LoopTestExpression;
_countingExpression = astNode.CountingExpression;
}
public Variable(AST.Task.AstVariableNode astNode) : base(astNode.Name)
{
TypeCode = (TypeCode)Enum.Parse(typeof(TypeCode), astNode.TypeCode.ToString());
ValueString = astNode.Value;
EvaluateAsExpression = astNode.EvaluateAsExpression;
InheritFromPackageParentConfigurationString = astNode.InheritFromPackageParentConfigurationString;
IsSystemVariable = astNode.IsSystemVariable;
}
private void AppendUpdate(AST.Table.AstTableColumnBaseNode column, StringBuilder updateBuilder)
{
updateTemplateRequired = true;
if (updateBuilder.Length > 0)
{
updateBuilder.Append(",");
}
updateBuilder.AppendFormat(CultureInfo.InvariantCulture, "TARGET.[{0}] = SOURCE.[{0}]", column.Name);
}
private void AppendConstraintBase(AST.Table.AstTableKeyBaseNode constraint, string primaryKeyString, string unique)
{
string clustered = constraint.Clustered ? "CLUSTERED" : "NONCLUSTERED";
string ignoreDupKey = constraint.IgnoreDupKey ? "IGNORE_DUP_KEY = ON" : "IGNORE_DUP_KEY = OFF";
string padIndex = constraint.PadIndex ? "PAD_INDEX = ON" : "PAD_INDEX = OFF";
string keys = BuildKeys(constraint);
var te = new TemplatePlatformEmitter("ConstraintTemplate", String.Format(CultureInfo.InvariantCulture,"[{0}]",constraint.Name), unique + clustered, keys, "WITH(" + padIndex + "," + ignoreDupKey + ")", primaryKeyString);
_constraintKeyBuilder.Append("," + te.Emit());
_constraintKeyBuilder.AppendFormat(CultureInfo.InvariantCulture, "\n");
}
public void AppendConstraint(AST.Table.AstTableKeyBaseNode keyBase)
{
if (keyBase is AST.Table.AstTablePrimaryKeyNode || keyBase is AST.Table.AstTableIdentityNode)
{
AppendConstraintBase(keyBase, "PRIMARY KEY", String.Empty);
}
else
{
AppendConstraintBase(keyBase, String.Empty, keyBase.Unique ? "UNIQUE " : " ");
}
}
private void AppendInsertValue(AST.Table.AstTableColumnBaseNode column, StringBuilder insertParamBuilder, StringBuilder insertValueBuilder)
{
if (insertParamBuilder.Length > 0)
{
insertParamBuilder.AppendFormat(CultureInfo.InvariantCulture, ",\n");
}
insertParamBuilder.AppendFormat(CultureInfo.InvariantCulture, "[{0}]", column.Name);
if (insertValueBuilder.Length > 0)
{
insertValueBuilder.AppendFormat(CultureInfo.InvariantCulture, ",\n");
}
insertValueBuilder.AppendFormat(CultureInfo.InvariantCulture, "SOURCE.[{0}]", column.Name);
}
private void AppendNotEqual(AST.Table.AstTableColumnBaseNode column, StringBuilder notEqualBuilder)
{
if (notEqualBuilder.Length > 0)
{
notEqualBuilder.AppendFormat(CultureInfo.InvariantCulture, "\nOR\n");
}
// Bug #3757, special handling for uniqueidentifier data type
if (column.CustomType != null && column.CustomType.Equals("uniqueidentifier", StringComparison.OrdinalIgnoreCase))
{
notEqualBuilder.AppendFormat("COALESCE(TARGET.[{0}],CONVERT(uniqueidentifier,'00000000-0000-0000-0000-000000000000')) <> COALESCE(SOURCE.[{0}],CONVERT(uniqueidentifier,'00000000-0000-0000-0000-000000000000'))", column.Name);
}
else
{
notEqualBuilder.AppendFormat("COALESCE(TARGET.[{0}],'') <> COALESCE(SOURCE.[{0}],'')", column.Name);
}
}
public StoredProcTSqlEmitter(AST.Task.AstStoredProcNode astNode)
{
_name = astNode.SchemaQualifiedName;
_body = astNode.Body;
foreach (AST.Task.AstStoredProcColumnNode storedProcedureColumn in astNode.Columns)
{
string physicalType =
TSqlTypeTranslator.Translate(
storedProcedureColumn.ColumnType,
storedProcedureColumn.Length,
storedProcedureColumn.Precision,
storedProcedureColumn.Scale,
storedProcedureColumn.CustomType);
AddColumn(storedProcedureColumn.Name, physicalType, storedProcedureColumn.Default, storedProcedureColumn.IsOutput, storedProcedureColumn.IsReadOnly);
}
}
public Sequence(AST.Task.AstContainerTaskNode astNode) : base(astNode)
{
}
public MergeTSqlEmitter(AST.Task.AstMergeTaskNode astNode)
{
_mergeTask = astNode;
}
public void AppendIndex(string tableName, AST.Table.AstTableIndexNode index)
{
string unique = index.Unique ? "UNIQUE" : String.Empty;
string clustered = index.Clustered ? "CLUSTERED" : "NONCLUSTERED";
string dropExisting = index.DropExisting ? "DROP_EXISTING = ON" : "DROP_EXISTING = OFF";
string ignoreDupKey = index.IgnoreDupKey ? "IGNORE_DUP_KEY = ON" : "IGNORE_DUP_KEY = OFF";
string online = index.Online ? "ONLINE = ON" : "ONLINE = OFF";
string padIndex = index.Online ? "PAD_INDEX = ON" : "PAD_INDEX = OFF";
string sortInTempdb = index.SortInTempDB ? "SORT_IN_TEMPDB = ON" : "SORT_IN_TEMPDB = OFF";
string properties = string.Format(CultureInfo.InvariantCulture, "{0},\n{1},\n{2},\n{3},\n{4}", padIndex, sortInTempdb, dropExisting, ignoreDupKey, online);
string keys = BuildKeys(index.Columns);
var te = new TemplatePlatformEmitter("CreateIndex", unique, clustered, String.Format(CultureInfo.InvariantCulture,"[{0}]",index.Name), tableName, keys, properties, string.Empty);
_indexBuilder.Append(te.Emit());
_indexBuilder.Append("\n");
}
private static string BuildKeys(AST.Table.AstTableKeyBaseNode keyBase)
{
var keyBuilder = new StringBuilder();
foreach (AST.Table.AstTableKeyColumnNode columnNode in keyBase.Columns)
{
ColumnsTSqlEmitter.CheckAndAppendSeparator(",", keyBuilder);
keyBuilder.AppendFormat(CultureInfo.InvariantCulture, "[{0}] {1}", columnNode.Column.Name, columnNode.SortOrder);
}
return keyBuilder.ToString();
}
