public void TestPartReplaced()
{
exprTree = MakeEqualsNode();
alias = "IntPrimitive";
resultingTree = ColumnNamedNodeSwapper.Swap(exprTree, alias, fullExpr);
Assert.IsTrue(resultingTree == exprTree);
var childNodes = resultingTree.ChildNodes;
var oldChildNodes = exprTree.ChildNodes;
Assert.IsTrue(childNodes.Length == 2);
Assert.IsTrue(childNodes[0] == fullExpr);
Assert.IsTrue(childNodes[1] == oldChildNodes[1]);
exprTree = resultingTree;
alias = "IntBoxed";
resultingTree = ColumnNamedNodeSwapper.Swap(exprTree, alias, fullExpr);
childNodes = resultingTree.ChildNodes;
Assert.IsTrue(childNodes.Length == 2);
Assert.IsTrue(childNodes[0] == fullExpr);
Assert.IsTrue(childNodes[1] == fullExpr);
exprTree = resultingTree;
ExprNode newFullExpr = new ExprIdentNodeImpl("new full expr");
alias = "full expression";
resultingTree = ColumnNamedNodeSwapper.Swap(exprTree, alias, newFullExpr);
childNodes = resultingTree.ChildNodes;
Assert.IsTrue(childNodes.Length == 2);
Assert.IsTrue(childNodes[0] == newFullExpr);
Assert.IsTrue(childNodes[1] == newFullExpr);
}
public static ExprNode MakeIdentNode(string fieldName, string streamName)
{
ExprIdentNode node = new ExprIdentNodeImpl(fieldName, streamName);
Validate3Stream(node);
return(node);
}
public static ExprAndNode Make2SubNodeAnd()
{
ExprAndNode topNode = new ExprAndNodeImpl();
ExprEqualsNode e1 = new ExprEqualsNodeImpl(false, false);
ExprEqualsNode e2 = new ExprEqualsNodeImpl(false, false);
topNode.AddChildNode(e1);
topNode.AddChildNode(e2);
ExprIdentNode i1_1 = new ExprIdentNodeImpl("IntPrimitive", "s0");
ExprIdentNode i1_2 = new ExprIdentNodeImpl("IntBoxed", "s1");
e1.AddChildNode(i1_1);
e1.AddChildNode(i1_2);
ExprIdentNode i2_1 = new ExprIdentNodeImpl("TheString", "s1");
ExprIdentNode i2_2 = new ExprIdentNodeImpl("TheString", "s0");
e2.AddChildNode(i2_1);
e2.AddChildNode(i2_2);
Validate3Stream(topNode);
return(topNode);
}
public static ExprNode MakeIdentNodeMD(string names)
{
ExprNode node = new ExprIdentNodeImpl(names);
Validate1StreamMD(node);
return(node);
}
public void TestPartReplaced()
{
_exprTree = MakeEqualsNode();
_alias = "IntPrimitive";
_resultingTree = ColumnNamedNodeSwapper.Swap(_exprTree, _alias, _fullExpr);
Assert.IsTrue(_resultingTree == _exprTree);
ExprNode[] childNodes = _resultingTree.ChildNodes;
ExprNode[] oldChildNodes = _exprTree.ChildNodes;
Assert.IsTrue(childNodes.Length == 2);
Assert.IsTrue(childNodes[0] == _fullExpr);
Assert.IsTrue(childNodes[1] == oldChildNodes[1]);
_exprTree = _resultingTree;
_alias = "IntBoxed";
_resultingTree = ColumnNamedNodeSwapper.Swap(_exprTree, _alias, _fullExpr);
childNodes = _resultingTree.ChildNodes;
Assert.IsTrue(childNodes.Length == 2);
Assert.IsTrue(childNodes[0] == _fullExpr);
Assert.IsTrue(childNodes[1] == _fullExpr);
_exprTree = _resultingTree;
ExprNode newFullExpr = new ExprIdentNodeImpl("new full expr");
_alias = "full expression";
_resultingTree = ColumnNamedNodeSwapper.Swap(_exprTree, _alias, newFullExpr);
childNodes = _resultingTree.ChildNodes;
Assert.IsTrue(childNodes.Length == 2);
Assert.IsTrue(childNodes[0] == newFullExpr);
Assert.IsTrue(childNodes[1] == newFullExpr);
}
public static ExprNode Make3SubNodeAnd()
{
ExprNode topNode = new ExprAndNodeImpl();
var equalNodes = new ExprEqualsNode[3];
for (var i = 0; i < equalNodes.Length; i++)
{
equalNodes[i] = new ExprEqualsNodeImpl(false, false);
topNode.AddChildNode(equalNodes[i]);
}
ExprIdentNode i1_1 = new ExprIdentNodeImpl("IntPrimitive", "s0");
ExprIdentNode i1_2 = new ExprIdentNodeImpl("IntBoxed", "s1");
equalNodes[0].AddChildNode(i1_1);
equalNodes[0].AddChildNode(i1_2);
ExprIdentNode i2_1 = new ExprIdentNodeImpl("TheString", "s1");
ExprIdentNode i2_2 = new ExprIdentNodeImpl("TheString", "s0");
equalNodes[1].AddChildNode(i2_1);
equalNodes[1].AddChildNode(i2_2);
ExprIdentNode i3_1 = new ExprIdentNodeImpl("BoolBoxed", "s0");
ExprIdentNode i3_2 = new ExprIdentNodeImpl("BoolPrimitive", "s1");
equalNodes[2].AddChildNode(i3_1);
equalNodes[2].AddChildNode(i3_2);
Validate3Stream(topNode);
return(topNode);
}
/// <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,
QueryGraphForge 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);
QueryGraphValuePairHashKeyIndexForge hashKeys = value.HashKeyProps;
var otherStrictKeyProps = hashKeys.StrictKeys;
var otherIndexProps = hashKeys.Indexed;
var otherPropertyNum = -1;
if (otherIndexProps == null) {
continue;
}
for (var i = 0; i < otherIndexProps.Length; 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 static ExprNode[] MakeIdentExprNodes(params string[] props)
{
var nodes = new ExprNode[props.Length];
for (var i = 0; i < props.Length; i++) {
nodes[i] = new ExprIdentNodeImpl(props[i]);
}
return nodes;
}
private static ExprEqualsNode MakeEqualsNode(string ident1, string stream1, object value)
{
ExprEqualsNode topNode = new ExprEqualsNodeImpl(false, false);
ExprIdentNode i1_1 = new ExprIdentNodeImpl(ident1, stream1);
var constantNode = new SupportExprNode(value);
topNode.AddChildNode(i1_1);
topNode.AddChildNode(constantNode);
return(topNode);
}
public override void ToPrecedenceFreeEPL(
TextWriter writer,
ExprNodeRenderableFlags flags)
{
ExprIdentNodeImpl.ToPrecedenceFreeEPL(
writer,
_streamOrPropertyName,
_unresolvedPropertyName,
ExprNodeRenderableFlags.DEFAULTFLAGS);
}
public static ExprEqualsNode MakeEqualsNode()
{
ExprEqualsNode topNode = new ExprEqualsNodeImpl(false, false);
ExprIdentNode i1_1 = new ExprIdentNodeImpl("IntPrimitive");
ExprIdentNode i1_2 = new ExprIdentNodeImpl("IntBoxed");
topNode.AddChildNode(i1_1);
topNode.AddChildNode(i1_2);
return(topNode);
}
public void SetUp()
{
_identNodes = new ExprIdentNode[4];
_identNodes[0] = new ExprIdentNodeImpl("Mapped('a')");
_identNodes[1] = new ExprIdentNodeImpl("NestedValue", "Nested");
_identNodes[2] = new ExprIdentNodeImpl("Indexed[1]", "s2");
_identNodes[3] = new ExprIdentNodeImpl("IntPrimitive", "s0");
_streamTypeService = new SupportStreamTypeSvc3Stream();
}
private static void PerformanceTestIdentNode()
{
var bidData = new BidData("IBM", 0L, 0.50);
var identNode1 = new ExprIdentNodeImpl("BidPrice");
var bidDataEventType = _espServiceProvider.EventAdapterService.GetEventTypeByName("BidData");
var streamTypeService = new StreamTypeServiceImpl(bidDataEventType, null, false, null);
identNode1.Validate(
new ExprValidationContext(
_container,
streamTypeService,
null,
null,
null,
null,
null,
null,
null,
null,
null,
-1,
null,
null,
null,
false,
false,
false,
false,
null,
false
));
var exprEvaluatorContext = (ExprEvaluatorContext)null;
Console.WriteLine("IdentNode");
for (var nn = 0; nn < 10; nn++)
{
var eventBean = new BeanEventBean(bidData, bidDataEventType);
var eventBeans = new EventBean[] { eventBean };
var timeItem = PerformanceObserver.TimeMicro(
delegate
{
for (var ii = 1000000; ii >= 0; ii--)
{
identNode1.ExprEvaluator.Evaluate(
new EvaluateParams(eventBeans, false, exprEvaluatorContext));
}
});
Console.WriteLine("time: {0} {1:N3} {2:N3}", timeItem, timeItem / 1000000.0m, 1000000.0m / timeItem);
}
}
public static ExprNode[] MakeIdentNodesMD(params string[] names)
{
var nodes = new ExprNode[names.Length];
for (var i = 0; i < names.Length; i++)
{
nodes[i] = new ExprIdentNodeImpl(names[i]);
Validate1StreamMD(nodes[i]);
}
return(nodes);
}
public static ExprAggregateNode MakeSumAggregateNode()
{
var top = new ExprSumNode(false);
ExprIdentNode ident = new ExprIdentNodeImpl("IntPrimitive", "s0");
top.AddChildNode(ident);
Validate3Stream(top);
return(top);
}
public static OuterJoinDesc MakeDesc(String propOne, String streamOne, String propTwo, String streamTwo, OuterJoinType type)
{
ExprIdentNode identNodeOne = new ExprIdentNodeImpl(propOne, streamOne);
ExprIdentNode identNodeTwo = new ExprIdentNodeImpl(propTwo, streamTwo);
ExprValidationContext context = SupportExprValidationContextFactory.Make(new SupportStreamTypeSvc3Stream());
identNodeOne.Validate(context);
identNodeTwo.Validate(context);
OuterJoinDesc desc = new OuterJoinDesc(type, identNodeOne, identNodeTwo, null, null);
return(desc);
}
public static ExprEqualsNode MakeEqualsNode()
{
ExprEqualsNode topNode = new ExprEqualsNodeImpl(false, false);
ExprIdentNode i1_1 = new ExprIdentNodeImpl("IntPrimitive");
ExprIdentNode i1_2 = new ExprIdentNodeImpl("IntBoxed");
topNode.AddChildNode(i1_1);
topNode.AddChildNode(i1_2);
SupportExprNodeFactory.Validate1StreamBean(topNode);
return(topNode);
}
public ExprEqualsNode MakeEqualsNode()
{
ExprEqualsNode topNode = new ExprEqualsNodeImpl(false, false);
ExprIdentNode i1_1 = new ExprIdentNodeImpl("IntPrimitive", "s0");
ExprIdentNode i1_2 = new ExprIdentNodeImpl("IntBoxed", "s1");
topNode.AddChildNode(i1_1);
topNode.AddChildNode(i1_2);
Validate3Stream(topNode);
return(topNode);
}
public static ExprNode MakeMathNode()
{
ExprIdentNode node1 = new ExprIdentNodeImpl("IntBoxed", "s0");
ExprIdentNode node2 = new ExprIdentNodeImpl("IntPrimitive", "s0");
var mathNode = new ExprMathNode(MathArithTypeEnum.MULTIPLY, false, false);
mathNode.AddChildNode(node1);
mathNode.AddChildNode(node2);
Validate3Stream(mathNode);
return(mathNode);
}
public EventAdvancedIndexProvisionCompileTime ToCompileTime(
EventType eventTypeIndexed,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
ExprNode[] indexedExpr;
if (IndexExpressionsOpt != null) {
indexedExpr = IndexExpressionsOpt;
}
else {
if (IsIndexExpressionsAllProps) {
indexedExpr = new ExprNode[IndexProperties.Length];
for (var i = 0; i < IndexProperties.Length; i++) {
indexedExpr[i] = new ExprIdentNodeImpl(eventTypeIndexed, IndexProperties[i], 0);
}
}
else {
indexedExpr = new ExprNode[IndexProperties.Length];
for (var i = 0; i < IndexProperties.Length; i++) {
indexedExpr[i] = services.CompilerServices.CompileExpression(IndexExpressionTexts[i], services);
indexedExpr[i] = EPLValidationUtil.ValidateSimpleGetSubtree(
ExprNodeOrigin.CREATEINDEXCOLUMN,
indexedExpr[i],
eventTypeIndexed,
false,
statementRawInfo,
services);
}
}
}
var desc = new AdvancedIndexDescWExpr(IndexTypeName, indexedExpr);
ExprNode[] parameters;
if (ParameterExpressionsOpt != null) {
parameters = ParameterExpressionsOpt;
}
else {
parameters = new ExprNode[ParameterExpressionTexts.Length];
for (var i = 0; i < ParameterExpressionTexts.Length; i++) {
parameters[i] = services.CompilerServices.CompileExpression(ParameterExpressionTexts[i], services);
}
}
return new EventAdvancedIndexProvisionCompileTime(
desc,
parameters,
Factory.Forge,
Factory.ToConfigStatement(indexedExpr));
}
public static ExprPreviousNode MakePreviousNode()
{
var prevNode = new ExprPreviousNode(ExprPreviousNodePreviousType.PREV);
ExprNode indexNode = new ExprIdentNodeImpl("IntPrimitive", "s1");
prevNode.AddChildNode(indexNode);
ExprNode propNode = new ExprIdentNodeImpl("DoublePrimitive", "s1");
prevNode.AddChildNode(propNode);
Validate3Stream(prevNode);
return(prevNode);
}
public static ExprPriorNode MakePriorNode()
{
var priorNode = new ExprPriorNode();
ExprNode indexNode = new ExprConstantNodeImpl(1);
priorNode.AddChildNode(indexNode);
ExprNode propNode = new ExprIdentNodeImpl("DoublePrimitive", "s0");
priorNode.AddChildNode(propNode);
Validate3Stream(priorNode);
return(priorNode);
}
public static ExprNode MakeSumAndFactorNode()
{
// sum node
var sum = new ExprSumNode(false);
ExprIdentNode ident = new ExprIdentNodeImpl("IntPrimitive", "s0");
sum.AddChildNode(ident);
ExprIdentNode node = new ExprIdentNodeImpl("IntBoxed", "s0");
var mathNode = new ExprMathNode(MathArithTypeEnum.MULTIPLY, false, false);
mathNode.AddChildNode(node);
mathNode.AddChildNode(sum);
Validate3Stream(mathNode);
return(mathNode);
}
public static OuterJoinDesc MakeDesc(
IContainer container,
string propOne,
string streamOne,
string propTwo,
string streamTwo,
OuterJoinType type)
{
ExprIdentNode identNodeOne = new ExprIdentNodeImpl(propOne, streamOne);
ExprIdentNode identNodeTwo = new ExprIdentNodeImpl(propTwo, streamTwo);
var context = SupportExprValidationContextFactory.Make(
container,
new SupportStreamTypeSvc3Stream(SupportEventTypeFactory.GetInstance(container)));
identNodeOne.Validate(context);
identNodeTwo.Validate(context);
var desc = new OuterJoinDesc(type, identNodeOne, identNodeTwo, null, null);
return(desc);
}
public override void ToPrecedenceFreeEPL(TextWriter writer)
{
ExprIdentNodeImpl.ToPrecedenceFreeEPL(writer, streamOrPropertyName, unresolvedPropertyName);
}
public void SetUp()
{
fullExpr = new ExprIdentNodeImpl("full expression");
}
public static SelectClauseElementCompiled[] MakeInvalidSelectList()
{
ExprIdentNode node = new ExprIdentNodeImpl("xxxx", "s0");
return(new SelectClauseElementCompiled[] { new SelectClauseExprCompiledSpec(node, null, null, false) });
}
