public static void SerializeGreaterThanExpression()
{
var v = new NumberLiteral(2);
var a = new GreaterThanExpression(v, v);
var b = SerializationUtil.Reserialize(a);
Assert.AreEqual(a, b);
}
public void GreaterThanExpression()
{
var e = new GreaterThanExpression(new Literal("13"), new Literal("37"));
Assert.IsFalse(e.IsTrivial);
Assert.AreEqual("(13>37)", e.ToString());
Assert.AreEqual("GreaterThan", e.Name);
}
public void TestRightNull()
{
var expression = new GreaterThanExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)false),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)null),
ExpressiveOptions.None);
Assert.AreEqual(null, expression.Evaluate(null));
}
public void TestIntFloatFalse()
{
var expression = new GreaterThanExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)1),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)1.001),
ExpressiveOptions.None);
Assert.AreEqual(false, expression.Evaluate(null));
}
public static void TestEvaluate(object lhs, object rhs, object expectedValue)
{
var expression = new GreaterThanExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == lhs),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == rhs),
new Context(ExpressiveOptions.None));
Assert.That(expression.Evaluate(null), Is.EqualTo(expectedValue));
}
private object GreaterThan(object l, object r)
{
var scope = new Scope();
scope.SetVar("l", l);
scope.SetVar("r", r);
var exp = new GreaterThanExpression(
new VariableExpression("l"),
new VariableExpression("r")
);
return(exp.Evaluate(scope, new Bindings()).AsObject());
}
public void Visit(GreaterThanExpression expression)
{
var leftArg = new QueryPhaseArgs()
{
BoolQueryArg = new QueryGreaterThan()
};
VisitChild(expression.Left, leftArg);
var rightArg = new QueryPhaseArgs()
{
BoolQueryArg = new QueryGreaterThan()
};
VisitChild(expression.Right, rightArg);
var parentArgs = _visitStack.Peek();
parentArgs.RowResult = ValidateTypes(leftArg.BoolQueryArg, rightArg.BoolQueryArg, (l, r) => l > r);
}
public override AstNode VisitCompare([NotNull] QlParser.CompareContext context)
{
var op = context.op.Text;
BinaryExpression binExp = null;
var lhs = this.Visit(context.lhs) as Expression;
var rhs = this.Visit(context.rhs) as Expression;
switch (op)
{
case "<":
binExp = new LessThanExpression(lhs, rhs);
break;
case "<=":
binExp = new LessThanOrEqualExpression(lhs, rhs);
break;
case ">":
binExp = new GreaterThanExpression(lhs, rhs);
break;
case ">=":
binExp = new GreaterThanOrEqualExpression(lhs, rhs);
break;
case "==":
binExp = new EqualExpression(lhs, rhs);
break;
case "!=":
binExp = new NotEqualExpression(lhs, rhs);
break;
default:
throw new ArgumentOutOfRangeException(nameof(op), "Unsupported operator.");
}
return(binExp);
}
private string GetExpression(GreaterThanExpression expression, ref List<OleDbParameter> parameters)
{
return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " > " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ";
}
public void Visit(GreaterThanExpression expression)
{
DoBoolean(expression, CodeBinaryOperatorType.GreaterThan);
}
public ValueType Visit(GreaterThanExpression expression, ITypeEnvironment environment)
{
return(this.CheckBinaryComparisonExpression(expression, environment));
}
private static string PrintExpression(GreaterThanExpression greaterThan, IPlainSelect selectBody)
{
return($"{PrintExpression((dynamic)greaterThan.LeftExp, selectBody)} > {PrintExpression((dynamic)greaterThan.RightExp, selectBody)}");
}
public virtual void VisitGreaterThanExpression(GreaterThanExpression greaterThanExpression)
{
DefaultVisit(greaterThanExpression);
}
private bool ParseRelationalOperatorIfExists(Lexer lexer, Token token, Attributes attributes)
{
var successfullyParsed = true;
successfullyParsed &= ParseAdditionOrSubstractionIfExists(lexer, token, attributes);
if (lexer.GetCurrentToken().Is(TokenType.EqualOperator) ||
lexer.GetCurrentToken().Is(TokenType.GreaterThanOperator) ||
lexer.GetCurrentToken().Is(TokenType.GreaterThanOrEqualOperator) ||
lexer.GetCurrentToken().Is(TokenType.LessThanOperator) ||
lexer.GetCurrentToken().Is(TokenType.LessThanOrEqualOperator) ||
lexer.GetCurrentToken().Is(TokenType.DistinctOperator))
{
BinaryExpression tree;
if (lexer.GetCurrentToken().Is(TokenType.EqualOperator))
{
tree = new EqualExpression();
}
else if (lexer.GetCurrentToken().Is(TokenType.GreaterThanOperator))
{
tree = new GreaterThanExpression();
}
else if (lexer.GetCurrentToken().Is(TokenType.GreaterThanOrEqualOperator))
{
tree = new GreaterThanOrEqualExpression();
}
else if (lexer.GetCurrentToken().Is(TokenType.LessThanOperator))
{
tree = new LessThanExpression();
}
else if (lexer.GetCurrentToken().Is(TokenType.LessThanOrEqualOperator))
{
tree = new LessThanOrEqualExpression();
}
else
{
tree = new DistinctExpression();
}
tree.LeftOperand = attributes["EXP"] as Expression;
successfullyParsed &= ParseAdditionOrSubstractionIfExists(lexer, lexer.GetNextToken(), attributes);
tree.RightOperand = attributes["EXP"] as Expression;
// SEM: Sólo pueden compararse expresiones del mismo tipo
if (tree.LeftOperand.Type != tree.RightOperand.Type)
{
LogTypeMismatch(lexer.GetCurrentToken(), tree.LeftOperand.Type, tree.RightOperand.Type);
successfullyParsed = false;
}
// SEM: Las comparaciones de tipo >, >=, <, <= sólo pueden realizarse entre enteros
else if (!lexer.GetCurrentToken().Is(TokenType.EqualOperator) &&
!lexer.GetCurrentToken().Is(TokenType.DistinctOperator) && tree.LeftOperand.Type != DataType.Integer)
{
LogTypeExpressionInvalid(lexer.GetCurrentToken(), DataType.Integer, tree.LeftOperand.Type);
successfullyParsed = false;
}
attributes["EXP"] = tree;
}
return(successfullyParsed);
}
public IValue Visit(GreaterThanExpression expression, TypeEnvironment environment)
{
return(expression.LeftExpression
.Accept(this, environment)
.GreaterThan(expression.RightExpression.Accept(this, environment)));
}
public virtual TResult Visit(GreaterThanExpression expression, TEnvironment environment)
{
return(this.Visit((BinaryExpression)expression, environment));
}
public override void Visit(GreaterThanExpression expression)
{
_expressionString.Append(" (");
Visit(expression.Left);
_expressionString.Append(" > ");
Visit(expression.Right);
_expressionString.Append(") ");
}
public void Visit(GreaterThanExpression expression, CommonTree tree)
{
SetLine(expression, tree);
Parent(tree).Children.Add(expression);
VisitChildren(tree);
}
private string GetExpression(GreaterThanExpression expression, ref List <OleDbParameter> parameters)
{
return(" ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " > " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ");
}
