public void TestValidate()
{
// test success
_andNode.AddChildNode(new SupportExprNode(typeof(Boolean)));
_andNode.AddChildNode(new SupportExprNode(typeof(Boolean)));
_andNode.Validate(SupportExprValidationContextFactory.MakeEmpty(_container));
// test failure, type mismatch
_andNode.AddChildNode(new SupportExprNode(typeof(string)));
try
{
_andNode.Validate(SupportExprValidationContextFactory.MakeEmpty(_container));
Assert.Fail();
}
catch (ExprValidationException)
{
// Expected
}
// test failed - with just one child
_andNode = new ExprAndNodeImpl();
_andNode.AddChildNode(new SupportExprNode(typeof(Boolean)));
try
{
_andNode.Validate(SupportExprValidationContextFactory.MakeEmpty(_container));
Assert.Fail();
}
catch (ExprValidationException)
{
// Expected
}
}
/// <summary>
/// Analyze the AND-node.
/// </summary>
/// <param name="andNode">node to analyze</param>
/// <param name="queryGraph">to store relationships between stream properties</param>
/// <param name="isOuterJoin">if set to <c>true</c> [is outer join].</param>
internal static void AnalyzeAndNode(ExprAndNode andNode, QueryGraph queryGraph, bool isOuterJoin)
{
foreach (var childNode in andNode.ChildNodes)
{
Analyze(childNode, queryGraph, isOuterJoin);
}
}
public void Visit(ExprAndNode node)
{
foreach (var subnode in node)
{
Visit((dynamic)subnode);
}
}
public void TestEvaluate()
{
_andNode.AddChildNode(new SupportBoolExprNode(true));
_andNode.AddChildNode(new SupportBoolExprNode(true));
SupportExprNodeUtil.Validate(_andNode);
Assert.IsTrue(_andNode.Evaluate(new EvaluateParams(null, false, null)).AsBoolean());
_andNode = new ExprAndNodeImpl();
_andNode.AddChildNode(new SupportBoolExprNode(true));
_andNode.AddChildNode(new SupportBoolExprNode(false));
SupportExprNodeUtil.Validate(_andNode);
Assert.IsFalse(_andNode.Evaluate(new EvaluateParams(null, false, null)).AsBoolean());
}
public void TestEvaluate()
{
andNode.AddChildNode(new SupportBoolExprNode(true));
andNode.AddChildNode(new SupportBoolExprNode(true));
SupportExprNodeUtil.Validate(container, andNode);
Assert.IsTrue((bool)andNode.Forge.ExprEvaluator.Evaluate(null, false, null));
andNode = new ExprAndNodeImpl();
andNode.AddChildNode(new SupportBoolExprNode(true));
andNode.AddChildNode(new SupportBoolExprNode(false));
SupportExprNodeUtil.Validate(container, andNode);
Assert.IsFalse((bool)andNode.Forge.ExprEvaluator.Evaluate(null, false, null));
}
public void TestAnalyzeAnd()
{
ExprAndNode andNode = SupportExprNodeFactory.Make2SubNodeAnd();
QueryGraph graph = new QueryGraph(2, null, false);
FilterExprAnalyzer.AnalyzeAndNode(andNode, graph, false);
Assert.IsTrue(graph.IsNavigableAtAll(0, 1));
EPAssertionUtil.AssertEqualsExactOrder(QueryGraphTestUtil.GetStrictKeyProperties(graph, 0, 1), new String[] { "IntPrimitive", "TheString" });
EPAssertionUtil.AssertEqualsExactOrder(QueryGraphTestUtil.GetIndexProperties(graph, 1, 0), new String[] { "IntPrimitive", "TheString" });
EPAssertionUtil.AssertEqualsExactOrder(QueryGraphTestUtil.GetStrictKeyProperties(graph, 1, 0), new String[] { "IntBoxed", "TheString" });
EPAssertionUtil.AssertEqualsExactOrder(QueryGraphTestUtil.GetIndexProperties(graph, 0, 1), new String[] { "IntBoxed", "TheString" });
}
private static ExprAndNode MakeValidateAndNode(
IList<ExprNode> remainingExprNodes,
FilterSpecCompilerArgs args)
{
ExprAndNode andNode = ExprNodeUtilityMake.ConnectExpressionsByLogicalAnd(remainingExprNodes);
ExprValidationContext validationContext =
new ExprValidationContextBuilder(
args.streamTypeService,
args.statementRawInfo,
args.compileTimeServices)
.WithAllowBindingConsumption(true)
.WithContextDescriptor(args.contextDescriptor)
.Build();
andNode.Validate(validationContext);
return andNode;
}
public Node ExprAnd()
{
var node1 = ExprComp();
while (CurrentToken == TokenCategory.AND)
{
var node2 = new ExprAndNode()
{
AnchorToken = Expect(TokenCategory.AND)
};
node2.Add(node1);
node2.Add(ExprComp());
node1 = node2;
}
return(node1);
}
private ExprNode GetFilterExpressionInclOnClause(ExprNode optionalFilterNode, OuterJoinDesc[] outerJoinDescList)
{
if (optionalFilterNode == null)
{ // no need to add as query planning is fully based on on-clause
return(null);
}
if (outerJoinDescList.Length == 0)
{ // not an outer-join syntax
return(optionalFilterNode);
}
if (!OuterJoinDesc.ConsistsOfAllInnerJoins(outerJoinDescList))
{ // all-inner joins
return(optionalFilterNode);
}
var hasOnClauses = OuterJoinDesc.HasOnClauses(outerJoinDescList);
if (!hasOnClauses)
{
return(optionalFilterNode);
}
var expressions = new List <ExprNode>();
expressions.Add(optionalFilterNode);
foreach (var outerJoinDesc in outerJoinDescList)
{
if (outerJoinDesc.OptLeftNode != null)
{
expressions.Add(outerJoinDesc.MakeExprNode(null));
}
}
ExprAndNode andNode = ExprNodeUtility.ConnectExpressionsByLogicalAnd(expressions);
try
{
andNode.Validate(null);
}
catch (ExprValidationException ex)
{
throw new EPRuntimeException("Unexpected exception validating expression: " + ex.Message, ex);
}
return(andNode);
}
private static ExprAndNode MakeValidateAndNode(IList<ExprNode> remainingExprNodes, FilterSpecCompilerArgs args)
{
ExprAndNode andNode = ExprNodeUtility.ConnectExpressionsByLogicalAnd(remainingExprNodes);
var validationContext = new ExprValidationContext(
args.StreamTypeService,
args.MethodResolutionService, null,
args.TimeProvider,
args.VariableService,
args.TableService,
args.ExprEvaluatorContext,
args.EventAdapterService,
args.StatementName,
args.StatementId,
args.Annotations,
args.ContextDescriptor,
args.ScriptingService,
false, false, true, false, null, false);
andNode.Validate(validationContext);
return andNode;
}
public static ExprNode ConnectExpressionsByLogicalAnd(
IList<ExprNode> nodes,
ExprNode optionalAdditionalFilter)
{
if (nodes.IsEmpty()) {
return optionalAdditionalFilter;
}
if (optionalAdditionalFilter == null) {
if (nodes.Count == 1) {
return nodes[0];
}
return ConnectExpressionsByLogicalAnd(nodes);
}
if (nodes.Count == 1) {
return ConnectExpressionsByLogicalAnd(Collections.List(nodes[0], optionalAdditionalFilter));
}
ExprAndNode andNode = ConnectExpressionsByLogicalAnd(nodes);
andNode.AddChildNode(optionalAdditionalFilter);
return andNode;
}
public void SetUp()
{
_container = SupportContainer.Reset();
_andNode = new ExprAndNodeImpl();
}
public void SetUp()
{
_andNode = new ExprAndNodeImpl();
}
