public VulcanEngine.IR.IIR Execute(VulcanEngine.IR.IIR PredecessorIR)
{
PhysicalIR physicalIR = PredecessorIR as PhysicalIR;
if (physicalIR == null)
{
// TODO: Message.Trace(Severity.Error, Resources.ErrorPhaseWorkflowIncorrectInputIRType, PredecessorIR.GetType().ToString(), this.Name);
}
foreach (LogicalObject physicalNode in physicalIR.PhysicalNodes)
{
if (physicalNode is ConnectionConfiguration)
{
SsisConnectionConfiguration configEmitter = new SsisConnectionConfiguration((ConnectionConfiguration)physicalNode, new SSISEmitterContext(null, null, _pluginLoader));
configEmitter.Emit();
}
}
int PackagesCount = physicalIR.PhysicalNodes.Count(delegate(LogicalObject o) { return o is Package; });
int PackagesProcessed = 0;
foreach (LogicalObject physicalNode in physicalIR.PhysicalNodes)
{
if (physicalNode is Package)
{
SsisPackage emitterPackage = new SsisPackage((Package)physicalNode, new SSISEmitterContext(null, null, _pluginLoader));
MessageEngine.Global.UpdateProgress(PackagesProcessed / (double)PackagesCount);
emitterPackage.Emit();
MessageEngine.Global.UpdateProgress(++PackagesProcessed / (double)PackagesCount);
}
}
return null;
}
public VulcanEngine.IR.IIR Execute(VulcanEngine.IR.IIR PredecessorIR)
{
XmlIR xmlIR = PredecessorIR as XmlIR;
if (xmlIR == null)
{
Message.Trace(Severity.Error, Resources.ErrorPhaseWorkflowIncorrectInputIRType, PredecessorIR.GetType().ToString(), this.Name);
}
xmlIR.ValidateXDocuments();
return xmlIR;
}
public VulcanEngine.IR.IIR Execute(VulcanEngine.IR.IIR PredecessorIR)
{
// TODO: Enhance the PluginLoader so we can use it as the type store. We're currently missing all types that lack a friendly name.
XmlIR xmlIR = PredecessorIR as XmlIR;
if (xmlIR == null)
{
// TODO: Message.Trace(Severity.Error, Resources.ErrorPhaseWorkflowIncorrectInputIRType, PredecessorIR.GetType().ToString(), this.Name);
}
AstIR astIR = new AstIR(xmlIR);
astIR.AstRootNode = new AstRootNode();
foreach (XmlIRDocumentType docType in astIR.XDocuments.Keys)
{
foreach (XDocument xDocument in astIR.XDocuments[docType])
{
parseElement(xDocument.Root, astIR.AstRootNode,docType);
}
}
HashSet<string> processedIncludeFiles = new HashSet<string>();
List<string> newIncludeFiles = new List<string>();
bool bContinue;
do
{
bContinue = false;
var newFiles = from file in astIR.AstRootNode.IncludedFiles
where !processedIncludeFiles.Contains(file.IncludedFile)
select file.IncludedFile;
List<string> newFileList = new List<string>();
newFileList.AddRange(newFiles);
foreach (var xmlFile in newFileList)
{
XDocument xDocument = astIR.AddXml(xmlFile, XmlIRDocumentType.INCLUDE);
if (xDocument != null)
{
bContinue = true;
parseElement(xDocument.Root, astIR.AstRootNode, XmlIRDocumentType.INCLUDE);
processedIncludeFiles.Add(xmlFile);
}
}
} while (bContinue);
ProcessLateBindingQueue();
ProcessNewObjectQueue(xmlIR);
return astIR;
}
public VulcanEngine.IR.IIR Execute(VulcanEngine.IR.IIR PredecessorIR)
{
AstIR ir = (AstIR)PredecessorIR;
/*foreach (AstPackageNode p in ir.AstRootNode.Packages)
{
foreach (AstTaskNode t in p)
{
Console.WriteLine("Task! {0}", t.Name);
}
} */
return ProcessTableQuerySources(ir);
//return ir;
}
public VulcanEngine.IR.IIR Execute(VulcanEngine.IR.IIR predecessorIR)
{
var physicalIR = predecessorIR as PhysicalIR;
if (physicalIR != null)
{
int emittablesCount = 0;
foreach (PhysicalObject root in physicalIR.EmittableNodes)
{
emittablesCount += root.Count;
foreach (PhysicalObject emittable in root.Children)
{
var package = emittable as Package;
if (package != null)
{
package.ClearProjectDirectory();
}
}
}
// TODO: Progress bar is whacky.
int emittablesProcessed = 0;
var context = new SsisEmitterContext();
foreach (PhysicalObject root in physicalIR.EmittableNodes)
{
MessageEngine.UpdateProgress(emittablesProcessed / (double)emittablesCount);
foreach (ISsisEmitter emittable in root.Children)
{
emittable.Initialize(context);
emittable.Emit(context);
}
emittablesProcessed += root.Count;
MessageEngine.UpdateProgress(emittablesProcessed / (double)emittablesCount);
}
}
return null;
}
public VulcanEngine.IR.IIR Execute(VulcanEngine.IR.IIR predecessorIR)
{
AstIR astIR = predecessorIR as AstIR;
if (astIR == null)
{
// TODO: Message.Trace(Severity.Error, Resources.ErrorPhaseWorkflowIncorrectInputIRType, PredecessorIR.GetType().ToString(), this.Name);
}
PhysicalIR physicalIR = new PhysicalIR(astIR);
try
{
foreach (Task.AstPackageNode packageNode in astIR.AstRootNode.Packages)
{
if (packageNode.Emit && !packageNode.AsClassOnly)
{
Package package = packageNode.Lower();
if (String.IsNullOrEmpty(package.Type))
{
package.Type = "ETL";
}
physicalIR.PhysicalNodes.Add(package);
}
}
foreach (Dimension.AstDimensionNode dimensionNode in astIR.AstRootNode.Dimensions)
{
if (dimensionNode.Emit && !dimensionNode.AsClassOnly)
{
Package package = dimensionNode.Lower().Lower();
package.Type = "Dimension";
physicalIR.PhysicalNodes.Add(package);
}
}
foreach (Fact.AstFactNode factNode in astIR.AstRootNode.Facts)
{
if (factNode.Emit && !factNode.AsClassOnly)
{
Package package = factNode.Lower().Lower();
package.Type = "FactTable";
physicalIR.PhysicalNodes.Add(package);
}
}
foreach (Connection.AstConnectionNode connectionNode in astIR.AstRootNode.Connections)
{
physicalIR.PhysicalNodes.Add(connectionNode.Lower());
}
foreach (Table.AstTableNode tableNode in astIR.AstRootNode.Tables)
{
if (tableNode.Emit && !tableNode.AsClassOnly)
{
Package package = tableNode.Lower().Lower();
package.Type = "Table";
physicalIR.PhysicalNodes.Add(package);
foreach (Table.AstTableSourceBaseNode sourceNode in tableNode.Sources)
{
Table.AstTableDynamicSourceNode dynamicSource = sourceNode as Table.AstTableDynamicSourceNode;
if (dynamicSource != null)
{
Package sourcePackage = dynamicSource.Package.Lower();
sourcePackage.Type = "ETL";
physicalIR.PhysicalNodes.Add(sourcePackage);
}
}
}
}
}
catch (Ssis2008Emitter.SSISEmitterException EmitterException)
{
StringBuilder err = new StringBuilder();
err.Append("\r\nCompiling ");
Exception e = EmitterException;
bool bIsNullException = false;
while (e != null)
{
err.AppendFormat("{0}\r\n", e.Message);
if (e.InnerException != null)
{
e = (e.InnerException);
err.AppendFormat("-->\t");
}
else
{
if (e is NullReferenceException)
{
bIsNullException = true;
}
e = null;
}
}
MessageEngine.Global.Trace(Severity.Error, err.ToString());
if (bIsNullException)
{
MessageEngine.Global.Trace(Severity.Warning,
"Possible reason: an attribute or element is referencing undefined code." +
"To solve this issue, fix the mismatched reference or use <Using> to include the definition.");
}
}
return physicalIR;
}
private static string _generateScopedVariableName(VulcanEngine.IR.Ast.PersistentVariables.AstPersistentVariableNode astNode)
{
return String.Format(CultureInfo.InvariantCulture, "_{0}_ID", astNode.ScopedName.Replace(".", "_"));
}
public OleDBConnection(VulcanEngine.IR.Ast.Connection.AstConnectionNode astNode) : base(astNode)
{
ConnectionType = "OLEDB";
}
public AdoNetConnection(VulcanEngine.IR.Ast.Connection.AstConnectionNode astNode) : base(astNode)
{
ConnectionType = "ADO.NET:System.Data.SqlClient.SqlConnection, System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
}
