public void AddRelOp(ExprNode propertyKey, QueryGraphRangeEnum op, ExprIdentNode propertyValueIdent, bool isBetweenOrIn) { // Note: Read as follows: // Console.WriteLine("If I have an index on '" + propertyValue + "' I'm evaluating " + propertyKey + " and finding all values of " + propertyValue + " " + op + " then " + propertyKey); // Check if there is an opportunity to convert this to a range or remove an earlier specification var existing = FindIdentEntry(propertyValueIdent); if (existing == null) { _items.Add(new QueryGraphValueDesc(new ExprNode[] { propertyValueIdent }, new QueryGraphValueEntryRangeRelOp(op, propertyKey, isBetweenOrIn))); return; } if (!(existing.Entry is QueryGraphValueEntryRangeRelOp)) { return; // another comparison exists already, don't add range } var relOp = (QueryGraphValueEntryRangeRelOp)existing.Entry; var opsDesc = QueryGraphRangeUtil.GetCanConsolidate(op, relOp.RangeType); if (opsDesc != null) { var start = !opsDesc.IsReverse ? relOp.Expression : propertyKey; var end = !opsDesc.IsReverse ? propertyKey : relOp.Expression; _items.Remove(existing); AddRange(opsDesc.RangeType, start, end, propertyValueIdent); } }
public override EventType GetEventTypeCollection(EventAdapterService eventAdapterService, string statementId) { var selectClause = SelectClause; var rawEventType = RawEventType; if (selectClause == null) // wildcards allowed { return(rawEventType); } // special case: selecting a single property that is itself an event if (selectClause.Length == 1 && selectClause[0] is ExprIdentNode) { ExprIdentNode identNode = (ExprIdentNode)selectClause[0]; FragmentEventType fragment = rawEventType.GetFragmentType(identNode.ResolvedPropertyName); if (fragment != null && !fragment.IsIndexed) { return(fragment.FragmentType); } } // select of a single value otherwise results in a collection of scalar values if (selectClause.Length == 1) { return(null); } // fully-aggregated always returns zero or one row if (SubselectAggregationType == SubqueryAggregationType.FULLY_AGGREGATED) { return(null); } return(GetAssignAnonymousType(eventAdapterService, statementId)); }
public void AddRangeExpr(int indexedStream, ExprIdentNode indexedProp, ExprNode startNode, int? optionalStartStreamNum, ExprNode endNode, int? optionalEndStreamNum) { if (optionalStartStreamNum == null && optionalEndStreamNum == null) { for (var i = 0; i < _numStreams; i++) { if (i == indexedStream) { continue; } InternalAddRange(i, indexedStream, QueryGraphRangeEnum.RANGE_CLOSED, startNode, endNode, indexedProp); } return; } optionalStartStreamNum = optionalStartStreamNum ?? -1; optionalEndStreamNum = optionalEndStreamNum ?? -1; // add for a specific stream only if (optionalStartStreamNum.Equals(optionalEndStreamNum) || optionalEndStreamNum.Equals(-1)) { InternalAddRange(optionalStartStreamNum.Value, indexedStream, QueryGraphRangeEnum.RANGE_CLOSED, startNode, endNode, indexedProp); } if (optionalStartStreamNum.Equals(-1)) { InternalAddRange(optionalEndStreamNum.Value, indexedStream, QueryGraphRangeEnum.RANGE_CLOSED, startNode, endNode, indexedProp); } }
public void AddKeyedExpression( int indexedStream, ExprIdentNode indexedProp, int keyExprStream, ExprNode exprNodeNoIdent) { Check(indexedStream, keyExprStream); InternalAddEqualsNoProp(keyExprStream, indexedStream, indexedProp, exprNodeNoIdent); }
private static FilterSpecParam HandleProperty( FilterOperator op, ExprIdentNode identNodeLeft, ExprIdentNode identNodeRight, IDictionary<string, Pair<EventType, string>> arrayEventTypes, string statementName) { var propertyName = identNodeLeft.ResolvedPropertyName; var leftType = identNodeLeft.ExprEvaluator.ReturnType; var rightType = identNodeRight.ExprEvaluator.ReturnType; var numberCoercer = GetNumberCoercer(leftType, rightType, propertyName); var isMustCoerce = numberCoercer != null; var numericCoercionType = leftType.GetBoxedType(); var streamName = identNodeRight.ResolvedStreamName; if (arrayEventTypes != null && !arrayEventTypes.IsEmpty() && arrayEventTypes.ContainsKey(streamName)) { var indexAndProp = GetStreamIndex(identNodeRight.ResolvedPropertyName); return new FilterSpecParamEventPropIndexed( identNodeLeft.FilterLookupable, op, identNodeRight.ResolvedStreamName, indexAndProp.First.Value, indexAndProp.Second, isMustCoerce, numberCoercer, numericCoercionType, statementName); } return new FilterSpecParamEventProp( identNodeLeft.FilterLookupable, op, identNodeRight.ResolvedStreamName, identNodeRight.ResolvedPropertyName, isMustCoerce, numberCoercer, numericCoercionType, statementName); }
/// <summary>Analyzes the outer join descriptor list to build a query graph model. </summary> /// <param name="outerJoinDescList">list of outer join descriptors</param> /// <param name="queryGraph">model containing relationships between streams that is written into</param> /// <returns>queryGraph object</returns> public static QueryGraph Analyze(OuterJoinDesc[] outerJoinDescList, QueryGraph queryGraph) { foreach (OuterJoinDesc outerJoinDesc in outerJoinDescList) { // add optional on-expressions if (outerJoinDesc.OptLeftNode != null) { ExprIdentNode identNodeLeft = outerJoinDesc.OptLeftNode; ExprIdentNode identNodeRight = outerJoinDesc.OptRightNode; Add(queryGraph, identNodeLeft, identNodeRight); if (outerJoinDesc.AdditionalLeftNodes != null) { for (int i = 0; i < outerJoinDesc.AdditionalLeftNodes.Length; i++) { Add(queryGraph, outerJoinDesc.AdditionalLeftNodes[i], outerJoinDesc.AdditionalRightNodes[i]); } } } else { } } return queryGraph; }
public void Apply(QueryGraph queryGraph) { ExprIdentNode targetExpr = ExprNodeUtility.GetExprIdentNode(_typesPerStream, _targetStreamNum, _targetPropertyName); RangeFilterAnalyzer.Apply(targetExpr, _start, _end, _includeLow, _includeHigh, false, queryGraph); }
private static FilterSpecParamFilterForEvalDoubleForge GetIdentNodeDoubleEval( ExprIdentNode node, IDictionary<string, Pair<EventType, string>> arrayEventTypes, string statementName) { if (node.StreamId == 0) { return null; } if (arrayEventTypes != null && !arrayEventTypes.IsEmpty() && arrayEventTypes.ContainsKey(node.ResolvedStreamName)) { var indexAndProp = GetStreamIndex(node.ResolvedPropertyName); var eventType = GetArrayInnerEventType(arrayEventTypes, node.ResolvedStreamName); return new FilterForEvalEventPropIndexedDoubleForge( node.ResolvedStreamName, indexAndProp.First, indexAndProp.Second, eventType); } return new FilterForEvalEventPropDoubleForge( node.ResolvedStreamName, node.ResolvedPropertyName, node.ExprEvaluatorIdent); }
public ExprIdentNodeEvaluatorImpl(int streamNum, EventPropertyGetter propertyGetter, Type propertyType, ExprIdentNode identNode) { _streamNum = streamNum; _propertyGetter = propertyGetter; _propertyType = propertyType; // .GetBoxedType(); _identNode = identNode; }
/// <summary> /// Add key and index property. /// </summary> /// <param name="keyProperty">key property</param> /// <param name="indexPropertyIdent">index property</param> /// <param name="keyPropNode">key node</param> /// <returns>true if added and either property did not exist, false if either already existed</returns> public bool AddStrictCompare( string keyProperty, ExprIdentNode keyPropNode, ExprIdentNode indexPropertyIdent) { var value = FindIdentEntry(indexPropertyIdent); if (value != null && value.Entry is QueryGraphValueEntryHashKeyedForgeExpr) { // if this index property exists and is compared to a constant, ignore the index prop var expr = (QueryGraphValueEntryHashKeyedForgeExpr) value.Entry; if (expr.IsConstant) { return false; } } if (value != null && value.Entry is QueryGraphValueEntryHashKeyedForgeProp) { return false; // second comparison, ignore } Items.Add( new QueryGraphValueDescForge( new ExprNode[] {indexPropertyIdent}, new QueryGraphValueEntryHashKeyedForgeProp( keyPropNode, keyProperty, keyPropNode.ExprEvaluatorIdent.Getter))); return true; }
/// <summary> /// Analye EQUALS (=) node. /// </summary> /// <param name="equalsNode">node to analyze</param> /// <param name="queryGraph">store relationships between stream properties</param> /// <param name="isOuterJoin">if set to <c>true</c> [is outer join].</param> internal static void AnalyzeEqualsNode(ExprEqualsNode equalsNode, QueryGraph queryGraph, bool isOuterJoin) { if ((equalsNode.ChildNodes[0] is ExprIdentNode) && (equalsNode.ChildNodes[1] is ExprIdentNode)) { var identNodeLeft = (ExprIdentNode)equalsNode.ChildNodes[0]; var identNodeRight = (ExprIdentNode)equalsNode.ChildNodes[1]; if (identNodeLeft.StreamId != identNodeRight.StreamId) { queryGraph.AddStrictEquals(identNodeLeft.StreamId, identNodeLeft.ResolvedPropertyName, identNodeLeft, identNodeRight.StreamId, identNodeRight.ResolvedPropertyName, identNodeRight); } return; } if (isOuterJoin) // outerjoins don't use constants or one-way expression-derived information to evaluate join { return; } // handle constant-compare or transformation case var indexedStream = -1; ExprIdentNode indexedPropExpr = null; ExprNode exprNodeNoIdent = null; if (equalsNode.ChildNodes[0] is ExprIdentNode) { indexedPropExpr = (ExprIdentNode)equalsNode.ChildNodes[0]; indexedStream = indexedPropExpr.StreamId; exprNodeNoIdent = equalsNode.ChildNodes[1]; } else if (equalsNode.ChildNodes[1] is ExprIdentNode) { indexedPropExpr = (ExprIdentNode)equalsNode.ChildNodes[1]; indexedStream = indexedPropExpr.StreamId; exprNodeNoIdent = equalsNode.ChildNodes[0]; } if (indexedStream == -1) { return; // require property of right/left side of equals } var eligibility = EligibilityUtil.VerifyInputStream(exprNodeNoIdent, indexedStream); if (!eligibility.Eligibility.IsEligible()) { return; } if (eligibility.Eligibility == Eligibility.REQUIRE_NONE) { queryGraph.AddUnkeyedExpression(indexedStream, indexedPropExpr, exprNodeNoIdent); } else { queryGraph.AddKeyedExpression(indexedStream, indexedPropExpr, eligibility.StreamNum.Value, exprNodeNoIdent); } }
/// <summary>Ctor. </summary> /// <param name="outerJoinType">type of the outer join</param> /// <param name="optLeftNode">left hand identifier node</param> /// <param name="optRightNode">right hand identifier node</param> /// <param name="optAddLeftNode">additional optional left hand identifier nodes for the on-clause in a logical-and</param> /// <param name="optAddRightNode">additional optional right hand identifier nodes for the on-clause in a logical-and</param> public OuterJoinDesc(OuterJoinType outerJoinType, ExprIdentNode optLeftNode, ExprIdentNode optRightNode, ExprIdentNode[] optAddLeftNode, ExprIdentNode[] optAddRightNode) { OuterJoinType = outerJoinType; OptLeftNode = optLeftNode; OptRightNode = optRightNode; AdditionalLeftNodes = optAddLeftNode; AdditionalRightNodes = optAddRightNode; }
public void AddRelationalOpStrict(int streamIdLeft, ExprIdentNode propertyLeftExpr, int streamIdRight, ExprIdentNode propertyRightExpr, RelationalOpEnum relationalOpEnum) { Check(streamIdLeft, streamIdRight); InternalAddRelOp(streamIdLeft, streamIdRight, propertyLeftExpr, QueryGraphRangeEnumExtensions.MapFrom(relationalOpEnum.Reversed()), propertyRightExpr, false); InternalAddRelOp(streamIdRight, streamIdLeft, propertyRightExpr, QueryGraphRangeEnumExtensions.MapFrom(relationalOpEnum), propertyLeftExpr, false); }
public void AddKeyedExpr( ExprIdentNode indexedPropIdent, ExprNode exprNodeNoIdent) { Items.Add( new QueryGraphValueDescForge( new ExprNode[] {indexedPropIdent}, new QueryGraphValueEntryHashKeyedForgeExpr(exprNodeNoIdent, true))); }
private void TryInvalidValidate(ExprIdentNode identNode) { try { identNode.Validate(ExprValidationContextFactory.Make(_streamTypeService)); Assert.Fail(); } catch (ExprValidationException ex) { // expected } }
private static void ValidateBuiltin( CreateIndexItem columnDesc, EventType eventType, IList <IndexedPropDesc> hashProps, IList <IndexedPropDesc> btreeProps, ISet <string> indexedColumns) { if (columnDesc.Expressions.IsEmpty()) { throw new ExprValidationException("Invalid empty list of index expressions"); } if (columnDesc.Expressions.Count > 1) { throw new ExprValidationException("Invalid multiple index expressions for index type '" + columnDesc.IndexType + "'"); } ExprNode expression = columnDesc.Expressions[0]; if (!(expression is ExprIdentNode)) { throw new ExprValidationException("Invalid index expression '" + expression.ToExpressionStringMinPrecedenceSafe() + "'"); } ExprIdentNode identNode = (ExprIdentNode)expression; if (identNode.FullUnresolvedName.Contains(".")) { throw new ExprValidationException("Invalid index expression '" + expression.ToExpressionStringMinPrecedenceSafe() + "'"); } string columnName = identNode.FullUnresolvedName; Type type = eventType.GetPropertyType(columnName).GetBoxedType(); if (type == null) { throw new ExprValidationException("Property named '" + columnName + "' not found"); } if (!indexedColumns.Add(columnName)) { throw new ExprValidationException("Property named '" + columnName + "' has been declared more then once"); } var desc = new IndexedPropDesc(columnName, type); string indexType = columnDesc.IndexType; if (string.Equals(indexType, CreateIndexType.HASH.ToString(), StringComparison.InvariantCultureIgnoreCase)) { hashProps.Add(desc); } else { btreeProps.Add(desc); } }
private static void Add( QueryGraphForge queryGraph, ExprIdentNode identNodeLeft, ExprIdentNode identNodeRight) { queryGraph.AddStrictEquals( identNodeLeft.StreamId, identNodeLeft.ResolvedPropertyName, identNodeLeft, identNodeRight.StreamId, identNodeRight.ResolvedPropertyName, identNodeRight); }
private void InternalAddEqualsUnkeyed(int streamKey, int streamValue, ExprIdentNode indexedProp, ExprNode exprNodeNoIdent) { if (_nToZeroAnalysis && streamValue != 0) { return; } if (_optionalHint != null && _optionalHint.Filter(streamKey, streamValue, ExcludePlanFilterOperatorType.EQUALS)) { return; } var value = GetCreateValue(streamKey, streamValue); value.AddUnkeyedExpr(indexedProp, exprNodeNoIdent); }
private bool InternalAddEquals(int streamLookup, String propertyLookup, ExprIdentNode propertyLookupNode, int streamIndexed, ExprIdentNode propertyIndexedNode) { if (_nToZeroAnalysis && streamIndexed != 0) { return false; } if (_optionalHint != null && _optionalHint.Filter(streamLookup, propertyIndexedNode.StreamId, ExcludePlanFilterOperatorType.EQUALS, propertyLookupNode, propertyIndexedNode)) { return false; } var value = GetCreateValue(streamLookup, streamIndexed); return value.AddStrictCompare(propertyLookup, propertyLookupNode, propertyIndexedNode); }
private void InternalAddEqualsNoProp(int keyExprStream, int indexedStream, ExprIdentNode indexedProp, ExprNode exprNodeNoIdent) { if (_nToZeroAnalysis && indexedStream != 0) { return; } if (_optionalHint != null && _optionalHint.Filter(keyExprStream, indexedStream, ExcludePlanFilterOperatorType.EQUALS)) { return; } var value = GetCreateValue(keyExprStream, indexedStream); value.AddKeyedExpr(indexedProp, exprNodeNoIdent); }
private static void AnalyzeRelationalOpNode(ExprRelationalOpNode relNode, QueryGraph queryGraph) { if (((relNode.ChildNodes[0] is ExprIdentNode)) && ((relNode.ChildNodes[1] is ExprIdentNode))) { var identNodeLeft = (ExprIdentNode)relNode.ChildNodes[0]; var identNodeRight = (ExprIdentNode)relNode.ChildNodes[1]; if (identNodeLeft.StreamId != identNodeRight.StreamId) { queryGraph.AddRelationalOpStrict( identNodeLeft.StreamId, identNodeLeft, identNodeRight.StreamId, identNodeRight, relNode.RelationalOpEnum); } return; } var indexedStream = -1; ExprIdentNode indexedPropExpr = null; ExprNode exprNodeNoIdent = null; RelationalOpEnum relop = relNode.RelationalOpEnum; if (relNode.ChildNodes[0] is ExprIdentNode) { indexedPropExpr = (ExprIdentNode)relNode.ChildNodes[0]; indexedStream = indexedPropExpr.StreamId; exprNodeNoIdent = relNode.ChildNodes[1]; } else if (relNode.ChildNodes[1] is ExprIdentNode) { indexedPropExpr = (ExprIdentNode)relNode.ChildNodes[1]; indexedStream = indexedPropExpr.StreamId; exprNodeNoIdent = relNode.ChildNodes[0]; relop = relop.Reversed(); } if (indexedStream == -1) { return; // require property of right/left side of equals } var eligibility = EligibilityUtil.VerifyInputStream(exprNodeNoIdent, indexedStream); if (!eligibility.Eligibility.IsEligible()) { return; } queryGraph.AddRelationalOp(indexedStream, indexedPropExpr, eligibility.StreamNum, exprNodeNoIdent, relop); }
public override ExprNode Validate(ExprValidationContext validationContext) { if (ChildNodes.Length != 1) { throw new ExprValidationException("Exists function node must have exactly 1 child node"); } if (!(ChildNodes[0] is ExprIdentNode)) { throw new ExprValidationException( "Exists function expects an property value expression as the child node"); } identNode = (ExprIdentNode) ChildNodes[0]; return null; }
internal void AddRangeStrict( int streamNumStart, ExprIdentNode propertyStartExpr, int streamNumEnd, ExprIdentNode propertyEndExpr, int streamNumValue, ExprIdentNode propertyValueExpr, QueryGraphRangeEnum rangeOp) { Check(streamNumStart, streamNumValue); Check(streamNumEnd, streamNumValue); // add as a range if the endpoints are from the same stream if (streamNumStart == streamNumEnd && streamNumStart != streamNumValue) { InternalAddRange( streamNumStart, streamNumValue, rangeOp, propertyStartExpr, propertyEndExpr, propertyValueExpr); InternalAddRelOp( streamNumValue, streamNumStart, propertyValueExpr, QueryGraphRangeEnum.GREATER_OR_EQUAL, propertyEndExpr, false); InternalAddRelOp( streamNumValue, streamNumStart, propertyValueExpr, QueryGraphRangeEnum.LESS_OR_EQUAL, propertyStartExpr, false); } else { // endpoints from a different stream, add individually if (streamNumValue != streamNumStart) { // read propertyValue >= propertyStart InternalAddRelOp( streamNumStart, streamNumValue, propertyStartExpr, QueryGraphRangeEnum.GREATER_OR_EQUAL, propertyValueExpr, true); // read propertyStart <= propertyValue InternalAddRelOp( streamNumValue, streamNumStart, propertyValueExpr, QueryGraphRangeEnum.LESS_OR_EQUAL, propertyStartExpr, true); } if (streamNumValue != streamNumEnd) { // read propertyValue <= propertyEnd InternalAddRelOp( streamNumEnd, streamNumValue, propertyEndExpr, QueryGraphRangeEnum.LESS_OR_EQUAL, propertyValueExpr, true); // read propertyEnd >= propertyValue InternalAddRelOp( streamNumValue, streamNumEnd, propertyValueExpr, QueryGraphRangeEnum.GREATER_OR_EQUAL, propertyEndExpr, true); } } }
public static Pair<string, ExprNode> CheckGetAssignmentToProp(ExprNode node) { if (!(node is ExprEqualsNode)) { return null; } ExprEqualsNode equals = (ExprEqualsNode) node; if (!(equals.ChildNodes[0] is ExprIdentNode)) { return null; } ExprIdentNode identNode = (ExprIdentNode) equals.ChildNodes[0]; return new Pair<string, ExprNode>(identNode.FullUnresolvedName, equals.ChildNodes[1]); }
public void TestGetNavigableStreams() { ExprIdentNode fake = supportExprNodeFactory.MakeIdentNode("TheString", "s0"); queryGraph = new QueryGraphForge(5, null, false); queryGraph.AddStrictEquals(3, "p3", fake, 4, "p4", fake); queryGraph.AddStrictEquals(2, "P2", fake, 3, "p3", fake); queryGraph.AddStrictEquals(1, "P1", fake, 2, "P2", fake); Assert.AreEqual(0, queryGraph.GetNavigableStreams(0).Count); EPAssertionUtil.AssertEqualsAnyOrder(new int[] { 2 }, queryGraph.GetNavigableStreams(1)); EPAssertionUtil.AssertEqualsAnyOrder(new int[] { 1, 3 }, queryGraph.GetNavigableStreams(2)); EPAssertionUtil.AssertEqualsAnyOrder(new int[] { 2, 4 }, queryGraph.GetNavigableStreams(3)); EPAssertionUtil.AssertEqualsAnyOrder(new int[] { 3 }, queryGraph.GetNavigableStreams(4)); }
public void AddUnkeyedExpression(int indexedStream, ExprIdentNode indexedProp, ExprNode exprNodeNoIdent) { if (indexedStream < 0 || indexedStream >= _numStreams) { throw new ArgumentException("Invalid indexed stream " + indexedStream); } for (var i = 0; i < _numStreams; i++) { if (i != indexedStream) { InternalAddEqualsUnkeyed(i, indexedStream, indexedProp, exprNodeNoIdent); } } }
private QueryGraphValueDescForge FindIdentEntry(ExprIdentNode search) { foreach (var desc in Items) { if (desc.IndexExprs.Length > 1 || !(desc.IndexExprs[0] is ExprIdentNode)) { continue; } var other = (ExprIdentNode) desc.IndexExprs[0]; if (search.ResolvedPropertyName.Equals(other.ResolvedPropertyName)) { return desc; } } return null; }
private void TryAdd(string propertyKeyOne, QueryGraphRangeEnum opOne, ExprIdentNode valueOne, string propertyKeyTwo, QueryGraphRangeEnum opTwo, ExprIdentNode valueTwo, object[][] expected) { var value = new QueryGraphValue(); value.AddRelOp(MakeIdent(propertyKeyOne), opOne, valueOne, true); value.AddRelOp(MakeIdent(propertyKeyTwo), opTwo, valueTwo, true); AssertRanges(expected, value); value = new QueryGraphValue(); value.AddRelOp(MakeIdent(propertyKeyTwo), opTwo, valueTwo, true); value.AddRelOp(MakeIdent(propertyKeyOne), opOne, valueOne, true); AssertRanges(expected, value); }
private static bool IsColumnNameNode(ExprNode node, String name) { if (node is ExprIdentNode) { if (node.ChildNodes.Count > 0) { throw new IllegalStateException("Ident node has unexpected child nodes"); } ExprIdentNode identNode = (ExprIdentNode)node; return(identNode.UnresolvedPropertyName.Equals(name) && identNode.StreamOrPropertyName == null); } else { return(false); } }
private QueryGraphValueDesc FindIdentEntry(ExprIdentNode search) { foreach (var desc in _items) { if (desc.IndexExprs.Count > 1 || !(desc.IndexExprs[0] is ExprIdentNode)) { continue; } var other = (ExprIdentNode)desc.IndexExprs[0]; if (search.ResolvedPropertyName.Equals(other.ResolvedPropertyName)) { return(desc); } } return(null); }