private QueryGraphForge MakeQueryGraph()
{
var graph = new QueryGraphForge(2, null, false);
graph.AddStrictEquals(0, "P01", Make(0, "P01"), 1, "P11", Make(1, "P11"));
graph.AddStrictEquals(0, "P02", Make(0, "P02"), 1, "P12", Make(1, "P12"));
return(graph);
}
public void TestIndexAlreadyExists()
{
queryGraph = new QueryGraphForge(5, null, false);
queryGraph.AddStrictEquals(0, "P00", Make(0, "P00"), 1, "P10", Make(1, "P10"));
queryGraph.AddStrictEquals(0, "P00", Make(0, "P00"), 2, "P20", Make(2, "P20"));
var indexes = QueryPlanIndexBuilder.BuildIndexSpec(queryGraph, types, new string[queryGraph.NumStreams][][]);
string[][] expected = { new string[] { "P00" } };
EPAssertionUtil.AssertEqualsExactOrder(expected, indexes[0].IndexProps);
}
public void TestRecursiveBuild()
{
var streamNum = 2;
var queryGraph = new QueryGraphForge(6, null, false);
var outerInnerGraph = new OuterInnerDirectionalGraph(6);
var completedStreams = new HashSet <int>();
var substreamsPerStream = new LinkedHashMap <int, int[]>();
var requiredPerStream = new bool[6];
outerInnerGraph.Add(3, 2).Add(2, 1).Add(4, 3).Add(1, 0).Add(3, 5);
var fake = supportExprNodeFactory.MakeIdentNode("TheString", "s0");
queryGraph.AddStrictEquals(2, "", fake, 3, "", fake);
queryGraph.AddStrictEquals(3, "", fake, 4, "", fake);
queryGraph.AddStrictEquals(3, "", fake, 5, "", fake);
queryGraph.AddStrictEquals(2, "", fake, 1, "", fake);
queryGraph.AddStrictEquals(1, "", fake, 0, "", fake);
ISet <InterchangeablePair <int, int> > innerJoins = new HashSet <InterchangeablePair <int, int> >();
var innerJoinGraph = new InnerJoinGraph(6, innerJoins);
var streamStack = new Stack <int>();
NStreamOuterQueryPlanBuilder.RecursiveBuild(
streamNum,
streamStack,
queryGraph,
outerInnerGraph,
innerJoinGraph,
completedStreams,
substreamsPerStream,
requiredPerStream,
new DependencyGraph(6, false));
Assert.AreEqual(6, substreamsPerStream.Count);
EPAssertionUtil.AssertEqualsExactOrder(substreamsPerStream.Get(2), new[] { 3, 1 });
EPAssertionUtil.AssertEqualsExactOrder(substreamsPerStream.Get(3), new[] { 4, 5 });
EPAssertionUtil.AssertEqualsExactOrder(substreamsPerStream.Get(1), new[] { 0 });
EPAssertionUtil.AssertEqualsExactOrder(substreamsPerStream.Get(4), new int[] { });
EPAssertionUtil.AssertEqualsExactOrder(substreamsPerStream.Get(5), new int[] { });
EPAssertionUtil.AssertEqualsExactOrder(substreamsPerStream.Get(0), new int[] { });
NStreamOuterQueryPlanBuilder.VerifyJoinedPerStream(2, substreamsPerStream);
EPAssertionUtil.AssertEqualsExactOrder(
requiredPerStream,
new[] { false, false, false, true, true, false }
);
}
public void SetUp()
{
types = new[] {
supportEventTypeFactory.CreateMapType(CreateType("P00,P01")),
supportEventTypeFactory.CreateMapType(CreateType("P10")),
supportEventTypeFactory.CreateMapType(CreateType("P20,P21")),
supportEventTypeFactory.CreateMapType(CreateType("P30,P31")),
supportEventTypeFactory.CreateMapType(CreateType("P40,P41,P42"))
};
queryGraph = new QueryGraphForge(5, null, false);
queryGraph.AddStrictEquals(0, "P00", Make(0, "P00"), 1, "P10", Make(1, "P10"));
queryGraph.AddStrictEquals(0, "P01", Make(0, "P01"), 2, "P20", Make(2, "P20"));
queryGraph.AddStrictEquals(4, "P40", Make(4, "P40"), 3, "P30", Make(3, "P30"));
queryGraph.AddStrictEquals(4, "P41", Make(4, "P41"), 3, "P31", Make(3, "P31"));
queryGraph.AddStrictEquals(4, "P42", Make(4, "P42"), 2, "P21", Make(2, "P21"));
}
public void SetUp()
{
typesPerStream = new EventType[] {
supportEventTypeFactory.CreateBeanType(typeof(SupportBean_S0)),
supportEventTypeFactory.CreateBeanType(typeof(SupportBean_S1)),
supportEventTypeFactory.CreateBeanType(typeof(SupportBean_S2)),
supportEventTypeFactory.CreateBeanType(typeof(SupportBean_S3)),
supportEventTypeFactory.CreateBeanType(typeof(SupportBean_S4))
};
queryGraph = new QueryGraphForge(5, null, false);
queryGraph.AddStrictEquals(0, "P00", Make(0, "P00"), 1, "P10", Make(1, "P10"));
queryGraph.AddStrictEquals(0, "P01", Make(0, "P01"), 2, "P20", Make(2, "P20"));
queryGraph.AddStrictEquals(4, "P40", Make(4, "P40"), 3, "P30", Make(3, "P30"));
queryGraph.AddStrictEquals(4, "P41", Make(4, "P41"), 3, "P31", Make(3, "P31"));
queryGraph.AddStrictEquals(4, "P42", Make(4, "P42"), 2, "P21", Make(2, "P21"));
dependencyGraph = new DependencyGraph(5, false);
}
public void TestComputeNavigableDepth()
{
ExprIdentNode fake = supportExprNodeFactory.MakeIdentNode("TheString", "s0");
queryGraph.AddStrictEquals(3, "P30", fake, 2, "P20", fake);
queryGraph.AddStrictEquals(2, "P30", fake, 1, "P20", fake);
int depth = NStreamQueryPlanBuilder.ComputeNavigableDepth(0, new int[] { 1, 2, 3, 4 }, queryGraph);
Assert.AreEqual(4, depth);
depth = NStreamQueryPlanBuilder.ComputeNavigableDepth(0, new int[] { 4, 2, 3, 1 }, queryGraph);
Assert.AreEqual(0, depth);
depth = NStreamQueryPlanBuilder.ComputeNavigableDepth(4, new int[] { 3, 2, 1, 0 }, queryGraph);
Assert.AreEqual(4, depth);
depth = NStreamQueryPlanBuilder.ComputeNavigableDepth(1, new int[] { 0, 3, 4, 2 }, queryGraph);
Assert.AreEqual(1, depth);
}
private static void Add(
QueryGraphForge queryGraph,
ExprIdentNode identNodeLeft,
ExprIdentNode identNodeRight)
{
queryGraph.AddStrictEquals(
identNodeLeft.StreamId,
identNodeLeft.ResolvedPropertyName,
identNodeLeft,
identNodeRight.StreamId,
identNodeRight.ResolvedPropertyName,
identNodeRight);
}
public void Apply(QueryGraphForge filterQueryGraph)
{
if (targetStreamNum == parameterStreamNum) {
return;
}
var targetStartExpr = ExprNodeUtilityMake.MakeExprIdentNode(
typesPerStream,
targetStreamNum,
targetStartProp);
var targetEndExpr = ExprNodeUtilityMake.MakeExprIdentNode(typesPerStream, targetStreamNum, targetEndProp);
var parameterStartExpr = ExprNodeUtilityMake.MakeExprIdentNode(
typesPerStream,
parameterStreamNum,
parameterStartProp);
var parameterEndExpr = ExprNodeUtilityMake.MakeExprIdentNode(
typesPerStream,
parameterStreamNum,
parameterEndProp);
if (targetStartExpr.Forge.EvaluationType != parameterStartExpr.Forge.EvaluationType) {
return;
}
if (currentMethod == DateTimeMethodEnum.BEFORE) {
// a.end < b.start
filterQueryGraph.AddRelationalOpStrict(
targetStreamNum,
targetEndExpr,
parameterStreamNum,
parameterStartExpr,
RelationalOpEnum.LT);
}
else if (currentMethod == DateTimeMethodEnum.AFTER) {
// a.start > b.end
filterQueryGraph.AddRelationalOpStrict(
targetStreamNum,
targetStartExpr,
parameterStreamNum,
parameterEndExpr,
RelationalOpEnum.GT);
}
else if (currentMethod == DateTimeMethodEnum.COINCIDES) {
// a.startTimestamp = b.startTimestamp and a.endTimestamp = b.endTimestamp
filterQueryGraph.AddStrictEquals(
targetStreamNum,
targetStartProp,
targetStartExpr,
parameterStreamNum,
parameterStartProp,
parameterStartExpr);
var noDuration = parameterEndProp.Equals(parameterStartProp) && targetEndProp.Equals(targetStartProp);
if (!noDuration) {
var leftEndExpr = ExprNodeUtilityMake.MakeExprIdentNode(
typesPerStream,
targetStreamNum,
targetEndProp);
var rightEndExpr = ExprNodeUtilityMake.MakeExprIdentNode(
typesPerStream,
parameterStreamNum,
parameterEndProp);
filterQueryGraph.AddStrictEquals(
targetStreamNum,
targetEndProp,
leftEndExpr,
parameterStreamNum,
parameterEndProp,
rightEndExpr);
}
}
else if (currentMethod == DateTimeMethodEnum.DURING || currentMethod == DateTimeMethodEnum.INCLUDES) {
// DURING: b.startTimestamp < a.startTimestamp <= a.endTimestamp < b.endTimestamp
// INCLUDES: a.startTimestamp < b.startTimestamp <= b.endTimestamp < a.endTimestamp
var relop = currentMethod == DateTimeMethodEnum.DURING ? RelationalOpEnum.LT : RelationalOpEnum.GT;
filterQueryGraph.AddRelationalOpStrict(
parameterStreamNum,
parameterStartExpr,
targetStreamNum,
targetStartExpr,
relop);
filterQueryGraph.AddRelationalOpStrict(
targetStreamNum,
targetEndExpr,
parameterStreamNum,
parameterEndExpr,
relop);
}
else if (currentMethod == DateTimeMethodEnum.FINISHES || currentMethod == DateTimeMethodEnum.FINISHEDBY) {
// FINISHES: b.startTimestamp < a.startTimestamp and a.endTimestamp = b.endTimestamp
// FINISHEDBY: a.startTimestamp < b.startTimestamp and a.endTimestamp = b.endTimestamp
var relop = currentMethod == DateTimeMethodEnum.FINISHES ? RelationalOpEnum.LT : RelationalOpEnum.GT;
filterQueryGraph.AddRelationalOpStrict(
parameterStreamNum,
parameterStartExpr,
targetStreamNum,
targetStartExpr,
relop);
filterQueryGraph.AddStrictEquals(
targetStreamNum,
targetEndProp,
targetEndExpr,
parameterStreamNum,
parameterEndProp,
parameterEndExpr);
}
else if (currentMethod == DateTimeMethodEnum.MEETS) {
// a.endTimestamp = b.startTimestamp
filterQueryGraph.AddStrictEquals(
targetStreamNum,
targetEndProp,
targetEndExpr,
parameterStreamNum,
parameterStartProp,
parameterStartExpr);
}
else if (currentMethod == DateTimeMethodEnum.METBY) {
// a.startTimestamp = b.endTimestamp
filterQueryGraph.AddStrictEquals(
targetStreamNum,
targetStartProp,
targetStartExpr,
parameterStreamNum,
parameterEndProp,
parameterEndExpr);
}
else if (currentMethod == DateTimeMethodEnum.OVERLAPS || currentMethod == DateTimeMethodEnum.OVERLAPPEDBY) {
// OVERLAPS: a.startTimestamp < b.startTimestamp < a.endTimestamp < b.endTimestamp
// OVERLAPPEDBY: b.startTimestamp < a.startTimestamp < b.endTimestamp < a.endTimestamp
var relop = currentMethod == DateTimeMethodEnum.OVERLAPS ? RelationalOpEnum.LT : RelationalOpEnum.GT;
filterQueryGraph.AddRelationalOpStrict(
targetStreamNum,
targetStartExpr,
parameterStreamNum,
parameterStartExpr,
relop);
filterQueryGraph.AddRelationalOpStrict(
targetStreamNum,
targetEndExpr,
parameterStreamNum,
parameterEndExpr,
relop);
if (currentMethod == DateTimeMethodEnum.OVERLAPS) {
filterQueryGraph.AddRelationalOpStrict(
parameterStreamNum,
parameterStartExpr,
targetStreamNum,
targetEndExpr,
RelationalOpEnum.LT);
}
else {
filterQueryGraph.AddRelationalOpStrict(
targetStreamNum,
targetStartExpr,
parameterStreamNum,
parameterEndExpr,
RelationalOpEnum.LT);
}
}
else if (currentMethod == DateTimeMethodEnum.STARTS || currentMethod == DateTimeMethodEnum.STARTEDBY) {
// STARTS: a.startTimestamp = b.startTimestamp and a.endTimestamp < b.endTimestamp
// STARTEDBY: a.startTimestamp = b.startTimestamp and b.endTimestamp < a.endTimestamp
filterQueryGraph.AddStrictEquals(
targetStreamNum,
targetStartProp,
targetStartExpr,
parameterStreamNum,
parameterStartProp,
parameterStartExpr);
var relop = currentMethod == DateTimeMethodEnum.STARTS ? RelationalOpEnum.LT : RelationalOpEnum.GT;
filterQueryGraph.AddRelationalOpStrict(
targetStreamNum,
targetEndExpr,
parameterStreamNum,
parameterEndExpr,
relop);
}
}
/// <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);
}
}
