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); }
public void RemoveNode(ExprNode node) { FilterSpecPlanPathTripletForge param = exprNodes.Delete(node); if (param != null) { specParams.Remove(param); } }
private static FilterSpecPlanPathTripletForge HandleOrAlternateExpression( ExprOrNode orNode, bool performConditionPlanning, IDictionary <string, Pair <EventType, string> > taggedEventTypes, IDictionary <string, Pair <EventType, string> > arrayEventTypes, ISet <string> allTagNamesOrdered, string statementName, StreamTypeService streamTypeService, StatementRawInfo raw, StatementCompileTimeServices services) { IList <ExprNode> valueExpressions = new List <ExprNode>(orNode.ChildNodes.Length); foreach (ExprNode child in orNode.ChildNodes) { FilterSpecExprNodeVisitorValueLimitedExpr visitor = new FilterSpecExprNodeVisitorValueLimitedExpr(); child.Accept(visitor); if (visitor.IsLimited) { valueExpressions.Add(child); } } // The or-node must have a single constituent and one or more value expressions if (orNode.ChildNodes.Length != valueExpressions.Count + 1) { return(null); } IList <ExprNode> constituents = new List <ExprNode>(orNode.ChildNodes); constituents.RemoveAll(valueExpressions); if (constituents.Count != 1) { throw new IllegalStateException("Found multiple constituents"); } ExprNode constituent = constituents[0]; FilterSpecPlanPathTripletForge triplet = MakeFilterParam( constituent, performConditionPlanning, taggedEventTypes, arrayEventTypes, allTagNamesOrdered, statementName, streamTypeService, raw, services); if (triplet == null) { return(null); } ExprNode controlConfirm = ExprNodeUtilityMake.ConnectExpressionsByLogicalOrWhenNeeded(valueExpressions); return(new FilterSpecPlanPathTripletForge(triplet.Param, controlConfirm)); }
public bool EqualsFilter(FilterSpecPlanPathTripletForge other) { if (!ExprNodeUtilityCompare.DeepEqualsNullChecked(TripletConfirm, other.TripletConfirm, true)) { return false; } return Param.Equals(other.Param); }
/// <summary> /// Add a node and filter param. /// </summary> /// <param name="exprNode">is the node to add</param> /// <param name="param">is null if the expression node has not optimized form</param> public void Put( ExprNode exprNode, FilterSpecPlanPathTripletForge param) { exprNodes.Put(exprNode, param); if (param != null) { specParams.Put(param, exprNode); } }
/// <summary> /// Remove a filter parameter leaving the expression node in place. /// </summary> /// <param name="param">filter parameter to remove</param> public void RemoveValue(FilterSpecPlanPathTripletForge param) { var exprNode = specParams.Get(param); if (exprNode == null) { throw new IllegalStateException("Not found in collection param: " + param); } specParams.Remove(param); exprNodes.Put(exprNode, null); }
/// <summary> /// Removes a filter parameter and it's associated expression node /// </summary> /// <param name="param">is the parameter to remove</param> /// <returns>expression node removed</returns> public ExprNode RemoveEntry(FilterSpecPlanPathTripletForge param) { var exprNode = specParams.Get(param); if (exprNode == null) { throw new IllegalStateException("Not found in collection param: " + param); } specParams.Remove(param); exprNodes.Remove(exprNode); return exprNode; }
// consolidate "val != 3 and val != 4 and val != 5" // to "val not in (3, 4, 5)" private static void HandleConsolidateNotEqual( IList<FilterSpecPlanPathTripletForge> parameters, FilterSpecParaForgeMap filterParamExprMap, string statementName) { IList<FilterSpecParamInValueForge> values = new List<FilterSpecParamInValueForge>(); ExprNode lastNotEqualsExprNode = null; foreach (FilterSpecPlanPathTripletForge triplet in parameters) { FilterSpecParamForge paramForge = triplet.Param; if (paramForge is FilterSpecParamConstantForge) { var constantParam = (FilterSpecParamConstantForge) paramForge; var constant = constantParam.FilterConstant; values.Add(new FilterForEvalConstantAnyTypeForge(constant)); } else if (paramForge is FilterSpecParamEventPropForge) { var eventProp = (FilterSpecParamEventPropForge) paramForge; values.Add( new FilterForEvalEventPropForge( eventProp.ResultEventAsName, eventProp.ResultEventProperty, eventProp.ExprIdentNodeEvaluator, eventProp.IsMustCoerce, eventProp.CoercionType.GetBoxedType())); } else if (paramForge is FilterSpecParamEventPropIndexedForge) { var eventProp = (FilterSpecParamEventPropIndexedForge) paramForge; values.Add( new FilterForEvalEventPropIndexedForge( eventProp.ResultEventAsName, eventProp.ResultEventIndex, eventProp.ResultEventProperty, eventProp.EventType, eventProp.IsMustCoerce, eventProp.CoercionType.GetBoxedType())); } else { throw new ArgumentException("Unknown filter parameter:" + paramForge); } lastNotEqualsExprNode = filterParamExprMap.RemoveEntry(triplet); } FilterSpecParamInForge param = new FilterSpecParamInForge( parameters[0].Param.Lookupable, FilterOperator.NOT_IN_LIST_OF_VALUES, values); FilterSpecPlanPathTripletForge tripletForge = new FilterSpecPlanPathTripletForge(param, null); filterParamExprMap.Put(lastNotEqualsExprNode, tripletForge); }