private static PhysicalTask.SequenceTask ProcessHelperTables(AstTask.AstContainerTaskNode astNode, PhysicalTask.SequenceTask sequenceTask)
{
foreach (AstTable.AstTableNode helperTableNode in astNode.HelperTables)
{
IR.TSQL.Table helperTable = helperTableNode.Lower();
if (helperTable != null)
{
AstTask.AstExecuteSQLTaskNode createHelperTableTask = new VulcanEngine.IR.Ast.Task.AstExecuteSQLTaskNode();
createHelperTableTask.ParentASTNode = astNode;
createHelperTableTask.Name = "__Create HelperTable " + helperTable.Name;
createHelperTableTask.Connection = helperTableNode.Connection;
createHelperTableTask.ExecuteDuringDesignTime = helperTableNode.ExecuteDuringDesignTime;
createHelperTableTask.Type = VulcanEngine.IR.Ast.Task.ExecuteSQLTaskType.File;
createHelperTableTask.Body = new TSQLEmitter.TablePlatformEmitter().Emit(helperTable);
sequenceTask.Tasks.Insert(0, createHelperTableTask.Lower());
AstTask.AstExecuteSQLTaskNode dropHelperTableTask = new VulcanEngine.IR.Ast.Task.AstExecuteSQLTaskNode();
dropHelperTableTask.ParentASTNode = astNode;
dropHelperTableTask.Name = "__Drop HelperTable " + helperTable.Name;
dropHelperTableTask.Connection = helperTableNode.Connection;
dropHelperTableTask.ExecuteDuringDesignTime = false;
dropHelperTableTask.Type = VulcanEngine.IR.Ast.Task.ExecuteSQLTaskType.Expression;
dropHelperTableTask.Body = String.Format("\"{0}\"", new TSQLEmitter.TemplatePlatformEmitter("DropHelperTable", helperTable.Name).Emit(helperTable));
sequenceTask.Tasks.Add(dropHelperTableTask.Lower());
}
}
return sequenceTask;
}
private static HashSet<AstTaskNode> FindPredecessors(AstTask.AstContainerTaskNode container, AstTaskNode task, AstTaskNode previousTask, Dictionary<AstTaskNode, ICollection<AstTaskNode>> successors)
{
var predecessors = new HashSet<AstTaskNode>();
if (task.PrecedenceConstraints != null)
{
foreach (var input in task.PrecedenceConstraints.Inputs)
{
if (input.OutputPath != null)
{
var predecessorNode = input.OutputPath.ParentItem as AstTaskNode;
predecessors.Add(predecessorNode);
}
}
}
//if (containerTask != null && containerTask.ConstraintMode == ContainerConstraintMode.Linear && predecessors.Count == 0 && previousTask != null)
if (container.ConstraintMode == ContainerConstraintMode.Linear && predecessors.Count == 0 && previousTask != null)
{
predecessors.Add(previousTask);
}
return predecessors;
}
private static void ComputeRootsAndSuccessors(AstTask.AstContainerTaskNode container, IEnumerable<AstTaskNode> unsortedTransformations, HashSet<AstTaskNode> roots, Dictionary<AstTaskNode, ICollection<AstTaskNode>> successors)
{
AstTaskNode previousTransformation = null;
foreach (var transformation in unsortedTransformations)
{
HashSet<AstTaskNode> predecessors = FindPredecessors(container, transformation, previousTransformation, successors);
if (predecessors.Count == 0)
{
roots.Add(transformation);
}
foreach (var predecessor in predecessors)
{
if (!successors.ContainsKey(predecessor))
{
successors.Add(predecessor, new HashSet<AstTaskNode>());
}
successors[predecessor].Add(transformation);
}
previousTransformation = transformation;
}
}
private static List<AstTaskNode> SortTasks(AstTask.AstContainerTaskNode container, IEnumerable<AstTaskNode> unsortedTasks)
{
var roots = new HashSet<AstTaskNode>();
var successors = new Dictionary<AstTaskNode, ICollection<AstTaskNode>>();
ComputeRootsAndSuccessors(container, unsortedTasks, roots, successors);
return FlowSorter.TopologicalSort(roots,successors);
}
private static void LowerChildren(AstTask.AstContainerTaskNode container, LoweringContext context)
{
foreach (AstTask.AstVariableNode variable in container.Variables)
{
PhysicalLoweringProcessor.Lower(variable, context);
}
var sortedTasks = SortTasks(container, container.Tasks);
foreach (AstTask.AstTaskNode task in sortedTasks)
{
PhysicalLoweringProcessor.Lower(task, context);
}
}
public static void LowerEventHandlers(AstTask.AstTaskNode astTaskNode, Executable parentExecutable, LoweringContext context)
{
foreach (AstTask.AstTaskEventHandlerNode astTaskEventHandler in astTaskNode.Events)
{
PhysicalTask.EventHandler e = new IR.Tasks.EventHandler(astTaskEventHandler, parentExecutable);
context.ParentObject.Children.Add(e);
foreach (AstTask.AstTaskNode task in astTaskEventHandler.Tasks)
{
context = new TaskLoweringContext(e);
PhysicalLoweringProcessor.Lower(task, context);
}
}
}
