private void EvaluateLook(
int start,
int end,
FSA <TValue> fsa,
LookAheadQuantifier quantifier,
AstConcatNode concatNode,
ORegexOptions options)
{
bool isBehind = options.HasFlag(ORegexOptions.ReversePattern) ? !quantifier.IsBehind : quantifier.IsBehind;
bool isNegative = quantifier.IsNegative;
var condOptions = isBehind ? ORegexOptions.RightToLeft : ORegexOptions.None;
var concat = new AstConcatNode(concatNode.Children, concatNode.Range);
var root = new AstRootNode(concat,
true,
false,
concat.Range,
new[]
{
ORegexAstFactory <TValue> .MainCaptureName
});
var fa = Create(root, condOptions);
var oregex = new ORegex <TValue>(fa, condOptions);
var func = new ORegexPredicateEdge <TValue>("#look", oregex, isNegative, isBehind);
EvaluateCondition(start, end, fsa, func);
}
public static void ProcessPackages(AstRootNode astRootNode)
{
foreach (var package in astRootNode.Packages)
{
_processPackage(package);
}
_processMetadataTasks(astRootNode.SymbolTable);
}
/* when dealing with project parameters in Biml Express you have to take extra steps. See:
* https://www.cathrinewilhelmsen.net/2015/11/25/create-ssis-project-parameters-biml-bids-helper/
* This function will write the parameters to your current Project.params file
*/
public void AddProjectParameters(AstRootNode RootNode)
{
Varigence.Flow.FlowFramework.Validation.ValidationReporter ValidationReporter = new Varigence.Flow.FlowFramework.Validation.ValidationReporter();
var project = RootNode.PackageProjects.FirstOrDefault();
if (project == null)
{
ValidationReporter.Report(Severity.Error, "<PackageProject> does not exist");
}
else
{
var projectPath = project.GetTag("ProjectParametersPath");
if (projectPath == "")
{
ValidationReporter.Report(project, Severity.Error, "Annotation ProjectParametersPath does not exist", @"Add <Annotation Tag=""ProjectParametersPath"">C:\SSIS\TestProject\Project.params</Annotation> to <PackageProject>");
}
else
{
try
{
var fileAttributes = File.GetAttributes(projectPath);
if ((fileAttributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
File.SetAttributes(projectPath, (fileAttributes & ~FileAttributes.ReadOnly));
}
StringBuilder parameters = new StringBuilder();
parameters.AppendLine("<?xml version=\"1.0\"?>");
parameters.AppendLine("<SSIS:Parameters xmlns:SSIS=\"www.microsoft.com/SqlServer/SSIS\">");
foreach (var parameter in project.Parameters)
{
parameters.AppendFormat("<SSIS:Parameter SSIS:Name=\"{0}\">", parameter.Name).AppendLine();
parameters.AppendLine("<SSIS:Properties>");
parameters.AppendFormat("<SSIS:Property SSIS:Name=\"ID\">{{{0}}}</SSIS:Property>", (parameter.Id == Guid.Empty ? Guid.NewGuid() : parameter.Id)).AppendLine();
parameters.AppendFormat("<SSIS:Property SSIS:Name=\"DataType\">{0}</SSIS:Property>", Convert.ToByte(parameter.DataType)).AppendLine();
parameters.AppendFormat("<SSIS:Property SSIS:Name=\"Value\">{0}</SSIS:Property>", parameter.Value).AppendLine();
parameters.AppendFormat("<SSIS:Property SSIS:Name=\"Sensitive\">{0}</SSIS:Property>", Convert.ToByte(parameter.IsSensitive)).AppendLine();
parameters.AppendFormat("<SSIS:Property SSIS:Name=\"Required\">{0}</SSIS:Property>", Convert.ToByte(parameter.IsRequired)).AppendLine();
parameters.AppendFormat("<SSIS:Property SSIS:Name=\"IncludeInDebugDump\">{0}</SSIS:Property>", Convert.ToByte(parameter.IncludeInDebugDump)).AppendLine();
parameters.AppendFormat("<SSIS:Property SSIS:Name=\"Description\">{0}</SSIS:Property>", parameter.GetTag("Description")).AppendLine();
parameters.AppendFormat("<SSIS:Property SSIS:Name=\"CreationName\">{0}</SSIS:Property>", parameter.GetTag("CreationName")).AppendLine();
parameters.AppendLine("</SSIS:Properties>");
parameters.AppendLine("</SSIS:Parameter>");
}
parameters.AppendLine("</SSIS:Parameters>");
File.WriteAllText(projectPath, parameters.ToString());
}
catch (Exception e)
{
ValidationReporter.Report(project, Severity.Error, "Error writing Project Parameters to Project.params", String.Format("Make sure the path \"{0}\" is correct and that this project uses the Project Deployment Model", projectPath));
}
}
}
}
public static void ProcessPrincipals(AstRootNode astRootNode)
{
if (astRootNode.Principals.Count > 0)
{
var package = new AstPackageNode(astRootNode)
{
Name = "PrincipalsInitializer", Emit = true, PackageType = "Principal"
};
astRootNode.Packages.Add(package);
foreach (AstPrincipalNode principal in astRootNode.Principals)
{
TemplatePlatformEmitter principalTemplate;
switch (principal.PrincipalType)
{
case PrincipalType.ApplicationRole:
principalTemplate = new TemplatePlatformEmitter("CreatePrincipalApplicationRole", principal.Name);
break;
case PrincipalType.DBRole:
principalTemplate = new TemplatePlatformEmitter("CreatePrincipalDatabaseRole", principal.Name);
break;
case PrincipalType.SqlUser:
principalTemplate = new TemplatePlatformEmitter("CreatePrincipalSqlUser", principal.Name);
break;
case PrincipalType.WindowsGroup:
principalTemplate = new TemplatePlatformEmitter("CreatePrincipalWindowsUser", principal.Name);
break;
case PrincipalType.WindowsUser:
principalTemplate = new TemplatePlatformEmitter("CreatePrincipalWindowsUser", principal.Name);
break;
default:
MessageEngine.Trace(principal, Severity.Error, "V0139", "Unknown Principal Type {0} in principal {1}", principal.PrincipalType.ToString(), principal.Name);
return;
}
var executeSqlTask = new AstExecuteSqlTaskNode(package)
{
Name = Utility.NameCleanerAndUniqifier(String.Format(CultureInfo.InvariantCulture, "PrincipalConfig_{0}", principal.Name)),
Connection = principal.Connection
};
executeSqlTask.Query = new AstExecuteSqlQueryNode(executeSqlTask)
{
Body = principalTemplate.Emit(),
QueryType = QueryType.Standard
};
package.Tasks.Add(executeSqlTask);
}
}
}
public FiniteAutomaton <TValue> Create(AstRootNode root, ORegexOptions options)
{
var nfa = CreateRawFsa(root, options);
if (options.HasFlag(ORegexOptions.ReversePattern))
{
nfa = _fsaOperator.ReverseFsa(nfa);
}
var dfa = _fsaOperator.MinimizeFsa(nfa);
return(new FiniteAutomaton <TValue>(new CFSA <TValue>(dfa), new CFSA <TValue>(nfa)));
}
public static void ProcessSchema(AstRootNode astRootNode, AstSchemaNode schemaNode)
{
const string PackageTypeName = "Schema";
var packageNode = new AstPackageNode(schemaNode.ParentItem);
packageNode.Name = schemaNode.Name;
packageNode.PackageType = PackageTypeName;
var executeSqlNode = new AstExecuteSqlTaskNode(packageNode)
{
Name = schemaNode.Name, Connection = schemaNode.Connection, ResultSet = ExecuteSqlResultSet.None
};
executeSqlNode.Query = new AstExecuteSqlQueryNode(executeSqlNode)
{
QueryType = QueryType.Standard, Body = new TemplatePlatformEmitter("CreateSchema", schemaNode.Name).Emit()
};
packageNode.Tasks.Add(executeSqlNode);
bool hasPermissions = false;
var permissionBuilder = new StringBuilder();
foreach (var permission in schemaNode.Permissions)
{
hasPermissions = true;
permissionBuilder.AppendLine(PermissionsLowerer.ProcessPermission(schemaNode, permission));
}
if (hasPermissions)
{
var permissionsExecuteSqlTask = new AstExecuteSqlTaskNode(packageNode)
{
Name = "__SetPermissions",
Connection = schemaNode.Connection,
};
permissionsExecuteSqlTask.Query = new AstExecuteSqlQueryNode(permissionsExecuteSqlTask)
{
Body = permissionBuilder.ToString(),
QueryType = QueryType.Standard
};
packageNode.Tasks.Add(permissionsExecuteSqlTask);
}
if (schemaNode.CustomExtensions != null)
{
packageNode.Tasks.Add(schemaNode.CustomExtensions);
}
astRootNode.Packages.Add(packageNode);
}
private static void ProcessTables(AstRootNode astRootNode)
{
var tables = new List <AstTableBaseNode>(astRootNode.Tables);
foreach (var dimension in astRootNode.Dimensions)
{
tables.Add(dimension);
}
foreach (var fact in astRootNode.Facts)
{
tables.Add(fact);
}
foreach (AstTableNode table in tables)
{
if (table.LateArriving)
{
LateArrivingLowerer.ProcessLateArrivingTable(table);
}
if (table.HasScdColumns)
{
SlowlyChangingDimensionsLowerer.ProcessTableScdColumns(table);
}
foreach (var staticSourcePackage in StaticSourcesLowerer.ProcessTableStaticSource(table))
{
astRootNode.Packages.Add(staticSourcePackage);
}
if (!(table is AstTableCloneNode) && table.EmitVersionNumber)
{
var versionNumber = new AstTableColumnNode(table)
{
Name = "VersionNumber",
ColumnType = ColumnType.Binary,
Length = 8,
CustomType = "rowversion",
IsAssignable = false,
IsNullable = false,
IsAutoGenerated = true
};
table.Columns.Add(versionNumber);
}
if (table.Emit)
{
astRootNode.Packages.Add(TableLowerer.ProcessTable(table));
}
}
}
public static void ProcessSchemas(AstRootNode astRootNode)
{
var snapshotSymbolTable = new List <IReferenceableItem>(astRootNode.SymbolTable);
foreach (var astNamedNode in snapshotSymbolTable)
{
var schemaNode = astNamedNode as AstSchemaNode;
if (schemaNode != null && astNamedNode.FirstThisOrParent <ITemplate>() == null)
{
ProcessSchema(astRootNode, schemaNode);
}
}
}
public FSA <TValue> CreateRawFsa(AstRootNode root, ORegexOptions options)
{
var result = new FSA <TValue>(root.CaptureGroupNames[0])
{
CaptureNames = root.CaptureGroupNames
};
var start = result.NewState();
var end = result.NewState();
Evaluate(start, end, result, root, options);
result.AddFinal(end);
result.AddStart(start);
return(result);
}
public AstIR(AstIR astIR) : base(astIR)
{
this._astRootNode = astIR._astRootNode;
}
private void EvaluateRoot(int start, int end, FSA <TValue> fsa, AstRootNode astRootNode, ORegexOptions options)
{
fsa.ExactBegin = astRootNode.MatchBegin;
fsa.ExactEnd = astRootNode.MatchEnd;
Evaluate(start, end, fsa, astRootNode.Regex, options);
}
