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

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Query;
  7. use Doctrine\Deprecations\Deprecation;
  8. use Doctrine\ORM\EntityManagerInterface;
  9. use Doctrine\ORM\Mapping\ClassMetadata;
  10. use Doctrine\ORM\Query;
  11. use Doctrine\ORM\Query\AST\AggregateExpression;
  12. use Doctrine\ORM\Query\AST\ArithmeticExpression;
  13. use Doctrine\ORM\Query\AST\ArithmeticFactor;
  14. use Doctrine\ORM\Query\AST\ArithmeticTerm;
  15. use Doctrine\ORM\Query\AST\BetweenExpression;
  16. use Doctrine\ORM\Query\AST\CoalesceExpression;
  17. use Doctrine\ORM\Query\AST\CollectionMemberExpression;
  18. use Doctrine\ORM\Query\AST\ComparisonExpression;
  19. use Doctrine\ORM\Query\AST\ConditionalPrimary;
  20. use Doctrine\ORM\Query\AST\DeleteClause;
  21. use Doctrine\ORM\Query\AST\DeleteStatement;
  22. use Doctrine\ORM\Query\AST\EmptyCollectionComparisonExpression;
  23. use Doctrine\ORM\Query\AST\ExistsExpression;
  24. use Doctrine\ORM\Query\AST\FromClause;
  25. use Doctrine\ORM\Query\AST\Functions;
  26. use Doctrine\ORM\Query\AST\Functions\FunctionNode;
  27. use Doctrine\ORM\Query\AST\GeneralCaseExpression;
  28. use Doctrine\ORM\Query\AST\GroupByClause;
  29. use Doctrine\ORM\Query\AST\HavingClause;
  30. use Doctrine\ORM\Query\AST\IdentificationVariableDeclaration;
  31. use Doctrine\ORM\Query\AST\IndexBy;
  32. use Doctrine\ORM\Query\AST\InExpression;
  33. use Doctrine\ORM\Query\AST\InputParameter;
  34. use Doctrine\ORM\Query\AST\InstanceOfExpression;
  35. use Doctrine\ORM\Query\AST\Join;
  36. use Doctrine\ORM\Query\AST\JoinAssociationPathExpression;
  37. use Doctrine\ORM\Query\AST\LikeExpression;
  38. use Doctrine\ORM\Query\AST\Literal;
  39. use Doctrine\ORM\Query\AST\NewObjectExpression;
  40. use Doctrine\ORM\Query\AST\Node;
  41. use Doctrine\ORM\Query\AST\NullComparisonExpression;
  42. use Doctrine\ORM\Query\AST\NullIfExpression;
  43. use Doctrine\ORM\Query\AST\OrderByClause;
  44. use Doctrine\ORM\Query\AST\OrderByItem;
  45. use Doctrine\ORM\Query\AST\PartialObjectExpression;
  46. use Doctrine\ORM\Query\AST\PathExpression;
  47. use Doctrine\ORM\Query\AST\QuantifiedExpression;
  48. use Doctrine\ORM\Query\AST\RangeVariableDeclaration;
  49. use Doctrine\ORM\Query\AST\SelectClause;
  50. use Doctrine\ORM\Query\AST\SelectExpression;
  51. use Doctrine\ORM\Query\AST\SelectStatement;
  52. use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
  53. use Doctrine\ORM\Query\AST\SimpleSelectClause;
  54. use Doctrine\ORM\Query\AST\SimpleSelectExpression;
  55. use Doctrine\ORM\Query\AST\SimpleWhenClause;
  56. use Doctrine\ORM\Query\AST\Subselect;
  57. use Doctrine\ORM\Query\AST\SubselectFromClause;
  58. use Doctrine\ORM\Query\AST\UpdateClause;
  59. use Doctrine\ORM\Query\AST\UpdateItem;
  60. use Doctrine\ORM\Query\AST\UpdateStatement;
  61. use Doctrine\ORM\Query\AST\WhenClause;
  62. use Doctrine\ORM\Query\AST\WhereClause;
  63. use ReflectionClass;
  65. use function array_intersect;
  66. use function array_search;
  67. use function assert;
  68. use function call_user_func;
  69. use function class_exists;
  70. use function count;
  71. use function explode;
  72. use function implode;
  73. use function in_array;
  74. use function interface_exists;
  75. use function is_string;
  76. use function sprintf;
  77. use function strlen;
  78. use function strpos;
  79. use function strrpos;
  80. use function strtolower;
  81. use function substr;
  83. /**
  84.  * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  85.  * Parses a DQL query, reports any errors in it, and generates an AST.
  86.  */
  87. class Parser
  88. {
  89.     /**
  90.      * @readonly Maps BUILT-IN string function names to AST class names.
  91.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  92.      */
  93.     private static $stringFunctions = [
  94.         'concat'    => Functions\ConcatFunction::class,
  95.         'substring' => Functions\SubstringFunction::class,
  96.         'trim'      => Functions\TrimFunction::class,
  97.         'lower'     => Functions\LowerFunction::class,
  98.         'upper'     => Functions\UpperFunction::class,
  99.         'identity'  => Functions\IdentityFunction::class,
  100.     ];
  102.     /**
  103.      * @readonly Maps BUILT-IN numeric function names to AST class names.
  104.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  105.      */
  106.     private static $numericFunctions = [
  107.         'length'    => Functions\LengthFunction::class,
  108.         'locate'    => Functions\LocateFunction::class,
  109.         'abs'       => Functions\AbsFunction::class,
  110.         'sqrt'      => Functions\SqrtFunction::class,
  111.         'mod'       => Functions\ModFunction::class,
  112.         'size'      => Functions\SizeFunction::class,
  113.         'date_diff' => Functions\DateDiffFunction::class,
  114.         'bit_and'   => Functions\BitAndFunction::class,
  115.         'bit_or'    => Functions\BitOrFunction::class,
  117.         // Aggregate functions
  118.         'min'       => Functions\MinFunction::class,
  119.         'max'       => Functions\MaxFunction::class,
  120.         'avg'       => Functions\AvgFunction::class,
  121.         'sum'       => Functions\SumFunction::class,
  122.         'count'     => Functions\CountFunction::class,
  123.     ];
  125.     /**
  126.      * @readonly Maps BUILT-IN datetime function names to AST class names.
  127.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  128.      */
  129.     private static $datetimeFunctions = [
  130.         'current_date'      => Functions\CurrentDateFunction::class,
  131.         'current_time'      => Functions\CurrentTimeFunction::class,
  132.         'current_timestamp' => Functions\CurrentTimestampFunction::class,
  133.         'date_add'          => Functions\DateAddFunction::class,
  134.         'date_sub'          => Functions\DateSubFunction::class,
  135.     ];
  137.     /*
  138.      * Expressions that were encountered during parsing of identifiers and expressions
  139.      * and still need to be validated.
  140.      */
  142.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  143.     private $deferredIdentificationVariables = [];
  145.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  146.     private $deferredPartialObjectExpressions = [];
  148.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  149.     private $deferredPathExpressions = [];
  151.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  152.     private $deferredResultVariables = [];
  154.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  155.     private $deferredNewObjectExpressions = [];
  157.     /**
  158.      * The lexer.
  159.      *
  160.      * @var Lexer
  161.      */
  162.     private $lexer;
  164.     /**
  165.      * The parser result.
  166.      *
  167.      * @var ParserResult
  168.      */
  169.     private $parserResult;
  171.     /**
  172.      * The EntityManager.
  173.      *
  174.      * @var EntityManagerInterface
  175.      */
  176.     private $em;
  178.     /**
  179.      * The Query to parse.
  180.      *
  181.      * @var Query
  182.      */
  183.     private $query;
  185.     /**
  186.      * Map of declared query components in the parsed query.
  187.      *
  188.      * @psalm-var array<string, array<string, mixed>>
  189.      */
  190.     private $queryComponents = [];
  192.     /**
  193.      * Keeps the nesting level of defined ResultVariables.
  194.      *
  195.      * @var int
  196.      */
  197.     private $nestingLevel = 0;
  199.     /**
  200.      * Any additional custom tree walkers that modify the AST.
  201.      *
  202.      * @psalm-var list<class-string<TreeWalker>>
  203.      */
  204.     private $customTreeWalkers = [];
  206.     /**
  207.      * The custom last tree walker, if any, that is responsible for producing the output.
  208.      *
  209.      * @var class-string<TreeWalker>
  210.      */
  211.     private $customOutputWalker;
  213.     /** @psalm-var array<string, AST\SelectExpression> */
  214.     private $identVariableExpressions = [];
  216.     /**
  217.      * Creates a new query parser object.
  218.      *
  219.      * @param Query $query The Query to parse.
  220.      */
  221.     public function __construct(Query $query)
  222.     {
  223.         $this->query        = $query;
  224.         $this->em           = $query->getEntityManager();
  225.         $this->lexer        = new Lexer((string) $query->getDQL());
  226.         $this->parserResult = new ParserResult();
  227.     }
  229.     /**
  230.      * Sets a custom tree walker that produces output.
  231.      * This tree walker will be run last over the AST, after any other walkers.
  232.      *
  233.      * @param string $className
  234.      *
  235.      * @return void
  236.      */
  237.     public function setCustomOutputTreeWalker($className)
  238.     {
  239.         $this->customOutputWalker = $className;
  240.     }
  242.     /**
  243.      * Adds a custom tree walker for modifying the AST.
  244.      *
  245.      * @param string $className
  246.      * @psalm-param class-string $className
  247.      *
  248.      * @return void
  249.      */
  250.     public function addCustomTreeWalker($className)
  251.     {
  252.         $this->customTreeWalkers[] = $className;
  253.     }
  255.     /**
  256.      * Gets the lexer used by the parser.
  257.      *
  258.      * @return Lexer
  259.      */
  260.     public function getLexer()
  261.     {
  262.         return $this->lexer;
  263.     }
  265.     /**
  266.      * Gets the ParserResult that is being filled with information during parsing.
  267.      *
  268.      * @return ParserResult
  269.      */
  270.     public function getParserResult()
  271.     {
  272.         return $this->parserResult;
  273.     }
  275.     /**
  276.      * Gets the EntityManager used by the parser.
  277.      *
  278.      * @return EntityManagerInterface
  279.      */
  280.     public function getEntityManager()
  281.     {
  282.         return $this->em;
  283.     }
  285.     /**
  286.      * Parses and builds AST for the given Query.
  287.      *
  288.      * @return SelectStatement|UpdateStatement|DeleteStatement
  289.      */
  290.     public function getAST()
  291.     {
  292.         // Parse & build AST
  293.         $AST = $this->QueryLanguage();
  295.         // Process any deferred validations of some nodes in the AST.
  296.         // This also allows post-processing of the AST for modification purposes.
  297.         $this->processDeferredIdentificationVariables();
  299.         if ($this->deferredPartialObjectExpressions) {
  300.             $this->processDeferredPartialObjectExpressions();
  301.         }
  303.         if ($this->deferredPathExpressions) {
  304.             $this->processDeferredPathExpressions();
  305.         }
  307.         if ($this->deferredResultVariables) {
  308.             $this->processDeferredResultVariables();
  309.         }
  311.         if ($this->deferredNewObjectExpressions) {
  312.             $this->processDeferredNewObjectExpressions($AST);
  313.         }
  315.         $this->processRootEntityAliasSelected();
  317.         // TODO: Is there a way to remove this? It may impact the mixed hydration resultset a lot!
  318.         $this->fixIdentificationVariableOrder($AST);
  320.         return $AST;
  321.     }
  323.     /**
  324.      * Attempts to match the given token with the current lookahead token.
  325.      *
  326.      * If they match, updates the lookahead token; otherwise raises a syntax
  327.      * error.
  328.      *
  329.      * @param int $token The token type.
  330.      *
  331.      * @return void
  332.      *
  333.      * @throws QueryException If the tokens don't match.
  334.      */
  335.     public function match($token)
  336.     {
  337.         $lookaheadType = $this->lexer->lookahead['type'] ?? null;
  339.         // Short-circuit on first condition, usually types match
  340.         if ($lookaheadType === $token) {
  341.             $this->lexer->moveNext();
  343.             return;
  344.         }
  346.         // If parameter is not identifier (1-99) must be exact match
  347.         if ($token < Lexer::T_IDENTIFIER) {
  348.             $this->syntaxError($this->lexer->getLiteral($token));
  349.         }
  351.         // If parameter is keyword (200+) must be exact match
  352.         if ($token > Lexer::T_IDENTIFIER) {
  353.             $this->syntaxError($this->lexer->getLiteral($token));
  354.         }
  356.         // If parameter is T_IDENTIFIER, then matches T_IDENTIFIER (100) and keywords (200+)
  357.         if ($token === Lexer::T_IDENTIFIER && $lookaheadType < Lexer::T_IDENTIFIER) {
  358.             $this->syntaxError($this->lexer->getLiteral($token));
  359.         }
  361.         $this->lexer->moveNext();
  362.     }
  364.     /**
  365.      * Frees this parser, enabling it to be reused.
  366.      *
  367.      * @param bool $deep     Whether to clean peek and reset errors.
  368.      * @param int  $position Position to reset.
  369.      *
  370.      * @return void
  371.      */
  372.     public function free($deep = false, $position = 0)
  373.     {
  374.         // WARNING! Use this method with care. It resets the scanner!
  375.         $this->lexer->resetPosition($position);
  377.         // Deep = true cleans peek and also any previously defined errors
  378.         if ($deep) {
  379.             $this->lexer->resetPeek();
  380.         }
  382.         $this->lexer->token     = null;
  383.         $this->lexer->lookahead = null;
  384.     }
  386.     /**
  387.      * Parses a query string.
  388.      *
  389.      * @return ParserResult
  390.      */
  391.     public function parse()
  392.     {
  393.         $AST = $this->getAST();
  395.         $customWalkers = $this->query->getHint(Query::HINT_CUSTOM_TREE_WALKERS);
  396.         if ($customWalkers !== false) {
  397.             $this->customTreeWalkers = $customWalkers;
  398.         }
  400.         $customOutputWalker = $this->query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER);
  401.         if ($customOutputWalker !== false) {
  402.             $this->customOutputWalker = $customOutputWalker;
  403.         }
  405.         // Run any custom tree walkers over the AST
  406.         if ($this->customTreeWalkers) {
  407.             $treeWalkerChain = new TreeWalkerChain($this->query, $this->parserResult, $this->queryComponents);
  409.             foreach ($this->customTreeWalkers as $walker) {
  410.                 $treeWalkerChain->addTreeWalker($walker);
  411.             }
  413.             switch (true) {
  414.                 case $AST instanceof AST\UpdateStatement:
  415.                     $treeWalkerChain->walkUpdateStatement($AST);
  416.                     break;
  418.                 case $AST instanceof AST\DeleteStatement:
  419.                     $treeWalkerChain->walkDeleteStatement($AST);
  420.                     break;
  422.                 case $AST instanceof AST\SelectStatement:
  423.                 default:
  424.                     $treeWalkerChain->walkSelectStatement($AST);
  425.             }
  427.             $this->queryComponents = $treeWalkerChain->getQueryComponents();
  428.         }
  430.         $outputWalkerClass = $this->customOutputWalker ?: SqlWalker::class;
  431.         $outputWalker      = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
  433.         // Assign an SQL executor to the parser result
  434.         $this->parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
  436.         return $this->parserResult;
  437.     }
  439.     /**
  440.      * Fixes order of identification variables.
  441.      *
  442.      * They have to appear in the select clause in the same order as the
  443.      * declarations (from ... x join ... y join ... z ...) appear in the query
  444.      * as the hydration process relies on that order for proper operation.
  445.      *
  446.      * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST
  447.      */
  448.     private function fixIdentificationVariableOrder(Node $AST): void
  449.     {
  450.         if (count($this->identVariableExpressions) <= 1) {
  451.             return;
  452.         }
  454.         assert($AST instanceof AST\SelectStatement);
  456.         foreach ($this->queryComponents as $dqlAlias => $qComp) {
  457.             if (! isset($this->identVariableExpressions[$dqlAlias])) {
  458.                 continue;
  459.             }
  461.             $expr = $this->identVariableExpressions[$dqlAlias];
  462.             $key  = array_search($expr, $AST->selectClause->selectExpressions, true);
  464.             unset($AST->selectClause->selectExpressions[$key]);
  466.             $AST->selectClause->selectExpressions[] = $expr;
  467.         }
  468.     }
  470.     /**
  471.      * Generates a new syntax error.
  472.      *
  473.      * @param string       $expected Expected string.
  474.      * @param mixed[]|null $token    Got token.
  475.      * @psalm-param array<string, mixed>|null $token
  476.      *
  477.      * @return void
  478.      * @psalm-return no-return
  479.      *
  480.      * @throws QueryException
  481.      */
  482.     public function syntaxError($expected = '', $token = null)
  483.     {
  484.         if ($token === null) {
  485.             $token = $this->lexer->lookahead;
  486.         }
  488.         $tokenPos = $token['position'] ?? '-1';
  490.         $message  = sprintf('line 0, col %d: Error: ', $tokenPos);
  491.         $message .= $expected !== '' ? sprintf('Expected %s, got ', $expected) : 'Unexpected ';
  492.         $message .= $this->lexer->lookahead === null ? 'end of string.' : sprintf("'%s'", $token['value']);
  494.         throw QueryException::syntaxError($message, QueryException::dqlError($this->query->getDQL() ?? ''));
  495.     }
  497.     /**
  498.      * Generates a new semantical error.
  499.      *
  500.      * @param string       $message Optional message.
  501.      * @param mixed[]|null $token   Optional token.
  502.      * @psalm-param array<string, mixed>|null $token
  503.      *
  504.      * @return void
  505.      *
  506.      * @throws QueryException
  507.      */
  508.     public function semanticalError($message = '', $token = null)
  509.     {
  510.         if ($token === null) {
  511.             $token = $this->lexer->lookahead ?? ['position' => 0];
  512.         }
  514.         // Minimum exposed chars ahead of token
  515.         $distance = 12;
  517.         // Find a position of a final word to display in error string
  518.         $dql    = $this->query->getDQL();
  519.         $length = strlen($dql);
  520.         $pos    = $token['position'] + $distance;
  521.         $pos    = strpos($dql, ' ', $length > $pos ? $pos : $length);
  522.         $length = $pos !== false ? $pos - $token['position'] : $distance;
  524.         $tokenPos = $token['position'] > 0 ? $token['position'] : '-1';
  525.         $tokenStr = substr($dql, $token['position'], $length);
  527.         // Building informative message
  528.         $message = 'line 0, col ' . $tokenPos . " near '" . $tokenStr . "': Error: " . $message;
  530.         throw QueryException::semanticalError($message, QueryException::dqlError($this->query->getDQL()));
  531.     }
  533.     /**
  534.      * Peeks beyond the matched closing parenthesis and returns the first token after that one.
  535.      *
  536.      * @param bool $resetPeek Reset peek after finding the closing parenthesis.
  537.      *
  538.      * @return mixed[]
  539.      * @psalm-return array{value: string, type: int|null|string, position: int}|null
  540.      */
  541.     private function peekBeyondClosingParenthesis(bool $resetPeek = true): ?array
  542.     {
  543.         $token        = $this->lexer->peek();
  544.         $numUnmatched = 1;
  546.         while ($numUnmatched > 0 && $token !== null) {
  547.             switch ($token['type']) {
  548.                 case Lexer::T_OPEN_PARENTHESIS:
  549.                     ++$numUnmatched;
  550.                     break;
  552.                 case Lexer::T_CLOSE_PARENTHESIS:
  553.                     --$numUnmatched;
  554.                     break;
  556.                 default:
  557.                     // Do nothing
  558.             }
  560.             $token = $this->lexer->peek();
  561.         }
  563.         if ($resetPeek) {
  564.             $this->lexer->resetPeek();
  565.         }
  567.         return $token;
  568.     }
  570.     /**
  571.      * Checks if the given token indicates a mathematical operator.
  572.      *
  573.      * @psalm-param array<string, mixed>|null $token
  574.      */
  575.     private function isMathOperator(?array $token): bool
  576.     {
  577.         return $token !== null && in_array($token['type'], [Lexer::T_PLUS, Lexer::T_MINUS, Lexer::T_DIVIDE, Lexer::T_MULTIPLY], true);
  578.     }
  580.     /**
  581.      * Checks if the next-next (after lookahead) token starts a function.
  582.      *
  583.      * @return bool TRUE if the next-next tokens start a function, FALSE otherwise.
  584.      */
  585.     private function isFunction(): bool
  586.     {
  587.         $lookaheadType = $this->lexer->lookahead['type'];
  588.         $peek          = $this->lexer->peek();
  590.         $this->lexer->resetPeek();
  592.         return $lookaheadType >= Lexer::T_IDENTIFIER && $peek !== null && $peek['type'] === Lexer::T_OPEN_PARENTHESIS;
  593.     }
  595.     /**
  596.      * Checks whether the given token type indicates an aggregate function.
  597.      *
  598.      * @psalm-param Lexer::T_* $tokenType
  599.      *
  600.      * @return bool TRUE if the token type is an aggregate function, FALSE otherwise.
  601.      */
  602.     private function isAggregateFunction(int $tokenType): bool
  603.     {
  604.         return in_array(
  605.             $tokenType,
  606.             [Lexer::T_AVG, Lexer::T_MIN, Lexer::T_MAX, Lexer::T_SUM, Lexer::T_COUNT],
  607.             true
  608.         );
  609.     }
  611.     /**
  612.      * Checks whether the current lookahead token of the lexer has the type T_ALL, T_ANY or T_SOME.
  613.      */
  614.     private function isNextAllAnySome(): bool
  615.     {
  616.         return in_array(
  617.             $this->lexer->lookahead['type'],
  618.             [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME],
  619.             true
  620.         );
  621.     }
  623.     /**
  624.      * Validates that the given <tt>IdentificationVariable</tt> is semantically correct.
  625.      * It must exist in query components list.
  626.      */
  627.     private function processDeferredIdentificationVariables(): void
  628.     {
  629.         foreach ($this->deferredIdentificationVariables as $deferredItem) {
  630.             $identVariable = $deferredItem['expression'];
  632.             // Check if IdentificationVariable exists in queryComponents
  633.             if (! isset($this->queryComponents[$identVariable])) {
  634.                 $this->semanticalError(
  635.                     sprintf("'%s' is not defined.", $identVariable),
  636.                     $deferredItem['token']
  637.                 );
  638.             }
  640.             $qComp = $this->queryComponents[$identVariable];
  642.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  643.             if (! isset($qComp['metadata'])) {
  644.                 $this->semanticalError(
  645.                     sprintf("'%s' does not point to a Class.", $identVariable),
  646.                     $deferredItem['token']
  647.                 );
  648.             }
  650.             // Validate if identification variable nesting level is lower or equal than the current one
  651.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  652.                 $this->semanticalError(
  653.                     sprintf("'%s' is used outside the scope of its declaration.", $identVariable),
  654.                     $deferredItem['token']
  655.                 );
  656.             }
  657.         }
  658.     }
  660.     /**
  661.      * Validates that the given <tt>NewObjectExpression</tt>.
  662.      */
  663.     private function processDeferredNewObjectExpressions(SelectStatement $AST): void
  664.     {
  665.         foreach ($this->deferredNewObjectExpressions as $deferredItem) {
  666.             $expression    = $deferredItem['expression'];
  667.             $token         = $deferredItem['token'];
  668.             $className     = $expression->className;
  669.             $args          = $expression->args;
  670.             $fromClassName = $AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName ?? null;
  672.             // If the namespace is not given then assumes the first FROM entity namespace
  673.             if (strpos($className, '\\') === false && ! class_exists($className) && strpos($fromClassName, '\\') !== false) {
  674.                 $namespace = substr($fromClassName, 0, strrpos($fromClassName, '\\'));
  675.                 $fqcn      = $namespace . '\\' . $className;
  677.                 if (class_exists($fqcn)) {
  678.                     $expression->className = $fqcn;
  679.                     $className             = $fqcn;
  680.                 }
  681.             }
  683.             if (! class_exists($className)) {
  684.                 $this->semanticalError(sprintf('Class "%s" is not defined.', $className), $token);
  685.             }
  687.             $class = new ReflectionClass($className);
  689.             if (! $class->isInstantiable()) {
  690.                 $this->semanticalError(sprintf('Class "%s" can not be instantiated.', $className), $token);
  691.             }
  693.             if ($class->getConstructor() === null) {
  694.                 $this->semanticalError(sprintf('Class "%s" has not a valid constructor.', $className), $token);
  695.             }
  697.             if ($class->getConstructor()->getNumberOfRequiredParameters() > count($args)) {
  698.                 $this->semanticalError(sprintf('Number of arguments does not match with "%s" constructor declaration.', $className), $token);
  699.             }
  700.         }
  701.     }
  703.     /**
  704.      * Validates that the given <tt>PartialObjectExpression</tt> is semantically correct.
  705.      * It must exist in query components list.
  706.      */
  707.     private function processDeferredPartialObjectExpressions(): void
  708.     {
  709.         foreach ($this->deferredPartialObjectExpressions as $deferredItem) {
  710.             $expr  = $deferredItem['expression'];
  711.             $class = $this->queryComponents[$expr->identificationVariable]['metadata'];
  713.             foreach ($expr->partialFieldSet as $field) {
  714.                 if (isset($class->fieldMappings[$field])) {
  715.                     continue;
  716.                 }
  718.                 if (
  719.                     isset($class->associationMappings[$field]) &&
  720.                     $class->associationMappings[$field]['isOwningSide'] &&
  721.                     $class->associationMappings[$field]['type'] & ClassMetadata::TO_ONE
  722.                 ) {
  723.                     continue;
  724.                 }
  726.                 $this->semanticalError(sprintf(
  727.                     "There is no mapped field named '%s' on class %s.",
  728.                     $field,
  729.                     $class->name
  730.                 ), $deferredItem['token']);
  731.             }
  733.             if (array_intersect($class->identifier, $expr->partialFieldSet) !== $class->identifier) {
  734.                 $this->semanticalError(
  735.                     'The partial field selection of class ' . $class->name . ' must contain the identifier.',
  736.                     $deferredItem['token']
  737.                 );
  738.             }
  739.         }
  740.     }
  742.     /**
  743.      * Validates that the given <tt>ResultVariable</tt> is semantically correct.
  744.      * It must exist in query components list.
  745.      */
  746.     private function processDeferredResultVariables(): void
  747.     {
  748.         foreach ($this->deferredResultVariables as $deferredItem) {
  749.             $resultVariable = $deferredItem['expression'];
  751.             // Check if ResultVariable exists in queryComponents
  752.             if (! isset($this->queryComponents[$resultVariable])) {
  753.                 $this->semanticalError(
  754.                     sprintf("'%s' is not defined.", $resultVariable),
  755.                     $deferredItem['token']
  756.                 );
  757.             }
  759.             $qComp = $this->queryComponents[$resultVariable];
  761.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  762.             if (! isset($qComp['resultVariable'])) {
  763.                 $this->semanticalError(
  764.                     sprintf("'%s' does not point to a ResultVariable.", $resultVariable),
  765.                     $deferredItem['token']
  766.                 );
  767.             }
  769.             // Validate if identification variable nesting level is lower or equal than the current one
  770.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  771.                 $this->semanticalError(
  772.                     sprintf("'%s' is used outside the scope of its declaration.", $resultVariable),
  773.                     $deferredItem['token']
  774.                 );
  775.             }
  776.         }
  777.     }
  779.     /**
  780.      * Validates that the given <tt>PathExpression</tt> is semantically correct for grammar rules:
  781.      *
  782.      * AssociationPathExpression             ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  783.      * SingleValuedPathExpression            ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  784.      * StateFieldPathExpression              ::= IdentificationVariable "." StateField
  785.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  786.      * CollectionValuedPathExpression        ::= IdentificationVariable "." CollectionValuedAssociationField
  787.      */
  788.     private function processDeferredPathExpressions(): void
  789.     {
  790.         foreach ($this->deferredPathExpressions as $deferredItem) {
  791.             $pathExpression = $deferredItem['expression'];
  793.             $qComp = $this->queryComponents[$pathExpression->identificationVariable];
  794.             $class = $qComp['metadata'];
  796.             $field = $pathExpression->field;
  797.             if ($field === null) {
  798.                 $field = $pathExpression->field = $class->identifier[0];
  799.             }
  801.             // Check if field or association exists
  802.             if (! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
  803.                 $this->semanticalError(
  804.                     'Class ' . $class->name . ' has no field or association named ' . $field,
  805.                     $deferredItem['token']
  806.                 );
  807.             }
  809.             $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
  811.             if (isset($class->associationMappings[$field])) {
  812.                 $assoc = $class->associationMappings[$field];
  814.                 $fieldType = $assoc['type'] & ClassMetadata::TO_ONE
  815.                     ? AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  816.                     : AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
  817.             }
  819.             // Validate if PathExpression is one of the expected types
  820.             $expectedType = $pathExpression->expectedType;
  822.             if (! ($expectedType & $fieldType)) {
  823.                 // We need to recognize which was expected type(s)
  824.                 $expectedStringTypes = [];
  826.                 // Validate state field type
  827.                 if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
  828.                     $expectedStringTypes[] = 'StateFieldPathExpression';
  829.                 }
  831.                 // Validate single valued association (*-to-one)
  832.                 if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
  833.                     $expectedStringTypes[] = 'SingleValuedAssociationField';
  834.                 }
  836.                 // Validate single valued association (*-to-many)
  837.                 if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
  838.                     $expectedStringTypes[] = 'CollectionValuedAssociationField';
  839.                 }
  841.                 // Build the error message
  842.                 $semanticalError  = 'Invalid PathExpression. ';
  843.                 $semanticalError .= count($expectedStringTypes) === 1
  844.                     ? 'Must be a ' . $expectedStringTypes[0] . '.'
  845.                     : implode(' or ', $expectedStringTypes) . ' expected.';
  847.                 $this->semanticalError($semanticalError, $deferredItem['token']);
  848.             }
  850.             // We need to force the type in PathExpression
  851.             $pathExpression->type = $fieldType;
  852.         }
  853.     }
  855.     private function processRootEntityAliasSelected(): void
  856.     {
  857.         if (! count($this->identVariableExpressions)) {
  858.             return;
  859.         }
  861.         foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
  862.             if (isset($this->queryComponents[$dqlAlias]) && $this->queryComponents[$dqlAlias]['parent'] === null) {
  863.                 return;
  864.             }
  865.         }
  867.         $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');
  868.     }
  870.     /**
  871.      * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
  872.      *
  873.      * @return SelectStatement|UpdateStatement|DeleteStatement
  874.      */
  875.     public function QueryLanguage()
  876.     {
  877.         $statement = null;
  879.         $this->lexer->moveNext();
  881.         switch ($this->lexer->lookahead['type'] ?? null) {
  882.             case Lexer::T_SELECT:
  883.                 $statement = $this->SelectStatement();
  884.                 break;
  886.             case Lexer::T_UPDATE:
  887.                 $statement = $this->UpdateStatement();
  888.                 break;
  890.             case Lexer::T_DELETE:
  891.                 $statement = $this->DeleteStatement();
  892.                 break;
  894.             default:
  895.                 $this->syntaxError('SELECT, UPDATE or DELETE');
  896.                 break;
  897.         }
  899.         // Check for end of string
  900.         if ($this->lexer->lookahead !== null) {
  901.             $this->syntaxError('end of string');
  902.         }
  904.         return $statement;
  905.     }
  907.     /**
  908.      * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  909.      *
  910.      * @return SelectStatement
  911.      */
  912.     public function SelectStatement()
  913.     {
  914.         $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());
  916.         $selectStatement->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  917.         $selectStatement->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  918.         $selectStatement->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  919.         $selectStatement->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  921.         return $selectStatement;
  922.     }
  924.     /**
  925.      * UpdateStatement ::= UpdateClause [WhereClause]
  926.      *
  927.      * @return UpdateStatement
  928.      */
  929.     public function UpdateStatement()
  930.     {
  931.         $updateStatement = new AST\UpdateStatement($this->UpdateClause());
  933.         $updateStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  935.         return $updateStatement;
  936.     }
  938.     /**
  939.      * DeleteStatement ::= DeleteClause [WhereClause]
  940.      *
  941.      * @return DeleteStatement
  942.      */
  943.     public function DeleteStatement()
  944.     {
  945.         $deleteStatement = new AST\DeleteStatement($this->DeleteClause());
  947.         $deleteStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  949.         return $deleteStatement;
  950.     }
  952.     /**
  953.      * IdentificationVariable ::= identifier
  954.      *
  955.      * @return string
  956.      */
  957.     public function IdentificationVariable()
  958.     {
  959.         $this->match(Lexer::T_IDENTIFIER);
  961.         $identVariable = $this->lexer->token['value'];
  963.         $this->deferredIdentificationVariables[] = [
  964.             'expression'   => $identVariable,
  965.             'nestingLevel' => $this->nestingLevel,
  966.             'token'        => $this->lexer->token,
  967.         ];
  969.         return $identVariable;
  970.     }
  972.     /**
  973.      * AliasIdentificationVariable = identifier
  974.      *
  975.      * @return string
  976.      */
  977.     public function AliasIdentificationVariable()
  978.     {
  979.         $this->match(Lexer::T_IDENTIFIER);
  981.         $aliasIdentVariable = $this->lexer->token['value'];
  982.         $exists             = isset($this->queryComponents[$aliasIdentVariable]);
  984.         if ($exists) {
  985.             $this->semanticalError(
  986.                 sprintf("'%s' is already defined.", $aliasIdentVariable),
  987.                 $this->lexer->token
  988.             );
  989.         }
  991.         return $aliasIdentVariable;
  992.     }
  994.     /**
  995.      * AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
  996.      *
  997.      * @return string
  998.      */
  999.     public function AbstractSchemaName()
  1000.     {
  1001.         if ($this->lexer->isNextToken(Lexer::T_FULLY_QUALIFIED_NAME)) {
  1002.             $this->match(Lexer::T_FULLY_QUALIFIED_NAME);
  1004.             return $this->lexer->token['value'];
  1005.         }
  1007.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  1008.             $this->match(Lexer::T_IDENTIFIER);
  1010.             return $this->lexer->token['value'];
  1011.         }
  1013.         $this->match(Lexer::T_ALIASED_NAME);
  1015.         [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token['value']);
  1017.         return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  1018.     }
  1020.     /**
  1021.      * Validates an AbstractSchemaName, making sure the class exists.
  1022.      *
  1023.      * @param string $schemaName The name to validate.
  1024.      *
  1025.      * @throws QueryException if the name does not exist.
  1026.      */
  1027.     private function validateAbstractSchemaName(string $schemaName): void
  1028.     {
  1029.         if (! (class_exists($schemaName, true) || interface_exists($schemaName, true))) {
  1030.             $this->semanticalError(
  1031.                 sprintf("Class '%s' is not defined.", $schemaName),
  1032.                 $this->lexer->token
  1033.             );
  1034.         }
  1035.     }
  1037.     /**
  1038.      * AliasResultVariable ::= identifier
  1039.      *
  1040.      * @return string
  1041.      */
  1042.     public function AliasResultVariable()
  1043.     {
  1044.         $this->match(Lexer::T_IDENTIFIER);
  1046.         $resultVariable = $this->lexer->token['value'];
  1047.         $exists         = isset($this->queryComponents[$resultVariable]);
  1049.         if ($exists) {
  1050.             $this->semanticalError(
  1051.                 sprintf("'%s' is already defined.", $resultVariable),
  1052.                 $this->lexer->token
  1053.             );
  1054.         }
  1056.         return $resultVariable;
  1057.     }
  1059.     /**
  1060.      * ResultVariable ::= identifier
  1061.      *
  1062.      * @return string
  1063.      */
  1064.     public function ResultVariable()
  1065.     {
  1066.         $this->match(Lexer::T_IDENTIFIER);
  1068.         $resultVariable = $this->lexer->token['value'];
  1070.         // Defer ResultVariable validation
  1071.         $this->deferredResultVariables[] = [
  1072.             'expression'   => $resultVariable,
  1073.             'nestingLevel' => $this->nestingLevel,
  1074.             'token'        => $this->lexer->token,
  1075.         ];
  1077.         return $resultVariable;
  1078.     }
  1080.     /**
  1081.      * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
  1082.      *
  1083.      * @return JoinAssociationPathExpression
  1084.      */
  1085.     public function JoinAssociationPathExpression()
  1086.     {
  1087.         $identVariable = $this->IdentificationVariable();
  1089.         if (! isset($this->queryComponents[$identVariable])) {
  1090.             $this->semanticalError(
  1091.                 'Identification Variable ' . $identVariable . ' used in join path expression but was not defined before.'
  1092.             );
  1093.         }
  1095.         $this->match(Lexer::T_DOT);
  1096.         $this->match(Lexer::T_IDENTIFIER);
  1098.         $field = $this->lexer->token['value'];
  1100.         // Validate association field
  1101.         $qComp = $this->queryComponents[$identVariable];
  1102.         $class = $qComp['metadata'];
  1104.         if (! $class->hasAssociation($field)) {
  1105.             $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
  1106.         }
  1108.         return new AST\JoinAssociationPathExpression($identVariable, $field);
  1109.     }
  1111.     /**
  1112.      * Parses an arbitrary path expression and defers semantical validation
  1113.      * based on expected types.
  1114.      *
  1115.      * PathExpression ::= IdentificationVariable {"." identifier}*
  1116.      *
  1117.      * @param int $expectedTypes
  1118.      *
  1119.      * @return PathExpression
  1120.      */
  1121.     public function PathExpression($expectedTypes)
  1122.     {
  1123.         $identVariable = $this->IdentificationVariable();
  1124.         $field         = null;
  1126.         if ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1127.             $this->match(Lexer::T_DOT);
  1128.             $this->match(Lexer::T_IDENTIFIER);
  1130.             $field = $this->lexer->token['value'];
  1132.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1133.                 $this->match(Lexer::T_DOT);
  1134.                 $this->match(Lexer::T_IDENTIFIER);
  1135.                 $field .= '.' . $this->lexer->token['value'];
  1136.             }
  1137.         }
  1139.         // Creating AST node
  1140.         $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);
  1142.         // Defer PathExpression validation if requested to be deferred
  1143.         $this->deferredPathExpressions[] = [
  1144.             'expression'   => $pathExpr,
  1145.             'nestingLevel' => $this->nestingLevel,
  1146.             'token'        => $this->lexer->token,
  1147.         ];
  1149.         return $pathExpr;
  1150.     }
  1152.     /**
  1153.      * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  1154.      *
  1155.      * @return PathExpression
  1156.      */
  1157.     public function AssociationPathExpression()
  1158.     {
  1159.         return $this->PathExpression(
  1160.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |
  1161.             AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION
  1162.         );
  1163.     }
  1165.     /**
  1166.      * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  1167.      *
  1168.      * @return PathExpression
  1169.      */
  1170.     public function SingleValuedPathExpression()
  1171.     {
  1172.         return $this->PathExpression(
  1173.             AST\PathExpression::TYPE_STATE_FIELD |
  1174.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  1175.         );
  1176.     }
  1178.     /**
  1179.      * StateFieldPathExpression ::= IdentificationVariable "." StateField
  1180.      *
  1181.      * @return PathExpression
  1182.      */
  1183.     public function StateFieldPathExpression()
  1184.     {
  1185.         return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);
  1186.     }
  1188.     /**
  1189.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  1190.      *
  1191.      * @return PathExpression
  1192.      */
  1193.     public function SingleValuedAssociationPathExpression()
  1194.     {
  1195.         return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);
  1196.     }
  1198.     /**
  1199.      * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  1200.      *
  1201.      * @return PathExpression
  1202.      */
  1203.     public function CollectionValuedPathExpression()
  1204.     {
  1205.         return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);
  1206.     }
  1208.     /**
  1209.      * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
  1210.      *
  1211.      * @return SelectClause
  1212.      */
  1213.     public function SelectClause()
  1214.     {
  1215.         $isDistinct = false;
  1216.         $this->match(Lexer::T_SELECT);
  1218.         // Check for DISTINCT
  1219.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1220.             $this->match(Lexer::T_DISTINCT);
  1222.             $isDistinct = true;
  1223.         }
  1225.         // Process SelectExpressions (1..N)
  1226.         $selectExpressions   = [];
  1227.         $selectExpressions[] = $this->SelectExpression();
  1229.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1230.             $this->match(Lexer::T_COMMA);
  1232.             $selectExpressions[] = $this->SelectExpression();
  1233.         }
  1235.         return new AST\SelectClause($selectExpressions, $isDistinct);
  1236.     }
  1238.     /**
  1239.      * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
  1240.      *
  1241.      * @return SimpleSelectClause
  1242.      */
  1243.     public function SimpleSelectClause()
  1244.     {
  1245.         $isDistinct = false;
  1246.         $this->match(Lexer::T_SELECT);
  1248.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1249.             $this->match(Lexer::T_DISTINCT);
  1251.             $isDistinct = true;
  1252.         }
  1254.         return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);
  1255.     }
  1257.     /**
  1258.      * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*
  1259.      *
  1260.      * @return UpdateClause
  1261.      */
  1262.     public function UpdateClause()
  1263.     {
  1264.         $this->match(Lexer::T_UPDATE);
  1266.         $token              = $this->lexer->lookahead;
  1267.         $abstractSchemaName = $this->AbstractSchemaName();
  1269.         $this->validateAbstractSchemaName($abstractSchemaName);
  1271.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1272.             $this->match(Lexer::T_AS);
  1273.         }
  1275.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1277.         $class = $this->em->getClassMetadata($abstractSchemaName);
  1279.         // Building queryComponent
  1280.         $queryComponent = [
  1281.             'metadata'     => $class,
  1282.             'parent'       => null,
  1283.             'relation'     => null,
  1284.             'map'          => null,
  1285.             'nestingLevel' => $this->nestingLevel,
  1286.             'token'        => $token,
  1287.         ];
  1289.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1291.         $this->match(Lexer::T_SET);
  1293.         $updateItems   = [];
  1294.         $updateItems[] = $this->UpdateItem();
  1296.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1297.             $this->match(Lexer::T_COMMA);
  1299.             $updateItems[] = $this->UpdateItem();
  1300.         }
  1302.         $updateClause                              = new AST\UpdateClause($abstractSchemaName, $updateItems);
  1303.         $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1305.         return $updateClause;
  1306.     }
  1308.     /**
  1309.      * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable
  1310.      *
  1311.      * @return DeleteClause
  1312.      */
  1313.     public function DeleteClause()
  1314.     {
  1315.         $this->match(Lexer::T_DELETE);
  1317.         if ($this->lexer->isNextToken(Lexer::T_FROM)) {
  1318.             $this->match(Lexer::T_FROM);
  1319.         }
  1321.         $token              = $this->lexer->lookahead;
  1322.         $abstractSchemaName = $this->AbstractSchemaName();
  1324.         $this->validateAbstractSchemaName($abstractSchemaName);
  1326.         $deleteClause = new AST\DeleteClause($abstractSchemaName);
  1328.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1329.             $this->match(Lexer::T_AS);
  1330.         }
  1332.         $aliasIdentificationVariable = $this->lexer->isNextToken(Lexer::T_IDENTIFIER)
  1333.             ? $this->AliasIdentificationVariable()
  1334.             : 'alias_should_have_been_set';
  1336.         $deleteClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1337.         $class                                     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1339.         // Building queryComponent
  1340.         $queryComponent = [
  1341.             'metadata'     => $class,
  1342.             'parent'       => null,
  1343.             'relation'     => null,
  1344.             'map'          => null,
  1345.             'nestingLevel' => $this->nestingLevel,
  1346.             'token'        => $token,
  1347.         ];
  1349.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1351.         return $deleteClause;
  1352.     }
  1354.     /**
  1355.      * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}*
  1356.      *
  1357.      * @return FromClause
  1358.      */
  1359.     public function FromClause()
  1360.     {
  1361.         $this->match(Lexer::T_FROM);
  1363.         $identificationVariableDeclarations   = [];
  1364.         $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1366.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1367.             $this->match(Lexer::T_COMMA);
  1369.             $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1370.         }
  1372.         return new AST\FromClause($identificationVariableDeclarations);
  1373.     }
  1375.     /**
  1376.      * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
  1377.      *
  1378.      * @return SubselectFromClause
  1379.      */
  1380.     public function SubselectFromClause()
  1381.     {
  1382.         $this->match(Lexer::T_FROM);
  1384.         $identificationVariables   = [];
  1385.         $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1387.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1388.             $this->match(Lexer::T_COMMA);
  1390.             $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1391.         }
  1393.         return new AST\SubselectFromClause($identificationVariables);
  1394.     }
  1396.     /**
  1397.      * WhereClause ::= "WHERE" ConditionalExpression
  1398.      *
  1399.      * @return WhereClause
  1400.      */
  1401.     public function WhereClause()
  1402.     {
  1403.         $this->match(Lexer::T_WHERE);
  1405.         return new AST\WhereClause($this->ConditionalExpression());
  1406.     }
  1408.     /**
  1409.      * HavingClause ::= "HAVING" ConditionalExpression
  1410.      *
  1411.      * @return HavingClause
  1412.      */
  1413.     public function HavingClause()
  1414.     {
  1415.         $this->match(Lexer::T_HAVING);
  1417.         return new AST\HavingClause($this->ConditionalExpression());
  1418.     }
  1420.     /**
  1421.      * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
  1422.      *
  1423.      * @return GroupByClause
  1424.      */
  1425.     public function GroupByClause()
  1426.     {
  1427.         $this->match(Lexer::T_GROUP);
  1428.         $this->match(Lexer::T_BY);
  1430.         $groupByItems = [$this->GroupByItem()];
  1432.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1433.             $this->match(Lexer::T_COMMA);
  1435.             $groupByItems[] = $this->GroupByItem();
  1436.         }
  1438.         return new AST\GroupByClause($groupByItems);
  1439.     }
  1441.     /**
  1442.      * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
  1443.      *
  1444.      * @return OrderByClause
  1445.      */
  1446.     public function OrderByClause()
  1447.     {
  1448.         $this->match(Lexer::T_ORDER);
  1449.         $this->match(Lexer::T_BY);
  1451.         $orderByItems   = [];
  1452.         $orderByItems[] = $this->OrderByItem();
  1454.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1455.             $this->match(Lexer::T_COMMA);
  1457.             $orderByItems[] = $this->OrderByItem();
  1458.         }
  1460.         return new AST\OrderByClause($orderByItems);
  1461.     }
  1463.     /**
  1464.      * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  1465.      *
  1466.      * @return Subselect
  1467.      */
  1468.     public function Subselect()
  1469.     {
  1470.         // Increase query nesting level
  1471.         $this->nestingLevel++;
  1473.         $subselect = new AST\Subselect($this->SimpleSelectClause(), $this->SubselectFromClause());
  1475.         $subselect->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  1476.         $subselect->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  1477.         $subselect->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  1478.         $subselect->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  1480.         // Decrease query nesting level
  1481.         $this->nestingLevel--;
  1483.         return $subselect;
  1484.     }
  1486.     /**
  1487.      * UpdateItem ::= SingleValuedPathExpression "=" NewValue
  1488.      *
  1489.      * @return UpdateItem
  1490.      */
  1491.     public function UpdateItem()
  1492.     {
  1493.         $pathExpr = $this->SingleValuedPathExpression();
  1495.         $this->match(Lexer::T_EQUALS);
  1497.         return new AST\UpdateItem($pathExpr, $this->NewValue());
  1498.     }
  1500.     /**
  1501.      * GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression
  1502.      *
  1503.      * @return string|PathExpression
  1504.      */
  1505.     public function GroupByItem()
  1506.     {
  1507.         // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  1508.         $glimpse = $this->lexer->glimpse();
  1510.         if ($glimpse !== null && $glimpse['type'] === Lexer::T_DOT) {
  1511.             return $this->SingleValuedPathExpression();
  1512.         }
  1514.         // Still need to decide between IdentificationVariable or ResultVariable
  1515.         $lookaheadValue = $this->lexer->lookahead['value'];
  1517.         if (! isset($this->queryComponents[$lookaheadValue])) {
  1518.             $this->semanticalError('Cannot group by undefined identification or result variable.');
  1519.         }
  1521.         return isset($this->queryComponents[$lookaheadValue]['metadata'])
  1522.             ? $this->IdentificationVariable()
  1523.             : $this->ResultVariable();
  1524.     }
  1526.     /**
  1527.      * OrderByItem ::= (
  1528.      *      SimpleArithmeticExpression | SingleValuedPathExpression | CaseExpression |
  1529.      *      ScalarExpression | ResultVariable | FunctionDeclaration
  1530.      * ) ["ASC" | "DESC"]
  1531.      *
  1532.      * @return OrderByItem
  1533.      */
  1534.     public function OrderByItem()
  1535.     {
  1536.         $this->lexer->peek(); // lookahead => '.'
  1537.         $this->lexer->peek(); // lookahead => token after '.'
  1539.         $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1541.         $this->lexer->resetPeek();
  1543.         $glimpse = $this->lexer->glimpse();
  1545.         switch (true) {
  1546.             case $this->isMathOperator($peek):
  1547.                 $expr = $this->SimpleArithmeticExpression();
  1548.                 break;
  1550.             case $glimpse !== null && $glimpse['type'] === Lexer::T_DOT:
  1551.                 $expr = $this->SingleValuedPathExpression();
  1552.                 break;
  1554.             case $this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  1555.                 $expr = $this->ScalarExpression();
  1556.                 break;
  1558.             case $this->lexer->lookahead['type'] === Lexer::T_CASE:
  1559.                 $expr = $this->CaseExpression();
  1560.                 break;
  1562.             case $this->isFunction():
  1563.                 $expr = $this->FunctionDeclaration();
  1564.                 break;
  1566.             default:
  1567.                 $expr = $this->ResultVariable();
  1568.                 break;
  1569.         }
  1571.         $type = 'ASC';
  1572.         $item = new AST\OrderByItem($expr);
  1574.         switch (true) {
  1575.             case $this->lexer->isNextToken(Lexer::T_DESC):
  1576.                 $this->match(Lexer::T_DESC);
  1577.                 $type = 'DESC';
  1578.                 break;
  1580.             case $this->lexer->isNextToken(Lexer::T_ASC):
  1581.                 $this->match(Lexer::T_ASC);
  1582.                 break;
  1584.             default:
  1585.                 // Do nothing
  1586.         }
  1588.         $item->type = $type;
  1590.         return $item;
  1591.     }
  1593.     /**
  1594.      * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
  1595.      *      EnumPrimary | SimpleEntityExpression | "NULL"
  1596.      *
  1597.      * NOTE: Since it is not possible to correctly recognize individual types, here is the full
  1598.      * grammar that needs to be supported:
  1599.      *
  1600.      * NewValue ::= SimpleArithmeticExpression | "NULL"
  1601.      *
  1602.      * SimpleArithmeticExpression covers all *Primary grammar rules and also SimpleEntityExpression
  1603.      *
  1604.      * @return AST\ArithmeticExpression|AST\InputParameter|null
  1605.      */
  1606.     public function NewValue()
  1607.     {
  1608.         if ($this->lexer->isNextToken(Lexer::T_NULL)) {
  1609.             $this->match(Lexer::T_NULL);
  1611.             return null;
  1612.         }
  1614.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  1615.             $this->match(Lexer::T_INPUT_PARAMETER);
  1617.             return new AST\InputParameter($this->lexer->token['value']);
  1618.         }
  1620.         return $this->ArithmeticExpression();
  1621.     }
  1623.     /**
  1624.      * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*
  1625.      *
  1626.      * @return IdentificationVariableDeclaration
  1627.      */
  1628.     public function IdentificationVariableDeclaration()
  1629.     {
  1630.         $joins                    = [];
  1631.         $rangeVariableDeclaration = $this->RangeVariableDeclaration();
  1632.         $indexBy                  = $this->lexer->isNextToken(Lexer::T_INDEX)
  1633.             ? $this->IndexBy()
  1634.             : null;
  1636.         $rangeVariableDeclaration->isRoot = true;
  1638.         while (
  1639.             $this->lexer->isNextToken(Lexer::T_LEFT) ||
  1640.             $this->lexer->isNextToken(Lexer::T_INNER) ||
  1641.             $this->lexer->isNextToken(Lexer::T_JOIN)
  1642.         ) {
  1643.             $joins[] = $this->Join();
  1644.         }
  1646.         return new AST\IdentificationVariableDeclaration(
  1647.             $rangeVariableDeclaration,
  1648.             $indexBy,
  1649.             $joins
  1650.         );
  1651.     }
  1653.     /**
  1654.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration
  1655.      *
  1656.      * {Internal note: WARNING: Solution is harder than a bare implementation.
  1657.      * Desired EBNF support:
  1658.      *
  1659.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
  1660.      *
  1661.      * It demands that entire SQL generation to become programmatical. This is
  1662.      * needed because association based subselect requires "WHERE" conditional
  1663.      * expressions to be injected, but there is no scope to do that. Only scope
  1664.      * accessible is "FROM", prohibiting an easy implementation without larger
  1665.      * changes.}
  1666.      *
  1667.      * @return IdentificationVariableDeclaration
  1668.      */
  1669.     public function SubselectIdentificationVariableDeclaration()
  1670.     {
  1671.         /*
  1672.         NOT YET IMPLEMENTED!
  1674.         $glimpse = $this->lexer->glimpse();
  1676.         if ($glimpse['type'] == Lexer::T_DOT) {
  1677.             $associationPathExpression = $this->AssociationPathExpression();
  1679.             if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1680.                 $this->match(Lexer::T_AS);
  1681.             }
  1683.             $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1684.             $identificationVariable      = $associationPathExpression->identificationVariable;
  1685.             $field                       = $associationPathExpression->associationField;
  1687.             $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1688.             $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1690.             // Building queryComponent
  1691.             $joinQueryComponent = array(
  1692.                 'metadata'     => $targetClass,
  1693.                 'parent'       => $identificationVariable,
  1694.                 'relation'     => $class->getAssociationMapping($field),
  1695.                 'map'          => null,
  1696.                 'nestingLevel' => $this->nestingLevel,
  1697.                 'token'        => $this->lexer->lookahead
  1698.             );
  1700.             $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1702.             return new AST\SubselectIdentificationVariableDeclaration(
  1703.                 $associationPathExpression, $aliasIdentificationVariable
  1704.             );
  1705.         }
  1706.         */
  1708.         return $this->IdentificationVariableDeclaration();
  1709.     }
  1711.     /**
  1712.      * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN"
  1713.      *          (JoinAssociationDeclaration | RangeVariableDeclaration)
  1714.      *          ["WITH" ConditionalExpression]
  1715.      *
  1716.      * @return Join
  1717.      */
  1718.     public function Join()
  1719.     {
  1720.         // Check Join type
  1721.         $joinType = AST\Join::JOIN_TYPE_INNER;
  1723.         switch (true) {
  1724.             case $this->lexer->isNextToken(Lexer::T_LEFT):
  1725.                 $this->match(Lexer::T_LEFT);
  1727.                 $joinType = AST\Join::JOIN_TYPE_LEFT;
  1729.                 // Possible LEFT OUTER join
  1730.                 if ($this->lexer->isNextToken(Lexer::T_OUTER)) {
  1731.                     $this->match(Lexer::T_OUTER);
  1733.                     $joinType = AST\Join::JOIN_TYPE_LEFTOUTER;
  1734.                 }
  1736.                 break;
  1738.             case $this->lexer->isNextToken(Lexer::T_INNER):
  1739.                 $this->match(Lexer::T_INNER);
  1740.                 break;
  1742.             default:
  1743.                 // Do nothing
  1744.         }
  1746.         $this->match(Lexer::T_JOIN);
  1748.         $next            = $this->lexer->glimpse();
  1749.         $joinDeclaration = $next['type'] === Lexer::T_DOT ? $this->JoinAssociationDeclaration() : $this->RangeVariableDeclaration();
  1750.         $adhocConditions = $this->lexer->isNextToken(Lexer::T_WITH);
  1751.         $join            = new AST\Join($joinType, $joinDeclaration);
  1753.         // Describe non-root join declaration
  1754.         if ($joinDeclaration instanceof AST\RangeVariableDeclaration) {
  1755.             $joinDeclaration->isRoot = false;
  1756.         }
  1758.         // Check for ad-hoc Join conditions
  1759.         if ($adhocConditions) {
  1760.             $this->match(Lexer::T_WITH);
  1762.             $join->conditionalExpression = $this->ConditionalExpression();
  1763.         }
  1765.         return $join;
  1766.     }
  1768.     /**
  1769.      * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
  1770.      *
  1771.      * @return RangeVariableDeclaration
  1772.      *
  1773.      * @throws QueryException
  1774.      */
  1775.     public function RangeVariableDeclaration()
  1776.     {
  1777.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $this->lexer->glimpse()['type'] === Lexer::T_SELECT) {
  1778.             $this->semanticalError('Subquery is not supported here', $this->lexer->token);
  1779.         }
  1781.         $abstractSchemaName = $this->AbstractSchemaName();
  1783.         $this->validateAbstractSchemaName($abstractSchemaName);
  1785.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1786.             $this->match(Lexer::T_AS);
  1787.         }
  1789.         $token                       = $this->lexer->lookahead;
  1790.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1791.         $classMetadata               = $this->em->getClassMetadata($abstractSchemaName);
  1793.         // Building queryComponent
  1794.         $queryComponent = [
  1795.             'metadata'     => $classMetadata,
  1796.             'parent'       => null,
  1797.             'relation'     => null,
  1798.             'map'          => null,
  1799.             'nestingLevel' => $this->nestingLevel,
  1800.             'token'        => $token,
  1801.         ];
  1803.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1805.         return new AST\RangeVariableDeclaration($abstractSchemaName, $aliasIdentificationVariable);
  1806.     }
  1808.     /**
  1809.      * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [IndexBy]
  1810.      *
  1811.      * @return AST\JoinAssociationDeclaration
  1812.      */
  1813.     public function JoinAssociationDeclaration()
  1814.     {
  1815.         $joinAssociationPathExpression = $this->JoinAssociationPathExpression();
  1817.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1818.             $this->match(Lexer::T_AS);
  1819.         }
  1821.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1822.         $indexBy                     = $this->lexer->isNextToken(Lexer::T_INDEX) ? $this->IndexBy() : null;
  1824.         $identificationVariable = $joinAssociationPathExpression->identificationVariable;
  1825.         $field                  = $joinAssociationPathExpression->associationField;
  1827.         $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1828.         $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1830.         // Building queryComponent
  1831.         $joinQueryComponent = [
  1832.             'metadata'     => $targetClass,
  1833.             'parent'       => $joinAssociationPathExpression->identificationVariable,
  1834.             'relation'     => $class->getAssociationMapping($field),
  1835.             'map'          => null,
  1836.             'nestingLevel' => $this->nestingLevel,
  1837.             'token'        => $this->lexer->lookahead,
  1838.         ];
  1840.         $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1842.         return new AST\JoinAssociationDeclaration($joinAssociationPathExpression, $aliasIdentificationVariable, $indexBy);
  1843.     }
  1845.     /**
  1846.      * PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
  1847.      * PartialFieldSet ::= "{" SimpleStateField {"," SimpleStateField}* "}"
  1848.      *
  1849.      * @return PartialObjectExpression
  1850.      */
  1851.     public function PartialObjectExpression()
  1852.     {
  1853.         Deprecation::trigger(
  1854.             'doctrine/orm',
  1855.             'https://github.com/doctrine/orm/issues/8471',
  1856.             'PARTIAL syntax in DQL is deprecated.'
  1857.         );
  1859.         $this->match(Lexer::T_PARTIAL);
  1861.         $partialFieldSet = [];
  1863.         $identificationVariable = $this->IdentificationVariable();
  1865.         $this->match(Lexer::T_DOT);
  1866.         $this->match(Lexer::T_OPEN_CURLY_BRACE);
  1867.         $this->match(Lexer::T_IDENTIFIER);
  1869.         $field = $this->lexer->token['value'];
  1871.         // First field in partial expression might be embeddable property
  1872.         while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1873.             $this->match(Lexer::T_DOT);
  1874.             $this->match(Lexer::T_IDENTIFIER);
  1875.             $field .= '.' . $this->lexer->token['value'];
  1876.         }
  1878.         $partialFieldSet[] = $field;
  1880.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1881.             $this->match(Lexer::T_COMMA);
  1882.             $this->match(Lexer::T_IDENTIFIER);
  1884.             $field = $this->lexer->token['value'];
  1886.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1887.                 $this->match(Lexer::T_DOT);
  1888.                 $this->match(Lexer::T_IDENTIFIER);
  1889.                 $field .= '.' . $this->lexer->token['value'];
  1890.             }
  1892.             $partialFieldSet[] = $field;
  1893.         }
  1895.         $this->match(Lexer::T_CLOSE_CURLY_BRACE);
  1897.         $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
  1899.         // Defer PartialObjectExpression validation
  1900.         $this->deferredPartialObjectExpressions[] = [
  1901.             'expression'   => $partialObjectExpression,
  1902.             'nestingLevel' => $this->nestingLevel,
  1903.             'token'        => $this->lexer->token,
  1904.         ];
  1906.         return $partialObjectExpression;
  1907.     }
  1909.     /**
  1910.      * NewObjectExpression ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
  1911.      *
  1912.      * @return NewObjectExpression
  1913.      */
  1914.     public function NewObjectExpression()
  1915.     {
  1916.         $this->match(Lexer::T_NEW);
  1918.         $className = $this->AbstractSchemaName(); // note that this is not yet validated
  1919.         $token     = $this->lexer->token;
  1921.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  1923.         $args[] = $this->NewObjectArg();
  1925.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1926.             $this->match(Lexer::T_COMMA);
  1928.             $args[] = $this->NewObjectArg();
  1929.         }
  1931.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1933.         $expression = new AST\NewObjectExpression($className, $args);
  1935.         // Defer NewObjectExpression validation
  1936.         $this->deferredNewObjectExpressions[] = [
  1937.             'token'        => $token,
  1938.             'expression'   => $expression,
  1939.             'nestingLevel' => $this->nestingLevel,
  1940.         ];
  1942.         return $expression;
  1943.     }
  1945.     /**
  1946.      * NewObjectArg ::= ScalarExpression | "(" Subselect ")"
  1947.      *
  1948.      * @return mixed
  1949.      */
  1950.     public function NewObjectArg()
  1951.     {
  1952.         $token = $this->lexer->lookahead;
  1953.         $peek  = $this->lexer->glimpse();
  1955.         if ($token['type'] === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT) {
  1956.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  1957.             $expression = $this->Subselect();
  1958.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1960.             return $expression;
  1961.         }
  1963.         return $this->ScalarExpression();
  1964.     }
  1966.     /**
  1967.      * IndexBy ::= "INDEX" "BY" SingleValuedPathExpression
  1968.      *
  1969.      * @return IndexBy
  1970.      */
  1971.     public function IndexBy()
  1972.     {
  1973.         $this->match(Lexer::T_INDEX);
  1974.         $this->match(Lexer::T_BY);
  1975.         $pathExpr = $this->SingleValuedPathExpression();
  1977.         // Add the INDEX BY info to the query component
  1978.         $this->queryComponents[$pathExpr->identificationVariable]['map'] = $pathExpr->field;
  1980.         return new AST\IndexBy($pathExpr);
  1981.     }
  1983.     /**
  1984.      * ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DateTimePrimary |
  1985.      *                      StateFieldPathExpression | BooleanPrimary | CaseExpression |
  1986.      *                      InstanceOfExpression
  1987.      *
  1988.      * @return mixed One of the possible expressions or subexpressions.
  1989.      */
  1990.     public function ScalarExpression()
  1991.     {
  1992.         $lookahead = $this->lexer->lookahead['type'];
  1993.         $peek      = $this->lexer->glimpse();
  1995.         switch (true) {
  1996.             case $lookahead === Lexer::T_INTEGER:
  1997.             case $lookahead === Lexer::T_FLOAT:
  1998.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )  or ( - 1 ) or ( + 1 )
  1999.             case $lookahead === Lexer::T_MINUS:
  2000.             case $lookahead === Lexer::T_PLUS:
  2001.                 return $this->SimpleArithmeticExpression();
  2003.             case $lookahead === Lexer::T_STRING:
  2004.                 return $this->StringPrimary();
  2006.             case $lookahead === Lexer::T_TRUE:
  2007.             case $lookahead === Lexer::T_FALSE:
  2008.                 $this->match($lookahead);
  2010.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2012.             case $lookahead === Lexer::T_INPUT_PARAMETER:
  2013.                 switch (true) {
  2014.                     case $this->isMathOperator($peek):
  2015.                         // :param + u.value
  2016.                         return $this->SimpleArithmeticExpression();
  2018.                     default:
  2019.                         return $this->InputParameter();
  2020.                 }
  2021.             case $lookahead === Lexer::T_CASE:
  2022.             case $lookahead === Lexer::T_COALESCE:
  2023.             case $lookahead === Lexer::T_NULLIF:
  2024.                 // Since NULLIF and COALESCE can be identified as a function,
  2025.                 // we need to check these before checking for FunctionDeclaration
  2026.                 return $this->CaseExpression();
  2028.             case $lookahead === Lexer::T_OPEN_PARENTHESIS:
  2029.                 return $this->SimpleArithmeticExpression();
  2031.             // this check must be done before checking for a filed path expression
  2032.             case $this->isFunction():
  2033.                 $this->lexer->peek(); // "("
  2035.                 switch (true) {
  2036.                     case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2037.                         // SUM(u.id) + COUNT(u.id)
  2038.                         return $this->SimpleArithmeticExpression();
  2040.                     default:
  2041.                         // IDENTITY(u)
  2042.                         return $this->FunctionDeclaration();
  2043.                 }
  2045.                 break;
  2046.             // it is no function, so it must be a field path
  2047.             case $lookahead === Lexer::T_IDENTIFIER:
  2048.                 $this->lexer->peek(); // lookahead => '.'
  2049.                 $this->lexer->peek(); // lookahead => token after '.'
  2050.                 $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  2051.                 $this->lexer->resetPeek();
  2053.                 if ($this->isMathOperator($peek)) {
  2054.                     return $this->SimpleArithmeticExpression();
  2055.                 }
  2057.                 return $this->StateFieldPathExpression();
  2059.             default:
  2060.                 $this->syntaxError();
  2061.         }
  2062.     }
  2064.     /**
  2065.      * CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullifExpression
  2066.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2067.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2068.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2069.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2070.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2071.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2072.      * NullifExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2073.      *
  2074.      * @return mixed One of the possible expressions or subexpressions.
  2075.      */
  2076.     public function CaseExpression()
  2077.     {
  2078.         $lookahead = $this->lexer->lookahead['type'];
  2080.         switch ($lookahead) {
  2081.             case Lexer::T_NULLIF:
  2082.                 return $this->NullIfExpression();
  2084.             case Lexer::T_COALESCE:
  2085.                 return $this->CoalesceExpression();
  2087.             case Lexer::T_CASE:
  2088.                 $this->lexer->resetPeek();
  2089.                 $peek = $this->lexer->peek();
  2091.                 if ($peek['type'] === Lexer::T_WHEN) {
  2092.                     return $this->GeneralCaseExpression();
  2093.                 }
  2095.                 return $this->SimpleCaseExpression();
  2097.             default:
  2098.                 // Do nothing
  2099.                 break;
  2100.         }
  2102.         $this->syntaxError();
  2103.     }
  2105.     /**
  2106.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2107.      *
  2108.      * @return CoalesceExpression
  2109.      */
  2110.     public function CoalesceExpression()
  2111.     {
  2112.         $this->match(Lexer::T_COALESCE);
  2113.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2115.         // Process ScalarExpressions (1..N)
  2116.         $scalarExpressions   = [];
  2117.         $scalarExpressions[] = $this->ScalarExpression();
  2119.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  2120.             $this->match(Lexer::T_COMMA);
  2122.             $scalarExpressions[] = $this->ScalarExpression();
  2123.         }
  2125.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2127.         return new AST\CoalesceExpression($scalarExpressions);
  2128.     }
  2130.     /**
  2131.      * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2132.      *
  2133.      * @return NullIfExpression
  2134.      */
  2135.     public function NullIfExpression()
  2136.     {
  2137.         $this->match(Lexer::T_NULLIF);
  2138.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2140.         $firstExpression = $this->ScalarExpression();
  2141.         $this->match(Lexer::T_COMMA);
  2142.         $secondExpression = $this->ScalarExpression();
  2144.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2146.         return new AST\NullIfExpression($firstExpression, $secondExpression);
  2147.     }
  2149.     /**
  2150.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2151.      *
  2152.      * @return GeneralCaseExpression
  2153.      */
  2154.     public function GeneralCaseExpression()
  2155.     {
  2156.         $this->match(Lexer::T_CASE);
  2158.         // Process WhenClause (1..N)
  2159.         $whenClauses = [];
  2161.         do {
  2162.             $whenClauses[] = $this->WhenClause();
  2163.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2165.         $this->match(Lexer::T_ELSE);
  2166.         $scalarExpression = $this->ScalarExpression();
  2167.         $this->match(Lexer::T_END);
  2169.         return new AST\GeneralCaseExpression($whenClauses, $scalarExpression);
  2170.     }
  2172.     /**
  2173.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2174.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2175.      *
  2176.      * @return AST\SimpleCaseExpression
  2177.      */
  2178.     public function SimpleCaseExpression()
  2179.     {
  2180.         $this->match(Lexer::T_CASE);
  2181.         $caseOperand = $this->StateFieldPathExpression();
  2183.         // Process SimpleWhenClause (1..N)
  2184.         $simpleWhenClauses = [];
  2186.         do {
  2187.             $simpleWhenClauses[] = $this->SimpleWhenClause();
  2188.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2190.         $this->match(Lexer::T_ELSE);
  2191.         $scalarExpression = $this->ScalarExpression();
  2192.         $this->match(Lexer::T_END);
  2194.         return new AST\SimpleCaseExpression($caseOperand, $simpleWhenClauses, $scalarExpression);
  2195.     }
  2197.     /**
  2198.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2199.      *
  2200.      * @return WhenClause
  2201.      */
  2202.     public function WhenClause()
  2203.     {
  2204.         $this->match(Lexer::T_WHEN);
  2205.         $conditionalExpression = $this->ConditionalExpression();
  2206.         $this->match(Lexer::T_THEN);
  2208.         return new AST\WhenClause($conditionalExpression, $this->ScalarExpression());
  2209.     }
  2211.     /**
  2212.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2213.      *
  2214.      * @return SimpleWhenClause
  2215.      */
  2216.     public function SimpleWhenClause()
  2217.     {
  2218.         $this->match(Lexer::T_WHEN);
  2219.         $conditionalExpression = $this->ScalarExpression();
  2220.         $this->match(Lexer::T_THEN);
  2222.         return new AST\SimpleWhenClause($conditionalExpression, $this->ScalarExpression());
  2223.     }
  2225.     /**
  2226.      * SelectExpression ::= (
  2227.      *     IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration |
  2228.      *     PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression
  2229.      * ) [["AS"] ["HIDDEN"] AliasResultVariable]
  2230.      *
  2231.      * @return SelectExpression
  2232.      */
  2233.     public function SelectExpression()
  2234.     {
  2235.         $expression    = null;
  2236.         $identVariable = null;
  2237.         $peek          = $this->lexer->glimpse();
  2238.         $lookaheadType = $this->lexer->lookahead['type'];
  2240.         switch (true) {
  2241.             // ScalarExpression (u.name)
  2242.             case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] === Lexer::T_DOT:
  2243.                 $expression = $this->ScalarExpression();
  2244.                 break;
  2246.             // IdentificationVariable (u)
  2247.             case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2248.                 $expression = $identVariable = $this->IdentificationVariable();
  2249.                 break;
  2251.             // CaseExpression (CASE ... or NULLIF(...) or COALESCE(...))
  2252.             case $lookaheadType === Lexer::T_CASE:
  2253.             case $lookaheadType === Lexer::T_COALESCE:
  2254.             case $lookaheadType === Lexer::T_NULLIF:
  2255.                 $expression = $this->CaseExpression();
  2256.                 break;
  2258.             // DQL Function (SUM(u.value) or SUM(u.value) + 1)
  2259.             case $this->isFunction():
  2260.                 $this->lexer->peek(); // "("
  2262.                 switch (true) {
  2263.                     case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2264.                         // SUM(u.id) + COUNT(u.id)
  2265.                         $expression = $this->ScalarExpression();
  2266.                         break;
  2268.                     default:
  2269.                         // IDENTITY(u)
  2270.                         $expression = $this->FunctionDeclaration();
  2271.                         break;
  2272.                 }
  2274.                 break;
  2276.             // PartialObjectExpression (PARTIAL u.{id, name})
  2277.             case $lookaheadType === Lexer::T_PARTIAL:
  2278.                 $expression    = $this->PartialObjectExpression();
  2279.                 $identVariable = $expression->identificationVariable;
  2280.                 break;
  2282.             // Subselect
  2283.             case $lookaheadType === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT:
  2284.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2285.                 $expression = $this->Subselect();
  2286.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2287.                 break;
  2289.             // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2290.             case $lookaheadType === Lexer::T_OPEN_PARENTHESIS:
  2291.             case $lookaheadType === Lexer::T_INTEGER:
  2292.             case $lookaheadType === Lexer::T_STRING:
  2293.             case $lookaheadType === Lexer::T_FLOAT:
  2294.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )
  2295.             case $lookaheadType === Lexer::T_MINUS:
  2296.             case $lookaheadType === Lexer::T_PLUS:
  2297.                 $expression = $this->SimpleArithmeticExpression();
  2298.                 break;
  2300.             // NewObjectExpression (New ClassName(id, name))
  2301.             case $lookaheadType === Lexer::T_NEW:
  2302.                 $expression = $this->NewObjectExpression();
  2303.                 break;
  2305.             default:
  2306.                 $this->syntaxError(
  2307.                     'IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression',
  2308.                     $this->lexer->lookahead
  2309.                 );
  2310.         }
  2312.         // [["AS"] ["HIDDEN"] AliasResultVariable]
  2313.         $mustHaveAliasResultVariable = false;
  2315.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2316.             $this->match(Lexer::T_AS);
  2318.             $mustHaveAliasResultVariable = true;
  2319.         }
  2321.         $hiddenAliasResultVariable = false;
  2323.         if ($this->lexer->isNextToken(Lexer::T_HIDDEN)) {
  2324.             $this->match(Lexer::T_HIDDEN);
  2326.             $hiddenAliasResultVariable = true;
  2327.         }
  2329.         $aliasResultVariable = null;
  2331.         if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2332.             $token               = $this->lexer->lookahead;
  2333.             $aliasResultVariable = $this->AliasResultVariable();
  2335.             // Include AliasResultVariable in query components.
  2336.             $this->queryComponents[$aliasResultVariable] = [
  2337.                 'resultVariable' => $expression,
  2338.                 'nestingLevel'   => $this->nestingLevel,
  2339.                 'token'          => $token,
  2340.             ];
  2341.         }
  2343.         // AST
  2345.         $expr = new AST\SelectExpression($expression, $aliasResultVariable, $hiddenAliasResultVariable);
  2347.         if ($identVariable) {
  2348.             $this->identVariableExpressions[$identVariable] = $expr;
  2349.         }
  2351.         return $expr;
  2352.     }
  2354.     /**
  2355.      * SimpleSelectExpression ::= (
  2356.      *      StateFieldPathExpression | IdentificationVariable | FunctionDeclaration |
  2357.      *      AggregateExpression | "(" Subselect ")" | ScalarExpression
  2358.      * ) [["AS"] AliasResultVariable]
  2359.      *
  2360.      * @return SimpleSelectExpression
  2361.      */
  2362.     public function SimpleSelectExpression()
  2363.     {
  2364.         $peek = $this->lexer->glimpse();
  2366.         switch ($this->lexer->lookahead['type']) {
  2367.             case Lexer::T_IDENTIFIER:
  2368.                 switch (true) {
  2369.                     case $peek['type'] === Lexer::T_DOT:
  2370.                         $expression = $this->StateFieldPathExpression();
  2372.                         return new AST\SimpleSelectExpression($expression);
  2374.                     case $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2375.                         $expression = $this->IdentificationVariable();
  2377.                         return new AST\SimpleSelectExpression($expression);
  2379.                     case $this->isFunction():
  2380.                         // SUM(u.id) + COUNT(u.id)
  2381.                         if ($this->isMathOperator($this->peekBeyondClosingParenthesis())) {
  2382.                             return new AST\SimpleSelectExpression($this->ScalarExpression());
  2383.                         }
  2385.                         // COUNT(u.id)
  2386.                         if ($this->isAggregateFunction($this->lexer->lookahead['type'])) {
  2387.                             return new AST\SimpleSelectExpression($this->AggregateExpression());
  2388.                         }
  2390.                         // IDENTITY(u)
  2391.                         return new AST\SimpleSelectExpression($this->FunctionDeclaration());
  2393.                     default:
  2394.                         // Do nothing
  2395.                 }
  2397.                 break;
  2399.             case Lexer::T_OPEN_PARENTHESIS:
  2400.                 if ($peek['type'] !== Lexer::T_SELECT) {
  2401.                     // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2402.                     $expression = $this->SimpleArithmeticExpression();
  2404.                     return new AST\SimpleSelectExpression($expression);
  2405.                 }
  2407.                 // Subselect
  2408.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2409.                 $expression = $this->Subselect();
  2410.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2412.                 return new AST\SimpleSelectExpression($expression);
  2414.             default:
  2415.                 // Do nothing
  2416.         }
  2418.         $this->lexer->peek();
  2420.         $expression = $this->ScalarExpression();
  2421.         $expr       = new AST\SimpleSelectExpression($expression);
  2423.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2424.             $this->match(Lexer::T_AS);
  2425.         }
  2427.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2428.             $token                             = $this->lexer->lookahead;
  2429.             $resultVariable                    = $this->AliasResultVariable();
  2430.             $expr->fieldIdentificationVariable = $resultVariable;
  2432.             // Include AliasResultVariable in query components.
  2433.             $this->queryComponents[$resultVariable] = [
  2434.                 'resultvariable' => $expr,
  2435.                 'nestingLevel'   => $this->nestingLevel,
  2436.                 'token'          => $token,
  2437.             ];
  2438.         }
  2440.         return $expr;
  2441.     }
  2443.     /**
  2444.      * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
  2445.      *
  2446.      * @return AST\ConditionalExpression|AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2447.      */
  2448.     public function ConditionalExpression()
  2449.     {
  2450.         $conditionalTerms   = [];
  2451.         $conditionalTerms[] = $this->ConditionalTerm();
  2453.         while ($this->lexer->isNextToken(Lexer::T_OR)) {
  2454.             $this->match(Lexer::T_OR);
  2456.             $conditionalTerms[] = $this->ConditionalTerm();
  2457.         }
  2459.         // Phase 1 AST optimization: Prevent AST\ConditionalExpression
  2460.         // if only one AST\ConditionalTerm is defined
  2461.         if (count($conditionalTerms) === 1) {
  2462.             return $conditionalTerms[0];
  2463.         }
  2465.         return new AST\ConditionalExpression($conditionalTerms);
  2466.     }
  2468.     /**
  2469.      * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
  2470.      *
  2471.      * @return AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2472.      */
  2473.     public function ConditionalTerm()
  2474.     {
  2475.         $conditionalFactors   = [];
  2476.         $conditionalFactors[] = $this->ConditionalFactor();
  2478.         while ($this->lexer->isNextToken(Lexer::T_AND)) {
  2479.             $this->match(Lexer::T_AND);
  2481.             $conditionalFactors[] = $this->ConditionalFactor();
  2482.         }
  2484.         // Phase 1 AST optimization: Prevent AST\ConditionalTerm
  2485.         // if only one AST\ConditionalFactor is defined
  2486.         if (count($conditionalFactors) === 1) {
  2487.             return $conditionalFactors[0];
  2488.         }
  2490.         return new AST\ConditionalTerm($conditionalFactors);
  2491.     }
  2493.     /**
  2494.      * ConditionalFactor ::= ["NOT"] ConditionalPrimary
  2495.      *
  2496.      * @return AST\ConditionalFactor|AST\ConditionalPrimary
  2497.      */
  2498.     public function ConditionalFactor()
  2499.     {
  2500.         $not = false;
  2502.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2503.             $this->match(Lexer::T_NOT);
  2505.             $not = true;
  2506.         }
  2508.         $conditionalPrimary = $this->ConditionalPrimary();
  2510.         // Phase 1 AST optimization: Prevent AST\ConditionalFactor
  2511.         // if only one AST\ConditionalPrimary is defined
  2512.         if (! $not) {
  2513.             return $conditionalPrimary;
  2514.         }
  2516.         $conditionalFactor      = new AST\ConditionalFactor($conditionalPrimary);
  2517.         $conditionalFactor->not = $not;
  2519.         return $conditionalFactor;
  2520.     }
  2522.     /**
  2523.      * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
  2524.      *
  2525.      * @return ConditionalPrimary
  2526.      */
  2527.     public function ConditionalPrimary()
  2528.     {
  2529.         $condPrimary = new AST\ConditionalPrimary();
  2531.         if (! $this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2532.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2534.             return $condPrimary;
  2535.         }
  2537.         // Peek beyond the matching closing parenthesis ')'
  2538.         $peek = $this->peekBeyondClosingParenthesis();
  2540.         if (
  2541.             $peek !== null && (
  2542.             in_array($peek['value'], ['=', '<', '<=', '<>', '>', '>=', '!='], true) ||
  2543.             in_array($peek['type'], [Lexer::T_NOT, Lexer::T_BETWEEN, Lexer::T_LIKE, Lexer::T_IN, Lexer::T_IS, Lexer::T_EXISTS], true) ||
  2544.             $this->isMathOperator($peek)
  2545.             )
  2546.         ) {
  2547.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2549.             return $condPrimary;
  2550.         }
  2552.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2553.         $condPrimary->conditionalExpression = $this->ConditionalExpression();
  2554.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2556.         return $condPrimary;
  2557.     }
  2559.     /**
  2560.      * SimpleConditionalExpression ::=
  2561.      *      ComparisonExpression | BetweenExpression | LikeExpression |
  2562.      *      InExpression | NullComparisonExpression | ExistsExpression |
  2563.      *      EmptyCollectionComparisonExpression | CollectionMemberExpression |
  2564.      *      InstanceOfExpression
  2565.      *
  2566.      * @return AST\BetweenExpression|
  2567.      *         AST\CollectionMemberExpression|
  2568.      *         AST\ComparisonExpression|
  2569.      *         AST\EmptyCollectionComparisonExpression|
  2570.      *         AST\ExistsExpression|
  2571.      *         AST\InExpression|
  2572.      *         AST\InstanceOfExpression|
  2573.      *         AST\LikeExpression|
  2574.      *         AST\NullComparisonExpression
  2575.      */
  2576.     public function SimpleConditionalExpression()
  2577.     {
  2578.         if ($this->lexer->isNextToken(Lexer::T_EXISTS)) {
  2579.             return $this->ExistsExpression();
  2580.         }
  2582.         $token     = $this->lexer->lookahead;
  2583.         $peek      = $this->lexer->glimpse();
  2584.         $lookahead = $token;
  2586.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2587.             $token = $this->lexer->glimpse();
  2588.         }
  2590.         if ($token['type'] === Lexer::T_IDENTIFIER || $token['type'] === Lexer::T_INPUT_PARAMETER || $this->isFunction()) {
  2591.             // Peek beyond the matching closing parenthesis.
  2592.             $beyond = $this->lexer->peek();
  2594.             switch ($peek['value']) {
  2595.                 case '(':
  2596.                     // Peeks beyond the matched closing parenthesis.
  2597.                     $token = $this->peekBeyondClosingParenthesis(false);
  2599.                     if ($token['type'] === Lexer::T_NOT) {
  2600.                         $token = $this->lexer->peek();
  2601.                     }
  2603.                     if ($token['type'] === Lexer::T_IS) {
  2604.                         $lookahead = $this->lexer->peek();
  2605.                     }
  2607.                     break;
  2609.                 default:
  2610.                     // Peek beyond the PathExpression or InputParameter.
  2611.                     $token = $beyond;
  2613.                     while ($token['value'] === '.') {
  2614.                         $this->lexer->peek();
  2616.                         $token = $this->lexer->peek();
  2617.                     }
  2619.                     // Also peek beyond a NOT if there is one.
  2620.                     if ($token['type'] === Lexer::T_NOT) {
  2621.                         $token = $this->lexer->peek();
  2622.                     }
  2624.                     // We need to go even further in case of IS (differentiate between NULL and EMPTY)
  2625.                     $lookahead = $this->lexer->peek();
  2626.             }
  2628.             // Also peek beyond a NOT if there is one.
  2629.             if ($lookahead['type'] === Lexer::T_NOT) {
  2630.                 $lookahead = $this->lexer->peek();
  2631.             }
  2633.             $this->lexer->resetPeek();
  2634.         }
  2636.         if ($token['type'] === Lexer::T_BETWEEN) {
  2637.             return $this->BetweenExpression();
  2638.         }
  2640.         if ($token['type'] === Lexer::T_LIKE) {
  2641.             return $this->LikeExpression();
  2642.         }
  2644.         if ($token['type'] === Lexer::T_IN) {
  2645.             return $this->InExpression();
  2646.         }
  2648.         if ($token['type'] === Lexer::T_INSTANCE) {
  2649.             return $this->InstanceOfExpression();
  2650.         }
  2652.         if ($token['type'] === Lexer::T_MEMBER) {
  2653.             return $this->CollectionMemberExpression();
  2654.         }
  2656.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_NULL) {
  2657.             return $this->NullComparisonExpression();
  2658.         }
  2660.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_EMPTY) {
  2661.             return $this->EmptyCollectionComparisonExpression();
  2662.         }
  2664.         return $this->ComparisonExpression();
  2665.     }
  2667.     /**
  2668.      * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
  2669.      *
  2670.      * @return EmptyCollectionComparisonExpression
  2671.      */
  2672.     public function EmptyCollectionComparisonExpression()
  2673.     {
  2674.         $emptyCollectionCompExpr = new AST\EmptyCollectionComparisonExpression(
  2675.             $this->CollectionValuedPathExpression()
  2676.         );
  2677.         $this->match(Lexer::T_IS);
  2679.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2680.             $this->match(Lexer::T_NOT);
  2681.             $emptyCollectionCompExpr->not = true;
  2682.         }
  2684.         $this->match(Lexer::T_EMPTY);
  2686.         return $emptyCollectionCompExpr;
  2687.     }
  2689.     /**
  2690.      * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
  2691.      *
  2692.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2693.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2694.      *
  2695.      * @return CollectionMemberExpression
  2696.      */
  2697.     public function CollectionMemberExpression()
  2698.     {
  2699.         $not        = false;
  2700.         $entityExpr = $this->EntityExpression();
  2702.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2703.             $this->match(Lexer::T_NOT);
  2705.             $not = true;
  2706.         }
  2708.         $this->match(Lexer::T_MEMBER);
  2710.         if ($this->lexer->isNextToken(Lexer::T_OF)) {
  2711.             $this->match(Lexer::T_OF);
  2712.         }
  2714.         $collMemberExpr      = new AST\CollectionMemberExpression(
  2715.             $entityExpr,
  2716.             $this->CollectionValuedPathExpression()
  2717.         );
  2718.         $collMemberExpr->not = $not;
  2720.         return $collMemberExpr;
  2721.     }
  2723.     /**
  2724.      * Literal ::= string | char | integer | float | boolean
  2725.      *
  2726.      * @return Literal
  2727.      */
  2728.     public function Literal()
  2729.     {
  2730.         switch ($this->lexer->lookahead['type']) {
  2731.             case Lexer::T_STRING:
  2732.                 $this->match(Lexer::T_STRING);
  2734.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  2736.             case Lexer::T_INTEGER:
  2737.             case Lexer::T_FLOAT:
  2738.                 $this->match(
  2739.                     $this->lexer->isNextToken(Lexer::T_INTEGER) ? Lexer::T_INTEGER : Lexer::T_FLOAT
  2740.                 );
  2742.                 return new AST\Literal(AST\Literal::NUMERIC, $this->lexer->token['value']);
  2744.             case Lexer::T_TRUE:
  2745.             case Lexer::T_FALSE:
  2746.                 $this->match(
  2747.                     $this->lexer->isNextToken(Lexer::T_TRUE) ? Lexer::T_TRUE : Lexer::T_FALSE
  2748.                 );
  2750.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2752.             default:
  2753.                 $this->syntaxError('Literal');
  2754.         }
  2755.     }
  2757.     /**
  2758.      * InParameter ::= ArithmeticExpression | InputParameter
  2759.      *
  2760.      * @return AST\InputParameter|AST\ArithmeticExpression
  2761.      */
  2762.     public function InParameter()
  2763.     {
  2764.         if ($this->lexer->lookahead['type'] === Lexer::T_INPUT_PARAMETER) {
  2765.             return $this->InputParameter();
  2766.         }
  2768.         return $this->ArithmeticExpression();
  2769.     }
  2771.     /**
  2772.      * InputParameter ::= PositionalParameter | NamedParameter
  2773.      *
  2774.      * @return InputParameter
  2775.      */
  2776.     public function InputParameter()
  2777.     {
  2778.         $this->match(Lexer::T_INPUT_PARAMETER);
  2780.         return new AST\InputParameter($this->lexer->token['value']);
  2781.     }
  2783.     /**
  2784.      * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
  2785.      *
  2786.      * @return ArithmeticExpression
  2787.      */
  2788.     public function ArithmeticExpression()
  2789.     {
  2790.         $expr = new AST\ArithmeticExpression();
  2792.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2793.             $peek = $this->lexer->glimpse();
  2795.             if ($peek['type'] === Lexer::T_SELECT) {
  2796.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2797.                 $expr->subselect = $this->Subselect();
  2798.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2800.                 return $expr;
  2801.             }
  2802.         }
  2804.         $expr->simpleArithmeticExpression = $this->SimpleArithmeticExpression();
  2806.         return $expr;
  2807.     }
  2809.     /**
  2810.      * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
  2811.      *
  2812.      * @return SimpleArithmeticExpression|ArithmeticTerm
  2813.      */
  2814.     public function SimpleArithmeticExpression()
  2815.     {
  2816.         $terms   = [];
  2817.         $terms[] = $this->ArithmeticTerm();
  2819.         while (($isPlus = $this->lexer->isNextToken(Lexer::T_PLUS)) || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2820.             $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2822.             $terms[] = $this->lexer->token['value'];
  2823.             $terms[] = $this->ArithmeticTerm();
  2824.         }
  2826.         // Phase 1 AST optimization: Prevent AST\SimpleArithmeticExpression
  2827.         // if only one AST\ArithmeticTerm is defined
  2828.         if (count($terms) === 1) {
  2829.             return $terms[0];
  2830.         }
  2832.         return new AST\SimpleArithmeticExpression($terms);
  2833.     }
  2835.     /**
  2836.      * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
  2837.      *
  2838.      * @return ArithmeticTerm
  2839.      */
  2840.     public function ArithmeticTerm()
  2841.     {
  2842.         $factors   = [];
  2843.         $factors[] = $this->ArithmeticFactor();
  2845.         while (($isMult = $this->lexer->isNextToken(Lexer::T_MULTIPLY)) || $this->lexer->isNextToken(Lexer::T_DIVIDE)) {
  2846.             $this->match($isMult ? Lexer::T_MULTIPLY : Lexer::T_DIVIDE);
  2848.             $factors[] = $this->lexer->token['value'];
  2849.             $factors[] = $this->ArithmeticFactor();
  2850.         }
  2852.         // Phase 1 AST optimization: Prevent AST\ArithmeticTerm
  2853.         // if only one AST\ArithmeticFactor is defined
  2854.         if (count($factors) === 1) {
  2855.             return $factors[0];
  2856.         }
  2858.         return new AST\ArithmeticTerm($factors);
  2859.     }
  2861.     /**
  2862.      * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
  2863.      *
  2864.      * @return ArithmeticFactor
  2865.      */
  2866.     public function ArithmeticFactor()
  2867.     {
  2868.         $sign = null;
  2870.         $isPlus = $this->lexer->isNextToken(Lexer::T_PLUS);
  2871.         if ($isPlus || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2872.             $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2873.             $sign = $isPlus;
  2874.         }
  2876.         $primary = $this->ArithmeticPrimary();
  2878.         // Phase 1 AST optimization: Prevent AST\ArithmeticFactor
  2879.         // if only one AST\ArithmeticPrimary is defined
  2880.         if ($sign === null) {
  2881.             return $primary;
  2882.         }
  2884.         return new AST\ArithmeticFactor($primary, $sign);
  2885.     }
  2887.     /**
  2888.      * ArithmeticPrimary ::= SingleValuedPathExpression | Literal | ParenthesisExpression
  2889.      *          | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings
  2890.      *          | FunctionsReturningDatetime | IdentificationVariable | ResultVariable
  2891.      *          | InputParameter | CaseExpression
  2892.      *
  2893.      * @return Node|string
  2894.      */
  2895.     public function ArithmeticPrimary()
  2896.     {
  2897.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2898.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2900.             $expr = $this->SimpleArithmeticExpression();
  2902.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2904.             return new AST\ParenthesisExpression($expr);
  2905.         }
  2907.         switch ($this->lexer->lookahead['type']) {
  2908.             case Lexer::T_COALESCE:
  2909.             case Lexer::T_NULLIF:
  2910.             case Lexer::T_CASE:
  2911.                 return $this->CaseExpression();
  2913.             case Lexer::T_IDENTIFIER:
  2914.                 $peek = $this->lexer->glimpse();
  2916.                 if ($peek !== null && $peek['value'] === '(') {
  2917.                     return $this->FunctionDeclaration();
  2918.                 }
  2920.                 if ($peek !== null && $peek['value'] === '.') {
  2921.                     return $this->SingleValuedPathExpression();
  2922.                 }
  2924.                 if (isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])) {
  2925.                     return $this->ResultVariable();
  2926.                 }
  2928.                 return $this->StateFieldPathExpression();
  2930.             case Lexer::T_INPUT_PARAMETER:
  2931.                 return $this->InputParameter();
  2933.             default:
  2934.                 $peek = $this->lexer->glimpse();
  2936.                 if ($peek !== null && $peek['value'] === '(') {
  2937.                     return $this->FunctionDeclaration();
  2938.                 }
  2940.                 return $this->Literal();
  2941.         }
  2942.     }
  2944.     /**
  2945.      * StringExpression ::= StringPrimary | ResultVariable | "(" Subselect ")"
  2946.      *
  2947.      * @return Subselect|Node|string
  2948.      */
  2949.     public function StringExpression()
  2950.     {
  2951.         $peek = $this->lexer->glimpse();
  2953.         // Subselect
  2954.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $peek['type'] === Lexer::T_SELECT) {
  2955.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2956.             $expr = $this->Subselect();
  2957.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2959.             return $expr;
  2960.         }
  2962.         // ResultVariable (string)
  2963.         if (
  2964.             $this->lexer->isNextToken(Lexer::T_IDENTIFIER) &&
  2965.             isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])
  2966.         ) {
  2967.             return $this->ResultVariable();
  2968.         }
  2970.         return $this->StringPrimary();
  2971.     }
  2973.     /**
  2974.      * StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression
  2975.      *
  2976.      * @return Node
  2977.      */
  2978.     public function StringPrimary()
  2979.     {
  2980.         $lookaheadType = $this->lexer->lookahead['type'];
  2982.         switch ($lookaheadType) {
  2983.             case Lexer::T_IDENTIFIER:
  2984.                 $peek = $this->lexer->glimpse();
  2986.                 if ($peek['value'] === '.') {
  2987.                     return $this->StateFieldPathExpression();
  2988.                 }
  2990.                 if ($peek['value'] === '(') {
  2991.                     // do NOT directly go to FunctionsReturningString() because it doesn't check for custom functions.
  2992.                     return $this->FunctionDeclaration();
  2993.                 }
  2995.                 $this->syntaxError("'.' or '('");
  2996.                 break;
  2998.             case Lexer::T_STRING:
  2999.                 $this->match(Lexer::T_STRING);
  3001.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3003.             case Lexer::T_INPUT_PARAMETER:
  3004.                 return $this->InputParameter();
  3006.             case Lexer::T_CASE:
  3007.             case Lexer::T_COALESCE:
  3008.             case Lexer::T_NULLIF:
  3009.                 return $this->CaseExpression();
  3011.             default:
  3012.                 if ($this->isAggregateFunction($lookaheadType)) {
  3013.                     return $this->AggregateExpression();
  3014.                 }
  3015.         }
  3017.         $this->syntaxError(
  3018.             'StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression'
  3019.         );
  3020.     }
  3022.     /**
  3023.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  3024.      *
  3025.      * @return AST\InputParameter|PathExpression
  3026.      */
  3027.     public function EntityExpression()
  3028.     {
  3029.         $glimpse = $this->lexer->glimpse();
  3031.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER) && $glimpse['value'] === '.') {
  3032.             return $this->SingleValuedAssociationPathExpression();
  3033.         }
  3035.         return $this->SimpleEntityExpression();
  3036.     }
  3038.     /**
  3039.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  3040.      *
  3041.      * @return AST\InputParameter|AST\PathExpression
  3042.      */
  3043.     public function SimpleEntityExpression()
  3044.     {
  3045.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3046.             return $this->InputParameter();
  3047.         }
  3049.         return $this->StateFieldPathExpression();
  3050.     }
  3052.     /**
  3053.      * AggregateExpression ::=
  3054.      *  ("AVG" | "MAX" | "MIN" | "SUM" | "COUNT") "(" ["DISTINCT"] SimpleArithmeticExpression ")"
  3055.      *
  3056.      * @return AggregateExpression
  3057.      */
  3058.     public function AggregateExpression()
  3059.     {
  3060.         $lookaheadType = $this->lexer->lookahead['type'];
  3061.         $isDistinct    = false;
  3063.         if (! in_array($lookaheadType, [Lexer::T_COUNT, Lexer::T_AVG, Lexer::T_MAX, Lexer::T_MIN, Lexer::T_SUM], true)) {
  3064.             $this->syntaxError('One of: MAX, MIN, AVG, SUM, COUNT');
  3065.         }
  3067.         $this->match($lookaheadType);
  3068.         $functionName = $this->lexer->token['value'];
  3069.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3071.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  3072.             $this->match(Lexer::T_DISTINCT);
  3073.             $isDistinct = true;
  3074.         }
  3076.         $pathExp = $this->SimpleArithmeticExpression();
  3078.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3080.         return new AST\AggregateExpression($functionName, $pathExp, $isDistinct);
  3081.     }
  3083.     /**
  3084.      * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
  3085.      *
  3086.      * @return QuantifiedExpression
  3087.      */
  3088.     public function QuantifiedExpression()
  3089.     {
  3090.         $lookaheadType = $this->lexer->lookahead['type'];
  3091.         $value         = $this->lexer->lookahead['value'];
  3093.         if (! in_array($lookaheadType, [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME], true)) {
  3094.             $this->syntaxError('ALL, ANY or SOME');
  3095.         }
  3097.         $this->match($lookaheadType);
  3098.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3100.         $qExpr       = new AST\QuantifiedExpression($this->Subselect());
  3101.         $qExpr->type = $value;
  3103.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3105.         return $qExpr;
  3106.     }
  3108.     /**
  3109.      * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
  3110.      *
  3111.      * @return BetweenExpression
  3112.      */
  3113.     public function BetweenExpression()
  3114.     {
  3115.         $not        = false;
  3116.         $arithExpr1 = $this->ArithmeticExpression();
  3118.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3119.             $this->match(Lexer::T_NOT);
  3120.             $not = true;
  3121.         }
  3123.         $this->match(Lexer::T_BETWEEN);
  3124.         $arithExpr2 = $this->ArithmeticExpression();
  3125.         $this->match(Lexer::T_AND);
  3126.         $arithExpr3 = $this->ArithmeticExpression();
  3128.         $betweenExpr      = new AST\BetweenExpression($arithExpr1, $arithExpr2, $arithExpr3);
  3129.         $betweenExpr->not = $not;
  3131.         return $betweenExpr;
  3132.     }
  3134.     /**
  3135.      * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )
  3136.      *
  3137.      * @return ComparisonExpression
  3138.      */
  3139.     public function ComparisonExpression()
  3140.     {
  3141.         $this->lexer->glimpse();
  3143.         $leftExpr  = $this->ArithmeticExpression();
  3144.         $operator  = $this->ComparisonOperator();
  3145.         $rightExpr = $this->isNextAllAnySome()
  3146.             ? $this->QuantifiedExpression()
  3147.             : $this->ArithmeticExpression();
  3149.         return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
  3150.     }
  3152.     /**
  3153.      * InExpression ::= SingleValuedPathExpression ["NOT"] "IN" "(" (InParameter {"," InParameter}* | Subselect) ")"
  3154.      *
  3155.      * @return InExpression
  3156.      */
  3157.     public function InExpression()
  3158.     {
  3159.         $inExpression = new AST\InExpression($this->ArithmeticExpression());
  3161.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3162.             $this->match(Lexer::T_NOT);
  3163.             $inExpression->not = true;
  3164.         }
  3166.         $this->match(Lexer::T_IN);
  3167.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3169.         if ($this->lexer->isNextToken(Lexer::T_SELECT)) {
  3170.             $inExpression->subselect = $this->Subselect();
  3171.         } else {
  3172.             $literals   = [];
  3173.             $literals[] = $this->InParameter();
  3175.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3176.                 $this->match(Lexer::T_COMMA);
  3177.                 $literals[] = $this->InParameter();
  3178.             }
  3180.             $inExpression->literals = $literals;
  3181.         }
  3183.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3185.         return $inExpression;
  3186.     }
  3188.     /**
  3189.      * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
  3190.      *
  3191.      * @return InstanceOfExpression
  3192.      */
  3193.     public function InstanceOfExpression()
  3194.     {
  3195.         $instanceOfExpression = new AST\InstanceOfExpression($this->IdentificationVariable());
  3197.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3198.             $this->match(Lexer::T_NOT);
  3199.             $instanceOfExpression->not = true;
  3200.         }
  3202.         $this->match(Lexer::T_INSTANCE);
  3203.         $this->match(Lexer::T_OF);
  3205.         $exprValues = [];
  3207.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  3208.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  3210.             $exprValues[] = $this->InstanceOfParameter();
  3212.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3213.                 $this->match(Lexer::T_COMMA);
  3215.                 $exprValues[] = $this->InstanceOfParameter();
  3216.             }
  3218.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3220.             $instanceOfExpression->value = $exprValues;
  3222.             return $instanceOfExpression;
  3223.         }
  3225.         $exprValues[] = $this->InstanceOfParameter();
  3227.         $instanceOfExpression->value = $exprValues;
  3229.         return $instanceOfExpression;
  3230.     }
  3232.     /**
  3233.      * InstanceOfParameter ::= AbstractSchemaName | InputParameter
  3234.      *
  3235.      * @return mixed
  3236.      */
  3237.     public function InstanceOfParameter()
  3238.     {
  3239.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3240.             $this->match(Lexer::T_INPUT_PARAMETER);
  3242.             return new AST\InputParameter($this->lexer->token['value']);
  3243.         }
  3245.         $abstractSchemaName = $this->AbstractSchemaName();
  3247.         $this->validateAbstractSchemaName($abstractSchemaName);
  3249.         return $abstractSchemaName;
  3250.     }
  3252.     /**
  3253.      * LikeExpression ::= StringExpression ["NOT"] "LIKE" StringPrimary ["ESCAPE" char]
  3254.      *
  3255.      * @return LikeExpression
  3256.      */
  3257.     public function LikeExpression()
  3258.     {
  3259.         $stringExpr = $this->StringExpression();
  3260.         $not        = false;
  3262.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3263.             $this->match(Lexer::T_NOT);
  3264.             $not = true;
  3265.         }
  3267.         $this->match(Lexer::T_LIKE);
  3269.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3270.             $this->match(Lexer::T_INPUT_PARAMETER);
  3271.             $stringPattern = new AST\InputParameter($this->lexer->token['value']);
  3272.         } else {
  3273.             $stringPattern = $this->StringPrimary();
  3274.         }
  3276.         $escapeChar = null;
  3278.         if ($this->lexer->lookahead !== null && $this->lexer->lookahead['type'] === Lexer::T_ESCAPE) {
  3279.             $this->match(Lexer::T_ESCAPE);
  3280.             $this->match(Lexer::T_STRING);
  3282.             $escapeChar = new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3283.         }
  3285.         $likeExpr      = new AST\LikeExpression($stringExpr, $stringPattern, $escapeChar);
  3286.         $likeExpr->not = $not;
  3288.         return $likeExpr;
  3289.     }
  3291.     /**
  3292.      * NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) "IS" ["NOT"] "NULL"
  3293.      *
  3294.      * @return NullComparisonExpression
  3295.      */
  3296.     public function NullComparisonExpression()
  3297.     {
  3298.         switch (true) {
  3299.             case $this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER):
  3300.                 $this->match(Lexer::T_INPUT_PARAMETER);
  3302.                 $expr = new AST\InputParameter($this->lexer->token['value']);
  3303.                 break;
  3305.             case $this->lexer->isNextToken(Lexer::T_NULLIF):
  3306.                 $expr = $this->NullIfExpression();
  3307.                 break;
  3309.             case $this->lexer->isNextToken(Lexer::T_COALESCE):
  3310.                 $expr = $this->CoalesceExpression();
  3311.                 break;
  3313.             case $this->isFunction():
  3314.                 $expr = $this->FunctionDeclaration();
  3315.                 break;
  3317.             default:
  3318.                 // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  3319.                 $glimpse = $this->lexer->glimpse();
  3321.                 if ($glimpse['type'] === Lexer::T_DOT) {
  3322.                     $expr = $this->SingleValuedPathExpression();
  3324.                     // Leave switch statement
  3325.                     break;
  3326.                 }
  3328.                 $lookaheadValue = $this->lexer->lookahead['value'];
  3330.                 // Validate existing component
  3331.                 if (! isset($this->queryComponents[$lookaheadValue])) {
  3332.                     $this->semanticalError('Cannot add having condition on undefined result variable.');
  3333.                 }
  3335.                 // Validate SingleValuedPathExpression (ie.: "product")
  3336.                 if (isset($this->queryComponents[$lookaheadValue]['metadata'])) {
  3337.                     $expr = $this->SingleValuedPathExpression();
  3338.                     break;
  3339.                 }
  3341.                 // Validating ResultVariable
  3342.                 if (! isset($this->queryComponents[$lookaheadValue]['resultVariable'])) {
  3343.                     $this->semanticalError('Cannot add having condition on a non result variable.');
  3344.                 }
  3346.                 $expr = $this->ResultVariable();
  3347.                 break;
  3348.         }
  3350.         $nullCompExpr = new AST\NullComparisonExpression($expr);
  3352.         $this->match(Lexer::T_IS);
  3354.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3355.             $this->match(Lexer::T_NOT);
  3357.             $nullCompExpr->not = true;
  3358.         }
  3360.         $this->match(Lexer::T_NULL);
  3362.         return $nullCompExpr;
  3363.     }
  3365.     /**
  3366.      * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
  3367.      *
  3368.      * @return ExistsExpression
  3369.      */
  3370.     public function ExistsExpression()
  3371.     {
  3372.         $not = false;
  3374.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3375.             $this->match(Lexer::T_NOT);
  3376.             $not = true;
  3377.         }
  3379.         $this->match(Lexer::T_EXISTS);
  3380.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3382.         $existsExpression      = new AST\ExistsExpression($this->Subselect());
  3383.         $existsExpression->not = $not;
  3385.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3387.         return $existsExpression;
  3388.     }
  3390.     /**
  3391.      * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
  3392.      *
  3393.      * @return string
  3394.      */
  3395.     public function ComparisonOperator()
  3396.     {
  3397.         switch ($this->lexer->lookahead['value']) {
  3398.             case '=':
  3399.                 $this->match(Lexer::T_EQUALS);
  3401.                 return '=';
  3403.             case '<':
  3404.                 $this->match(Lexer::T_LOWER_THAN);
  3405.                 $operator = '<';
  3407.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3408.                     $this->match(Lexer::T_EQUALS);
  3409.                     $operator .= '=';
  3410.                 } elseif ($this->lexer->isNextToken(Lexer::T_GREATER_THAN)) {
  3411.                     $this->match(Lexer::T_GREATER_THAN);
  3412.                     $operator .= '>';
  3413.                 }
  3415.                 return $operator;
  3417.             case '>':
  3418.                 $this->match(Lexer::T_GREATER_THAN);
  3419.                 $operator = '>';
  3421.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3422.                     $this->match(Lexer::T_EQUALS);
  3423.                     $operator .= '=';
  3424.                 }
  3426.                 return $operator;
  3428.             case '!':
  3429.                 $this->match(Lexer::T_NEGATE);
  3430.                 $this->match(Lexer::T_EQUALS);
  3432.                 return '<>';
  3434.             default:
  3435.                 $this->syntaxError('=, <, <=, <>, >, >=, !=');
  3436.         }
  3437.     }
  3439.     /**
  3440.      * FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDatetime
  3441.      *
  3442.      * @return FunctionNode
  3443.      */
  3444.     public function FunctionDeclaration()
  3445.     {
  3446.         $token    = $this->lexer->lookahead;
  3447.         $funcName = strtolower($token['value']);
  3449.         $customFunctionDeclaration = $this->CustomFunctionDeclaration();
  3451.         // Check for custom functions functions first!
  3452.         switch (true) {
  3453.             case $customFunctionDeclaration !== null:
  3454.                 return $customFunctionDeclaration;
  3456.             case isset(self::$stringFunctions[$funcName]):
  3457.                 return $this->FunctionsReturningStrings();
  3459.             case isset(self::$numericFunctions[$funcName]):
  3460.                 return $this->FunctionsReturningNumerics();
  3462.             case isset(self::$datetimeFunctions[$funcName]):
  3463.                 return $this->FunctionsReturningDatetime();
  3465.             default:
  3466.                 $this->syntaxError('known function', $token);
  3467.         }
  3468.     }
  3470.     /**
  3471.      * Helper function for FunctionDeclaration grammar rule.
  3472.      */
  3473.     private function CustomFunctionDeclaration(): ?FunctionNode
  3474.     {
  3475.         $token    = $this->lexer->lookahead;
  3476.         $funcName = strtolower($token['value']);
  3478.         // Check for custom functions afterwards
  3479.         $config = $this->em->getConfiguration();
  3481.         switch (true) {
  3482.             case $config->getCustomStringFunction($funcName) !== null:
  3483.                 return $this->CustomFunctionsReturningStrings();
  3485.             case $config->getCustomNumericFunction($funcName) !== null:
  3486.                 return $this->CustomFunctionsReturningNumerics();
  3488.             case $config->getCustomDatetimeFunction($funcName) !== null:
  3489.                 return $this->CustomFunctionsReturningDatetime();
  3491.             default:
  3492.                 return null;
  3493.         }
  3494.     }
  3496.     /**
  3497.      * FunctionsReturningNumerics ::=
  3498.      *      "LENGTH" "(" StringPrimary ")" |
  3499.      *      "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")" |
  3500.      *      "ABS" "(" SimpleArithmeticExpression ")" |
  3501.      *      "SQRT" "(" SimpleArithmeticExpression ")" |
  3502.      *      "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3503.      *      "SIZE" "(" CollectionValuedPathExpression ")" |
  3504.      *      "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3505.      *      "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3506.      *      "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
  3507.      *
  3508.      * @return FunctionNode
  3509.      */
  3510.     public function FunctionsReturningNumerics()
  3511.     {
  3512.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3513.         $funcClass     = self::$numericFunctions[$funcNameLower];
  3515.         $function = new $funcClass($funcNameLower);
  3516.         $function->parse($this);
  3518.         return $function;
  3519.     }
  3521.     /**
  3522.      * @return FunctionNode
  3523.      */
  3524.     public function CustomFunctionsReturningNumerics()
  3525.     {
  3526.         // getCustomNumericFunction is case-insensitive
  3527.         $functionName  = strtolower($this->lexer->lookahead['value']);
  3528.         $functionClass = $this->em->getConfiguration()->getCustomNumericFunction($functionName);
  3530.         assert($functionClass !== null);
  3532.         $function = is_string($functionClass)
  3533.             ? new $functionClass($functionName)
  3534.             : call_user_func($functionClass, $functionName);
  3536.         $function->parse($this);
  3538.         return $function;
  3539.     }
  3541.     /**
  3542.      * FunctionsReturningDateTime ::=
  3543.      *     "CURRENT_DATE" |
  3544.      *     "CURRENT_TIME" |
  3545.      *     "CURRENT_TIMESTAMP" |
  3546.      *     "DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")" |
  3547.      *     "DATE_SUB" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
  3548.      *
  3549.      * @return FunctionNode
  3550.      */
  3551.     public function FunctionsReturningDatetime()
  3552.     {
  3553.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3554.         $funcClass     = self::$datetimeFunctions[$funcNameLower];
  3556.         $function = new $funcClass($funcNameLower);
  3557.         $function->parse($this);
  3559.         return $function;
  3560.     }
  3562.     /**
  3563.      * @return FunctionNode
  3564.      */
  3565.     public function CustomFunctionsReturningDatetime()
  3566.     {
  3567.         // getCustomDatetimeFunction is case-insensitive
  3568.         $functionName  = $this->lexer->lookahead['value'];
  3569.         $functionClass = $this->em->getConfiguration()->getCustomDatetimeFunction($functionName);
  3571.         assert($functionClass !== null);
  3573.         $function = is_string($functionClass)
  3574.             ? new $functionClass($functionName)
  3575.             : call_user_func($functionClass, $functionName);
  3577.         $function->parse($this);
  3579.         return $function;
  3580.     }
  3582.     /**
  3583.      * FunctionsReturningStrings ::=
  3584.      *   "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary}* ")" |
  3585.      *   "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3586.      *   "TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")" |
  3587.      *   "LOWER" "(" StringPrimary ")" |
  3588.      *   "UPPER" "(" StringPrimary ")" |
  3589.      *   "IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
  3590.      *
  3591.      * @return FunctionNode
  3592.      */
  3593.     public function FunctionsReturningStrings()
  3594.     {
  3595.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3596.         $funcClass     = self::$stringFunctions[$funcNameLower];
  3598.         $function = new $funcClass($funcNameLower);
  3599.         $function->parse($this);
  3601.         return $function;
  3602.     }
  3604.     /**
  3605.      * @return FunctionNode
  3606.      */
  3607.     public function CustomFunctionsReturningStrings()
  3608.     {
  3609.         // getCustomStringFunction is case-insensitive
  3610.         $functionName  = $this->lexer->lookahead['value'];
  3611.         $functionClass = $this->em->getConfiguration()->getCustomStringFunction($functionName);
  3613.         assert($functionClass !== null);
  3615.         $function = is_string($functionClass)
  3616.             ? new $functionClass($functionName)
  3617.             : call_user_func($functionClass, $functionName);
  3619.         $function->parse($this);
  3621.         return $function;
  3622.     }
  3623. }