public static void Apply( ExprNode target, ExprNode start, ExprNode end, bool includeStart, bool includeEnd, bool isNot, QueryGraphForge queryGraph) { var rangeOp = QueryGraphRangeEnumExtensions.GetRangeOp(includeStart, includeEnd, isNot); if (target is ExprIdentNode && start is ExprIdentNode && end is ExprIdentNode) { var identNodeValue = (ExprIdentNode) target; var identNodeStart = (ExprIdentNode) start; var identNodeEnd = (ExprIdentNode) end; var keyStreamStart = identNodeStart.StreamId; var keyStreamEnd = identNodeEnd.StreamId; var valueStream = identNodeValue.StreamId; queryGraph.AddRangeStrict( keyStreamStart, identNodeStart, keyStreamEnd, identNodeEnd, valueStream, identNodeValue, rangeOp); return; } // handle constant-compare or transformation case if (target is ExprIdentNode) { var identNode = (ExprIdentNode) target; var indexedStream = identNode.StreamId; var eligibilityStart = EligibilityUtil.VerifyInputStream(start, indexedStream); if (!eligibilityStart.Eligibility.IsEligible()) { return; } var eligibilityEnd = EligibilityUtil.VerifyInputStream(end, indexedStream); if (!eligibilityEnd.Eligibility.IsEligible()) { return; } queryGraph.AddRangeExpr( indexedStream, identNode, start, eligibilityStart.StreamNum, end, eligibilityEnd.StreamNum, rangeOp); } }
private static void AnalyzeInNodeSingleIndex( ExprInNode inNode, QueryGraphForge queryGraph) { if (!(inNode.ChildNodes[0] is ExprIdentNode)) { return; } var testIdent = (ExprIdentNode) inNode.ChildNodes[0]; var testIdentClass = testIdent.Forge.EvaluationType.GetBoxedType(); var indexedStream = testIdent.StreamId; var setExpressions = GetInNodeSetExpressions(inNode); if (setExpressions.Length == 0) { return; } var perStreamExprs = new LinkedHashMap<int?, IList<ExprNode>>(); foreach (var exprNodeSet in setExpressions) { if (exprNodeSet.Forge.EvaluationType.GetBoxedType() != testIdentClass) { continue; } if (exprNodeSet is ExprIdentNode) { var setIdent = (ExprIdentNode) exprNodeSet; AddToList(setIdent.StreamId, setIdent, perStreamExprs); } else { var eligibility = EligibilityUtil.VerifyInputStream(exprNodeSet, indexedStream); if (!eligibility.Eligibility.IsEligible()) { continue; } AddToList(eligibility.StreamNum, exprNodeSet, perStreamExprs); } } foreach (var entry in perStreamExprs) { var exprNodes = ExprNodeUtilityQuery.ToArray(entry.Value); if (entry.Key == null) { queryGraph.AddInSetSingleIndexUnkeyed(testIdent.StreamId, testIdent, exprNodes); continue; } if (entry.Key != indexedStream) { queryGraph.AddInSetSingleIndex(testIdent.StreamId, testIdent, entry.Key.Value, exprNodes); } } }
private static void AnalyzeRelationalOpNode( ExprRelationalOpNode relNode, QueryGraphForge 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; var 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); }
private static void AnalyzeInNodeMultiIndex( ExprInNode inNode, QueryGraphForge queryGraph) { var setExpressions = GetInNodeSetExpressions(inNode); if (setExpressions.Length == 0) { return; } var perStreamExprs = new LinkedHashMap<int?, IList<ExprNode>>(); foreach (var exprNodeSet in setExpressions) { if (!(exprNodeSet is ExprIdentNode)) { continue; } var setIdent = (ExprIdentNode) exprNodeSet; AddToList(setIdent.StreamId, setIdent, perStreamExprs); } if (perStreamExprs.IsEmpty()) { return; } var testExpr = inNode.ChildNodes[0]; var testExprType = testExpr.Forge.EvaluationType.GetBoxedType(); if (perStreamExprs.Count > 1) { return; } var entry = perStreamExprs.First(); var exprNodes = ExprNodeUtilityQuery.ToArray(entry.Value); foreach (var node in exprNodes) { var exprType = node.Forge.EvaluationType; if (exprType.GetBoxedType() != testExprType) { return; } } int? testStreamNum; var setStream = entry.Key.Value; if (!(testExpr is ExprIdentNode)) { var eligibility = EligibilityUtil.VerifyInputStream(testExpr, setStream); if (!eligibility.Eligibility.IsEligible()) { return; } if (eligibility.Eligibility == Eligibility.REQUIRE_ONE && setStream == eligibility.StreamNum) { return; } testStreamNum = eligibility.StreamNum; } else { testStreamNum = ((ExprIdentNode) testExpr).StreamId; } if (testStreamNum == null) { queryGraph.AddInSetMultiIndexUnkeyed(testExpr, setStream, exprNodes); } else { if (testStreamNum.Equals(entry.Key)) { return; } queryGraph.AddInSetMultiIndex(testStreamNum.Value, testExpr, setStream, exprNodes); } }
/// <summary> /// Analye EQUALS (=) node. /// </summary> /// <param name="equalsNode">node to analyze</param> /// <param name="queryGraph">store relationships between stream properties</param> /// <param name="isOuterJoin">indicator for outer join</param> protected internal static void AnalyzeEqualsNode( ExprEqualsNode equalsNode, QueryGraphForge 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); } }