private ExpressionNode ParseRel()
{
var lhs = ParseMathExpr();
if (_reader.Peek() is LessThan)
{
Match <LessThan>();
lhs = new LessThanNode(lhs, ParseMathExpr());
}
else if (_reader.Peek() is LessThanOrEqual)
{
Match <LessThanOrEqual>();
lhs = new LessThanOrEqualNode(lhs, ParseMathExpr());
}
else if (_reader.Peek() is GreaterThan)
{
Match <GreaterThan>();
lhs = new GreaterThanNode(lhs, ParseMathExpr());
}
else if (_reader.Peek() is GreaterThanOrEqual)
{
Match <GreaterThanOrEqual>();
lhs = new GreaterThanNodeOrEqual(lhs, ParseMathExpr());
}
return(lhs);
}
public override bool Visit(LessThanOrEqualNode node)
{
int nodeLeft = 0;
int nodeRight = 0;
if (node.Left is NumberNode)
{
nodeLeft = Visit(node.Left as NumberNode);
}
else if (node.Left is IdentifierNode)
{
nodeLeft = Visit(node.Left as IdentifierNode);
}
else
{
nodeLeft = Visit(node.Left as InfixExpressionNode);
}
if (node.Right is NumberNode)
{
nodeRight = Visit(node.Right as NumberNode);
}
else if (node.Right is IdentifierNode)
{
nodeRight = Visit(node.Right as IdentifierNode);
}
else
{
nodeRight = Visit(node.Right as InfixExpressionNode);
}
return(nodeLeft <= nodeRight);
}
public void Init()
{
_testExpression = Expression.LessThan(TestLeftExpression, TestRightExpression);
TestObject = new LessThanOrEqualNode(
MockNodeFactory.Object,
TestExpression);
}
public void LessThanOrEqualExpressionHasExpectedRight()
{
IExpressionNode actual = TestObject.Build(TestLessThanOrEqualExpression);
LessThanOrEqualNode actualNode = actual.VerifyIsActually <LessThanOrEqualNode>();
ConstantNode rightNode = actualNode.Right.VerifyIsActually <ConstantNode>();
Assert.AreSame(TestConstantOne, rightNode.SourceExpression);
}
public void LessThanOrEqualExpressionIsExpected()
{
Expression testExpression = TestLessThanOrEqualExpression;
IExpressionNode actual = TestObject.Build(testExpression);
LessThanOrEqualNode actualNode = actual.VerifyIsActually <LessThanOrEqualNode>();
Assert.AreSame(testExpression, actualNode.SourceExpression);
}
protected virtual BaseQuery HandleLessThanOrEqual(LessThanOrEqualNode node, ElasticSearchQueryMapperState state)
{
BaseQuery query;
var fieldNode = node.GetFieldNode();
var valueNode = QueryHelper.GetValueNode(node, fieldNode.FieldType);
if (ProcessAsVirtualField(fieldNode, valueNode, node.Boost, ComparisonType.LessThanOrEqual, state, out query))
{
return(query);
}
return(HandleLessThanOrEqual(fieldNode.FieldKey, valueNode.Value, node.Boost));
}
public virtual void VisitLessThanOrEqual(LessThanOrEqualNode lessThanOrEqualNode) => throw new NotImplementedException();
protected virtual QueryNode VisitLessThanOrEqual(LessThanOrEqualNode node, AzureQueryOptimizerState state)
{
return((QueryNode) new LessThanOrEqualNode(this.Visit(node.LeftNode, state), this.Visit(node.RightNode, state)));
}
protected virtual QueryNode VisitLessThanOrEqual(LessThanOrEqualNode node, ElasticSearchQueryOptimizerState state)
{
var node2 = Visit(node.LeftNode, state);
return(new LessThanOrEqualNode(node2, Visit(node.RightNode, state)));
}
protected QueryBase VisitLessThanOrEqual(LessThanOrEqualNode node, ElasticQueryMapperState state)
{
return(GetSingleTermRangeQuery(node, RangeQueryPropertyNames.LessThanOrEqualTo));
}
public abstract U Visit(LessThanOrEqualNode node);
