public void SetUp()
{
_typesPerStream = new EventType[]
{
SupportEventAdapterService.Service.AddBeanType(typeof(SupportBean_S0).FullName, typeof(SupportBean_S0),
true, true, true),
SupportEventAdapterService.Service.AddBeanType(typeof(SupportBean_S1).FullName, typeof(SupportBean_S1),
true, true, true),
SupportEventAdapterService.Service.AddBeanType(typeof(SupportBean_S2).FullName, typeof(SupportBean_S2),
true, true, true),
SupportEventAdapterService.Service.AddBeanType(typeof(SupportBean_S3).FullName, typeof(SupportBean_S3),
true, true, true),
SupportEventAdapterService.Service.AddBeanType(typeof(SupportBean_S4).FullName, typeof(SupportBean_S4),
true, true, true)
};
_queryGraph = new QueryGraph(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 TestRecursiveBuild()
{
var streamNum = 2;
var queryGraph = new QueryGraph(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);
queryGraph.AddStrictEquals(2, "", null, 3, "", null);
queryGraph.AddStrictEquals(3, "", null, 4, "", null);
queryGraph.AddStrictEquals(3, "", null, 5, "", null);
queryGraph.AddStrictEquals(2, "", null, 1, "", null);
queryGraph.AddStrictEquals(1, "", null, 0, "", null);
ICollection <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[2], new int[] { 3, 1 });
EPAssertionUtil.AssertEqualsExactOrder(substreamsPerStream.Get(3), new int[] { 4, 5 });
EPAssertionUtil.AssertEqualsExactOrder(substreamsPerStream[1], new int[] { 0 });
EPAssertionUtil.AssertEqualsExactOrder(substreamsPerStream.Get(4), new int[] {});
EPAssertionUtil.AssertEqualsExactOrder(substreamsPerStream.Get(5), new int[] {});
EPAssertionUtil.AssertEqualsExactOrder(substreamsPerStream[0], new int[] {});
NStreamOuterQueryPlanBuilder.VerifyJoinedPerStream(2, substreamsPerStream);
EPAssertionUtil.AssertEqualsExactOrder(requiredPerStream, new bool[] { false, false, false, true, true, false }
);
}
private QueryGraph MakeQueryGraph()
{
QueryGraph graph = new QueryGraph(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 QueryGraph(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"));
QueryPlanIndex[] indexes = QueryPlanIndexBuilder.BuildIndexSpec(_queryGraph, _types, new String[_queryGraph.NumStreams][][]);
String[][] expected = new String[][] { new [] { "p00" } };
EPAssertionUtil.AssertEqualsExactOrder(indexes[0].IndexProps, expected);
}
public void TestGetNavigableStreams()
{
_queryGraph = new QueryGraph(5, null, false);
_queryGraph.AddStrictEquals(3, "p3", null, 4, "p4", null);
_queryGraph.AddStrictEquals(2, "p2", null, 3, "p3", null);
_queryGraph.AddStrictEquals(1, "p1", null, 2, "p2", null);
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));
}
/// <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);
}
}
public void SetUp()
{
_types = new EventType[] {
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 QueryGraph(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 TestComputeNavigableDepth()
{
_queryGraph.AddStrictEquals(3, "P30", null, 2, "P20", null);
_queryGraph.AddStrictEquals(2, "P30", null, 1, "P20", null);
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);
}
/// <summary>
/// Looks at the key and index (aka. left and right) properties of the 2 streams and checks
/// for each property if any equivalent index properties exist for other streams.
/// Example: s0.p0 = s1.p1 and s1.p1 = s2.p2 ==> therefore s0.p0 = s2.p2
/// ==> look stream s0, property p0; indexed stream s1, property p1
/// Is there any other lookup stream that has stream 1 and property p1 as index property? ==> this is stream s2, p2
/// Add navigation entry between stream s0 and property p0 to stream s2, property p2
/// </summary>
private static bool FillEquivalentNav(
EventType[] typesPerStream, QueryGraph queryGraph, int lookupStream,
string keyProp, int indexedStream, string indexProp)
{
var addedEquivalency = false;
for (var otherStream = 0; otherStream < queryGraph.NumStreams; otherStream++)
{
if (otherStream == lookupStream || otherStream == indexedStream)
{
continue;
}
var value = queryGraph.GetGraphValue(otherStream, indexedStream);
var hashKeys = value.HashKeyProps;
var otherStrictKeyProps = hashKeys.StrictKeys;
var otherIndexProps = hashKeys.Indexed;
var otherPropertyNum = -1;
if (otherIndexProps == null)
{
continue;
}
for (var i = 0; i < otherIndexProps.Count; i++)
{
if (otherIndexProps[i].Equals(indexProp))
{
otherPropertyNum = i;
break;
}
}
if (otherPropertyNum != -1)
{
if (otherStrictKeyProps[otherPropertyNum] != null)
{
ExprIdentNode identNodeLookup =
new ExprIdentNodeImpl(typesPerStream[lookupStream], keyProp, lookupStream);
ExprIdentNode identNodeOther = new ExprIdentNodeImpl(
typesPerStream[otherStream],
otherStrictKeyProps[otherPropertyNum], otherStream);
var added = queryGraph.AddStrictEquals(
lookupStream, keyProp, identNodeLookup, otherStream,
otherStrictKeyProps[otherPropertyNum], identNodeOther);
if (added)
{
addedEquivalency = true;
}
}
}
}
return(addedEquivalency);
}
public void TestFillEquivalency()
{
// test with just 3 streams
_queryGraph.AddStrictEquals(0, "p00", Make(0, "p00"), 1, "p10", Make(1, "p10"));
_queryGraph.AddStrictEquals(1, "p10", Make(1, "p10"), 2, "p20", Make(2, "p20"));
Assert.IsFalse(_queryGraph.IsNavigableAtAll(0, 2));
Assert.AreEqual(0, QueryGraphTestUtil.GetStrictKeyProperties(_queryGraph, 0, 2).Count);
Assert.AreEqual(0, QueryGraphTestUtil.GetIndexProperties(_queryGraph, 0, 2).Count);
QueryGraph.FillEquivalentNav(_types, _queryGraph);
Assert.IsTrue(_queryGraph.IsNavigableAtAll(0, 2));
String[] expectedOne = new String[] { "p00" };
String[] expectedTwo = new String[] { "p20" };
Assert.IsTrue(Collections.AreEqual(expectedOne, QueryGraphTestUtil.GetStrictKeyProperties(_queryGraph, 0, 2)));
Assert.IsTrue(Collections.AreEqual(expectedTwo, QueryGraphTestUtil.GetIndexProperties(_queryGraph, 0, 2)));
// test with 5 streams, connect all streams to all streams
_queryGraph = new QueryGraph(5, null, false);
_queryGraph.AddStrictEquals(0, "p0", Make(0, "p0"), 1, "p1", Make(1, "p1"));
_queryGraph.AddStrictEquals(3, "p3", Make(3, "p3"), 4, "p4", Make(4, "p4"));
_queryGraph.AddStrictEquals(2, "p2", Make(2, "p2"), 3, "p3", Make(3, "p3"));
_queryGraph.AddStrictEquals(1, "p1", Make(1, "p1"), 2, "p2", Make(2, "p2"));
QueryGraph.FillEquivalentNav(_types, _queryGraph);
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
if (i == j)
{
continue;
}
Assert.IsTrue(_queryGraph.IsNavigableAtAll(i, j), "Not navigable: i=" + i + " j=" + j);
}
}
}
private static void Add(QueryGraph queryGraph, ExprIdentNode identNodeLeft, ExprIdentNode identNodeRight)
{
queryGraph.AddStrictEquals(identNodeLeft.StreamId, identNodeLeft.ResolvedPropertyName, identNodeLeft,
identNodeRight.StreamId, identNodeRight.ResolvedPropertyName, identNodeRight);
}
