vendor/doctrine/orm/lib/Doctrine/ORM/Query/Parser.php line 410

Open in your IDE?
  1. <?php
  3. /*
  4.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  5.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  6.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  7.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  8.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  9.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  10.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  11.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  12.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  13.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  14.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  15.  *
  16.  * This software consists of voluntary contributions made by many individuals
  17.  * and is licensed under the MIT license. For more information, see
  18.  * <http://www.doctrine-project.org>.
  19.  */
  21. namespace Doctrine\ORM\Query;
  23. use Doctrine\Deprecations\Deprecation;
  24. use Doctrine\ORM\EntityManager;
  25. use Doctrine\ORM\EntityManagerInterface;
  26. use Doctrine\ORM\Mapping\ClassMetadata;
  27. use Doctrine\ORM\Query;
  28. use Doctrine\ORM\Query\AST\AggregateExpression;
  29. use Doctrine\ORM\Query\AST\ArithmeticExpression;
  30. use Doctrine\ORM\Query\AST\ArithmeticFactor;
  31. use Doctrine\ORM\Query\AST\ArithmeticTerm;
  32. use Doctrine\ORM\Query\AST\BetweenExpression;
  33. use Doctrine\ORM\Query\AST\CoalesceExpression;
  34. use Doctrine\ORM\Query\AST\CollectionMemberExpression;
  35. use Doctrine\ORM\Query\AST\ComparisonExpression;
  36. use Doctrine\ORM\Query\AST\ConditionalPrimary;
  37. use Doctrine\ORM\Query\AST\DeleteClause;
  38. use Doctrine\ORM\Query\AST\DeleteStatement;
  39. use Doctrine\ORM\Query\AST\EmptyCollectionComparisonExpression;
  40. use Doctrine\ORM\Query\AST\ExistsExpression;
  41. use Doctrine\ORM\Query\AST\FromClause;
  42. use Doctrine\ORM\Query\AST\Functions;
  43. use Doctrine\ORM\Query\AST\Functions\FunctionNode;
  44. use Doctrine\ORM\Query\AST\GeneralCaseExpression;
  45. use Doctrine\ORM\Query\AST\GroupByClause;
  46. use Doctrine\ORM\Query\AST\HavingClause;
  47. use Doctrine\ORM\Query\AST\IdentificationVariableDeclaration;
  48. use Doctrine\ORM\Query\AST\IndexBy;
  49. use Doctrine\ORM\Query\AST\InExpression;
  50. use Doctrine\ORM\Query\AST\InputParameter;
  51. use Doctrine\ORM\Query\AST\InstanceOfExpression;
  52. use Doctrine\ORM\Query\AST\Join;
  53. use Doctrine\ORM\Query\AST\JoinAssociationPathExpression;
  54. use Doctrine\ORM\Query\AST\LikeExpression;
  55. use Doctrine\ORM\Query\AST\Literal;
  56. use Doctrine\ORM\Query\AST\NewObjectExpression;
  57. use Doctrine\ORM\Query\AST\Node;
  58. use Doctrine\ORM\Query\AST\NullComparisonExpression;
  59. use Doctrine\ORM\Query\AST\NullIfExpression;
  60. use Doctrine\ORM\Query\AST\OrderByClause;
  61. use Doctrine\ORM\Query\AST\OrderByItem;
  62. use Doctrine\ORM\Query\AST\PartialObjectExpression;
  63. use Doctrine\ORM\Query\AST\PathExpression;
  64. use Doctrine\ORM\Query\AST\QuantifiedExpression;
  65. use Doctrine\ORM\Query\AST\RangeVariableDeclaration;
  66. use Doctrine\ORM\Query\AST\SelectClause;
  67. use Doctrine\ORM\Query\AST\SelectExpression;
  68. use Doctrine\ORM\Query\AST\SelectStatement;
  69. use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
  70. use Doctrine\ORM\Query\AST\SimpleSelectClause;
  71. use Doctrine\ORM\Query\AST\SimpleSelectExpression;
  72. use Doctrine\ORM\Query\AST\SimpleWhenClause;
  73. use Doctrine\ORM\Query\AST\Subselect;
  74. use Doctrine\ORM\Query\AST\SubselectFromClause;
  75. use Doctrine\ORM\Query\AST\UpdateClause;
  76. use Doctrine\ORM\Query\AST\UpdateItem;
  77. use Doctrine\ORM\Query\AST\UpdateStatement;
  78. use Doctrine\ORM\Query\AST\WhenClause;
  79. use Doctrine\ORM\Query\AST\WhereClause;
  80. use ReflectionClass;
  82. use function array_intersect;
  83. use function array_search;
  84. use function assert;
  85. use function call_user_func;
  86. use function class_exists;
  87. use function count;
  88. use function explode;
  89. use function implode;
  90. use function in_array;
  91. use function interface_exists;
  92. use function is_string;
  93. use function sprintf;
  94. use function strlen;
  95. use function strpos;
  96. use function strrpos;
  97. use function strtolower;
  98. use function substr;
  100. /**
  101.  * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  102.  * Parses a DQL query, reports any errors in it, and generates an AST.
  103.  */
  104. class Parser
  105. {
  106.     /**
  107.      * READ-ONLY: Maps BUILT-IN string function names to AST class names.
  108.      *
  109.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  110.      */
  111.     private static $stringFunctions = [
  112.         'concat'    => Functions\ConcatFunction::class,
  113.         'substring' => Functions\SubstringFunction::class,
  114.         'trim'      => Functions\TrimFunction::class,
  115.         'lower'     => Functions\LowerFunction::class,
  116.         'upper'     => Functions\UpperFunction::class,
  117.         'identity'  => Functions\IdentityFunction::class,
  118.     ];
  120.     /**
  121.      * READ-ONLY: Maps BUILT-IN numeric function names to AST class names.
  122.      *
  123.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  124.      */
  125.     private static $numericFunctions = [
  126.         'length'    => Functions\LengthFunction::class,
  127.         'locate'    => Functions\LocateFunction::class,
  128.         'abs'       => Functions\AbsFunction::class,
  129.         'sqrt'      => Functions\SqrtFunction::class,
  130.         'mod'       => Functions\ModFunction::class,
  131.         'size'      => Functions\SizeFunction::class,
  132.         'date_diff' => Functions\DateDiffFunction::class,
  133.         'bit_and'   => Functions\BitAndFunction::class,
  134.         'bit_or'    => Functions\BitOrFunction::class,
  136.         // Aggregate functions
  137.         'min'       => Functions\MinFunction::class,
  138.         'max'       => Functions\MaxFunction::class,
  139.         'avg'       => Functions\AvgFunction::class,
  140.         'sum'       => Functions\SumFunction::class,
  141.         'count'     => Functions\CountFunction::class,
  142.     ];
  144.     /**
  145.      * READ-ONLY: Maps BUILT-IN datetime function names to AST class names.
  146.      *
  147.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  148.      */
  149.     private static $datetimeFunctions = [
  150.         'current_date'      => Functions\CurrentDateFunction::class,
  151.         'current_time'      => Functions\CurrentTimeFunction::class,
  152.         'current_timestamp' => Functions\CurrentTimestampFunction::class,
  153.         'date_add'          => Functions\DateAddFunction::class,
  154.         'date_sub'          => Functions\DateSubFunction::class,
  155.     ];
  157.     /*
  158.      * Expressions that were encountered during parsing of identifiers and expressions
  159.      * and still need to be validated.
  160.      */
  162.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  163.     private $deferredIdentificationVariables = [];
  165.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  166.     private $deferredPartialObjectExpressions = [];
  168.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  169.     private $deferredPathExpressions = [];
  171.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  172.     private $deferredResultVariables = [];
  174.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  175.     private $deferredNewObjectExpressions = [];
  177.     /**
  178.      * The lexer.
  179.      *
  180.      * @var Lexer
  181.      */
  182.     private $lexer;
  184.     /**
  185.      * The parser result.
  186.      *
  187.      * @var ParserResult
  188.      */
  189.     private $parserResult;
  191.     /**
  192.      * The EntityManager.
  193.      *
  194.      * @var EntityManagerInterface
  195.      */
  196.     private $em;
  198.     /**
  199.      * The Query to parse.
  200.      *
  201.      * @var Query
  202.      */
  203.     private $query;
  205.     /**
  206.      * Map of declared query components in the parsed query.
  207.      *
  208.      * @psalm-var array<string, array<string, mixed>>
  209.      */
  210.     private $queryComponents = [];
  212.     /**
  213.      * Keeps the nesting level of defined ResultVariables.
  214.      *
  215.      * @var int
  216.      */
  217.     private $nestingLevel = 0;
  219.     /**
  220.      * Any additional custom tree walkers that modify the AST.
  221.      *
  222.      * @psalm-var list<class-string<TreeWalker>>
  223.      */
  224.     private $customTreeWalkers = [];
  226.     /**
  227.      * The custom last tree walker, if any, that is responsible for producing the output.
  228.      *
  229.      * @var class-string<TreeWalker>
  230.      */
  231.     private $customOutputWalker;
  233.     /** @psalm-var list<AST\SelectExpression> */
  234.     private $identVariableExpressions = [];
  236.     /**
  237.      * Creates a new query parser object.
  238.      *
  239.      * @param Query $query The Query to parse.
  240.      */
  241.     public function __construct(Query $query)
  242.     {
  243.         $this->query        = $query;
  244.         $this->em           = $query->getEntityManager();
  245.         $this->lexer        = new Lexer((string) $query->getDQL());
  246.         $this->parserResult = new ParserResult();
  247.     }
  249.     /**
  250.      * Sets a custom tree walker that produces output.
  251.      * This tree walker will be run last over the AST, after any other walkers.
  252.      *
  253.      * @param string $className
  254.      *
  255.      * @return void
  256.      */
  257.     public function setCustomOutputTreeWalker($className)
  258.     {
  259.         $this->customOutputWalker = $className;
  260.     }
  262.     /**
  263.      * Adds a custom tree walker for modifying the AST.
  264.      *
  265.      * @psalm-param class-string $className
  266.      *
  267.      * @return void
  268.      */
  269.     public function addCustomTreeWalker($className)
  270.     {
  271.         $this->customTreeWalkers[] = $className;
  272.     }
  274.     /**
  275.      * Gets the lexer used by the parser.
  276.      *
  277.      * @return Lexer
  278.      */
  279.     public function getLexer()
  280.     {
  281.         return $this->lexer;
  282.     }
  284.     /**
  285.      * Gets the ParserResult that is being filled with information during parsing.
  286.      *
  287.      * @return ParserResult
  288.      */
  289.     public function getParserResult()
  290.     {
  291.         return $this->parserResult;
  292.     }
  294.     /**
  295.      * Gets the EntityManager used by the parser.
  296.      *
  297.      * @return EntityManagerInterface
  298.      */
  299.     public function getEntityManager()
  300.     {
  301.         return $this->em;
  302.     }
  304.     /**
  305.      * Parses and builds AST for the given Query.
  306.      *
  307.      * @return SelectStatement|UpdateStatement|DeleteStatement
  308.      */
  309.     public function getAST()
  310.     {
  311.         // Parse & build AST
  312.         $AST = $this->QueryLanguage();
  314.         // Process any deferred validations of some nodes in the AST.
  315.         // This also allows post-processing of the AST for modification purposes.
  316.         $this->processDeferredIdentificationVariables();
  318.         if ($this->deferredPartialObjectExpressions) {
  319.             $this->processDeferredPartialObjectExpressions();
  320.         }
  322.         if ($this->deferredPathExpressions) {
  323.             $this->processDeferredPathExpressions();
  324.         }
  326.         if ($this->deferredResultVariables) {
  327.             $this->processDeferredResultVariables();
  328.         }
  330.         if ($this->deferredNewObjectExpressions) {
  331.             $this->processDeferredNewObjectExpressions($AST);
  332.         }
  334.         $this->processRootEntityAliasSelected();
  336.         // TODO: Is there a way to remove this? It may impact the mixed hydration resultset a lot!
  337.         $this->fixIdentificationVariableOrder($AST);
  339.         return $AST;
  340.     }
  342.     /**
  343.      * Attempts to match the given token with the current lookahead token.
  344.      *
  345.      * If they match, updates the lookahead token; otherwise raises a syntax
  346.      * error.
  347.      *
  348.      * @param int $token The token type.
  349.      *
  350.      * @return void
  351.      *
  352.      * @throws QueryException If the tokens don't match.
  353.      */
  354.     public function match($token)
  355.     {
  356.         $lookaheadType = $this->lexer->lookahead['type'] ?? null;
  358.         // Short-circuit on first condition, usually types match
  359.         if ($lookaheadType === $token) {
  360.             $this->lexer->moveNext();
  362.             return;
  363.         }
  365.         // If parameter is not identifier (1-99) must be exact match
  366.         if ($token < Lexer::T_IDENTIFIER) {
  367.             $this->syntaxError($this->lexer->getLiteral($token));
  368.         }
  370.         // If parameter is keyword (200+) must be exact match
  371.         if ($token > Lexer::T_IDENTIFIER) {
  372.             $this->syntaxError($this->lexer->getLiteral($token));
  373.         }
  375.         // If parameter is T_IDENTIFIER, then matches T_IDENTIFIER (100) and keywords (200+)
  376.         if ($token === Lexer::T_IDENTIFIER && $lookaheadType < Lexer::T_IDENTIFIER) {
  377.             $this->syntaxError($this->lexer->getLiteral($token));
  378.         }
  380.         $this->lexer->moveNext();
  381.     }
  383.     /**
  384.      * Frees this parser, enabling it to be reused.
  385.      *
  386.      * @param bool $deep     Whether to clean peek and reset errors.
  387.      * @param int  $position Position to reset.
  388.      *
  389.      * @return void
  390.      */
  391.     public function free($deep = false, $position = 0)
  392.     {
  393.         // WARNING! Use this method with care. It resets the scanner!
  394.         $this->lexer->resetPosition($position);
  396.         // Deep = true cleans peek and also any previously defined errors
  397.         if ($deep) {
  398.             $this->lexer->resetPeek();
  399.         }
  401.         $this->lexer->token     = null;
  402.         $this->lexer->lookahead = null;
  403.     }
  405.     /**
  406.      * Parses a query string.
  407.      *
  408.      * @return ParserResult
  409.      */
  410.     public function parse()
  411.     {
  412.         $AST = $this->getAST();
  414.         $customWalkers = $this->query->getHint(Query::HINT_CUSTOM_TREE_WALKERS);
  415.         if ($customWalkers !== false) {
  416.             $this->customTreeWalkers = $customWalkers;
  417.         }
  419.         $customOutputWalker = $this->query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER);
  420.         if ($customOutputWalker !== false) {
  421.             $this->customOutputWalker = $customOutputWalker;
  422.         }
  424.         // Run any custom tree walkers over the AST
  425.         if ($this->customTreeWalkers) {
  426.             $treeWalkerChain = new TreeWalkerChain($this->query, $this->parserResult, $this->queryComponents);
  428.             foreach ($this->customTreeWalkers as $walker) {
  429.                 $treeWalkerChain->addTreeWalker($walker);
  430.             }
  432.             switch (true) {
  433.                 case $AST instanceof AST\UpdateStatement:
  434.                     $treeWalkerChain->walkUpdateStatement($AST);
  435.                     break;
  437.                 case $AST instanceof AST\DeleteStatement:
  438.                     $treeWalkerChain->walkDeleteStatement($AST);
  439.                     break;
  441.                 case $AST instanceof AST\SelectStatement:
  442.                 default:
  443.                     $treeWalkerChain->walkSelectStatement($AST);
  444.             }
  446.             $this->queryComponents = $treeWalkerChain->getQueryComponents();
  447.         }
  449.         $outputWalkerClass = $this->customOutputWalker ?: SqlWalker::class;
  450.         $outputWalker      = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
  452.         // Assign an SQL executor to the parser result
  453.         $this->parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
  455.         return $this->parserResult;
  456.     }
  458.     /**
  459.      * Fixes order of identification variables.
  460.      *
  461.      * They have to appear in the select clause in the same order as the
  462.      * declarations (from ... x join ... y join ... z ...) appear in the query
  463.      * as the hydration process relies on that order for proper operation.
  464.      *
  465.      * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST
  466.      */
  467.     private function fixIdentificationVariableOrder(Node $AST): void
  468.     {
  469.         if (count($this->identVariableExpressions) <= 1) {
  470.             return;
  471.         }
  473.         assert($AST instanceof AST\SelectStatement);
  475.         foreach ($this->queryComponents as $dqlAlias => $qComp) {
  476.             if (! isset($this->identVariableExpressions[$dqlAlias])) {
  477.                 continue;
  478.             }
  480.             $expr = $this->identVariableExpressions[$dqlAlias];
  481.             $key  = array_search($expr, $AST->selectClause->selectExpressions);
  483.             unset($AST->selectClause->selectExpressions[$key]);
  485.             $AST->selectClause->selectExpressions[] = $expr;
  486.         }
  487.     }
  489.     /**
  490.      * Generates a new syntax error.
  491.      *
  492.      * @param string $expected Expected string.
  493.      * @psalm-param array<string, mixed>|null $token    Got token.
  494.      *
  495.      * @return void
  496.      * @psalm-return no-return
  497.      *
  498.      * @throws QueryException
  499.      */
  500.     public function syntaxError($expected = '', $token = null)
  501.     {
  502.         if ($token === null) {
  503.             $token = $this->lexer->lookahead;
  504.         }
  506.         $tokenPos = $token['position'] ?? '-1';
  508.         $message  = sprintf('line 0, col %d: Error: ', $tokenPos);
  509.         $message .= $expected !== '' ? sprintf('Expected %s, got ', $expected) : 'Unexpected ';
  510.         $message .= $this->lexer->lookahead === null ? 'end of string.' : sprintf("'%s'", $token['value']);
  512.         throw QueryException::syntaxError($message, QueryException::dqlError($this->query->getDQL()));
  513.     }
  515.     /**
  516.      * Generates a new semantical error.
  517.      *
  518.      * @param string $message Optional message.
  519.      * @psalm-param array<string, mixed>|null $token Optional token.
  520.      *
  521.      * @return void
  522.      *
  523.      * @throws QueryException
  524.      */
  525.     public function semanticalError($message = '', $token = null)
  526.     {
  527.         if ($token === null) {
  528.             $token = $this->lexer->lookahead ?? ['position' => null];
  529.         }
  531.         // Minimum exposed chars ahead of token
  532.         $distance = 12;
  534.         // Find a position of a final word to display in error string
  535.         $dql    = $this->query->getDQL();
  536.         $length = strlen($dql);
  537.         $pos    = $token['position'] + $distance;
  538.         $pos    = strpos($dql, ' ', $length > $pos ? $pos : $length);
  539.         $length = $pos !== false ? $pos - $token['position'] : $distance;
  541.         $tokenPos = isset($token['position']) && $token['position'] > 0 ? $token['position'] : '-1';
  542.         $tokenStr = substr($dql, $token['position'], $length);
  544.         // Building informative message
  545.         $message = 'line 0, col ' . $tokenPos . " near '" . $tokenStr . "': Error: " . $message;
  547.         throw QueryException::semanticalError($message, QueryException::dqlError($this->query->getDQL()));
  548.     }
  550.     /**
  551.      * Peeks beyond the matched closing parenthesis and returns the first token after that one.
  552.      *
  553.      * @param bool $resetPeek Reset peek after finding the closing parenthesis.
  554.      *
  555.      * @return mixed[]
  556.      * @psalm-return array{value: string, type: int|null|string, position: int}|null
  557.      */
  558.     private function peekBeyondClosingParenthesis(bool $resetPeek = true): ?array
  559.     {
  560.         $token        = $this->lexer->peek();
  561.         $numUnmatched = 1;
  563.         while ($numUnmatched > 0 && $token !== null) {
  564.             switch ($token['type']) {
  565.                 case Lexer::T_OPEN_PARENTHESIS:
  566.                     ++$numUnmatched;
  567.                     break;
  569.                 case Lexer::T_CLOSE_PARENTHESIS:
  570.                     --$numUnmatched;
  571.                     break;
  573.                 default:
  574.                     // Do nothing
  575.             }
  577.             $token = $this->lexer->peek();
  578.         }
  580.         if ($resetPeek) {
  581.             $this->lexer->resetPeek();
  582.         }
  584.         return $token;
  585.     }
  587.     /**
  588.      * Checks if the given token indicates a mathematical operator.
  589.      *
  590.      * @psalm-param array<string, mixed>|null $token
  591.      */
  592.     private function isMathOperator(?array $token): bool
  593.     {
  594.         return $token !== null && in_array($token['type'], [Lexer::T_PLUS, Lexer::T_MINUS, Lexer::T_DIVIDE, Lexer::T_MULTIPLY]);
  595.     }
  597.     /**
  598.      * Checks if the next-next (after lookahead) token starts a function.
  599.      *
  600.      * @return bool TRUE if the next-next tokens start a function, FALSE otherwise.
  601.      */
  602.     private function isFunction(): bool
  603.     {
  604.         $lookaheadType = $this->lexer->lookahead['type'];
  605.         $peek          = $this->lexer->peek();
  607.         $this->lexer->resetPeek();
  609.         return $lookaheadType >= Lexer::T_IDENTIFIER && $peek !== null && $peek['type'] === Lexer::T_OPEN_PARENTHESIS;
  610.     }
  612.     /**
  613.      * Checks whether the given token type indicates an aggregate function.
  614.      *
  615.      * @psalm-param Lexer::T_* $tokenType
  616.      *
  617.      * @return bool TRUE if the token type is an aggregate function, FALSE otherwise.
  618.      */
  619.     private function isAggregateFunction(int $tokenType): bool
  620.     {
  621.         return in_array(
  622.             $tokenType,
  623.             [Lexer::T_AVG, Lexer::T_MIN, Lexer::T_MAX, Lexer::T_SUM, Lexer::T_COUNT]
  624.         );
  625.     }
  627.     /**
  628.      * Checks whether the current lookahead token of the lexer has the type T_ALL, T_ANY or T_SOME.
  629.      */
  630.     private function isNextAllAnySome(): bool
  631.     {
  632.         return in_array(
  633.             $this->lexer->lookahead['type'],
  634.             [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME]
  635.         );
  636.     }
  638.     /**
  639.      * Validates that the given <tt>IdentificationVariable</tt> is semantically correct.
  640.      * It must exist in query components list.
  641.      */
  642.     private function processDeferredIdentificationVariables(): void
  643.     {
  644.         foreach ($this->deferredIdentificationVariables as $deferredItem) {
  645.             $identVariable = $deferredItem['expression'];
  647.             // Check if IdentificationVariable exists in queryComponents
  648.             if (! isset($this->queryComponents[$identVariable])) {
  649.                 $this->semanticalError(
  650.                     sprintf("'%s' is not defined.", $identVariable),
  651.                     $deferredItem['token']
  652.                 );
  653.             }
  655.             $qComp = $this->queryComponents[$identVariable];
  657.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  658.             if (! isset($qComp['metadata'])) {
  659.                 $this->semanticalError(
  660.                     sprintf("'%s' does not point to a Class.", $identVariable),
  661.                     $deferredItem['token']
  662.                 );
  663.             }
  665.             // Validate if identification variable nesting level is lower or equal than the current one
  666.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  667.                 $this->semanticalError(
  668.                     sprintf("'%s' is used outside the scope of its declaration.", $identVariable),
  669.                     $deferredItem['token']
  670.                 );
  671.             }
  672.         }
  673.     }
  675.     /**
  676.      * Validates that the given <tt>NewObjectExpression</tt>.
  677.      */
  678.     private function processDeferredNewObjectExpressions(SelectStatement $AST): void
  679.     {
  680.         foreach ($this->deferredNewObjectExpressions as $deferredItem) {
  681.             $expression    = $deferredItem['expression'];
  682.             $token         = $deferredItem['token'];
  683.             $className     = $expression->className;
  684.             $args          = $expression->args;
  685.             $fromClassName = $AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName ?? null;
  687.             // If the namespace is not given then assumes the first FROM entity namespace
  688.             if (strpos($className, '\\') === false && ! class_exists($className) && strpos($fromClassName, '\\') !== false) {
  689.                 $namespace = substr($fromClassName, 0, strrpos($fromClassName, '\\'));
  690.                 $fqcn      = $namespace . '\\' . $className;
  692.                 if (class_exists($fqcn)) {
  693.                     $expression->className = $fqcn;
  694.                     $className             = $fqcn;
  695.                 }
  696.             }
  698.             if (! class_exists($className)) {
  699.                 $this->semanticalError(sprintf('Class "%s" is not defined.', $className), $token);
  700.             }
  702.             $class = new ReflectionClass($className);
  704.             if (! $class->isInstantiable()) {
  705.                 $this->semanticalError(sprintf('Class "%s" can not be instantiated.', $className), $token);
  706.             }
  708.             if ($class->getConstructor() === null) {
  709.                 $this->semanticalError(sprintf('Class "%s" has not a valid constructor.', $className), $token);
  710.             }
  712.             if ($class->getConstructor()->getNumberOfRequiredParameters() > count($args)) {
  713.                 $this->semanticalError(sprintf('Number of arguments does not match with "%s" constructor declaration.', $className), $token);
  714.             }
  715.         }
  716.     }
  718.     /**
  719.      * Validates that the given <tt>PartialObjectExpression</tt> is semantically correct.
  720.      * It must exist in query components list.
  721.      */
  722.     private function processDeferredPartialObjectExpressions(): void
  723.     {
  724.         foreach ($this->deferredPartialObjectExpressions as $deferredItem) {
  725.             $expr  = $deferredItem['expression'];
  726.             $class = $this->queryComponents[$expr->identificationVariable]['metadata'];
  728.             foreach ($expr->partialFieldSet as $field) {
  729.                 if (isset($class->fieldMappings[$field])) {
  730.                     continue;
  731.                 }
  733.                 if (
  734.                     isset($class->associationMappings[$field]) &&
  735.                     $class->associationMappings[$field]['isOwningSide'] &&
  736.                     $class->associationMappings[$field]['type'] & ClassMetadata::TO_ONE
  737.                 ) {
  738.                     continue;
  739.                 }
  741.                 $this->semanticalError(sprintf(
  742.                     "There is no mapped field named '%s' on class %s.",
  743.                     $field,
  744.                     $class->name
  745.                 ), $deferredItem['token']);
  746.             }
  748.             if (array_intersect($class->identifier, $expr->partialFieldSet) !== $class->identifier) {
  749.                 $this->semanticalError(
  750.                     'The partial field selection of class ' . $class->name . ' must contain the identifier.',
  751.                     $deferredItem['token']
  752.                 );
  753.             }
  754.         }
  755.     }
  757.     /**
  758.      * Validates that the given <tt>ResultVariable</tt> is semantically correct.
  759.      * It must exist in query components list.
  760.      */
  761.     private function processDeferredResultVariables(): void
  762.     {
  763.         foreach ($this->deferredResultVariables as $deferredItem) {
  764.             $resultVariable = $deferredItem['expression'];
  766.             // Check if ResultVariable exists in queryComponents
  767.             if (! isset($this->queryComponents[$resultVariable])) {
  768.                 $this->semanticalError(
  769.                     sprintf("'%s' is not defined.", $resultVariable),
  770.                     $deferredItem['token']
  771.                 );
  772.             }
  774.             $qComp = $this->queryComponents[$resultVariable];
  776.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  777.             if (! isset($qComp['resultVariable'])) {
  778.                 $this->semanticalError(
  779.                     sprintf("'%s' does not point to a ResultVariable.", $resultVariable),
  780.                     $deferredItem['token']
  781.                 );
  782.             }
  784.             // Validate if identification variable nesting level is lower or equal than the current one
  785.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  786.                 $this->semanticalError(
  787.                     sprintf("'%s' is used outside the scope of its declaration.", $resultVariable),
  788.                     $deferredItem['token']
  789.                 );
  790.             }
  791.         }
  792.     }
  794.     /**
  795.      * Validates that the given <tt>PathExpression</tt> is semantically correct for grammar rules:
  796.      *
  797.      * AssociationPathExpression             ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  798.      * SingleValuedPathExpression            ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  799.      * StateFieldPathExpression              ::= IdentificationVariable "." StateField
  800.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  801.      * CollectionValuedPathExpression        ::= IdentificationVariable "." CollectionValuedAssociationField
  802.      */
  803.     private function processDeferredPathExpressions(): void
  804.     {
  805.         foreach ($this->deferredPathExpressions as $deferredItem) {
  806.             $pathExpression = $deferredItem['expression'];
  808.             $qComp = $this->queryComponents[$pathExpression->identificationVariable];
  809.             $class = $qComp['metadata'];
  811.             $field = $pathExpression->field;
  812.             if ($field === null) {
  813.                 $field = $pathExpression->field = $class->identifier[0];
  814.             }
  816.             // Check if field or association exists
  817.             if (! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
  818.                 $this->semanticalError(
  819.                     'Class ' . $class->name . ' has no field or association named ' . $field,
  820.                     $deferredItem['token']
  821.                 );
  822.             }
  824.             $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
  826.             if (isset($class->associationMappings[$field])) {
  827.                 $assoc = $class->associationMappings[$field];
  829.                 $fieldType = $assoc['type'] & ClassMetadata::TO_ONE
  830.                     ? AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  831.                     : AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
  832.             }
  834.             // Validate if PathExpression is one of the expected types
  835.             $expectedType = $pathExpression->expectedType;
  837.             if (! ($expectedType & $fieldType)) {
  838.                 // We need to recognize which was expected type(s)
  839.                 $expectedStringTypes = [];
  841.                 // Validate state field type
  842.                 if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
  843.                     $expectedStringTypes[] = 'StateFieldPathExpression';
  844.                 }
  846.                 // Validate single valued association (*-to-one)
  847.                 if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
  848.                     $expectedStringTypes[] = 'SingleValuedAssociationField';
  849.                 }
  851.                 // Validate single valued association (*-to-many)
  852.                 if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
  853.                     $expectedStringTypes[] = 'CollectionValuedAssociationField';
  854.                 }
  856.                 // Build the error message
  857.                 $semanticalError  = 'Invalid PathExpression. ';
  858.                 $semanticalError .= count($expectedStringTypes) === 1
  859.                     ? 'Must be a ' . $expectedStringTypes[0] . '.'
  860.                     : implode(' or ', $expectedStringTypes) . ' expected.';
  862.                 $this->semanticalError($semanticalError, $deferredItem['token']);
  863.             }
  865.             // We need to force the type in PathExpression
  866.             $pathExpression->type = $fieldType;
  867.         }
  868.     }
  870.     private function processRootEntityAliasSelected(): void
  871.     {
  872.         if (! count($this->identVariableExpressions)) {
  873.             return;
  874.         }
  876.         foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
  877.             if (isset($this->queryComponents[$dqlAlias]) && $this->queryComponents[$dqlAlias]['parent'] === null) {
  878.                 return;
  879.             }
  880.         }
  882.         $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');
  883.     }
  885.     /**
  886.      * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
  887.      *
  888.      * @return SelectStatement|UpdateStatement|DeleteStatement
  889.      */
  890.     public function QueryLanguage()
  891.     {
  892.         $statement = null;
  894.         $this->lexer->moveNext();
  896.         switch ($this->lexer->lookahead['type'] ?? null) {
  897.             case Lexer::T_SELECT:
  898.                 $statement = $this->SelectStatement();
  899.                 break;
  901.             case Lexer::T_UPDATE:
  902.                 $statement = $this->UpdateStatement();
  903.                 break;
  905.             case Lexer::T_DELETE:
  906.                 $statement = $this->DeleteStatement();
  907.                 break;
  909.             default:
  910.                 $this->syntaxError('SELECT, UPDATE or DELETE');
  911.                 break;
  912.         }
  914.         // Check for end of string
  915.         if ($this->lexer->lookahead !== null) {
  916.             $this->syntaxError('end of string');
  917.         }
  919.         return $statement;
  920.     }
  922.     /**
  923.      * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  924.      *
  925.      * @return SelectStatement
  926.      */
  927.     public function SelectStatement()
  928.     {
  929.         $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());
  931.         $selectStatement->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  932.         $selectStatement->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  933.         $selectStatement->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  934.         $selectStatement->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  936.         return $selectStatement;
  937.     }
  939.     /**
  940.      * UpdateStatement ::= UpdateClause [WhereClause]
  941.      *
  942.      * @return UpdateStatement
  943.      */
  944.     public function UpdateStatement()
  945.     {
  946.         $updateStatement = new AST\UpdateStatement($this->UpdateClause());
  948.         $updateStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  950.         return $updateStatement;
  951.     }
  953.     /**
  954.      * DeleteStatement ::= DeleteClause [WhereClause]
  955.      *
  956.      * @return DeleteStatement
  957.      */
  958.     public function DeleteStatement()
  959.     {
  960.         $deleteStatement = new AST\DeleteStatement($this->DeleteClause());
  962.         $deleteStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  964.         return $deleteStatement;
  965.     }
  967.     /**
  968.      * IdentificationVariable ::= identifier
  969.      *
  970.      * @return string
  971.      */
  972.     public function IdentificationVariable()
  973.     {
  974.         $this->match(Lexer::T_IDENTIFIER);
  976.         $identVariable = $this->lexer->token['value'];
  978.         $this->deferredIdentificationVariables[] = [
  979.             'expression'   => $identVariable,
  980.             'nestingLevel' => $this->nestingLevel,
  981.             'token'        => $this->lexer->token,
  982.         ];
  984.         return $identVariable;
  985.     }
  987.     /**
  988.      * AliasIdentificationVariable = identifier
  989.      *
  990.      * @return string
  991.      */
  992.     public function AliasIdentificationVariable()
  993.     {
  994.         $this->match(Lexer::T_IDENTIFIER);
  996.         $aliasIdentVariable = $this->lexer->token['value'];
  997.         $exists             = isset($this->queryComponents[$aliasIdentVariable]);
  999.         if ($exists) {
  1000.             $this->semanticalError(
  1001.                 sprintf("'%s' is already defined.", $aliasIdentVariable),
  1002.                 $this->lexer->token
  1003.             );
  1004.         }
  1006.         return $aliasIdentVariable;
  1007.     }
  1009.     /**
  1010.      * AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
  1011.      *
  1012.      * @return string
  1013.      */
  1014.     public function AbstractSchemaName()
  1015.     {
  1016.         if ($this->lexer->isNextToken(Lexer::T_FULLY_QUALIFIED_NAME)) {
  1017.             $this->match(Lexer::T_FULLY_QUALIFIED_NAME);
  1019.             return $this->lexer->token['value'];
  1020.         }
  1022.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  1023.             $this->match(Lexer::T_IDENTIFIER);
  1025.             return $this->lexer->token['value'];
  1026.         }
  1028.         $this->match(Lexer::T_ALIASED_NAME);
  1030.         [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token['value']);
  1032.         return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  1033.     }
  1035.     /**
  1036.      * Validates an AbstractSchemaName, making sure the class exists.
  1037.      *
  1038.      * @param string $schemaName The name to validate.
  1039.      *
  1040.      * @throws QueryException if the name does not exist.
  1041.      */
  1042.     private function validateAbstractSchemaName(string $schemaName): void
  1043.     {
  1044.         if (! (class_exists($schemaName, true) || interface_exists($schemaName, true))) {
  1045.             $this->semanticalError(
  1046.                 sprintf("Class '%s' is not defined.", $schemaName),
  1047.                 $this->lexer->token
  1048.             );
  1049.         }
  1050.     }
  1052.     /**
  1053.      * AliasResultVariable ::= identifier
  1054.      *
  1055.      * @return string
  1056.      */
  1057.     public function AliasResultVariable()
  1058.     {
  1059.         $this->match(Lexer::T_IDENTIFIER);
  1061.         $resultVariable = $this->lexer->token['value'];
  1062.         $exists         = isset($this->queryComponents[$resultVariable]);
  1064.         if ($exists) {
  1065.             $this->semanticalError(
  1066.                 sprintf("'%s' is already defined.", $resultVariable),
  1067.                 $this->lexer->token
  1068.             );
  1069.         }
  1071.         return $resultVariable;
  1072.     }
  1074.     /**
  1075.      * ResultVariable ::= identifier
  1076.      *
  1077.      * @return string
  1078.      */
  1079.     public function ResultVariable()
  1080.     {
  1081.         $this->match(Lexer::T_IDENTIFIER);
  1083.         $resultVariable = $this->lexer->token['value'];
  1085.         // Defer ResultVariable validation
  1086.         $this->deferredResultVariables[] = [
  1087.             'expression'   => $resultVariable,
  1088.             'nestingLevel' => $this->nestingLevel,
  1089.             'token'        => $this->lexer->token,
  1090.         ];
  1092.         return $resultVariable;
  1093.     }
  1095.     /**
  1096.      * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
  1097.      *
  1098.      * @return JoinAssociationPathExpression
  1099.      */
  1100.     public function JoinAssociationPathExpression()
  1101.     {
  1102.         $identVariable = $this->IdentificationVariable();
  1104.         if (! isset($this->queryComponents[$identVariable])) {
  1105.             $this->semanticalError(
  1106.                 'Identification Variable ' . $identVariable . ' used in join path expression but was not defined before.'
  1107.             );
  1108.         }
  1110.         $this->match(Lexer::T_DOT);
  1111.         $this->match(Lexer::T_IDENTIFIER);
  1113.         $field = $this->lexer->token['value'];
  1115.         // Validate association field
  1116.         $qComp = $this->queryComponents[$identVariable];
  1117.         $class = $qComp['metadata'];
  1119.         if (! $class->hasAssociation($field)) {
  1120.             $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
  1121.         }
  1123.         return new AST\JoinAssociationPathExpression($identVariable, $field);
  1124.     }
  1126.     /**
  1127.      * Parses an arbitrary path expression and defers semantical validation
  1128.      * based on expected types.
  1129.      *
  1130.      * PathExpression ::= IdentificationVariable {"." identifier}*
  1131.      *
  1132.      * @param int $expectedTypes
  1133.      *
  1134.      * @return PathExpression
  1135.      */
  1136.     public function PathExpression($expectedTypes)
  1137.     {
  1138.         $identVariable = $this->IdentificationVariable();
  1139.         $field         = null;
  1141.         if ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1142.             $this->match(Lexer::T_DOT);
  1143.             $this->match(Lexer::T_IDENTIFIER);
  1145.             $field = $this->lexer->token['value'];
  1147.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1148.                 $this->match(Lexer::T_DOT);
  1149.                 $this->match(Lexer::T_IDENTIFIER);
  1150.                 $field .= '.' . $this->lexer->token['value'];
  1151.             }
  1152.         }
  1154.         // Creating AST node
  1155.         $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);
  1157.         // Defer PathExpression validation if requested to be deferred
  1158.         $this->deferredPathExpressions[] = [
  1159.             'expression'   => $pathExpr,
  1160.             'nestingLevel' => $this->nestingLevel,
  1161.             'token'        => $this->lexer->token,
  1162.         ];
  1164.         return $pathExpr;
  1165.     }
  1167.     /**
  1168.      * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  1169.      *
  1170.      * @return PathExpression
  1171.      */
  1172.     public function AssociationPathExpression()
  1173.     {
  1174.         return $this->PathExpression(
  1175.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |
  1176.             AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION
  1177.         );
  1178.     }
  1180.     /**
  1181.      * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  1182.      *
  1183.      * @return PathExpression
  1184.      */
  1185.     public function SingleValuedPathExpression()
  1186.     {
  1187.         return $this->PathExpression(
  1188.             AST\PathExpression::TYPE_STATE_FIELD |
  1189.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  1190.         );
  1191.     }
  1193.     /**
  1194.      * StateFieldPathExpression ::= IdentificationVariable "." StateField
  1195.      *
  1196.      * @return PathExpression
  1197.      */
  1198.     public function StateFieldPathExpression()
  1199.     {
  1200.         return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);
  1201.     }
  1203.     /**
  1204.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  1205.      *
  1206.      * @return PathExpression
  1207.      */
  1208.     public function SingleValuedAssociationPathExpression()
  1209.     {
  1210.         return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);
  1211.     }
  1213.     /**
  1214.      * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  1215.      *
  1216.      * @return PathExpression
  1217.      */
  1218.     public function CollectionValuedPathExpression()
  1219.     {
  1220.         return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);
  1221.     }
  1223.     /**
  1224.      * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
  1225.      *
  1226.      * @return SelectClause
  1227.      */
  1228.     public function SelectClause()
  1229.     {
  1230.         $isDistinct = false;
  1231.         $this->match(Lexer::T_SELECT);
  1233.         // Check for DISTINCT
  1234.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1235.             $this->match(Lexer::T_DISTINCT);
  1237.             $isDistinct = true;
  1238.         }
  1240.         // Process SelectExpressions (1..N)
  1241.         $selectExpressions   = [];
  1242.         $selectExpressions[] = $this->SelectExpression();
  1244.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1245.             $this->match(Lexer::T_COMMA);
  1247.             $selectExpressions[] = $this->SelectExpression();
  1248.         }
  1250.         return new AST\SelectClause($selectExpressions, $isDistinct);
  1251.     }
  1253.     /**
  1254.      * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
  1255.      *
  1256.      * @return SimpleSelectClause
  1257.      */
  1258.     public function SimpleSelectClause()
  1259.     {
  1260.         $isDistinct = false;
  1261.         $this->match(Lexer::T_SELECT);
  1263.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1264.             $this->match(Lexer::T_DISTINCT);
  1266.             $isDistinct = true;
  1267.         }
  1269.         return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);
  1270.     }
  1272.     /**
  1273.      * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*
  1274.      *
  1275.      * @return UpdateClause
  1276.      */
  1277.     public function UpdateClause()
  1278.     {
  1279.         $this->match(Lexer::T_UPDATE);
  1281.         $token              = $this->lexer->lookahead;
  1282.         $abstractSchemaName = $this->AbstractSchemaName();
  1284.         $this->validateAbstractSchemaName($abstractSchemaName);
  1286.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1287.             $this->match(Lexer::T_AS);
  1288.         }
  1290.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1292.         $class = $this->em->getClassMetadata($abstractSchemaName);
  1294.         // Building queryComponent
  1295.         $queryComponent = [
  1296.             'metadata'     => $class,
  1297.             'parent'       => null,
  1298.             'relation'     => null,
  1299.             'map'          => null,
  1300.             'nestingLevel' => $this->nestingLevel,
  1301.             'token'        => $token,
  1302.         ];
  1304.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1306.         $this->match(Lexer::T_SET);
  1308.         $updateItems   = [];
  1309.         $updateItems[] = $this->UpdateItem();
  1311.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1312.             $this->match(Lexer::T_COMMA);
  1314.             $updateItems[] = $this->UpdateItem();
  1315.         }
  1317.         $updateClause                              = new AST\UpdateClause($abstractSchemaName, $updateItems);
  1318.         $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1320.         return $updateClause;
  1321.     }
  1323.     /**
  1324.      * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable
  1325.      *
  1326.      * @return DeleteClause
  1327.      */
  1328.     public function DeleteClause()
  1329.     {
  1330.         $this->match(Lexer::T_DELETE);
  1332.         if ($this->lexer->isNextToken(Lexer::T_FROM)) {
  1333.             $this->match(Lexer::T_FROM);
  1334.         }
  1336.         $token              = $this->lexer->lookahead;
  1337.         $abstractSchemaName = $this->AbstractSchemaName();
  1339.         $this->validateAbstractSchemaName($abstractSchemaName);
  1341.         $deleteClause = new AST\DeleteClause($abstractSchemaName);
  1343.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1344.             $this->match(Lexer::T_AS);
  1345.         }
  1347.         $aliasIdentificationVariable = $this->lexer->isNextToken(Lexer::T_IDENTIFIER)
  1348.             ? $this->AliasIdentificationVariable()
  1349.             : 'alias_should_have_been_set';
  1351.         $deleteClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1352.         $class                                     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1354.         // Building queryComponent
  1355.         $queryComponent = [
  1356.             'metadata'     => $class,
  1357.             'parent'       => null,
  1358.             'relation'     => null,
  1359.             'map'          => null,
  1360.             'nestingLevel' => $this->nestingLevel,
  1361.             'token'        => $token,
  1362.         ];
  1364.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1366.         return $deleteClause;
  1367.     }
  1369.     /**
  1370.      * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}*
  1371.      *
  1372.      * @return FromClause
  1373.      */
  1374.     public function FromClause()
  1375.     {
  1376.         $this->match(Lexer::T_FROM);
  1378.         $identificationVariableDeclarations   = [];
  1379.         $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1381.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1382.             $this->match(Lexer::T_COMMA);
  1384.             $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1385.         }
  1387.         return new AST\FromClause($identificationVariableDeclarations);
  1388.     }
  1390.     /**
  1391.      * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
  1392.      *
  1393.      * @return SubselectFromClause
  1394.      */
  1395.     public function SubselectFromClause()
  1396.     {
  1397.         $this->match(Lexer::T_FROM);
  1399.         $identificationVariables   = [];
  1400.         $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1402.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1403.             $this->match(Lexer::T_COMMA);
  1405.             $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1406.         }
  1408.         return new AST\SubselectFromClause($identificationVariables);
  1409.     }
  1411.     /**
  1412.      * WhereClause ::= "WHERE" ConditionalExpression
  1413.      *
  1414.      * @return WhereClause
  1415.      */
  1416.     public function WhereClause()
  1417.     {
  1418.         $this->match(Lexer::T_WHERE);
  1420.         return new AST\WhereClause($this->ConditionalExpression());
  1421.     }
  1423.     /**
  1424.      * HavingClause ::= "HAVING" ConditionalExpression
  1425.      *
  1426.      * @return HavingClause
  1427.      */
  1428.     public function HavingClause()
  1429.     {
  1430.         $this->match(Lexer::T_HAVING);
  1432.         return new AST\HavingClause($this->ConditionalExpression());
  1433.     }
  1435.     /**
  1436.      * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
  1437.      *
  1438.      * @return GroupByClause
  1439.      */
  1440.     public function GroupByClause()
  1441.     {
  1442.         $this->match(Lexer::T_GROUP);
  1443.         $this->match(Lexer::T_BY);
  1445.         $groupByItems = [$this->GroupByItem()];
  1447.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1448.             $this->match(Lexer::T_COMMA);
  1450.             $groupByItems[] = $this->GroupByItem();
  1451.         }
  1453.         return new AST\GroupByClause($groupByItems);
  1454.     }
  1456.     /**
  1457.      * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
  1458.      *
  1459.      * @return OrderByClause
  1460.      */
  1461.     public function OrderByClause()
  1462.     {
  1463.         $this->match(Lexer::T_ORDER);
  1464.         $this->match(Lexer::T_BY);
  1466.         $orderByItems   = [];
  1467.         $orderByItems[] = $this->OrderByItem();
  1469.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1470.             $this->match(Lexer::T_COMMA);
  1472.             $orderByItems[] = $this->OrderByItem();
  1473.         }
  1475.         return new AST\OrderByClause($orderByItems);
  1476.     }
  1478.     /**
  1479.      * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  1480.      *
  1481.      * @return Subselect
  1482.      */
  1483.     public function Subselect()
  1484.     {
  1485.         // Increase query nesting level
  1486.         $this->nestingLevel++;
  1488.         $subselect = new AST\Subselect($this->SimpleSelectClause(), $this->SubselectFromClause());
  1490.         $subselect->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  1491.         $subselect->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  1492.         $subselect->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  1493.         $subselect->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  1495.         // Decrease query nesting level
  1496.         $this->nestingLevel--;
  1498.         return $subselect;
  1499.     }
  1501.     /**
  1502.      * UpdateItem ::= SingleValuedPathExpression "=" NewValue
  1503.      *
  1504.      * @return UpdateItem
  1505.      */
  1506.     public function UpdateItem()
  1507.     {
  1508.         $pathExpr = $this->SingleValuedPathExpression();
  1510.         $this->match(Lexer::T_EQUALS);
  1512.         return new AST\UpdateItem($pathExpr, $this->NewValue());
  1513.     }
  1515.     /**
  1516.      * GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression
  1517.      *
  1518.      * @return string|PathExpression
  1519.      */
  1520.     public function GroupByItem()
  1521.     {
  1522.         // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  1523.         $glimpse = $this->lexer->glimpse();
  1525.         if ($glimpse !== null && $glimpse['type'] === Lexer::T_DOT) {
  1526.             return $this->SingleValuedPathExpression();
  1527.         }
  1529.         // Still need to decide between IdentificationVariable or ResultVariable
  1530.         $lookaheadValue = $this->lexer->lookahead['value'];
  1532.         if (! isset($this->queryComponents[$lookaheadValue])) {
  1533.             $this->semanticalError('Cannot group by undefined identification or result variable.');
  1534.         }
  1536.         return isset($this->queryComponents[$lookaheadValue]['metadata'])
  1537.             ? $this->IdentificationVariable()
  1538.             : $this->ResultVariable();
  1539.     }
  1541.     /**
  1542.      * OrderByItem ::= (
  1543.      *      SimpleArithmeticExpression | SingleValuedPathExpression | CaseExpression |
  1544.      *      ScalarExpression | ResultVariable | FunctionDeclaration
  1545.      * ) ["ASC" | "DESC"]
  1546.      *
  1547.      * @return OrderByItem
  1548.      */
  1549.     public function OrderByItem()
  1550.     {
  1551.         $this->lexer->peek(); // lookahead => '.'
  1552.         $this->lexer->peek(); // lookahead => token after '.'
  1554.         $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1556.         $this->lexer->resetPeek();
  1558.         $glimpse = $this->lexer->glimpse();
  1560.         switch (true) {
  1561.             case $this->isMathOperator($peek):
  1562.                 $expr = $this->SimpleArithmeticExpression();
  1563.                 break;
  1565.             case $glimpse !== null && $glimpse['type'] === Lexer::T_DOT:
  1566.                 $expr = $this->SingleValuedPathExpression();
  1567.                 break;
  1569.             case $this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  1570.                 $expr = $this->ScalarExpression();
  1571.                 break;
  1573.             case $this->lexer->lookahead['type'] === Lexer::T_CASE:
  1574.                 $expr = $this->CaseExpression();
  1575.                 break;
  1577.             case $this->isFunction():
  1578.                 $expr = $this->FunctionDeclaration();
  1579.                 break;
  1581.             default:
  1582.                 $expr = $this->ResultVariable();
  1583.                 break;
  1584.         }
  1586.         $type = 'ASC';
  1587.         $item = new AST\OrderByItem($expr);
  1589.         switch (true) {
  1590.             case $this->lexer->isNextToken(Lexer::T_DESC):
  1591.                 $this->match(Lexer::T_DESC);
  1592.                 $type = 'DESC';
  1593.                 break;
  1595.             case $this->lexer->isNextToken(Lexer::T_ASC):
  1596.                 $this->match(Lexer::T_ASC);
  1597.                 break;
  1599.             default:
  1600.                 // Do nothing
  1601.         }
  1603.         $item->type = $type;
  1605.         return $item;
  1606.     }
  1608.     /**
  1609.      * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
  1610.      *      EnumPrimary | SimpleEntityExpression | "NULL"
  1611.      *
  1612.      * NOTE: Since it is not possible to correctly recognize individual types, here is the full
  1613.      * grammar that needs to be supported:
  1614.      *
  1615.      * NewValue ::= SimpleArithmeticExpression | "NULL"
  1616.      *
  1617.      * SimpleArithmeticExpression covers all *Primary grammar rules and also SimpleEntityExpression
  1618.      *
  1619.      * @return AST\ArithmeticExpression|AST\InputParameter|null
  1620.      */
  1621.     public function NewValue()
  1622.     {
  1623.         if ($this->lexer->isNextToken(Lexer::T_NULL)) {
  1624.             $this->match(Lexer::T_NULL);
  1626.             return null;
  1627.         }
  1629.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  1630.             $this->match(Lexer::T_INPUT_PARAMETER);
  1632.             return new AST\InputParameter($this->lexer->token['value']);
  1633.         }
  1635.         return $this->ArithmeticExpression();
  1636.     }
  1638.     /**
  1639.      * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*
  1640.      *
  1641.      * @return IdentificationVariableDeclaration
  1642.      */
  1643.     public function IdentificationVariableDeclaration()
  1644.     {
  1645.         $joins                    = [];
  1646.         $rangeVariableDeclaration = $this->RangeVariableDeclaration();
  1647.         $indexBy                  = $this->lexer->isNextToken(Lexer::T_INDEX)
  1648.             ? $this->IndexBy()
  1649.             : null;
  1651.         $rangeVariableDeclaration->isRoot = true;
  1653.         while (
  1654.             $this->lexer->isNextToken(Lexer::T_LEFT) ||
  1655.             $this->lexer->isNextToken(Lexer::T_INNER) ||
  1656.             $this->lexer->isNextToken(Lexer::T_JOIN)
  1657.         ) {
  1658.             $joins[] = $this->Join();
  1659.         }
  1661.         return new AST\IdentificationVariableDeclaration(
  1662.             $rangeVariableDeclaration,
  1663.             $indexBy,
  1664.             $joins
  1665.         );
  1666.     }
  1668.     /**
  1669.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration
  1670.      *
  1671.      * {Internal note: WARNING: Solution is harder than a bare implementation.
  1672.      * Desired EBNF support:
  1673.      *
  1674.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
  1675.      *
  1676.      * It demands that entire SQL generation to become programmatical. This is
  1677.      * needed because association based subselect requires "WHERE" conditional
  1678.      * expressions to be injected, but there is no scope to do that. Only scope
  1679.      * accessible is "FROM", prohibiting an easy implementation without larger
  1680.      * changes.}
  1681.      *
  1682.      * @return IdentificationVariableDeclaration
  1683.      */
  1684.     public function SubselectIdentificationVariableDeclaration()
  1685.     {
  1686.         /*
  1687.         NOT YET IMPLEMENTED!
  1689.         $glimpse = $this->lexer->glimpse();
  1691.         if ($glimpse['type'] == Lexer::T_DOT) {
  1692.             $associationPathExpression = $this->AssociationPathExpression();
  1694.             if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1695.                 $this->match(Lexer::T_AS);
  1696.             }
  1698.             $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1699.             $identificationVariable      = $associationPathExpression->identificationVariable;
  1700.             $field                       = $associationPathExpression->associationField;
  1702.             $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1703.             $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1705.             // Building queryComponent
  1706.             $joinQueryComponent = array(
  1707.                 'metadata'     => $targetClass,
  1708.                 'parent'       => $identificationVariable,
  1709.                 'relation'     => $class->getAssociationMapping($field),
  1710.                 'map'          => null,
  1711.                 'nestingLevel' => $this->nestingLevel,
  1712.                 'token'        => $this->lexer->lookahead
  1713.             );
  1715.             $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1717.             return new AST\SubselectIdentificationVariableDeclaration(
  1718.                 $associationPathExpression, $aliasIdentificationVariable
  1719.             );
  1720.         }
  1721.         */
  1723.         return $this->IdentificationVariableDeclaration();
  1724.     }
  1726.     /**
  1727.      * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN"
  1728.      *          (JoinAssociationDeclaration | RangeVariableDeclaration)
  1729.      *          ["WITH" ConditionalExpression]
  1730.      *
  1731.      * @return Join
  1732.      */
  1733.     public function Join()
  1734.     {
  1735.         // Check Join type
  1736.         $joinType = AST\Join::JOIN_TYPE_INNER;
  1738.         switch (true) {
  1739.             case $this->lexer->isNextToken(Lexer::T_LEFT):
  1740.                 $this->match(Lexer::T_LEFT);
  1742.                 $joinType = AST\Join::JOIN_TYPE_LEFT;
  1744.                 // Possible LEFT OUTER join
  1745.                 if ($this->lexer->isNextToken(Lexer::T_OUTER)) {
  1746.                     $this->match(Lexer::T_OUTER);
  1748.                     $joinType = AST\Join::JOIN_TYPE_LEFTOUTER;
  1749.                 }
  1751.                 break;
  1753.             case $this->lexer->isNextToken(Lexer::T_INNER):
  1754.                 $this->match(Lexer::T_INNER);
  1755.                 break;
  1757.             default:
  1758.                 // Do nothing
  1759.         }
  1761.         $this->match(Lexer::T_JOIN);
  1763.         $next            = $this->lexer->glimpse();
  1764.         $joinDeclaration = $next['type'] === Lexer::T_DOT ? $this->JoinAssociationDeclaration() : $this->RangeVariableDeclaration();
  1765.         $adhocConditions = $this->lexer->isNextToken(Lexer::T_WITH);
  1766.         $join            = new AST\Join($joinType, $joinDeclaration);
  1768.         // Describe non-root join declaration
  1769.         if ($joinDeclaration instanceof AST\RangeVariableDeclaration) {
  1770.             $joinDeclaration->isRoot = false;
  1771.         }
  1773.         // Check for ad-hoc Join conditions
  1774.         if ($adhocConditions) {
  1775.             $this->match(Lexer::T_WITH);
  1777.             $join->conditionalExpression = $this->ConditionalExpression();
  1778.         }
  1780.         return $join;
  1781.     }
  1783.     /**
  1784.      * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
  1785.      *
  1786.      * @return RangeVariableDeclaration
  1787.      *
  1788.      * @throws QueryException
  1789.      */
  1790.     public function RangeVariableDeclaration()
  1791.     {
  1792.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $this->lexer->glimpse()['type'] === Lexer::T_SELECT) {
  1793.             $this->semanticalError('Subquery is not supported here', $this->lexer->token);
  1794.         }
  1796.         $abstractSchemaName = $this->AbstractSchemaName();
  1798.         $this->validateAbstractSchemaName($abstractSchemaName);
  1800.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1801.             $this->match(Lexer::T_AS);
  1802.         }
  1804.         $token                       = $this->lexer->lookahead;
  1805.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1806.         $classMetadata               = $this->em->getClassMetadata($abstractSchemaName);
  1808.         // Building queryComponent
  1809.         $queryComponent = [
  1810.             'metadata'     => $classMetadata,
  1811.             'parent'       => null,
  1812.             'relation'     => null,
  1813.             'map'          => null,
  1814.             'nestingLevel' => $this->nestingLevel,
  1815.             'token'        => $token,
  1816.         ];
  1818.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1820.         return new AST\RangeVariableDeclaration($abstractSchemaName, $aliasIdentificationVariable);
  1821.     }
  1823.     /**
  1824.      * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [IndexBy]
  1825.      *
  1826.      * @return AST\JoinAssociationDeclaration
  1827.      */
  1828.     public function JoinAssociationDeclaration()
  1829.     {
  1830.         $joinAssociationPathExpression = $this->JoinAssociationPathExpression();
  1832.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1833.             $this->match(Lexer::T_AS);
  1834.         }
  1836.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1837.         $indexBy                     = $this->lexer->isNextToken(Lexer::T_INDEX) ? $this->IndexBy() : null;
  1839.         $identificationVariable = $joinAssociationPathExpression->identificationVariable;
  1840.         $field                  = $joinAssociationPathExpression->associationField;
  1842.         $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1843.         $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1845.         // Building queryComponent
  1846.         $joinQueryComponent = [
  1847.             'metadata'     => $targetClass,
  1848.             'parent'       => $joinAssociationPathExpression->identificationVariable,
  1849.             'relation'     => $class->getAssociationMapping($field),
  1850.             'map'          => null,
  1851.             'nestingLevel' => $this->nestingLevel,
  1852.             'token'        => $this->lexer->lookahead,
  1853.         ];
  1855.         $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1857.         return new AST\JoinAssociationDeclaration($joinAssociationPathExpression, $aliasIdentificationVariable, $indexBy);
  1858.     }
  1860.     /**
  1861.      * PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
  1862.      * PartialFieldSet ::= "{" SimpleStateField {"," SimpleStateField}* "}"
  1863.      *
  1864.      * @return PartialObjectExpression
  1865.      */
  1866.     public function PartialObjectExpression()
  1867.     {
  1868.         Deprecation::trigger(
  1869.             'doctrine/orm',
  1870.             'https://github.com/doctrine/orm/issues/8471',
  1871.             'PARTIAL syntax in DQL is deprecated.'
  1872.         );
  1874.         $this->match(Lexer::T_PARTIAL);
  1876.         $partialFieldSet = [];
  1878.         $identificationVariable = $this->IdentificationVariable();
  1880.         $this->match(Lexer::T_DOT);
  1881.         $this->match(Lexer::T_OPEN_CURLY_BRACE);
  1882.         $this->match(Lexer::T_IDENTIFIER);
  1884.         $field = $this->lexer->token['value'];
  1886.         // First field in partial expression might be embeddable property
  1887.         while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1888.             $this->match(Lexer::T_DOT);
  1889.             $this->match(Lexer::T_IDENTIFIER);
  1890.             $field .= '.' . $this->lexer->token['value'];
  1891.         }
  1893.         $partialFieldSet[] = $field;
  1895.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1896.             $this->match(Lexer::T_COMMA);
  1897.             $this->match(Lexer::T_IDENTIFIER);
  1899.             $field = $this->lexer->token['value'];
  1901.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1902.                 $this->match(Lexer::T_DOT);
  1903.                 $this->match(Lexer::T_IDENTIFIER);
  1904.                 $field .= '.' . $this->lexer->token['value'];
  1905.             }
  1907.             $partialFieldSet[] = $field;
  1908.         }
  1910.         $this->match(Lexer::T_CLOSE_CURLY_BRACE);
  1912.         $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
  1914.         // Defer PartialObjectExpression validation
  1915.         $this->deferredPartialObjectExpressions[] = [
  1916.             'expression'   => $partialObjectExpression,
  1917.             'nestingLevel' => $this->nestingLevel,
  1918.             'token'        => $this->lexer->token,
  1919.         ];
  1921.         return $partialObjectExpression;
  1922.     }
  1924.     /**
  1925.      * NewObjectExpression ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
  1926.      *
  1927.      * @return NewObjectExpression
  1928.      */
  1929.     public function NewObjectExpression()
  1930.     {
  1931.         $this->match(Lexer::T_NEW);
  1933.         $className = $this->AbstractSchemaName(); // note that this is not yet validated
  1934.         $token     = $this->lexer->token;
  1936.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  1938.         $args[] = $this->NewObjectArg();
  1940.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1941.             $this->match(Lexer::T_COMMA);
  1943.             $args[] = $this->NewObjectArg();
  1944.         }
  1946.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1948.         $expression = new AST\NewObjectExpression($className, $args);
  1950.         // Defer NewObjectExpression validation
  1951.         $this->deferredNewObjectExpressions[] = [
  1952.             'token'        => $token,
  1953.             'expression'   => $expression,
  1954.             'nestingLevel' => $this->nestingLevel,
  1955.         ];
  1957.         return $expression;
  1958.     }
  1960.     /**
  1961.      * NewObjectArg ::= ScalarExpression | "(" Subselect ")"
  1962.      *
  1963.      * @return mixed
  1964.      */
  1965.     public function NewObjectArg()
  1966.     {
  1967.         $token = $this->lexer->lookahead;
  1968.         $peek  = $this->lexer->glimpse();
  1970.         if ($token['type'] === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT) {
  1971.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  1972.             $expression = $this->Subselect();
  1973.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1975.             return $expression;
  1976.         }
  1978.         return $this->ScalarExpression();
  1979.     }
  1981.     /**
  1982.      * IndexBy ::= "INDEX" "BY" SingleValuedPathExpression
  1983.      *
  1984.      * @return IndexBy
  1985.      */
  1986.     public function IndexBy()
  1987.     {
  1988.         $this->match(Lexer::T_INDEX);
  1989.         $this->match(Lexer::T_BY);
  1990.         $pathExpr = $this->SingleValuedPathExpression();
  1992.         // Add the INDEX BY info to the query component
  1993.         $this->queryComponents[$pathExpr->identificationVariable]['map'] = $pathExpr->field;
  1995.         return new AST\IndexBy($pathExpr);
  1996.     }
  1998.     /**
  1999.      * ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DateTimePrimary |
  2000.      *                      StateFieldPathExpression | BooleanPrimary | CaseExpression |
  2001.      *                      InstanceOfExpression
  2002.      *
  2003.      * @return mixed One of the possible expressions or subexpressions.
  2004.      */
  2005.     public function ScalarExpression()
  2006.     {
  2007.         $lookahead = $this->lexer->lookahead['type'];
  2008.         $peek      = $this->lexer->glimpse();
  2010.         switch (true) {
  2011.             case $lookahead === Lexer::T_INTEGER:
  2012.             case $lookahead === Lexer::T_FLOAT:
  2013.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )  or ( - 1 ) or ( + 1 )
  2014.             case $lookahead === Lexer::T_MINUS:
  2015.             case $lookahead === Lexer::T_PLUS:
  2016.                 return $this->SimpleArithmeticExpression();
  2018.             case $lookahead === Lexer::T_STRING:
  2019.                 return $this->StringPrimary();
  2021.             case $lookahead === Lexer::T_TRUE:
  2022.             case $lookahead === Lexer::T_FALSE:
  2023.                 $this->match($lookahead);
  2025.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2027.             case $lookahead === Lexer::T_INPUT_PARAMETER:
  2028.                 switch (true) {
  2029.                     case $this->isMathOperator($peek):
  2030.                         // :param + u.value
  2031.                         return $this->SimpleArithmeticExpression();
  2033.                     default:
  2034.                         return $this->InputParameter();
  2035.                 }
  2036.             case $lookahead === Lexer::T_CASE:
  2037.             case $lookahead === Lexer::T_COALESCE:
  2038.             case $lookahead === Lexer::T_NULLIF:
  2039.                 // Since NULLIF and COALESCE can be identified as a function,
  2040.                 // we need to check these before checking for FunctionDeclaration
  2041.                 return $this->CaseExpression();
  2043.             case $lookahead === Lexer::T_OPEN_PARENTHESIS:
  2044.                 return $this->SimpleArithmeticExpression();
  2046.             // this check must be done before checking for a filed path expression
  2047.             case $this->isFunction():
  2048.                 $this->lexer->peek(); // "("
  2050.                 switch (true) {
  2051.                     case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2052.                         // SUM(u.id) + COUNT(u.id)
  2053.                         return $this->SimpleArithmeticExpression();
  2055.                     default:
  2056.                         // IDENTITY(u)
  2057.                         return $this->FunctionDeclaration();
  2058.                 }
  2060.                 break;
  2061.             // it is no function, so it must be a field path
  2062.             case $lookahead === Lexer::T_IDENTIFIER:
  2063.                 $this->lexer->peek(); // lookahead => '.'
  2064.                 $this->lexer->peek(); // lookahead => token after '.'
  2065.                 $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  2066.                 $this->lexer->resetPeek();
  2068.                 if ($this->isMathOperator($peek)) {
  2069.                     return $this->SimpleArithmeticExpression();
  2070.                 }
  2072.                 return $this->StateFieldPathExpression();
  2074.             default:
  2075.                 $this->syntaxError();
  2076.         }
  2077.     }
  2079.     /**
  2080.      * CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullifExpression
  2081.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2082.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2083.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2084.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2085.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2086.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2087.      * NullifExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2088.      *
  2089.      * @return mixed One of the possible expressions or subexpressions.
  2090.      */
  2091.     public function CaseExpression()
  2092.     {
  2093.         $lookahead = $this->lexer->lookahead['type'];
  2095.         switch ($lookahead) {
  2096.             case Lexer::T_NULLIF:
  2097.                 return $this->NullIfExpression();
  2099.             case Lexer::T_COALESCE:
  2100.                 return $this->CoalesceExpression();
  2102.             case Lexer::T_CASE:
  2103.                 $this->lexer->resetPeek();
  2104.                 $peek = $this->lexer->peek();
  2106.                 if ($peek['type'] === Lexer::T_WHEN) {
  2107.                     return $this->GeneralCaseExpression();
  2108.                 }
  2110.                 return $this->SimpleCaseExpression();
  2112.             default:
  2113.                 // Do nothing
  2114.                 break;
  2115.         }
  2117.         $this->syntaxError();
  2118.     }
  2120.     /**
  2121.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2122.      *
  2123.      * @return CoalesceExpression
  2124.      */
  2125.     public function CoalesceExpression()
  2126.     {
  2127.         $this->match(Lexer::T_COALESCE);
  2128.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2130.         // Process ScalarExpressions (1..N)
  2131.         $scalarExpressions   = [];
  2132.         $scalarExpressions[] = $this->ScalarExpression();
  2134.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  2135.             $this->match(Lexer::T_COMMA);
  2137.             $scalarExpressions[] = $this->ScalarExpression();
  2138.         }
  2140.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2142.         return new AST\CoalesceExpression($scalarExpressions);
  2143.     }
  2145.     /**
  2146.      * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2147.      *
  2148.      * @return NullIfExpression
  2149.      */
  2150.     public function NullIfExpression()
  2151.     {
  2152.         $this->match(Lexer::T_NULLIF);
  2153.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2155.         $firstExpression = $this->ScalarExpression();
  2156.         $this->match(Lexer::T_COMMA);
  2157.         $secondExpression = $this->ScalarExpression();
  2159.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2161.         return new AST\NullIfExpression($firstExpression, $secondExpression);
  2162.     }
  2164.     /**
  2165.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2166.      *
  2167.      * @return GeneralCaseExpression
  2168.      */
  2169.     public function GeneralCaseExpression()
  2170.     {
  2171.         $this->match(Lexer::T_CASE);
  2173.         // Process WhenClause (1..N)
  2174.         $whenClauses = [];
  2176.         do {
  2177.             $whenClauses[] = $this->WhenClause();
  2178.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2180.         $this->match(Lexer::T_ELSE);
  2181.         $scalarExpression = $this->ScalarExpression();
  2182.         $this->match(Lexer::T_END);
  2184.         return new AST\GeneralCaseExpression($whenClauses, $scalarExpression);
  2185.     }
  2187.     /**
  2188.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2189.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2190.      *
  2191.      * @return AST\SimpleCaseExpression
  2192.      */
  2193.     public function SimpleCaseExpression()
  2194.     {
  2195.         $this->match(Lexer::T_CASE);
  2196.         $caseOperand = $this->StateFieldPathExpression();
  2198.         // Process SimpleWhenClause (1..N)
  2199.         $simpleWhenClauses = [];
  2201.         do {
  2202.             $simpleWhenClauses[] = $this->SimpleWhenClause();
  2203.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2205.         $this->match(Lexer::T_ELSE);
  2206.         $scalarExpression = $this->ScalarExpression();
  2207.         $this->match(Lexer::T_END);
  2209.         return new AST\SimpleCaseExpression($caseOperand, $simpleWhenClauses, $scalarExpression);
  2210.     }
  2212.     /**
  2213.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2214.      *
  2215.      * @return WhenClause
  2216.      */
  2217.     public function WhenClause()
  2218.     {
  2219.         $this->match(Lexer::T_WHEN);
  2220.         $conditionalExpression = $this->ConditionalExpression();
  2221.         $this->match(Lexer::T_THEN);
  2223.         return new AST\WhenClause($conditionalExpression, $this->ScalarExpression());
  2224.     }
  2226.     /**
  2227.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2228.      *
  2229.      * @return SimpleWhenClause
  2230.      */
  2231.     public function SimpleWhenClause()
  2232.     {
  2233.         $this->match(Lexer::T_WHEN);
  2234.         $conditionalExpression = $this->ScalarExpression();
  2235.         $this->match(Lexer::T_THEN);
  2237.         return new AST\SimpleWhenClause($conditionalExpression, $this->ScalarExpression());
  2238.     }
  2240.     /**
  2241.      * SelectExpression ::= (
  2242.      *     IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration |
  2243.      *     PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression
  2244.      * ) [["AS"] ["HIDDEN"] AliasResultVariable]
  2245.      *
  2246.      * @return SelectExpression
  2247.      */
  2248.     public function SelectExpression()
  2249.     {
  2250.         $expression    = null;
  2251.         $identVariable = null;
  2252.         $peek          = $this->lexer->glimpse();
  2253.         $lookaheadType = $this->lexer->lookahead['type'];
  2255.         switch (true) {
  2256.             // ScalarExpression (u.name)
  2257.             case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] === Lexer::T_DOT:
  2258.                 $expression = $this->ScalarExpression();
  2259.                 break;
  2261.             // IdentificationVariable (u)
  2262.             case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2263.                 $expression = $identVariable = $this->IdentificationVariable();
  2264.                 break;
  2266.             // CaseExpression (CASE ... or NULLIF(...) or COALESCE(...))
  2267.             case $lookaheadType === Lexer::T_CASE:
  2268.             case $lookaheadType === Lexer::T_COALESCE:
  2269.             case $lookaheadType === Lexer::T_NULLIF:
  2270.                 $expression = $this->CaseExpression();
  2271.                 break;
  2273.             // DQL Function (SUM(u.value) or SUM(u.value) + 1)
  2274.             case $this->isFunction():
  2275.                 $this->lexer->peek(); // "("
  2277.                 switch (true) {
  2278.                     case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2279.                         // SUM(u.id) + COUNT(u.id)
  2280.                         $expression = $this->ScalarExpression();
  2281.                         break;
  2283.                     default:
  2284.                         // IDENTITY(u)
  2285.                         $expression = $this->FunctionDeclaration();
  2286.                         break;
  2287.                 }
  2289.                 break;
  2291.             // PartialObjectExpression (PARTIAL u.{id, name})
  2292.             case $lookaheadType === Lexer::T_PARTIAL:
  2293.                 $expression    = $this->PartialObjectExpression();
  2294.                 $identVariable = $expression->identificationVariable;
  2295.                 break;
  2297.             // Subselect
  2298.             case $lookaheadType === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT:
  2299.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2300.                 $expression = $this->Subselect();
  2301.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2302.                 break;
  2304.             // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2305.             case $lookaheadType === Lexer::T_OPEN_PARENTHESIS:
  2306.             case $lookaheadType === Lexer::T_INTEGER:
  2307.             case $lookaheadType === Lexer::T_STRING:
  2308.             case $lookaheadType === Lexer::T_FLOAT:
  2309.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )
  2310.             case $lookaheadType === Lexer::T_MINUS:
  2311.             case $lookaheadType === Lexer::T_PLUS:
  2312.                 $expression = $this->SimpleArithmeticExpression();
  2313.                 break;
  2315.             // NewObjectExpression (New ClassName(id, name))
  2316.             case $lookaheadType === Lexer::T_NEW:
  2317.                 $expression = $this->NewObjectExpression();
  2318.                 break;
  2320.             default:
  2321.                 $this->syntaxError(
  2322.                     'IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression',
  2323.                     $this->lexer->lookahead
  2324.                 );
  2325.         }
  2327.         // [["AS"] ["HIDDEN"] AliasResultVariable]
  2328.         $mustHaveAliasResultVariable = false;
  2330.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2331.             $this->match(Lexer::T_AS);
  2333.             $mustHaveAliasResultVariable = true;
  2334.         }
  2336.         $hiddenAliasResultVariable = false;
  2338.         if ($this->lexer->isNextToken(Lexer::T_HIDDEN)) {
  2339.             $this->match(Lexer::T_HIDDEN);
  2341.             $hiddenAliasResultVariable = true;
  2342.         }
  2344.         $aliasResultVariable = null;
  2346.         if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2347.             $token               = $this->lexer->lookahead;
  2348.             $aliasResultVariable = $this->AliasResultVariable();
  2350.             // Include AliasResultVariable in query components.
  2351.             $this->queryComponents[$aliasResultVariable] = [
  2352.                 'resultVariable' => $expression,
  2353.                 'nestingLevel'   => $this->nestingLevel,
  2354.                 'token'          => $token,
  2355.             ];
  2356.         }
  2358.         // AST
  2360.         $expr = new AST\SelectExpression($expression, $aliasResultVariable, $hiddenAliasResultVariable);
  2362.         if ($identVariable) {
  2363.             $this->identVariableExpressions[$identVariable] = $expr;
  2364.         }
  2366.         return $expr;
  2367.     }
  2369.     /**
  2370.      * SimpleSelectExpression ::= (
  2371.      *      StateFieldPathExpression | IdentificationVariable | FunctionDeclaration |
  2372.      *      AggregateExpression | "(" Subselect ")" | ScalarExpression
  2373.      * ) [["AS"] AliasResultVariable]
  2374.      *
  2375.      * @return SimpleSelectExpression
  2376.      */
  2377.     public function SimpleSelectExpression()
  2378.     {
  2379.         $peek = $this->lexer->glimpse();
  2381.         switch ($this->lexer->lookahead['type']) {
  2382.             case Lexer::T_IDENTIFIER:
  2383.                 switch (true) {
  2384.                     case $peek['type'] === Lexer::T_DOT:
  2385.                         $expression = $this->StateFieldPathExpression();
  2387.                         return new AST\SimpleSelectExpression($expression);
  2389.                     case $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2390.                         $expression = $this->IdentificationVariable();
  2392.                         return new AST\SimpleSelectExpression($expression);
  2394.                     case $this->isFunction():
  2395.                         // SUM(u.id) + COUNT(u.id)
  2396.                         if ($this->isMathOperator($this->peekBeyondClosingParenthesis())) {
  2397.                             return new AST\SimpleSelectExpression($this->ScalarExpression());
  2398.                         }
  2400.                         // COUNT(u.id)
  2401.                         if ($this->isAggregateFunction($this->lexer->lookahead['type'])) {
  2402.                             return new AST\SimpleSelectExpression($this->AggregateExpression());
  2403.                         }
  2405.                         // IDENTITY(u)
  2406.                         return new AST\SimpleSelectExpression($this->FunctionDeclaration());
  2408.                     default:
  2409.                         // Do nothing
  2410.                 }
  2412.                 break;
  2414.             case Lexer::T_OPEN_PARENTHESIS:
  2415.                 if ($peek['type'] !== Lexer::T_SELECT) {
  2416.                     // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2417.                     $expression = $this->SimpleArithmeticExpression();
  2419.                     return new AST\SimpleSelectExpression($expression);
  2420.                 }
  2422.                 // Subselect
  2423.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2424.                 $expression = $this->Subselect();
  2425.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2427.                 return new AST\SimpleSelectExpression($expression);
  2429.             default:
  2430.                 // Do nothing
  2431.         }
  2433.         $this->lexer->peek();
  2435.         $expression = $this->ScalarExpression();
  2436.         $expr       = new AST\SimpleSelectExpression($expression);
  2438.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2439.             $this->match(Lexer::T_AS);
  2440.         }
  2442.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2443.             $token                             = $this->lexer->lookahead;
  2444.             $resultVariable                    = $this->AliasResultVariable();
  2445.             $expr->fieldIdentificationVariable = $resultVariable;
  2447.             // Include AliasResultVariable in query components.
  2448.             $this->queryComponents[$resultVariable] = [
  2449.                 'resultvariable' => $expr,
  2450.                 'nestingLevel'   => $this->nestingLevel,
  2451.                 'token'          => $token,
  2452.             ];
  2453.         }
  2455.         return $expr;
  2456.     }
  2458.     /**
  2459.      * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
  2460.      *
  2461.      * @return AST\ConditionalExpression|AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2462.      */
  2463.     public function ConditionalExpression()
  2464.     {
  2465.         $conditionalTerms   = [];
  2466.         $conditionalTerms[] = $this->ConditionalTerm();
  2468.         while ($this->lexer->isNextToken(Lexer::T_OR)) {
  2469.             $this->match(Lexer::T_OR);
  2471.             $conditionalTerms[] = $this->ConditionalTerm();
  2472.         }
  2474.         // Phase 1 AST optimization: Prevent AST\ConditionalExpression
  2475.         // if only one AST\ConditionalTerm is defined
  2476.         if (count($conditionalTerms) === 1) {
  2477.             return $conditionalTerms[0];
  2478.         }
  2480.         return new AST\ConditionalExpression($conditionalTerms);
  2481.     }
  2483.     /**
  2484.      * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
  2485.      *
  2486.      * @return AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2487.      */
  2488.     public function ConditionalTerm()
  2489.     {
  2490.         $conditionalFactors   = [];
  2491.         $conditionalFactors[] = $this->ConditionalFactor();
  2493.         while ($this->lexer->isNextToken(Lexer::T_AND)) {
  2494.             $this->match(Lexer::T_AND);
  2496.             $conditionalFactors[] = $this->ConditionalFactor();
  2497.         }
  2499.         // Phase 1 AST optimization: Prevent AST\ConditionalTerm
  2500.         // if only one AST\ConditionalFactor is defined
  2501.         if (count($conditionalFactors) === 1) {
  2502.             return $conditionalFactors[0];
  2503.         }
  2505.         return new AST\ConditionalTerm($conditionalFactors);
  2506.     }
  2508.     /**
  2509.      * ConditionalFactor ::= ["NOT"] ConditionalPrimary
  2510.      *
  2511.      * @return AST\ConditionalFactor|AST\ConditionalPrimary
  2512.      */
  2513.     public function ConditionalFactor()
  2514.     {
  2515.         $not = false;
  2517.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2518.             $this->match(Lexer::T_NOT);
  2520.             $not = true;
  2521.         }
  2523.         $conditionalPrimary = $this->ConditionalPrimary();
  2525.         // Phase 1 AST optimization: Prevent AST\ConditionalFactor
  2526.         // if only one AST\ConditionalPrimary is defined
  2527.         if (! $not) {
  2528.             return $conditionalPrimary;
  2529.         }
  2531.         $conditionalFactor      = new AST\ConditionalFactor($conditionalPrimary);
  2532.         $conditionalFactor->not = $not;
  2534.         return $conditionalFactor;
  2535.     }
  2537.     /**
  2538.      * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
  2539.      *
  2540.      * @return ConditionalPrimary
  2541.      */
  2542.     public function ConditionalPrimary()
  2543.     {
  2544.         $condPrimary = new AST\ConditionalPrimary();
  2546.         if (! $this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2547.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2549.             return $condPrimary;
  2550.         }
  2552.         // Peek beyond the matching closing parenthesis ')'
  2553.         $peek = $this->peekBeyondClosingParenthesis();
  2555.         if (
  2556.             $peek !== null && (
  2557.             in_array($peek['value'], ['=', '<', '<=', '<>', '>', '>=', '!=']) ||
  2558.             in_array($peek['type'], [Lexer::T_NOT, Lexer::T_BETWEEN, Lexer::T_LIKE, Lexer::T_IN, Lexer::T_IS, Lexer::T_EXISTS]) ||
  2559.             $this->isMathOperator($peek)
  2560.             )
  2561.         ) {
  2562.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2564.             return $condPrimary;
  2565.         }
  2567.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2568.         $condPrimary->conditionalExpression = $this->ConditionalExpression();
  2569.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2571.         return $condPrimary;
  2572.     }
  2574.     /**
  2575.      * SimpleConditionalExpression ::=
  2576.      *      ComparisonExpression | BetweenExpression | LikeExpression |
  2577.      *      InExpression | NullComparisonExpression | ExistsExpression |
  2578.      *      EmptyCollectionComparisonExpression | CollectionMemberExpression |
  2579.      *      InstanceOfExpression
  2580.      *
  2581.      * @return AST\BetweenExpression|
  2582.      *         AST\CollectionMemberExpression|
  2583.      *         AST\ComparisonExpression|
  2584.      *         AST\EmptyCollectionComparisonExpression|
  2585.      *         AST\ExistsExpression|
  2586.      *         AST\InExpression|
  2587.      *         AST\InstanceOfExpression|
  2588.      *         AST\LikeExpression|
  2589.      *         AST\NullComparisonExpression
  2590.      */
  2591.     public function SimpleConditionalExpression()
  2592.     {
  2593.         if ($this->lexer->isNextToken(Lexer::T_EXISTS)) {
  2594.             return $this->ExistsExpression();
  2595.         }
  2597.         $token     = $this->lexer->lookahead;
  2598.         $peek      = $this->lexer->glimpse();
  2599.         $lookahead = $token;
  2601.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2602.             $token = $this->lexer->glimpse();
  2603.         }
  2605.         if ($token['type'] === Lexer::T_IDENTIFIER || $token['type'] === Lexer::T_INPUT_PARAMETER || $this->isFunction()) {
  2606.             // Peek beyond the matching closing parenthesis.
  2607.             $beyond = $this->lexer->peek();
  2609.             switch ($peek['value']) {
  2610.                 case '(':
  2611.                     // Peeks beyond the matched closing parenthesis.
  2612.                     $token = $this->peekBeyondClosingParenthesis(false);
  2614.                     if ($token['type'] === Lexer::T_NOT) {
  2615.                         $token = $this->lexer->peek();
  2616.                     }
  2618.                     if ($token['type'] === Lexer::T_IS) {
  2619.                         $lookahead = $this->lexer->peek();
  2620.                     }
  2622.                     break;
  2624.                 default:
  2625.                     // Peek beyond the PathExpression or InputParameter.
  2626.                     $token = $beyond;
  2628.                     while ($token['value'] === '.') {
  2629.                         $this->lexer->peek();
  2631.                         $token = $this->lexer->peek();
  2632.                     }
  2634.                     // Also peek beyond a NOT if there is one.
  2635.                     if ($token['type'] === Lexer::T_NOT) {
  2636.                         $token = $this->lexer->peek();
  2637.                     }
  2639.                     // We need to go even further in case of IS (differentiate between NULL and EMPTY)
  2640.                     $lookahead = $this->lexer->peek();
  2641.             }
  2643.             // Also peek beyond a NOT if there is one.
  2644.             if ($lookahead['type'] === Lexer::T_NOT) {
  2645.                 $lookahead = $this->lexer->peek();
  2646.             }
  2648.             $this->lexer->resetPeek();
  2649.         }
  2651.         if ($token['type'] === Lexer::T_BETWEEN) {
  2652.             return $this->BetweenExpression();
  2653.         }
  2655.         if ($token['type'] === Lexer::T_LIKE) {
  2656.             return $this->LikeExpression();
  2657.         }
  2659.         if ($token['type'] === Lexer::T_IN) {
  2660.             return $this->InExpression();
  2661.         }
  2663.         if ($token['type'] === Lexer::T_INSTANCE) {
  2664.             return $this->InstanceOfExpression();
  2665.         }
  2667.         if ($token['type'] === Lexer::T_MEMBER) {
  2668.             return $this->CollectionMemberExpression();
  2669.         }
  2671.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_NULL) {
  2672.             return $this->NullComparisonExpression();
  2673.         }
  2675.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_EMPTY) {
  2676.             return $this->EmptyCollectionComparisonExpression();
  2677.         }
  2679.         return $this->ComparisonExpression();
  2680.     }
  2682.     /**
  2683.      * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
  2684.      *
  2685.      * @return EmptyCollectionComparisonExpression
  2686.      */
  2687.     public function EmptyCollectionComparisonExpression()
  2688.     {
  2689.         $emptyCollectionCompExpr = new AST\EmptyCollectionComparisonExpression(
  2690.             $this->CollectionValuedPathExpression()
  2691.         );
  2692.         $this->match(Lexer::T_IS);
  2694.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2695.             $this->match(Lexer::T_NOT);
  2696.             $emptyCollectionCompExpr->not = true;
  2697.         }
  2699.         $this->match(Lexer::T_EMPTY);
  2701.         return $emptyCollectionCompExpr;
  2702.     }
  2704.     /**
  2705.      * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
  2706.      *
  2707.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2708.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2709.      *
  2710.      * @return CollectionMemberExpression
  2711.      */
  2712.     public function CollectionMemberExpression()
  2713.     {
  2714.         $not        = false;
  2715.         $entityExpr = $this->EntityExpression();
  2717.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2718.             $this->match(Lexer::T_NOT);
  2720.             $not = true;
  2721.         }
  2723.         $this->match(Lexer::T_MEMBER);
  2725.         if ($this->lexer->isNextToken(Lexer::T_OF)) {
  2726.             $this->match(Lexer::T_OF);
  2727.         }
  2729.         $collMemberExpr      = new AST\CollectionMemberExpression(
  2730.             $entityExpr,
  2731.             $this->CollectionValuedPathExpression()
  2732.         );
  2733.         $collMemberExpr->not = $not;
  2735.         return $collMemberExpr;
  2736.     }
  2738.     /**
  2739.      * Literal ::= string | char | integer | float | boolean
  2740.      *
  2741.      * @return Literal
  2742.      */
  2743.     public function Literal()
  2744.     {
  2745.         switch ($this->lexer->lookahead['type']) {
  2746.             case Lexer::T_STRING:
  2747.                 $this->match(Lexer::T_STRING);
  2749.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  2751.             case Lexer::T_INTEGER:
  2752.             case Lexer::T_FLOAT:
  2753.                 $this->match(
  2754.                     $this->lexer->isNextToken(Lexer::T_INTEGER) ? Lexer::T_INTEGER : Lexer::T_FLOAT
  2755.                 );
  2757.                 return new AST\Literal(AST\Literal::NUMERIC, $this->lexer->token['value']);
  2759.             case Lexer::T_TRUE:
  2760.             case Lexer::T_FALSE:
  2761.                 $this->match(
  2762.                     $this->lexer->isNextToken(Lexer::T_TRUE) ? Lexer::T_TRUE : Lexer::T_FALSE
  2763.                 );
  2765.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2767.             default:
  2768.                 $this->syntaxError('Literal');
  2769.         }
  2770.     }
  2772.     /**
  2773.      * InParameter ::= Literal | InputParameter
  2774.      *
  2775.      * @return AST\InputParameter|AST\Literal
  2776.      */
  2777.     public function InParameter()
  2778.     {
  2779.         if ($this->lexer->lookahead['type'] === Lexer::T_INPUT_PARAMETER) {
  2780.             return $this->InputParameter();
  2781.         }
  2783.         return $this->Literal();
  2784.     }
  2786.     /**
  2787.      * InputParameter ::= PositionalParameter | NamedParameter
  2788.      *
  2789.      * @return InputParameter
  2790.      */
  2791.     public function InputParameter()
  2792.     {
  2793.         $this->match(Lexer::T_INPUT_PARAMETER);
  2795.         return new AST\InputParameter($this->lexer->token['value']);
  2796.     }
  2798.     /**
  2799.      * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
  2800.      *
  2801.      * @return ArithmeticExpression
  2802.      */
  2803.     public function ArithmeticExpression()
  2804.     {
  2805.         $expr = new AST\ArithmeticExpression();
  2807.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2808.             $peek = $this->lexer->glimpse();
  2810.             if ($peek['type'] === Lexer::T_SELECT) {
  2811.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2812.                 $expr->subselect = $this->Subselect();
  2813.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2815.                 return $expr;
  2816.             }
  2817.         }
  2819.         $expr->simpleArithmeticExpression = $this->SimpleArithmeticExpression();
  2821.         return $expr;
  2822.     }
  2824.     /**
  2825.      * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
  2826.      *
  2827.      * @return SimpleArithmeticExpression
  2828.      */
  2829.     public function SimpleArithmeticExpression()
  2830.     {
  2831.         $terms   = [];
  2832.         $terms[] = $this->ArithmeticTerm();
  2834.         while (($isPlus = $this->lexer->isNextToken(Lexer::T_PLUS)) || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2835.             $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2837.             $terms[] = $this->lexer->token['value'];
  2838.             $terms[] = $this->ArithmeticTerm();
  2839.         }
  2841.         // Phase 1 AST optimization: Prevent AST\SimpleArithmeticExpression
  2842.         // if only one AST\ArithmeticTerm is defined
  2843.         if (count($terms) === 1) {
  2844.             return $terms[0];
  2845.         }
  2847.         return new AST\SimpleArithmeticExpression($terms);
  2848.     }
  2850.     /**
  2851.      * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
  2852.      *
  2853.      * @return ArithmeticTerm
  2854.      */
  2855.     public function ArithmeticTerm()
  2856.     {
  2857.         $factors   = [];
  2858.         $factors[] = $this->ArithmeticFactor();
  2860.         while (($isMult = $this->lexer->isNextToken(Lexer::T_MULTIPLY)) || $this->lexer->isNextToken(Lexer::T_DIVIDE)) {
  2861.             $this->match($isMult ? Lexer::T_MULTIPLY : Lexer::T_DIVIDE);
  2863.             $factors[] = $this->lexer->token['value'];
  2864.             $factors[] = $this->ArithmeticFactor();
  2865.         }
  2867.         // Phase 1 AST optimization: Prevent AST\ArithmeticTerm
  2868.         // if only one AST\ArithmeticFactor is defined
  2869.         if (count($factors) === 1) {
  2870.             return $factors[0];
  2871.         }
  2873.         return new AST\ArithmeticTerm($factors);
  2874.     }
  2876.     /**
  2877.      * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
  2878.      *
  2879.      * @return ArithmeticFactor
  2880.      */
  2881.     public function ArithmeticFactor()
  2882.     {
  2883.         $sign = null;
  2885.         $isPlus = $this->lexer->isNextToken(Lexer::T_PLUS);
  2886.         if ($isPlus || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2887.             $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2888.             $sign = $isPlus;
  2889.         }
  2891.         $primary = $this->ArithmeticPrimary();
  2893.         // Phase 1 AST optimization: Prevent AST\ArithmeticFactor
  2894.         // if only one AST\ArithmeticPrimary is defined
  2895.         if ($sign === null) {
  2896.             return $primary;
  2897.         }
  2899.         return new AST\ArithmeticFactor($primary, $sign);
  2900.     }
  2902.     /**
  2903.      * ArithmeticPrimary ::= SingleValuedPathExpression | Literal | ParenthesisExpression
  2904.      *          | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings
  2905.      *          | FunctionsReturningDatetime | IdentificationVariable | ResultVariable
  2906.      *          | InputParameter | CaseExpression
  2907.      *
  2908.      * @return Node|string
  2909.      */
  2910.     public function ArithmeticPrimary()
  2911.     {
  2912.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2913.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2915.             $expr = $this->SimpleArithmeticExpression();
  2917.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2919.             return new AST\ParenthesisExpression($expr);
  2920.         }
  2922.         switch ($this->lexer->lookahead['type']) {
  2923.             case Lexer::T_COALESCE:
  2924.             case Lexer::T_NULLIF:
  2925.             case Lexer::T_CASE:
  2926.                 return $this->CaseExpression();
  2928.             case Lexer::T_IDENTIFIER:
  2929.                 $peek = $this->lexer->glimpse();
  2931.                 if ($peek !== null && $peek['value'] === '(') {
  2932.                     return $this->FunctionDeclaration();
  2933.                 }
  2935.                 if ($peek !== null && $peek['value'] === '.') {
  2936.                     return $this->SingleValuedPathExpression();
  2937.                 }
  2939.                 if (isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])) {
  2940.                     return $this->ResultVariable();
  2941.                 }
  2943.                 return $this->StateFieldPathExpression();
  2945.             case Lexer::T_INPUT_PARAMETER:
  2946.                 return $this->InputParameter();
  2948.             default:
  2949.                 $peek = $this->lexer->glimpse();
  2951.                 if ($peek !== null && $peek['value'] === '(') {
  2952.                     return $this->FunctionDeclaration();
  2953.                 }
  2955.                 return $this->Literal();
  2956.         }
  2957.     }
  2959.     /**
  2960.      * StringExpression ::= StringPrimary | ResultVariable | "(" Subselect ")"
  2961.      *
  2962.      * @return Subselect|string
  2963.      */
  2964.     public function StringExpression()
  2965.     {
  2966.         $peek = $this->lexer->glimpse();
  2968.         // Subselect
  2969.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $peek['type'] === Lexer::T_SELECT) {
  2970.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2971.             $expr = $this->Subselect();
  2972.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2974.             return $expr;
  2975.         }
  2977.         // ResultVariable (string)
  2978.         if (
  2979.             $this->lexer->isNextToken(Lexer::T_IDENTIFIER) &&
  2980.             isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])
  2981.         ) {
  2982.             return $this->ResultVariable();
  2983.         }
  2985.         return $this->StringPrimary();
  2986.     }
  2988.     /**
  2989.      * StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression
  2990.      *
  2991.      * @return Node
  2992.      */
  2993.     public function StringPrimary()
  2994.     {
  2995.         $lookaheadType = $this->lexer->lookahead['type'];
  2997.         switch ($lookaheadType) {
  2998.             case Lexer::T_IDENTIFIER:
  2999.                 $peek = $this->lexer->glimpse();
  3001.                 if ($peek['value'] === '.') {
  3002.                     return $this->StateFieldPathExpression();
  3003.                 }
  3005.                 if ($peek['value'] === '(') {
  3006.                     // do NOT directly go to FunctionsReturningString() because it doesn't check for custom functions.
  3007.                     return $this->FunctionDeclaration();
  3008.                 }
  3010.                 $this->syntaxError("'.' or '('");
  3011.                 break;
  3013.             case Lexer::T_STRING:
  3014.                 $this->match(Lexer::T_STRING);
  3016.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3018.             case Lexer::T_INPUT_PARAMETER:
  3019.                 return $this->InputParameter();
  3021.             case Lexer::T_CASE:
  3022.             case Lexer::T_COALESCE:
  3023.             case Lexer::T_NULLIF:
  3024.                 return $this->CaseExpression();
  3026.             default:
  3027.                 if ($this->isAggregateFunction($lookaheadType)) {
  3028.                     return $this->AggregateExpression();
  3029.                 }
  3030.         }
  3032.         $this->syntaxError(
  3033.             'StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression'
  3034.         );
  3035.     }
  3037.     /**
  3038.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  3039.      *
  3040.      * @return AST\InputParameter|PathExpression
  3041.      */
  3042.     public function EntityExpression()
  3043.     {
  3044.         $glimpse = $this->lexer->glimpse();
  3046.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER) && $glimpse['value'] === '.') {
  3047.             return $this->SingleValuedAssociationPathExpression();
  3048.         }
  3050.         return $this->SimpleEntityExpression();
  3051.     }
  3053.     /**
  3054.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  3055.      *
  3056.      * @return AST\InputParameter|AST\PathExpression
  3057.      */
  3058.     public function SimpleEntityExpression()
  3059.     {
  3060.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3061.             return $this->InputParameter();
  3062.         }
  3064.         return $this->StateFieldPathExpression();
  3065.     }
  3067.     /**
  3068.      * AggregateExpression ::=
  3069.      *  ("AVG" | "MAX" | "MIN" | "SUM" | "COUNT") "(" ["DISTINCT"] SimpleArithmeticExpression ")"
  3070.      *
  3071.      * @return AggregateExpression
  3072.      */
  3073.     public function AggregateExpression()
  3074.     {
  3075.         $lookaheadType = $this->lexer->lookahead['type'];
  3076.         $isDistinct    = false;
  3078.         if (! in_array($lookaheadType, [Lexer::T_COUNT, Lexer::T_AVG, Lexer::T_MAX, Lexer::T_MIN, Lexer::T_SUM])) {
  3079.             $this->syntaxError('One of: MAX, MIN, AVG, SUM, COUNT');
  3080.         }
  3082.         $this->match($lookaheadType);
  3083.         $functionName = $this->lexer->token['value'];
  3084.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3086.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  3087.             $this->match(Lexer::T_DISTINCT);
  3088.             $isDistinct = true;
  3089.         }
  3091.         $pathExp = $this->SimpleArithmeticExpression();
  3093.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3095.         return new AST\AggregateExpression($functionName, $pathExp, $isDistinct);
  3096.     }
  3098.     /**
  3099.      * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
  3100.      *
  3101.      * @return QuantifiedExpression
  3102.      */
  3103.     public function QuantifiedExpression()
  3104.     {
  3105.         $lookaheadType = $this->lexer->lookahead['type'];
  3106.         $value         = $this->lexer->lookahead['value'];
  3108.         if (! in_array($lookaheadType, [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME])) {
  3109.             $this->syntaxError('ALL, ANY or SOME');
  3110.         }
  3112.         $this->match($lookaheadType);
  3113.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3115.         $qExpr       = new AST\QuantifiedExpression($this->Subselect());
  3116.         $qExpr->type = $value;
  3118.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3120.         return $qExpr;
  3121.     }
  3123.     /**
  3124.      * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
  3125.      *
  3126.      * @return BetweenExpression
  3127.      */
  3128.     public function BetweenExpression()
  3129.     {
  3130.         $not        = false;
  3131.         $arithExpr1 = $this->ArithmeticExpression();
  3133.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3134.             $this->match(Lexer::T_NOT);
  3135.             $not = true;
  3136.         }
  3138.         $this->match(Lexer::T_BETWEEN);
  3139.         $arithExpr2 = $this->ArithmeticExpression();
  3140.         $this->match(Lexer::T_AND);
  3141.         $arithExpr3 = $this->ArithmeticExpression();
  3143.         $betweenExpr      = new AST\BetweenExpression($arithExpr1, $arithExpr2, $arithExpr3);
  3144.         $betweenExpr->not = $not;
  3146.         return $betweenExpr;
  3147.     }
  3149.     /**
  3150.      * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )
  3151.      *
  3152.      * @return ComparisonExpression
  3153.      */
  3154.     public function ComparisonExpression()
  3155.     {
  3156.         $this->lexer->glimpse();
  3158.         $leftExpr  = $this->ArithmeticExpression();
  3159.         $operator  = $this->ComparisonOperator();
  3160.         $rightExpr = $this->isNextAllAnySome()
  3161.             ? $this->QuantifiedExpression()
  3162.             : $this->ArithmeticExpression();
  3164.         return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
  3165.     }
  3167.     /**
  3168.      * InExpression ::= SingleValuedPathExpression ["NOT"] "IN" "(" (InParameter {"," InParameter}* | Subselect) ")"
  3169.      *
  3170.      * @return InExpression
  3171.      */
  3172.     public function InExpression()
  3173.     {
  3174.         $inExpression = new AST\InExpression($this->ArithmeticExpression());
  3176.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3177.             $this->match(Lexer::T_NOT);
  3178.             $inExpression->not = true;
  3179.         }
  3181.         $this->match(Lexer::T_IN);
  3182.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3184.         if ($this->lexer->isNextToken(Lexer::T_SELECT)) {
  3185.             $inExpression->subselect = $this->Subselect();
  3186.         } else {
  3187.             $literals   = [];
  3188.             $literals[] = $this->InParameter();
  3190.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3191.                 $this->match(Lexer::T_COMMA);
  3192.                 $literals[] = $this->InParameter();
  3193.             }
  3195.             $inExpression->literals = $literals;
  3196.         }
  3198.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3200.         return $inExpression;
  3201.     }
  3203.     /**
  3204.      * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
  3205.      *
  3206.      * @return InstanceOfExpression
  3207.      */
  3208.     public function InstanceOfExpression()
  3209.     {
  3210.         $instanceOfExpression = new AST\InstanceOfExpression($this->IdentificationVariable());
  3212.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3213.             $this->match(Lexer::T_NOT);
  3214.             $instanceOfExpression->not = true;
  3215.         }
  3217.         $this->match(Lexer::T_INSTANCE);
  3218.         $this->match(Lexer::T_OF);
  3220.         $exprValues = [];
  3222.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  3223.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  3225.             $exprValues[] = $this->InstanceOfParameter();
  3227.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3228.                 $this->match(Lexer::T_COMMA);
  3230.                 $exprValues[] = $this->InstanceOfParameter();
  3231.             }
  3233.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3235.             $instanceOfExpression->value = $exprValues;
  3237.             return $instanceOfExpression;
  3238.         }
  3240.         $exprValues[] = $this->InstanceOfParameter();
  3242.         $instanceOfExpression->value = $exprValues;
  3244.         return $instanceOfExpression;
  3245.     }
  3247.     /**
  3248.      * InstanceOfParameter ::= AbstractSchemaName | InputParameter
  3249.      *
  3250.      * @return mixed
  3251.      */
  3252.     public function InstanceOfParameter()
  3253.     {
  3254.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3255.             $this->match(Lexer::T_INPUT_PARAMETER);
  3257.             return new AST\InputParameter($this->lexer->token['value']);
  3258.         }
  3260.         $abstractSchemaName = $this->AbstractSchemaName();
  3262.         $this->validateAbstractSchemaName($abstractSchemaName);
  3264.         return $abstractSchemaName;
  3265.     }
  3267.     /**
  3268.      * LikeExpression ::= StringExpression ["NOT"] "LIKE" StringPrimary ["ESCAPE" char]
  3269.      *
  3270.      * @return LikeExpression
  3271.      */
  3272.     public function LikeExpression()
  3273.     {
  3274.         $stringExpr = $this->StringExpression();
  3275.         $not        = false;
  3277.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3278.             $this->match(Lexer::T_NOT);
  3279.             $not = true;
  3280.         }
  3282.         $this->match(Lexer::T_LIKE);
  3284.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3285.             $this->match(Lexer::T_INPUT_PARAMETER);
  3286.             $stringPattern = new AST\InputParameter($this->lexer->token['value']);
  3287.         } else {
  3288.             $stringPattern = $this->StringPrimary();
  3289.         }
  3291.         $escapeChar = null;
  3293.         if ($this->lexer->lookahead !== null && $this->lexer->lookahead['type'] === Lexer::T_ESCAPE) {
  3294.             $this->match(Lexer::T_ESCAPE);
  3295.             $this->match(Lexer::T_STRING);
  3297.             $escapeChar = new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3298.         }
  3300.         $likeExpr      = new AST\LikeExpression($stringExpr, $stringPattern, $escapeChar);
  3301.         $likeExpr->not = $not;
  3303.         return $likeExpr;
  3304.     }
  3306.     /**
  3307.      * NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) "IS" ["NOT"] "NULL"
  3308.      *
  3309.      * @return NullComparisonExpression
  3310.      */
  3311.     public function NullComparisonExpression()
  3312.     {
  3313.         switch (true) {
  3314.             case $this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER):
  3315.                 $this->match(Lexer::T_INPUT_PARAMETER);
  3317.                 $expr = new AST\InputParameter($this->lexer->token['value']);
  3318.                 break;
  3320.             case $this->lexer->isNextToken(Lexer::T_NULLIF):
  3321.                 $expr = $this->NullIfExpression();
  3322.                 break;
  3324.             case $this->lexer->isNextToken(Lexer::T_COALESCE):
  3325.                 $expr = $this->CoalesceExpression();
  3326.                 break;
  3328.             case $this->isFunction():
  3329.                 $expr = $this->FunctionDeclaration();
  3330.                 break;
  3332.             default:
  3333.                 // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  3334.                 $glimpse = $this->lexer->glimpse();
  3336.                 if ($glimpse['type'] === Lexer::T_DOT) {
  3337.                     $expr = $this->SingleValuedPathExpression();
  3339.                     // Leave switch statement
  3340.                     break;
  3341.                 }
  3343.                 $lookaheadValue = $this->lexer->lookahead['value'];
  3345.                 // Validate existing component
  3346.                 if (! isset($this->queryComponents[$lookaheadValue])) {
  3347.                     $this->semanticalError('Cannot add having condition on undefined result variable.');
  3348.                 }
  3350.                 // Validate SingleValuedPathExpression (ie.: "product")
  3351.                 if (isset($this->queryComponents[$lookaheadValue]['metadata'])) {
  3352.                     $expr = $this->SingleValuedPathExpression();
  3353.                     break;
  3354.                 }
  3356.                 // Validating ResultVariable
  3357.                 if (! isset($this->queryComponents[$lookaheadValue]['resultVariable'])) {
  3358.                     $this->semanticalError('Cannot add having condition on a non result variable.');
  3359.                 }
  3361.                 $expr = $this->ResultVariable();
  3362.                 break;
  3363.         }
  3365.         $nullCompExpr = new AST\NullComparisonExpression($expr);
  3367.         $this->match(Lexer::T_IS);
  3369.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3370.             $this->match(Lexer::T_NOT);
  3372.             $nullCompExpr->not = true;
  3373.         }
  3375.         $this->match(Lexer::T_NULL);
  3377.         return $nullCompExpr;
  3378.     }
  3380.     /**
  3381.      * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
  3382.      *
  3383.      * @return ExistsExpression
  3384.      */
  3385.     public function ExistsExpression()
  3386.     {
  3387.         $not = false;
  3389.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3390.             $this->match(Lexer::T_NOT);
  3391.             $not = true;
  3392.         }
  3394.         $this->match(Lexer::T_EXISTS);
  3395.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3397.         $existsExpression      = new AST\ExistsExpression($this->Subselect());
  3398.         $existsExpression->not = $not;
  3400.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3402.         return $existsExpression;
  3403.     }
  3405.     /**
  3406.      * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
  3407.      *
  3408.      * @return string
  3409.      */
  3410.     public function ComparisonOperator()
  3411.     {
  3412.         switch ($this->lexer->lookahead['value']) {
  3413.             case '=':
  3414.                 $this->match(Lexer::T_EQUALS);
  3416.                 return '=';
  3418.             case '<':
  3419.                 $this->match(Lexer::T_LOWER_THAN);
  3420.                 $operator = '<';
  3422.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3423.                     $this->match(Lexer::T_EQUALS);
  3424.                     $operator .= '=';
  3425.                 } elseif ($this->lexer->isNextToken(Lexer::T_GREATER_THAN)) {
  3426.                     $this->match(Lexer::T_GREATER_THAN);
  3427.                     $operator .= '>';
  3428.                 }
  3430.                 return $operator;
  3432.             case '>':
  3433.                 $this->match(Lexer::T_GREATER_THAN);
  3434.                 $operator = '>';
  3436.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3437.                     $this->match(Lexer::T_EQUALS);
  3438.                     $operator .= '=';
  3439.                 }
  3441.                 return $operator;
  3443.             case '!':
  3444.                 $this->match(Lexer::T_NEGATE);
  3445.                 $this->match(Lexer::T_EQUALS);
  3447.                 return '<>';
  3449.             default:
  3450.                 $this->syntaxError('=, <, <=, <>, >, >=, !=');
  3451.         }
  3452.     }
  3454.     /**
  3455.      * FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDatetime
  3456.      *
  3457.      * @return FunctionNode
  3458.      */
  3459.     public function FunctionDeclaration()
  3460.     {
  3461.         $token    = $this->lexer->lookahead;
  3462.         $funcName = strtolower($token['value']);
  3464.         $customFunctionDeclaration = $this->CustomFunctionDeclaration();
  3466.         // Check for custom functions functions first!
  3467.         switch (true) {
  3468.             case $customFunctionDeclaration !== null:
  3469.                 return $customFunctionDeclaration;
  3471.             case isset(self::$stringFunctions[$funcName]):
  3472.                 return $this->FunctionsReturningStrings();
  3474.             case isset(self::$numericFunctions[$funcName]):
  3475.                 return $this->FunctionsReturningNumerics();
  3477.             case isset(self::$datetimeFunctions[$funcName]):
  3478.                 return $this->FunctionsReturningDatetime();
  3480.             default:
  3481.                 $this->syntaxError('known function', $token);
  3482.         }
  3483.     }
  3485.     /**
  3486.      * Helper function for FunctionDeclaration grammar rule.
  3487.      */
  3488.     private function CustomFunctionDeclaration(): ?FunctionNode
  3489.     {
  3490.         $token    = $this->lexer->lookahead;
  3491.         $funcName = strtolower($token['value']);
  3493.         // Check for custom functions afterwards
  3494.         $config = $this->em->getConfiguration();
  3496.         switch (true) {
  3497.             case $config->getCustomStringFunction($funcName) !== null:
  3498.                 return $this->CustomFunctionsReturningStrings();
  3500.             case $config->getCustomNumericFunction($funcName) !== null:
  3501.                 return $this->CustomFunctionsReturningNumerics();
  3503.             case $config->getCustomDatetimeFunction($funcName) !== null:
  3504.                 return $this->CustomFunctionsReturningDatetime();
  3506.             default:
  3507.                 return null;
  3508.         }
  3509.     }
  3511.     /**
  3512.      * FunctionsReturningNumerics ::=
  3513.      *      "LENGTH" "(" StringPrimary ")" |
  3514.      *      "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")" |
  3515.      *      "ABS" "(" SimpleArithmeticExpression ")" |
  3516.      *      "SQRT" "(" SimpleArithmeticExpression ")" |
  3517.      *      "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3518.      *      "SIZE" "(" CollectionValuedPathExpression ")" |
  3519.      *      "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3520.      *      "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3521.      *      "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
  3522.      *
  3523.      * @return FunctionNode
  3524.      */
  3525.     public function FunctionsReturningNumerics()
  3526.     {
  3527.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3528.         $funcClass     = self::$numericFunctions[$funcNameLower];
  3530.         $function = new $funcClass($funcNameLower);
  3531.         $function->parse($this);
  3533.         return $function;
  3534.     }
  3536.     /**
  3537.      * @return FunctionNode
  3538.      */
  3539.     public function CustomFunctionsReturningNumerics()
  3540.     {
  3541.         // getCustomNumericFunction is case-insensitive
  3542.         $functionName  = strtolower($this->lexer->lookahead['value']);
  3543.         $functionClass = $this->em->getConfiguration()->getCustomNumericFunction($functionName);
  3545.         assert($functionClass !== null);
  3547.         $function = is_string($functionClass)
  3548.             ? new $functionClass($functionName)
  3549.             : call_user_func($functionClass, $functionName);
  3551.         $function->parse($this);
  3553.         return $function;
  3554.     }
  3556.     /**
  3557.      * FunctionsReturningDateTime ::=
  3558.      *     "CURRENT_DATE" |
  3559.      *     "CURRENT_TIME" |
  3560.      *     "CURRENT_TIMESTAMP" |
  3561.      *     "DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")" |
  3562.      *     "DATE_SUB" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
  3563.      *
  3564.      * @return FunctionNode
  3565.      */
  3566.     public function FunctionsReturningDatetime()
  3567.     {
  3568.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3569.         $funcClass     = self::$datetimeFunctions[$funcNameLower];
  3571.         $function = new $funcClass($funcNameLower);
  3572.         $function->parse($this);
  3574.         return $function;
  3575.     }
  3577.     /**
  3578.      * @return FunctionNode
  3579.      */
  3580.     public function CustomFunctionsReturningDatetime()
  3581.     {
  3582.         // getCustomDatetimeFunction is case-insensitive
  3583.         $functionName  = $this->lexer->lookahead['value'];
  3584.         $functionClass = $this->em->getConfiguration()->getCustomDatetimeFunction($functionName);
  3586.         assert($functionClass !== null);
  3588.         $function = is_string($functionClass)
  3589.             ? new $functionClass($functionName)
  3590.             : call_user_func($functionClass, $functionName);
  3592.         $function->parse($this);
  3594.         return $function;
  3595.     }
  3597.     /**
  3598.      * FunctionsReturningStrings ::=
  3599.      *   "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary}* ")" |
  3600.      *   "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3601.      *   "TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")" |
  3602.      *   "LOWER" "(" StringPrimary ")" |
  3603.      *   "UPPER" "(" StringPrimary ")" |
  3604.      *   "IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
  3605.      *
  3606.      * @return FunctionNode
  3607.      */
  3608.     public function FunctionsReturningStrings()
  3609.     {
  3610.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3611.         $funcClass     = self::$stringFunctions[$funcNameLower];
  3613.         $function = new $funcClass($funcNameLower);
  3614.         $function->parse($this);
  3616.         return $function;
  3617.     }
  3619.     /**
  3620.      * @return FunctionNode
  3621.      */
  3622.     public function CustomFunctionsReturningStrings()
  3623.     {
  3624.         // getCustomStringFunction is case-insensitive
  3625.         $functionName  = $this->lexer->lookahead['value'];
  3626.         $functionClass = $this->em->getConfiguration()->getCustomStringFunction($functionName);
  3628.         assert($functionClass !== null);
  3630.         $function = is_string($functionClass)
  3631.             ? new $functionClass($functionName)
  3632.             : call_user_func($functionClass, $functionName);
  3634.         $function->parse($this);
  3636.         return $function;
  3637.     }
  3638. }