private static IList<FilterSpecParamForge> ComputePermutation(
FilterSpecParaForgeMap filterParamExprMap,
object[] permutation,
FilterSpecParaForgeMap[][] orNodesMaps,
FilterSpecCompilerArgs args)
{
FilterSpecParaForgeMap mapAll = new FilterSpecParaForgeMap();
mapAll.Add(filterParamExprMap);
// combine
for (int orNodeNum = 0; orNodeNum < permutation.Length; orNodeNum++) {
int orChildNodeNum = (int) permutation[orNodeNum];
FilterSpecParaForgeMap mapOrSub = orNodesMaps[orNodeNum][orChildNodeNum];
mapAll.Add(mapOrSub);
}
// consolidate across
FilterSpecCompilerConsolidateUtil.Consolidate(mapAll, args.statementRawInfo.StatementName);
IList<FilterSpecParamForge> filterParams = new List<FilterSpecParamForge>();
filterParams.AddAll(mapAll.FilterParams);
int countUnassigned = mapAll.CountUnassignedExpressions();
if (countUnassigned == 0) {
return filterParams;
}
FilterSpecParamForge node = MakeRemainingNode(mapAll.UnassignedExpressions, args);
filterParams.Add(node);
return filterParams;
}
private static FilterSpecPlanPathForge ComputePermutation(
FilterSpecParaForgeMap filterParamExprMap,
object[] permutation,
FilterSpecParaForgeMap[][] orNodesMaps,
FilterSpecCompilerArgs args)
{
var mapAll = new FilterSpecParaForgeMap();
mapAll.Add(filterParamExprMap);
// combine
for (var orNodeNum = 0; orNodeNum < permutation.Length; orNodeNum++) {
var orChildNodeNum = permutation[orNodeNum].AsInt32();
var mapOrSub = orNodesMaps[orNodeNum][orChildNodeNum];
mapAll.Add(mapOrSub);
}
// consolidate across
FilterSpecCompilerConsolidateUtil.Consolidate(mapAll, args.statementRawInfo.StatementName);
IList<FilterSpecPlanPathTripletForge> filterParams = new List<FilterSpecPlanPathTripletForge>(mapAll.Triplets);
var countUnassigned = mapAll.CountUnassignedExpressions();
if (countUnassigned != 0) {
FilterSpecPlanPathTripletForge node = MakeRemainingNode(mapAll.UnassignedExpressions, args);
filterParams.Add(node);
}
FilterSpecPlanPathTripletForge[] triplets = filterParams.ToArray();
return new FilterSpecPlanPathForge(triplets, null);
}
internal static ExprNode DecomposePopulateConsolidate(
FilterSpecParaForgeMap filterParamExprMap,
bool performConditionPlanning,
IList<ExprNode> validatedNodes,
FilterSpecCompilerArgs args)
{
var constituents = DecomposeCheckAggregation(validatedNodes);
// Remove constituents that are value-expressions
ExprNode topLevelControl = null;
if (performConditionPlanning) {
IList<ExprNode> valueOnlyConstituents = null;
foreach (var node in constituents) {
var visitor = new FilterSpecExprNodeVisitorValueLimitedExpr();
node.Accept(visitor);
if (visitor.IsLimited) {
if (valueOnlyConstituents == null) {
valueOnlyConstituents = new List<ExprNode>();
}
valueOnlyConstituents.Add(node);
}
}
if (valueOnlyConstituents != null) {
constituents.RemoveAll(valueOnlyConstituents);
topLevelControl = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(valueOnlyConstituents);
}
}
// Make filter parameter for each expression node, if it can be optimized
foreach (var constituent in constituents) {
var triplet = FilterSpecCompilerIndexPlannerConstituent.MakeFilterParam(
constituent,
performConditionPlanning,
args.taggedEventTypes,
args.arrayEventTypes,
args.allTagNamesOrdered,
args.statementRawInfo.StatementName,
args.streamTypeService,
args.statementRawInfo,
args.compileTimeServices);
filterParamExprMap.Put(constituent, triplet); // accepts null values as the expression may not be optimized
}
// Consolidate entries as possible, i.e. (a != 5 and a != 6) is (a not in (5,6))
// Removes duplicates for same property and same filter operator for filter service index optimizations
FilterSpecCompilerConsolidateUtil.Consolidate(filterParamExprMap, args.statementRawInfo.StatementName);
return topLevelControl;
}
private static void DecomposePopulateConsolidate(
FilterSpecParaForgeMap filterParamExprMap,
IList<ExprNode> validatedNodes,
FilterSpecCompilerArgs args)
{
IList<ExprNode> constituents = DecomposeCheckAggregation(validatedNodes);
// Make filter parameter for each expression node, if it can be optimized
foreach (ExprNode constituent in constituents) {
FilterSpecParamForge param = FilterSpecCompilerMakeParamUtil.MakeFilterParam(
constituent,
args.arrayEventTypes,
args.statementRawInfo.StatementName);
filterParamExprMap.Put(constituent, param); // accepts null values as the expression may not be optimized
}
// Consolidate entries as possible, i.e. (a != 5 and a != 6) is (a not in (5,6))
// Removes duplicates for same property and same filter operator for filter service index optimizations
FilterSpecCompilerConsolidateUtil.Consolidate(filterParamExprMap, args.statementRawInfo.StatementName);
}
private static CombPermutationTriplets ComputePermutation(
FilterSpecParaForgeMap filterParamExprMap,
object[] permutation,
OrChildNode[][] orChildNodes,
bool hasControl,
FilterSpecCompilerArgs args)
{
var mapAll = new FilterSpecParaForgeMap();
mapAll.Add(filterParamExprMap);
// combine
IList <ExprNode> nvPerOr = new List <ExprNode>(permutation.Length);
IList <ExprNode> negatingPath = new List <ExprNode>(permutation.Length);
for (var orNodeNum = 0; orNodeNum < permutation.Length; orNodeNum++)
{
int orChildNodeNum = permutation[orNodeNum].AsInt32();
var current = orChildNodes[orNodeNum][orChildNodeNum];
if (current is OrChildNodeNV)
{
var nv = (OrChildNodeNV)current;
mapAll.Add(nv.Map);
if (current is OrChildNodeNVNegated)
{
negatingPath.Add(((OrChildNodeNVNegated)current).Control);
}
}
else
{
var v = (OrChildNodeV)current;
negatingPath.Add(v.Node);
}
var orChildNodesForCurrent = orChildNodes[orNodeNum];
foreach (var other in orChildNodesForCurrent)
{
if (current == other)
{
continue;
}
if (other is OrChildNodeV)
{
var v = (OrChildNodeV)other;
var not = new ExprNotNode();
not.AddChildNode(v.Node);
nvPerOr.Add(not);
}
}
}
// consolidate across
FilterSpecCompilerConsolidateUtil.Consolidate(mapAll, args.statementRawInfo.StatementName);
IList <FilterSpecPlanPathTripletForge> triplets = new List <FilterSpecPlanPathTripletForge>(mapAll.Triplets);
var countUnassigned = mapAll.CountUnassignedExpressions();
if (countUnassigned != 0)
{
var triplet = MakeRemainingNode(mapAll.UnassignedExpressions, args);
triplets.Add(triplet);
}
// without conditions we are done
var tripletsArray = triplets.ToArray();
if (!hasControl)
{
return(new CombPermutationTriplets(tripletsArray, null));
}
var negatingNode = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(negatingPath);
var excluded = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(nvPerOr);
var merged = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(negatingNode, excluded);
return(new CombPermutationTriplets(tripletsArray, merged));
}
