private void OnEvaluateBinaryExpression(BinaryExpressionType type, BinaryExpressionArgs args)
{
if (EvaluateBinaryExpression != null)
{
EvaluateBinaryExpression(type, args);
}
}
public static string BinaryExpressionType(BinaryExpressionType btype)
{
switch (btype)
{
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.Add:
return("+");
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.BitwiseAnd:
return("&");
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.BitwiseOr:
return("|");
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.BitwiseXor:
return("^");
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.Divide:
return("/");
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.Modulo:
return("%");
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.Multiply:
return("*");
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.Subtract:
return("-");
default:
throw new GraphViewException("Invalid binary expression type");
}
}
internal BinaryExpression(BinaryExpressionType type, IExpression lhs, IExpression rhs, ExpressiveOptions options)
{
_expressionType = type;
_leftHandSide = lhs;
_options = options;
_rightHandSide = rhs;
}
/// <summary>
/// Get binary operator string by expression type
/// </summary>
/// <param name="type">The binary expression type</param>
/// <returns>The binary operator string</returns>
protected static string GetBinaryOperatorString(BinaryExpressionType type)
{
switch (type)
{
case BinaryExpressionType.Plus:
return("+");
case BinaryExpressionType.Minus:
return("-");
case BinaryExpressionType.Multiply:
return("*");
case BinaryExpressionType.Div:
return("/");
case BinaryExpressionType.Mod:
return("%");
case BinaryExpressionType.BitAnd:
return("&");
default:
throw new ExpressionEvaluatorException("unknown binary operator");
}
}
public BinaryExpressionNode(IExpression left, IExpression right, BinaryExpressionType type, String binaryOperator)
{
this.Type = ExpressionType.BinaryOperation;
this.BinaryType = type;
this.Left = left;
this.Right = right;
this.BinaryOperator = binaryOperator;
}
public BinaryExpression(
BinaryExpressionType type,
Expression leftExpression,
Expression rightExpression)
{
this.type = type;
this.leftExpression = leftExpression;
this.rightExpression = rightExpression;
}
void ex_EvaluateBinaryExpression(BinaryExpressionType type, BinaryExpressionArgs args)
{
if (type == BinaryExpressionType.Plus)
{
double left = Convert.ToDouble(args.LeftValue);
double right = Convert.ToDouble(args.RightValue);
left = Double.IsNaN(left) ? 0 : left;
right = Double.IsNaN(right) ? 0 : right;
args.Result = left + right;
}
}
public void SingleExpressionTest(
[Values("+", "-", "*", "/")] string opString,
[Values(BinaryExpressionType.Add, BinaryExpressionType.Sub, BinaryExpressionType.Mul, BinaryExpressionType.Div)] BinaryExpressionType expectedType)
{
AddFile("foo", $"const foo = 123 {opString} 456;");
var result = Parse("foo");
var expected = new BinaryExpression {
ExpressionType = expectedType, Left = new LiteralExpression {
Value = 123
}, Right = new LiteralExpression {
Value = 456
}
};
Assert.AreEqual(expected, result.Constants[0].Expression);
}
internal static SqlTypeInfo CreateFromBinaryExpression(SqlTypeInfo leftType, SqlTypeInfo rightType, BinaryExpressionType binaryExpressionType)
{
if (leftType == SqlTypeInfo.Unknown || rightType == SqlTypeInfo.Unknown)
{
return SqlTypeInfo.Unknown;
}
// these binary expressions produce a result of the highest-precedence type of their operands
if (binaryExpressionType == BinaryExpressionType.Add
|| binaryExpressionType == BinaryExpressionType.Subtract
|| binaryExpressionType == BinaryExpressionType.Multiply
|| binaryExpressionType == BinaryExpressionType.Divide)
{
return ((FullSqlTypeInfo)leftType).GetHigherPrecedenceType((FullSqlTypeInfo)rightType);
}
return SqlTypeInfo.Unknown; // TODO: support other expressions
}
public static object Evaluate(BinaryExpressionType op, object left, object right)
{
// TODO: use switch expression, expression bodied member
switch (op)
{
case BinaryExpressionType.Add:
// TODO: handle numeric conversions properly
if (left is string s && right is string t)
{
return(s + t);
}
if (left is int i && right is int j)
{
return(i + j);
}
return((int)left + (int)right);
case BinaryExpressionType.Subtract:
return((int)left - (int)right);
case BinaryExpressionType.Multiply:
return((int)left * (int)right);
case BinaryExpressionType.Divide:
return((int)left / (int)right);
case BinaryExpressionType.Modulo:
return((int)left % (int)right);
case BinaryExpressionType.BitwiseAnd:
return((int)left & (int)right);
case BinaryExpressionType.BitwiseOr:
return((int)left & (int)right);
case BinaryExpressionType.BitwiseXor:
return((int)left ^ (int)right);
default:
throw FeatureNotSupportedException.Value(op);
}
}
private static int Priority(Token t, out BinaryExpressionType expressionType)
{
switch (t.Type)
{
case TokenType.LeftShift: expressionType = BinaryExpressionType.LeftShift; return(1);
case TokenType.RightShift: expressionType = BinaryExpressionType.RightShift; return(1);
case TokenType.Plus: expressionType = BinaryExpressionType.Add; return(2);
case TokenType.Minus: expressionType = BinaryExpressionType.Sub; return(2);
case TokenType.Star: expressionType = BinaryExpressionType.Mul; return(3);
case TokenType.Slash: expressionType = BinaryExpressionType.Div; return(3);
}
// Dummy
expressionType = BinaryExpressionType.Add;
return(0);
}
internal static gsMathOperationType ToMathOperationType(this BinaryExpressionType binaryExpressionType)
{
switch (binaryExpressionType)
{
case BinaryExpressionType.Add:
return(gsMathOperationType.Add);
case BinaryExpressionType.Subtract:
return(gsMathOperationType.Subtract);
case BinaryExpressionType.Multiply:
return(gsMathOperationType.Multiply);
case BinaryExpressionType.Divide:
return(gsMathOperationType.Divide);
case BinaryExpressionType.Modulo:
return(gsMathOperationType.Modulo);
default:
throw new NotImplementedException($"Binary expression type {binaryExpressionType.GetType().Name} not supported");
}
}
public static string BinaryExpressionType(BinaryExpressionType btype)
{
switch (btype)
{
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.Add:
return "+";
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.BitwiseAnd:
return "&";
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.BitwiseOr:
return "|";
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.BitwiseXor:
return "^";
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.Divide:
return "/";
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.Modulo:
return "%";
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.Multiply:
return "*";
case Microsoft.SqlServer.TransactSql.ScriptDom.BinaryExpressionType.Subtract:
return "-";
default:
throw new GraphViewException("Invalid binary expression type");
}
}
private L.Expression WithCommonNumericType(L.Expression left, L.Expression right,
Func <L.Expression, L.Expression, L.Expression> action, BinaryExpressionType expressiontype = BinaryExpressionType.Unknown)
{
left = UnwrapNullable(left);
right = UnwrapNullable(right);
if (_options.HasFlag(EvaluateOptions.BooleanCalculation))
{
if (left.Type == typeof(bool))
{
left = L.Expression.Condition(left, L.Expression.Constant(1.0), L.Expression.Constant(0.0));
}
if (right.Type == typeof(bool))
{
right = L.Expression.Condition(right, L.Expression.Constant(1.0), L.Expression.Constant(0.0));
}
}
var precedence = new[]
{
typeof(decimal),
typeof(double),
typeof(float),
typeof(ulong),
typeof(long),
typeof(uint),
typeof(int),
typeof(ushort),
typeof(short),
typeof(byte),
typeof(sbyte)
};
int l = Array.IndexOf(precedence, left.Type);
int r = Array.IndexOf(precedence, right.Type);
if (l >= 0 && r >= 0)
{
var type = precedence[Math.Min(l, r)];
if (left.Type != type)
{
left = L.Expression.Convert(left, type);
}
if (right.Type != type)
{
right = L.Expression.Convert(right, type);
}
}
L.Expression comparer = null;
if (IgnoreCaseString)
{
if (Ordinal)
{
comparer = L.Expression.Property(null, typeof(StringComparer), "OrdinalIgnoreCase");
}
else
{
comparer = L.Expression.Property(null, typeof(StringComparer), "CurrentCultureIgnoreCase");
}
}
else
{
comparer = L.Expression.Property(null, typeof(StringComparer), "Ordinal");
}
if (comparer != null && (typeof(string).Equals(left.Type) || typeof(string).Equals(right.Type)))
{
switch (expressiontype)
{
case BinaryExpressionType.Equal: return(L.Expression.Call(comparer, typeof(StringComparer).GetRuntimeMethod("Equals", new[] { typeof(string), typeof(string) }), new L.Expression[] { left, right }));
case BinaryExpressionType.NotEqual: return(L.Expression.Not(L.Expression.Call(comparer, typeof(StringComparer).GetRuntimeMethod("Equals", new[] { typeof(string), typeof(string) }), new L.Expression[] { left, right })));
case BinaryExpressionType.GreaterOrEqual: return(L.Expression.GreaterThanOrEqual(L.Expression.Call(comparer, typeof(StringComparer).GetRuntimeMethod("Compare", new[] { typeof(string), typeof(string) }), new L.Expression[] { left, right }), L.Expression.Constant(0)));
case BinaryExpressionType.LesserOrEqual: return(L.Expression.LessThanOrEqual(L.Expression.Call(comparer, typeof(StringComparer).GetRuntimeMethod("Compare", new[] { typeof(string), typeof(string) }), new L.Expression[] { left, right }), L.Expression.Constant(0)));
case BinaryExpressionType.Greater: return(L.Expression.GreaterThan(L.Expression.Call(comparer, typeof(StringComparer).GetRuntimeMethod("Compare", new[] { typeof(string), typeof(string) }), new L.Expression[] { left, right }), L.Expression.Constant(0)));
case BinaryExpressionType.Lesser: return(L.Expression.LessThan(L.Expression.Call(comparer, typeof(StringComparer).GetRuntimeMethod("Compare", new[] { typeof(string), typeof(string) }), new L.Expression[] { left, right }), L.Expression.Constant(0)));
}
}
return(action(left, right));
}
public BinaryScalarFunction(ScalarFunction f1, ScalarFunction f2, BinaryExpressionType binaryType)
{
this.f1 = f1;
this.f2 = f2;
this.binaryType = binaryType;
}
public BinaryExpression(BinaryExpressionType type, LogicalExpression leftExpression, LogicalExpression rightExpression)
{
Type = type;
LeftExpression = leftExpression;
RightExpression = rightExpression;
}
public NQuery Where(object left, object right, BinaryExpressionType type)
{
Expression e = new BinaryExpression(type, new ValueExpression(left, Convert.GetTypeCode(left)), new ValueExpression(right, Convert.GetTypeCode(right)));
return new NQuery(this, e);
}
/// <summary>
/// Binary expression
/// </summary>
/// <param name="type">Binary expression type</param>
/// <param name="leftExpression">The left expression</param>
/// <param name="rightExpression">The right expression</param>
public BinaryExpression(BinaryExpressionType type, IExpression leftExpression, IExpression rightExpression)
{
this.type = type;
this.leftExpression = leftExpression;
this.rightExpression = rightExpression;
}
/// <summary>
/// Get binary operator string by expression type
/// </summary>
/// <param name="type">The binary expression type</param>
/// <returns>The binary operator string</returns>
protected static string GetBinaryOperatorString(BinaryExpressionType type)
{
switch (type)
{
case BinaryExpressionType.Plus:
return "+";
case BinaryExpressionType.Minus:
return "-";
case BinaryExpressionType.Multiply:
return "*";
case BinaryExpressionType.Div:
return "/";
case BinaryExpressionType.Mod:
return "%";
case BinaryExpressionType.BitAnd:
return "&";
default:
throw new ExpressionEvaluatorException("unknown binary operator");
}
}
private static Type AnalysisType(AstExpression left, BinaryExpressionType expressionType, AstExpression right)
{
switch (expressionType)
{
case BinaryExpressionType.Add:
case BinaryExpressionType.Subtract:
case BinaryExpressionType.Multiply:
case BinaryExpressionType.Divide:
case BinaryExpressionType.Modulo:
if (left.RuntimeType == right.RuntimeType && IsArithmetic(left.RuntimeType))
{
return(left.RuntimeType);
}
throw new AstException($"{left.RuntimeType}类型不支持“{expressionType}”运算!");
case BinaryExpressionType.LessThan:
case BinaryExpressionType.LessThanOrEqual:
case BinaryExpressionType.Equal:
case BinaryExpressionType.GreaterThanOrEqual:
case BinaryExpressionType.GreaterThan:
case BinaryExpressionType.NotEqual:
if (left.RuntimeType == right.RuntimeType && IsArithmetic(left.RuntimeType))
{
return(typeof(bool));
}
throw new AstException("左右表达式类型不相同!");
case BinaryExpressionType.OrElse:
case BinaryExpressionType.AndAlso:
if (left.RuntimeType == right.RuntimeType && left.RuntimeType == typeof(bool))
{
return(left.RuntimeType);
}
throw new AstException($"{left.RuntimeType}类型不支持“{expressionType}”运算!");
case BinaryExpressionType.Or:
case BinaryExpressionType.And:
case BinaryExpressionType.ExclusiveOr:
if (left.RuntimeType == right.RuntimeType && IsIntegerOrBool(left.RuntimeType))
{
return(left.RuntimeType);
}
throw new AstException($"{left.RuntimeType}类型不支持“{expressionType}”运算!");
case BinaryExpressionType.LeftShift:
case BinaryExpressionType.RightShift:
if (IsInteger(left.RuntimeType))
{
if (right.RuntimeType == typeof(int))
{
return(left.RuntimeType);
}
throw new AstException($"“{expressionType}”运算，右侧表达式类型必须是“int”!");
}
throw new AstException($"{left.RuntimeType}类型不支持“{expressionType}”运算!");
case BinaryExpressionType.Power:
if (left.RuntimeType == right.RuntimeType && left.RuntimeType == typeof(double))
{
return(left.RuntimeType);
}
#if NETSTANDARD2_1_OR_GREATER
if (left.RuntimeType == right.RuntimeType && left.RuntimeType == typeof(float))
{
return(left.RuntimeType);
}
#endif
throw new AstException($"{left.RuntimeType}类型不支持“{expressionType}”运算!");
case BinaryExpressionType.OrAssign:
case BinaryExpressionType.AndAssign:
case BinaryExpressionType.ExclusiveOrAssign:
if (!left.CanWrite)
{
throw new AstException("左表达式不可写!");
}
goto case BinaryExpressionType.Or;
case BinaryExpressionType.LeftShiftAssign:
case BinaryExpressionType.RightShiftAssign:
if (!left.CanWrite)
{
throw new AstException("左表达式不可写!");
}
goto case BinaryExpressionType.LeftShift;
case BinaryExpressionType.PowerAssign:
if (!left.CanWrite)
{
throw new AstException("左表达式不可写!");
}
goto case BinaryExpressionType.Power;
case BinaryExpressionType.AddAssign:
case BinaryExpressionType.SubtractAssign:
case BinaryExpressionType.MultiplyAssign:
case BinaryExpressionType.DivideAssign:
case BinaryExpressionType.ModuloAssign:
if (!left.CanWrite)
{
throw new AstException("左表达式不可写!");
}
goto case BinaryExpressionType.Add;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// 构造函数。
/// </summary>
/// <param name="left">左表达式。</param>
/// <param name="expressionType">计算方式。</param>
/// <param name="right">右表达式。</param>
public BinaryAst(AstExpression left, BinaryExpressionType expressionType, AstExpression right) : base(AnalysisType(left, expressionType, right))
{
this.left = left;
this.expressionType = expressionType;
this.right = right;
}
private BinaryAst(BinaryAst binaryAst) : base(binaryAst.RuntimeType)
{
left = binaryAst.left;
expressionType = binaryAst.expressionType - 1;
right = binaryAst.right;
}
public BinaryExpression(BinaryExpressionType type, LogicalExpression leftExpression, LogicalExpression rightExpression)
{
Type = type;
LeftExpression = leftExpression;
RightExpression = rightExpression;
}
public BinaryExpression(BashExpression lhs, BashExpression rhs, BinaryExpressionType type)
{
Left = lhs;
Right = rhs;
Type = type;
}
