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)); }