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

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Query;
  7. use Doctrine\Common\Lexer\AbstractLexer;
  8. use Doctrine\Deprecations\Deprecation;
  9. use Doctrine\ORM\EntityManagerInterface;
  10. use Doctrine\ORM\Mapping\ClassMetadata;
  11. use Doctrine\ORM\Query;
  12. use Doctrine\ORM\Query\AST\AggregateExpression;
  13. use Doctrine\ORM\Query\AST\ArithmeticExpression;
  14. use Doctrine\ORM\Query\AST\ArithmeticFactor;
  15. use Doctrine\ORM\Query\AST\ArithmeticTerm;
  16. use Doctrine\ORM\Query\AST\BetweenExpression;
  17. use Doctrine\ORM\Query\AST\CoalesceExpression;
  18. use Doctrine\ORM\Query\AST\CollectionMemberExpression;
  19. use Doctrine\ORM\Query\AST\ComparisonExpression;
  20. use Doctrine\ORM\Query\AST\ConditionalPrimary;
  21. use Doctrine\ORM\Query\AST\DeleteClause;
  22. use Doctrine\ORM\Query\AST\DeleteStatement;
  23. use Doctrine\ORM\Query\AST\EmptyCollectionComparisonExpression;
  24. use Doctrine\ORM\Query\AST\ExistsExpression;
  25. use Doctrine\ORM\Query\AST\FromClause;
  26. use Doctrine\ORM\Query\AST\Functions;
  27. use Doctrine\ORM\Query\AST\Functions\FunctionNode;
  28. use Doctrine\ORM\Query\AST\GeneralCaseExpression;
  29. use Doctrine\ORM\Query\AST\GroupByClause;
  30. use Doctrine\ORM\Query\AST\HavingClause;
  31. use Doctrine\ORM\Query\AST\IdentificationVariableDeclaration;
  32. use Doctrine\ORM\Query\AST\IndexBy;
  33. use Doctrine\ORM\Query\AST\InExpression;
  34. use Doctrine\ORM\Query\AST\InputParameter;
  35. use Doctrine\ORM\Query\AST\InstanceOfExpression;
  36. use Doctrine\ORM\Query\AST\Join;
  37. use Doctrine\ORM\Query\AST\JoinAssociationPathExpression;
  38. use Doctrine\ORM\Query\AST\LikeExpression;
  39. use Doctrine\ORM\Query\AST\Literal;
  40. use Doctrine\ORM\Query\AST\NewObjectExpression;
  41. use Doctrine\ORM\Query\AST\Node;
  42. use Doctrine\ORM\Query\AST\NullComparisonExpression;
  43. use Doctrine\ORM\Query\AST\NullIfExpression;
  44. use Doctrine\ORM\Query\AST\OrderByClause;
  45. use Doctrine\ORM\Query\AST\OrderByItem;
  46. use Doctrine\ORM\Query\AST\PartialObjectExpression;
  47. use Doctrine\ORM\Query\AST\PathExpression;
  48. use Doctrine\ORM\Query\AST\QuantifiedExpression;
  49. use Doctrine\ORM\Query\AST\RangeVariableDeclaration;
  50. use Doctrine\ORM\Query\AST\SelectClause;
  51. use Doctrine\ORM\Query\AST\SelectExpression;
  52. use Doctrine\ORM\Query\AST\SelectStatement;
  53. use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
  54. use Doctrine\ORM\Query\AST\SimpleSelectClause;
  55. use Doctrine\ORM\Query\AST\SimpleSelectExpression;
  56. use Doctrine\ORM\Query\AST\SimpleWhenClause;
  57. use Doctrine\ORM\Query\AST\Subselect;
  58. use Doctrine\ORM\Query\AST\SubselectFromClause;
  59. use Doctrine\ORM\Query\AST\UpdateClause;
  60. use Doctrine\ORM\Query\AST\UpdateItem;
  61. use Doctrine\ORM\Query\AST\UpdateStatement;
  62. use Doctrine\ORM\Query\AST\WhenClause;
  63. use Doctrine\ORM\Query\AST\WhereClause;
  64. use LogicException;
  65. use ReflectionClass;
  67. use function array_intersect;
  68. use function array_search;
  69. use function assert;
  70. use function class_exists;
  71. use function count;
  72. use function explode;
  73. use function implode;
  74. use function in_array;
  75. use function interface_exists;
  76. use function is_string;
  77. use function sprintf;
  78. use function str_contains;
  79. use function strlen;
  80. use function strpos;
  81. use function strrpos;
  82. use function strtolower;
  83. use function substr;
  85. /**
  86.  * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  87.  * Parses a DQL query, reports any errors in it, and generates an AST.
  88.  *
  89.  * @psalm-import-type Token from AbstractLexer
  90.  * @psalm-type QueryComponent = array{
  91.  *                 metadata?: ClassMetadata<object>,
  92.  *                 parent?: string|null,
  93.  *                 relation?: mixed[]|null,
  94.  *                 map?: string|null,
  95.  *                 resultVariable?: AST\Node|string,
  96.  *                 nestingLevel: int,
  97.  *                 token: Token,
  98.  *             }
  99.  */
  100. class Parser
  101. {
  102.     /**
  103.      * @readonly Maps BUILT-IN string function names to AST class names.
  104.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  105.      */
  106.     private static $stringFunctions = [
  107.         'concat'    => Functions\ConcatFunction::class,
  108.         'substring' => Functions\SubstringFunction::class,
  109.         'trim'      => Functions\TrimFunction::class,
  110.         'lower'     => Functions\LowerFunction::class,
  111.         'upper'     => Functions\UpperFunction::class,
  112.         'identity'  => Functions\IdentityFunction::class,
  113.     ];
  115.     /**
  116.      * @readonly Maps BUILT-IN numeric function names to AST class names.
  117.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  118.      */
  119.     private static $numericFunctions = [
  120.         'length'    => Functions\LengthFunction::class,
  121.         'locate'    => Functions\LocateFunction::class,
  122.         'abs'       => Functions\AbsFunction::class,
  123.         'sqrt'      => Functions\SqrtFunction::class,
  124.         'mod'       => Functions\ModFunction::class,
  125.         'size'      => Functions\SizeFunction::class,
  126.         'date_diff' => Functions\DateDiffFunction::class,
  127.         'bit_and'   => Functions\BitAndFunction::class,
  128.         'bit_or'    => Functions\BitOrFunction::class,
  130.         // Aggregate functions
  131.         'min'       => Functions\MinFunction::class,
  132.         'max'       => Functions\MaxFunction::class,
  133.         'avg'       => Functions\AvgFunction::class,
  134.         'sum'       => Functions\SumFunction::class,
  135.         'count'     => Functions\CountFunction::class,
  136.     ];
  138.     /**
  139.      * @readonly Maps BUILT-IN datetime function names to AST class names.
  140.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  141.      */
  142.     private static $datetimeFunctions = [
  143.         'current_date'      => Functions\CurrentDateFunction::class,
  144.         'current_time'      => Functions\CurrentTimeFunction::class,
  145.         'current_timestamp' => Functions\CurrentTimestampFunction::class,
  146.         'date_add'          => Functions\DateAddFunction::class,
  147.         'date_sub'          => Functions\DateSubFunction::class,
  148.     ];
  150.     /*
  151.      * Expressions that were encountered during parsing of identifiers and expressions
  152.      * and still need to be validated.
  153.      */
  155.     /** @psalm-var list<array{token: Token|null, expression: mixed, nestingLevel: int}> */
  156.     private $deferredIdentificationVariables = [];
  158.     /** @psalm-var list<array{token: Token|null, expression: AST\PartialObjectExpression, nestingLevel: int}> */
  159.     private $deferredPartialObjectExpressions = [];
  161.     /** @psalm-var list<array{token: Token|null, expression: AST\PathExpression, nestingLevel: int}> */
  162.     private $deferredPathExpressions = [];
  164.     /** @psalm-var list<array{token: Token|null, expression: mixed, nestingLevel: int}> */
  165.     private $deferredResultVariables = [];
  167.     /** @psalm-var list<array{token: Token|null, expression: AST\NewObjectExpression, nestingLevel: int}> */
  168.     private $deferredNewObjectExpressions = [];
  170.     /**
  171.      * The lexer.
  172.      *
  173.      * @var Lexer
  174.      */
  175.     private $lexer;
  177.     /**
  178.      * The parser result.
  179.      *
  180.      * @var ParserResult
  181.      */
  182.     private $parserResult;
  184.     /**
  185.      * The EntityManager.
  186.      *
  187.      * @var EntityManagerInterface
  188.      */
  189.     private $em;
  191.     /**
  192.      * The Query to parse.
  193.      *
  194.      * @var Query
  195.      */
  196.     private $query;
  198.     /**
  199.      * Map of declared query components in the parsed query.
  200.      *
  201.      * @psalm-var array<string, QueryComponent>
  202.      */
  203.     private $queryComponents = [];
  205.     /**
  206.      * Keeps the nesting level of defined ResultVariables.
  207.      *
  208.      * @var int
  209.      */
  210.     private $nestingLevel = 0;
  212.     /**
  213.      * Any additional custom tree walkers that modify the AST.
  214.      *
  215.      * @psalm-var list<class-string<TreeWalker>>
  216.      */
  217.     private $customTreeWalkers = [];
  219.     /**
  220.      * The custom last tree walker, if any, that is responsible for producing the output.
  221.      *
  222.      * @var class-string<SqlWalker>|null
  223.      */
  224.     private $customOutputWalker;
  226.     /** @psalm-var array<string, AST\SelectExpression> */
  227.     private $identVariableExpressions = [];
  229.     /**
  230.      * Creates a new query parser object.
  231.      *
  232.      * @param Query $query The Query to parse.
  233.      */
  234.     public function __construct(Query $query)
  235.     {
  236.         $this->query        = $query;
  237.         $this->em           = $query->getEntityManager();
  238.         $this->lexer        = new Lexer((string) $query->getDQL());
  239.         $this->parserResult = new ParserResult();
  240.     }
  242.     /**
  243.      * Sets a custom tree walker that produces output.
  244.      * This tree walker will be run last over the AST, after any other walkers.
  245.      *
  246.      * @param string $className
  247.      * @psalm-param class-string<SqlWalker> $className
  248.      *
  249.      * @return void
  250.      */
  251.     public function setCustomOutputTreeWalker($className)
  252.     {
  253.         $this->customOutputWalker = $className;
  254.     }
  256.     /**
  257.      * Adds a custom tree walker for modifying the AST.
  258.      *
  259.      * @param string $className
  260.      * @psalm-param class-string<TreeWalker> $className
  261.      *
  262.      * @return void
  263.      */
  264.     public function addCustomTreeWalker($className)
  265.     {
  266.         $this->customTreeWalkers[] = $className;
  267.     }
  269.     /**
  270.      * Gets the lexer used by the parser.
  271.      *
  272.      * @return Lexer
  273.      */
  274.     public function getLexer()
  275.     {
  276.         return $this->lexer;
  277.     }
  279.     /**
  280.      * Gets the ParserResult that is being filled with information during parsing.
  281.      *
  282.      * @return ParserResult
  283.      */
  284.     public function getParserResult()
  285.     {
  286.         return $this->parserResult;
  287.     }
  289.     /**
  290.      * Gets the EntityManager used by the parser.
  291.      *
  292.      * @return EntityManagerInterface
  293.      */
  294.     public function getEntityManager()
  295.     {
  296.         return $this->em;
  297.     }
  299.     /**
  300.      * Parses and builds AST for the given Query.
  301.      *
  302.      * @return SelectStatement|UpdateStatement|DeleteStatement
  303.      */
  304.     public function getAST()
  305.     {
  306.         // Parse & build AST
  307.         $AST = $this->QueryLanguage();
  309.         // Process any deferred validations of some nodes in the AST.
  310.         // This also allows post-processing of the AST for modification purposes.
  311.         $this->processDeferredIdentificationVariables();
  313.         if ($this->deferredPartialObjectExpressions) {
  314.             $this->processDeferredPartialObjectExpressions();
  315.         }
  317.         if ($this->deferredPathExpressions) {
  318.             $this->processDeferredPathExpressions();
  319.         }
  321.         if ($this->deferredResultVariables) {
  322.             $this->processDeferredResultVariables();
  323.         }
  325.         if ($this->deferredNewObjectExpressions) {
  326.             $this->processDeferredNewObjectExpressions($AST);
  327.         }
  329.         $this->processRootEntityAliasSelected();
  331.         // TODO: Is there a way to remove this? It may impact the mixed hydration resultset a lot!
  332.         $this->fixIdentificationVariableOrder($AST);
  334.         return $AST;
  335.     }
  337.     /**
  338.      * Attempts to match the given token with the current lookahead token.
  339.      *
  340.      * If they match, updates the lookahead token; otherwise raises a syntax
  341.      * error.
  342.      *
  343.      * @param int $token The token type.
  344.      *
  345.      * @return void
  346.      *
  347.      * @throws QueryException If the tokens don't match.
  348.      */
  349.     public function match($token)
  350.     {
  351.         $lookaheadType = $this->lexer->lookahead['type'] ?? null;
  353.         // Short-circuit on first condition, usually types match
  354.         if ($lookaheadType === $token) {
  355.             $this->lexer->moveNext();
  357.             return;
  358.         }
  360.         // If parameter is not identifier (1-99) must be exact match
  361.         if ($token < Lexer::T_IDENTIFIER) {
  362.             $this->syntaxError($this->lexer->getLiteral($token));
  363.         }
  365.         // If parameter is keyword (200+) must be exact match
  366.         if ($token > Lexer::T_IDENTIFIER) {
  367.             $this->syntaxError($this->lexer->getLiteral($token));
  368.         }
  370.         // If parameter is T_IDENTIFIER, then matches T_IDENTIFIER (100) and keywords (200+)
  371.         if ($token === Lexer::T_IDENTIFIER && $lookaheadType < Lexer::T_IDENTIFIER) {
  372.             $this->syntaxError($this->lexer->getLiteral($token));
  373.         }
  375.         $this->lexer->moveNext();
  376.     }
  378.     /**
  379.      * Frees this parser, enabling it to be reused.
  380.      *
  381.      * @param bool $deep     Whether to clean peek and reset errors.
  382.      * @param int  $position Position to reset.
  383.      *
  384.      * @return void
  385.      */
  386.     public function free($deep = false, $position = 0)
  387.     {
  388.         // WARNING! Use this method with care. It resets the scanner!
  389.         $this->lexer->resetPosition($position);
  391.         // Deep = true cleans peek and also any previously defined errors
  392.         if ($deep) {
  393.             $this->lexer->resetPeek();
  394.         }
  396.         $this->lexer->token     = null;
  397.         $this->lexer->lookahead = null;
  398.     }
  400.     /**
  401.      * Parses a query string.
  402.      *
  403.      * @return ParserResult
  404.      */
  405.     public function parse()
  406.     {
  407.         $AST = $this->getAST();
  409.         $customWalkers = $this->query->getHint(Query::HINT_CUSTOM_TREE_WALKERS);
  410.         if ($customWalkers !== false) {
  411.             $this->customTreeWalkers = $customWalkers;
  412.         }
  414.         $customOutputWalker = $this->query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER);
  415.         if ($customOutputWalker !== false) {
  416.             $this->customOutputWalker = $customOutputWalker;
  417.         }
  419.         // Run any custom tree walkers over the AST
  420.         if ($this->customTreeWalkers) {
  421.             $treeWalkerChain = new TreeWalkerChain($this->query, $this->parserResult, $this->queryComponents);
  423.             foreach ($this->customTreeWalkers as $walker) {
  424.                 $treeWalkerChain->addTreeWalker($walker);
  425.             }
  427.             switch (true) {
  428.                 case $AST instanceof AST\UpdateStatement:
  429.                     $treeWalkerChain->walkUpdateStatement($AST);
  430.                     break;
  432.                 case $AST instanceof AST\DeleteStatement:
  433.                     $treeWalkerChain->walkDeleteStatement($AST);
  434.                     break;
  436.                 case $AST instanceof AST\SelectStatement:
  437.                 default:
  438.                     $treeWalkerChain->walkSelectStatement($AST);
  439.             }
  441.             $this->queryComponents = $treeWalkerChain->getQueryComponents();
  442.         }
  444.         $outputWalkerClass = $this->customOutputWalker ?: SqlWalker::class;
  445.         $outputWalker      = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
  447.         // Assign an SQL executor to the parser result
  448.         $this->parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
  450.         return $this->parserResult;
  451.     }
  453.     /**
  454.      * Fixes order of identification variables.
  455.      *
  456.      * They have to appear in the select clause in the same order as the
  457.      * declarations (from ... x join ... y join ... z ...) appear in the query
  458.      * as the hydration process relies on that order for proper operation.
  459.      *
  460.      * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST
  461.      */
  462.     private function fixIdentificationVariableOrder(Node $AST): void
  463.     {
  464.         if (count($this->identVariableExpressions) <= 1) {
  465.             return;
  466.         }
  468.         assert($AST instanceof AST\SelectStatement);
  470.         foreach ($this->queryComponents as $dqlAlias => $qComp) {
  471.             if (! isset($this->identVariableExpressions[$dqlAlias])) {
  472.                 continue;
  473.             }
  475.             $expr = $this->identVariableExpressions[$dqlAlias];
  476.             $key  = array_search($expr, $AST->selectClause->selectExpressions, true);
  478.             unset($AST->selectClause->selectExpressions[$key]);
  480.             $AST->selectClause->selectExpressions[] = $expr;
  481.         }
  482.     }
  484.     /**
  485.      * Generates a new syntax error.
  486.      *
  487.      * @param string       $expected Expected string.
  488.      * @param mixed[]|null $token    Got token.
  489.      * @psalm-param Token|null $token
  490.      *
  491.      * @return void
  492.      * @psalm-return no-return
  493.      *
  494.      * @throws QueryException
  495.      */
  496.     public function syntaxError($expected = '', $token = null)
  497.     {
  498.         if ($token === null) {
  499.             $token = $this->lexer->lookahead;
  500.         }
  502.         $tokenPos = $token['position'] ?? '-1';
  504.         $message  = sprintf('line 0, col %d: Error: ', $tokenPos);
  505.         $message .= $expected !== '' ? sprintf('Expected %s, got ', $expected) : 'Unexpected ';
  506.         $message .= $this->lexer->lookahead === null ? 'end of string.' : sprintf("'%s'", $token['value']);
  508.         throw QueryException::syntaxError($message, QueryException::dqlError($this->query->getDQL() ?? ''));
  509.     }
  511.     /**
  512.      * Generates a new semantical error.
  513.      *
  514.      * @param string       $message Optional message.
  515.      * @param mixed[]|null $token   Optional token.
  516.      * @psalm-param Token|null $token
  517.      *
  518.      * @return void
  519.      * @psalm-return no-return
  520.      *
  521.      * @throws QueryException
  522.      */
  523.     public function semanticalError($message = '', $token = null)
  524.     {
  525.         if ($token === null) {
  526.             $token = $this->lexer->lookahead ?? ['position' => 0];
  527.         }
  529.         // Minimum exposed chars ahead of token
  530.         $distance = 12;
  532.         // Find a position of a final word to display in error string
  533.         $dql    = $this->query->getDQL();
  534.         $length = strlen($dql);
  535.         $pos    = $token['position'] + $distance;
  536.         $pos    = strpos($dql, ' ', $length > $pos ? $pos : $length);
  537.         $length = $pos !== false ? $pos - $token['position'] : $distance;
  539.         $tokenPos = $token['position'] > 0 ? $token['position'] : '-1';
  540.         $tokenStr = substr($dql, $token['position'], $length);
  542.         // Building informative message
  543.         $message = 'line 0, col ' . $tokenPos . " near '" . $tokenStr . "': Error: " . $message;
  545.         throw QueryException::semanticalError($message, QueryException::dqlError($this->query->getDQL()));
  546.     }
  548.     /**
  549.      * Peeks beyond the matched closing parenthesis and returns the first token after that one.
  550.      *
  551.      * @param bool $resetPeek Reset peek after finding the closing parenthesis.
  552.      *
  553.      * @return mixed[]
  554.      * @psalm-return array{value: string, type: int|null|string, position: int}|null
  555.      */
  556.     private function peekBeyondClosingParenthesis(bool $resetPeek = true): ?array
  557.     {
  558.         $token        = $this->lexer->peek();
  559.         $numUnmatched = 1;
  561.         while ($numUnmatched > 0 && $token !== null) {
  562.             switch ($token['type']) {
  563.                 case Lexer::T_OPEN_PARENTHESIS:
  564.                     ++$numUnmatched;
  565.                     break;
  567.                 case Lexer::T_CLOSE_PARENTHESIS:
  568.                     --$numUnmatched;
  569.                     break;
  571.                 default:
  572.                     // Do nothing
  573.             }
  575.             $token = $this->lexer->peek();
  576.         }
  578.         if ($resetPeek) {
  579.             $this->lexer->resetPeek();
  580.         }
  582.         return $token;
  583.     }
  585.     /**
  586.      * Checks if the given token indicates a mathematical operator.
  587.      *
  588.      * @psalm-param Token|null $token
  589.      */
  590.     private function isMathOperator(?array $token): bool
  591.     {
  592.         return $token !== null && in_array($token['type'], [Lexer::T_PLUS, Lexer::T_MINUS, Lexer::T_DIVIDE, Lexer::T_MULTIPLY], true);
  593.     }
  595.     /**
  596.      * Checks if the next-next (after lookahead) token starts a function.
  597.      *
  598.      * @return bool TRUE if the next-next tokens start a function, FALSE otherwise.
  599.      */
  600.     private function isFunction(): bool
  601.     {
  602.         $lookaheadType = $this->lexer->lookahead['type'];
  603.         $peek          = $this->lexer->peek();
  605.         $this->lexer->resetPeek();
  607.         return $lookaheadType >= Lexer::T_IDENTIFIER && $peek !== null && $peek['type'] === Lexer::T_OPEN_PARENTHESIS;
  608.     }
  610.     /**
  611.      * Checks whether the given token type indicates an aggregate function.
  612.      *
  613.      * @psalm-param Lexer::T_* $tokenType
  614.      *
  615.      * @return bool TRUE if the token type is an aggregate function, FALSE otherwise.
  616.      */
  617.     private function isAggregateFunction(int $tokenType): bool
  618.     {
  619.         return in_array(
  620.             $tokenType,
  621.             [Lexer::T_AVG, Lexer::T_MIN, Lexer::T_MAX, Lexer::T_SUM, Lexer::T_COUNT],
  622.             true
  623.         );
  624.     }
  626.     /**
  627.      * Checks whether the current lookahead token of the lexer has the type T_ALL, T_ANY or T_SOME.
  628.      */
  629.     private function isNextAllAnySome(): bool
  630.     {
  631.         return in_array(
  632.             $this->lexer->lookahead['type'],
  633.             [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME],
  634.             true
  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 (! str_contains($className, '\\') && ! class_exists($className) && str_contains($fromClassName, '\\')) {
  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->getMetadataForDqlAlias($expr->identificationVariable);
  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.             $class = $this->getMetadataForDqlAlias($pathExpression->identificationVariable);
  810.             $field = $pathExpression->field;
  811.             if ($field === null) {
  812.                 $field = $pathExpression->field = $class->identifier[0];
  813.             }
  815.             // Check if field or association exists
  816.             if (! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
  817.                 $this->semanticalError(
  818.                     'Class ' . $class->name . ' has no field or association named ' . $field,
  819.                     $deferredItem['token']
  820.                 );
  821.             }
  823.             $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
  825.             if (isset($class->associationMappings[$field])) {
  826.                 $assoc = $class->associationMappings[$field];
  828.                 $fieldType = $assoc['type'] & ClassMetadata::TO_ONE
  829.                     ? AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  830.                     : AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
  831.             }
  833.             // Validate if PathExpression is one of the expected types
  834.             $expectedType = $pathExpression->expectedType;
  836.             if (! ($expectedType & $fieldType)) {
  837.                 // We need to recognize which was expected type(s)
  838.                 $expectedStringTypes = [];
  840.                 // Validate state field type
  841.                 if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
  842.                     $expectedStringTypes[] = 'StateFieldPathExpression';
  843.                 }
  845.                 // Validate single valued association (*-to-one)
  846.                 if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
  847.                     $expectedStringTypes[] = 'SingleValuedAssociationField';
  848.                 }
  850.                 // Validate single valued association (*-to-many)
  851.                 if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
  852.                     $expectedStringTypes[] = 'CollectionValuedAssociationField';
  853.                 }
  855.                 // Build the error message
  856.                 $semanticalError  = 'Invalid PathExpression. ';
  857.                 $semanticalError .= count($expectedStringTypes) === 1
  858.                     ? 'Must be a ' . $expectedStringTypes[0] . '.'
  859.                     : implode(' or ', $expectedStringTypes) . ' expected.';
  861.                 $this->semanticalError($semanticalError, $deferredItem['token']);
  862.             }
  864.             // We need to force the type in PathExpression
  865.             $pathExpression->type = $fieldType;
  866.         }
  867.     }
  869.     private function processRootEntityAliasSelected(): void
  870.     {
  871.         if (! count($this->identVariableExpressions)) {
  872.             return;
  873.         }
  875.         foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
  876.             if (isset($this->queryComponents[$dqlAlias]) && ! isset($this->queryComponents[$dqlAlias]['parent'])) {
  877.                 return;
  878.             }
  879.         }
  881.         $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');
  882.     }
  884.     /**
  885.      * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
  886.      *
  887.      * @return SelectStatement|UpdateStatement|DeleteStatement
  888.      */
  889.     public function QueryLanguage()
  890.     {
  891.         $statement = null;
  893.         $this->lexer->moveNext();
  895.         switch ($this->lexer->lookahead['type'] ?? null) {
  896.             case Lexer::T_SELECT:
  897.                 $statement = $this->SelectStatement();
  898.                 break;
  900.             case Lexer::T_UPDATE:
  901.                 $statement = $this->UpdateStatement();
  902.                 break;
  904.             case Lexer::T_DELETE:
  905.                 $statement = $this->DeleteStatement();
  906.                 break;
  908.             default:
  909.                 $this->syntaxError('SELECT, UPDATE or DELETE');
  910.                 break;
  911.         }
  913.         // Check for end of string
  914.         if ($this->lexer->lookahead !== null) {
  915.             $this->syntaxError('end of string');
  916.         }
  918.         return $statement;
  919.     }
  921.     /**
  922.      * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  923.      *
  924.      * @return SelectStatement
  925.      */
  926.     public function SelectStatement()
  927.     {
  928.         $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());
  930.         $selectStatement->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  931.         $selectStatement->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  932.         $selectStatement->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  933.         $selectStatement->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  935.         return $selectStatement;
  936.     }
  938.     /**
  939.      * UpdateStatement ::= UpdateClause [WhereClause]
  940.      *
  941.      * @return UpdateStatement
  942.      */
  943.     public function UpdateStatement()
  944.     {
  945.         $updateStatement = new AST\UpdateStatement($this->UpdateClause());
  947.         $updateStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  949.         return $updateStatement;
  950.     }
  952.     /**
  953.      * DeleteStatement ::= DeleteClause [WhereClause]
  954.      *
  955.      * @return DeleteStatement
  956.      */
  957.     public function DeleteStatement()
  958.     {
  959.         $deleteStatement = new AST\DeleteStatement($this->DeleteClause());
  961.         $deleteStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  963.         return $deleteStatement;
  964.     }
  966.     /**
  967.      * IdentificationVariable ::= identifier
  968.      *
  969.      * @return string
  970.      */
  971.     public function IdentificationVariable()
  972.     {
  973.         $this->match(Lexer::T_IDENTIFIER);
  975.         $identVariable = $this->lexer->token['value'];
  977.         $this->deferredIdentificationVariables[] = [
  978.             'expression'   => $identVariable,
  979.             'nestingLevel' => $this->nestingLevel,
  980.             'token'        => $this->lexer->token,
  981.         ];
  983.         return $identVariable;
  984.     }
  986.     /**
  987.      * AliasIdentificationVariable = identifier
  988.      *
  989.      * @return string
  990.      */
  991.     public function AliasIdentificationVariable()
  992.     {
  993.         $this->match(Lexer::T_IDENTIFIER);
  995.         $aliasIdentVariable = $this->lexer->token['value'];
  996.         $exists             = isset($this->queryComponents[$aliasIdentVariable]);
  998.         if ($exists) {
  999.             $this->semanticalError(
  1000.                 sprintf("'%s' is already defined.", $aliasIdentVariable),
  1001.                 $this->lexer->token
  1002.             );
  1003.         }
  1005.         return $aliasIdentVariable;
  1006.     }
  1008.     /**
  1009.      * AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
  1010.      *
  1011.      * @return string
  1012.      */
  1013.     public function AbstractSchemaName()
  1014.     {
  1015.         if ($this->lexer->isNextToken(Lexer::T_FULLY_QUALIFIED_NAME)) {
  1016.             $this->match(Lexer::T_FULLY_QUALIFIED_NAME);
  1018.             return $this->lexer->token['value'];
  1019.         }
  1021.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  1022.             $this->match(Lexer::T_IDENTIFIER);
  1024.             return $this->lexer->token['value'];
  1025.         }
  1027.         $this->match(Lexer::T_ALIASED_NAME);
  1029.         Deprecation::trigger(
  1030.             'doctrine/orm',
  1031.             'https://github.com/doctrine/orm/issues/8818',
  1032.             'Short namespace aliases such as "%s" are deprecated and will be removed in Doctrine ORM 3.0.',
  1033.             $this->lexer->token['value']
  1034.         );
  1036.         [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token['value']);
  1038.         return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  1039.     }
  1041.     /**
  1042.      * Validates an AbstractSchemaName, making sure the class exists.
  1043.      *
  1044.      * @param string $schemaName The name to validate.
  1045.      *
  1046.      * @throws QueryException if the name does not exist.
  1047.      */
  1048.     private function validateAbstractSchemaName(string $schemaName): void
  1049.     {
  1050.         if (! (class_exists($schemaName, true) || interface_exists($schemaName, true))) {
  1051.             $this->semanticalError(
  1052.                 sprintf("Class '%s' is not defined.", $schemaName),
  1053.                 $this->lexer->token
  1054.             );
  1055.         }
  1056.     }
  1058.     /**
  1059.      * AliasResultVariable ::= identifier
  1060.      *
  1061.      * @return string
  1062.      */
  1063.     public function AliasResultVariable()
  1064.     {
  1065.         $this->match(Lexer::T_IDENTIFIER);
  1067.         $resultVariable = $this->lexer->token['value'];
  1068.         $exists         = isset($this->queryComponents[$resultVariable]);
  1070.         if ($exists) {
  1071.             $this->semanticalError(
  1072.                 sprintf("'%s' is already defined.", $resultVariable),
  1073.                 $this->lexer->token
  1074.             );
  1075.         }
  1077.         return $resultVariable;
  1078.     }
  1080.     /**
  1081.      * ResultVariable ::= identifier
  1082.      *
  1083.      * @return string
  1084.      */
  1085.     public function ResultVariable()
  1086.     {
  1087.         $this->match(Lexer::T_IDENTIFIER);
  1089.         $resultVariable = $this->lexer->token['value'];
  1091.         // Defer ResultVariable validation
  1092.         $this->deferredResultVariables[] = [
  1093.             'expression'   => $resultVariable,
  1094.             'nestingLevel' => $this->nestingLevel,
  1095.             'token'        => $this->lexer->token,
  1096.         ];
  1098.         return $resultVariable;
  1099.     }
  1101.     /**
  1102.      * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
  1103.      *
  1104.      * @return JoinAssociationPathExpression
  1105.      */
  1106.     public function JoinAssociationPathExpression()
  1107.     {
  1108.         $identVariable = $this->IdentificationVariable();
  1110.         if (! isset($this->queryComponents[$identVariable])) {
  1111.             $this->semanticalError(
  1112.                 'Identification Variable ' . $identVariable . ' used in join path expression but was not defined before.'
  1113.             );
  1114.         }
  1116.         $this->match(Lexer::T_DOT);
  1117.         $this->match(Lexer::T_IDENTIFIER);
  1119.         assert($this->lexer->token !== null);
  1120.         $field = $this->lexer->token['value'];
  1122.         // Validate association field
  1123.         $class = $this->getMetadataForDqlAlias($identVariable);
  1125.         if (! $class->hasAssociation($field)) {
  1126.             $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
  1127.         }
  1129.         return new AST\JoinAssociationPathExpression($identVariable, $field);
  1130.     }
  1132.     /**
  1133.      * Parses an arbitrary path expression and defers semantical validation
  1134.      * based on expected types.
  1135.      *
  1136.      * PathExpression ::= IdentificationVariable {"." identifier}*
  1137.      *
  1138.      * @param int $expectedTypes
  1139.      * @psalm-param int-mask-of<PathExpression::TYPE_*> $expectedTypes
  1140.      *
  1141.      * @return PathExpression
  1142.      */
  1143.     public function PathExpression($expectedTypes)
  1144.     {
  1145.         $identVariable = $this->IdentificationVariable();
  1146.         $field         = null;
  1148.         if ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1149.             $this->match(Lexer::T_DOT);
  1150.             $this->match(Lexer::T_IDENTIFIER);
  1152.             $field = $this->lexer->token['value'];
  1154.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1155.                 $this->match(Lexer::T_DOT);
  1156.                 $this->match(Lexer::T_IDENTIFIER);
  1157.                 $field .= '.' . $this->lexer->token['value'];
  1158.             }
  1159.         }
  1161.         // Creating AST node
  1162.         $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);
  1164.         // Defer PathExpression validation if requested to be deferred
  1165.         $this->deferredPathExpressions[] = [
  1166.             'expression'   => $pathExpr,
  1167.             'nestingLevel' => $this->nestingLevel,
  1168.             'token'        => $this->lexer->token,
  1169.         ];
  1171.         return $pathExpr;
  1172.     }
  1174.     /**
  1175.      * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  1176.      *
  1177.      * @return PathExpression
  1178.      */
  1179.     public function AssociationPathExpression()
  1180.     {
  1181.         return $this->PathExpression(
  1182.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |
  1183.             AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION
  1184.         );
  1185.     }
  1187.     /**
  1188.      * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  1189.      *
  1190.      * @return PathExpression
  1191.      */
  1192.     public function SingleValuedPathExpression()
  1193.     {
  1194.         return $this->PathExpression(
  1195.             AST\PathExpression::TYPE_STATE_FIELD |
  1196.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  1197.         );
  1198.     }
  1200.     /**
  1201.      * StateFieldPathExpression ::= IdentificationVariable "." StateField
  1202.      *
  1203.      * @return PathExpression
  1204.      */
  1205.     public function StateFieldPathExpression()
  1206.     {
  1207.         return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);
  1208.     }
  1210.     /**
  1211.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  1212.      *
  1213.      * @return PathExpression
  1214.      */
  1215.     public function SingleValuedAssociationPathExpression()
  1216.     {
  1217.         return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);
  1218.     }
  1220.     /**
  1221.      * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  1222.      *
  1223.      * @return PathExpression
  1224.      */
  1225.     public function CollectionValuedPathExpression()
  1226.     {
  1227.         return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);
  1228.     }
  1230.     /**
  1231.      * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
  1232.      *
  1233.      * @return SelectClause
  1234.      */
  1235.     public function SelectClause()
  1236.     {
  1237.         $isDistinct = false;
  1238.         $this->match(Lexer::T_SELECT);
  1240.         // Check for DISTINCT
  1241.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1242.             $this->match(Lexer::T_DISTINCT);
  1244.             $isDistinct = true;
  1245.         }
  1247.         // Process SelectExpressions (1..N)
  1248.         $selectExpressions   = [];
  1249.         $selectExpressions[] = $this->SelectExpression();
  1251.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1252.             $this->match(Lexer::T_COMMA);
  1254.             $selectExpressions[] = $this->SelectExpression();
  1255.         }
  1257.         return new AST\SelectClause($selectExpressions, $isDistinct);
  1258.     }
  1260.     /**
  1261.      * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
  1262.      *
  1263.      * @return SimpleSelectClause
  1264.      */
  1265.     public function SimpleSelectClause()
  1266.     {
  1267.         $isDistinct = false;
  1268.         $this->match(Lexer::T_SELECT);
  1270.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1271.             $this->match(Lexer::T_DISTINCT);
  1273.             $isDistinct = true;
  1274.         }
  1276.         return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);
  1277.     }
  1279.     /**
  1280.      * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*
  1281.      *
  1282.      * @return UpdateClause
  1283.      */
  1284.     public function UpdateClause()
  1285.     {
  1286.         $this->match(Lexer::T_UPDATE);
  1287.         assert($this->lexer->lookahead !== null);
  1289.         $token              = $this->lexer->lookahead;
  1290.         $abstractSchemaName = $this->AbstractSchemaName();
  1292.         $this->validateAbstractSchemaName($abstractSchemaName);
  1294.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1295.             $this->match(Lexer::T_AS);
  1296.         }
  1298.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1300.         $class = $this->em->getClassMetadata($abstractSchemaName);
  1302.         // Building queryComponent
  1303.         $queryComponent = [
  1304.             'metadata'     => $class,
  1305.             'parent'       => null,
  1306.             'relation'     => null,
  1307.             'map'          => null,
  1308.             'nestingLevel' => $this->nestingLevel,
  1309.             'token'        => $token,
  1310.         ];
  1312.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1314.         $this->match(Lexer::T_SET);
  1316.         $updateItems   = [];
  1317.         $updateItems[] = $this->UpdateItem();
  1319.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1320.             $this->match(Lexer::T_COMMA);
  1322.             $updateItems[] = $this->UpdateItem();
  1323.         }
  1325.         $updateClause                              = new AST\UpdateClause($abstractSchemaName, $updateItems);
  1326.         $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1328.         return $updateClause;
  1329.     }
  1331.     /**
  1332.      * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable
  1333.      *
  1334.      * @return DeleteClause
  1335.      */
  1336.     public function DeleteClause()
  1337.     {
  1338.         $this->match(Lexer::T_DELETE);
  1340.         if ($this->lexer->isNextToken(Lexer::T_FROM)) {
  1341.             $this->match(Lexer::T_FROM);
  1342.         }
  1344.         assert($this->lexer->lookahead !== null);
  1345.         $token              = $this->lexer->lookahead;
  1346.         $abstractSchemaName = $this->AbstractSchemaName();
  1348.         $this->validateAbstractSchemaName($abstractSchemaName);
  1350.         $deleteClause = new AST\DeleteClause($abstractSchemaName);
  1352.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1353.             $this->match(Lexer::T_AS);
  1354.         }
  1356.         $aliasIdentificationVariable = $this->lexer->isNextToken(Lexer::T_IDENTIFIER)
  1357.             ? $this->AliasIdentificationVariable()
  1358.             : 'alias_should_have_been_set';
  1360.         $deleteClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1361.         $class                                     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1363.         // Building queryComponent
  1364.         $queryComponent = [
  1365.             'metadata'     => $class,
  1366.             'parent'       => null,
  1367.             'relation'     => null,
  1368.             'map'          => null,
  1369.             'nestingLevel' => $this->nestingLevel,
  1370.             'token'        => $token,
  1371.         ];
  1373.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1375.         return $deleteClause;
  1376.     }
  1378.     /**
  1379.      * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}*
  1380.      *
  1381.      * @return FromClause
  1382.      */
  1383.     public function FromClause()
  1384.     {
  1385.         $this->match(Lexer::T_FROM);
  1387.         $identificationVariableDeclarations   = [];
  1388.         $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1390.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1391.             $this->match(Lexer::T_COMMA);
  1393.             $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1394.         }
  1396.         return new AST\FromClause($identificationVariableDeclarations);
  1397.     }
  1399.     /**
  1400.      * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
  1401.      *
  1402.      * @return SubselectFromClause
  1403.      */
  1404.     public function SubselectFromClause()
  1405.     {
  1406.         $this->match(Lexer::T_FROM);
  1408.         $identificationVariables   = [];
  1409.         $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1411.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1412.             $this->match(Lexer::T_COMMA);
  1414.             $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1415.         }
  1417.         return new AST\SubselectFromClause($identificationVariables);
  1418.     }
  1420.     /**
  1421.      * WhereClause ::= "WHERE" ConditionalExpression
  1422.      *
  1423.      * @return WhereClause
  1424.      */
  1425.     public function WhereClause()
  1426.     {
  1427.         $this->match(Lexer::T_WHERE);
  1429.         return new AST\WhereClause($this->ConditionalExpression());
  1430.     }
  1432.     /**
  1433.      * HavingClause ::= "HAVING" ConditionalExpression
  1434.      *
  1435.      * @return HavingClause
  1436.      */
  1437.     public function HavingClause()
  1438.     {
  1439.         $this->match(Lexer::T_HAVING);
  1441.         return new AST\HavingClause($this->ConditionalExpression());
  1442.     }
  1444.     /**
  1445.      * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
  1446.      *
  1447.      * @return GroupByClause
  1448.      */
  1449.     public function GroupByClause()
  1450.     {
  1451.         $this->match(Lexer::T_GROUP);
  1452.         $this->match(Lexer::T_BY);
  1454.         $groupByItems = [$this->GroupByItem()];
  1456.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1457.             $this->match(Lexer::T_COMMA);
  1459.             $groupByItems[] = $this->GroupByItem();
  1460.         }
  1462.         return new AST\GroupByClause($groupByItems);
  1463.     }
  1465.     /**
  1466.      * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
  1467.      *
  1468.      * @return OrderByClause
  1469.      */
  1470.     public function OrderByClause()
  1471.     {
  1472.         $this->match(Lexer::T_ORDER);
  1473.         $this->match(Lexer::T_BY);
  1475.         $orderByItems   = [];
  1476.         $orderByItems[] = $this->OrderByItem();
  1478.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1479.             $this->match(Lexer::T_COMMA);
  1481.             $orderByItems[] = $this->OrderByItem();
  1482.         }
  1484.         return new AST\OrderByClause($orderByItems);
  1485.     }
  1487.     /**
  1488.      * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  1489.      *
  1490.      * @return Subselect
  1491.      */
  1492.     public function Subselect()
  1493.     {
  1494.         // Increase query nesting level
  1495.         $this->nestingLevel++;
  1497.         $subselect = new AST\Subselect($this->SimpleSelectClause(), $this->SubselectFromClause());
  1499.         $subselect->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  1500.         $subselect->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  1501.         $subselect->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  1502.         $subselect->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  1504.         // Decrease query nesting level
  1505.         $this->nestingLevel--;
  1507.         return $subselect;
  1508.     }
  1510.     /**
  1511.      * UpdateItem ::= SingleValuedPathExpression "=" NewValue
  1512.      *
  1513.      * @return UpdateItem
  1514.      */
  1515.     public function UpdateItem()
  1516.     {
  1517.         $pathExpr = $this->SingleValuedPathExpression();
  1519.         $this->match(Lexer::T_EQUALS);
  1521.         return new AST\UpdateItem($pathExpr, $this->NewValue());
  1522.     }
  1524.     /**
  1525.      * GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression
  1526.      *
  1527.      * @return string|PathExpression
  1528.      */
  1529.     public function GroupByItem()
  1530.     {
  1531.         // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  1532.         $glimpse = $this->lexer->glimpse();
  1534.         if ($glimpse !== null && $glimpse['type'] === Lexer::T_DOT) {
  1535.             return $this->SingleValuedPathExpression();
  1536.         }
  1538.         // Still need to decide between IdentificationVariable or ResultVariable
  1539.         $lookaheadValue = $this->lexer->lookahead['value'];
  1541.         if (! isset($this->queryComponents[$lookaheadValue])) {
  1542.             $this->semanticalError('Cannot group by undefined identification or result variable.');
  1543.         }
  1545.         return isset($this->queryComponents[$lookaheadValue]['metadata'])
  1546.             ? $this->IdentificationVariable()
  1547.             : $this->ResultVariable();
  1548.     }
  1550.     /**
  1551.      * OrderByItem ::= (
  1552.      *      SimpleArithmeticExpression | SingleValuedPathExpression | CaseExpression |
  1553.      *      ScalarExpression | ResultVariable | FunctionDeclaration
  1554.      * ) ["ASC" | "DESC"]
  1555.      *
  1556.      * @return OrderByItem
  1557.      */
  1558.     public function OrderByItem()
  1559.     {
  1560.         $this->lexer->peek(); // lookahead => '.'
  1561.         $this->lexer->peek(); // lookahead => token after '.'
  1563.         $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1565.         $this->lexer->resetPeek();
  1567.         $glimpse = $this->lexer->glimpse();
  1569.         switch (true) {
  1570.             case $this->isMathOperator($peek):
  1571.                 $expr = $this->SimpleArithmeticExpression();
  1572.                 break;
  1574.             case $glimpse !== null && $glimpse['type'] === Lexer::T_DOT:
  1575.                 $expr = $this->SingleValuedPathExpression();
  1576.                 break;
  1578.             case $this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  1579.                 $expr = $this->ScalarExpression();
  1580.                 break;
  1582.             case $this->lexer->lookahead['type'] === Lexer::T_CASE:
  1583.                 $expr = $this->CaseExpression();
  1584.                 break;
  1586.             case $this->isFunction():
  1587.                 $expr = $this->FunctionDeclaration();
  1588.                 break;
  1590.             default:
  1591.                 $expr = $this->ResultVariable();
  1592.                 break;
  1593.         }
  1595.         $type = 'ASC';
  1596.         $item = new AST\OrderByItem($expr);
  1598.         switch (true) {
  1599.             case $this->lexer->isNextToken(Lexer::T_DESC):
  1600.                 $this->match(Lexer::T_DESC);
  1601.                 $type = 'DESC';
  1602.                 break;
  1604.             case $this->lexer->isNextToken(Lexer::T_ASC):
  1605.                 $this->match(Lexer::T_ASC);
  1606.                 break;
  1608.             default:
  1609.                 // Do nothing
  1610.         }
  1612.         $item->type = $type;
  1614.         return $item;
  1615.     }
  1617.     /**
  1618.      * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
  1619.      *      EnumPrimary | SimpleEntityExpression | "NULL"
  1620.      *
  1621.      * NOTE: Since it is not possible to correctly recognize individual types, here is the full
  1622.      * grammar that needs to be supported:
  1623.      *
  1624.      * NewValue ::= SimpleArithmeticExpression | "NULL"
  1625.      *
  1626.      * SimpleArithmeticExpression covers all *Primary grammar rules and also SimpleEntityExpression
  1627.      *
  1628.      * @return AST\ArithmeticExpression|AST\InputParameter|null
  1629.      */
  1630.     public function NewValue()
  1631.     {
  1632.         if ($this->lexer->isNextToken(Lexer::T_NULL)) {
  1633.             $this->match(Lexer::T_NULL);
  1635.             return null;
  1636.         }
  1638.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  1639.             $this->match(Lexer::T_INPUT_PARAMETER);
  1641.             return new AST\InputParameter($this->lexer->token['value']);
  1642.         }
  1644.         return $this->ArithmeticExpression();
  1645.     }
  1647.     /**
  1648.      * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*
  1649.      *
  1650.      * @return IdentificationVariableDeclaration
  1651.      */
  1652.     public function IdentificationVariableDeclaration()
  1653.     {
  1654.         $joins                    = [];
  1655.         $rangeVariableDeclaration = $this->RangeVariableDeclaration();
  1656.         $indexBy                  = $this->lexer->isNextToken(Lexer::T_INDEX)
  1657.             ? $this->IndexBy()
  1658.             : null;
  1660.         $rangeVariableDeclaration->isRoot = true;
  1662.         while (
  1663.             $this->lexer->isNextToken(Lexer::T_LEFT) ||
  1664.             $this->lexer->isNextToken(Lexer::T_INNER) ||
  1665.             $this->lexer->isNextToken(Lexer::T_JOIN)
  1666.         ) {
  1667.             $joins[] = $this->Join();
  1668.         }
  1670.         return new AST\IdentificationVariableDeclaration(
  1671.             $rangeVariableDeclaration,
  1672.             $indexBy,
  1673.             $joins
  1674.         );
  1675.     }
  1677.     /**
  1678.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration
  1679.      *
  1680.      * {Internal note: WARNING: Solution is harder than a bare implementation.
  1681.      * Desired EBNF support:
  1682.      *
  1683.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
  1684.      *
  1685.      * It demands that entire SQL generation to become programmatical. This is
  1686.      * needed because association based subselect requires "WHERE" conditional
  1687.      * expressions to be injected, but there is no scope to do that. Only scope
  1688.      * accessible is "FROM", prohibiting an easy implementation without larger
  1689.      * changes.}
  1690.      *
  1691.      * @return IdentificationVariableDeclaration
  1692.      */
  1693.     public function SubselectIdentificationVariableDeclaration()
  1694.     {
  1695.         /*
  1696.         NOT YET IMPLEMENTED!
  1698.         $glimpse = $this->lexer->glimpse();
  1700.         if ($glimpse['type'] == Lexer::T_DOT) {
  1701.             $associationPathExpression = $this->AssociationPathExpression();
  1703.             if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1704.                 $this->match(Lexer::T_AS);
  1705.             }
  1707.             $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1708.             $identificationVariable      = $associationPathExpression->identificationVariable;
  1709.             $field                       = $associationPathExpression->associationField;
  1711.             $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1712.             $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1714.             // Building queryComponent
  1715.             $joinQueryComponent = array(
  1716.                 'metadata'     => $targetClass,
  1717.                 'parent'       => $identificationVariable,
  1718.                 'relation'     => $class->getAssociationMapping($field),
  1719.                 'map'          => null,
  1720.                 'nestingLevel' => $this->nestingLevel,
  1721.                 'token'        => $this->lexer->lookahead
  1722.             );
  1724.             $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1726.             return new AST\SubselectIdentificationVariableDeclaration(
  1727.                 $associationPathExpression, $aliasIdentificationVariable
  1728.             );
  1729.         }
  1730.         */
  1732.         return $this->IdentificationVariableDeclaration();
  1733.     }
  1735.     /**
  1736.      * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN"
  1737.      *          (JoinAssociationDeclaration | RangeVariableDeclaration)
  1738.      *          ["WITH" ConditionalExpression]
  1739.      *
  1740.      * @return Join
  1741.      */
  1742.     public function Join()
  1743.     {
  1744.         // Check Join type
  1745.         $joinType = AST\Join::JOIN_TYPE_INNER;
  1747.         switch (true) {
  1748.             case $this->lexer->isNextToken(Lexer::T_LEFT):
  1749.                 $this->match(Lexer::T_LEFT);
  1751.                 $joinType = AST\Join::JOIN_TYPE_LEFT;
  1753.                 // Possible LEFT OUTER join
  1754.                 if ($this->lexer->isNextToken(Lexer::T_OUTER)) {
  1755.                     $this->match(Lexer::T_OUTER);
  1757.                     $joinType = AST\Join::JOIN_TYPE_LEFTOUTER;
  1758.                 }
  1760.                 break;
  1762.             case $this->lexer->isNextToken(Lexer::T_INNER):
  1763.                 $this->match(Lexer::T_INNER);
  1764.                 break;
  1766.             default:
  1767.                 // Do nothing
  1768.         }
  1770.         $this->match(Lexer::T_JOIN);
  1772.         $next            = $this->lexer->glimpse();
  1773.         $joinDeclaration = $next['type'] === Lexer::T_DOT ? $this->JoinAssociationDeclaration() : $this->RangeVariableDeclaration();
  1774.         $adhocConditions = $this->lexer->isNextToken(Lexer::T_WITH);
  1775.         $join            = new AST\Join($joinType, $joinDeclaration);
  1777.         // Describe non-root join declaration
  1778.         if ($joinDeclaration instanceof AST\RangeVariableDeclaration) {
  1779.             $joinDeclaration->isRoot = false;
  1780.         }
  1782.         // Check for ad-hoc Join conditions
  1783.         if ($adhocConditions) {
  1784.             $this->match(Lexer::T_WITH);
  1786.             $join->conditionalExpression = $this->ConditionalExpression();
  1787.         }
  1789.         return $join;
  1790.     }
  1792.     /**
  1793.      * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
  1794.      *
  1795.      * @return RangeVariableDeclaration
  1796.      *
  1797.      * @throws QueryException
  1798.      */
  1799.     public function RangeVariableDeclaration()
  1800.     {
  1801.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $this->lexer->glimpse()['type'] === Lexer::T_SELECT) {
  1802.             $this->semanticalError('Subquery is not supported here', $this->lexer->token);
  1803.         }
  1805.         $abstractSchemaName = $this->AbstractSchemaName();
  1807.         $this->validateAbstractSchemaName($abstractSchemaName);
  1809.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1810.             $this->match(Lexer::T_AS);
  1811.         }
  1813.         assert($this->lexer->lookahead !== null);
  1814.         $token                       = $this->lexer->lookahead;
  1815.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1816.         $classMetadata               = $this->em->getClassMetadata($abstractSchemaName);
  1818.         // Building queryComponent
  1819.         $queryComponent = [
  1820.             'metadata'     => $classMetadata,
  1821.             'parent'       => null,
  1822.             'relation'     => null,
  1823.             'map'          => null,
  1824.             'nestingLevel' => $this->nestingLevel,
  1825.             'token'        => $token,
  1826.         ];
  1828.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1830.         return new AST\RangeVariableDeclaration($abstractSchemaName, $aliasIdentificationVariable);
  1831.     }
  1833.     /**
  1834.      * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [IndexBy]
  1835.      *
  1836.      * @return AST\JoinAssociationDeclaration
  1837.      */
  1838.     public function JoinAssociationDeclaration()
  1839.     {
  1840.         $joinAssociationPathExpression = $this->JoinAssociationPathExpression();
  1842.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1843.             $this->match(Lexer::T_AS);
  1844.         }
  1846.         assert($this->lexer->lookahead !== null);
  1848.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1849.         $indexBy                     = $this->lexer->isNextToken(Lexer::T_INDEX) ? $this->IndexBy() : null;
  1851.         $identificationVariable = $joinAssociationPathExpression->identificationVariable;
  1852.         $field                  = $joinAssociationPathExpression->associationField;
  1854.         $class       = $this->getMetadataForDqlAlias($identificationVariable);
  1855.         $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1857.         // Building queryComponent
  1858.         $joinQueryComponent = [
  1859.             'metadata'     => $targetClass,
  1860.             'parent'       => $joinAssociationPathExpression->identificationVariable,
  1861.             'relation'     => $class->getAssociationMapping($field),
  1862.             'map'          => null,
  1863.             'nestingLevel' => $this->nestingLevel,
  1864.             'token'        => $this->lexer->lookahead,
  1865.         ];
  1867.         $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1869.         return new AST\JoinAssociationDeclaration($joinAssociationPathExpression, $aliasIdentificationVariable, $indexBy);
  1870.     }
  1872.     /**
  1873.      * PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
  1874.      * PartialFieldSet ::= "{" SimpleStateField {"," SimpleStateField}* "}"
  1875.      *
  1876.      * @return PartialObjectExpression
  1877.      */
  1878.     public function PartialObjectExpression()
  1879.     {
  1880.         Deprecation::trigger(
  1881.             'doctrine/orm',
  1882.             'https://github.com/doctrine/orm/issues/8471',
  1883.             'PARTIAL syntax in DQL is deprecated.'
  1884.         );
  1886.         $this->match(Lexer::T_PARTIAL);
  1888.         $partialFieldSet = [];
  1890.         $identificationVariable = $this->IdentificationVariable();
  1892.         $this->match(Lexer::T_DOT);
  1893.         $this->match(Lexer::T_OPEN_CURLY_BRACE);
  1894.         $this->match(Lexer::T_IDENTIFIER);
  1896.         $field = $this->lexer->token['value'];
  1898.         // First field in partial expression might be embeddable property
  1899.         while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1900.             $this->match(Lexer::T_DOT);
  1901.             $this->match(Lexer::T_IDENTIFIER);
  1902.             $field .= '.' . $this->lexer->token['value'];
  1903.         }
  1905.         $partialFieldSet[] = $field;
  1907.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1908.             $this->match(Lexer::T_COMMA);
  1909.             $this->match(Lexer::T_IDENTIFIER);
  1911.             $field = $this->lexer->token['value'];
  1913.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1914.                 $this->match(Lexer::T_DOT);
  1915.                 $this->match(Lexer::T_IDENTIFIER);
  1916.                 $field .= '.' . $this->lexer->token['value'];
  1917.             }
  1919.             $partialFieldSet[] = $field;
  1920.         }
  1922.         $this->match(Lexer::T_CLOSE_CURLY_BRACE);
  1924.         $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
  1926.         assert($this->lexer->token !== null);
  1927.         // Defer PartialObjectExpression validation
  1928.         $this->deferredPartialObjectExpressions[] = [
  1929.             'expression'   => $partialObjectExpression,
  1930.             'nestingLevel' => $this->nestingLevel,
  1931.             'token'        => $this->lexer->token,
  1932.         ];
  1934.         return $partialObjectExpression;
  1935.     }
  1937.     /**
  1938.      * NewObjectExpression ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
  1939.      *
  1940.      * @return NewObjectExpression
  1941.      */
  1942.     public function NewObjectExpression()
  1943.     {
  1944.         $this->match(Lexer::T_NEW);
  1946.         $className = $this->AbstractSchemaName(); // note that this is not yet validated
  1947.         $token     = $this->lexer->token;
  1949.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  1951.         $args[] = $this->NewObjectArg();
  1953.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1954.             $this->match(Lexer::T_COMMA);
  1956.             $args[] = $this->NewObjectArg();
  1957.         }
  1959.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1961.         $expression = new AST\NewObjectExpression($className, $args);
  1963.         // Defer NewObjectExpression validation
  1964.         $this->deferredNewObjectExpressions[] = [
  1965.             'token'        => $token,
  1966.             'expression'   => $expression,
  1967.             'nestingLevel' => $this->nestingLevel,
  1968.         ];
  1970.         return $expression;
  1971.     }
  1973.     /**
  1974.      * NewObjectArg ::= ScalarExpression | "(" Subselect ")"
  1975.      *
  1976.      * @return mixed
  1977.      */
  1978.     public function NewObjectArg()
  1979.     {
  1980.         $token = $this->lexer->lookahead;
  1981.         $peek  = $this->lexer->glimpse();
  1983.         if ($token['type'] === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT) {
  1984.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  1985.             $expression = $this->Subselect();
  1986.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1988.             return $expression;
  1989.         }
  1991.         return $this->ScalarExpression();
  1992.     }
  1994.     /**
  1995.      * IndexBy ::= "INDEX" "BY" SingleValuedPathExpression
  1996.      *
  1997.      * @return IndexBy
  1998.      */
  1999.     public function IndexBy()
  2000.     {
  2001.         $this->match(Lexer::T_INDEX);
  2002.         $this->match(Lexer::T_BY);
  2003.         $pathExpr = $this->SingleValuedPathExpression();
  2005.         // Add the INDEX BY info to the query component
  2006.         $this->queryComponents[$pathExpr->identificationVariable]['map'] = $pathExpr->field;
  2008.         return new AST\IndexBy($pathExpr);
  2009.     }
  2011.     /**
  2012.      * ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DateTimePrimary |
  2013.      *                      StateFieldPathExpression | BooleanPrimary | CaseExpression |
  2014.      *                      InstanceOfExpression
  2015.      *
  2016.      * @return mixed One of the possible expressions or subexpressions.
  2017.      */
  2018.     public function ScalarExpression()
  2019.     {
  2020.         $lookahead = $this->lexer->lookahead['type'];
  2021.         $peek      = $this->lexer->glimpse();
  2023.         switch (true) {
  2024.             case $lookahead === Lexer::T_INTEGER:
  2025.             case $lookahead === Lexer::T_FLOAT:
  2026.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )  or ( - 1 ) or ( + 1 )
  2027.             case $lookahead === Lexer::T_MINUS:
  2028.             case $lookahead === Lexer::T_PLUS:
  2029.                 return $this->SimpleArithmeticExpression();
  2031.             case $lookahead === Lexer::T_STRING:
  2032.                 return $this->StringPrimary();
  2034.             case $lookahead === Lexer::T_TRUE:
  2035.             case $lookahead === Lexer::T_FALSE:
  2036.                 $this->match($lookahead);
  2038.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2040.             case $lookahead === Lexer::T_INPUT_PARAMETER:
  2041.                 switch (true) {
  2042.                     case $this->isMathOperator($peek):
  2043.                         // :param + u.value
  2044.                         return $this->SimpleArithmeticExpression();
  2046.                     default:
  2047.                         return $this->InputParameter();
  2048.                 }
  2049.             case $lookahead === Lexer::T_CASE:
  2050.             case $lookahead === Lexer::T_COALESCE:
  2051.             case $lookahead === Lexer::T_NULLIF:
  2052.                 // Since NULLIF and COALESCE can be identified as a function,
  2053.                 // we need to check these before checking for FunctionDeclaration
  2054.                 return $this->CaseExpression();
  2056.             case $lookahead === Lexer::T_OPEN_PARENTHESIS:
  2057.                 return $this->SimpleArithmeticExpression();
  2059.             // this check must be done before checking for a filed path expression
  2060.             case $this->isFunction():
  2061.                 $this->lexer->peek(); // "("
  2063.                 switch (true) {
  2064.                     case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2065.                         // SUM(u.id) + COUNT(u.id)
  2066.                         return $this->SimpleArithmeticExpression();
  2068.                     default:
  2069.                         // IDENTITY(u)
  2070.                         return $this->FunctionDeclaration();
  2071.                 }
  2073.                 break;
  2074.             // it is no function, so it must be a field path
  2075.             case $lookahead === Lexer::T_IDENTIFIER:
  2076.                 $this->lexer->peek(); // lookahead => '.'
  2077.                 $this->lexer->peek(); // lookahead => token after '.'
  2078.                 $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  2079.                 $this->lexer->resetPeek();
  2081.                 if ($this->isMathOperator($peek)) {
  2082.                     return $this->SimpleArithmeticExpression();
  2083.                 }
  2085.                 return $this->StateFieldPathExpression();
  2087.             default:
  2088.                 $this->syntaxError();
  2089.         }
  2090.     }
  2092.     /**
  2093.      * CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullifExpression
  2094.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2095.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2096.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2097.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2098.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2099.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2100.      * NullifExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2101.      *
  2102.      * @return mixed One of the possible expressions or subexpressions.
  2103.      */
  2104.     public function CaseExpression()
  2105.     {
  2106.         $lookahead = $this->lexer->lookahead['type'];
  2108.         switch ($lookahead) {
  2109.             case Lexer::T_NULLIF:
  2110.                 return $this->NullIfExpression();
  2112.             case Lexer::T_COALESCE:
  2113.                 return $this->CoalesceExpression();
  2115.             case Lexer::T_CASE:
  2116.                 $this->lexer->resetPeek();
  2117.                 $peek = $this->lexer->peek();
  2119.                 if ($peek['type'] === Lexer::T_WHEN) {
  2120.                     return $this->GeneralCaseExpression();
  2121.                 }
  2123.                 return $this->SimpleCaseExpression();
  2125.             default:
  2126.                 // Do nothing
  2127.                 break;
  2128.         }
  2130.         $this->syntaxError();
  2131.     }
  2133.     /**
  2134.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2135.      *
  2136.      * @return CoalesceExpression
  2137.      */
  2138.     public function CoalesceExpression()
  2139.     {
  2140.         $this->match(Lexer::T_COALESCE);
  2141.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2143.         // Process ScalarExpressions (1..N)
  2144.         $scalarExpressions   = [];
  2145.         $scalarExpressions[] = $this->ScalarExpression();
  2147.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  2148.             $this->match(Lexer::T_COMMA);
  2150.             $scalarExpressions[] = $this->ScalarExpression();
  2151.         }
  2153.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2155.         return new AST\CoalesceExpression($scalarExpressions);
  2156.     }
  2158.     /**
  2159.      * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2160.      *
  2161.      * @return NullIfExpression
  2162.      */
  2163.     public function NullIfExpression()
  2164.     {
  2165.         $this->match(Lexer::T_NULLIF);
  2166.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2168.         $firstExpression = $this->ScalarExpression();
  2169.         $this->match(Lexer::T_COMMA);
  2170.         $secondExpression = $this->ScalarExpression();
  2172.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2174.         return new AST\NullIfExpression($firstExpression, $secondExpression);
  2175.     }
  2177.     /**
  2178.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2179.      *
  2180.      * @return GeneralCaseExpression
  2181.      */
  2182.     public function GeneralCaseExpression()
  2183.     {
  2184.         $this->match(Lexer::T_CASE);
  2186.         // Process WhenClause (1..N)
  2187.         $whenClauses = [];
  2189.         do {
  2190.             $whenClauses[] = $this->WhenClause();
  2191.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2193.         $this->match(Lexer::T_ELSE);
  2194.         $scalarExpression = $this->ScalarExpression();
  2195.         $this->match(Lexer::T_END);
  2197.         return new AST\GeneralCaseExpression($whenClauses, $scalarExpression);
  2198.     }
  2200.     /**
  2201.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2202.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2203.      *
  2204.      * @return AST\SimpleCaseExpression
  2205.      */
  2206.     public function SimpleCaseExpression()
  2207.     {
  2208.         $this->match(Lexer::T_CASE);
  2209.         $caseOperand = $this->StateFieldPathExpression();
  2211.         // Process SimpleWhenClause (1..N)
  2212.         $simpleWhenClauses = [];
  2214.         do {
  2215.             $simpleWhenClauses[] = $this->SimpleWhenClause();
  2216.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2218.         $this->match(Lexer::T_ELSE);
  2219.         $scalarExpression = $this->ScalarExpression();
  2220.         $this->match(Lexer::T_END);
  2222.         return new AST\SimpleCaseExpression($caseOperand, $simpleWhenClauses, $scalarExpression);
  2223.     }
  2225.     /**
  2226.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2227.      *
  2228.      * @return WhenClause
  2229.      */
  2230.     public function WhenClause()
  2231.     {
  2232.         $this->match(Lexer::T_WHEN);
  2233.         $conditionalExpression = $this->ConditionalExpression();
  2234.         $this->match(Lexer::T_THEN);
  2236.         return new AST\WhenClause($conditionalExpression, $this->ScalarExpression());
  2237.     }
  2239.     /**
  2240.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2241.      *
  2242.      * @return SimpleWhenClause
  2243.      */
  2244.     public function SimpleWhenClause()
  2245.     {
  2246.         $this->match(Lexer::T_WHEN);
  2247.         $conditionalExpression = $this->ScalarExpression();
  2248.         $this->match(Lexer::T_THEN);
  2250.         return new AST\SimpleWhenClause($conditionalExpression, $this->ScalarExpression());
  2251.     }
  2253.     /**
  2254.      * SelectExpression ::= (
  2255.      *     IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration |
  2256.      *     PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression
  2257.      * ) [["AS"] ["HIDDEN"] AliasResultVariable]
  2258.      *
  2259.      * @return SelectExpression
  2260.      */
  2261.     public function SelectExpression()
  2262.     {
  2263.         $expression    = null;
  2264.         $identVariable = null;
  2265.         $peek          = $this->lexer->glimpse();
  2266.         $lookaheadType = $this->lexer->lookahead['type'];
  2268.         switch (true) {
  2269.             // ScalarExpression (u.name)
  2270.             case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] === Lexer::T_DOT:
  2271.                 $expression = $this->ScalarExpression();
  2272.                 break;
  2274.             // IdentificationVariable (u)
  2275.             case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2276.                 $expression = $identVariable = $this->IdentificationVariable();
  2277.                 break;
  2279.             // CaseExpression (CASE ... or NULLIF(...) or COALESCE(...))
  2280.             case $lookaheadType === Lexer::T_CASE:
  2281.             case $lookaheadType === Lexer::T_COALESCE:
  2282.             case $lookaheadType === Lexer::T_NULLIF:
  2283.                 $expression = $this->CaseExpression();
  2284.                 break;
  2286.             // DQL Function (SUM(u.value) or SUM(u.value) + 1)
  2287.             case $this->isFunction():
  2288.                 $this->lexer->peek(); // "("
  2290.                 switch (true) {
  2291.                     case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2292.                         // SUM(u.id) + COUNT(u.id)
  2293.                         $expression = $this->ScalarExpression();
  2294.                         break;
  2296.                     default:
  2297.                         // IDENTITY(u)
  2298.                         $expression = $this->FunctionDeclaration();
  2299.                         break;
  2300.                 }
  2302.                 break;
  2304.             // PartialObjectExpression (PARTIAL u.{id, name})
  2305.             case $lookaheadType === Lexer::T_PARTIAL:
  2306.                 $expression    = $this->PartialObjectExpression();
  2307.                 $identVariable = $expression->identificationVariable;
  2308.                 break;
  2310.             // Subselect
  2311.             case $lookaheadType === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT:
  2312.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2313.                 $expression = $this->Subselect();
  2314.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2315.                 break;
  2317.             // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2318.             case $lookaheadType === Lexer::T_OPEN_PARENTHESIS:
  2319.             case $lookaheadType === Lexer::T_INTEGER:
  2320.             case $lookaheadType === Lexer::T_STRING:
  2321.             case $lookaheadType === Lexer::T_FLOAT:
  2322.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )
  2323.             case $lookaheadType === Lexer::T_MINUS:
  2324.             case $lookaheadType === Lexer::T_PLUS:
  2325.                 $expression = $this->SimpleArithmeticExpression();
  2326.                 break;
  2328.             // NewObjectExpression (New ClassName(id, name))
  2329.             case $lookaheadType === Lexer::T_NEW:
  2330.                 $expression = $this->NewObjectExpression();
  2331.                 break;
  2333.             default:
  2334.                 $this->syntaxError(
  2335.                     'IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression',
  2336.                     $this->lexer->lookahead
  2337.                 );
  2338.         }
  2340.         // [["AS"] ["HIDDEN"] AliasResultVariable]
  2341.         $mustHaveAliasResultVariable = false;
  2343.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2344.             $this->match(Lexer::T_AS);
  2346.             $mustHaveAliasResultVariable = true;
  2347.         }
  2349.         $hiddenAliasResultVariable = false;
  2351.         if ($this->lexer->isNextToken(Lexer::T_HIDDEN)) {
  2352.             $this->match(Lexer::T_HIDDEN);
  2354.             $hiddenAliasResultVariable = true;
  2355.         }
  2357.         $aliasResultVariable = null;
  2359.         if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2360.             assert($this->lexer->lookahead !== null);
  2361.             assert($expression instanceof AST\Node || is_string($expression));
  2362.             $token               = $this->lexer->lookahead;
  2363.             $aliasResultVariable = $this->AliasResultVariable();
  2365.             // Include AliasResultVariable in query components.
  2366.             $this->queryComponents[$aliasResultVariable] = [
  2367.                 'resultVariable' => $expression,
  2368.                 'nestingLevel'   => $this->nestingLevel,
  2369.                 'token'          => $token,
  2370.             ];
  2371.         }
  2373.         // AST
  2375.         $expr = new AST\SelectExpression($expression, $aliasResultVariable, $hiddenAliasResultVariable);
  2377.         if ($identVariable) {
  2378.             $this->identVariableExpressions[$identVariable] = $expr;
  2379.         }
  2381.         return $expr;
  2382.     }
  2384.     /**
  2385.      * SimpleSelectExpression ::= (
  2386.      *      StateFieldPathExpression | IdentificationVariable | FunctionDeclaration |
  2387.      *      AggregateExpression | "(" Subselect ")" | ScalarExpression
  2388.      * ) [["AS"] AliasResultVariable]
  2389.      *
  2390.      * @return SimpleSelectExpression
  2391.      */
  2392.     public function SimpleSelectExpression()
  2393.     {
  2394.         $peek = $this->lexer->glimpse();
  2396.         switch ($this->lexer->lookahead['type']) {
  2397.             case Lexer::T_IDENTIFIER:
  2398.                 switch (true) {
  2399.                     case $peek['type'] === Lexer::T_DOT:
  2400.                         $expression = $this->StateFieldPathExpression();
  2402.                         return new AST\SimpleSelectExpression($expression);
  2404.                     case $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2405.                         $expression = $this->IdentificationVariable();
  2407.                         return new AST\SimpleSelectExpression($expression);
  2409.                     case $this->isFunction():
  2410.                         // SUM(u.id) + COUNT(u.id)
  2411.                         if ($this->isMathOperator($this->peekBeyondClosingParenthesis())) {
  2412.                             return new AST\SimpleSelectExpression($this->ScalarExpression());
  2413.                         }
  2415.                         // COUNT(u.id)
  2416.                         if ($this->isAggregateFunction($this->lexer->lookahead['type'])) {
  2417.                             return new AST\SimpleSelectExpression($this->AggregateExpression());
  2418.                         }
  2420.                         // IDENTITY(u)
  2421.                         return new AST\SimpleSelectExpression($this->FunctionDeclaration());
  2423.                     default:
  2424.                         // Do nothing
  2425.                 }
  2427.                 break;
  2429.             case Lexer::T_OPEN_PARENTHESIS:
  2430.                 if ($peek['type'] !== Lexer::T_SELECT) {
  2431.                     // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2432.                     $expression = $this->SimpleArithmeticExpression();
  2434.                     return new AST\SimpleSelectExpression($expression);
  2435.                 }
  2437.                 // Subselect
  2438.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2439.                 $expression = $this->Subselect();
  2440.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2442.                 return new AST\SimpleSelectExpression($expression);
  2444.             default:
  2445.                 // Do nothing
  2446.         }
  2448.         $this->lexer->peek();
  2450.         $expression = $this->ScalarExpression();
  2451.         $expr       = new AST\SimpleSelectExpression($expression);
  2453.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2454.             $this->match(Lexer::T_AS);
  2455.         }
  2457.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2458.             assert($this->lexer->lookahead !== null);
  2459.             $token                             = $this->lexer->lookahead;
  2460.             $resultVariable                    = $this->AliasResultVariable();
  2461.             $expr->fieldIdentificationVariable = $resultVariable;
  2463.             // Include AliasResultVariable in query components.
  2464.             $this->queryComponents[$resultVariable] = [
  2465.                 'resultvariable' => $expr,
  2466.                 'nestingLevel'   => $this->nestingLevel,
  2467.                 'token'          => $token,
  2468.             ];
  2469.         }
  2471.         return $expr;
  2472.     }
  2474.     /**
  2475.      * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
  2476.      *
  2477.      * @return AST\ConditionalExpression|AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2478.      */
  2479.     public function ConditionalExpression()
  2480.     {
  2481.         $conditionalTerms   = [];
  2482.         $conditionalTerms[] = $this->ConditionalTerm();
  2484.         while ($this->lexer->isNextToken(Lexer::T_OR)) {
  2485.             $this->match(Lexer::T_OR);
  2487.             $conditionalTerms[] = $this->ConditionalTerm();
  2488.         }
  2490.         // Phase 1 AST optimization: Prevent AST\ConditionalExpression
  2491.         // if only one AST\ConditionalTerm is defined
  2492.         if (count($conditionalTerms) === 1) {
  2493.             return $conditionalTerms[0];
  2494.         }
  2496.         return new AST\ConditionalExpression($conditionalTerms);
  2497.     }
  2499.     /**
  2500.      * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
  2501.      *
  2502.      * @return AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2503.      */
  2504.     public function ConditionalTerm()
  2505.     {
  2506.         $conditionalFactors   = [];
  2507.         $conditionalFactors[] = $this->ConditionalFactor();
  2509.         while ($this->lexer->isNextToken(Lexer::T_AND)) {
  2510.             $this->match(Lexer::T_AND);
  2512.             $conditionalFactors[] = $this->ConditionalFactor();
  2513.         }
  2515.         // Phase 1 AST optimization: Prevent AST\ConditionalTerm
  2516.         // if only one AST\ConditionalFactor is defined
  2517.         if (count($conditionalFactors) === 1) {
  2518.             return $conditionalFactors[0];
  2519.         }
  2521.         return new AST\ConditionalTerm($conditionalFactors);
  2522.     }
  2524.     /**
  2525.      * ConditionalFactor ::= ["NOT"] ConditionalPrimary
  2526.      *
  2527.      * @return AST\ConditionalFactor|AST\ConditionalPrimary
  2528.      */
  2529.     public function ConditionalFactor()
  2530.     {
  2531.         $not = false;
  2533.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2534.             $this->match(Lexer::T_NOT);
  2536.             $not = true;
  2537.         }
  2539.         $conditionalPrimary = $this->ConditionalPrimary();
  2541.         // Phase 1 AST optimization: Prevent AST\ConditionalFactor
  2542.         // if only one AST\ConditionalPrimary is defined
  2543.         if (! $not) {
  2544.             return $conditionalPrimary;
  2545.         }
  2547.         $conditionalFactor      = new AST\ConditionalFactor($conditionalPrimary);
  2548.         $conditionalFactor->not = $not;
  2550.         return $conditionalFactor;
  2551.     }
  2553.     /**
  2554.      * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
  2555.      *
  2556.      * @return ConditionalPrimary
  2557.      */
  2558.     public function ConditionalPrimary()
  2559.     {
  2560.         $condPrimary = new AST\ConditionalPrimary();
  2562.         if (! $this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2563.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2565.             return $condPrimary;
  2566.         }
  2568.         // Peek beyond the matching closing parenthesis ')'
  2569.         $peek = $this->peekBeyondClosingParenthesis();
  2571.         if (
  2572.             $peek !== null && (
  2573.             in_array($peek['value'], ['=', '<', '<=', '<>', '>', '>=', '!='], true) ||
  2574.             in_array($peek['type'], [Lexer::T_NOT, Lexer::T_BETWEEN, Lexer::T_LIKE, Lexer::T_IN, Lexer::T_IS, Lexer::T_EXISTS], true) ||
  2575.             $this->isMathOperator($peek)
  2576.             )
  2577.         ) {
  2578.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2580.             return $condPrimary;
  2581.         }
  2583.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2584.         $condPrimary->conditionalExpression = $this->ConditionalExpression();
  2585.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2587.         return $condPrimary;
  2588.     }
  2590.     /**
  2591.      * SimpleConditionalExpression ::=
  2592.      *      ComparisonExpression | BetweenExpression | LikeExpression |
  2593.      *      InExpression | NullComparisonExpression | ExistsExpression |
  2594.      *      EmptyCollectionComparisonExpression | CollectionMemberExpression |
  2595.      *      InstanceOfExpression
  2596.      *
  2597.      * @return AST\BetweenExpression|
  2598.      *         AST\CollectionMemberExpression|
  2599.      *         AST\ComparisonExpression|
  2600.      *         AST\EmptyCollectionComparisonExpression|
  2601.      *         AST\ExistsExpression|
  2602.      *         AST\InExpression|
  2603.      *         AST\InstanceOfExpression|
  2604.      *         AST\LikeExpression|
  2605.      *         AST\NullComparisonExpression
  2606.      */
  2607.     public function SimpleConditionalExpression()
  2608.     {
  2609.         if ($this->lexer->isNextToken(Lexer::T_EXISTS)) {
  2610.             return $this->ExistsExpression();
  2611.         }
  2613.         $token     = $this->lexer->lookahead;
  2614.         $peek      = $this->lexer->glimpse();
  2615.         $lookahead = $token;
  2617.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2618.             $token = $this->lexer->glimpse();
  2619.         }
  2621.         if ($token['type'] === Lexer::T_IDENTIFIER || $token['type'] === Lexer::T_INPUT_PARAMETER || $this->isFunction()) {
  2622.             // Peek beyond the matching closing parenthesis.
  2623.             $beyond = $this->lexer->peek();
  2625.             switch ($peek['value']) {
  2626.                 case '(':
  2627.                     // Peeks beyond the matched closing parenthesis.
  2628.                     $token = $this->peekBeyondClosingParenthesis(false);
  2630.                     if ($token['type'] === Lexer::T_NOT) {
  2631.                         $token = $this->lexer->peek();
  2632.                     }
  2634.                     if ($token['type'] === Lexer::T_IS) {
  2635.                         $lookahead = $this->lexer->peek();
  2636.                     }
  2638.                     break;
  2640.                 default:
  2641.                     // Peek beyond the PathExpression or InputParameter.
  2642.                     $token = $beyond;
  2644.                     while ($token['value'] === '.') {
  2645.                         $this->lexer->peek();
  2647.                         $token = $this->lexer->peek();
  2648.                     }
  2650.                     // Also peek beyond a NOT if there is one.
  2651.                     if ($token['type'] === Lexer::T_NOT) {
  2652.                         $token = $this->lexer->peek();
  2653.                     }
  2655.                     // We need to go even further in case of IS (differentiate between NULL and EMPTY)
  2656.                     $lookahead = $this->lexer->peek();
  2657.             }
  2659.             // Also peek beyond a NOT if there is one.
  2660.             if ($lookahead['type'] === Lexer::T_NOT) {
  2661.                 $lookahead = $this->lexer->peek();
  2662.             }
  2664.             $this->lexer->resetPeek();
  2665.         }
  2667.         if ($token['type'] === Lexer::T_BETWEEN) {
  2668.             return $this->BetweenExpression();
  2669.         }
  2671.         if ($token['type'] === Lexer::T_LIKE) {
  2672.             return $this->LikeExpression();
  2673.         }
  2675.         if ($token['type'] === Lexer::T_IN) {
  2676.             return $this->InExpression();
  2677.         }
  2679.         if ($token['type'] === Lexer::T_INSTANCE) {
  2680.             return $this->InstanceOfExpression();
  2681.         }
  2683.         if ($token['type'] === Lexer::T_MEMBER) {
  2684.             return $this->CollectionMemberExpression();
  2685.         }
  2687.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_NULL) {
  2688.             return $this->NullComparisonExpression();
  2689.         }
  2691.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_EMPTY) {
  2692.             return $this->EmptyCollectionComparisonExpression();
  2693.         }
  2695.         return $this->ComparisonExpression();
  2696.     }
  2698.     /**
  2699.      * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
  2700.      *
  2701.      * @return EmptyCollectionComparisonExpression
  2702.      */
  2703.     public function EmptyCollectionComparisonExpression()
  2704.     {
  2705.         $emptyCollectionCompExpr = new AST\EmptyCollectionComparisonExpression(
  2706.             $this->CollectionValuedPathExpression()
  2707.         );
  2708.         $this->match(Lexer::T_IS);
  2710.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2711.             $this->match(Lexer::T_NOT);
  2712.             $emptyCollectionCompExpr->not = true;
  2713.         }
  2715.         $this->match(Lexer::T_EMPTY);
  2717.         return $emptyCollectionCompExpr;
  2718.     }
  2720.     /**
  2721.      * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
  2722.      *
  2723.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2724.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2725.      *
  2726.      * @return CollectionMemberExpression
  2727.      */
  2728.     public function CollectionMemberExpression()
  2729.     {
  2730.         $not        = false;
  2731.         $entityExpr = $this->EntityExpression();
  2733.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2734.             $this->match(Lexer::T_NOT);
  2736.             $not = true;
  2737.         }
  2739.         $this->match(Lexer::T_MEMBER);
  2741.         if ($this->lexer->isNextToken(Lexer::T_OF)) {
  2742.             $this->match(Lexer::T_OF);
  2743.         }
  2745.         $collMemberExpr      = new AST\CollectionMemberExpression(
  2746.             $entityExpr,
  2747.             $this->CollectionValuedPathExpression()
  2748.         );
  2749.         $collMemberExpr->not = $not;
  2751.         return $collMemberExpr;
  2752.     }
  2754.     /**
  2755.      * Literal ::= string | char | integer | float | boolean
  2756.      *
  2757.      * @return Literal
  2758.      */
  2759.     public function Literal()
  2760.     {
  2761.         switch ($this->lexer->lookahead['type']) {
  2762.             case Lexer::T_STRING:
  2763.                 $this->match(Lexer::T_STRING);
  2765.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  2767.             case Lexer::T_INTEGER:
  2768.             case Lexer::T_FLOAT:
  2769.                 $this->match(
  2770.                     $this->lexer->isNextToken(Lexer::T_INTEGER) ? Lexer::T_INTEGER : Lexer::T_FLOAT
  2771.                 );
  2773.                 return new AST\Literal(AST\Literal::NUMERIC, $this->lexer->token['value']);
  2775.             case Lexer::T_TRUE:
  2776.             case Lexer::T_FALSE:
  2777.                 $this->match(
  2778.                     $this->lexer->isNextToken(Lexer::T_TRUE) ? Lexer::T_TRUE : Lexer::T_FALSE
  2779.                 );
  2781.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2783.             default:
  2784.                 $this->syntaxError('Literal');
  2785.         }
  2786.     }
  2788.     /**
  2789.      * InParameter ::= ArithmeticExpression | InputParameter
  2790.      *
  2791.      * @return AST\InputParameter|AST\ArithmeticExpression
  2792.      */
  2793.     public function InParameter()
  2794.     {
  2795.         if ($this->lexer->lookahead['type'] === Lexer::T_INPUT_PARAMETER) {
  2796.             return $this->InputParameter();
  2797.         }
  2799.         return $this->ArithmeticExpression();
  2800.     }
  2802.     /**
  2803.      * InputParameter ::= PositionalParameter | NamedParameter
  2804.      *
  2805.      * @return InputParameter
  2806.      */
  2807.     public function InputParameter()
  2808.     {
  2809.         $this->match(Lexer::T_INPUT_PARAMETER);
  2811.         return new AST\InputParameter($this->lexer->token['value']);
  2812.     }
  2814.     /**
  2815.      * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
  2816.      *
  2817.      * @return ArithmeticExpression
  2818.      */
  2819.     public function ArithmeticExpression()
  2820.     {
  2821.         $expr = new AST\ArithmeticExpression();
  2823.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2824.             $peek = $this->lexer->glimpse();
  2826.             if ($peek['type'] === Lexer::T_SELECT) {
  2827.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2828.                 $expr->subselect = $this->Subselect();
  2829.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2831.                 return $expr;
  2832.             }
  2833.         }
  2835.         $expr->simpleArithmeticExpression = $this->SimpleArithmeticExpression();
  2837.         return $expr;
  2838.     }
  2840.     /**
  2841.      * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
  2842.      *
  2843.      * @return SimpleArithmeticExpression|ArithmeticTerm
  2844.      */
  2845.     public function SimpleArithmeticExpression()
  2846.     {
  2847.         $terms   = [];
  2848.         $terms[] = $this->ArithmeticTerm();
  2850.         while (($isPlus = $this->lexer->isNextToken(Lexer::T_PLUS)) || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2851.             $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2853.             $terms[] = $this->lexer->token['value'];
  2854.             $terms[] = $this->ArithmeticTerm();
  2855.         }
  2857.         // Phase 1 AST optimization: Prevent AST\SimpleArithmeticExpression
  2858.         // if only one AST\ArithmeticTerm is defined
  2859.         if (count($terms) === 1) {
  2860.             return $terms[0];
  2861.         }
  2863.         return new AST\SimpleArithmeticExpression($terms);
  2864.     }
  2866.     /**
  2867.      * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
  2868.      *
  2869.      * @return ArithmeticTerm
  2870.      */
  2871.     public function ArithmeticTerm()
  2872.     {
  2873.         $factors   = [];
  2874.         $factors[] = $this->ArithmeticFactor();
  2876.         while (($isMult = $this->lexer->isNextToken(Lexer::T_MULTIPLY)) || $this->lexer->isNextToken(Lexer::T_DIVIDE)) {
  2877.             $this->match($isMult ? Lexer::T_MULTIPLY : Lexer::T_DIVIDE);
  2879.             $factors[] = $this->lexer->token['value'];
  2880.             $factors[] = $this->ArithmeticFactor();
  2881.         }
  2883.         // Phase 1 AST optimization: Prevent AST\ArithmeticTerm
  2884.         // if only one AST\ArithmeticFactor is defined
  2885.         if (count($factors) === 1) {
  2886.             return $factors[0];
  2887.         }
  2889.         return new AST\ArithmeticTerm($factors);
  2890.     }
  2892.     /**
  2893.      * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
  2894.      *
  2895.      * @return ArithmeticFactor
  2896.      */
  2897.     public function ArithmeticFactor()
  2898.     {
  2899.         $sign = null;
  2901.         $isPlus = $this->lexer->isNextToken(Lexer::T_PLUS);
  2902.         if ($isPlus || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2903.             $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2904.             $sign = $isPlus;
  2905.         }
  2907.         $primary = $this->ArithmeticPrimary();
  2909.         // Phase 1 AST optimization: Prevent AST\ArithmeticFactor
  2910.         // if only one AST\ArithmeticPrimary is defined
  2911.         if ($sign === null) {
  2912.             return $primary;
  2913.         }
  2915.         return new AST\ArithmeticFactor($primary, $sign);
  2916.     }
  2918.     /**
  2919.      * ArithmeticPrimary ::= SingleValuedPathExpression | Literal | ParenthesisExpression
  2920.      *          | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings
  2921.      *          | FunctionsReturningDatetime | IdentificationVariable | ResultVariable
  2922.      *          | InputParameter | CaseExpression
  2923.      *
  2924.      * @return Node|string
  2925.      */
  2926.     public function ArithmeticPrimary()
  2927.     {
  2928.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2929.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2931.             $expr = $this->SimpleArithmeticExpression();
  2933.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2935.             return new AST\ParenthesisExpression($expr);
  2936.         }
  2938.         switch ($this->lexer->lookahead['type']) {
  2939.             case Lexer::T_COALESCE:
  2940.             case Lexer::T_NULLIF:
  2941.             case Lexer::T_CASE:
  2942.                 return $this->CaseExpression();
  2944.             case Lexer::T_IDENTIFIER:
  2945.                 $peek = $this->lexer->glimpse();
  2947.                 if ($peek !== null && $peek['value'] === '(') {
  2948.                     return $this->FunctionDeclaration();
  2949.                 }
  2951.                 if ($peek !== null && $peek['value'] === '.') {
  2952.                     return $this->SingleValuedPathExpression();
  2953.                 }
  2955.                 if (isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])) {
  2956.                     return $this->ResultVariable();
  2957.                 }
  2959.                 return $this->StateFieldPathExpression();
  2961.             case Lexer::T_INPUT_PARAMETER:
  2962.                 return $this->InputParameter();
  2964.             default:
  2965.                 $peek = $this->lexer->glimpse();
  2967.                 if ($peek !== null && $peek['value'] === '(') {
  2968.                     return $this->FunctionDeclaration();
  2969.                 }
  2971.                 return $this->Literal();
  2972.         }
  2973.     }
  2975.     /**
  2976.      * StringExpression ::= StringPrimary | ResultVariable | "(" Subselect ")"
  2977.      *
  2978.      * @return Subselect|Node|string
  2979.      */
  2980.     public function StringExpression()
  2981.     {
  2982.         $peek = $this->lexer->glimpse();
  2984.         // Subselect
  2985.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $peek['type'] === Lexer::T_SELECT) {
  2986.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2987.             $expr = $this->Subselect();
  2988.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2990.             return $expr;
  2991.         }
  2993.         // ResultVariable (string)
  2994.         if (
  2995.             $this->lexer->isNextToken(Lexer::T_IDENTIFIER) &&
  2996.             isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])
  2997.         ) {
  2998.             return $this->ResultVariable();
  2999.         }
  3001.         return $this->StringPrimary();
  3002.     }
  3004.     /**
  3005.      * StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression
  3006.      *
  3007.      * @return Node
  3008.      */
  3009.     public function StringPrimary()
  3010.     {
  3011.         $lookaheadType = $this->lexer->lookahead['type'];
  3013.         switch ($lookaheadType) {
  3014.             case Lexer::T_IDENTIFIER:
  3015.                 $peek = $this->lexer->glimpse();
  3017.                 if ($peek['value'] === '.') {
  3018.                     return $this->StateFieldPathExpression();
  3019.                 }
  3021.                 if ($peek['value'] === '(') {
  3022.                     // do NOT directly go to FunctionsReturningString() because it doesn't check for custom functions.
  3023.                     return $this->FunctionDeclaration();
  3024.                 }
  3026.                 $this->syntaxError("'.' or '('");
  3027.                 break;
  3029.             case Lexer::T_STRING:
  3030.                 $this->match(Lexer::T_STRING);
  3032.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3034.             case Lexer::T_INPUT_PARAMETER:
  3035.                 return $this->InputParameter();
  3037.             case Lexer::T_CASE:
  3038.             case Lexer::T_COALESCE:
  3039.             case Lexer::T_NULLIF:
  3040.                 return $this->CaseExpression();
  3042.             default:
  3043.                 if ($this->isAggregateFunction($lookaheadType)) {
  3044.                     return $this->AggregateExpression();
  3045.                 }
  3046.         }
  3048.         $this->syntaxError(
  3049.             'StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression'
  3050.         );
  3051.     }
  3053.     /**
  3054.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  3055.      *
  3056.      * @return AST\InputParameter|PathExpression
  3057.      */
  3058.     public function EntityExpression()
  3059.     {
  3060.         $glimpse = $this->lexer->glimpse();
  3062.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER) && $glimpse['value'] === '.') {
  3063.             return $this->SingleValuedAssociationPathExpression();
  3064.         }
  3066.         return $this->SimpleEntityExpression();
  3067.     }
  3069.     /**
  3070.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  3071.      *
  3072.      * @return AST\InputParameter|AST\PathExpression
  3073.      */
  3074.     public function SimpleEntityExpression()
  3075.     {
  3076.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3077.             return $this->InputParameter();
  3078.         }
  3080.         return $this->StateFieldPathExpression();
  3081.     }
  3083.     /**
  3084.      * AggregateExpression ::=
  3085.      *  ("AVG" | "MAX" | "MIN" | "SUM" | "COUNT") "(" ["DISTINCT"] SimpleArithmeticExpression ")"
  3086.      *
  3087.      * @return AggregateExpression
  3088.      */
  3089.     public function AggregateExpression()
  3090.     {
  3091.         $lookaheadType = $this->lexer->lookahead['type'];
  3092.         $isDistinct    = false;
  3094.         if (! in_array($lookaheadType, [Lexer::T_COUNT, Lexer::T_AVG, Lexer::T_MAX, Lexer::T_MIN, Lexer::T_SUM], true)) {
  3095.             $this->syntaxError('One of: MAX, MIN, AVG, SUM, COUNT');
  3096.         }
  3098.         $this->match($lookaheadType);
  3099.         $functionName = $this->lexer->token['value'];
  3100.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3102.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  3103.             $this->match(Lexer::T_DISTINCT);
  3104.             $isDistinct = true;
  3105.         }
  3107.         $pathExp = $this->SimpleArithmeticExpression();
  3109.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3111.         return new AST\AggregateExpression($functionName, $pathExp, $isDistinct);
  3112.     }
  3114.     /**
  3115.      * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
  3116.      *
  3117.      * @return QuantifiedExpression
  3118.      */
  3119.     public function QuantifiedExpression()
  3120.     {
  3121.         $lookaheadType = $this->lexer->lookahead['type'];
  3122.         $value         = $this->lexer->lookahead['value'];
  3124.         if (! in_array($lookaheadType, [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME], true)) {
  3125.             $this->syntaxError('ALL, ANY or SOME');
  3126.         }
  3128.         $this->match($lookaheadType);
  3129.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3131.         $qExpr       = new AST\QuantifiedExpression($this->Subselect());
  3132.         $qExpr->type = $value;
  3134.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3136.         return $qExpr;
  3137.     }
  3139.     /**
  3140.      * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
  3141.      *
  3142.      * @return BetweenExpression
  3143.      */
  3144.     public function BetweenExpression()
  3145.     {
  3146.         $not        = false;
  3147.         $arithExpr1 = $this->ArithmeticExpression();
  3149.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3150.             $this->match(Lexer::T_NOT);
  3151.             $not = true;
  3152.         }
  3154.         $this->match(Lexer::T_BETWEEN);
  3155.         $arithExpr2 = $this->ArithmeticExpression();
  3156.         $this->match(Lexer::T_AND);
  3157.         $arithExpr3 = $this->ArithmeticExpression();
  3159.         $betweenExpr      = new AST\BetweenExpression($arithExpr1, $arithExpr2, $arithExpr3);
  3160.         $betweenExpr->not = $not;
  3162.         return $betweenExpr;
  3163.     }
  3165.     /**
  3166.      * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )
  3167.      *
  3168.      * @return ComparisonExpression
  3169.      */
  3170.     public function ComparisonExpression()
  3171.     {
  3172.         $this->lexer->glimpse();
  3174.         $leftExpr  = $this->ArithmeticExpression();
  3175.         $operator  = $this->ComparisonOperator();
  3176.         $rightExpr = $this->isNextAllAnySome()
  3177.             ? $this->QuantifiedExpression()
  3178.             : $this->ArithmeticExpression();
  3180.         return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
  3181.     }
  3183.     /**
  3184.      * InExpression ::= SingleValuedPathExpression ["NOT"] "IN" "(" (InParameter {"," InParameter}* | Subselect) ")"
  3185.      *
  3186.      * @return InExpression
  3187.      */
  3188.     public function InExpression()
  3189.     {
  3190.         $inExpression = new AST\InExpression($this->ArithmeticExpression());
  3192.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3193.             $this->match(Lexer::T_NOT);
  3194.             $inExpression->not = true;
  3195.         }
  3197.         $this->match(Lexer::T_IN);
  3198.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3200.         if ($this->lexer->isNextToken(Lexer::T_SELECT)) {
  3201.             $inExpression->subselect = $this->Subselect();
  3202.         } else {
  3203.             $literals   = [];
  3204.             $literals[] = $this->InParameter();
  3206.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3207.                 $this->match(Lexer::T_COMMA);
  3208.                 $literals[] = $this->InParameter();
  3209.             }
  3211.             $inExpression->literals = $literals;
  3212.         }
  3214.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3216.         return $inExpression;
  3217.     }
  3219.     /**
  3220.      * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
  3221.      *
  3222.      * @return InstanceOfExpression
  3223.      */
  3224.     public function InstanceOfExpression()
  3225.     {
  3226.         $instanceOfExpression = new AST\InstanceOfExpression($this->IdentificationVariable());
  3228.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3229.             $this->match(Lexer::T_NOT);
  3230.             $instanceOfExpression->not = true;
  3231.         }
  3233.         $this->match(Lexer::T_INSTANCE);
  3234.         $this->match(Lexer::T_OF);
  3236.         $exprValues = [];
  3238.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  3239.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  3241.             $exprValues[] = $this->InstanceOfParameter();
  3243.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3244.                 $this->match(Lexer::T_COMMA);
  3246.                 $exprValues[] = $this->InstanceOfParameter();
  3247.             }
  3249.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3251.             $instanceOfExpression->value = $exprValues;
  3253.             return $instanceOfExpression;
  3254.         }
  3256.         $exprValues[] = $this->InstanceOfParameter();
  3258.         $instanceOfExpression->value = $exprValues;
  3260.         return $instanceOfExpression;
  3261.     }
  3263.     /**
  3264.      * InstanceOfParameter ::= AbstractSchemaName | InputParameter
  3265.      *
  3266.      * @return mixed
  3267.      */
  3268.     public function InstanceOfParameter()
  3269.     {
  3270.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3271.             $this->match(Lexer::T_INPUT_PARAMETER);
  3273.             return new AST\InputParameter($this->lexer->token['value']);
  3274.         }
  3276.         $abstractSchemaName = $this->AbstractSchemaName();
  3278.         $this->validateAbstractSchemaName($abstractSchemaName);
  3280.         return $abstractSchemaName;
  3281.     }
  3283.     /**
  3284.      * LikeExpression ::= StringExpression ["NOT"] "LIKE" StringPrimary ["ESCAPE" char]
  3285.      *
  3286.      * @return LikeExpression
  3287.      */
  3288.     public function LikeExpression()
  3289.     {
  3290.         $stringExpr = $this->StringExpression();
  3291.         $not        = false;
  3293.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3294.             $this->match(Lexer::T_NOT);
  3295.             $not = true;
  3296.         }
  3298.         $this->match(Lexer::T_LIKE);
  3300.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3301.             $this->match(Lexer::T_INPUT_PARAMETER);
  3302.             $stringPattern = new AST\InputParameter($this->lexer->token['value']);
  3303.         } else {
  3304.             $stringPattern = $this->StringPrimary();
  3305.         }
  3307.         $escapeChar = null;
  3309.         if ($this->lexer->lookahead !== null && $this->lexer->lookahead['type'] === Lexer::T_ESCAPE) {
  3310.             $this->match(Lexer::T_ESCAPE);
  3311.             $this->match(Lexer::T_STRING);
  3313.             $escapeChar = new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3314.         }
  3316.         $likeExpr      = new AST\LikeExpression($stringExpr, $stringPattern, $escapeChar);
  3317.         $likeExpr->not = $not;
  3319.         return $likeExpr;
  3320.     }
  3322.     /**
  3323.      * NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) "IS" ["NOT"] "NULL"
  3324.      *
  3325.      * @return NullComparisonExpression
  3326.      */
  3327.     public function NullComparisonExpression()
  3328.     {
  3329.         switch (true) {
  3330.             case $this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER):
  3331.                 $this->match(Lexer::T_INPUT_PARAMETER);
  3333.                 $expr = new AST\InputParameter($this->lexer->token['value']);
  3334.                 break;
  3336.             case $this->lexer->isNextToken(Lexer::T_NULLIF):
  3337.                 $expr = $this->NullIfExpression();
  3338.                 break;
  3340.             case $this->lexer->isNextToken(Lexer::T_COALESCE):
  3341.                 $expr = $this->CoalesceExpression();
  3342.                 break;
  3344.             case $this->isFunction():
  3345.                 $expr = $this->FunctionDeclaration();
  3346.                 break;
  3348.             default:
  3349.                 // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  3350.                 $glimpse = $this->lexer->glimpse();
  3352.                 if ($glimpse['type'] === Lexer::T_DOT) {
  3353.                     $expr = $this->SingleValuedPathExpression();
  3355.                     // Leave switch statement
  3356.                     break;
  3357.                 }
  3359.                 $lookaheadValue = $this->lexer->lookahead['value'];
  3361.                 // Validate existing component
  3362.                 if (! isset($this->queryComponents[$lookaheadValue])) {
  3363.                     $this->semanticalError('Cannot add having condition on undefined result variable.');
  3364.                 }
  3366.                 // Validate SingleValuedPathExpression (ie.: "product")
  3367.                 if (isset($this->queryComponents[$lookaheadValue]['metadata'])) {
  3368.                     $expr = $this->SingleValuedPathExpression();
  3369.                     break;
  3370.                 }
  3372.                 // Validating ResultVariable
  3373.                 if (! isset($this->queryComponents[$lookaheadValue]['resultVariable'])) {
  3374.                     $this->semanticalError('Cannot add having condition on a non result variable.');
  3375.                 }
  3377.                 $expr = $this->ResultVariable();
  3378.                 break;
  3379.         }
  3381.         $nullCompExpr = new AST\NullComparisonExpression($expr);
  3383.         $this->match(Lexer::T_IS);
  3385.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3386.             $this->match(Lexer::T_NOT);
  3388.             $nullCompExpr->not = true;
  3389.         }
  3391.         $this->match(Lexer::T_NULL);
  3393.         return $nullCompExpr;
  3394.     }
  3396.     /**
  3397.      * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
  3398.      *
  3399.      * @return ExistsExpression
  3400.      */
  3401.     public function ExistsExpression()
  3402.     {
  3403.         $not = false;
  3405.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3406.             $this->match(Lexer::T_NOT);
  3407.             $not = true;
  3408.         }
  3410.         $this->match(Lexer::T_EXISTS);
  3411.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3413.         $existsExpression      = new AST\ExistsExpression($this->Subselect());
  3414.         $existsExpression->not = $not;
  3416.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3418.         return $existsExpression;
  3419.     }
  3421.     /**
  3422.      * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
  3423.      *
  3424.      * @return string
  3425.      */
  3426.     public function ComparisonOperator()
  3427.     {
  3428.         switch ($this->lexer->lookahead['value']) {
  3429.             case '=':
  3430.                 $this->match(Lexer::T_EQUALS);
  3432.                 return '=';
  3434.             case '<':
  3435.                 $this->match(Lexer::T_LOWER_THAN);
  3436.                 $operator = '<';
  3438.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3439.                     $this->match(Lexer::T_EQUALS);
  3440.                     $operator .= '=';
  3441.                 } elseif ($this->lexer->isNextToken(Lexer::T_GREATER_THAN)) {
  3442.                     $this->match(Lexer::T_GREATER_THAN);
  3443.                     $operator .= '>';
  3444.                 }
  3446.                 return $operator;
  3448.             case '>':
  3449.                 $this->match(Lexer::T_GREATER_THAN);
  3450.                 $operator = '>';
  3452.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3453.                     $this->match(Lexer::T_EQUALS);
  3454.                     $operator .= '=';
  3455.                 }
  3457.                 return $operator;
  3459.             case '!':
  3460.                 $this->match(Lexer::T_NEGATE);
  3461.                 $this->match(Lexer::T_EQUALS);
  3463.                 return '<>';
  3465.             default:
  3466.                 $this->syntaxError('=, <, <=, <>, >, >=, !=');
  3467.         }
  3468.     }
  3470.     /**
  3471.      * FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDatetime
  3472.      *
  3473.      * @return FunctionNode
  3474.      */
  3475.     public function FunctionDeclaration()
  3476.     {
  3477.         $token    = $this->lexer->lookahead;
  3478.         $funcName = strtolower($token['value']);
  3480.         $customFunctionDeclaration = $this->CustomFunctionDeclaration();
  3482.         // Check for custom functions functions first!
  3483.         switch (true) {
  3484.             case $customFunctionDeclaration !== null:
  3485.                 return $customFunctionDeclaration;
  3487.             case isset(self::$stringFunctions[$funcName]):
  3488.                 return $this->FunctionsReturningStrings();
  3490.             case isset(self::$numericFunctions[$funcName]):
  3491.                 return $this->FunctionsReturningNumerics();
  3493.             case isset(self::$datetimeFunctions[$funcName]):
  3494.                 return $this->FunctionsReturningDatetime();
  3496.             default:
  3497.                 $this->syntaxError('known function', $token);
  3498.         }
  3499.     }
  3501.     /**
  3502.      * Helper function for FunctionDeclaration grammar rule.
  3503.      */
  3504.     private function CustomFunctionDeclaration(): ?FunctionNode
  3505.     {
  3506.         $token    = $this->lexer->lookahead;
  3507.         $funcName = strtolower($token['value']);
  3509.         // Check for custom functions afterwards
  3510.         $config = $this->em->getConfiguration();
  3512.         switch (true) {
  3513.             case $config->getCustomStringFunction($funcName) !== null:
  3514.                 return $this->CustomFunctionsReturningStrings();
  3516.             case $config->getCustomNumericFunction($funcName) !== null:
  3517.                 return $this->CustomFunctionsReturningNumerics();
  3519.             case $config->getCustomDatetimeFunction($funcName) !== null:
  3520.                 return $this->CustomFunctionsReturningDatetime();
  3522.             default:
  3523.                 return null;
  3524.         }
  3525.     }
  3527.     /**
  3528.      * FunctionsReturningNumerics ::=
  3529.      *      "LENGTH" "(" StringPrimary ")" |
  3530.      *      "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")" |
  3531.      *      "ABS" "(" SimpleArithmeticExpression ")" |
  3532.      *      "SQRT" "(" SimpleArithmeticExpression ")" |
  3533.      *      "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3534.      *      "SIZE" "(" CollectionValuedPathExpression ")" |
  3535.      *      "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3536.      *      "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3537.      *      "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
  3538.      *
  3539.      * @return FunctionNode
  3540.      */
  3541.     public function FunctionsReturningNumerics()
  3542.     {
  3543.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3544.         $funcClass     = self::$numericFunctions[$funcNameLower];
  3546.         $function = new $funcClass($funcNameLower);
  3547.         $function->parse($this);
  3549.         return $function;
  3550.     }
  3552.     /**
  3553.      * @return FunctionNode
  3554.      */
  3555.     public function CustomFunctionsReturningNumerics()
  3556.     {
  3557.         // getCustomNumericFunction is case-insensitive
  3558.         $functionName  = strtolower($this->lexer->lookahead['value']);
  3559.         $functionClass = $this->em->getConfiguration()->getCustomNumericFunction($functionName);
  3561.         assert($functionClass !== null);
  3563.         $function = is_string($functionClass)
  3564.             ? new $functionClass($functionName)
  3565.             : $functionClass($functionName);
  3567.         $function->parse($this);
  3569.         return $function;
  3570.     }
  3572.     /**
  3573.      * FunctionsReturningDateTime ::=
  3574.      *     "CURRENT_DATE" |
  3575.      *     "CURRENT_TIME" |
  3576.      *     "CURRENT_TIMESTAMP" |
  3577.      *     "DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")" |
  3578.      *     "DATE_SUB" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
  3579.      *
  3580.      * @return FunctionNode
  3581.      */
  3582.     public function FunctionsReturningDatetime()
  3583.     {
  3584.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3585.         $funcClass     = self::$datetimeFunctions[$funcNameLower];
  3587.         $function = new $funcClass($funcNameLower);
  3588.         $function->parse($this);
  3590.         return $function;
  3591.     }
  3593.     /**
  3594.      * @return FunctionNode
  3595.      */
  3596.     public function CustomFunctionsReturningDatetime()
  3597.     {
  3598.         // getCustomDatetimeFunction is case-insensitive
  3599.         $functionName  = $this->lexer->lookahead['value'];
  3600.         $functionClass = $this->em->getConfiguration()->getCustomDatetimeFunction($functionName);
  3602.         assert($functionClass !== null);
  3604.         $function = is_string($functionClass)
  3605.             ? new $functionClass($functionName)
  3606.             : $functionClass($functionName);
  3608.         $function->parse($this);
  3610.         return $function;
  3611.     }
  3613.     /**
  3614.      * FunctionsReturningStrings ::=
  3615.      *   "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary}* ")" |
  3616.      *   "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3617.      *   "TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")" |
  3618.      *   "LOWER" "(" StringPrimary ")" |
  3619.      *   "UPPER" "(" StringPrimary ")" |
  3620.      *   "IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
  3621.      *
  3622.      * @return FunctionNode
  3623.      */
  3624.     public function FunctionsReturningStrings()
  3625.     {
  3626.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3627.         $funcClass     = self::$stringFunctions[$funcNameLower];
  3629.         $function = new $funcClass($funcNameLower);
  3630.         $function->parse($this);
  3632.         return $function;
  3633.     }
  3635.     /**
  3636.      * @return FunctionNode
  3637.      */
  3638.     public function CustomFunctionsReturningStrings()
  3639.     {
  3640.         // getCustomStringFunction is case-insensitive
  3641.         $functionName  = $this->lexer->lookahead['value'];
  3642.         $functionClass = $this->em->getConfiguration()->getCustomStringFunction($functionName);
  3644.         assert($functionClass !== null);
  3646.         $function = is_string($functionClass)
  3647.             ? new $functionClass($functionName)
  3648.             : $functionClass($functionName);
  3650.         $function->parse($this);
  3652.         return $function;
  3653.     }
  3655.     private function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
  3656.     {
  3657.         if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
  3658.             throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
  3659.         }
  3661.         return $this->queryComponents[$dqlAlias]['metadata'];
  3662.     }
  3663. }