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

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\EntityManager;
  9. use Doctrine\ORM\EntityManagerInterface;
  10. use Doctrine\ORM\Mapping\ClassMetadata;
  11. use Doctrine\ORM\Query;
  12. use Doctrine\ORM\Query\AST\AggregateExpression;
  13. use Doctrine\ORM\Query\AST\ArithmeticExpression;
  14. use Doctrine\ORM\Query\AST\ArithmeticFactor;
  15. use Doctrine\ORM\Query\AST\ArithmeticTerm;
  16. use Doctrine\ORM\Query\AST\BetweenExpression;
  17. use Doctrine\ORM\Query\AST\CoalesceExpression;
  18. use Doctrine\ORM\Query\AST\CollectionMemberExpression;
  19. use Doctrine\ORM\Query\AST\ComparisonExpression;
  20. use Doctrine\ORM\Query\AST\ConditionalPrimary;
  21. use Doctrine\ORM\Query\AST\DeleteClause;
  22. use Doctrine\ORM\Query\AST\DeleteStatement;
  23. use Doctrine\ORM\Query\AST\EmptyCollectionComparisonExpression;
  24. use Doctrine\ORM\Query\AST\ExistsExpression;
  25. use Doctrine\ORM\Query\AST\FromClause;
  26. use Doctrine\ORM\Query\AST\Functions;
  27. use Doctrine\ORM\Query\AST\Functions\FunctionNode;
  28. use Doctrine\ORM\Query\AST\GeneralCaseExpression;
  29. use Doctrine\ORM\Query\AST\GroupByClause;
  30. use Doctrine\ORM\Query\AST\HavingClause;
  31. use Doctrine\ORM\Query\AST\IdentificationVariableDeclaration;
  32. use Doctrine\ORM\Query\AST\IndexBy;
  33. use Doctrine\ORM\Query\AST\InExpression;
  34. use Doctrine\ORM\Query\AST\InputParameter;
  35. use Doctrine\ORM\Query\AST\InstanceOfExpression;
  36. use Doctrine\ORM\Query\AST\Join;
  37. use Doctrine\ORM\Query\AST\JoinAssociationPathExpression;
  38. use Doctrine\ORM\Query\AST\LikeExpression;
  39. use Doctrine\ORM\Query\AST\Literal;
  40. use Doctrine\ORM\Query\AST\NewObjectExpression;
  41. use Doctrine\ORM\Query\AST\Node;
  42. use Doctrine\ORM\Query\AST\NullComparisonExpression;
  43. use Doctrine\ORM\Query\AST\NullIfExpression;
  44. use Doctrine\ORM\Query\AST\OrderByClause;
  45. use Doctrine\ORM\Query\AST\OrderByItem;
  46. use Doctrine\ORM\Query\AST\PartialObjectExpression;
  47. use Doctrine\ORM\Query\AST\PathExpression;
  48. use Doctrine\ORM\Query\AST\QuantifiedExpression;
  49. use Doctrine\ORM\Query\AST\RangeVariableDeclaration;
  50. use Doctrine\ORM\Query\AST\SelectClause;
  51. use Doctrine\ORM\Query\AST\SelectExpression;
  52. use Doctrine\ORM\Query\AST\SelectStatement;
  53. use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
  54. use Doctrine\ORM\Query\AST\SimpleSelectClause;
  55. use Doctrine\ORM\Query\AST\SimpleSelectExpression;
  56. use Doctrine\ORM\Query\AST\SimpleWhenClause;
  57. use Doctrine\ORM\Query\AST\Subselect;
  58. use Doctrine\ORM\Query\AST\SubselectFromClause;
  59. use Doctrine\ORM\Query\AST\UpdateClause;
  60. use Doctrine\ORM\Query\AST\UpdateItem;
  61. use Doctrine\ORM\Query\AST\UpdateStatement;
  62. use Doctrine\ORM\Query\AST\WhenClause;
  63. use Doctrine\ORM\Query\AST\WhereClause;
  64. use ReflectionClass;
  66. use function array_intersect;
  67. use function array_search;
  68. use function assert;
  69. use function call_user_func;
  70. use function class_exists;
  71. use function count;
  72. use function explode;
  73. use function implode;
  74. use function in_array;
  75. use function interface_exists;
  76. use function is_string;
  77. use function sprintf;
  78. use function strlen;
  79. use function strpos;
  80. use function strrpos;
  81. use function strtolower;
  82. use function substr;
  84. /**
  85.  * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  86.  * Parses a DQL query, reports any errors in it, and generates an AST.
  87.  */
  88. class Parser
  89. {
  90.     /**
  91.      * READ-ONLY: Maps BUILT-IN string function names to AST class names.
  92.      *
  93.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  94.      */
  95.     private static $stringFunctions = [
  96.         'concat'    => Functions\ConcatFunction::class,
  97.         'substring' => Functions\SubstringFunction::class,
  98.         'trim'      => Functions\TrimFunction::class,
  99.         'lower'     => Functions\LowerFunction::class,
  100.         'upper'     => Functions\UpperFunction::class,
  101.         'identity'  => Functions\IdentityFunction::class,
  102.     ];
  104.     /**
  105.      * READ-ONLY: Maps BUILT-IN numeric function names to AST class names.
  106.      *
  107.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  108.      */
  109.     private static $numericFunctions = [
  110.         'length'    => Functions\LengthFunction::class,
  111.         'locate'    => Functions\LocateFunction::class,
  112.         'abs'       => Functions\AbsFunction::class,
  113.         'sqrt'      => Functions\SqrtFunction::class,
  114.         'mod'       => Functions\ModFunction::class,
  115.         'size'      => Functions\SizeFunction::class,
  116.         'date_diff' => Functions\DateDiffFunction::class,
  117.         'bit_and'   => Functions\BitAndFunction::class,
  118.         'bit_or'    => Functions\BitOrFunction::class,
  120.         // Aggregate functions
  121.         'min'       => Functions\MinFunction::class,
  122.         'max'       => Functions\MaxFunction::class,
  123.         'avg'       => Functions\AvgFunction::class,
  124.         'sum'       => Functions\SumFunction::class,
  125.         'count'     => Functions\CountFunction::class,
  126.     ];
  128.     /**
  129.      * READ-ONLY: Maps BUILT-IN datetime function names to AST class names.
  130.      *
  131.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  132.      */
  133.     private static $datetimeFunctions = [
  134.         'current_date'      => Functions\CurrentDateFunction::class,
  135.         'current_time'      => Functions\CurrentTimeFunction::class,
  136.         'current_timestamp' => Functions\CurrentTimestampFunction::class,
  137.         'date_add'          => Functions\DateAddFunction::class,
  138.         'date_sub'          => Functions\DateSubFunction::class,
  139.     ];
  141.     /*
  142.      * Expressions that were encountered during parsing of identifiers and expressions
  143.      * and still need to be validated.
  144.      */
  146.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  147.     private $deferredIdentificationVariables = [];
  149.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  150.     private $deferredPartialObjectExpressions = [];
  152.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  153.     private $deferredPathExpressions = [];
  155.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  156.     private $deferredResultVariables = [];
  158.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  159.     private $deferredNewObjectExpressions = [];
  161.     /**
  162.      * The lexer.
  163.      *
  164.      * @var Lexer
  165.      */
  166.     private $lexer;
  168.     /**
  169.      * The parser result.
  170.      *
  171.      * @var ParserResult
  172.      */
  173.     private $parserResult;
  175.     /**
  176.      * The EntityManager.
  177.      *
  178.      * @var EntityManagerInterface
  179.      */
  180.     private $em;
  182.     /**
  183.      * The Query to parse.
  184.      *
  185.      * @var Query
  186.      */
  187.     private $query;
  189.     /**
  190.      * Map of declared query components in the parsed query.
  191.      *
  192.      * @psalm-var array<string, array<string, mixed>>
  193.      */
  194.     private $queryComponents = [];
  196.     /**
  197.      * Keeps the nesting level of defined ResultVariables.
  198.      *
  199.      * @var int
  200.      */
  201.     private $nestingLevel = 0;
  203.     /**
  204.      * Any additional custom tree walkers that modify the AST.
  205.      *
  206.      * @psalm-var list<class-string<TreeWalker>>
  207.      */
  208.     private $customTreeWalkers = [];
  210.     /**
  211.      * The custom last tree walker, if any, that is responsible for producing the output.
  212.      *
  213.      * @var class-string<TreeWalker>
  214.      */
  215.     private $customOutputWalker;
  217.     /** @psalm-var array<string, AST\SelectExpression> */
  218.     private $identVariableExpressions = [];
  220.     /**
  221.      * Creates a new query parser object.
  222.      *
  223.      * @param Query $query The Query to parse.
  224.      */
  225.     public function __construct(Query $query)
  226.     {
  227.         $this->query        = $query;
  228.         $this->em           = $query->getEntityManager();
  229.         $this->lexer        = new Lexer((string) $query->getDQL());
  230.         $this->parserResult = new ParserResult();
  231.     }
  233.     /**
  234.      * Sets a custom tree walker that produces output.
  235.      * This tree walker will be run last over the AST, after any other walkers.
  236.      *
  237.      * @param string $className
  238.      *
  239.      * @return void
  240.      */
  241.     public function setCustomOutputTreeWalker($className)
  242.     {
  243.         $this->customOutputWalker = $className;
  244.     }
  246.     /**
  247.      * Adds a custom tree walker for modifying the AST.
  248.      *
  249.      * @param string $className
  250.      * @psalm-param class-string $className
  251.      *
  252.      * @return void
  253.      */
  254.     public function addCustomTreeWalker($className)
  255.     {
  256.         $this->customTreeWalkers[] = $className;
  257.     }
  259.     /**
  260.      * Gets the lexer used by the parser.
  261.      *
  262.      * @return Lexer
  263.      */
  264.     public function getLexer()
  265.     {
  266.         return $this->lexer;
  267.     }
  269.     /**
  270.      * Gets the ParserResult that is being filled with information during parsing.
  271.      *
  272.      * @return ParserResult
  273.      */
  274.     public function getParserResult()
  275.     {
  276.         return $this->parserResult;
  277.     }
  279.     /**
  280.      * Gets the EntityManager used by the parser.
  281.      *
  282.      * @return EntityManagerInterface
  283.      */
  284.     public function getEntityManager()
  285.     {
  286.         return $this->em;
  287.     }
  289.     /**
  290.      * Parses and builds AST for the given Query.
  291.      *
  292.      * @return SelectStatement|UpdateStatement|DeleteStatement
  293.      */
  294.     public function getAST()
  295.     {
  296.         // Parse & build AST
  297.         $AST = $this->QueryLanguage();
  299.         // Process any deferred validations of some nodes in the AST.
  300.         // This also allows post-processing of the AST for modification purposes.
  301.         $this->processDeferredIdentificationVariables();
  303.         if ($this->deferredPartialObjectExpressions) {
  304.             $this->processDeferredPartialObjectExpressions();
  305.         }
  307.         if ($this->deferredPathExpressions) {
  308.             $this->processDeferredPathExpressions();
  309.         }
  311.         if ($this->deferredResultVariables) {
  312.             $this->processDeferredResultVariables();
  313.         }
  315.         if ($this->deferredNewObjectExpressions) {
  316.             $this->processDeferredNewObjectExpressions($AST);
  317.         }
  319.         $this->processRootEntityAliasSelected();
  321.         // TODO: Is there a way to remove this? It may impact the mixed hydration resultset a lot!
  322.         $this->fixIdentificationVariableOrder($AST);
  324.         return $AST;
  325.     }
  327.     /**
  328.      * Attempts to match the given token with the current lookahead token.
  329.      *
  330.      * If they match, updates the lookahead token; otherwise raises a syntax
  331.      * error.
  332.      *
  333.      * @param int $token The token type.
  334.      *
  335.      * @return void
  336.      *
  337.      * @throws QueryException If the tokens don't match.
  338.      */
  339.     public function match($token)
  340.     {
  341.         $lookaheadType = $this->lexer->lookahead['type'] ?? null;
  343.         // Short-circuit on first condition, usually types match
  344.         if ($lookaheadType === $token) {
  345.             $this->lexer->moveNext();
  347.             return;
  348.         }
  350.         // If parameter is not identifier (1-99) must be exact match
  351.         if ($token < Lexer::T_IDENTIFIER) {
  352.             $this->syntaxError($this->lexer->getLiteral($token));
  353.         }
  355.         // If parameter is keyword (200+) must be exact match
  356.         if ($token > Lexer::T_IDENTIFIER) {
  357.             $this->syntaxError($this->lexer->getLiteral($token));
  358.         }
  360.         // If parameter is T_IDENTIFIER, then matches T_IDENTIFIER (100) and keywords (200+)
  361.         if ($token === Lexer::T_IDENTIFIER && $lookaheadType < Lexer::T_IDENTIFIER) {
  362.             $this->syntaxError($this->lexer->getLiteral($token));
  363.         }
  365.         $this->lexer->moveNext();
  366.     }
  368.     /**
  369.      * Frees this parser, enabling it to be reused.
  370.      *
  371.      * @param bool $deep     Whether to clean peek and reset errors.
  372.      * @param int  $position Position to reset.
  373.      *
  374.      * @return void
  375.      */
  376.     public function free($deep = false, $position = 0)
  377.     {
  378.         // WARNING! Use this method with care. It resets the scanner!
  379.         $this->lexer->resetPosition($position);
  381.         // Deep = true cleans peek and also any previously defined errors
  382.         if ($deep) {
  383.             $this->lexer->resetPeek();
  384.         }
  386.         $this->lexer->token     = null;
  387.         $this->lexer->lookahead = null;
  388.     }
  390.     /**
  391.      * Parses a query string.
  392.      *
  393.      * @return ParserResult
  394.      */
  395.     public function parse()
  396.     {
  397.         $AST = $this->getAST();
  399.         $customWalkers = $this->query->getHint(Query::HINT_CUSTOM_TREE_WALKERS);
  400.         if ($customWalkers !== false) {
  401.             $this->customTreeWalkers = $customWalkers;
  402.         }
  404.         $customOutputWalker = $this->query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER);
  405.         if ($customOutputWalker !== false) {
  406.             $this->customOutputWalker = $customOutputWalker;
  407.         }
  409.         // Run any custom tree walkers over the AST
  410.         if ($this->customTreeWalkers) {
  411.             $treeWalkerChain = new TreeWalkerChain($this->query, $this->parserResult, $this->queryComponents);
  413.             foreach ($this->customTreeWalkers as $walker) {
  414.                 $treeWalkerChain->addTreeWalker($walker);
  415.             }
  417.             switch (true) {
  418.                 case $AST instanceof AST\UpdateStatement:
  419.                     $treeWalkerChain->walkUpdateStatement($AST);
  420.                     break;
  422.                 case $AST instanceof AST\DeleteStatement:
  423.                     $treeWalkerChain->walkDeleteStatement($AST);
  424.                     break;
  426.                 case $AST instanceof AST\SelectStatement:
  427.                 default:
  428.                     $treeWalkerChain->walkSelectStatement($AST);
  429.             }
  431.             $this->queryComponents = $treeWalkerChain->getQueryComponents();
  432.         }
  434.         $outputWalkerClass = $this->customOutputWalker ?: SqlWalker::class;
  435.         $outputWalker      = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
  437.         // Assign an SQL executor to the parser result
  438.         $this->parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
  440.         return $this->parserResult;
  441.     }
  443.     /**
  444.      * Fixes order of identification variables.
  445.      *
  446.      * They have to appear in the select clause in the same order as the
  447.      * declarations (from ... x join ... y join ... z ...) appear in the query
  448.      * as the hydration process relies on that order for proper operation.
  449.      *
  450.      * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST
  451.      */
  452.     private function fixIdentificationVariableOrder(Node $AST): void
  453.     {
  454.         if (count($this->identVariableExpressions) <= 1) {
  455.             return;
  456.         }
  458.         assert($AST instanceof AST\SelectStatement);
  460.         foreach ($this->queryComponents as $dqlAlias => $qComp) {
  461.             if (! isset($this->identVariableExpressions[$dqlAlias])) {
  462.                 continue;
  463.             }
  465.             $expr = $this->identVariableExpressions[$dqlAlias];
  466.             $key  = array_search($expr, $AST->selectClause->selectExpressions, true);
  468.             unset($AST->selectClause->selectExpressions[$key]);
  470.             $AST->selectClause->selectExpressions[] = $expr;
  471.         }
  472.     }
  474.     /**
  475.      * Generates a new syntax error.
  476.      *
  477.      * @param string       $expected Expected string.
  478.      * @param mixed[]|null $token    Got token.
  479.      * @psalm-param array<string, mixed>|null $token
  480.      *
  481.      * @return void
  482.      * @psalm-return no-return
  483.      *
  484.      * @throws QueryException
  485.      */
  486.     public function syntaxError($expected = '', $token = null)
  487.     {
  488.         if ($token === null) {
  489.             $token = $this->lexer->lookahead;
  490.         }
  492.         $tokenPos = $token['position'] ?? '-1';
  494.         $message  = sprintf('line 0, col %d: Error: ', $tokenPos);
  495.         $message .= $expected !== '' ? sprintf('Expected %s, got ', $expected) : 'Unexpected ';
  496.         $message .= $this->lexer->lookahead === null ? 'end of string.' : sprintf("'%s'", $token['value']);
  498.         throw QueryException::syntaxError($message, QueryException::dqlError($this->query->getDQL() ?? ''));
  499.     }
  501.     /**
  502.      * Generates a new semantical error.
  503.      *
  504.      * @param string       $message Optional message.
  505.      * @param mixed[]|null $token   Optional token.
  506.      * @psalm-param array<string, mixed>|null $token
  507.      *
  508.      * @return void
  509.      *
  510.      * @throws QueryException
  511.      */
  512.     public function semanticalError($message = '', $token = null)
  513.     {
  514.         if ($token === null) {
  515.             $token = $this->lexer->lookahead ?? ['position' => 0];
  516.         }
  518.         // Minimum exposed chars ahead of token
  519.         $distance = 12;
  521.         // Find a position of a final word to display in error string
  522.         $dql    = $this->query->getDQL();
  523.         $length = strlen($dql);
  524.         $pos    = $token['position'] + $distance;
  525.         $pos    = strpos($dql, ' ', $length > $pos ? $pos : $length);
  526.         $length = $pos !== false ? $pos - $token['position'] : $distance;
  528.         $tokenPos = $token['position'] > 0 ? $token['position'] : '-1';
  529.         $tokenStr = substr($dql, $token['position'], $length);
  531.         // Building informative message
  532.         $message = 'line 0, col ' . $tokenPos . " near '" . $tokenStr . "': Error: " . $message;
  534.         throw QueryException::semanticalError($message, QueryException::dqlError($this->query->getDQL()));
  535.     }
  537.     /**
  538.      * Peeks beyond the matched closing parenthesis and returns the first token after that one.
  539.      *
  540.      * @param bool $resetPeek Reset peek after finding the closing parenthesis.
  541.      *
  542.      * @return mixed[]
  543.      * @psalm-return array{value: string, type: int|null|string, position: int}|null
  544.      */
  545.     private function peekBeyondClosingParenthesis(bool $resetPeek = true): ?array
  546.     {
  547.         $token        = $this->lexer->peek();
  548.         $numUnmatched = 1;
  550.         while ($numUnmatched > 0 && $token !== null) {
  551.             switch ($token['type']) {
  552.                 case Lexer::T_OPEN_PARENTHESIS:
  553.                     ++$numUnmatched;
  554.                     break;
  556.                 case Lexer::T_CLOSE_PARENTHESIS:
  557.                     --$numUnmatched;
  558.                     break;
  560.                 default:
  561.                     // Do nothing
  562.             }
  564.             $token = $this->lexer->peek();
  565.         }
  567.         if ($resetPeek) {
  568.             $this->lexer->resetPeek();
  569.         }
  571.         return $token;
  572.     }
  574.     /**
  575.      * Checks if the given token indicates a mathematical operator.
  576.      *
  577.      * @psalm-param array<string, mixed>|null $token
  578.      */
  579.     private function isMathOperator(?array $token): bool
  580.     {
  581.         return $token !== null && in_array($token['type'], [Lexer::T_PLUS, Lexer::T_MINUS, Lexer::T_DIVIDE, Lexer::T_MULTIPLY], true);
  582.     }
  584.     /**
  585.      * Checks if the next-next (after lookahead) token starts a function.
  586.      *
  587.      * @return bool TRUE if the next-next tokens start a function, FALSE otherwise.
  588.      */
  589.     private function isFunction(): bool
  590.     {
  591.         $lookaheadType = $this->lexer->lookahead['type'];
  592.         $peek          = $this->lexer->peek();
  594.         $this->lexer->resetPeek();
  596.         return $lookaheadType >= Lexer::T_IDENTIFIER && $peek !== null && $peek['type'] === Lexer::T_OPEN_PARENTHESIS;
  597.     }
  599.     /**
  600.      * Checks whether the given token type indicates an aggregate function.
  601.      *
  602.      * @psalm-param Lexer::T_* $tokenType
  603.      *
  604.      * @return bool TRUE if the token type is an aggregate function, FALSE otherwise.
  605.      */
  606.     private function isAggregateFunction(int $tokenType): bool
  607.     {
  608.         return in_array(
  609.             $tokenType,
  610.             [Lexer::T_AVG, Lexer::T_MIN, Lexer::T_MAX, Lexer::T_SUM, Lexer::T_COUNT],
  611.             true
  612.         );
  613.     }
  615.     /**
  616.      * Checks whether the current lookahead token of the lexer has the type T_ALL, T_ANY or T_SOME.
  617.      */
  618.     private function isNextAllAnySome(): bool
  619.     {
  620.         return in_array(
  621.             $this->lexer->lookahead['type'],
  622.             [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME],
  623.             true
  624.         );
  625.     }
  627.     /**
  628.      * Validates that the given <tt>IdentificationVariable</tt> is semantically correct.
  629.      * It must exist in query components list.
  630.      */
  631.     private function processDeferredIdentificationVariables(): void
  632.     {
  633.         foreach ($this->deferredIdentificationVariables as $deferredItem) {
  634.             $identVariable = $deferredItem['expression'];
  636.             // Check if IdentificationVariable exists in queryComponents
  637.             if (! isset($this->queryComponents[$identVariable])) {
  638.                 $this->semanticalError(
  639.                     sprintf("'%s' is not defined.", $identVariable),
  640.                     $deferredItem['token']
  641.                 );
  642.             }
  644.             $qComp = $this->queryComponents[$identVariable];
  646.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  647.             if (! isset($qComp['metadata'])) {
  648.                 $this->semanticalError(
  649.                     sprintf("'%s' does not point to a Class.", $identVariable),
  650.                     $deferredItem['token']
  651.                 );
  652.             }
  654.             // Validate if identification variable nesting level is lower or equal than the current one
  655.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  656.                 $this->semanticalError(
  657.                     sprintf("'%s' is used outside the scope of its declaration.", $identVariable),
  658.                     $deferredItem['token']
  659.                 );
  660.             }
  661.         }
  662.     }
  664.     /**
  665.      * Validates that the given <tt>NewObjectExpression</tt>.
  666.      */
  667.     private function processDeferredNewObjectExpressions(SelectStatement $AST): void
  668.     {
  669.         foreach ($this->deferredNewObjectExpressions as $deferredItem) {
  670.             $expression    = $deferredItem['expression'];
  671.             $token         = $deferredItem['token'];
  672.             $className     = $expression->className;
  673.             $args          = $expression->args;
  674.             $fromClassName = $AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName ?? null;
  676.             // If the namespace is not given then assumes the first FROM entity namespace
  677.             if (strpos($className, '\\') === false && ! class_exists($className) && strpos($fromClassName, '\\') !== false) {
  678.                 $namespace = substr($fromClassName, 0, strrpos($fromClassName, '\\'));
  679.                 $fqcn      = $namespace . '\\' . $className;
  681.                 if (class_exists($fqcn)) {
  682.                     $expression->className = $fqcn;
  683.                     $className             = $fqcn;
  684.                 }
  685.             }
  687.             if (! class_exists($className)) {
  688.                 $this->semanticalError(sprintf('Class "%s" is not defined.', $className), $token);
  689.             }
  691.             $class = new ReflectionClass($className);
  693.             if (! $class->isInstantiable()) {
  694.                 $this->semanticalError(sprintf('Class "%s" can not be instantiated.', $className), $token);
  695.             }
  697.             if ($class->getConstructor() === null) {
  698.                 $this->semanticalError(sprintf('Class "%s" has not a valid constructor.', $className), $token);
  699.             }
  701.             if ($class->getConstructor()->getNumberOfRequiredParameters() > count($args)) {
  702.                 $this->semanticalError(sprintf('Number of arguments does not match with "%s" constructor declaration.', $className), $token);
  703.             }
  704.         }
  705.     }
  707.     /**
  708.      * Validates that the given <tt>PartialObjectExpression</tt> is semantically correct.
  709.      * It must exist in query components list.
  710.      */
  711.     private function processDeferredPartialObjectExpressions(): void
  712.     {
  713.         foreach ($this->deferredPartialObjectExpressions as $deferredItem) {
  714.             $expr  = $deferredItem['expression'];
  715.             $class = $this->queryComponents[$expr->identificationVariable]['metadata'];
  717.             foreach ($expr->partialFieldSet as $field) {
  718.                 if (isset($class->fieldMappings[$field])) {
  719.                     continue;
  720.                 }
  722.                 if (
  723.                     isset($class->associationMappings[$field]) &&
  724.                     $class->associationMappings[$field]['isOwningSide'] &&
  725.                     $class->associationMappings[$field]['type'] & ClassMetadata::TO_ONE
  726.                 ) {
  727.                     continue;
  728.                 }
  730.                 $this->semanticalError(sprintf(
  731.                     "There is no mapped field named '%s' on class %s.",
  732.                     $field,
  733.                     $class->name
  734.                 ), $deferredItem['token']);
  735.             }
  737.             if (array_intersect($class->identifier, $expr->partialFieldSet) !== $class->identifier) {
  738.                 $this->semanticalError(
  739.                     'The partial field selection of class ' . $class->name . ' must contain the identifier.',
  740.                     $deferredItem['token']
  741.                 );
  742.             }
  743.         }
  744.     }
  746.     /**
  747.      * Validates that the given <tt>ResultVariable</tt> is semantically correct.
  748.      * It must exist in query components list.
  749.      */
  750.     private function processDeferredResultVariables(): void
  751.     {
  752.         foreach ($this->deferredResultVariables as $deferredItem) {
  753.             $resultVariable = $deferredItem['expression'];
  755.             // Check if ResultVariable exists in queryComponents
  756.             if (! isset($this->queryComponents[$resultVariable])) {
  757.                 $this->semanticalError(
  758.                     sprintf("'%s' is not defined.", $resultVariable),
  759.                     $deferredItem['token']
  760.                 );
  761.             }
  763.             $qComp = $this->queryComponents[$resultVariable];
  765.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  766.             if (! isset($qComp['resultVariable'])) {
  767.                 $this->semanticalError(
  768.                     sprintf("'%s' does not point to a ResultVariable.", $resultVariable),
  769.                     $deferredItem['token']
  770.                 );
  771.             }
  773.             // Validate if identification variable nesting level is lower or equal than the current one
  774.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  775.                 $this->semanticalError(
  776.                     sprintf("'%s' is used outside the scope of its declaration.", $resultVariable),
  777.                     $deferredItem['token']
  778.                 );
  779.             }
  780.         }
  781.     }
  783.     /**
  784.      * Validates that the given <tt>PathExpression</tt> is semantically correct for grammar rules:
  785.      *
  786.      * AssociationPathExpression             ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  787.      * SingleValuedPathExpression            ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  788.      * StateFieldPathExpression              ::= IdentificationVariable "." StateField
  789.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  790.      * CollectionValuedPathExpression        ::= IdentificationVariable "." CollectionValuedAssociationField
  791.      */
  792.     private function processDeferredPathExpressions(): void
  793.     {
  794.         foreach ($this->deferredPathExpressions as $deferredItem) {
  795.             $pathExpression = $deferredItem['expression'];
  797.             $qComp = $this->queryComponents[$pathExpression->identificationVariable];
  798.             $class = $qComp['metadata'];
  800.             $field = $pathExpression->field;
  801.             if ($field === null) {
  802.                 $field = $pathExpression->field = $class->identifier[0];
  803.             }
  805.             // Check if field or association exists
  806.             if (! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
  807.                 $this->semanticalError(
  808.                     'Class ' . $class->name . ' has no field or association named ' . $field,
  809.                     $deferredItem['token']
  810.                 );
  811.             }
  813.             $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
  815.             if (isset($class->associationMappings[$field])) {
  816.                 $assoc = $class->associationMappings[$field];
  818.                 $fieldType = $assoc['type'] & ClassMetadata::TO_ONE
  819.                     ? AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  820.                     : AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
  821.             }
  823.             // Validate if PathExpression is one of the expected types
  824.             $expectedType = $pathExpression->expectedType;
  826.             if (! ($expectedType & $fieldType)) {
  827.                 // We need to recognize which was expected type(s)
  828.                 $expectedStringTypes = [];
  830.                 // Validate state field type
  831.                 if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
  832.                     $expectedStringTypes[] = 'StateFieldPathExpression';
  833.                 }
  835.                 // Validate single valued association (*-to-one)
  836.                 if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
  837.                     $expectedStringTypes[] = 'SingleValuedAssociationField';
  838.                 }
  840.                 // Validate single valued association (*-to-many)
  841.                 if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
  842.                     $expectedStringTypes[] = 'CollectionValuedAssociationField';
  843.                 }
  845.                 // Build the error message
  846.                 $semanticalError  = 'Invalid PathExpression. ';
  847.                 $semanticalError .= count($expectedStringTypes) === 1
  848.                     ? 'Must be a ' . $expectedStringTypes[0] . '.'
  849.                     : implode(' or ', $expectedStringTypes) . ' expected.';
  851.                 $this->semanticalError($semanticalError, $deferredItem['token']);
  852.             }
  854.             // We need to force the type in PathExpression
  855.             $pathExpression->type = $fieldType;
  856.         }
  857.     }
  859.     private function processRootEntityAliasSelected(): void
  860.     {
  861.         if (! count($this->identVariableExpressions)) {
  862.             return;
  863.         }
  865.         foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
  866.             if (isset($this->queryComponents[$dqlAlias]) && $this->queryComponents[$dqlAlias]['parent'] === null) {
  867.                 return;
  868.             }
  869.         }
  871.         $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');
  872.     }
  874.     /**
  875.      * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
  876.      *
  877.      * @return SelectStatement|UpdateStatement|DeleteStatement
  878.      */
  879.     public function QueryLanguage()
  880.     {
  881.         $statement = null;
  883.         $this->lexer->moveNext();
  885.         switch ($this->lexer->lookahead['type'] ?? null) {
  886.             case Lexer::T_SELECT:
  887.                 $statement = $this->SelectStatement();
  888.                 break;
  890.             case Lexer::T_UPDATE:
  891.                 $statement = $this->UpdateStatement();
  892.                 break;
  894.             case Lexer::T_DELETE:
  895.                 $statement = $this->DeleteStatement();
  896.                 break;
  898.             default:
  899.                 $this->syntaxError('SELECT, UPDATE or DELETE');
  900.                 break;
  901.         }
  903.         // Check for end of string
  904.         if ($this->lexer->lookahead !== null) {
  905.             $this->syntaxError('end of string');
  906.         }
  908.         return $statement;
  909.     }
  911.     /**
  912.      * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  913.      *
  914.      * @return SelectStatement
  915.      */
  916.     public function SelectStatement()
  917.     {
  918.         $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());
  920.         $selectStatement->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  921.         $selectStatement->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  922.         $selectStatement->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  923.         $selectStatement->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  925.         return $selectStatement;
  926.     }
  928.     /**
  929.      * UpdateStatement ::= UpdateClause [WhereClause]
  930.      *
  931.      * @return UpdateStatement
  932.      */
  933.     public function UpdateStatement()
  934.     {
  935.         $updateStatement = new AST\UpdateStatement($this->UpdateClause());
  937.         $updateStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  939.         return $updateStatement;
  940.     }
  942.     /**
  943.      * DeleteStatement ::= DeleteClause [WhereClause]
  944.      *
  945.      * @return DeleteStatement
  946.      */
  947.     public function DeleteStatement()
  948.     {
  949.         $deleteStatement = new AST\DeleteStatement($this->DeleteClause());
  951.         $deleteStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  953.         return $deleteStatement;
  954.     }
  956.     /**
  957.      * IdentificationVariable ::= identifier
  958.      *
  959.      * @return string
  960.      */
  961.     public function IdentificationVariable()
  962.     {
  963.         $this->match(Lexer::T_IDENTIFIER);
  965.         $identVariable = $this->lexer->token['value'];
  967.         $this->deferredIdentificationVariables[] = [
  968.             'expression'   => $identVariable,
  969.             'nestingLevel' => $this->nestingLevel,
  970.             'token'        => $this->lexer->token,
  971.         ];
  973.         return $identVariable;
  974.     }
  976.     /**
  977.      * AliasIdentificationVariable = identifier
  978.      *
  979.      * @return string
  980.      */
  981.     public function AliasIdentificationVariable()
  982.     {
  983.         $this->match(Lexer::T_IDENTIFIER);
  985.         $aliasIdentVariable = $this->lexer->token['value'];
  986.         $exists             = isset($this->queryComponents[$aliasIdentVariable]);
  988.         if ($exists) {
  989.             $this->semanticalError(
  990.                 sprintf("'%s' is already defined.", $aliasIdentVariable),
  991.                 $this->lexer->token
  992.             );
  993.         }
  995.         return $aliasIdentVariable;
  996.     }
  998.     /**
  999.      * AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
  1000.      *
  1001.      * @return string
  1002.      */
  1003.     public function AbstractSchemaName()
  1004.     {
  1005.         if ($this->lexer->isNextToken(Lexer::T_FULLY_QUALIFIED_NAME)) {
  1006.             $this->match(Lexer::T_FULLY_QUALIFIED_NAME);
  1008.             return $this->lexer->token['value'];
  1009.         }
  1011.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  1012.             $this->match(Lexer::T_IDENTIFIER);
  1014.             return $this->lexer->token['value'];
  1015.         }
  1017.         $this->match(Lexer::T_ALIASED_NAME);
  1019.         [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token['value']);
  1021.         return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  1022.     }
  1024.     /**
  1025.      * Validates an AbstractSchemaName, making sure the class exists.
  1026.      *
  1027.      * @param string $schemaName The name to validate.
  1028.      *
  1029.      * @throws QueryException if the name does not exist.
  1030.      */
  1031.     private function validateAbstractSchemaName(string $schemaName): void
  1032.     {
  1033.         if (! (class_exists($schemaName, true) || interface_exists($schemaName, true))) {
  1034.             $this->semanticalError(
  1035.                 sprintf("Class '%s' is not defined.", $schemaName),
  1036.                 $this->lexer->token
  1037.             );
  1038.         }
  1039.     }
  1041.     /**
  1042.      * AliasResultVariable ::= identifier
  1043.      *
  1044.      * @return string
  1045.      */
  1046.     public function AliasResultVariable()
  1047.     {
  1048.         $this->match(Lexer::T_IDENTIFIER);
  1050.         $resultVariable = $this->lexer->token['value'];
  1051.         $exists         = isset($this->queryComponents[$resultVariable]);
  1053.         if ($exists) {
  1054.             $this->semanticalError(
  1055.                 sprintf("'%s' is already defined.", $resultVariable),
  1056.                 $this->lexer->token
  1057.             );
  1058.         }
  1060.         return $resultVariable;
  1061.     }
  1063.     /**
  1064.      * ResultVariable ::= identifier
  1065.      *
  1066.      * @return string
  1067.      */
  1068.     public function ResultVariable()
  1069.     {
  1070.         $this->match(Lexer::T_IDENTIFIER);
  1072.         $resultVariable = $this->lexer->token['value'];
  1074.         // Defer ResultVariable validation
  1075.         $this->deferredResultVariables[] = [
  1076.             'expression'   => $resultVariable,
  1077.             'nestingLevel' => $this->nestingLevel,
  1078.             'token'        => $this->lexer->token,
  1079.         ];
  1081.         return $resultVariable;
  1082.     }
  1084.     /**
  1085.      * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
  1086.      *
  1087.      * @return JoinAssociationPathExpression
  1088.      */
  1089.     public function JoinAssociationPathExpression()
  1090.     {
  1091.         $identVariable = $this->IdentificationVariable();
  1093.         if (! isset($this->queryComponents[$identVariable])) {
  1094.             $this->semanticalError(
  1095.                 'Identification Variable ' . $identVariable . ' used in join path expression but was not defined before.'
  1096.             );
  1097.         }
  1099.         $this->match(Lexer::T_DOT);
  1100.         $this->match(Lexer::T_IDENTIFIER);
  1102.         $field = $this->lexer->token['value'];
  1104.         // Validate association field
  1105.         $qComp = $this->queryComponents[$identVariable];
  1106.         $class = $qComp['metadata'];
  1108.         if (! $class->hasAssociation($field)) {
  1109.             $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
  1110.         }
  1112.         return new AST\JoinAssociationPathExpression($identVariable, $field);
  1113.     }
  1115.     /**
  1116.      * Parses an arbitrary path expression and defers semantical validation
  1117.      * based on expected types.
  1118.      *
  1119.      * PathExpression ::= IdentificationVariable {"." identifier}*
  1120.      *
  1121.      * @param int $expectedTypes
  1122.      *
  1123.      * @return PathExpression
  1124.      */
  1125.     public function PathExpression($expectedTypes)
  1126.     {
  1127.         $identVariable = $this->IdentificationVariable();
  1128.         $field         = null;
  1130.         if ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1131.             $this->match(Lexer::T_DOT);
  1132.             $this->match(Lexer::T_IDENTIFIER);
  1134.             $field = $this->lexer->token['value'];
  1136.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1137.                 $this->match(Lexer::T_DOT);
  1138.                 $this->match(Lexer::T_IDENTIFIER);
  1139.                 $field .= '.' . $this->lexer->token['value'];
  1140.             }
  1141.         }
  1143.         // Creating AST node
  1144.         $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);
  1146.         // Defer PathExpression validation if requested to be deferred
  1147.         $this->deferredPathExpressions[] = [
  1148.             'expression'   => $pathExpr,
  1149.             'nestingLevel' => $this->nestingLevel,
  1150.             'token'        => $this->lexer->token,
  1151.         ];
  1153.         return $pathExpr;
  1154.     }
  1156.     /**
  1157.      * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  1158.      *
  1159.      * @return PathExpression
  1160.      */
  1161.     public function AssociationPathExpression()
  1162.     {
  1163.         return $this->PathExpression(
  1164.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |
  1165.             AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION
  1166.         );
  1167.     }
  1169.     /**
  1170.      * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  1171.      *
  1172.      * @return PathExpression
  1173.      */
  1174.     public function SingleValuedPathExpression()
  1175.     {
  1176.         return $this->PathExpression(
  1177.             AST\PathExpression::TYPE_STATE_FIELD |
  1178.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  1179.         );
  1180.     }
  1182.     /**
  1183.      * StateFieldPathExpression ::= IdentificationVariable "." StateField
  1184.      *
  1185.      * @return PathExpression
  1186.      */
  1187.     public function StateFieldPathExpression()
  1188.     {
  1189.         return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);
  1190.     }
  1192.     /**
  1193.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  1194.      *
  1195.      * @return PathExpression
  1196.      */
  1197.     public function SingleValuedAssociationPathExpression()
  1198.     {
  1199.         return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);
  1200.     }
  1202.     /**
  1203.      * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  1204.      *
  1205.      * @return PathExpression
  1206.      */
  1207.     public function CollectionValuedPathExpression()
  1208.     {
  1209.         return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);
  1210.     }
  1212.     /**
  1213.      * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
  1214.      *
  1215.      * @return SelectClause
  1216.      */
  1217.     public function SelectClause()
  1218.     {
  1219.         $isDistinct = false;
  1220.         $this->match(Lexer::T_SELECT);
  1222.         // Check for DISTINCT
  1223.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1224.             $this->match(Lexer::T_DISTINCT);
  1226.             $isDistinct = true;
  1227.         }
  1229.         // Process SelectExpressions (1..N)
  1230.         $selectExpressions   = [];
  1231.         $selectExpressions[] = $this->SelectExpression();
  1233.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1234.             $this->match(Lexer::T_COMMA);
  1236.             $selectExpressions[] = $this->SelectExpression();
  1237.         }
  1239.         return new AST\SelectClause($selectExpressions, $isDistinct);
  1240.     }
  1242.     /**
  1243.      * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
  1244.      *
  1245.      * @return SimpleSelectClause
  1246.      */
  1247.     public function SimpleSelectClause()
  1248.     {
  1249.         $isDistinct = false;
  1250.         $this->match(Lexer::T_SELECT);
  1252.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1253.             $this->match(Lexer::T_DISTINCT);
  1255.             $isDistinct = true;
  1256.         }
  1258.         return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);
  1259.     }
  1261.     /**
  1262.      * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*
  1263.      *
  1264.      * @return UpdateClause
  1265.      */
  1266.     public function UpdateClause()
  1267.     {
  1268.         $this->match(Lexer::T_UPDATE);
  1270.         $token              = $this->lexer->lookahead;
  1271.         $abstractSchemaName = $this->AbstractSchemaName();
  1273.         $this->validateAbstractSchemaName($abstractSchemaName);
  1275.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1276.             $this->match(Lexer::T_AS);
  1277.         }
  1279.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1281.         $class = $this->em->getClassMetadata($abstractSchemaName);
  1283.         // Building queryComponent
  1284.         $queryComponent = [
  1285.             'metadata'     => $class,
  1286.             'parent'       => null,
  1287.             'relation'     => null,
  1288.             'map'          => null,
  1289.             'nestingLevel' => $this->nestingLevel,
  1290.             'token'        => $token,
  1291.         ];
  1293.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1295.         $this->match(Lexer::T_SET);
  1297.         $updateItems   = [];
  1298.         $updateItems[] = $this->UpdateItem();
  1300.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1301.             $this->match(Lexer::T_COMMA);
  1303.             $updateItems[] = $this->UpdateItem();
  1304.         }
  1306.         $updateClause                              = new AST\UpdateClause($abstractSchemaName, $updateItems);
  1307.         $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1309.         return $updateClause;
  1310.     }
  1312.     /**
  1313.      * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable
  1314.      *
  1315.      * @return DeleteClause
  1316.      */
  1317.     public function DeleteClause()
  1318.     {
  1319.         $this->match(Lexer::T_DELETE);
  1321.         if ($this->lexer->isNextToken(Lexer::T_FROM)) {
  1322.             $this->match(Lexer::T_FROM);
  1323.         }
  1325.         $token              = $this->lexer->lookahead;
  1326.         $abstractSchemaName = $this->AbstractSchemaName();
  1328.         $this->validateAbstractSchemaName($abstractSchemaName);
  1330.         $deleteClause = new AST\DeleteClause($abstractSchemaName);
  1332.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1333.             $this->match(Lexer::T_AS);
  1334.         }
  1336.         $aliasIdentificationVariable = $this->lexer->isNextToken(Lexer::T_IDENTIFIER)
  1337.             ? $this->AliasIdentificationVariable()
  1338.             : 'alias_should_have_been_set';
  1340.         $deleteClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1341.         $class                                     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1343.         // Building queryComponent
  1344.         $queryComponent = [
  1345.             'metadata'     => $class,
  1346.             'parent'       => null,
  1347.             'relation'     => null,
  1348.             'map'          => null,
  1349.             'nestingLevel' => $this->nestingLevel,
  1350.             'token'        => $token,
  1351.         ];
  1353.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1355.         return $deleteClause;
  1356.     }
  1358.     /**
  1359.      * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}*
  1360.      *
  1361.      * @return FromClause
  1362.      */
  1363.     public function FromClause()
  1364.     {
  1365.         $this->match(Lexer::T_FROM);
  1367.         $identificationVariableDeclarations   = [];
  1368.         $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1370.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1371.             $this->match(Lexer::T_COMMA);
  1373.             $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1374.         }
  1376.         return new AST\FromClause($identificationVariableDeclarations);
  1377.     }
  1379.     /**
  1380.      * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
  1381.      *
  1382.      * @return SubselectFromClause
  1383.      */
  1384.     public function SubselectFromClause()
  1385.     {
  1386.         $this->match(Lexer::T_FROM);
  1388.         $identificationVariables   = [];
  1389.         $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1391.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1392.             $this->match(Lexer::T_COMMA);
  1394.             $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1395.         }
  1397.         return new AST\SubselectFromClause($identificationVariables);
  1398.     }
  1400.     /**
  1401.      * WhereClause ::= "WHERE" ConditionalExpression
  1402.      *
  1403.      * @return WhereClause
  1404.      */
  1405.     public function WhereClause()
  1406.     {
  1407.         $this->match(Lexer::T_WHERE);
  1409.         return new AST\WhereClause($this->ConditionalExpression());
  1410.     }
  1412.     /**
  1413.      * HavingClause ::= "HAVING" ConditionalExpression
  1414.      *
  1415.      * @return HavingClause
  1416.      */
  1417.     public function HavingClause()
  1418.     {
  1419.         $this->match(Lexer::T_HAVING);
  1421.         return new AST\HavingClause($this->ConditionalExpression());
  1422.     }
  1424.     /**
  1425.      * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
  1426.      *
  1427.      * @return GroupByClause
  1428.      */
  1429.     public function GroupByClause()
  1430.     {
  1431.         $this->match(Lexer::T_GROUP);
  1432.         $this->match(Lexer::T_BY);
  1434.         $groupByItems = [$this->GroupByItem()];
  1436.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1437.             $this->match(Lexer::T_COMMA);
  1439.             $groupByItems[] = $this->GroupByItem();
  1440.         }
  1442.         return new AST\GroupByClause($groupByItems);
  1443.     }
  1445.     /**
  1446.      * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
  1447.      *
  1448.      * @return OrderByClause
  1449.      */
  1450.     public function OrderByClause()
  1451.     {
  1452.         $this->match(Lexer::T_ORDER);
  1453.         $this->match(Lexer::T_BY);
  1455.         $orderByItems   = [];
  1456.         $orderByItems[] = $this->OrderByItem();
  1458.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1459.             $this->match(Lexer::T_COMMA);
  1461.             $orderByItems[] = $this->OrderByItem();
  1462.         }
  1464.         return new AST\OrderByClause($orderByItems);
  1465.     }
  1467.     /**
  1468.      * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  1469.      *
  1470.      * @return Subselect
  1471.      */
  1472.     public function Subselect()
  1473.     {
  1474.         // Increase query nesting level
  1475.         $this->nestingLevel++;
  1477.         $subselect = new AST\Subselect($this->SimpleSelectClause(), $this->SubselectFromClause());
  1479.         $subselect->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  1480.         $subselect->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  1481.         $subselect->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  1482.         $subselect->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  1484.         // Decrease query nesting level
  1485.         $this->nestingLevel--;
  1487.         return $subselect;
  1488.     }
  1490.     /**
  1491.      * UpdateItem ::= SingleValuedPathExpression "=" NewValue
  1492.      *
  1493.      * @return UpdateItem
  1494.      */
  1495.     public function UpdateItem()
  1496.     {
  1497.         $pathExpr = $this->SingleValuedPathExpression();
  1499.         $this->match(Lexer::T_EQUALS);
  1501.         return new AST\UpdateItem($pathExpr, $this->NewValue());
  1502.     }
  1504.     /**
  1505.      * GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression
  1506.      *
  1507.      * @return string|PathExpression
  1508.      */
  1509.     public function GroupByItem()
  1510.     {
  1511.         // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  1512.         $glimpse = $this->lexer->glimpse();
  1514.         if ($glimpse !== null && $glimpse['type'] === Lexer::T_DOT) {
  1515.             return $this->SingleValuedPathExpression();
  1516.         }
  1518.         // Still need to decide between IdentificationVariable or ResultVariable
  1519.         $lookaheadValue = $this->lexer->lookahead['value'];
  1521.         if (! isset($this->queryComponents[$lookaheadValue])) {
  1522.             $this->semanticalError('Cannot group by undefined identification or result variable.');
  1523.         }
  1525.         return isset($this->queryComponents[$lookaheadValue]['metadata'])
  1526.             ? $this->IdentificationVariable()
  1527.             : $this->ResultVariable();
  1528.     }
  1530.     /**
  1531.      * OrderByItem ::= (
  1532.      *      SimpleArithmeticExpression | SingleValuedPathExpression | CaseExpression |
  1533.      *      ScalarExpression | ResultVariable | FunctionDeclaration
  1534.      * ) ["ASC" | "DESC"]
  1535.      *
  1536.      * @return OrderByItem
  1537.      */
  1538.     public function OrderByItem()
  1539.     {
  1540.         $this->lexer->peek(); // lookahead => '.'
  1541.         $this->lexer->peek(); // lookahead => token after '.'
  1543.         $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1545.         $this->lexer->resetPeek();
  1547.         $glimpse = $this->lexer->glimpse();
  1549.         switch (true) {
  1550.             case $this->isMathOperator($peek):
  1551.                 $expr = $this->SimpleArithmeticExpression();
  1552.                 break;
  1554.             case $glimpse !== null && $glimpse['type'] === Lexer::T_DOT:
  1555.                 $expr = $this->SingleValuedPathExpression();
  1556.                 break;
  1558.             case $this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  1559.                 $expr = $this->ScalarExpression();
  1560.                 break;
  1562.             case $this->lexer->lookahead['type'] === Lexer::T_CASE:
  1563.                 $expr = $this->CaseExpression();
  1564.                 break;
  1566.             case $this->isFunction():
  1567.                 $expr = $this->FunctionDeclaration();
  1568.                 break;
  1570.             default:
  1571.                 $expr = $this->ResultVariable();
  1572.                 break;
  1573.         }
  1575.         $type = 'ASC';
  1576.         $item = new AST\OrderByItem($expr);
  1578.         switch (true) {
  1579.             case $this->lexer->isNextToken(Lexer::T_DESC):
  1580.                 $this->match(Lexer::T_DESC);
  1581.                 $type = 'DESC';
  1582.                 break;
  1584.             case $this->lexer->isNextToken(Lexer::T_ASC):
  1585.                 $this->match(Lexer::T_ASC);
  1586.                 break;
  1588.             default:
  1589.                 // Do nothing
  1590.         }
  1592.         $item->type = $type;
  1594.         return $item;
  1595.     }
  1597.     /**
  1598.      * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
  1599.      *      EnumPrimary | SimpleEntityExpression | "NULL"
  1600.      *
  1601.      * NOTE: Since it is not possible to correctly recognize individual types, here is the full
  1602.      * grammar that needs to be supported:
  1603.      *
  1604.      * NewValue ::= SimpleArithmeticExpression | "NULL"
  1605.      *
  1606.      * SimpleArithmeticExpression covers all *Primary grammar rules and also SimpleEntityExpression
  1607.      *
  1608.      * @return AST\ArithmeticExpression|AST\InputParameter|null
  1609.      */
  1610.     public function NewValue()
  1611.     {
  1612.         if ($this->lexer->isNextToken(Lexer::T_NULL)) {
  1613.             $this->match(Lexer::T_NULL);
  1615.             return null;
  1616.         }
  1618.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  1619.             $this->match(Lexer::T_INPUT_PARAMETER);
  1621.             return new AST\InputParameter($this->lexer->token['value']);
  1622.         }
  1624.         return $this->ArithmeticExpression();
  1625.     }
  1627.     /**
  1628.      * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*
  1629.      *
  1630.      * @return IdentificationVariableDeclaration
  1631.      */
  1632.     public function IdentificationVariableDeclaration()
  1633.     {
  1634.         $joins                    = [];
  1635.         $rangeVariableDeclaration = $this->RangeVariableDeclaration();
  1636.         $indexBy                  = $this->lexer->isNextToken(Lexer::T_INDEX)
  1637.             ? $this->IndexBy()
  1638.             : null;
  1640.         $rangeVariableDeclaration->isRoot = true;
  1642.         while (
  1643.             $this->lexer->isNextToken(Lexer::T_LEFT) ||
  1644.             $this->lexer->isNextToken(Lexer::T_INNER) ||
  1645.             $this->lexer->isNextToken(Lexer::T_JOIN)
  1646.         ) {
  1647.             $joins[] = $this->Join();
  1648.         }
  1650.         return new AST\IdentificationVariableDeclaration(
  1651.             $rangeVariableDeclaration,
  1652.             $indexBy,
  1653.             $joins
  1654.         );
  1655.     }
  1657.     /**
  1658.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration
  1659.      *
  1660.      * {Internal note: WARNING: Solution is harder than a bare implementation.
  1661.      * Desired EBNF support:
  1662.      *
  1663.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
  1664.      *
  1665.      * It demands that entire SQL generation to become programmatical. This is
  1666.      * needed because association based subselect requires "WHERE" conditional
  1667.      * expressions to be injected, but there is no scope to do that. Only scope
  1668.      * accessible is "FROM", prohibiting an easy implementation without larger
  1669.      * changes.}
  1670.      *
  1671.      * @return IdentificationVariableDeclaration
  1672.      */
  1673.     public function SubselectIdentificationVariableDeclaration()
  1674.     {
  1675.         /*
  1676.         NOT YET IMPLEMENTED!
  1678.         $glimpse = $this->lexer->glimpse();
  1680.         if ($glimpse['type'] == Lexer::T_DOT) {
  1681.             $associationPathExpression = $this->AssociationPathExpression();
  1683.             if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1684.                 $this->match(Lexer::T_AS);
  1685.             }
  1687.             $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1688.             $identificationVariable      = $associationPathExpression->identificationVariable;
  1689.             $field                       = $associationPathExpression->associationField;
  1691.             $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1692.             $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1694.             // Building queryComponent
  1695.             $joinQueryComponent = array(
  1696.                 'metadata'     => $targetClass,
  1697.                 'parent'       => $identificationVariable,
  1698.                 'relation'     => $class->getAssociationMapping($field),
  1699.                 'map'          => null,
  1700.                 'nestingLevel' => $this->nestingLevel,
  1701.                 'token'        => $this->lexer->lookahead
  1702.             );
  1704.             $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1706.             return new AST\SubselectIdentificationVariableDeclaration(
  1707.                 $associationPathExpression, $aliasIdentificationVariable
  1708.             );
  1709.         }
  1710.         */
  1712.         return $this->IdentificationVariableDeclaration();
  1713.     }
  1715.     /**
  1716.      * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN"
  1717.      *          (JoinAssociationDeclaration | RangeVariableDeclaration)
  1718.      *          ["WITH" ConditionalExpression]
  1719.      *
  1720.      * @return Join
  1721.      */
  1722.     public function Join()
  1723.     {
  1724.         // Check Join type
  1725.         $joinType = AST\Join::JOIN_TYPE_INNER;
  1727.         switch (true) {
  1728.             case $this->lexer->isNextToken(Lexer::T_LEFT):
  1729.                 $this->match(Lexer::T_LEFT);
  1731.                 $joinType = AST\Join::JOIN_TYPE_LEFT;
  1733.                 // Possible LEFT OUTER join
  1734.                 if ($this->lexer->isNextToken(Lexer::T_OUTER)) {
  1735.                     $this->match(Lexer::T_OUTER);
  1737.                     $joinType = AST\Join::JOIN_TYPE_LEFTOUTER;
  1738.                 }
  1740.                 break;
  1742.             case $this->lexer->isNextToken(Lexer::T_INNER):
  1743.                 $this->match(Lexer::T_INNER);
  1744.                 break;
  1746.             default:
  1747.                 // Do nothing
  1748.         }
  1750.         $this->match(Lexer::T_JOIN);
  1752.         $next            = $this->lexer->glimpse();
  1753.         $joinDeclaration = $next['type'] === Lexer::T_DOT ? $this->JoinAssociationDeclaration() : $this->RangeVariableDeclaration();
  1754.         $adhocConditions = $this->lexer->isNextToken(Lexer::T_WITH);
  1755.         $join            = new AST\Join($joinType, $joinDeclaration);
  1757.         // Describe non-root join declaration
  1758.         if ($joinDeclaration instanceof AST\RangeVariableDeclaration) {
  1759.             $joinDeclaration->isRoot = false;
  1760.         }
  1762.         // Check for ad-hoc Join conditions
  1763.         if ($adhocConditions) {
  1764.             $this->match(Lexer::T_WITH);
  1766.             $join->conditionalExpression = $this->ConditionalExpression();
  1767.         }
  1769.         return $join;
  1770.     }
  1772.     /**
  1773.      * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
  1774.      *
  1775.      * @return RangeVariableDeclaration
  1776.      *
  1777.      * @throws QueryException
  1778.      */
  1779.     public function RangeVariableDeclaration()
  1780.     {
  1781.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $this->lexer->glimpse()['type'] === Lexer::T_SELECT) {
  1782.             $this->semanticalError('Subquery is not supported here', $this->lexer->token);
  1783.         }
  1785.         $abstractSchemaName = $this->AbstractSchemaName();
  1787.         $this->validateAbstractSchemaName($abstractSchemaName);
  1789.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1790.             $this->match(Lexer::T_AS);
  1791.         }
  1793.         $token                       = $this->lexer->lookahead;
  1794.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1795.         $classMetadata               = $this->em->getClassMetadata($abstractSchemaName);
  1797.         // Building queryComponent
  1798.         $queryComponent = [
  1799.             'metadata'     => $classMetadata,
  1800.             'parent'       => null,
  1801.             'relation'     => null,
  1802.             'map'          => null,
  1803.             'nestingLevel' => $this->nestingLevel,
  1804.             'token'        => $token,
  1805.         ];
  1807.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1809.         return new AST\RangeVariableDeclaration($abstractSchemaName, $aliasIdentificationVariable);
  1810.     }
  1812.     /**
  1813.      * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [IndexBy]
  1814.      *
  1815.      * @return AST\JoinAssociationDeclaration
  1816.      */
  1817.     public function JoinAssociationDeclaration()
  1818.     {
  1819.         $joinAssociationPathExpression = $this->JoinAssociationPathExpression();
  1821.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1822.             $this->match(Lexer::T_AS);
  1823.         }
  1825.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1826.         $indexBy                     = $this->lexer->isNextToken(Lexer::T_INDEX) ? $this->IndexBy() : null;
  1828.         $identificationVariable = $joinAssociationPathExpression->identificationVariable;
  1829.         $field                  = $joinAssociationPathExpression->associationField;
  1831.         $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1832.         $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1834.         // Building queryComponent
  1835.         $joinQueryComponent = [
  1836.             'metadata'     => $targetClass,
  1837.             'parent'       => $joinAssociationPathExpression->identificationVariable,
  1838.             'relation'     => $class->getAssociationMapping($field),
  1839.             'map'          => null,
  1840.             'nestingLevel' => $this->nestingLevel,
  1841.             'token'        => $this->lexer->lookahead,
  1842.         ];
  1844.         $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1846.         return new AST\JoinAssociationDeclaration($joinAssociationPathExpression, $aliasIdentificationVariable, $indexBy);
  1847.     }
  1849.     /**
  1850.      * PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
  1851.      * PartialFieldSet ::= "{" SimpleStateField {"," SimpleStateField}* "}"
  1852.      *
  1853.      * @return PartialObjectExpression
  1854.      */
  1855.     public function PartialObjectExpression()
  1856.     {
  1857.         Deprecation::trigger(
  1858.             'doctrine/orm',
  1859.             'https://github.com/doctrine/orm/issues/8471',
  1860.             'PARTIAL syntax in DQL is deprecated.'
  1861.         );
  1863.         $this->match(Lexer::T_PARTIAL);
  1865.         $partialFieldSet = [];
  1867.         $identificationVariable = $this->IdentificationVariable();
  1869.         $this->match(Lexer::T_DOT);
  1870.         $this->match(Lexer::T_OPEN_CURLY_BRACE);
  1871.         $this->match(Lexer::T_IDENTIFIER);
  1873.         $field = $this->lexer->token['value'];
  1875.         // First field in partial expression might be embeddable property
  1876.         while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1877.             $this->match(Lexer::T_DOT);
  1878.             $this->match(Lexer::T_IDENTIFIER);
  1879.             $field .= '.' . $this->lexer->token['value'];
  1880.         }
  1882.         $partialFieldSet[] = $field;
  1884.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1885.             $this->match(Lexer::T_COMMA);
  1886.             $this->match(Lexer::T_IDENTIFIER);
  1888.             $field = $this->lexer->token['value'];
  1890.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1891.                 $this->match(Lexer::T_DOT);
  1892.                 $this->match(Lexer::T_IDENTIFIER);
  1893.                 $field .= '.' . $this->lexer->token['value'];
  1894.             }
  1896.             $partialFieldSet[] = $field;
  1897.         }
  1899.         $this->match(Lexer::T_CLOSE_CURLY_BRACE);
  1901.         $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
  1903.         // Defer PartialObjectExpression validation
  1904.         $this->deferredPartialObjectExpressions[] = [
  1905.             'expression'   => $partialObjectExpression,
  1906.             'nestingLevel' => $this->nestingLevel,
  1907.             'token'        => $this->lexer->token,
  1908.         ];
  1910.         return $partialObjectExpression;
  1911.     }
  1913.     /**
  1914.      * NewObjectExpression ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
  1915.      *
  1916.      * @return NewObjectExpression
  1917.      */
  1918.     public function NewObjectExpression()
  1919.     {
  1920.         $this->match(Lexer::T_NEW);
  1922.         $className = $this->AbstractSchemaName(); // note that this is not yet validated
  1923.         $token     = $this->lexer->token;
  1925.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  1927.         $args[] = $this->NewObjectArg();
  1929.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1930.             $this->match(Lexer::T_COMMA);
  1932.             $args[] = $this->NewObjectArg();
  1933.         }
  1935.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1937.         $expression = new AST\NewObjectExpression($className, $args);
  1939.         // Defer NewObjectExpression validation
  1940.         $this->deferredNewObjectExpressions[] = [
  1941.             'token'        => $token,
  1942.             'expression'   => $expression,
  1943.             'nestingLevel' => $this->nestingLevel,
  1944.         ];
  1946.         return $expression;
  1947.     }
  1949.     /**
  1950.      * NewObjectArg ::= ScalarExpression | "(" Subselect ")"
  1951.      *
  1952.      * @return mixed
  1953.      */
  1954.     public function NewObjectArg()
  1955.     {
  1956.         $token = $this->lexer->lookahead;
  1957.         $peek  = $this->lexer->glimpse();
  1959.         if ($token['type'] === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT) {
  1960.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  1961.             $expression = $this->Subselect();
  1962.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1964.             return $expression;
  1965.         }
  1967.         return $this->ScalarExpression();
  1968.     }
  1970.     /**
  1971.      * IndexBy ::= "INDEX" "BY" SingleValuedPathExpression
  1972.      *
  1973.      * @return IndexBy
  1974.      */
  1975.     public function IndexBy()
  1976.     {
  1977.         $this->match(Lexer::T_INDEX);
  1978.         $this->match(Lexer::T_BY);
  1979.         $pathExpr = $this->SingleValuedPathExpression();
  1981.         // Add the INDEX BY info to the query component
  1982.         $this->queryComponents[$pathExpr->identificationVariable]['map'] = $pathExpr->field;
  1984.         return new AST\IndexBy($pathExpr);
  1985.     }
  1987.     /**
  1988.      * ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DateTimePrimary |
  1989.      *                      StateFieldPathExpression | BooleanPrimary | CaseExpression |
  1990.      *                      InstanceOfExpression
  1991.      *
  1992.      * @return mixed One of the possible expressions or subexpressions.
  1993.      */
  1994.     public function ScalarExpression()
  1995.     {
  1996.         $lookahead = $this->lexer->lookahead['type'];
  1997.         $peek      = $this->lexer->glimpse();
  1999.         switch (true) {
  2000.             case $lookahead === Lexer::T_INTEGER:
  2001.             case $lookahead === Lexer::T_FLOAT:
  2002.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )  or ( - 1 ) or ( + 1 )
  2003.             case $lookahead === Lexer::T_MINUS:
  2004.             case $lookahead === Lexer::T_PLUS:
  2005.                 return $this->SimpleArithmeticExpression();
  2007.             case $lookahead === Lexer::T_STRING:
  2008.                 return $this->StringPrimary();
  2010.             case $lookahead === Lexer::T_TRUE:
  2011.             case $lookahead === Lexer::T_FALSE:
  2012.                 $this->match($lookahead);
  2014.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2016.             case $lookahead === Lexer::T_INPUT_PARAMETER:
  2017.                 switch (true) {
  2018.                     case $this->isMathOperator($peek):
  2019.                         // :param + u.value
  2020.                         return $this->SimpleArithmeticExpression();
  2022.                     default:
  2023.                         return $this->InputParameter();
  2024.                 }
  2025.             case $lookahead === Lexer::T_CASE:
  2026.             case $lookahead === Lexer::T_COALESCE:
  2027.             case $lookahead === Lexer::T_NULLIF:
  2028.                 // Since NULLIF and COALESCE can be identified as a function,
  2029.                 // we need to check these before checking for FunctionDeclaration
  2030.                 return $this->CaseExpression();
  2032.             case $lookahead === Lexer::T_OPEN_PARENTHESIS:
  2033.                 return $this->SimpleArithmeticExpression();
  2035.             // this check must be done before checking for a filed path expression
  2036.             case $this->isFunction():
  2037.                 $this->lexer->peek(); // "("
  2039.                 switch (true) {
  2040.                     case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2041.                         // SUM(u.id) + COUNT(u.id)
  2042.                         return $this->SimpleArithmeticExpression();
  2044.                     default:
  2045.                         // IDENTITY(u)
  2046.                         return $this->FunctionDeclaration();
  2047.                 }
  2049.                 break;
  2050.             // it is no function, so it must be a field path
  2051.             case $lookahead === Lexer::T_IDENTIFIER:
  2052.                 $this->lexer->peek(); // lookahead => '.'
  2053.                 $this->lexer->peek(); // lookahead => token after '.'
  2054.                 $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  2055.                 $this->lexer->resetPeek();
  2057.                 if ($this->isMathOperator($peek)) {
  2058.                     return $this->SimpleArithmeticExpression();
  2059.                 }
  2061.                 return $this->StateFieldPathExpression();
  2063.             default:
  2064.                 $this->syntaxError();
  2065.         }
  2066.     }
  2068.     /**
  2069.      * CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullifExpression
  2070.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2071.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2072.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2073.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2074.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2075.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2076.      * NullifExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2077.      *
  2078.      * @return mixed One of the possible expressions or subexpressions.
  2079.      */
  2080.     public function CaseExpression()
  2081.     {
  2082.         $lookahead = $this->lexer->lookahead['type'];
  2084.         switch ($lookahead) {
  2085.             case Lexer::T_NULLIF:
  2086.                 return $this->NullIfExpression();
  2088.             case Lexer::T_COALESCE:
  2089.                 return $this->CoalesceExpression();
  2091.             case Lexer::T_CASE:
  2092.                 $this->lexer->resetPeek();
  2093.                 $peek = $this->lexer->peek();
  2095.                 if ($peek['type'] === Lexer::T_WHEN) {
  2096.                     return $this->GeneralCaseExpression();
  2097.                 }
  2099.                 return $this->SimpleCaseExpression();
  2101.             default:
  2102.                 // Do nothing
  2103.                 break;
  2104.         }
  2106.         $this->syntaxError();
  2107.     }
  2109.     /**
  2110.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2111.      *
  2112.      * @return CoalesceExpression
  2113.      */
  2114.     public function CoalesceExpression()
  2115.     {
  2116.         $this->match(Lexer::T_COALESCE);
  2117.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2119.         // Process ScalarExpressions (1..N)
  2120.         $scalarExpressions   = [];
  2121.         $scalarExpressions[] = $this->ScalarExpression();
  2123.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  2124.             $this->match(Lexer::T_COMMA);
  2126.             $scalarExpressions[] = $this->ScalarExpression();
  2127.         }
  2129.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2131.         return new AST\CoalesceExpression($scalarExpressions);
  2132.     }
  2134.     /**
  2135.      * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2136.      *
  2137.      * @return NullIfExpression
  2138.      */
  2139.     public function NullIfExpression()
  2140.     {
  2141.         $this->match(Lexer::T_NULLIF);
  2142.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2144.         $firstExpression = $this->ScalarExpression();
  2145.         $this->match(Lexer::T_COMMA);
  2146.         $secondExpression = $this->ScalarExpression();
  2148.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2150.         return new AST\NullIfExpression($firstExpression, $secondExpression);
  2151.     }
  2153.     /**
  2154.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2155.      *
  2156.      * @return GeneralCaseExpression
  2157.      */
  2158.     public function GeneralCaseExpression()
  2159.     {
  2160.         $this->match(Lexer::T_CASE);
  2162.         // Process WhenClause (1..N)
  2163.         $whenClauses = [];
  2165.         do {
  2166.             $whenClauses[] = $this->WhenClause();
  2167.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2169.         $this->match(Lexer::T_ELSE);
  2170.         $scalarExpression = $this->ScalarExpression();
  2171.         $this->match(Lexer::T_END);
  2173.         return new AST\GeneralCaseExpression($whenClauses, $scalarExpression);
  2174.     }
  2176.     /**
  2177.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2178.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2179.      *
  2180.      * @return AST\SimpleCaseExpression
  2181.      */
  2182.     public function SimpleCaseExpression()
  2183.     {
  2184.         $this->match(Lexer::T_CASE);
  2185.         $caseOperand = $this->StateFieldPathExpression();
  2187.         // Process SimpleWhenClause (1..N)
  2188.         $simpleWhenClauses = [];
  2190.         do {
  2191.             $simpleWhenClauses[] = $this->SimpleWhenClause();
  2192.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2194.         $this->match(Lexer::T_ELSE);
  2195.         $scalarExpression = $this->ScalarExpression();
  2196.         $this->match(Lexer::T_END);
  2198.         return new AST\SimpleCaseExpression($caseOperand, $simpleWhenClauses, $scalarExpression);
  2199.     }
  2201.     /**
  2202.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2203.      *
  2204.      * @return WhenClause
  2205.      */
  2206.     public function WhenClause()
  2207.     {
  2208.         $this->match(Lexer::T_WHEN);
  2209.         $conditionalExpression = $this->ConditionalExpression();
  2210.         $this->match(Lexer::T_THEN);
  2212.         return new AST\WhenClause($conditionalExpression, $this->ScalarExpression());
  2213.     }
  2215.     /**
  2216.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2217.      *
  2218.      * @return SimpleWhenClause
  2219.      */
  2220.     public function SimpleWhenClause()
  2221.     {
  2222.         $this->match(Lexer::T_WHEN);
  2223.         $conditionalExpression = $this->ScalarExpression();
  2224.         $this->match(Lexer::T_THEN);
  2226.         return new AST\SimpleWhenClause($conditionalExpression, $this->ScalarExpression());
  2227.     }
  2229.     /**
  2230.      * SelectExpression ::= (
  2231.      *     IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration |
  2232.      *     PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression
  2233.      * ) [["AS"] ["HIDDEN"] AliasResultVariable]
  2234.      *
  2235.      * @return SelectExpression
  2236.      */
  2237.     public function SelectExpression()
  2238.     {
  2239.         $expression    = null;
  2240.         $identVariable = null;
  2241.         $peek          = $this->lexer->glimpse();
  2242.         $lookaheadType = $this->lexer->lookahead['type'];
  2244.         switch (true) {
  2245.             // ScalarExpression (u.name)
  2246.             case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] === Lexer::T_DOT:
  2247.                 $expression = $this->ScalarExpression();
  2248.                 break;
  2250.             // IdentificationVariable (u)
  2251.             case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2252.                 $expression = $identVariable = $this->IdentificationVariable();
  2253.                 break;
  2255.             // CaseExpression (CASE ... or NULLIF(...) or COALESCE(...))
  2256.             case $lookaheadType === Lexer::T_CASE:
  2257.             case $lookaheadType === Lexer::T_COALESCE:
  2258.             case $lookaheadType === Lexer::T_NULLIF:
  2259.                 $expression = $this->CaseExpression();
  2260.                 break;
  2262.             // DQL Function (SUM(u.value) or SUM(u.value) + 1)
  2263.             case $this->isFunction():
  2264.                 $this->lexer->peek(); // "("
  2266.                 switch (true) {
  2267.                     case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2268.                         // SUM(u.id) + COUNT(u.id)
  2269.                         $expression = $this->ScalarExpression();
  2270.                         break;
  2272.                     default:
  2273.                         // IDENTITY(u)
  2274.                         $expression = $this->FunctionDeclaration();
  2275.                         break;
  2276.                 }
  2278.                 break;
  2280.             // PartialObjectExpression (PARTIAL u.{id, name})
  2281.             case $lookaheadType === Lexer::T_PARTIAL:
  2282.                 $expression    = $this->PartialObjectExpression();
  2283.                 $identVariable = $expression->identificationVariable;
  2284.                 break;
  2286.             // Subselect
  2287.             case $lookaheadType === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT:
  2288.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2289.                 $expression = $this->Subselect();
  2290.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2291.                 break;
  2293.             // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2294.             case $lookaheadType === Lexer::T_OPEN_PARENTHESIS:
  2295.             case $lookaheadType === Lexer::T_INTEGER:
  2296.             case $lookaheadType === Lexer::T_STRING:
  2297.             case $lookaheadType === Lexer::T_FLOAT:
  2298.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )
  2299.             case $lookaheadType === Lexer::T_MINUS:
  2300.             case $lookaheadType === Lexer::T_PLUS:
  2301.                 $expression = $this->SimpleArithmeticExpression();
  2302.                 break;
  2304.             // NewObjectExpression (New ClassName(id, name))
  2305.             case $lookaheadType === Lexer::T_NEW:
  2306.                 $expression = $this->NewObjectExpression();
  2307.                 break;
  2309.             default:
  2310.                 $this->syntaxError(
  2311.                     'IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression',
  2312.                     $this->lexer->lookahead
  2313.                 );
  2314.         }
  2316.         // [["AS"] ["HIDDEN"] AliasResultVariable]
  2317.         $mustHaveAliasResultVariable = false;
  2319.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2320.             $this->match(Lexer::T_AS);
  2322.             $mustHaveAliasResultVariable = true;
  2323.         }
  2325.         $hiddenAliasResultVariable = false;
  2327.         if ($this->lexer->isNextToken(Lexer::T_HIDDEN)) {
  2328.             $this->match(Lexer::T_HIDDEN);
  2330.             $hiddenAliasResultVariable = true;
  2331.         }
  2333.         $aliasResultVariable = null;
  2335.         if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2336.             $token               = $this->lexer->lookahead;
  2337.             $aliasResultVariable = $this->AliasResultVariable();
  2339.             // Include AliasResultVariable in query components.
  2340.             $this->queryComponents[$aliasResultVariable] = [
  2341.                 'resultVariable' => $expression,
  2342.                 'nestingLevel'   => $this->nestingLevel,
  2343.                 'token'          => $token,
  2344.             ];
  2345.         }
  2347.         // AST
  2349.         $expr = new AST\SelectExpression($expression, $aliasResultVariable, $hiddenAliasResultVariable);
  2351.         if ($identVariable) {
  2352.             $this->identVariableExpressions[$identVariable] = $expr;
  2353.         }
  2355.         return $expr;
  2356.     }
  2358.     /**
  2359.      * SimpleSelectExpression ::= (
  2360.      *      StateFieldPathExpression | IdentificationVariable | FunctionDeclaration |
  2361.      *      AggregateExpression | "(" Subselect ")" | ScalarExpression
  2362.      * ) [["AS"] AliasResultVariable]
  2363.      *
  2364.      * @return SimpleSelectExpression
  2365.      */
  2366.     public function SimpleSelectExpression()
  2367.     {
  2368.         $peek = $this->lexer->glimpse();
  2370.         switch ($this->lexer->lookahead['type']) {
  2371.             case Lexer::T_IDENTIFIER:
  2372.                 switch (true) {
  2373.                     case $peek['type'] === Lexer::T_DOT:
  2374.                         $expression = $this->StateFieldPathExpression();
  2376.                         return new AST\SimpleSelectExpression($expression);
  2378.                     case $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2379.                         $expression = $this->IdentificationVariable();
  2381.                         return new AST\SimpleSelectExpression($expression);
  2383.                     case $this->isFunction():
  2384.                         // SUM(u.id) + COUNT(u.id)
  2385.                         if ($this->isMathOperator($this->peekBeyondClosingParenthesis())) {
  2386.                             return new AST\SimpleSelectExpression($this->ScalarExpression());
  2387.                         }
  2389.                         // COUNT(u.id)
  2390.                         if ($this->isAggregateFunction($this->lexer->lookahead['type'])) {
  2391.                             return new AST\SimpleSelectExpression($this->AggregateExpression());
  2392.                         }
  2394.                         // IDENTITY(u)
  2395.                         return new AST\SimpleSelectExpression($this->FunctionDeclaration());
  2397.                     default:
  2398.                         // Do nothing
  2399.                 }
  2401.                 break;
  2403.             case Lexer::T_OPEN_PARENTHESIS:
  2404.                 if ($peek['type'] !== Lexer::T_SELECT) {
  2405.                     // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2406.                     $expression = $this->SimpleArithmeticExpression();
  2408.                     return new AST\SimpleSelectExpression($expression);
  2409.                 }
  2411.                 // Subselect
  2412.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2413.                 $expression = $this->Subselect();
  2414.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2416.                 return new AST\SimpleSelectExpression($expression);
  2418.             default:
  2419.                 // Do nothing
  2420.         }
  2422.         $this->lexer->peek();
  2424.         $expression = $this->ScalarExpression();
  2425.         $expr       = new AST\SimpleSelectExpression($expression);
  2427.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2428.             $this->match(Lexer::T_AS);
  2429.         }
  2431.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2432.             $token                             = $this->lexer->lookahead;
  2433.             $resultVariable                    = $this->AliasResultVariable();
  2434.             $expr->fieldIdentificationVariable = $resultVariable;
  2436.             // Include AliasResultVariable in query components.
  2437.             $this->queryComponents[$resultVariable] = [
  2438.                 'resultvariable' => $expr,
  2439.                 'nestingLevel'   => $this->nestingLevel,
  2440.                 'token'          => $token,
  2441.             ];
  2442.         }
  2444.         return $expr;
  2445.     }
  2447.     /**
  2448.      * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
  2449.      *
  2450.      * @return AST\ConditionalExpression|AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2451.      */
  2452.     public function ConditionalExpression()
  2453.     {
  2454.         $conditionalTerms   = [];
  2455.         $conditionalTerms[] = $this->ConditionalTerm();
  2457.         while ($this->lexer->isNextToken(Lexer::T_OR)) {
  2458.             $this->match(Lexer::T_OR);
  2460.             $conditionalTerms[] = $this->ConditionalTerm();
  2461.         }
  2463.         // Phase 1 AST optimization: Prevent AST\ConditionalExpression
  2464.         // if only one AST\ConditionalTerm is defined
  2465.         if (count($conditionalTerms) === 1) {
  2466.             return $conditionalTerms[0];
  2467.         }
  2469.         return new AST\ConditionalExpression($conditionalTerms);
  2470.     }
  2472.     /**
  2473.      * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
  2474.      *
  2475.      * @return AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2476.      */
  2477.     public function ConditionalTerm()
  2478.     {
  2479.         $conditionalFactors   = [];
  2480.         $conditionalFactors[] = $this->ConditionalFactor();
  2482.         while ($this->lexer->isNextToken(Lexer::T_AND)) {
  2483.             $this->match(Lexer::T_AND);
  2485.             $conditionalFactors[] = $this->ConditionalFactor();
  2486.         }
  2488.         // Phase 1 AST optimization: Prevent AST\ConditionalTerm
  2489.         // if only one AST\ConditionalFactor is defined
  2490.         if (count($conditionalFactors) === 1) {
  2491.             return $conditionalFactors[0];
  2492.         }
  2494.         return new AST\ConditionalTerm($conditionalFactors);
  2495.     }
  2497.     /**
  2498.      * ConditionalFactor ::= ["NOT"] ConditionalPrimary
  2499.      *
  2500.      * @return AST\ConditionalFactor|AST\ConditionalPrimary
  2501.      */
  2502.     public function ConditionalFactor()
  2503.     {
  2504.         $not = false;
  2506.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2507.             $this->match(Lexer::T_NOT);
  2509.             $not = true;
  2510.         }
  2512.         $conditionalPrimary = $this->ConditionalPrimary();
  2514.         // Phase 1 AST optimization: Prevent AST\ConditionalFactor
  2515.         // if only one AST\ConditionalPrimary is defined
  2516.         if (! $not) {
  2517.             return $conditionalPrimary;
  2518.         }
  2520.         $conditionalFactor      = new AST\ConditionalFactor($conditionalPrimary);
  2521.         $conditionalFactor->not = $not;
  2523.         return $conditionalFactor;
  2524.     }
  2526.     /**
  2527.      * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
  2528.      *
  2529.      * @return ConditionalPrimary
  2530.      */
  2531.     public function ConditionalPrimary()
  2532.     {
  2533.         $condPrimary = new AST\ConditionalPrimary();
  2535.         if (! $this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2536.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2538.             return $condPrimary;
  2539.         }
  2541.         // Peek beyond the matching closing parenthesis ')'
  2542.         $peek = $this->peekBeyondClosingParenthesis();
  2544.         if (
  2545.             $peek !== null && (
  2546.             in_array($peek['value'], ['=', '<', '<=', '<>', '>', '>=', '!='], true) ||
  2547.             in_array($peek['type'], [Lexer::T_NOT, Lexer::T_BETWEEN, Lexer::T_LIKE, Lexer::T_IN, Lexer::T_IS, Lexer::T_EXISTS], true) ||
  2548.             $this->isMathOperator($peek)
  2549.             )
  2550.         ) {
  2551.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2553.             return $condPrimary;
  2554.         }
  2556.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2557.         $condPrimary->conditionalExpression = $this->ConditionalExpression();
  2558.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2560.         return $condPrimary;
  2561.     }
  2563.     /**
  2564.      * SimpleConditionalExpression ::=
  2565.      *      ComparisonExpression | BetweenExpression | LikeExpression |
  2566.      *      InExpression | NullComparisonExpression | ExistsExpression |
  2567.      *      EmptyCollectionComparisonExpression | CollectionMemberExpression |
  2568.      *      InstanceOfExpression
  2569.      *
  2570.      * @return AST\BetweenExpression|
  2571.      *         AST\CollectionMemberExpression|
  2572.      *         AST\ComparisonExpression|
  2573.      *         AST\EmptyCollectionComparisonExpression|
  2574.      *         AST\ExistsExpression|
  2575.      *         AST\InExpression|
  2576.      *         AST\InstanceOfExpression|
  2577.      *         AST\LikeExpression|
  2578.      *         AST\NullComparisonExpression
  2579.      */
  2580.     public function SimpleConditionalExpression()
  2581.     {
  2582.         if ($this->lexer->isNextToken(Lexer::T_EXISTS)) {
  2583.             return $this->ExistsExpression();
  2584.         }
  2586.         $token     = $this->lexer->lookahead;
  2587.         $peek      = $this->lexer->glimpse();
  2588.         $lookahead = $token;
  2590.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2591.             $token = $this->lexer->glimpse();
  2592.         }
  2594.         if ($token['type'] === Lexer::T_IDENTIFIER || $token['type'] === Lexer::T_INPUT_PARAMETER || $this->isFunction()) {
  2595.             // Peek beyond the matching closing parenthesis.
  2596.             $beyond = $this->lexer->peek();
  2598.             switch ($peek['value']) {
  2599.                 case '(':
  2600.                     // Peeks beyond the matched closing parenthesis.
  2601.                     $token = $this->peekBeyondClosingParenthesis(false);
  2603.                     if ($token['type'] === Lexer::T_NOT) {
  2604.                         $token = $this->lexer->peek();
  2605.                     }
  2607.                     if ($token['type'] === Lexer::T_IS) {
  2608.                         $lookahead = $this->lexer->peek();
  2609.                     }
  2611.                     break;
  2613.                 default:
  2614.                     // Peek beyond the PathExpression or InputParameter.
  2615.                     $token = $beyond;
  2617.                     while ($token['value'] === '.') {
  2618.                         $this->lexer->peek();
  2620.                         $token = $this->lexer->peek();
  2621.                     }
  2623.                     // Also peek beyond a NOT if there is one.
  2624.                     if ($token['type'] === Lexer::T_NOT) {
  2625.                         $token = $this->lexer->peek();
  2626.                     }
  2628.                     // We need to go even further in case of IS (differentiate between NULL and EMPTY)
  2629.                     $lookahead = $this->lexer->peek();
  2630.             }
  2632.             // Also peek beyond a NOT if there is one.
  2633.             if ($lookahead['type'] === Lexer::T_NOT) {
  2634.                 $lookahead = $this->lexer->peek();
  2635.             }
  2637.             $this->lexer->resetPeek();
  2638.         }
  2640.         if ($token['type'] === Lexer::T_BETWEEN) {
  2641.             return $this->BetweenExpression();
  2642.         }
  2644.         if ($token['type'] === Lexer::T_LIKE) {
  2645.             return $this->LikeExpression();
  2646.         }
  2648.         if ($token['type'] === Lexer::T_IN) {
  2649.             return $this->InExpression();
  2650.         }
  2652.         if ($token['type'] === Lexer::T_INSTANCE) {
  2653.             return $this->InstanceOfExpression();
  2654.         }
  2656.         if ($token['type'] === Lexer::T_MEMBER) {
  2657.             return $this->CollectionMemberExpression();
  2658.         }
  2660.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_NULL) {
  2661.             return $this->NullComparisonExpression();
  2662.         }
  2664.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_EMPTY) {
  2665.             return $this->EmptyCollectionComparisonExpression();
  2666.         }
  2668.         return $this->ComparisonExpression();
  2669.     }
  2671.     /**
  2672.      * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
  2673.      *
  2674.      * @return EmptyCollectionComparisonExpression
  2675.      */
  2676.     public function EmptyCollectionComparisonExpression()
  2677.     {
  2678.         $emptyCollectionCompExpr = new AST\EmptyCollectionComparisonExpression(
  2679.             $this->CollectionValuedPathExpression()
  2680.         );
  2681.         $this->match(Lexer::T_IS);
  2683.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2684.             $this->match(Lexer::T_NOT);
  2685.             $emptyCollectionCompExpr->not = true;
  2686.         }
  2688.         $this->match(Lexer::T_EMPTY);
  2690.         return $emptyCollectionCompExpr;
  2691.     }
  2693.     /**
  2694.      * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
  2695.      *
  2696.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2697.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2698.      *
  2699.      * @return CollectionMemberExpression
  2700.      */
  2701.     public function CollectionMemberExpression()
  2702.     {
  2703.         $not        = false;
  2704.         $entityExpr = $this->EntityExpression();
  2706.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2707.             $this->match(Lexer::T_NOT);
  2709.             $not = true;
  2710.         }
  2712.         $this->match(Lexer::T_MEMBER);
  2714.         if ($this->lexer->isNextToken(Lexer::T_OF)) {
  2715.             $this->match(Lexer::T_OF);
  2716.         }
  2718.         $collMemberExpr      = new AST\CollectionMemberExpression(
  2719.             $entityExpr,
  2720.             $this->CollectionValuedPathExpression()
  2721.         );
  2722.         $collMemberExpr->not = $not;
  2724.         return $collMemberExpr;
  2725.     }
  2727.     /**
  2728.      * Literal ::= string | char | integer | float | boolean
  2729.      *
  2730.      * @return Literal
  2731.      */
  2732.     public function Literal()
  2733.     {
  2734.         switch ($this->lexer->lookahead['type']) {
  2735.             case Lexer::T_STRING:
  2736.                 $this->match(Lexer::T_STRING);
  2738.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  2740.             case Lexer::T_INTEGER:
  2741.             case Lexer::T_FLOAT:
  2742.                 $this->match(
  2743.                     $this->lexer->isNextToken(Lexer::T_INTEGER) ? Lexer::T_INTEGER : Lexer::T_FLOAT
  2744.                 );
  2746.                 return new AST\Literal(AST\Literal::NUMERIC, $this->lexer->token['value']);
  2748.             case Lexer::T_TRUE:
  2749.             case Lexer::T_FALSE:
  2750.                 $this->match(
  2751.                     $this->lexer->isNextToken(Lexer::T_TRUE) ? Lexer::T_TRUE : Lexer::T_FALSE
  2752.                 );
  2754.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2756.             default:
  2757.                 $this->syntaxError('Literal');
  2758.         }
  2759.     }
  2761.     /**
  2762.      * InParameter ::= Literal | InputParameter
  2763.      *
  2764.      * @return AST\InputParameter|AST\Literal
  2765.      */
  2766.     public function InParameter()
  2767.     {
  2768.         if ($this->lexer->lookahead['type'] === Lexer::T_INPUT_PARAMETER) {
  2769.             return $this->InputParameter();
  2770.         }
  2772.         return $this->Literal();
  2773.     }
  2775.     /**
  2776.      * InputParameter ::= PositionalParameter | NamedParameter
  2777.      *
  2778.      * @return InputParameter
  2779.      */
  2780.     public function InputParameter()
  2781.     {
  2782.         $this->match(Lexer::T_INPUT_PARAMETER);
  2784.         return new AST\InputParameter($this->lexer->token['value']);
  2785.     }
  2787.     /**
  2788.      * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
  2789.      *
  2790.      * @return ArithmeticExpression
  2791.      */
  2792.     public function ArithmeticExpression()
  2793.     {
  2794.         $expr = new AST\ArithmeticExpression();
  2796.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2797.             $peek = $this->lexer->glimpse();
  2799.             if ($peek['type'] === Lexer::T_SELECT) {
  2800.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2801.                 $expr->subselect = $this->Subselect();
  2802.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2804.                 return $expr;
  2805.             }
  2806.         }
  2808.         $expr->simpleArithmeticExpression = $this->SimpleArithmeticExpression();
  2810.         return $expr;
  2811.     }
  2813.     /**
  2814.      * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
  2815.      *
  2816.      * @return SimpleArithmeticExpression
  2817.      */
  2818.     public function SimpleArithmeticExpression()
  2819.     {
  2820.         $terms   = [];
  2821.         $terms[] = $this->ArithmeticTerm();
  2823.         while (($isPlus = $this->lexer->isNextToken(Lexer::T_PLUS)) || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2824.             $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2826.             $terms[] = $this->lexer->token['value'];
  2827.             $terms[] = $this->ArithmeticTerm();
  2828.         }
  2830.         // Phase 1 AST optimization: Prevent AST\SimpleArithmeticExpression
  2831.         // if only one AST\ArithmeticTerm is defined
  2832.         if (count($terms) === 1) {
  2833.             return $terms[0];
  2834.         }
  2836.         return new AST\SimpleArithmeticExpression($terms);
  2837.     }
  2839.     /**
  2840.      * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
  2841.      *
  2842.      * @return ArithmeticTerm
  2843.      */
  2844.     public function ArithmeticTerm()
  2845.     {
  2846.         $factors   = [];
  2847.         $factors[] = $this->ArithmeticFactor();
  2849.         while (($isMult = $this->lexer->isNextToken(Lexer::T_MULTIPLY)) || $this->lexer->isNextToken(Lexer::T_DIVIDE)) {
  2850.             $this->match($isMult ? Lexer::T_MULTIPLY : Lexer::T_DIVIDE);
  2852.             $factors[] = $this->lexer->token['value'];
  2853.             $factors[] = $this->ArithmeticFactor();
  2854.         }
  2856.         // Phase 1 AST optimization: Prevent AST\ArithmeticTerm
  2857.         // if only one AST\ArithmeticFactor is defined
  2858.         if (count($factors) === 1) {
  2859.             return $factors[0];
  2860.         }
  2862.         return new AST\ArithmeticTerm($factors);
  2863.     }
  2865.     /**
  2866.      * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
  2867.      *
  2868.      * @return ArithmeticFactor
  2869.      */
  2870.     public function ArithmeticFactor()
  2871.     {
  2872.         $sign = null;
  2874.         $isPlus = $this->lexer->isNextToken(Lexer::T_PLUS);
  2875.         if ($isPlus || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2876.             $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2877.             $sign = $isPlus;
  2878.         }
  2880.         $primary = $this->ArithmeticPrimary();
  2882.         // Phase 1 AST optimization: Prevent AST\ArithmeticFactor
  2883.         // if only one AST\ArithmeticPrimary is defined
  2884.         if ($sign === null) {
  2885.             return $primary;
  2886.         }
  2888.         return new AST\ArithmeticFactor($primary, $sign);
  2889.     }
  2891.     /**
  2892.      * ArithmeticPrimary ::= SingleValuedPathExpression | Literal | ParenthesisExpression
  2893.      *          | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings
  2894.      *          | FunctionsReturningDatetime | IdentificationVariable | ResultVariable
  2895.      *          | InputParameter | CaseExpression
  2896.      *
  2897.      * @return Node|string
  2898.      */
  2899.     public function ArithmeticPrimary()
  2900.     {
  2901.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2902.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2904.             $expr = $this->SimpleArithmeticExpression();
  2906.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2908.             return new AST\ParenthesisExpression($expr);
  2909.         }
  2911.         switch ($this->lexer->lookahead['type']) {
  2912.             case Lexer::T_COALESCE:
  2913.             case Lexer::T_NULLIF:
  2914.             case Lexer::T_CASE:
  2915.                 return $this->CaseExpression();
  2917.             case Lexer::T_IDENTIFIER:
  2918.                 $peek = $this->lexer->glimpse();
  2920.                 if ($peek !== null && $peek['value'] === '(') {
  2921.                     return $this->FunctionDeclaration();
  2922.                 }
  2924.                 if ($peek !== null && $peek['value'] === '.') {
  2925.                     return $this->SingleValuedPathExpression();
  2926.                 }
  2928.                 if (isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])) {
  2929.                     return $this->ResultVariable();
  2930.                 }
  2932.                 return $this->StateFieldPathExpression();
  2934.             case Lexer::T_INPUT_PARAMETER:
  2935.                 return $this->InputParameter();
  2937.             default:
  2938.                 $peek = $this->lexer->glimpse();
  2940.                 if ($peek !== null && $peek['value'] === '(') {
  2941.                     return $this->FunctionDeclaration();
  2942.                 }
  2944.                 return $this->Literal();
  2945.         }
  2946.     }
  2948.     /**
  2949.      * StringExpression ::= StringPrimary | ResultVariable | "(" Subselect ")"
  2950.      *
  2951.      * @return Subselect|Node|string
  2952.      */
  2953.     public function StringExpression()
  2954.     {
  2955.         $peek = $this->lexer->glimpse();
  2957.         // Subselect
  2958.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $peek['type'] === Lexer::T_SELECT) {
  2959.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2960.             $expr = $this->Subselect();
  2961.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2963.             return $expr;
  2964.         }
  2966.         // ResultVariable (string)
  2967.         if (
  2968.             $this->lexer->isNextToken(Lexer::T_IDENTIFIER) &&
  2969.             isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])
  2970.         ) {
  2971.             return $this->ResultVariable();
  2972.         }
  2974.         return $this->StringPrimary();
  2975.     }
  2977.     /**
  2978.      * StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression
  2979.      *
  2980.      * @return Node
  2981.      */
  2982.     public function StringPrimary()
  2983.     {
  2984.         $lookaheadType = $this->lexer->lookahead['type'];
  2986.         switch ($lookaheadType) {
  2987.             case Lexer::T_IDENTIFIER:
  2988.                 $peek = $this->lexer->glimpse();
  2990.                 if ($peek['value'] === '.') {
  2991.                     return $this->StateFieldPathExpression();
  2992.                 }
  2994.                 if ($peek['value'] === '(') {
  2995.                     // do NOT directly go to FunctionsReturningString() because it doesn't check for custom functions.
  2996.                     return $this->FunctionDeclaration();
  2997.                 }
  2999.                 $this->syntaxError("'.' or '('");
  3000.                 break;
  3002.             case Lexer::T_STRING:
  3003.                 $this->match(Lexer::T_STRING);
  3005.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3007.             case Lexer::T_INPUT_PARAMETER:
  3008.                 return $this->InputParameter();
  3010.             case Lexer::T_CASE:
  3011.             case Lexer::T_COALESCE:
  3012.             case Lexer::T_NULLIF:
  3013.                 return $this->CaseExpression();
  3015.             default:
  3016.                 if ($this->isAggregateFunction($lookaheadType)) {
  3017.                     return $this->AggregateExpression();
  3018.                 }
  3019.         }
  3021.         $this->syntaxError(
  3022.             'StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression'
  3023.         );
  3024.     }
  3026.     /**
  3027.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  3028.      *
  3029.      * @return AST\InputParameter|PathExpression
  3030.      */
  3031.     public function EntityExpression()
  3032.     {
  3033.         $glimpse = $this->lexer->glimpse();
  3035.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER) && $glimpse['value'] === '.') {
  3036.             return $this->SingleValuedAssociationPathExpression();
  3037.         }
  3039.         return $this->SimpleEntityExpression();
  3040.     }
  3042.     /**
  3043.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  3044.      *
  3045.      * @return AST\InputParameter|AST\PathExpression
  3046.      */
  3047.     public function SimpleEntityExpression()
  3048.     {
  3049.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3050.             return $this->InputParameter();
  3051.         }
  3053.         return $this->StateFieldPathExpression();
  3054.     }
  3056.     /**
  3057.      * AggregateExpression ::=
  3058.      *  ("AVG" | "MAX" | "MIN" | "SUM" | "COUNT") "(" ["DISTINCT"] SimpleArithmeticExpression ")"
  3059.      *
  3060.      * @return AggregateExpression
  3061.      */
  3062.     public function AggregateExpression()
  3063.     {
  3064.         $lookaheadType = $this->lexer->lookahead['type'];
  3065.         $isDistinct    = false;
  3067.         if (! in_array($lookaheadType, [Lexer::T_COUNT, Lexer::T_AVG, Lexer::T_MAX, Lexer::T_MIN, Lexer::T_SUM], true)) {
  3068.             $this->syntaxError('One of: MAX, MIN, AVG, SUM, COUNT');
  3069.         }
  3071.         $this->match($lookaheadType);
  3072.         $functionName = $this->lexer->token['value'];
  3073.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3075.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  3076.             $this->match(Lexer::T_DISTINCT);
  3077.             $isDistinct = true;
  3078.         }
  3080.         $pathExp = $this->SimpleArithmeticExpression();
  3082.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3084.         return new AST\AggregateExpression($functionName, $pathExp, $isDistinct);
  3085.     }
  3087.     /**
  3088.      * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
  3089.      *
  3090.      * @return QuantifiedExpression
  3091.      */
  3092.     public function QuantifiedExpression()
  3093.     {
  3094.         $lookaheadType = $this->lexer->lookahead['type'];
  3095.         $value         = $this->lexer->lookahead['value'];
  3097.         if (! in_array($lookaheadType, [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME], true)) {
  3098.             $this->syntaxError('ALL, ANY or SOME');
  3099.         }
  3101.         $this->match($lookaheadType);
  3102.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3104.         $qExpr       = new AST\QuantifiedExpression($this->Subselect());
  3105.         $qExpr->type = $value;
  3107.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3109.         return $qExpr;
  3110.     }
  3112.     /**
  3113.      * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
  3114.      *
  3115.      * @return BetweenExpression
  3116.      */
  3117.     public function BetweenExpression()
  3118.     {
  3119.         $not        = false;
  3120.         $arithExpr1 = $this->ArithmeticExpression();
  3122.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3123.             $this->match(Lexer::T_NOT);
  3124.             $not = true;
  3125.         }
  3127.         $this->match(Lexer::T_BETWEEN);
  3128.         $arithExpr2 = $this->ArithmeticExpression();
  3129.         $this->match(Lexer::T_AND);
  3130.         $arithExpr3 = $this->ArithmeticExpression();
  3132.         $betweenExpr      = new AST\BetweenExpression($arithExpr1, $arithExpr2, $arithExpr3);
  3133.         $betweenExpr->not = $not;
  3135.         return $betweenExpr;
  3136.     }
  3138.     /**
  3139.      * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )
  3140.      *
  3141.      * @return ComparisonExpression
  3142.      */
  3143.     public function ComparisonExpression()
  3144.     {
  3145.         $this->lexer->glimpse();
  3147.         $leftExpr  = $this->ArithmeticExpression();
  3148.         $operator  = $this->ComparisonOperator();
  3149.         $rightExpr = $this->isNextAllAnySome()
  3150.             ? $this->QuantifiedExpression()
  3151.             : $this->ArithmeticExpression();
  3153.         return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
  3154.     }
  3156.     /**
  3157.      * InExpression ::= SingleValuedPathExpression ["NOT"] "IN" "(" (InParameter {"," InParameter}* | Subselect) ")"
  3158.      *
  3159.      * @return InExpression
  3160.      */
  3161.     public function InExpression()
  3162.     {
  3163.         $inExpression = new AST\InExpression($this->ArithmeticExpression());
  3165.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3166.             $this->match(Lexer::T_NOT);
  3167.             $inExpression->not = true;
  3168.         }
  3170.         $this->match(Lexer::T_IN);
  3171.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3173.         if ($this->lexer->isNextToken(Lexer::T_SELECT)) {
  3174.             $inExpression->subselect = $this->Subselect();
  3175.         } else {
  3176.             $literals   = [];
  3177.             $literals[] = $this->InParameter();
  3179.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3180.                 $this->match(Lexer::T_COMMA);
  3181.                 $literals[] = $this->InParameter();
  3182.             }
  3184.             $inExpression->literals = $literals;
  3185.         }
  3187.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3189.         return $inExpression;
  3190.     }
  3192.     /**
  3193.      * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
  3194.      *
  3195.      * @return InstanceOfExpression
  3196.      */
  3197.     public function InstanceOfExpression()
  3198.     {
  3199.         $instanceOfExpression = new AST\InstanceOfExpression($this->IdentificationVariable());
  3201.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3202.             $this->match(Lexer::T_NOT);
  3203.             $instanceOfExpression->not = true;
  3204.         }
  3206.         $this->match(Lexer::T_INSTANCE);
  3207.         $this->match(Lexer::T_OF);
  3209.         $exprValues = [];
  3211.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  3212.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  3214.             $exprValues[] = $this->InstanceOfParameter();
  3216.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3217.                 $this->match(Lexer::T_COMMA);
  3219.                 $exprValues[] = $this->InstanceOfParameter();
  3220.             }
  3222.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3224.             $instanceOfExpression->value = $exprValues;
  3226.             return $instanceOfExpression;
  3227.         }
  3229.         $exprValues[] = $this->InstanceOfParameter();
  3231.         $instanceOfExpression->value = $exprValues;
  3233.         return $instanceOfExpression;
  3234.     }
  3236.     /**
  3237.      * InstanceOfParameter ::= AbstractSchemaName | InputParameter
  3238.      *
  3239.      * @return mixed
  3240.      */
  3241.     public function InstanceOfParameter()
  3242.     {
  3243.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3244.             $this->match(Lexer::T_INPUT_PARAMETER);
  3246.             return new AST\InputParameter($this->lexer->token['value']);
  3247.         }
  3249.         $abstractSchemaName = $this->AbstractSchemaName();
  3251.         $this->validateAbstractSchemaName($abstractSchemaName);
  3253.         return $abstractSchemaName;
  3254.     }
  3256.     /**
  3257.      * LikeExpression ::= StringExpression ["NOT"] "LIKE" StringPrimary ["ESCAPE" char]
  3258.      *
  3259.      * @return LikeExpression
  3260.      */
  3261.     public function LikeExpression()
  3262.     {
  3263.         $stringExpr = $this->StringExpression();
  3264.         $not        = false;
  3266.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3267.             $this->match(Lexer::T_NOT);
  3268.             $not = true;
  3269.         }
  3271.         $this->match(Lexer::T_LIKE);
  3273.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3274.             $this->match(Lexer::T_INPUT_PARAMETER);
  3275.             $stringPattern = new AST\InputParameter($this->lexer->token['value']);
  3276.         } else {
  3277.             $stringPattern = $this->StringPrimary();
  3278.         }
  3280.         $escapeChar = null;
  3282.         if ($this->lexer->lookahead !== null && $this->lexer->lookahead['type'] === Lexer::T_ESCAPE) {
  3283.             $this->match(Lexer::T_ESCAPE);
  3284.             $this->match(Lexer::T_STRING);
  3286.             $escapeChar = new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3287.         }
  3289.         $likeExpr      = new AST\LikeExpression($stringExpr, $stringPattern, $escapeChar);
  3290.         $likeExpr->not = $not;
  3292.         return $likeExpr;
  3293.     }
  3295.     /**
  3296.      * NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) "IS" ["NOT"] "NULL"
  3297.      *
  3298.      * @return NullComparisonExpression
  3299.      */
  3300.     public function NullComparisonExpression()
  3301.     {
  3302.         switch (true) {
  3303.             case $this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER):
  3304.                 $this->match(Lexer::T_INPUT_PARAMETER);
  3306.                 $expr = new AST\InputParameter($this->lexer->token['value']);
  3307.                 break;
  3309.             case $this->lexer->isNextToken(Lexer::T_NULLIF):
  3310.                 $expr = $this->NullIfExpression();
  3311.                 break;
  3313.             case $this->lexer->isNextToken(Lexer::T_COALESCE):
  3314.                 $expr = $this->CoalesceExpression();
  3315.                 break;
  3317.             case $this->isFunction():
  3318.                 $expr = $this->FunctionDeclaration();
  3319.                 break;
  3321.             default:
  3322.                 // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  3323.                 $glimpse = $this->lexer->glimpse();
  3325.                 if ($glimpse['type'] === Lexer::T_DOT) {
  3326.                     $expr = $this->SingleValuedPathExpression();
  3328.                     // Leave switch statement
  3329.                     break;
  3330.                 }
  3332.                 $lookaheadValue = $this->lexer->lookahead['value'];
  3334.                 // Validate existing component
  3335.                 if (! isset($this->queryComponents[$lookaheadValue])) {
  3336.                     $this->semanticalError('Cannot add having condition on undefined result variable.');
  3337.                 }
  3339.                 // Validate SingleValuedPathExpression (ie.: "product")
  3340.                 if (isset($this->queryComponents[$lookaheadValue]['metadata'])) {
  3341.                     $expr = $this->SingleValuedPathExpression();
  3342.                     break;
  3343.                 }
  3345.                 // Validating ResultVariable
  3346.                 if (! isset($this->queryComponents[$lookaheadValue]['resultVariable'])) {
  3347.                     $this->semanticalError('Cannot add having condition on a non result variable.');
  3348.                 }
  3350.                 $expr = $this->ResultVariable();
  3351.                 break;
  3352.         }
  3354.         $nullCompExpr = new AST\NullComparisonExpression($expr);
  3356.         $this->match(Lexer::T_IS);
  3358.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3359.             $this->match(Lexer::T_NOT);
  3361.             $nullCompExpr->not = true;
  3362.         }
  3364.         $this->match(Lexer::T_NULL);
  3366.         return $nullCompExpr;
  3367.     }
  3369.     /**
  3370.      * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
  3371.      *
  3372.      * @return ExistsExpression
  3373.      */
  3374.     public function ExistsExpression()
  3375.     {
  3376.         $not = false;
  3378.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3379.             $this->match(Lexer::T_NOT);
  3380.             $not = true;
  3381.         }
  3383.         $this->match(Lexer::T_EXISTS);
  3384.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3386.         $existsExpression      = new AST\ExistsExpression($this->Subselect());
  3387.         $existsExpression->not = $not;
  3389.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3391.         return $existsExpression;
  3392.     }
  3394.     /**
  3395.      * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
  3396.      *
  3397.      * @return string
  3398.      */
  3399.     public function ComparisonOperator()
  3400.     {
  3401.         switch ($this->lexer->lookahead['value']) {
  3402.             case '=':
  3403.                 $this->match(Lexer::T_EQUALS);
  3405.                 return '=';
  3407.             case '<':
  3408.                 $this->match(Lexer::T_LOWER_THAN);
  3409.                 $operator = '<';
  3411.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3412.                     $this->match(Lexer::T_EQUALS);
  3413.                     $operator .= '=';
  3414.                 } elseif ($this->lexer->isNextToken(Lexer::T_GREATER_THAN)) {
  3415.                     $this->match(Lexer::T_GREATER_THAN);
  3416.                     $operator .= '>';
  3417.                 }
  3419.                 return $operator;
  3421.             case '>':
  3422.                 $this->match(Lexer::T_GREATER_THAN);
  3423.                 $operator = '>';
  3425.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3426.                     $this->match(Lexer::T_EQUALS);
  3427.                     $operator .= '=';
  3428.                 }
  3430.                 return $operator;
  3432.             case '!':
  3433.                 $this->match(Lexer::T_NEGATE);
  3434.                 $this->match(Lexer::T_EQUALS);
  3436.                 return '<>';
  3438.             default:
  3439.                 $this->syntaxError('=, <, <=, <>, >, >=, !=');
  3440.         }
  3441.     }
  3443.     /**
  3444.      * FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDatetime
  3445.      *
  3446.      * @return FunctionNode
  3447.      */
  3448.     public function FunctionDeclaration()
  3449.     {
  3450.         $token    = $this->lexer->lookahead;
  3451.         $funcName = strtolower($token['value']);
  3453.         $customFunctionDeclaration = $this->CustomFunctionDeclaration();
  3455.         // Check for custom functions functions first!
  3456.         switch (true) {
  3457.             case $customFunctionDeclaration !== null:
  3458.                 return $customFunctionDeclaration;
  3460.             case isset(self::$stringFunctions[$funcName]):
  3461.                 return $this->FunctionsReturningStrings();
  3463.             case isset(self::$numericFunctions[$funcName]):
  3464.                 return $this->FunctionsReturningNumerics();
  3466.             case isset(self::$datetimeFunctions[$funcName]):
  3467.                 return $this->FunctionsReturningDatetime();
  3469.             default:
  3470.                 $this->syntaxError('known function', $token);
  3471.         }
  3472.     }
  3474.     /**
  3475.      * Helper function for FunctionDeclaration grammar rule.
  3476.      */
  3477.     private function CustomFunctionDeclaration(): ?FunctionNode
  3478.     {
  3479.         $token    = $this->lexer->lookahead;
  3480.         $funcName = strtolower($token['value']);
  3482.         // Check for custom functions afterwards
  3483.         $config = $this->em->getConfiguration();
  3485.         switch (true) {
  3486.             case $config->getCustomStringFunction($funcName) !== null:
  3487.                 return $this->CustomFunctionsReturningStrings();
  3489.             case $config->getCustomNumericFunction($funcName) !== null:
  3490.                 return $this->CustomFunctionsReturningNumerics();
  3492.             case $config->getCustomDatetimeFunction($funcName) !== null:
  3493.                 return $this->CustomFunctionsReturningDatetime();
  3495.             default:
  3496.                 return null;
  3497.         }
  3498.     }
  3500.     /**
  3501.      * FunctionsReturningNumerics ::=
  3502.      *      "LENGTH" "(" StringPrimary ")" |
  3503.      *      "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")" |
  3504.      *      "ABS" "(" SimpleArithmeticExpression ")" |
  3505.      *      "SQRT" "(" SimpleArithmeticExpression ")" |
  3506.      *      "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3507.      *      "SIZE" "(" CollectionValuedPathExpression ")" |
  3508.      *      "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3509.      *      "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3510.      *      "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
  3511.      *
  3512.      * @return FunctionNode
  3513.      */
  3514.     public function FunctionsReturningNumerics()
  3515.     {
  3516.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3517.         $funcClass     = self::$numericFunctions[$funcNameLower];
  3519.         $function = new $funcClass($funcNameLower);
  3520.         $function->parse($this);
  3522.         return $function;
  3523.     }
  3525.     /**
  3526.      * @return FunctionNode
  3527.      */
  3528.     public function CustomFunctionsReturningNumerics()
  3529.     {
  3530.         // getCustomNumericFunction is case-insensitive
  3531.         $functionName  = strtolower($this->lexer->lookahead['value']);
  3532.         $functionClass = $this->em->getConfiguration()->getCustomNumericFunction($functionName);
  3534.         assert($functionClass !== null);
  3536.         $function = is_string($functionClass)
  3537.             ? new $functionClass($functionName)
  3538.             : call_user_func($functionClass, $functionName);
  3540.         $function->parse($this);
  3542.         return $function;
  3543.     }
  3545.     /**
  3546.      * FunctionsReturningDateTime ::=
  3547.      *     "CURRENT_DATE" |
  3548.      *     "CURRENT_TIME" |
  3549.      *     "CURRENT_TIMESTAMP" |
  3550.      *     "DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")" |
  3551.      *     "DATE_SUB" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
  3552.      *
  3553.      * @return FunctionNode
  3554.      */
  3555.     public function FunctionsReturningDatetime()
  3556.     {
  3557.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3558.         $funcClass     = self::$datetimeFunctions[$funcNameLower];
  3560.         $function = new $funcClass($funcNameLower);
  3561.         $function->parse($this);
  3563.         return $function;
  3564.     }
  3566.     /**
  3567.      * @return FunctionNode
  3568.      */
  3569.     public function CustomFunctionsReturningDatetime()
  3570.     {
  3571.         // getCustomDatetimeFunction is case-insensitive
  3572.         $functionName  = $this->lexer->lookahead['value'];
  3573.         $functionClass = $this->em->getConfiguration()->getCustomDatetimeFunction($functionName);
  3575.         assert($functionClass !== null);
  3577.         $function = is_string($functionClass)
  3578.             ? new $functionClass($functionName)
  3579.             : call_user_func($functionClass, $functionName);
  3581.         $function->parse($this);
  3583.         return $function;
  3584.     }
  3586.     /**
  3587.      * FunctionsReturningStrings ::=
  3588.      *   "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary}* ")" |
  3589.      *   "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3590.      *   "TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")" |
  3591.      *   "LOWER" "(" StringPrimary ")" |
  3592.      *   "UPPER" "(" StringPrimary ")" |
  3593.      *   "IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
  3594.      *
  3595.      * @return FunctionNode
  3596.      */
  3597.     public function FunctionsReturningStrings()
  3598.     {
  3599.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3600.         $funcClass     = self::$stringFunctions[$funcNameLower];
  3602.         $function = new $funcClass($funcNameLower);
  3603.         $function->parse($this);
  3605.         return $function;
  3606.     }
  3608.     /**
  3609.      * @return FunctionNode
  3610.      */
  3611.     public function CustomFunctionsReturningStrings()
  3612.     {
  3613.         // getCustomStringFunction is case-insensitive
  3614.         $functionName  = $this->lexer->lookahead['value'];
  3615.         $functionClass = $this->em->getConfiguration()->getCustomStringFunction($functionName);
  3617.         assert($functionClass !== null);
  3619.         $function = is_string($functionClass)
  3620.             ? new $functionClass($functionName)
  3621.             : call_user_func($functionClass, $functionName);
  3623.         $function->parse($this);
  3625.         return $function;
  3626.     }
  3627. }