解析单语句布尔表达式树

Question

MSDN文档有一个很好的解析表达式树的例子 ：

// Create an expression tree.
Expression<Func<int, bool>> exprTree = num => num < 5;

// Decompose the expression tree.
ParameterExpression param = (ParameterExpression)exprTree.Parameters[0];
BinaryExpression operation = (BinaryExpression)exprTree.Body;
ParameterExpression left = (ParameterExpression)operation.Left;
ConstantExpression right = (ConstantExpression)operation.Right;

Console.WriteLine("Decomposed expression: {0} => {1} {2} {3}",
              param.Name, left.Name, operation.NodeType, right.Value);

但我没有看到如何解析这样的事情的例子：

MyDomainObject foo;
Expression<Func<bool>> exprTree = () => ((foo.Scale < 5 || foo.Scale > 20) && foo.Scale <> -100) || foo.IsExempt;

我的目标是找到或构建一个实用程序，它可以（1）处理任何级别的括号嵌套，以及（2）生成一个包含等效SQL“where”子句的字符串作为解析表达式树的产品。 任何人都有一个代码段，可以帮助或知道解决此问题的nuget包？

对于上面的嵌套表达式，假设一个名为“MyDomainObject”的数据库表，正确的SQL where子句字符串输出将是：

(( Scale < 5 or Scale > 20) and Scale != -100) or IsExempt = true

显然，在没有二元运算符的情况下，我的想象解析器会假设只是断言'true'，就像“IsExempt = true”的情况一样

Answer 1

所以听起来你的问题不是“解析”（因为表达式已被解析为C＃表达式），你想要的是遍历表达式树并输出一个SQL表达式。

如果你可以避免它，我不建议你自己编写代码。 对于大多数人来说，LINQ to Entities可能是更好的方式， 因为它基本上是为你做的 ，同时完全隐藏了SQL。

如果您有其他要求（例如较低的.NET版本，或者您必须拥有SQL字符串），并且愿意自己编写代码，则可以使用递归函数执行此操作。 此函数可以使用表达式并将SQL子句作为字符串返回。

有些东西（没有经过测试，将其视为伪代码）：

public string WriteClause(Expression exp)
{
    if (exp is ParameterExpression)
    {
        return (exp as ParameterExpression).Name;
    }
    else if (exp is BinaryExpression)
    {
        var binaryExpression = exp as BinaryExpression;

        return "(" +
               WriteClause(binaryExpression.Left) + " "
               GetSqlOperator(binaryExpression.Method) + " "
               WriteClause(binaryExpression.Right) +
               ")";
    }
    else if...

    ...etc...

}

public string GetSqlOperator(MethodInfo method)
{
    switch (method.Name)
    {
        case "Add":
            return "+";
        case "Or":
            return "or";

        ...etc...
    }
}

递归意味着这种方法应该处理任何级别的括号深度。 它有点幼稚，所以它会放入比你需要的括号更多的括号。

Answer 2

这是一个至少将输入转换为有效SQL表达式的实现。 您需要自己实现更多表达式类型，但它可以让您了解它的工作原理。

这个答案恰好与Kazetsukai的答案非常相似，但它使用Expression.NodeType来查找运算符，因为表达式树中没有MethodInfos 。

还要注意，这会产生比实际需要更多的括号。 为了减少括号的数量，考虑到SQL中的运算符优先级，需要进一步分析表达式。

public static string GetSqlExpression(Expression expression)
{
    if (expression is BinaryExpression)
    {
        return string.Format("({0} {1} {2})",
            GetSqlExpression(((BinaryExpression)expression).Left),
            GetBinaryOperator((BinaryExpression)expression),
            GetSqlExpression(((BinaryExpression)expression).Right));
    }

    if (expression is MemberExpression)
    {
        MemberExpression member = (MemberExpression)expression;

        // it is somewhat naive to make a bool member into "Member = TRUE"
        // since the expression "Member == true" will turn into "(Member = TRUE) = TRUE"
        if (member.Type == typeof(bool))
        {
            return string.Format("([{0}] = TRUE)", member.Member.Name);
        }

        return string.Format("[{0}]", member.Member.Name);
    }

    if (expression is ConstantExpression)
    {
        ConstantExpression constant = (ConstantExpression)expression;

        // create a proper SQL representation for each type
        if (constant.Type == typeof(int) ||
            constant.Type == typeof(string))
        {
            return constant.Value.ToString();
        }

        if (constant.Type == typeof(bool))
        {
            return (bool)constant.Value ? "TRUE" : "FALSE";
        }

        throw new ArgumentException();
    }

    throw new ArgumentException();
}

public static string GetBinaryOperator(BinaryExpression expression)
{
    switch (expression.NodeType)
    {
        case ExpressionType.Equal:
            return "=";
        case ExpressionType.NotEqual:
            return "<>";
        case ExpressionType.OrElse:
            return "OR";
        case ExpressionType.AndAlso:
            return "AND";
        case ExpressionType.LessThan:
            return "<";
        case ExpressionType.GreaterThan:
            return ">";
        default:
            throw new ArgumentException();
    }
}

结果是：

(((([Scale] < 5) OR ([Scale] > 20)) AND ([Scale] <> -100)) OR ([IsExempt] = TRUE))

像这样调用方法：

string sqlExpression = GetSqlExpression(exprTree.Body);

我建议以更实用的方式构建表达式树。 不使用具体的foo构建Func<bool> ，而应使用Func<Foo, bool> 。 但是，无论如何它都会起作用。 它看起来不对劲。

Expression<Func<Foo, bool>> exprTree =
    (foo) => ((foo.Scale < 5 || foo.Scale > 20) && foo.Scale != -100) || foo.IsExempt == true;

显然，当您可以使用LINQ to Entities时，通常不需要自己构建SQL文本。 LINQ to实体和表达式树都需要.NET 3.5，您实际上可以将LINQ转换为sql语句 。

我不确定像IsExempt = TRUE这样的表达式是否适用于SQL Server。 我认为它应该是IsExempt = 1因为数据类型是bit 。 还需要单独处理像Value == null或Value != null这样的表达式，因为在SQL表达式中不能使用Value = NULL或Value <> NULL 。 它必须是Value IS NULL或Value IS NOT NULL 。