POData\UriProcessor\QueryProcessor\ExpressionParser\ExpressionParser::generateComparisonExpression()

Complexity

Conditions	20
Paths	416

Size

Total Lines	128
Code Lines	65

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    private static function generateComparisonExpression(
        AbstractExpression $left,
        AbstractExpression $right,
        ExpressionToken $expressionToken,
        bool $isPHPExpressionProvider
    ): AbstractExpression {
        FunctionDescription::verifyRelationalOpArguments($expressionToken, $left, $right);

        //We need special handling for comparison of following types:
        //1. EdmString
        //2. DateTime
        //3. Guid
        //4. Binary
        //Will make these comparison as function calls, which will
        // be converted to language specific function call by expression
        // provider
        $string = new StringType();
        if ($left->typeIs($string) && $right->typeIs($string)) {
            $strcmpFunctions = FunctionDescription::stringComparisonFunctions();
            $left            = new FunctionCallExpression($strcmpFunctions[0], [$left, $right]);
            $right           = new ConstantExpression(0, new Int32());
        }

        $dateTime = new DateTime();
        if ($left->typeIs($dateTime) && $right->typeIs($dateTime)) {
            $dateTimeCmpFunctions = FunctionDescription::dateTimeComparisonFunctions();
            $left                 = new FunctionCallExpression($dateTimeCmpFunctions[0], [$left, $right]);
            $right                = new ConstantExpression(0, new Int32());
        }

        $guid = new Guid();
        if ($left->typeIs($guid) && $right->typeIs($guid)) {
            $guidEqualityFunctions = FunctionDescription::guidEqualityFunctions();
            $left                  = new FunctionCallExpression($guidEqualityFunctions[0], [$left, $right]);
            $right                 = new ConstantExpression(true, new Boolean());
        }

        $binary = new Binary();
        if ($left->typeIs($binary) && $right->typeIs($binary)) {
            $binaryEqualityFunctions = FunctionDescription::binaryEqualityFunctions();
            $left                    = new FunctionCallExpression($binaryEqualityFunctions[0], [$left, $right]);
            $right                   = new ConstantExpression(true, new Boolean());
        }

        $null = new Null1();
        if ($left->typeIs($null) || $right->typeIs($null)) {
            // If the end user is responsible for implementing IExpressionProvider
            // then the sub-tree for a nullability check would be:

            //          RelationalExpression(EQ/NE)
            //                    |
            //               ------------
            //               |           |
            //               |           |
            //            CustomerID    NULL

            // Otherwise (In case of default PHPExpressionProvider):

            //  CustomerID eq null
            //  ==================

            //              FunctionCallExpression(is_null)
            //                       |
            //                       |- Signature => bool (typeof(CustomerID))
            //                       |- args => {CustomerID}

            //  CustomerID ne null
            //  ==================

            //              UnaryExpression (not)
            //                       |
            //              FunctionCallExpression(is_null)
            //                       |
            //                       |- Signature => bool (typeof(CustomerID))
            //                       |- args => {CustomerID}

            if ($isPHPExpressionProvider) {
                $arg                       = $left->typeIs($null) ? $right : $left;
                $isNullFunctionDescription = new FunctionDescription('is_null', new Boolean(), [$arg->getType()]);
                switch ($expressionToken->Text) {
                    case ODataConstants::KEYWORD_EQUAL:
                        return new FunctionCallExpression($isNullFunctionDescription, [$arg]);
                    case ODataConstants::KEYWORD_NOT_EQUAL:
                        return new UnaryExpression(
                            new FunctionCallExpression($isNullFunctionDescription, [$arg]),
                            ExpressionType::NOT_LOGICAL(),
                            new Boolean()
                        );
                }
            }
        }

        switch ($expressionToken->Text) {
            case ODataConstants::KEYWORD_EQUAL:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::EQUAL()
                );
            case ODataConstants::KEYWORD_NOT_EQUAL:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::NOTEQUAL()
                );
            case ODataConstants::KEYWORD_GREATERTHAN:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::GREATERTHAN()
                );
            case ODataConstants::KEYWORD_GREATERTHAN_OR_EQUAL:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::GREATERTHAN_OR_EQUAL()
                );
            case ODataConstants::KEYWORD_LESSTHAN:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::LESSTHAN()
                );
            default:
                return new RelationalExpression(
                    $left,
                    $right,
                    ExpressionType::LESSTHAN_OR_EQUAL()
                );