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

Open in your IDE?
  1. <?php
  3. /*
  4.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  5.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  6.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  7.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  8.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  9.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  10.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  11.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  12.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  13.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  14.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  15.  *
  16.  * This software consists of voluntary contributions made by many individuals
  17.  * and is licensed under the MIT license. For more information, see
  18.  * <http://www.doctrine-project.org>.
  19.  */
  21. namespace Doctrine\ORM\Query;
  23. use Doctrine\ORM\EntityManager;
  24. use Doctrine\ORM\Mapping\ClassMetadata;
  25. use Doctrine\ORM\Query;
  26. use Doctrine\ORM\Query\AST\AggregateExpression;
  27. use Doctrine\ORM\Query\AST\ArithmeticExpression;
  28. use Doctrine\ORM\Query\AST\ArithmeticFactor;
  29. use Doctrine\ORM\Query\AST\ArithmeticTerm;
  30. use Doctrine\ORM\Query\AST\BetweenExpression;
  31. use Doctrine\ORM\Query\AST\CoalesceExpression;
  32. use Doctrine\ORM\Query\AST\CollectionMemberExpression;
  33. use Doctrine\ORM\Query\AST\ComparisonExpression;
  34. use Doctrine\ORM\Query\AST\ConditionalPrimary;
  35. use Doctrine\ORM\Query\AST\DeleteClause;
  36. use Doctrine\ORM\Query\AST\DeleteStatement;
  37. use Doctrine\ORM\Query\AST\EmptyCollectionComparisonExpression;
  38. use Doctrine\ORM\Query\AST\ExistsExpression;
  39. use Doctrine\ORM\Query\AST\FromClause;
  40. use Doctrine\ORM\Query\AST\Functions;
  41. use Doctrine\ORM\Query\AST\Functions\FunctionNode;
  42. use Doctrine\ORM\Query\AST\GeneralCaseExpression;
  43. use Doctrine\ORM\Query\AST\GroupByClause;
  44. use Doctrine\ORM\Query\AST\HavingClause;
  45. use Doctrine\ORM\Query\AST\IdentificationVariableDeclaration;
  46. use Doctrine\ORM\Query\AST\IndexBy;
  47. use Doctrine\ORM\Query\AST\InExpression;
  48. use Doctrine\ORM\Query\AST\InputParameter;
  49. use Doctrine\ORM\Query\AST\InstanceOfExpression;
  50. use Doctrine\ORM\Query\AST\Join;
  51. use Doctrine\ORM\Query\AST\JoinAssociationPathExpression;
  52. use Doctrine\ORM\Query\AST\LikeExpression;
  53. use Doctrine\ORM\Query\AST\Literal;
  54. use Doctrine\ORM\Query\AST\NewObjectExpression;
  55. use Doctrine\ORM\Query\AST\Node;
  56. use Doctrine\ORM\Query\AST\NullComparisonExpression;
  57. use Doctrine\ORM\Query\AST\NullIfExpression;
  58. use Doctrine\ORM\Query\AST\OrderByClause;
  59. use Doctrine\ORM\Query\AST\OrderByItem;
  60. use Doctrine\ORM\Query\AST\PartialObjectExpression;
  61. use Doctrine\ORM\Query\AST\PathExpression;
  62. use Doctrine\ORM\Query\AST\QuantifiedExpression;
  63. use Doctrine\ORM\Query\AST\RangeVariableDeclaration;
  64. use Doctrine\ORM\Query\AST\SelectClause;
  65. use Doctrine\ORM\Query\AST\SelectExpression;
  66. use Doctrine\ORM\Query\AST\SelectStatement;
  67. use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
  68. use Doctrine\ORM\Query\AST\SimpleSelectClause;
  69. use Doctrine\ORM\Query\AST\SimpleSelectExpression;
  70. use Doctrine\ORM\Query\AST\SimpleWhenClause;
  71. use Doctrine\ORM\Query\AST\Subselect;
  72. use Doctrine\ORM\Query\AST\SubselectFromClause;
  73. use Doctrine\ORM\Query\AST\SubselectIdentificationVariableDeclaration;
  74. use Doctrine\ORM\Query\AST\UpdateClause;
  75. use Doctrine\ORM\Query\AST\UpdateItem;
  76. use Doctrine\ORM\Query\AST\UpdateStatement;
  77. use Doctrine\ORM\Query\AST\WhenClause;
  78. use Doctrine\ORM\Query\AST\WhereClause;
  79. use ReflectionClass;
  81. use function array_intersect;
  82. use function array_search;
  83. use function assert;
  84. use function call_user_func;
  85. use function class_exists;
  86. use function count;
  87. use function explode;
  88. use function implode;
  89. use function in_array;
  90. use function interface_exists;
  91. use function is_string;
  92. use function sprintf;
  93. use function strlen;
  94. use function strpos;
  95. use function strrpos;
  96. use function strtolower;
  97. use function substr;
  99. /**
  100.  * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  101.  * Parses a DQL query, reports any errors in it, and generates an AST.
  102.  */
  103. class Parser
  104. {
  105.     /**
  106.      * READ-ONLY: Maps BUILT-IN string function names to AST class names.
  107.      *
  108.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  109.      */
  110.     private static $stringFunctions = [
  111.         'concat'    => Functions\ConcatFunction::class,
  112.         'substring' => Functions\SubstringFunction::class,
  113.         'trim'      => Functions\TrimFunction::class,
  114.         'lower'     => Functions\LowerFunction::class,
  115.         'upper'     => Functions\UpperFunction::class,
  116.         'identity'  => Functions\IdentityFunction::class,
  117.     ];
  119.     /**
  120.      * READ-ONLY: Maps BUILT-IN numeric function names to AST class names.
  121.      *
  122.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  123.      */
  124.     private static $numericFunctions = [
  125.         'length'    => Functions\LengthFunction::class,
  126.         'locate'    => Functions\LocateFunction::class,
  127.         'abs'       => Functions\AbsFunction::class,
  128.         'sqrt'      => Functions\SqrtFunction::class,
  129.         'mod'       => Functions\ModFunction::class,
  130.         'size'      => Functions\SizeFunction::class,
  131.         'date_diff' => Functions\DateDiffFunction::class,
  132.         'bit_and'   => Functions\BitAndFunction::class,
  133.         'bit_or'    => Functions\BitOrFunction::class,
  135.         // Aggregate functions
  136.         'min'       => Functions\MinFunction::class,
  137.         'max'       => Functions\MaxFunction::class,
  138.         'avg'       => Functions\AvgFunction::class,
  139.         'sum'       => Functions\SumFunction::class,
  140.         'count'     => Functions\CountFunction::class,
  141.     ];
  143.     /**
  144.      * READ-ONLY: Maps BUILT-IN datetime function names to AST class names.
  145.      *
  146.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  147.      */
  148.     private static $datetimeFunctions = [
  149.         'current_date'      => Functions\CurrentDateFunction::class,
  150.         'current_time'      => Functions\CurrentTimeFunction::class,
  151.         'current_timestamp' => Functions\CurrentTimestampFunction::class,
  152.         'date_add'          => Functions\DateAddFunction::class,
  153.         'date_sub'          => Functions\DateSubFunction::class,
  154.     ];
  156.     /*
  157.      * Expressions that were encountered during parsing of identifiers and expressions
  158.      * and still need to be validated.
  159.      */
  161.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  162.     private $deferredIdentificationVariables = [];
  164.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  165.     private $deferredPartialObjectExpressions = [];
  167.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  168.     private $deferredPathExpressions = [];
  170.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  171.     private $deferredResultVariables = [];
  173.     /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  174.     private $deferredNewObjectExpressions = [];
  176.     /**
  177.      * The lexer.
  178.      *
  179.      * @var Lexer
  180.      */
  181.     private $lexer;
  183.     /**
  184.      * The parser result.
  185.      *
  186.      * @var ParserResult
  187.      */
  188.     private $parserResult;
  190.     /**
  191.      * The EntityManager.
  192.      *
  193.      * @var EntityManager
  194.      */
  195.     private $em;
  197.     /**
  198.      * The Query to parse.
  199.      *
  200.      * @var Query
  201.      */
  202.     private $query;
  204.     /**
  205.      * Map of declared query components in the parsed query.
  206.      *
  207.      * @psalm-var array<string, array<string, mixed>>
  208.      */
  209.     private $queryComponents = [];
  211.     /**
  212.      * Keeps the nesting level of defined ResultVariables.
  213.      *
  214.      * @var int
  215.      */
  216.     private $nestingLevel = 0;
  218.     /**
  219.      * Any additional custom tree walkers that modify the AST.
  220.      *
  221.      * @psalm-var list<class-string<TreeWalker>>
  222.      */
  223.     private $customTreeWalkers = [];
  225.     /**
  226.      * The custom last tree walker, if any, that is responsible for producing the output.
  227.      *
  228.      * @var class-string<TreeWalker>
  229.      */
  230.     private $customOutputWalker;
  232.     /** @psalm-var list<AST\SelectExpression> */
  233.     private $identVariableExpressions = [];
  235.     /**
  236.      * Creates a new query parser object.
  237.      *
  238.      * @param Query $query The Query to parse.
  239.      */
  240.     public function __construct(Query $query)
  241.     {
  242.         $this->query        = $query;
  243.         $this->em           = $query->getEntityManager();
  244.         $this->lexer        = new Lexer((string) $query->getDQL());
  245.         $this->parserResult = new ParserResult();
  246.     }
  248.     /**
  249.      * Sets a custom tree walker that produces output.
  250.      * This tree walker will be run last over the AST, after any other walkers.
  251.      *
  252.      * @param string $className
  253.      *
  254.      * @return void
  255.      */
  256.     public function setCustomOutputTreeWalker($className)
  257.     {
  258.         $this->customOutputWalker = $className;
  259.     }
  261.     /**
  262.      * Adds a custom tree walker for modifying the AST.
  263.      *
  264.      * @return void
  265.      *
  266.      * @psalm-param class-string $className
  267.      */
  268.     public function addCustomTreeWalker($className)
  269.     {
  270.         $this->customTreeWalkers[] = $className;
  271.     }
  273.     /**
  274.      * Gets the lexer used by the parser.
  275.      *
  276.      * @return Lexer
  277.      */
  278.     public function getLexer()
  279.     {
  280.         return $this->lexer;
  281.     }
  283.     /**
  284.      * Gets the ParserResult that is being filled with information during parsing.
  285.      *
  286.      * @return ParserResult
  287.      */
  288.     public function getParserResult()
  289.     {
  290.         return $this->parserResult;
  291.     }
  293.     /**
  294.      * Gets the EntityManager used by the parser.
  295.      *
  296.      * @return EntityManager
  297.      */
  298.     public function getEntityManager()
  299.     {
  300.         return $this->em;
  301.     }
  303.     /**
  304.      * Parses and builds AST for the given Query.
  305.      *
  306.      * @return SelectStatement|UpdateStatement|DeleteStatement
  307.      */
  308.     public function getAST()
  309.     {
  310.         // Parse & build AST
  311.         $AST = $this->QueryLanguage();
  313.         // Process any deferred validations of some nodes in the AST.
  314.         // This also allows post-processing of the AST for modification purposes.
  315.         $this->processDeferredIdentificationVariables();
  317.         if ($this->deferredPartialObjectExpressions) {
  318.             $this->processDeferredPartialObjectExpressions();
  319.         }
  321.         if ($this->deferredPathExpressions) {
  322.             $this->processDeferredPathExpressions();
  323.         }
  325.         if ($this->deferredResultVariables) {
  326.             $this->processDeferredResultVariables();
  327.         }
  329.         if ($this->deferredNewObjectExpressions) {
  330.             $this->processDeferredNewObjectExpressions($AST);
  331.         }
  333.         $this->processRootEntityAliasSelected();
  335.         // TODO: Is there a way to remove this? It may impact the mixed hydration resultset a lot!
  336.         $this->fixIdentificationVariableOrder($AST);
  338.         return $AST;
  339.     }
  341.     /**
  342.      * Attempts to match the given token with the current lookahead token.
  343.      *
  344.      * If they match, updates the lookahead token; otherwise raises a syntax
  345.      * error.
  346.      *
  347.      * @param int $token The token type.
  348.      *
  349.      * @return void
  350.      *
  351.      * @throws QueryException If the tokens don't match.
  352.      */
  353.     public function match($token)
  354.     {
  355.         $lookaheadType = $this->lexer->lookahead['type'] ?? null;
  357.         // Short-circuit on first condition, usually types match
  358.         if ($lookaheadType === $token) {
  359.             $this->lexer->moveNext();
  361.             return;
  362.         }
  364.         // If parameter is not identifier (1-99) must be exact match
  365.         if ($token < Lexer::T_IDENTIFIER) {
  366.             $this->syntaxError($this->lexer->getLiteral($token));
  367.         }
  369.         // If parameter is keyword (200+) must be exact match
  370.         if ($token > Lexer::T_IDENTIFIER) {
  371.             $this->syntaxError($this->lexer->getLiteral($token));
  372.         }
  374.         // If parameter is T_IDENTIFIER, then matches T_IDENTIFIER (100) and keywords (200+)
  375.         if ($token === Lexer::T_IDENTIFIER && $lookaheadType < Lexer::T_IDENTIFIER) {
  376.             $this->syntaxError($this->lexer->getLiteral($token));
  377.         }
  379.         $this->lexer->moveNext();
  380.     }
  382.     /**
  383.      * Frees this parser, enabling it to be reused.
  384.      *
  385.      * @param bool $deep     Whether to clean peek and reset errors.
  386.      * @param int  $position Position to reset.
  387.      *
  388.      * @return void
  389.      */
  390.     public function free($deep = false, $position = 0)
  391.     {
  392.         // WARNING! Use this method with care. It resets the scanner!
  393.         $this->lexer->resetPosition($position);
  395.         // Deep = true cleans peek and also any previously defined errors
  396.         if ($deep) {
  397.             $this->lexer->resetPeek();
  398.         }
  400.         $this->lexer->token     = null;
  401.         $this->lexer->lookahead = null;
  402.     }
  404.     /**
  405.      * Parses a query string.
  406.      *
  407.      * @return ParserResult
  408.      */
  409.     public function parse()
  410.     {
  411.         $AST = $this->getAST();
  413.         $customWalkers = $this->query->getHint(Query::HINT_CUSTOM_TREE_WALKERS);
  414.         if ($customWalkers !== false) {
  415.             $this->customTreeWalkers = $customWalkers;
  416.         }
  418.         $customOutputWalker = $this->query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER);
  419.         if ($customOutputWalker !== false) {
  420.             $this->customOutputWalker = $customOutputWalker;
  421.         }
  423.         // Run any custom tree walkers over the AST
  424.         if ($this->customTreeWalkers) {
  425.             $treeWalkerChain = new TreeWalkerChain($this->query, $this->parserResult, $this->queryComponents);
  427.             foreach ($this->customTreeWalkers as $walker) {
  428.                 $treeWalkerChain->addTreeWalker($walker);
  429.             }
  431.             switch (true) {
  432.                 case $AST instanceof AST\UpdateStatement:
  433.                     $treeWalkerChain->walkUpdateStatement($AST);
  434.                     break;
  436.                 case $AST instanceof AST\DeleteStatement:
  437.                     $treeWalkerChain->walkDeleteStatement($AST);
  438.                     break;
  440.                 case $AST instanceof AST\SelectStatement:
  441.                 default:
  442.                     $treeWalkerChain->walkSelectStatement($AST);
  443.             }
  445.             $this->queryComponents = $treeWalkerChain->getQueryComponents();
  446.         }
  448.         $outputWalkerClass = $this->customOutputWalker ?: SqlWalker::class;
  449.         $outputWalker      = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
  451.         // Assign an SQL executor to the parser result
  452.         $this->parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
  454.         return $this->parserResult;
  455.     }
  457.     /**
  458.      * Fixes order of identification variables.
  459.      *
  460.      * They have to appear in the select clause in the same order as the
  461.      * declarations (from ... x join ... y join ... z ...) appear in the query
  462.      * as the hydration process relies on that order for proper operation.
  463.      *
  464.      * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST
  465.      *
  466.      * @return void
  467.      */
  468.     private function fixIdentificationVariableOrder($AST)
  469.     {
  470.         if (count($this->identVariableExpressions) <= 1) {
  471.             return;
  472.         }
  474.         assert($AST instanceof AST\SelectStatement);
  476.         foreach ($this->queryComponents as $dqlAlias => $qComp) {
  477.             if (! isset($this->identVariableExpressions[$dqlAlias])) {
  478.                 continue;
  479.             }
  481.             $expr = $this->identVariableExpressions[$dqlAlias];
  482.             $key  = array_search($expr, $AST->selectClause->selectExpressions);
  484.             unset($AST->selectClause->selectExpressions[$key]);
  486.             $AST->selectClause->selectExpressions[] = $expr;
  487.         }
  488.     }
  490.     /**
  491.      * Generates a new syntax error.
  492.      *
  493.      * @param string $expected Expected string.
  494.      *
  495.      * @return void
  496.      *
  497.      * @throws QueryException
  498.      *
  499.      * @psalm-param array<string, mixed>|null $token    Got token.
  500.      */
  501.     public function syntaxError($expected = '', $token = null)
  502.     {
  503.         if ($token === null) {
  504.             $token = $this->lexer->lookahead;
  505.         }
  507.         $tokenPos = $token['position'] ?? '-1';
  509.         $message  = sprintf('line 0, col %d: Error: ', $tokenPos);
  510.         $message .= $expected !== '' ? sprintf('Expected %s, got ', $expected) : 'Unexpected ';
  511.         $message .= $this->lexer->lookahead === null ? 'end of string.' : sprintf("'%s'", $token['value']);
  513.         throw QueryException::syntaxError($message, QueryException::dqlError($this->query->getDQL()));
  514.     }
  516.     /**
  517.      * Generates a new semantical error.
  518.      *
  519.      * @param string $message Optional message.
  520.      *
  521.      * @return void
  522.      *
  523.      * @throws QueryException
  524.      *
  525.      * @psalm-param array<string, mixed>|null $token Optional token.
  526.      */
  527.     public function semanticalError($message = '', $token = null)
  528.     {
  529.         if ($token === null) {
  530.             $token = $this->lexer->lookahead ?? ['position' => null];
  531.         }
  533.         // Minimum exposed chars ahead of token
  534.         $distance = 12;
  536.         // Find a position of a final word to display in error string
  537.         $dql    = $this->query->getDQL();
  538.         $length = strlen($dql);
  539.         $pos    = $token['position'] + $distance;
  540.         $pos    = strpos($dql, ' ', $length > $pos ? $pos : $length);
  541.         $length = $pos !== false ? $pos - $token['position'] : $distance;
  543.         $tokenPos = isset($token['position']) && $token['position'] > 0 ? $token['position'] : '-1';
  544.         $tokenStr = substr($dql, $token['position'], $length);
  546.         // Building informative message
  547.         $message = 'line 0, col ' . $tokenPos . " near '" . $tokenStr . "': Error: " . $message;
  549.         throw QueryException::semanticalError($message, QueryException::dqlError($this->query->getDQL()));
  550.     }
  552.     /**
  553.      * Peeks beyond the matched closing parenthesis and returns the first token after that one.
  554.      *
  555.      * @param bool $resetPeek Reset peek after finding the closing parenthesis.
  556.      *
  557.      * @psalm-return array<string, mixed>| null
  558.      */
  559.     private function peekBeyondClosingParenthesis(bool $resetPeek = true)
  560.     {
  561.         $token        = $this->lexer->peek();
  562.         $numUnmatched = 1;
  564.         while ($numUnmatched > 0 && $token !== null) {
  565.             switch ($token['type']) {
  566.                 case Lexer::T_OPEN_PARENTHESIS:
  567.                     ++$numUnmatched;
  568.                     break;
  570.                 case Lexer::T_CLOSE_PARENTHESIS:
  571.                     --$numUnmatched;
  572.                     break;
  574.                 default:
  575.                     // Do nothing
  576.             }
  578.             $token = $this->lexer->peek();
  579.         }
  581.         if ($resetPeek) {
  582.             $this->lexer->resetPeek();
  583.         }
  585.         return $token;
  586.     }
  588.     /**
  589.      * Checks if the given token indicates a mathematical operator.
  590.      *
  591.      * @psalm-param array<string, mixed> $token
  592.      */
  593.     private function isMathOperator($token): bool
  594.     {
  595.         return $token !== null && in_array($token['type'], [Lexer::T_PLUS, Lexer::T_MINUS, Lexer::T_DIVIDE, Lexer::T_MULTIPLY]);
  596.     }
  598.     /**
  599.      * Checks if the next-next (after lookahead) token starts a function.
  600.      *
  601.      * @return bool TRUE if the next-next tokens start a function, FALSE otherwise.
  602.      */
  603.     private function isFunction(): bool
  604.     {
  605.         $lookaheadType = $this->lexer->lookahead['type'];
  606.         $peek          = $this->lexer->peek();
  608.         $this->lexer->resetPeek();
  610.         return $lookaheadType >= Lexer::T_IDENTIFIER && $peek !== null && $peek['type'] === Lexer::T_OPEN_PARENTHESIS;
  611.     }
  613.     /**
  614.      * Checks whether the given token type indicates an aggregate function.
  615.      *
  616.      * @return bool TRUE if the token type is an aggregate function, FALSE otherwise.
  617.      *
  618.      * @psalm-param Lexer::T_* $tokenType
  619.      */
  620.     private function isAggregateFunction(int $tokenType): bool
  621.     {
  622.         return in_array(
  623.             $tokenType,
  624.             [Lexer::T_AVG, Lexer::T_MIN, Lexer::T_MAX, Lexer::T_SUM, Lexer::T_COUNT]
  625.         );
  626.     }
  628.     /**
  629.      * Checks whether the current lookahead token of the lexer has the type T_ALL, T_ANY or T_SOME.
  630.      */
  631.     private function isNextAllAnySome(): bool
  632.     {
  633.         return in_array(
  634.             $this->lexer->lookahead['type'],
  635.             [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME]
  636.         );
  637.     }
  639.     /**
  640.      * Validates that the given <tt>IdentificationVariable</tt> is semantically correct.
  641.      * It must exist in query components list.
  642.      */
  643.     private function processDeferredIdentificationVariables(): void
  644.     {
  645.         foreach ($this->deferredIdentificationVariables as $deferredItem) {
  646.             $identVariable = $deferredItem['expression'];
  648.             // Check if IdentificationVariable exists in queryComponents
  649.             if (! isset($this->queryComponents[$identVariable])) {
  650.                 $this->semanticalError(
  651.                     sprintf("'%s' is not defined.", $identVariable),
  652.                     $deferredItem['token']
  653.                 );
  654.             }
  656.             $qComp = $this->queryComponents[$identVariable];
  658.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  659.             if (! isset($qComp['metadata'])) {
  660.                 $this->semanticalError(
  661.                     sprintf("'%s' does not point to a Class.", $identVariable),
  662.                     $deferredItem['token']
  663.                 );
  664.             }
  666.             // Validate if identification variable nesting level is lower or equal than the current one
  667.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  668.                 $this->semanticalError(
  669.                     sprintf("'%s' is used outside the scope of its declaration.", $identVariable),
  670.                     $deferredItem['token']
  671.                 );
  672.             }
  673.         }
  674.     }
  676.     /**
  677.      * Validates that the given <tt>NewObjectExpression</tt>.
  678.      */
  679.     private function processDeferredNewObjectExpressions(SelectStatement $AST): void
  680.     {
  681.         foreach ($this->deferredNewObjectExpressions as $deferredItem) {
  682.             $expression    = $deferredItem['expression'];
  683.             $token         = $deferredItem['token'];
  684.             $className     = $expression->className;
  685.             $args          = $expression->args;
  686.             $fromClassName = $AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName ?? null;
  688.             // If the namespace is not given then assumes the first FROM entity namespace
  689.             if (strpos($className, '\\') === false && ! class_exists($className) && strpos($fromClassName, '\\') !== false) {
  690.                 $namespace = substr($fromClassName, 0, strrpos($fromClassName, '\\'));
  691.                 $fqcn      = $namespace . '\\' . $className;
  693.                 if (class_exists($fqcn)) {
  694.                     $expression->className = $fqcn;
  695.                     $className             = $fqcn;
  696.                 }
  697.             }
  699.             if (! class_exists($className)) {
  700.                 $this->semanticalError(sprintf('Class "%s" is not defined.', $className), $token);
  701.             }
  703.             $class = new ReflectionClass($className);
  705.             if (! $class->isInstantiable()) {
  706.                 $this->semanticalError(sprintf('Class "%s" can not be instantiated.', $className), $token);
  707.             }
  709.             if ($class->getConstructor() === null) {
  710.                 $this->semanticalError(sprintf('Class "%s" has not a valid constructor.', $className), $token);
  711.             }
  713.             if ($class->getConstructor()->getNumberOfRequiredParameters() > count($args)) {
  714.                 $this->semanticalError(sprintf('Number of arguments does not match with "%s" constructor declaration.', $className), $token);
  715.             }
  716.         }
  717.     }
  719.     /**
  720.      * Validates that the given <tt>PartialObjectExpression</tt> is semantically correct.
  721.      * It must exist in query components list.
  722.      */
  723.     private function processDeferredPartialObjectExpressions(): void
  724.     {
  725.         foreach ($this->deferredPartialObjectExpressions as $deferredItem) {
  726.             $expr  = $deferredItem['expression'];
  727.             $class = $this->queryComponents[$expr->identificationVariable]['metadata'];
  729.             foreach ($expr->partialFieldSet as $field) {
  730.                 if (isset($class->fieldMappings[$field])) {
  731.                     continue;
  732.                 }
  734.                 if (
  735.                     isset($class->associationMappings[$field]) &&
  736.                     $class->associationMappings[$field]['isOwningSide'] &&
  737.                     $class->associationMappings[$field]['type'] & ClassMetadata::TO_ONE
  738.                 ) {
  739.                     continue;
  740.                 }
  742.                 $this->semanticalError(sprintf(
  743.                     "There is no mapped field named '%s' on class %s.",
  744.                     $field,
  745.                     $class->name
  746.                 ), $deferredItem['token']);
  747.             }
  749.             if (array_intersect($class->identifier, $expr->partialFieldSet) !== $class->identifier) {
  750.                 $this->semanticalError(
  751.                     'The partial field selection of class ' . $class->name . ' must contain the identifier.',
  752.                     $deferredItem['token']
  753.                 );
  754.             }
  755.         }
  756.     }
  758.     /**
  759.      * Validates that the given <tt>ResultVariable</tt> is semantically correct.
  760.      * It must exist in query components list.
  761.      */
  762.     private function processDeferredResultVariables(): void
  763.     {
  764.         foreach ($this->deferredResultVariables as $deferredItem) {
  765.             $resultVariable = $deferredItem['expression'];
  767.             // Check if ResultVariable exists in queryComponents
  768.             if (! isset($this->queryComponents[$resultVariable])) {
  769.                 $this->semanticalError(
  770.                     sprintf("'%s' is not defined.", $resultVariable),
  771.                     $deferredItem['token']
  772.                 );
  773.             }
  775.             $qComp = $this->queryComponents[$resultVariable];
  777.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  778.             if (! isset($qComp['resultVariable'])) {
  779.                 $this->semanticalError(
  780.                     sprintf("'%s' does not point to a ResultVariable.", $resultVariable),
  781.                     $deferredItem['token']
  782.                 );
  783.             }
  785.             // Validate if identification variable nesting level is lower or equal than the current one
  786.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  787.                 $this->semanticalError(
  788.                     sprintf("'%s' is used outside the scope of its declaration.", $resultVariable),
  789.                     $deferredItem['token']
  790.                 );
  791.             }
  792.         }
  793.     }
  795.     /**
  796.      * Validates that the given <tt>PathExpression</tt> is semantically correct for grammar rules:
  797.      *
  798.      * AssociationPathExpression             ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  799.      * SingleValuedPathExpression            ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  800.      * StateFieldPathExpression              ::= IdentificationVariable "." StateField
  801.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  802.      * CollectionValuedPathExpression        ::= IdentificationVariable "." CollectionValuedAssociationField
  803.      */
  804.     private function processDeferredPathExpressions(): void
  805.     {
  806.         foreach ($this->deferredPathExpressions as $deferredItem) {
  807.             $pathExpression = $deferredItem['expression'];
  809.             $qComp = $this->queryComponents[$pathExpression->identificationVariable];
  810.             $class = $qComp['metadata'];
  812.             $field = $pathExpression->field;
  813.             if ($field === null) {
  814.                 $field = $pathExpression->field = $class->identifier[0];
  815.             }
  817.             // Check if field or association exists
  818.             if (! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
  819.                 $this->semanticalError(
  820.                     'Class ' . $class->name . ' has no field or association named ' . $field,
  821.                     $deferredItem['token']
  822.                 );
  823.             }
  825.             $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
  827.             if (isset($class->associationMappings[$field])) {
  828.                 $assoc = $class->associationMappings[$field];
  830.                 $fieldType = $assoc['type'] & ClassMetadata::TO_ONE
  831.                     ? AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  832.                     : AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
  833.             }
  835.             // Validate if PathExpression is one of the expected types
  836.             $expectedType = $pathExpression->expectedType;
  838.             if (! ($expectedType & $fieldType)) {
  839.                 // We need to recognize which was expected type(s)
  840.                 $expectedStringTypes = [];
  842.                 // Validate state field type
  843.                 if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
  844.                     $expectedStringTypes[] = 'StateFieldPathExpression';
  845.                 }
  847.                 // Validate single valued association (*-to-one)
  848.                 if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
  849.                     $expectedStringTypes[] = 'SingleValuedAssociationField';
  850.                 }
  852.                 // Validate single valued association (*-to-many)
  853.                 if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
  854.                     $expectedStringTypes[] = 'CollectionValuedAssociationField';
  855.                 }
  857.                 // Build the error message
  858.                 $semanticalError  = 'Invalid PathExpression. ';
  859.                 $semanticalError .= count($expectedStringTypes) === 1
  860.                     ? 'Must be a ' . $expectedStringTypes[0] . '.'
  861.                     : implode(' or ', $expectedStringTypes) . ' expected.';
  863.                 $this->semanticalError($semanticalError, $deferredItem['token']);
  864.             }
  866.             // We need to force the type in PathExpression
  867.             $pathExpression->type = $fieldType;
  868.         }
  869.     }
  871.     private function processRootEntityAliasSelected(): void
  872.     {
  873.         if (! count($this->identVariableExpressions)) {
  874.             return;
  875.         }
  877.         foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
  878.             if (isset($this->queryComponents[$dqlAlias]) && $this->queryComponents[$dqlAlias]['parent'] === null) {
  879.                 return;
  880.             }
  881.         }
  883.         $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');
  884.     }
  886.     /**
  887.      * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
  888.      *
  889.      * @return SelectStatement|UpdateStatement|DeleteStatement
  890.      */
  891.     public function QueryLanguage()
  892.     {
  893.         $statement = null;
  895.         $this->lexer->moveNext();
  897.         switch ($this->lexer->lookahead['type'] ?? null) {
  898.             case Lexer::T_SELECT:
  899.                 $statement = $this->SelectStatement();
  900.                 break;
  902.             case Lexer::T_UPDATE:
  903.                 $statement = $this->UpdateStatement();
  904.                 break;
  906.             case Lexer::T_DELETE:
  907.                 $statement = $this->DeleteStatement();
  908.                 break;
  910.             default:
  911.                 $this->syntaxError('SELECT, UPDATE or DELETE');
  912.                 break;
  913.         }
  915.         // Check for end of string
  916.         if ($this->lexer->lookahead !== null) {
  917.             $this->syntaxError('end of string');
  918.         }
  920.         return $statement;
  921.     }
  923.     /**
  924.      * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  925.      *
  926.      * @return SelectStatement
  927.      */
  928.     public function SelectStatement()
  929.     {
  930.         $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());
  932.         $selectStatement->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  933.         $selectStatement->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  934.         $selectStatement->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  935.         $selectStatement->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  937.         return $selectStatement;
  938.     }
  940.     /**
  941.      * UpdateStatement ::= UpdateClause [WhereClause]
  942.      *
  943.      * @return UpdateStatement
  944.      */
  945.     public function UpdateStatement()
  946.     {
  947.         $updateStatement = new AST\UpdateStatement($this->UpdateClause());
  949.         $updateStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  951.         return $updateStatement;
  952.     }
  954.     /**
  955.      * DeleteStatement ::= DeleteClause [WhereClause]
  956.      *
  957.      * @return DeleteStatement
  958.      */
  959.     public function DeleteStatement()
  960.     {
  961.         $deleteStatement = new AST\DeleteStatement($this->DeleteClause());
  963.         $deleteStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  965.         return $deleteStatement;
  966.     }
  968.     /**
  969.      * IdentificationVariable ::= identifier
  970.      *
  971.      * @return string
  972.      */
  973.     public function IdentificationVariable()
  974.     {
  975.         $this->match(Lexer::T_IDENTIFIER);
  977.         $identVariable = $this->lexer->token['value'];
  979.         $this->deferredIdentificationVariables[] = [
  980.             'expression'   => $identVariable,
  981.             'nestingLevel' => $this->nestingLevel,
  982.             'token'        => $this->lexer->token,
  983.         ];
  985.         return $identVariable;
  986.     }
  988.     /**
  989.      * AliasIdentificationVariable = identifier
  990.      *
  991.      * @return string
  992.      */
  993.     public function AliasIdentificationVariable()
  994.     {
  995.         $this->match(Lexer::T_IDENTIFIER);
  997.         $aliasIdentVariable = $this->lexer->token['value'];
  998.         $exists             = isset($this->queryComponents[$aliasIdentVariable]);
  1000.         if ($exists) {
  1001.             $this->semanticalError(
  1002.                 sprintf("'%s' is already defined.", $aliasIdentVariable),
  1003.                 $this->lexer->token
  1004.             );
  1005.         }
  1007.         return $aliasIdentVariable;
  1008.     }
  1010.     /**
  1011.      * AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
  1012.      *
  1013.      * @return string
  1014.      */
  1015.     public function AbstractSchemaName()
  1016.     {
  1017.         if ($this->lexer->isNextToken(Lexer::T_FULLY_QUALIFIED_NAME)) {
  1018.             $this->match(Lexer::T_FULLY_QUALIFIED_NAME);
  1020.             return $this->lexer->token['value'];
  1021.         }
  1023.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  1024.             $this->match(Lexer::T_IDENTIFIER);
  1026.             return $this->lexer->token['value'];
  1027.         }
  1029.         $this->match(Lexer::T_ALIASED_NAME);
  1031.         [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token['value']);
  1033.         return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  1034.     }
  1036.     /**
  1037.      * Validates an AbstractSchemaName, making sure the class exists.
  1038.      *
  1039.      * @param string $schemaName The name to validate.
  1040.      *
  1041.      * @throws QueryException if the name does not exist.
  1042.      */
  1043.     private function validateAbstractSchemaName($schemaName)
  1044.     {
  1045.         if (! (class_exists($schemaName, true) || interface_exists($schemaName, true))) {
  1046.             $this->semanticalError(
  1047.                 sprintf("Class '%s' is not defined.", $schemaName),
  1048.                 $this->lexer->token
  1049.             );
  1050.         }
  1051.     }
  1053.     /**
  1054.      * AliasResultVariable ::= identifier
  1055.      *
  1056.      * @return string
  1057.      */
  1058.     public function AliasResultVariable()
  1059.     {
  1060.         $this->match(Lexer::T_IDENTIFIER);
  1062.         $resultVariable = $this->lexer->token['value'];
  1063.         $exists         = isset($this->queryComponents[$resultVariable]);
  1065.         if ($exists) {
  1066.             $this->semanticalError(
  1067.                 sprintf("'%s' is already defined.", $resultVariable),
  1068.                 $this->lexer->token
  1069.             );
  1070.         }
  1072.         return $resultVariable;
  1073.     }
  1075.     /**
  1076.      * ResultVariable ::= identifier
  1077.      *
  1078.      * @return string
  1079.      */
  1080.     public function ResultVariable()
  1081.     {
  1082.         $this->match(Lexer::T_IDENTIFIER);
  1084.         $resultVariable = $this->lexer->token['value'];
  1086.         // Defer ResultVariable validation
  1087.         $this->deferredResultVariables[] = [
  1088.             'expression'   => $resultVariable,
  1089.             'nestingLevel' => $this->nestingLevel,
  1090.             'token'        => $this->lexer->token,
  1091.         ];
  1093.         return $resultVariable;
  1094.     }
  1096.     /**
  1097.      * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
  1098.      *
  1099.      * @return JoinAssociationPathExpression
  1100.      */
  1101.     public function JoinAssociationPathExpression()
  1102.     {
  1103.         $identVariable = $this->IdentificationVariable();
  1105.         if (! isset($this->queryComponents[$identVariable])) {
  1106.             $this->semanticalError(
  1107.                 'Identification Variable ' . $identVariable . ' used in join path expression but was not defined before.'
  1108.             );
  1109.         }
  1111.         $this->match(Lexer::T_DOT);
  1112.         $this->match(Lexer::T_IDENTIFIER);
  1114.         $field = $this->lexer->token['value'];
  1116.         // Validate association field
  1117.         $qComp = $this->queryComponents[$identVariable];
  1118.         $class = $qComp['metadata'];
  1120.         if (! $class->hasAssociation($field)) {
  1121.             $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
  1122.         }
  1124.         return new AST\JoinAssociationPathExpression($identVariable, $field);
  1125.     }
  1127.     /**
  1128.      * Parses an arbitrary path expression and defers semantical validation
  1129.      * based on expected types.
  1130.      *
  1131.      * PathExpression ::= IdentificationVariable {"." identifier}*
  1132.      *
  1133.      * @param int $expectedTypes
  1134.      *
  1135.      * @return PathExpression
  1136.      */
  1137.     public function PathExpression($expectedTypes)
  1138.     {
  1139.         $identVariable = $this->IdentificationVariable();
  1140.         $field         = null;
  1142.         if ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1143.             $this->match(Lexer::T_DOT);
  1144.             $this->match(Lexer::T_IDENTIFIER);
  1146.             $field = $this->lexer->token['value'];
  1148.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1149.                 $this->match(Lexer::T_DOT);
  1150.                 $this->match(Lexer::T_IDENTIFIER);
  1151.                 $field .= '.' . $this->lexer->token['value'];
  1152.             }
  1153.         }
  1155.         // Creating AST node
  1156.         $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);
  1158.         // Defer PathExpression validation if requested to be deferred
  1159.         $this->deferredPathExpressions[] = [
  1160.             'expression'   => $pathExpr,
  1161.             'nestingLevel' => $this->nestingLevel,
  1162.             'token'        => $this->lexer->token,
  1163.         ];
  1165.         return $pathExpr;
  1166.     }
  1168.     /**
  1169.      * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  1170.      *
  1171.      * @return PathExpression
  1172.      */
  1173.     public function AssociationPathExpression()
  1174.     {
  1175.         return $this->PathExpression(
  1176.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |
  1177.             AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION
  1178.         );
  1179.     }
  1181.     /**
  1182.      * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  1183.      *
  1184.      * @return PathExpression
  1185.      */
  1186.     public function SingleValuedPathExpression()
  1187.     {
  1188.         return $this->PathExpression(
  1189.             AST\PathExpression::TYPE_STATE_FIELD |
  1190.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  1191.         );
  1192.     }
  1194.     /**
  1195.      * StateFieldPathExpression ::= IdentificationVariable "." StateField
  1196.      *
  1197.      * @return PathExpression
  1198.      */
  1199.     public function StateFieldPathExpression()
  1200.     {
  1201.         return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);
  1202.     }
  1204.     /**
  1205.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  1206.      *
  1207.      * @return PathExpression
  1208.      */
  1209.     public function SingleValuedAssociationPathExpression()
  1210.     {
  1211.         return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);
  1212.     }
  1214.     /**
  1215.      * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  1216.      *
  1217.      * @return PathExpression
  1218.      */
  1219.     public function CollectionValuedPathExpression()
  1220.     {
  1221.         return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);
  1222.     }
  1224.     /**
  1225.      * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
  1226.      *
  1227.      * @return SelectClause
  1228.      */
  1229.     public function SelectClause()
  1230.     {
  1231.         $isDistinct = false;
  1232.         $this->match(Lexer::T_SELECT);
  1234.         // Check for DISTINCT
  1235.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1236.             $this->match(Lexer::T_DISTINCT);
  1238.             $isDistinct = true;
  1239.         }
  1241.         // Process SelectExpressions (1..N)
  1242.         $selectExpressions   = [];
  1243.         $selectExpressions[] = $this->SelectExpression();
  1245.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1246.             $this->match(Lexer::T_COMMA);
  1248.             $selectExpressions[] = $this->SelectExpression();
  1249.         }
  1251.         return new AST\SelectClause($selectExpressions, $isDistinct);
  1252.     }
  1254.     /**
  1255.      * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
  1256.      *
  1257.      * @return SimpleSelectClause
  1258.      */
  1259.     public function SimpleSelectClause()
  1260.     {
  1261.         $isDistinct = false;
  1262.         $this->match(Lexer::T_SELECT);
  1264.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1265.             $this->match(Lexer::T_DISTINCT);
  1267.             $isDistinct = true;
  1268.         }
  1270.         return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);
  1271.     }
  1273.     /**
  1274.      * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*
  1275.      *
  1276.      * @return UpdateClause
  1277.      */
  1278.     public function UpdateClause()
  1279.     {
  1280.         $this->match(Lexer::T_UPDATE);
  1282.         $token              = $this->lexer->lookahead;
  1283.         $abstractSchemaName = $this->AbstractSchemaName();
  1285.         $this->validateAbstractSchemaName($abstractSchemaName);
  1287.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1288.             $this->match(Lexer::T_AS);
  1289.         }
  1291.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1293.         $class = $this->em->getClassMetadata($abstractSchemaName);
  1295.         // Building queryComponent
  1296.         $queryComponent = [
  1297.             'metadata'     => $class,
  1298.             'parent'       => null,
  1299.             'relation'     => null,
  1300.             'map'          => null,
  1301.             'nestingLevel' => $this->nestingLevel,
  1302.             'token'        => $token,
  1303.         ];
  1305.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1307.         $this->match(Lexer::T_SET);
  1309.         $updateItems   = [];
  1310.         $updateItems[] = $this->UpdateItem();
  1312.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1313.             $this->match(Lexer::T_COMMA);
  1315.             $updateItems[] = $this->UpdateItem();
  1316.         }
  1318.         $updateClause                              = new AST\UpdateClause($abstractSchemaName, $updateItems);
  1319.         $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1321.         return $updateClause;
  1322.     }
  1324.     /**
  1325.      * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable
  1326.      *
  1327.      * @return DeleteClause
  1328.      */
  1329.     public function DeleteClause()
  1330.     {
  1331.         $this->match(Lexer::T_DELETE);
  1333.         if ($this->lexer->isNextToken(Lexer::T_FROM)) {
  1334.             $this->match(Lexer::T_FROM);
  1335.         }
  1337.         $token              = $this->lexer->lookahead;
  1338.         $abstractSchemaName = $this->AbstractSchemaName();
  1340.         $this->validateAbstractSchemaName($abstractSchemaName);
  1342.         $deleteClause = new AST\DeleteClause($abstractSchemaName);
  1344.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1345.             $this->match(Lexer::T_AS);
  1346.         }
  1348.         $aliasIdentificationVariable = $this->lexer->isNextToken(Lexer::T_IDENTIFIER)
  1349.             ? $this->AliasIdentificationVariable()
  1350.             : 'alias_should_have_been_set';
  1352.         $deleteClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1353.         $class                                     = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1355.         // Building queryComponent
  1356.         $queryComponent = [
  1357.             'metadata'     => $class,
  1358.             'parent'       => null,
  1359.             'relation'     => null,
  1360.             'map'          => null,
  1361.             'nestingLevel' => $this->nestingLevel,
  1362.             'token'        => $token,
  1363.         ];
  1365.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1367.         return $deleteClause;
  1368.     }
  1370.     /**
  1371.      * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}*
  1372.      *
  1373.      * @return FromClause
  1374.      */
  1375.     public function FromClause()
  1376.     {
  1377.         $this->match(Lexer::T_FROM);
  1379.         $identificationVariableDeclarations   = [];
  1380.         $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1382.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1383.             $this->match(Lexer::T_COMMA);
  1385.             $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1386.         }
  1388.         return new AST\FromClause($identificationVariableDeclarations);
  1389.     }
  1391.     /**
  1392.      * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
  1393.      *
  1394.      * @return SubselectFromClause
  1395.      */
  1396.     public function SubselectFromClause()
  1397.     {
  1398.         $this->match(Lexer::T_FROM);
  1400.         $identificationVariables   = [];
  1401.         $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1403.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1404.             $this->match(Lexer::T_COMMA);
  1406.             $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1407.         }
  1409.         return new AST\SubselectFromClause($identificationVariables);
  1410.     }
  1412.     /**
  1413.      * WhereClause ::= "WHERE" ConditionalExpression
  1414.      *
  1415.      * @return WhereClause
  1416.      */
  1417.     public function WhereClause()
  1418.     {
  1419.         $this->match(Lexer::T_WHERE);
  1421.         return new AST\WhereClause($this->ConditionalExpression());
  1422.     }
  1424.     /**
  1425.      * HavingClause ::= "HAVING" ConditionalExpression
  1426.      *
  1427.      * @return HavingClause
  1428.      */
  1429.     public function HavingClause()
  1430.     {
  1431.         $this->match(Lexer::T_HAVING);
  1433.         return new AST\HavingClause($this->ConditionalExpression());
  1434.     }
  1436.     /**
  1437.      * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
  1438.      *
  1439.      * @return GroupByClause
  1440.      */
  1441.     public function GroupByClause()
  1442.     {
  1443.         $this->match(Lexer::T_GROUP);
  1444.         $this->match(Lexer::T_BY);
  1446.         $groupByItems = [$this->GroupByItem()];
  1448.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1449.             $this->match(Lexer::T_COMMA);
  1451.             $groupByItems[] = $this->GroupByItem();
  1452.         }
  1454.         return new AST\GroupByClause($groupByItems);
  1455.     }
  1457.     /**
  1458.      * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
  1459.      *
  1460.      * @return OrderByClause
  1461.      */
  1462.     public function OrderByClause()
  1463.     {
  1464.         $this->match(Lexer::T_ORDER);
  1465.         $this->match(Lexer::T_BY);
  1467.         $orderByItems   = [];
  1468.         $orderByItems[] = $this->OrderByItem();
  1470.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1471.             $this->match(Lexer::T_COMMA);
  1473.             $orderByItems[] = $this->OrderByItem();
  1474.         }
  1476.         return new AST\OrderByClause($orderByItems);
  1477.     }
  1479.     /**
  1480.      * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  1481.      *
  1482.      * @return Subselect
  1483.      */
  1484.     public function Subselect()
  1485.     {
  1486.         // Increase query nesting level
  1487.         $this->nestingLevel++;
  1489.         $subselect = new AST\Subselect($this->SimpleSelectClause(), $this->SubselectFromClause());
  1491.         $subselect->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  1492.         $subselect->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  1493.         $subselect->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  1494.         $subselect->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  1496.         // Decrease query nesting level
  1497.         $this->nestingLevel--;
  1499.         return $subselect;
  1500.     }
  1502.     /**
  1503.      * UpdateItem ::= SingleValuedPathExpression "=" NewValue
  1504.      *
  1505.      * @return UpdateItem
  1506.      */
  1507.     public function UpdateItem()
  1508.     {
  1509.         $pathExpr = $this->SingleValuedPathExpression();
  1511.         $this->match(Lexer::T_EQUALS);
  1513.         return new AST\UpdateItem($pathExpr, $this->NewValue());
  1514.     }
  1516.     /**
  1517.      * GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression
  1518.      *
  1519.      * @return string|PathExpression
  1520.      */
  1521.     public function GroupByItem()
  1522.     {
  1523.         // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  1524.         $glimpse = $this->lexer->glimpse();
  1526.         if ($glimpse !== null && $glimpse['type'] === Lexer::T_DOT) {
  1527.             return $this->SingleValuedPathExpression();
  1528.         }
  1530.         // Still need to decide between IdentificationVariable or ResultVariable
  1531.         $lookaheadValue = $this->lexer->lookahead['value'];
  1533.         if (! isset($this->queryComponents[$lookaheadValue])) {
  1534.             $this->semanticalError('Cannot group by undefined identification or result variable.');
  1535.         }
  1537.         return isset($this->queryComponents[$lookaheadValue]['metadata'])
  1538.             ? $this->IdentificationVariable()
  1539.             : $this->ResultVariable();
  1540.     }
  1542.     /**
  1543.      * OrderByItem ::= (
  1544.      *      SimpleArithmeticExpression | SingleValuedPathExpression | CaseExpression |
  1545.      *      ScalarExpression | ResultVariable | FunctionDeclaration
  1546.      * ) ["ASC" | "DESC"]
  1547.      *
  1548.      * @return OrderByItem
  1549.      */
  1550.     public function OrderByItem()
  1551.     {
  1552.         $this->lexer->peek(); // lookahead => '.'
  1553.         $this->lexer->peek(); // lookahead => token after '.'
  1555.         $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1557.         $this->lexer->resetPeek();
  1559.         $glimpse = $this->lexer->glimpse();
  1561.         switch (true) {
  1562.             case $this->isMathOperator($peek):
  1563.                 $expr = $this->SimpleArithmeticExpression();
  1564.                 break;
  1566.             case $glimpse !== null && $glimpse['type'] === Lexer::T_DOT:
  1567.                 $expr = $this->SingleValuedPathExpression();
  1568.                 break;
  1570.             case $this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  1571.                 $expr = $this->ScalarExpression();
  1572.                 break;
  1574.             case $this->lexer->lookahead['type'] === Lexer::T_CASE:
  1575.                 $expr = $this->CaseExpression();
  1576.                 break;
  1578.             case $this->isFunction():
  1579.                 $expr = $this->FunctionDeclaration();
  1580.                 break;
  1582.             default:
  1583.                 $expr = $this->ResultVariable();
  1584.                 break;
  1585.         }
  1587.         $type = 'ASC';
  1588.         $item = new AST\OrderByItem($expr);
  1590.         switch (true) {
  1591.             case $this->lexer->isNextToken(Lexer::T_DESC):
  1592.                 $this->match(Lexer::T_DESC);
  1593.                 $type = 'DESC';
  1594.                 break;
  1596.             case $this->lexer->isNextToken(Lexer::T_ASC):
  1597.                 $this->match(Lexer::T_ASC);
  1598.                 break;
  1600.             default:
  1601.                 // Do nothing
  1602.         }
  1604.         $item->type = $type;
  1606.         return $item;
  1607.     }
  1609.     /**
  1610.      * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
  1611.      *      EnumPrimary | SimpleEntityExpression | "NULL"
  1612.      *
  1613.      * NOTE: Since it is not possible to correctly recognize individual types, here is the full
  1614.      * grammar that needs to be supported:
  1615.      *
  1616.      * NewValue ::= SimpleArithmeticExpression | "NULL"
  1617.      *
  1618.      * SimpleArithmeticExpression covers all *Primary grammar rules and also SimpleEntityExpression
  1619.      *
  1620.      * @return AST\ArithmeticExpression|AST\InputParameter|null
  1621.      */
  1622.     public function NewValue()
  1623.     {
  1624.         if ($this->lexer->isNextToken(Lexer::T_NULL)) {
  1625.             $this->match(Lexer::T_NULL);
  1627.             return null;
  1628.         }
  1630.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  1631.             $this->match(Lexer::T_INPUT_PARAMETER);
  1633.             return new AST\InputParameter($this->lexer->token['value']);
  1634.         }
  1636.         return $this->ArithmeticExpression();
  1637.     }
  1639.     /**
  1640.      * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*
  1641.      *
  1642.      * @return IdentificationVariableDeclaration
  1643.      */
  1644.     public function IdentificationVariableDeclaration()
  1645.     {
  1646.         $joins                    = [];
  1647.         $rangeVariableDeclaration = $this->RangeVariableDeclaration();
  1648.         $indexBy                  = $this->lexer->isNextToken(Lexer::T_INDEX)
  1649.             ? $this->IndexBy()
  1650.             : null;
  1652.         $rangeVariableDeclaration->isRoot = true;
  1654.         while (
  1655.             $this->lexer->isNextToken(Lexer::T_LEFT) ||
  1656.             $this->lexer->isNextToken(Lexer::T_INNER) ||
  1657.             $this->lexer->isNextToken(Lexer::T_JOIN)
  1658.         ) {
  1659.             $joins[] = $this->Join();
  1660.         }
  1662.         return new AST\IdentificationVariableDeclaration(
  1663.             $rangeVariableDeclaration,
  1664.             $indexBy,
  1665.             $joins
  1666.         );
  1667.     }
  1669.     /**
  1670.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration
  1671.      *
  1672.      * {Internal note: WARNING: Solution is harder than a bare implementation.
  1673.      * Desired EBNF support:
  1674.      *
  1675.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
  1676.      *
  1677.      * It demands that entire SQL generation to become programmatical. This is
  1678.      * needed because association based subselect requires "WHERE" conditional
  1679.      * expressions to be injected, but there is no scope to do that. Only scope
  1680.      * accessible is "FROM", prohibiting an easy implementation without larger
  1681.      * changes.}
  1682.      *
  1683.      * @return SubselectIdentificationVariableDeclaration|IdentificationVariableDeclaration
  1684.      */
  1685.     public function SubselectIdentificationVariableDeclaration()
  1686.     {
  1687.         /*
  1688.         NOT YET IMPLEMENTED!
  1690.         $glimpse = $this->lexer->glimpse();
  1692.         if ($glimpse['type'] == Lexer::T_DOT) {
  1693.             $associationPathExpression = $this->AssociationPathExpression();
  1695.             if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1696.                 $this->match(Lexer::T_AS);
  1697.             }
  1699.             $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1700.             $identificationVariable      = $associationPathExpression->identificationVariable;
  1701.             $field                       = $associationPathExpression->associationField;
  1703.             $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1704.             $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1706.             // Building queryComponent
  1707.             $joinQueryComponent = array(
  1708.                 'metadata'     => $targetClass,
  1709.                 'parent'       => $identificationVariable,
  1710.                 'relation'     => $class->getAssociationMapping($field),
  1711.                 'map'          => null,
  1712.                 'nestingLevel' => $this->nestingLevel,
  1713.                 'token'        => $this->lexer->lookahead
  1714.             );
  1716.             $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1718.             return new AST\SubselectIdentificationVariableDeclaration(
  1719.                 $associationPathExpression, $aliasIdentificationVariable
  1720.             );
  1721.         }
  1722.         */
  1724.         return $this->IdentificationVariableDeclaration();
  1725.     }
  1727.     /**
  1728.      * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN"
  1729.      *          (JoinAssociationDeclaration | RangeVariableDeclaration)
  1730.      *          ["WITH" ConditionalExpression]
  1731.      *
  1732.      * @return Join
  1733.      */
  1734.     public function Join()
  1735.     {
  1736.         // Check Join type
  1737.         $joinType = AST\Join::JOIN_TYPE_INNER;
  1739.         switch (true) {
  1740.             case $this->lexer->isNextToken(Lexer::T_LEFT):
  1741.                 $this->match(Lexer::T_LEFT);
  1743.                 $joinType = AST\Join::JOIN_TYPE_LEFT;
  1745.                 // Possible LEFT OUTER join
  1746.                 if ($this->lexer->isNextToken(Lexer::T_OUTER)) {
  1747.                     $this->match(Lexer::T_OUTER);
  1749.                     $joinType = AST\Join::JOIN_TYPE_LEFTOUTER;
  1750.                 }
  1752.                 break;
  1754.             case $this->lexer->isNextToken(Lexer::T_INNER):
  1755.                 $this->match(Lexer::T_INNER);
  1756.                 break;
  1758.             default:
  1759.                 // Do nothing
  1760.         }
  1762.         $this->match(Lexer::T_JOIN);
  1764.         $next            = $this->lexer->glimpse();
  1765.         $joinDeclaration = $next['type'] === Lexer::T_DOT ? $this->JoinAssociationDeclaration() : $this->RangeVariableDeclaration();
  1766.         $adhocConditions = $this->lexer->isNextToken(Lexer::T_WITH);
  1767.         $join            = new AST\Join($joinType, $joinDeclaration);
  1769.         // Describe non-root join declaration
  1770.         if ($joinDeclaration instanceof AST\RangeVariableDeclaration) {
  1771.             $joinDeclaration->isRoot = false;
  1772.         }
  1774.         // Check for ad-hoc Join conditions
  1775.         if ($adhocConditions) {
  1776.             $this->match(Lexer::T_WITH);
  1778.             $join->conditionalExpression = $this->ConditionalExpression();
  1779.         }
  1781.         return $join;
  1782.     }
  1784.     /**
  1785.      * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
  1786.      *
  1787.      * @return RangeVariableDeclaration
  1788.      *
  1789.      * @throws QueryException
  1790.      */
  1791.     public function RangeVariableDeclaration()
  1792.     {
  1793.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $this->lexer->glimpse()['type'] === Lexer::T_SELECT) {
  1794.             $this->semanticalError('Subquery is not supported here', $this->lexer->token);
  1795.         }
  1797.         $abstractSchemaName = $this->AbstractSchemaName();
  1799.         $this->validateAbstractSchemaName($abstractSchemaName);
  1801.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1802.             $this->match(Lexer::T_AS);
  1803.         }
  1805.         $token                       = $this->lexer->lookahead;
  1806.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1807.         $classMetadata               = $this->em->getClassMetadata($abstractSchemaName);
  1809.         // Building queryComponent
  1810.         $queryComponent = [
  1811.             'metadata'     => $classMetadata,
  1812.             'parent'       => null,
  1813.             'relation'     => null,
  1814.             'map'          => null,
  1815.             'nestingLevel' => $this->nestingLevel,
  1816.             'token'        => $token,
  1817.         ];
  1819.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1821.         return new AST\RangeVariableDeclaration($abstractSchemaName, $aliasIdentificationVariable);
  1822.     }
  1824.     /**
  1825.      * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [IndexBy]
  1826.      *
  1827.      * @return AST\JoinAssociationDeclaration
  1828.      */
  1829.     public function JoinAssociationDeclaration()
  1830.     {
  1831.         $joinAssociationPathExpression = $this->JoinAssociationPathExpression();
  1833.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1834.             $this->match(Lexer::T_AS);
  1835.         }
  1837.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1838.         $indexBy                     = $this->lexer->isNextToken(Lexer::T_INDEX) ? $this->IndexBy() : null;
  1840.         $identificationVariable = $joinAssociationPathExpression->identificationVariable;
  1841.         $field                  = $joinAssociationPathExpression->associationField;
  1843.         $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1844.         $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1846.         // Building queryComponent
  1847.         $joinQueryComponent = [
  1848.             'metadata'     => $targetClass,
  1849.             'parent'       => $joinAssociationPathExpression->identificationVariable,
  1850.             'relation'     => $class->getAssociationMapping($field),
  1851.             'map'          => null,
  1852.             'nestingLevel' => $this->nestingLevel,
  1853.             'token'        => $this->lexer->lookahead,
  1854.         ];
  1856.         $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1858.         return new AST\JoinAssociationDeclaration($joinAssociationPathExpression, $aliasIdentificationVariable, $indexBy);
  1859.     }
  1861.     /**
  1862.      * PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
  1863.      * PartialFieldSet ::= "{" SimpleStateField {"," SimpleStateField}* "}"
  1864.      *
  1865.      * @return PartialObjectExpression
  1866.      */
  1867.     public function PartialObjectExpression()
  1868.     {
  1869.         $this->match(Lexer::T_PARTIAL);
  1871.         $partialFieldSet = [];
  1873.         $identificationVariable = $this->IdentificationVariable();
  1875.         $this->match(Lexer::T_DOT);
  1876.         $this->match(Lexer::T_OPEN_CURLY_BRACE);
  1877.         $this->match(Lexer::T_IDENTIFIER);
  1879.         $field = $this->lexer->token['value'];
  1881.         // First field in partial expression might be embeddable property
  1882.         while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1883.             $this->match(Lexer::T_DOT);
  1884.             $this->match(Lexer::T_IDENTIFIER);
  1885.             $field .= '.' . $this->lexer->token['value'];
  1886.         }
  1888.         $partialFieldSet[] = $field;
  1890.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1891.             $this->match(Lexer::T_COMMA);
  1892.             $this->match(Lexer::T_IDENTIFIER);
  1894.             $field = $this->lexer->token['value'];
  1896.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1897.                 $this->match(Lexer::T_DOT);
  1898.                 $this->match(Lexer::T_IDENTIFIER);
  1899.                 $field .= '.' . $this->lexer->token['value'];
  1900.             }
  1902.             $partialFieldSet[] = $field;
  1903.         }
  1905.         $this->match(Lexer::T_CLOSE_CURLY_BRACE);
  1907.         $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
  1909.         // Defer PartialObjectExpression validation
  1910.         $this->deferredPartialObjectExpressions[] = [
  1911.             'expression'   => $partialObjectExpression,
  1912.             'nestingLevel' => $this->nestingLevel,
  1913.             'token'        => $this->lexer->token,
  1914.         ];
  1916.         return $partialObjectExpression;
  1917.     }
  1919.     /**
  1920.      * NewObjectExpression ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
  1921.      *
  1922.      * @return NewObjectExpression
  1923.      */
  1924.     public function NewObjectExpression()
  1925.     {
  1926.         $this->match(Lexer::T_NEW);
  1928.         $className = $this->AbstractSchemaName(); // note that this is not yet validated
  1929.         $token     = $this->lexer->token;
  1931.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  1933.         $args[] = $this->NewObjectArg();
  1935.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1936.             $this->match(Lexer::T_COMMA);
  1938.             $args[] = $this->NewObjectArg();
  1939.         }
  1941.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1943.         $expression = new AST\NewObjectExpression($className, $args);
  1945.         // Defer NewObjectExpression validation
  1946.         $this->deferredNewObjectExpressions[] = [
  1947.             'token'        => $token,
  1948.             'expression'   => $expression,
  1949.             'nestingLevel' => $this->nestingLevel,
  1950.         ];
  1952.         return $expression;
  1953.     }
  1955.     /**
  1956.      * NewObjectArg ::= ScalarExpression | "(" Subselect ")"
  1957.      *
  1958.      * @return mixed
  1959.      */
  1960.     public function NewObjectArg()
  1961.     {
  1962.         $token = $this->lexer->lookahead;
  1963.         $peek  = $this->lexer->glimpse();
  1965.         if ($token['type'] === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT) {
  1966.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  1967.             $expression = $this->Subselect();
  1968.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1970.             return $expression;
  1971.         }
  1973.         return $this->ScalarExpression();
  1974.     }
  1976.     /**
  1977.      * IndexBy ::= "INDEX" "BY" StateFieldPathExpression
  1978.      *
  1979.      * @return IndexBy
  1980.      */
  1981.     public function IndexBy()
  1982.     {
  1983.         $this->match(Lexer::T_INDEX);
  1984.         $this->match(Lexer::T_BY);
  1985.         $pathExpr = $this->StateFieldPathExpression();
  1987.         // Add the INDEX BY info to the query component
  1988.         $this->queryComponents[$pathExpr->identificationVariable]['map'] = $pathExpr->field;
  1990.         return new AST\IndexBy($pathExpr);
  1991.     }
  1993.     /**
  1994.      * ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DateTimePrimary |
  1995.      *                      StateFieldPathExpression | BooleanPrimary | CaseExpression |
  1996.      *                      InstanceOfExpression
  1997.      *
  1998.      * @return mixed One of the possible expressions or subexpressions.
  1999.      */
  2000.     public function ScalarExpression()
  2001.     {
  2002.         $lookahead = $this->lexer->lookahead['type'];
  2003.         $peek      = $this->lexer->glimpse();
  2005.         switch (true) {
  2006.             case $lookahead === Lexer::T_INTEGER:
  2007.             case $lookahead === Lexer::T_FLOAT:
  2008.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )  or ( - 1 ) or ( + 1 )
  2009.             case $lookahead === Lexer::T_MINUS:
  2010.             case $lookahead === Lexer::T_PLUS:
  2011.                 return $this->SimpleArithmeticExpression();
  2013.             case $lookahead === Lexer::T_STRING:
  2014.                 return $this->StringPrimary();
  2016.             case $lookahead === Lexer::T_TRUE:
  2017.             case $lookahead === Lexer::T_FALSE:
  2018.                 $this->match($lookahead);
  2020.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2022.             case $lookahead === Lexer::T_INPUT_PARAMETER:
  2023.                 switch (true) {
  2024.                     case $this->isMathOperator($peek):
  2025.                         // :param + u.value
  2026.                         return $this->SimpleArithmeticExpression();
  2028.                     default:
  2029.                         return $this->InputParameter();
  2030.                 }
  2031.             case $lookahead === Lexer::T_CASE:
  2032.             case $lookahead === Lexer::T_COALESCE:
  2033.             case $lookahead === Lexer::T_NULLIF:
  2034.                 // Since NULLIF and COALESCE can be identified as a function,
  2035.                 // we need to check these before checking for FunctionDeclaration
  2036.                 return $this->CaseExpression();
  2038.             case $lookahead === Lexer::T_OPEN_PARENTHESIS:
  2039.                 return $this->SimpleArithmeticExpression();
  2041.             // this check must be done before checking for a filed path expression
  2042.             case $this->isFunction():
  2043.                 $this->lexer->peek(); // "("
  2045.                 switch (true) {
  2046.                     case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2047.                         // SUM(u.id) + COUNT(u.id)
  2048.                         return $this->SimpleArithmeticExpression();
  2050.                     default:
  2051.                         // IDENTITY(u)
  2052.                         return $this->FunctionDeclaration();
  2053.                 }
  2055.                 break;
  2056.             // it is no function, so it must be a field path
  2057.             case $lookahead === Lexer::T_IDENTIFIER:
  2058.                 $this->lexer->peek(); // lookahead => '.'
  2059.                 $this->lexer->peek(); // lookahead => token after '.'
  2060.                 $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  2061.                 $this->lexer->resetPeek();
  2063.                 if ($this->isMathOperator($peek)) {
  2064.                     return $this->SimpleArithmeticExpression();
  2065.                 }
  2067.                 return $this->StateFieldPathExpression();
  2069.             default:
  2070.                 $this->syntaxError();
  2071.         }
  2072.     }
  2074.     /**
  2075.      * CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullifExpression
  2076.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2077.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2078.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2079.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2080.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2081.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2082.      * NullifExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2083.      *
  2084.      * @return mixed One of the possible expressions or subexpressions.
  2085.      */
  2086.     public function CaseExpression()
  2087.     {
  2088.         $lookahead = $this->lexer->lookahead['type'];
  2090.         switch ($lookahead) {
  2091.             case Lexer::T_NULLIF:
  2092.                 return $this->NullIfExpression();
  2094.             case Lexer::T_COALESCE:
  2095.                 return $this->CoalesceExpression();
  2097.             case Lexer::T_CASE:
  2098.                 $this->lexer->resetPeek();
  2099.                 $peek = $this->lexer->peek();
  2101.                 if ($peek['type'] === Lexer::T_WHEN) {
  2102.                     return $this->GeneralCaseExpression();
  2103.                 }
  2105.                 return $this->SimpleCaseExpression();
  2107.             default:
  2108.                 // Do nothing
  2109.                 break;
  2110.         }
  2112.         $this->syntaxError();
  2113.     }
  2115.     /**
  2116.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2117.      *
  2118.      * @return CoalesceExpression
  2119.      */
  2120.     public function CoalesceExpression()
  2121.     {
  2122.         $this->match(Lexer::T_COALESCE);
  2123.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2125.         // Process ScalarExpressions (1..N)
  2126.         $scalarExpressions   = [];
  2127.         $scalarExpressions[] = $this->ScalarExpression();
  2129.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  2130.             $this->match(Lexer::T_COMMA);
  2132.             $scalarExpressions[] = $this->ScalarExpression();
  2133.         }
  2135.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2137.         return new AST\CoalesceExpression($scalarExpressions);
  2138.     }
  2140.     /**
  2141.      * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2142.      *
  2143.      * @return NullIfExpression
  2144.      */
  2145.     public function NullIfExpression()
  2146.     {
  2147.         $this->match(Lexer::T_NULLIF);
  2148.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2150.         $firstExpression = $this->ScalarExpression();
  2151.         $this->match(Lexer::T_COMMA);
  2152.         $secondExpression = $this->ScalarExpression();
  2154.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2156.         return new AST\NullIfExpression($firstExpression, $secondExpression);
  2157.     }
  2159.     /**
  2160.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2161.      *
  2162.      * @return GeneralCaseExpression
  2163.      */
  2164.     public function GeneralCaseExpression()
  2165.     {
  2166.         $this->match(Lexer::T_CASE);
  2168.         // Process WhenClause (1..N)
  2169.         $whenClauses = [];
  2171.         do {
  2172.             $whenClauses[] = $this->WhenClause();
  2173.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2175.         $this->match(Lexer::T_ELSE);
  2176.         $scalarExpression = $this->ScalarExpression();
  2177.         $this->match(Lexer::T_END);
  2179.         return new AST\GeneralCaseExpression($whenClauses, $scalarExpression);
  2180.     }
  2182.     /**
  2183.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2184.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2185.      *
  2186.      * @return AST\SimpleCaseExpression
  2187.      */
  2188.     public function SimpleCaseExpression()
  2189.     {
  2190.         $this->match(Lexer::T_CASE);
  2191.         $caseOperand = $this->StateFieldPathExpression();
  2193.         // Process SimpleWhenClause (1..N)
  2194.         $simpleWhenClauses = [];
  2196.         do {
  2197.             $simpleWhenClauses[] = $this->SimpleWhenClause();
  2198.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2200.         $this->match(Lexer::T_ELSE);
  2201.         $scalarExpression = $this->ScalarExpression();
  2202.         $this->match(Lexer::T_END);
  2204.         return new AST\SimpleCaseExpression($caseOperand, $simpleWhenClauses, $scalarExpression);
  2205.     }
  2207.     /**
  2208.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2209.      *
  2210.      * @return WhenClause
  2211.      */
  2212.     public function WhenClause()
  2213.     {
  2214.         $this->match(Lexer::T_WHEN);
  2215.         $conditionalExpression = $this->ConditionalExpression();
  2216.         $this->match(Lexer::T_THEN);
  2218.         return new AST\WhenClause($conditionalExpression, $this->ScalarExpression());
  2219.     }
  2221.     /**
  2222.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2223.      *
  2224.      * @return SimpleWhenClause
  2225.      */
  2226.     public function SimpleWhenClause()
  2227.     {
  2228.         $this->match(Lexer::T_WHEN);
  2229.         $conditionalExpression = $this->ScalarExpression();
  2230.         $this->match(Lexer::T_THEN);
  2232.         return new AST\SimpleWhenClause($conditionalExpression, $this->ScalarExpression());
  2233.     }
  2235.     /**
  2236.      * SelectExpression ::= (
  2237.      *     IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration |
  2238.      *     PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression
  2239.      * ) [["AS"] ["HIDDEN"] AliasResultVariable]
  2240.      *
  2241.      * @return SelectExpression
  2242.      */
  2243.     public function SelectExpression()
  2244.     {
  2245.         $expression    = null;
  2246.         $identVariable = null;
  2247.         $peek          = $this->lexer->glimpse();
  2248.         $lookaheadType = $this->lexer->lookahead['type'];
  2250.         switch (true) {
  2251.             // ScalarExpression (u.name)
  2252.             case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] === Lexer::T_DOT:
  2253.                 $expression = $this->ScalarExpression();
  2254.                 break;
  2256.             // IdentificationVariable (u)
  2257.             case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2258.                 $expression = $identVariable = $this->IdentificationVariable();
  2259.                 break;
  2261.             // CaseExpression (CASE ... or NULLIF(...) or COALESCE(...))
  2262.             case $lookaheadType === Lexer::T_CASE:
  2263.             case $lookaheadType === Lexer::T_COALESCE:
  2264.             case $lookaheadType === Lexer::T_NULLIF:
  2265.                 $expression = $this->CaseExpression();
  2266.                 break;
  2268.             // DQL Function (SUM(u.value) or SUM(u.value) + 1)
  2269.             case $this->isFunction():
  2270.                 $this->lexer->peek(); // "("
  2272.                 switch (true) {
  2273.                     case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2274.                         // SUM(u.id) + COUNT(u.id)
  2275.                         $expression = $this->ScalarExpression();
  2276.                         break;
  2278.                     default:
  2279.                         // IDENTITY(u)
  2280.                         $expression = $this->FunctionDeclaration();
  2281.                         break;
  2282.                 }
  2284.                 break;
  2286.             // PartialObjectExpression (PARTIAL u.{id, name})
  2287.             case $lookaheadType === Lexer::T_PARTIAL:
  2288.                 $expression    = $this->PartialObjectExpression();
  2289.                 $identVariable = $expression->identificationVariable;
  2290.                 break;
  2292.             // Subselect
  2293.             case $lookaheadType === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT:
  2294.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2295.                 $expression = $this->Subselect();
  2296.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2297.                 break;
  2299.             // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2300.             case $lookaheadType === Lexer::T_OPEN_PARENTHESIS:
  2301.             case $lookaheadType === Lexer::T_INTEGER:
  2302.             case $lookaheadType === Lexer::T_STRING:
  2303.             case $lookaheadType === Lexer::T_FLOAT:
  2304.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )
  2305.             case $lookaheadType === Lexer::T_MINUS:
  2306.             case $lookaheadType === Lexer::T_PLUS:
  2307.                 $expression = $this->SimpleArithmeticExpression();
  2308.                 break;
  2310.             // NewObjectExpression (New ClassName(id, name))
  2311.             case $lookaheadType === Lexer::T_NEW:
  2312.                 $expression = $this->NewObjectExpression();
  2313.                 break;
  2315.             default:
  2316.                 $this->syntaxError(
  2317.                     'IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression',
  2318.                     $this->lexer->lookahead
  2319.                 );
  2320.         }
  2322.         // [["AS"] ["HIDDEN"] AliasResultVariable]
  2323.         $mustHaveAliasResultVariable = false;
  2325.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2326.             $this->match(Lexer::T_AS);
  2328.             $mustHaveAliasResultVariable = true;
  2329.         }
  2331.         $hiddenAliasResultVariable = false;
  2333.         if ($this->lexer->isNextToken(Lexer::T_HIDDEN)) {
  2334.             $this->match(Lexer::T_HIDDEN);
  2336.             $hiddenAliasResultVariable = true;
  2337.         }
  2339.         $aliasResultVariable = null;
  2341.         if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2342.             $token               = $this->lexer->lookahead;
  2343.             $aliasResultVariable = $this->AliasResultVariable();
  2345.             // Include AliasResultVariable in query components.
  2346.             $this->queryComponents[$aliasResultVariable] = [
  2347.                 'resultVariable' => $expression,
  2348.                 'nestingLevel'   => $this->nestingLevel,
  2349.                 'token'          => $token,
  2350.             ];
  2351.         }
  2353.         // AST
  2355.         $expr = new AST\SelectExpression($expression, $aliasResultVariable, $hiddenAliasResultVariable);
  2357.         if ($identVariable) {
  2358.             $this->identVariableExpressions[$identVariable] = $expr;
  2359.         }
  2361.         return $expr;
  2362.     }
  2364.     /**
  2365.      * SimpleSelectExpression ::= (
  2366.      *      StateFieldPathExpression | IdentificationVariable | FunctionDeclaration |
  2367.      *      AggregateExpression | "(" Subselect ")" | ScalarExpression
  2368.      * ) [["AS"] AliasResultVariable]
  2369.      *
  2370.      * @return SimpleSelectExpression
  2371.      */
  2372.     public function SimpleSelectExpression()
  2373.     {
  2374.         $peek = $this->lexer->glimpse();
  2376.         switch ($this->lexer->lookahead['type']) {
  2377.             case Lexer::T_IDENTIFIER:
  2378.                 switch (true) {
  2379.                     case $peek['type'] === Lexer::T_DOT:
  2380.                         $expression = $this->StateFieldPathExpression();
  2382.                         return new AST\SimpleSelectExpression($expression);
  2384.                     case $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2385.                         $expression = $this->IdentificationVariable();
  2387.                         return new AST\SimpleSelectExpression($expression);
  2389.                     case $this->isFunction():
  2390.                         // SUM(u.id) + COUNT(u.id)
  2391.                         if ($this->isMathOperator($this->peekBeyondClosingParenthesis())) {
  2392.                             return new AST\SimpleSelectExpression($this->ScalarExpression());
  2393.                         }
  2395.                         // COUNT(u.id)
  2396.                         if ($this->isAggregateFunction($this->lexer->lookahead['type'])) {
  2397.                             return new AST\SimpleSelectExpression($this->AggregateExpression());
  2398.                         }
  2400.                         // IDENTITY(u)
  2401.                         return new AST\SimpleSelectExpression($this->FunctionDeclaration());
  2403.                     default:
  2404.                         // Do nothing
  2405.                 }
  2407.                 break;
  2409.             case Lexer::T_OPEN_PARENTHESIS:
  2410.                 if ($peek['type'] !== Lexer::T_SELECT) {
  2411.                     // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2412.                     $expression = $this->SimpleArithmeticExpression();
  2414.                     return new AST\SimpleSelectExpression($expression);
  2415.                 }
  2417.                 // Subselect
  2418.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2419.                 $expression = $this->Subselect();
  2420.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2422.                 return new AST\SimpleSelectExpression($expression);
  2424.             default:
  2425.                 // Do nothing
  2426.         }
  2428.         $this->lexer->peek();
  2430.         $expression = $this->ScalarExpression();
  2431.         $expr       = new AST\SimpleSelectExpression($expression);
  2433.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2434.             $this->match(Lexer::T_AS);
  2435.         }
  2437.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2438.             $token                             = $this->lexer->lookahead;
  2439.             $resultVariable                    = $this->AliasResultVariable();
  2440.             $expr->fieldIdentificationVariable = $resultVariable;
  2442.             // Include AliasResultVariable in query components.
  2443.             $this->queryComponents[$resultVariable] = [
  2444.                 'resultvariable' => $expr,
  2445.                 'nestingLevel'   => $this->nestingLevel,
  2446.                 'token'          => $token,
  2447.             ];
  2448.         }
  2450.         return $expr;
  2451.     }
  2453.     /**
  2454.      * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
  2455.      *
  2456.      * @return AST\ConditionalExpression|AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2457.      */
  2458.     public function ConditionalExpression()
  2459.     {
  2460.         $conditionalTerms   = [];
  2461.         $conditionalTerms[] = $this->ConditionalTerm();
  2463.         while ($this->lexer->isNextToken(Lexer::T_OR)) {
  2464.             $this->match(Lexer::T_OR);
  2466.             $conditionalTerms[] = $this->ConditionalTerm();
  2467.         }
  2469.         // Phase 1 AST optimization: Prevent AST\ConditionalExpression
  2470.         // if only one AST\ConditionalTerm is defined
  2471.         if (count($conditionalTerms) === 1) {
  2472.             return $conditionalTerms[0];
  2473.         }
  2475.         return new AST\ConditionalExpression($conditionalTerms);
  2476.     }
  2478.     /**
  2479.      * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
  2480.      *
  2481.      * @return AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2482.      */
  2483.     public function ConditionalTerm()
  2484.     {
  2485.         $conditionalFactors   = [];
  2486.         $conditionalFactors[] = $this->ConditionalFactor();
  2488.         while ($this->lexer->isNextToken(Lexer::T_AND)) {
  2489.             $this->match(Lexer::T_AND);
  2491.             $conditionalFactors[] = $this->ConditionalFactor();
  2492.         }
  2494.         // Phase 1 AST optimization: Prevent AST\ConditionalTerm
  2495.         // if only one AST\ConditionalFactor is defined
  2496.         if (count($conditionalFactors) === 1) {
  2497.             return $conditionalFactors[0];
  2498.         }
  2500.         return new AST\ConditionalTerm($conditionalFactors);
  2501.     }
  2503.     /**
  2504.      * ConditionalFactor ::= ["NOT"] ConditionalPrimary
  2505.      *
  2506.      * @return AST\ConditionalFactor|AST\ConditionalPrimary
  2507.      */
  2508.     public function ConditionalFactor()
  2509.     {
  2510.         $not = false;
  2512.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2513.             $this->match(Lexer::T_NOT);
  2515.             $not = true;
  2516.         }
  2518.         $conditionalPrimary = $this->ConditionalPrimary();
  2520.         // Phase 1 AST optimization: Prevent AST\ConditionalFactor
  2521.         // if only one AST\ConditionalPrimary is defined
  2522.         if (! $not) {
  2523.             return $conditionalPrimary;
  2524.         }
  2526.         $conditionalFactor      = new AST\ConditionalFactor($conditionalPrimary);
  2527.         $conditionalFactor->not = $not;
  2529.         return $conditionalFactor;
  2530.     }
  2532.     /**
  2533.      * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
  2534.      *
  2535.      * @return ConditionalPrimary
  2536.      */
  2537.     public function ConditionalPrimary()
  2538.     {
  2539.         $condPrimary = new AST\ConditionalPrimary();
  2541.         if (! $this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2542.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2544.             return $condPrimary;
  2545.         }
  2547.         // Peek beyond the matching closing parenthesis ')'
  2548.         $peek = $this->peekBeyondClosingParenthesis();
  2550.         if (
  2551.             $peek !== null && (
  2552.             in_array($peek['value'], ['=', '<', '<=', '<>', '>', '>=', '!=']) ||
  2553.             in_array($peek['type'], [Lexer::T_NOT, Lexer::T_BETWEEN, Lexer::T_LIKE, Lexer::T_IN, Lexer::T_IS, Lexer::T_EXISTS]) ||
  2554.             $this->isMathOperator($peek)
  2555.             )
  2556.         ) {
  2557.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2559.             return $condPrimary;
  2560.         }
  2562.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2563.         $condPrimary->conditionalExpression = $this->ConditionalExpression();
  2564.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2566.         return $condPrimary;
  2567.     }
  2569.     /**
  2570.      * SimpleConditionalExpression ::=
  2571.      *      ComparisonExpression | BetweenExpression | LikeExpression |
  2572.      *      InExpression | NullComparisonExpression | ExistsExpression |
  2573.      *      EmptyCollectionComparisonExpression | CollectionMemberExpression |
  2574.      *      InstanceOfExpression
  2575.      *
  2576.      * @return Node
  2577.      */
  2578.     public function SimpleConditionalExpression()
  2579.     {
  2580.         if ($this->lexer->isNextToken(Lexer::T_EXISTS)) {
  2581.             return $this->ExistsExpression();
  2582.         }
  2584.         $token     = $this->lexer->lookahead;
  2585.         $peek      = $this->lexer->glimpse();
  2586.         $lookahead = $token;
  2588.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2589.             $token = $this->lexer->glimpse();
  2590.         }
  2592.         if ($token['type'] === Lexer::T_IDENTIFIER || $token['type'] === Lexer::T_INPUT_PARAMETER || $this->isFunction()) {
  2593.             // Peek beyond the matching closing parenthesis.
  2594.             $beyond = $this->lexer->peek();
  2596.             switch ($peek['value']) {
  2597.                 case '(':
  2598.                     // Peeks beyond the matched closing parenthesis.
  2599.                     $token = $this->peekBeyondClosingParenthesis(false);
  2601.                     if ($token['type'] === Lexer::T_NOT) {
  2602.                         $token = $this->lexer->peek();
  2603.                     }
  2605.                     if ($token['type'] === Lexer::T_IS) {
  2606.                         $lookahead = $this->lexer->peek();
  2607.                     }
  2609.                     break;
  2611.                 default:
  2612.                     // Peek beyond the PathExpression or InputParameter.
  2613.                     $token = $beyond;
  2615.                     while ($token['value'] === '.') {
  2616.                         $this->lexer->peek();
  2618.                         $token = $this->lexer->peek();
  2619.                     }
  2621.                     // Also peek beyond a NOT if there is one.
  2622.                     if ($token['type'] === Lexer::T_NOT) {
  2623.                         $token = $this->lexer->peek();
  2624.                     }
  2626.                     // We need to go even further in case of IS (differentiate between NULL and EMPTY)
  2627.                     $lookahead = $this->lexer->peek();
  2628.             }
  2630.             // Also peek beyond a NOT if there is one.
  2631.             if ($lookahead['type'] === Lexer::T_NOT) {
  2632.                 $lookahead = $this->lexer->peek();
  2633.             }
  2635.             $this->lexer->resetPeek();
  2636.         }
  2638.         if ($token['type'] === Lexer::T_BETWEEN) {
  2639.             return $this->BetweenExpression();
  2640.         }
  2642.         if ($token['type'] === Lexer::T_LIKE) {
  2643.             return $this->LikeExpression();
  2644.         }
  2646.         if ($token['type'] === Lexer::T_IN) {
  2647.             return $this->InExpression();
  2648.         }
  2650.         if ($token['type'] === Lexer::T_INSTANCE) {
  2651.             return $this->InstanceOfExpression();
  2652.         }
  2654.         if ($token['type'] === Lexer::T_MEMBER) {
  2655.             return $this->CollectionMemberExpression();
  2656.         }
  2658.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_NULL) {
  2659.             return $this->NullComparisonExpression();
  2660.         }
  2662.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_EMPTY) {
  2663.             return $this->EmptyCollectionComparisonExpression();
  2664.         }
  2666.         return $this->ComparisonExpression();
  2667.     }
  2669.     /**
  2670.      * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
  2671.      *
  2672.      * @return EmptyCollectionComparisonExpression
  2673.      */
  2674.     public function EmptyCollectionComparisonExpression()
  2675.     {
  2676.         $emptyCollectionCompExpr = new AST\EmptyCollectionComparisonExpression(
  2677.             $this->CollectionValuedPathExpression()
  2678.         );
  2679.         $this->match(Lexer::T_IS);
  2681.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2682.             $this->match(Lexer::T_NOT);
  2683.             $emptyCollectionCompExpr->not = true;
  2684.         }
  2686.         $this->match(Lexer::T_EMPTY);
  2688.         return $emptyCollectionCompExpr;
  2689.     }
  2691.     /**
  2692.      * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
  2693.      *
  2694.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2695.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2696.      *
  2697.      * @return CollectionMemberExpression
  2698.      */
  2699.     public function CollectionMemberExpression()
  2700.     {
  2701.         $not        = false;
  2702.         $entityExpr = $this->EntityExpression();
  2704.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2705.             $this->match(Lexer::T_NOT);
  2707.             $not = true;
  2708.         }
  2710.         $this->match(Lexer::T_MEMBER);
  2712.         if ($this->lexer->isNextToken(Lexer::T_OF)) {
  2713.             $this->match(Lexer::T_OF);
  2714.         }
  2716.         $collMemberExpr      = new AST\CollectionMemberExpression(
  2717.             $entityExpr,
  2718.             $this->CollectionValuedPathExpression()
  2719.         );
  2720.         $collMemberExpr->not = $not;
  2722.         return $collMemberExpr;
  2723.     }
  2725.     /**
  2726.      * Literal ::= string | char | integer | float | boolean
  2727.      *
  2728.      * @return Literal
  2729.      */
  2730.     public function Literal()
  2731.     {
  2732.         switch ($this->lexer->lookahead['type']) {
  2733.             case Lexer::T_STRING:
  2734.                 $this->match(Lexer::T_STRING);
  2736.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  2738.             case Lexer::T_INTEGER:
  2739.             case Lexer::T_FLOAT:
  2740.                 $this->match(
  2741.                     $this->lexer->isNextToken(Lexer::T_INTEGER) ? Lexer::T_INTEGER : Lexer::T_FLOAT
  2742.                 );
  2744.                 return new AST\Literal(AST\Literal::NUMERIC, $this->lexer->token['value']);
  2746.             case Lexer::T_TRUE:
  2747.             case Lexer::T_FALSE:
  2748.                 $this->match(
  2749.                     $this->lexer->isNextToken(Lexer::T_TRUE) ? Lexer::T_TRUE : Lexer::T_FALSE
  2750.                 );
  2752.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2754.             default:
  2755.                 $this->syntaxError('Literal');
  2756.         }
  2757.     }
  2759.     /**
  2760.      * InParameter ::= Literal | InputParameter
  2761.      *
  2762.      * @return AST\InputParameter|AST\Literal
  2763.      */
  2764.     public function InParameter()
  2765.     {
  2766.         if ($this->lexer->lookahead['type'] === Lexer::T_INPUT_PARAMETER) {
  2767.             return $this->InputParameter();
  2768.         }
  2770.         return $this->Literal();
  2771.     }
  2773.     /**
  2774.      * InputParameter ::= PositionalParameter | NamedParameter
  2775.      *
  2776.      * @return InputParameter
  2777.      */
  2778.     public function InputParameter()
  2779.     {
  2780.         $this->match(Lexer::T_INPUT_PARAMETER);
  2782.         return new AST\InputParameter($this->lexer->token['value']);
  2783.     }
  2785.     /**
  2786.      * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
  2787.      *
  2788.      * @return ArithmeticExpression
  2789.      */
  2790.     public function ArithmeticExpression()
  2791.     {
  2792.         $expr = new AST\ArithmeticExpression();
  2794.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2795.             $peek = $this->lexer->glimpse();
  2797.             if ($peek['type'] === Lexer::T_SELECT) {
  2798.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2799.                 $expr->subselect = $this->Subselect();
  2800.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2802.                 return $expr;
  2803.             }
  2804.         }
  2806.         $expr->simpleArithmeticExpression = $this->SimpleArithmeticExpression();
  2808.         return $expr;
  2809.     }
  2811.     /**
  2812.      * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
  2813.      *
  2814.      * @return SimpleArithmeticExpression
  2815.      */
  2816.     public function SimpleArithmeticExpression()
  2817.     {
  2818.         $terms   = [];
  2819.         $terms[] = $this->ArithmeticTerm();
  2821.         while (($isPlus = $this->lexer->isNextToken(Lexer::T_PLUS)) || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2822.             $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2824.             $terms[] = $this->lexer->token['value'];
  2825.             $terms[] = $this->ArithmeticTerm();
  2826.         }
  2828.         // Phase 1 AST optimization: Prevent AST\SimpleArithmeticExpression
  2829.         // if only one AST\ArithmeticTerm is defined
  2830.         if (count($terms) === 1) {
  2831.             return $terms[0];
  2832.         }
  2834.         return new AST\SimpleArithmeticExpression($terms);
  2835.     }
  2837.     /**
  2838.      * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
  2839.      *
  2840.      * @return ArithmeticTerm
  2841.      */
  2842.     public function ArithmeticTerm()
  2843.     {
  2844.         $factors   = [];
  2845.         $factors[] = $this->ArithmeticFactor();
  2847.         while (($isMult = $this->lexer->isNextToken(Lexer::T_MULTIPLY)) || $this->lexer->isNextToken(Lexer::T_DIVIDE)) {
  2848.             $this->match($isMult ? Lexer::T_MULTIPLY : Lexer::T_DIVIDE);
  2850.             $factors[] = $this->lexer->token['value'];
  2851.             $factors[] = $this->ArithmeticFactor();
  2852.         }
  2854.         // Phase 1 AST optimization: Prevent AST\ArithmeticTerm
  2855.         // if only one AST\ArithmeticFactor is defined
  2856.         if (count($factors) === 1) {
  2857.             return $factors[0];
  2858.         }
  2860.         return new AST\ArithmeticTerm($factors);
  2861.     }
  2863.     /**
  2864.      * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
  2865.      *
  2866.      * @return ArithmeticFactor
  2867.      */
  2868.     public function ArithmeticFactor()
  2869.     {
  2870.         $sign = null;
  2872.         $isPlus = $this->lexer->isNextToken(Lexer::T_PLUS);
  2873.         if ($isPlus || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2874.             $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2875.             $sign = $isPlus;
  2876.         }
  2878.         $primary = $this->ArithmeticPrimary();
  2880.         // Phase 1 AST optimization: Prevent AST\ArithmeticFactor
  2881.         // if only one AST\ArithmeticPrimary is defined
  2882.         if ($sign === null) {
  2883.             return $primary;
  2884.         }
  2886.         return new AST\ArithmeticFactor($primary, $sign);
  2887.     }
  2889.     /**
  2890.      * ArithmeticPrimary ::= SingleValuedPathExpression | Literal | ParenthesisExpression
  2891.      *          | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings
  2892.      *          | FunctionsReturningDatetime | IdentificationVariable | ResultVariable
  2893.      *          | InputParameter | CaseExpression
  2894.      *
  2895.      * @return Node|string
  2896.      */
  2897.     public function ArithmeticPrimary()
  2898.     {
  2899.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2900.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2902.             $expr = $this->SimpleArithmeticExpression();
  2904.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2906.             return new AST\ParenthesisExpression($expr);
  2907.         }
  2909.         switch ($this->lexer->lookahead['type']) {
  2910.             case Lexer::T_COALESCE:
  2911.             case Lexer::T_NULLIF:
  2912.             case Lexer::T_CASE:
  2913.                 return $this->CaseExpression();
  2915.             case Lexer::T_IDENTIFIER:
  2916.                 $peek = $this->lexer->glimpse();
  2918.                 if ($peek !== null && $peek['value'] === '(') {
  2919.                     return $this->FunctionDeclaration();
  2920.                 }
  2922.                 if ($peek !== null && $peek['value'] === '.') {
  2923.                     return $this->SingleValuedPathExpression();
  2924.                 }
  2926.                 if (isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])) {
  2927.                     return $this->ResultVariable();
  2928.                 }
  2930.                 return $this->StateFieldPathExpression();
  2932.             case Lexer::T_INPUT_PARAMETER:
  2933.                 return $this->InputParameter();
  2935.             default:
  2936.                 $peek = $this->lexer->glimpse();
  2938.                 if ($peek !== null && $peek['value'] === '(') {
  2939.                     return $this->FunctionDeclaration();
  2940.                 }
  2942.                 return $this->Literal();
  2943.         }
  2944.     }
  2946.     /**
  2947.      * StringExpression ::= StringPrimary | ResultVariable | "(" Subselect ")"
  2948.      *
  2949.      * @return Subselect|string
  2950.      */
  2951.     public function StringExpression()
  2952.     {
  2953.         $peek = $this->lexer->glimpse();
  2955.         // Subselect
  2956.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $peek['type'] === Lexer::T_SELECT) {
  2957.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2958.             $expr = $this->Subselect();
  2959.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2961.             return $expr;
  2962.         }
  2964.         // ResultVariable (string)
  2965.         if (
  2966.             $this->lexer->isNextToken(Lexer::T_IDENTIFIER) &&
  2967.             isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])
  2968.         ) {
  2969.             return $this->ResultVariable();
  2970.         }
  2972.         return $this->StringPrimary();
  2973.     }
  2975.     /**
  2976.      * StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression
  2977.      *
  2978.      * @return Node
  2979.      */
  2980.     public function StringPrimary()
  2981.     {
  2982.         $lookaheadType = $this->lexer->lookahead['type'];
  2984.         switch ($lookaheadType) {
  2985.             case Lexer::T_IDENTIFIER:
  2986.                 $peek = $this->lexer->glimpse();
  2988.                 if ($peek['value'] === '.') {
  2989.                     return $this->StateFieldPathExpression();
  2990.                 }
  2992.                 if ($peek['value'] === '(') {
  2993.                     // do NOT directly go to FunctionsReturningString() because it doesn't check for custom functions.
  2994.                     return $this->FunctionDeclaration();
  2995.                 }
  2997.                 $this->syntaxError("'.' or '('");
  2998.                 break;
  3000.             case Lexer::T_STRING:
  3001.                 $this->match(Lexer::T_STRING);
  3003.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3005.             case Lexer::T_INPUT_PARAMETER:
  3006.                 return $this->InputParameter();
  3008.             case Lexer::T_CASE:
  3009.             case Lexer::T_COALESCE:
  3010.             case Lexer::T_NULLIF:
  3011.                 return $this->CaseExpression();
  3013.             default:
  3014.                 if ($this->isAggregateFunction($lookaheadType)) {
  3015.                     return $this->AggregateExpression();
  3016.                 }
  3017.         }
  3019.         $this->syntaxError(
  3020.             'StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression'
  3021.         );
  3022.     }
  3024.     /**
  3025.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  3026.      *
  3027.      * @return AST\InputParameter|PathExpression
  3028.      */
  3029.     public function EntityExpression()
  3030.     {
  3031.         $glimpse = $this->lexer->glimpse();
  3033.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER) && $glimpse['value'] === '.') {
  3034.             return $this->SingleValuedAssociationPathExpression();
  3035.         }
  3037.         return $this->SimpleEntityExpression();
  3038.     }
  3040.     /**
  3041.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  3042.      *
  3043.      * @return AST\InputParameter|AST\PathExpression
  3044.      */
  3045.     public function SimpleEntityExpression()
  3046.     {
  3047.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3048.             return $this->InputParameter();
  3049.         }
  3051.         return $this->StateFieldPathExpression();
  3052.     }
  3054.     /**
  3055.      * AggregateExpression ::=
  3056.      *  ("AVG" | "MAX" | "MIN" | "SUM" | "COUNT") "(" ["DISTINCT"] SimpleArithmeticExpression ")"
  3057.      *
  3058.      * @return AggregateExpression
  3059.      */
  3060.     public function AggregateExpression()
  3061.     {
  3062.         $lookaheadType = $this->lexer->lookahead['type'];
  3063.         $isDistinct    = false;
  3065.         if (! in_array($lookaheadType, [Lexer::T_COUNT, Lexer::T_AVG, Lexer::T_MAX, Lexer::T_MIN, Lexer::T_SUM])) {
  3066.             $this->syntaxError('One of: MAX, MIN, AVG, SUM, COUNT');
  3067.         }
  3069.         $this->match($lookaheadType);
  3070.         $functionName = $this->lexer->token['value'];
  3071.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3073.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  3074.             $this->match(Lexer::T_DISTINCT);
  3075.             $isDistinct = true;
  3076.         }
  3078.         $pathExp = $this->SimpleArithmeticExpression();
  3080.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3082.         return new AST\AggregateExpression($functionName, $pathExp, $isDistinct);
  3083.     }
  3085.     /**
  3086.      * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
  3087.      *
  3088.      * @return QuantifiedExpression
  3089.      */
  3090.     public function QuantifiedExpression()
  3091.     {
  3092.         $lookaheadType = $this->lexer->lookahead['type'];
  3093.         $value         = $this->lexer->lookahead['value'];
  3095.         if (! in_array($lookaheadType, [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME])) {
  3096.             $this->syntaxError('ALL, ANY or SOME');
  3097.         }
  3099.         $this->match($lookaheadType);
  3100.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3102.         $qExpr       = new AST\QuantifiedExpression($this->Subselect());
  3103.         $qExpr->type = $value;
  3105.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3107.         return $qExpr;
  3108.     }
  3110.     /**
  3111.      * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
  3112.      *
  3113.      * @return BetweenExpression
  3114.      */
  3115.     public function BetweenExpression()
  3116.     {
  3117.         $not        = false;
  3118.         $arithExpr1 = $this->ArithmeticExpression();
  3120.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3121.             $this->match(Lexer::T_NOT);
  3122.             $not = true;
  3123.         }
  3125.         $this->match(Lexer::T_BETWEEN);
  3126.         $arithExpr2 = $this->ArithmeticExpression();
  3127.         $this->match(Lexer::T_AND);
  3128.         $arithExpr3 = $this->ArithmeticExpression();
  3130.         $betweenExpr      = new AST\BetweenExpression($arithExpr1, $arithExpr2, $arithExpr3);
  3131.         $betweenExpr->not = $not;
  3133.         return $betweenExpr;
  3134.     }
  3136.     /**
  3137.      * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )
  3138.      *
  3139.      * @return ComparisonExpression
  3140.      */
  3141.     public function ComparisonExpression()
  3142.     {
  3143.         $this->lexer->glimpse();
  3145.         $leftExpr  = $this->ArithmeticExpression();
  3146.         $operator  = $this->ComparisonOperator();
  3147.         $rightExpr = $this->isNextAllAnySome()
  3148.             ? $this->QuantifiedExpression()
  3149.             : $this->ArithmeticExpression();
  3151.         return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
  3152.     }
  3154.     /**
  3155.      * InExpression ::= SingleValuedPathExpression ["NOT"] "IN" "(" (InParameter {"," InParameter}* | Subselect) ")"
  3156.      *
  3157.      * @return InExpression
  3158.      */
  3159.     public function InExpression()
  3160.     {
  3161.         $inExpression = new AST\InExpression($this->ArithmeticExpression());
  3163.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3164.             $this->match(Lexer::T_NOT);
  3165.             $inExpression->not = true;
  3166.         }
  3168.         $this->match(Lexer::T_IN);
  3169.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3171.         if ($this->lexer->isNextToken(Lexer::T_SELECT)) {
  3172.             $inExpression->subselect = $this->Subselect();
  3173.         } else {
  3174.             $literals   = [];
  3175.             $literals[] = $this->InParameter();
  3177.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3178.                 $this->match(Lexer::T_COMMA);
  3179.                 $literals[] = $this->InParameter();
  3180.             }
  3182.             $inExpression->literals = $literals;
  3183.         }
  3185.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3187.         return $inExpression;
  3188.     }
  3190.     /**
  3191.      * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
  3192.      *
  3193.      * @return InstanceOfExpression
  3194.      */
  3195.     public function InstanceOfExpression()
  3196.     {
  3197.         $instanceOfExpression = new AST\InstanceOfExpression($this->IdentificationVariable());
  3199.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3200.             $this->match(Lexer::T_NOT);
  3201.             $instanceOfExpression->not = true;
  3202.         }
  3204.         $this->match(Lexer::T_INSTANCE);
  3205.         $this->match(Lexer::T_OF);
  3207.         $exprValues = [];
  3209.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  3210.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  3212.             $exprValues[] = $this->InstanceOfParameter();
  3214.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3215.                 $this->match(Lexer::T_COMMA);
  3217.                 $exprValues[] = $this->InstanceOfParameter();
  3218.             }
  3220.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3222.             $instanceOfExpression->value = $exprValues;
  3224.             return $instanceOfExpression;
  3225.         }
  3227.         $exprValues[] = $this->InstanceOfParameter();
  3229.         $instanceOfExpression->value = $exprValues;
  3231.         return $instanceOfExpression;
  3232.     }
  3234.     /**
  3235.      * InstanceOfParameter ::= AbstractSchemaName | InputParameter
  3236.      *
  3237.      * @return mixed
  3238.      */
  3239.     public function InstanceOfParameter()
  3240.     {
  3241.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3242.             $this->match(Lexer::T_INPUT_PARAMETER);
  3244.             return new AST\InputParameter($this->lexer->token['value']);
  3245.         }
  3247.         $abstractSchemaName = $this->AbstractSchemaName();
  3249.         $this->validateAbstractSchemaName($abstractSchemaName);
  3251.         return $abstractSchemaName;
  3252.     }
  3254.     /**
  3255.      * LikeExpression ::= StringExpression ["NOT"] "LIKE" StringPrimary ["ESCAPE" char]
  3256.      *
  3257.      * @return LikeExpression
  3258.      */
  3259.     public function LikeExpression()
  3260.     {
  3261.         $stringExpr = $this->StringExpression();
  3262.         $not        = false;
  3264.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3265.             $this->match(Lexer::T_NOT);
  3266.             $not = true;
  3267.         }
  3269.         $this->match(Lexer::T_LIKE);
  3271.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3272.             $this->match(Lexer::T_INPUT_PARAMETER);
  3273.             $stringPattern = new AST\InputParameter($this->lexer->token['value']);
  3274.         } else {
  3275.             $stringPattern = $this->StringPrimary();
  3276.         }
  3278.         $escapeChar = null;
  3280.         if ($this->lexer->lookahead !== null && $this->lexer->lookahead['type'] === Lexer::T_ESCAPE) {
  3281.             $this->match(Lexer::T_ESCAPE);
  3282.             $this->match(Lexer::T_STRING);
  3284.             $escapeChar = new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3285.         }
  3287.         $likeExpr      = new AST\LikeExpression($stringExpr, $stringPattern, $escapeChar);
  3288.         $likeExpr->not = $not;
  3290.         return $likeExpr;
  3291.     }
  3293.     /**
  3294.      * NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) "IS" ["NOT"] "NULL"
  3295.      *
  3296.      * @return NullComparisonExpression
  3297.      */
  3298.     public function NullComparisonExpression()
  3299.     {
  3300.         switch (true) {
  3301.             case $this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER):
  3302.                 $this->match(Lexer::T_INPUT_PARAMETER);
  3304.                 $expr = new AST\InputParameter($this->lexer->token['value']);
  3305.                 break;
  3307.             case $this->lexer->isNextToken(Lexer::T_NULLIF):
  3308.                 $expr = $this->NullIfExpression();
  3309.                 break;
  3311.             case $this->lexer->isNextToken(Lexer::T_COALESCE):
  3312.                 $expr = $this->CoalesceExpression();
  3313.                 break;
  3315.             case $this->isFunction():
  3316.                 $expr = $this->FunctionDeclaration();
  3317.                 break;
  3319.             default:
  3320.                 // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  3321.                 $glimpse = $this->lexer->glimpse();
  3323.                 if ($glimpse['type'] === Lexer::T_DOT) {
  3324.                     $expr = $this->SingleValuedPathExpression();
  3326.                     // Leave switch statement
  3327.                     break;
  3328.                 }
  3330.                 $lookaheadValue = $this->lexer->lookahead['value'];
  3332.                 // Validate existing component
  3333.                 if (! isset($this->queryComponents[$lookaheadValue])) {
  3334.                     $this->semanticalError('Cannot add having condition on undefined result variable.');
  3335.                 }
  3337.                 // Validate SingleValuedPathExpression (ie.: "product")
  3338.                 if (isset($this->queryComponents[$lookaheadValue]['metadata'])) {
  3339.                     $expr = $this->SingleValuedPathExpression();
  3340.                     break;
  3341.                 }
  3343.                 // Validating ResultVariable
  3344.                 if (! isset($this->queryComponents[$lookaheadValue]['resultVariable'])) {
  3345.                     $this->semanticalError('Cannot add having condition on a non result variable.');
  3346.                 }
  3348.                 $expr = $this->ResultVariable();
  3349.                 break;
  3350.         }
  3352.         $nullCompExpr = new AST\NullComparisonExpression($expr);
  3354.         $this->match(Lexer::T_IS);
  3356.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3357.             $this->match(Lexer::T_NOT);
  3359.             $nullCompExpr->not = true;
  3360.         }
  3362.         $this->match(Lexer::T_NULL);
  3364.         return $nullCompExpr;
  3365.     }
  3367.     /**
  3368.      * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
  3369.      *
  3370.      * @return ExistsExpression
  3371.      */
  3372.     public function ExistsExpression()
  3373.     {
  3374.         $not = false;
  3376.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3377.             $this->match(Lexer::T_NOT);
  3378.             $not = true;
  3379.         }
  3381.         $this->match(Lexer::T_EXISTS);
  3382.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3384.         $existsExpression      = new AST\ExistsExpression($this->Subselect());
  3385.         $existsExpression->not = $not;
  3387.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3389.         return $existsExpression;
  3390.     }
  3392.     /**
  3393.      * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
  3394.      *
  3395.      * @return string
  3396.      */
  3397.     public function ComparisonOperator()
  3398.     {
  3399.         switch ($this->lexer->lookahead['value']) {
  3400.             case '=':
  3401.                 $this->match(Lexer::T_EQUALS);
  3403.                 return '=';
  3405.             case '<':
  3406.                 $this->match(Lexer::T_LOWER_THAN);
  3407.                 $operator = '<';
  3409.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3410.                     $this->match(Lexer::T_EQUALS);
  3411.                     $operator .= '=';
  3412.                 } elseif ($this->lexer->isNextToken(Lexer::T_GREATER_THAN)) {
  3413.                     $this->match(Lexer::T_GREATER_THAN);
  3414.                     $operator .= '>';
  3415.                 }
  3417.                 return $operator;
  3419.             case '>':
  3420.                 $this->match(Lexer::T_GREATER_THAN);
  3421.                 $operator = '>';
  3423.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3424.                     $this->match(Lexer::T_EQUALS);
  3425.                     $operator .= '=';
  3426.                 }
  3428.                 return $operator;
  3430.             case '!':
  3431.                 $this->match(Lexer::T_NEGATE);
  3432.                 $this->match(Lexer::T_EQUALS);
  3434.                 return '<>';
  3436.             default:
  3437.                 $this->syntaxError('=, <, <=, <>, >, >=, !=');
  3438.         }
  3439.     }
  3441.     /**
  3442.      * FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDatetime
  3443.      *
  3444.      * @return FunctionNode
  3445.      */
  3446.     public function FunctionDeclaration()
  3447.     {
  3448.         $token    = $this->lexer->lookahead;
  3449.         $funcName = strtolower($token['value']);
  3451.         $customFunctionDeclaration = $this->CustomFunctionDeclaration();
  3453.         // Check for custom functions functions first!
  3454.         switch (true) {
  3455.             case $customFunctionDeclaration !== null:
  3456.                 return $customFunctionDeclaration;
  3458.             case isset(self::$stringFunctions[$funcName]):
  3459.                 return $this->FunctionsReturningStrings();
  3461.             case isset(self::$numericFunctions[$funcName]):
  3462.                 return $this->FunctionsReturningNumerics();
  3464.             case isset(self::$datetimeFunctions[$funcName]):
  3465.                 return $this->FunctionsReturningDatetime();
  3467.             default:
  3468.                 $this->syntaxError('known function', $token);
  3469.         }
  3470.     }
  3472.     /**
  3473.      * Helper function for FunctionDeclaration grammar rule.
  3474.      *
  3475.      * @return FunctionNode
  3476.      */
  3477.     private function CustomFunctionDeclaration()
  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.         $function = is_string($functionClass)
  3535.             ? new $functionClass($functionName)
  3536.             : call_user_func($functionClass, $functionName);
  3538.         $function->parse($this);
  3540.         return $function;
  3541.     }
  3543.     /**
  3544.      * FunctionsReturningDateTime ::=
  3545.      *     "CURRENT_DATE" |
  3546.      *     "CURRENT_TIME" |
  3547.      *     "CURRENT_TIMESTAMP" |
  3548.      *     "DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")" |
  3549.      *     "DATE_SUB" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
  3550.      *
  3551.      * @return FunctionNode
  3552.      */
  3553.     public function FunctionsReturningDatetime()
  3554.     {
  3555.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3556.         $funcClass     = self::$datetimeFunctions[$funcNameLower];
  3558.         $function = new $funcClass($funcNameLower);
  3559.         $function->parse($this);
  3561.         return $function;
  3562.     }
  3564.     /**
  3565.      * @return FunctionNode
  3566.      */
  3567.     public function CustomFunctionsReturningDatetime()
  3568.     {
  3569.         // getCustomDatetimeFunction is case-insensitive
  3570.         $functionName  = $this->lexer->lookahead['value'];
  3571.         $functionClass = $this->em->getConfiguration()->getCustomDatetimeFunction($functionName);
  3573.         $function = is_string($functionClass)
  3574.             ? new $functionClass($functionName)
  3575.             : call_user_func($functionClass, $functionName);
  3577.         $function->parse($this);
  3579.         return $function;
  3580.     }
  3582.     /**
  3583.      * FunctionsReturningStrings ::=
  3584.      *   "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary}* ")" |
  3585.      *   "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3586.      *   "TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")" |
  3587.      *   "LOWER" "(" StringPrimary ")" |
  3588.      *   "UPPER" "(" StringPrimary ")" |
  3589.      *   "IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
  3590.      *
  3591.      * @return FunctionNode
  3592.      */
  3593.     public function FunctionsReturningStrings()
  3594.     {
  3595.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3596.         $funcClass     = self::$stringFunctions[$funcNameLower];
  3598.         $function = new $funcClass($funcNameLower);
  3599.         $function->parse($this);
  3601.         return $function;
  3602.     }
  3604.     /**
  3605.      * @return FunctionNode
  3606.      */
  3607.     public function CustomFunctionsReturningStrings()
  3608.     {
  3609.         // getCustomStringFunction is case-insensitive
  3610.         $functionName  = $this->lexer->lookahead['value'];
  3611.         $functionClass = $this->em->getConfiguration()->getCustomStringFunction($functionName);
  3613.         $function = is_string($functionClass)
  3614.             ? new $functionClass($functionName)
  3615.             : call_user_func($functionClass, $functionName);
  3617.         $function->parse($this);
  3619.         return $function;
  3620.     }
  3621. }