AnalyzeExpression()

void System.Data.Select.AnalyzeExpression ( BinaryNode expr )

inlineprivate

Definition at line 67 of file Select.cs.

    {
        if (_linearExpression == _expression)
        {
            return;
        }
        if (expr._op == 27)
        {
            _linearExpression = _expression;
            return;
        }
        if (expr._op == 26)
        {
            bool flag = false;
            bool flag2 = false;
            if (expr._left is BinaryNode)
            {
                AnalyzeExpression((BinaryNode)expr._left);
                if (_linearExpression == _expression)
                {
                    return;
                }
                flag = true;
            }
            else
            {
                UnaryNode unaryNode = expr._left as UnaryNode;
                if (unaryNode != null)
                {
                    while (unaryNode._op == 0 && unaryNode._right is UnaryNode && ((UnaryNode)unaryNode._right)._op == 0)
                    {
                        unaryNode = (UnaryNode)unaryNode._right;
                    }
                    if (unaryNode._op == 0 && unaryNode._right is BinaryNode)
                    {
                        AnalyzeExpression((BinaryNode)unaryNode._right);
                        if (_linearExpression == _expression)
                        {
                            return;
                        }
                        flag = true;
                    }
                }
            }
            if (expr._right is BinaryNode)
            {
                AnalyzeExpression((BinaryNode)expr._right);
                if (_linearExpression == _expression)
                {
                    return;
                }
                flag2 = true;
            }
            else
            {
                UnaryNode unaryNode2 = expr._right as UnaryNode;
                if (unaryNode2 != null)
                {
                    while (unaryNode2._op == 0 && unaryNode2._right is UnaryNode && ((UnaryNode)unaryNode2._right)._op == 0)
                    {
                        unaryNode2 = (UnaryNode)unaryNode2._right;
                    }
                    if (unaryNode2._op == 0 && unaryNode2._right is BinaryNode)
                    {
                        AnalyzeExpression((BinaryNode)unaryNode2._right);
                        if (_linearExpression == _expression)
                        {
                            return;
                        }
                        flag2 = true;
                    }
                }
            }
            if (!(flag && flag2))
            {
                ExpressionNode expressionNode = (flag ? expr._right : expr._left);
                _linearExpression = ((_linearExpression == null) ? expressionNode : new BinaryNode(_table, 26, expressionNode, _linearExpression));
            }
            return;
        }
        if (IsSupportedOperator(expr._op))
        {
            if (expr._left is NameNode && expr._right is ConstNode)
            {
                ColumnInfo columnInfo = _candidateColumns[((NameNode)expr._left)._column.Ordinal];
                columnInfo.expr = ((columnInfo.expr == null) ? expr : new BinaryNode(_table, 26, expr, columnInfo.expr));
                if (expr._op == 7)
                {
                    columnInfo.equalsOperator = true;
                }
                _candidatesForBinarySearch = true;
                return;
            }
            if (expr._right is NameNode && expr._left is ConstNode)
            {
                ExpressionNode left = expr._left;
                expr._left = expr._right;
                expr._right = left;
                switch (expr._op)
                {
                case 8:
                    expr._op = 9;
                    break;
                case 9:
                    expr._op = 8;
                    break;
                case 10:
                    expr._op = 11;
                    break;
                case 11:
                    expr._op = 10;
                    break;
                }
                ColumnInfo columnInfo2 = _candidateColumns[((NameNode)expr._left)._column.Ordinal];
                columnInfo2.expr = ((columnInfo2.expr == null) ? expr : new BinaryNode(_table, 26, expr, columnInfo2.expr));
                if (expr._op == 7)
                {
                    columnInfo2.equalsOperator = true;
                }
                _candidatesForBinarySearch = true;
                return;
            }
        }
        _linearExpression = ((_linearExpression == null) ? expr : new BinaryNode(_table, 26, expr, _linearExpression));
    }

References System.Data.Select._candidateColumns, System.Data.Select._candidatesForBinarySearch, System.Data.Select._expression, System.Data.BinaryNode._left, System.Data.Select._linearExpression, System.Data.BinaryNode._op, System.Data.UnaryNode._op, System.Data.BinaryNode._right, System.Data.Select._table, System.Data.Select.AnalyzeExpression(), and System.Data.Select.IsSupportedOperator().

Referenced by System.Data.Select.AnalyzeExpression(), and System.Data.Select.SelectRows().