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

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\ORM\Query;
  22. use Doctrine\ORM\Mapping\ClassMetadata;
  23. use Doctrine\ORM\Query;
  24. use Doctrine\ORM\Query\AST\DeleteStatement;
  25. use Doctrine\ORM\Query\AST\Functions;
  26. use Doctrine\ORM\Query\AST\IdentificationVariableDeclaration;
  27. use Doctrine\ORM\Query\AST\PathExpression;
  28. use Doctrine\ORM\Query\AST\SelectStatement;
  29. use Doctrine\ORM\Query\AST\Subselect;
  30. use Doctrine\ORM\Query\AST\SubselectIdentificationVariableDeclaration;
  31. use Doctrine\ORM\Query\AST\UpdateStatement;
  32. use function assert;
  33. use function in_array;
  34. use function strpos;
  36. /**
  37.  * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  38.  * Parses a DQL query, reports any errors in it, and generates an AST.
  39.  *
  40.  * @since   2.0
  41.  * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
  42.  * @author  Jonathan Wage <jonwage@gmail.com>
  43.  * @author  Roman Borschel <roman@code-factory.org>
  44.  * @author  Janne Vanhala <jpvanhal@cc.hut.fi>
  45.  * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
  46.  */
  47. class Parser
  48. {
  49.     /**
  50.      * READ-ONLY: Maps BUILT-IN string function names to AST class names.
  51.      *
  52.      * @var array
  53.      *
  54.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  55.      */
  56.     private static $_STRING_FUNCTIONS = [
  57.         'concat'    => Functions\ConcatFunction::class,
  58.         'substring' => Functions\SubstringFunction::class,
  59.         'trim'      => Functions\TrimFunction::class,
  60.         'lower'     => Functions\LowerFunction::class,
  61.         'upper'     => Functions\UpperFunction::class,
  62.         'identity'  => Functions\IdentityFunction::class,
  63.     ];
  65.     /**
  66.      * READ-ONLY: Maps BUILT-IN numeric function names to AST class names.
  67.      *
  68.      * @var array
  69.      *
  70.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  71.      */
  72.     private static $_NUMERIC_FUNCTIONS = [
  73.         'length'    => Functions\LengthFunction::class,
  74.         'locate'    => Functions\LocateFunction::class,
  75.         'abs'       => Functions\AbsFunction::class,
  76.         'sqrt'      => Functions\SqrtFunction::class,
  77.         'mod'       => Functions\ModFunction::class,
  78.         'size'      => Functions\SizeFunction::class,
  79.         'date_diff' => Functions\DateDiffFunction::class,
  80.         'bit_and'   => Functions\BitAndFunction::class,
  81.         'bit_or'    => Functions\BitOrFunction::class,
  83.         // Aggregate functions
  84.         'min'       => Functions\MinFunction::class,
  85.         'max'       => Functions\MaxFunction::class,
  86.         'avg'       => Functions\AvgFunction::class,
  87.         'sum'       => Functions\SumFunction::class,
  88.         'count'     => Functions\CountFunction::class,
  89.     ];
  91.     /**
  92.      * READ-ONLY: Maps BUILT-IN datetime function names to AST class names.
  93.      *
  94.      * @var array
  95.      *
  96.      * @psalm-var array<string, class-string<Functions\FunctionNode>>
  97.      */
  98.     private static $_DATETIME_FUNCTIONS = [
  99.         'current_date'      => Functions\CurrentDateFunction::class,
  100.         'current_time'      => Functions\CurrentTimeFunction::class,
  101.         'current_timestamp' => Functions\CurrentTimestampFunction::class,
  102.         'date_add'          => Functions\DateAddFunction::class,
  103.         'date_sub'          => Functions\DateSubFunction::class,
  104.     ];
  106.     /*
  107.      * Expressions that were encountered during parsing of identifiers and expressions
  108.      * and still need to be validated.
  109.      */
  111.     /**
  112.      * @var array
  113.      */
  114.     private $deferredIdentificationVariables = [];
  116.     /**
  117.      * @var array
  118.      */
  119.     private $deferredPartialObjectExpressions = [];
  121.     /**
  122.      * @var array
  123.      */
  124.     private $deferredPathExpressions = [];
  126.     /**
  127.      * @var array
  128.      */
  129.     private $deferredResultVariables = [];
  131.     /**
  132.      * @var array
  133.      */
  134.     private $deferredNewObjectExpressions = [];
  136.     /**
  137.      * The lexer.
  138.      *
  139.      * @var \Doctrine\ORM\Query\Lexer
  140.      */
  141.     private $lexer;
  143.     /**
  144.      * The parser result.
  145.      *
  146.      * @var \Doctrine\ORM\Query\ParserResult
  147.      */
  148.     private $parserResult;
  150.     /**
  151.      * The EntityManager.
  152.      *
  153.      * @var \Doctrine\ORM\EntityManager
  154.      */
  155.     private $em;
  157.     /**
  158.      * The Query to parse.
  159.      *
  160.      * @var Query
  161.      */
  162.     private $query;
  164.     /**
  165.      * Map of declared query components in the parsed query.
  166.      *
  167.      * @var array
  168.      */
  169.     private $queryComponents = [];
  171.     /**
  172.      * Keeps the nesting level of defined ResultVariables.
  173.      *
  174.      * @var integer
  175.      */
  176.     private $nestingLevel = 0;
  178.     /**
  179.      * Any additional custom tree walkers that modify the AST.
  180.      *
  181.      * @var array
  182.      */
  183.     private $customTreeWalkers = [];
  185.     /**
  186.      * The custom last tree walker, if any, that is responsible for producing the output.
  187.      *
  188.      * @var class-string<TreeWalker>
  189.      */
  190.     private $customOutputWalker;
  192.     /**
  193.      * @var array
  194.      */
  195.     private $identVariableExpressions = [];
  197.     /**
  198.      * Creates a new query parser object.
  199.      *
  200.      * @param Query $query The Query to parse.
  201.      */
  202.     public function __construct(Query $query)
  203.     {
  204.         $this->query        = $query;
  205.         $this->em           = $query->getEntityManager();
  206.         $this->lexer        = new Lexer((string) $query->getDQL());
  207.         $this->parserResult = new ParserResult();
  208.     }
  210.     /**
  211.      * Sets a custom tree walker that produces output.
  212.      * This tree walker will be run last over the AST, after any other walkers.
  213.      *
  214.      * @param string $className
  215.      *
  216.      * @return void
  217.      */
  218.     public function setCustomOutputTreeWalker($className)
  219.     {
  220.         $this->customOutputWalker = $className;
  221.     }
  223.     /**
  224.      * Adds a custom tree walker for modifying the AST.
  225.      *
  226.      * @param string $className
  227.      *
  228.      * @return void
  229.      */
  230.     public function addCustomTreeWalker($className)
  231.     {
  232.         $this->customTreeWalkers[] = $className;
  233.     }
  235.     /**
  236.      * Gets the lexer used by the parser.
  237.      *
  238.      * @return \Doctrine\ORM\Query\Lexer
  239.      */
  240.     public function getLexer()
  241.     {
  242.         return $this->lexer;
  243.     }
  245.     /**
  246.      * Gets the ParserResult that is being filled with information during parsing.
  247.      *
  248.      * @return \Doctrine\ORM\Query\ParserResult
  249.      */
  250.     public function getParserResult()
  251.     {
  252.         return $this->parserResult;
  253.     }
  255.     /**
  256.      * Gets the EntityManager used by the parser.
  257.      *
  258.      * @return \Doctrine\ORM\EntityManager
  259.      */
  260.     public function getEntityManager()
  261.     {
  262.         return $this->em;
  263.     }
  265.     /**
  266.      * Parses and builds AST for the given Query.
  267.      *
  268.      * @return SelectStatement|UpdateStatement|DeleteStatement
  269.      */
  270.     public function getAST()
  271.     {
  272.         // Parse & build AST
  273.         $AST = $this->QueryLanguage();
  275.         // Process any deferred validations of some nodes in the AST.
  276.         // This also allows post-processing of the AST for modification purposes.
  277.         $this->processDeferredIdentificationVariables();
  279.         if ($this->deferredPartialObjectExpressions) {
  280.             $this->processDeferredPartialObjectExpressions();
  281.         }
  283.         if ($this->deferredPathExpressions) {
  284.             $this->processDeferredPathExpressions();
  285.         }
  287.         if ($this->deferredResultVariables) {
  288.             $this->processDeferredResultVariables();
  289.         }
  291.         if ($this->deferredNewObjectExpressions) {
  292.             $this->processDeferredNewObjectExpressions($AST);
  293.         }
  295.         $this->processRootEntityAliasSelected();
  297.         // TODO: Is there a way to remove this? It may impact the mixed hydration resultset a lot!
  298.         $this->fixIdentificationVariableOrder($AST);
  300.         return $AST;
  301.     }
  303.     /**
  304.      * Attempts to match the given token with the current lookahead token.
  305.      *
  306.      * If they match, updates the lookahead token; otherwise raises a syntax
  307.      * error.
  308.      *
  309.      * @param int $token The token type.
  310.      *
  311.      * @return void
  312.      *
  313.      * @throws QueryException If the tokens don't match.
  314.      */
  315.     public function match($token)
  316.     {
  317.         $lookaheadType = $this->lexer->lookahead['type'] ?? null;
  319.         // Short-circuit on first condition, usually types match
  320.         if ($lookaheadType === $token) {
  321.             $this->lexer->moveNext();
  322.             return;
  323.         }
  325.         // If parameter is not identifier (1-99) must be exact match
  326.         if ($token < Lexer::T_IDENTIFIER) {
  327.             $this->syntaxError($this->lexer->getLiteral($token));
  328.         }
  330.         // If parameter is keyword (200+) must be exact match
  331.         if ($token > Lexer::T_IDENTIFIER) {
  332.             $this->syntaxError($this->lexer->getLiteral($token));
  333.         }
  335.         // If parameter is T_IDENTIFIER, then matches T_IDENTIFIER (100) and keywords (200+)
  336.         if ($token === Lexer::T_IDENTIFIER && $lookaheadType < Lexer::T_IDENTIFIER) {
  337.             $this->syntaxError($this->lexer->getLiteral($token));
  338.         }
  340.         $this->lexer->moveNext();
  341.     }
  343.     /**
  344.      * Frees this parser, enabling it to be reused.
  345.      *
  346.      * @param boolean $deep     Whether to clean peek and reset errors.
  347.      * @param integer $position Position to reset.
  348.      *
  349.      * @return void
  350.      */
  351.     public function free($deep = false, $position = 0)
  352.     {
  353.         // WARNING! Use this method with care. It resets the scanner!
  354.         $this->lexer->resetPosition($position);
  356.         // Deep = true cleans peek and also any previously defined errors
  357.         if ($deep) {
  358.             $this->lexer->resetPeek();
  359.         }
  361.         $this->lexer->token = null;
  362.         $this->lexer->lookahead = null;
  363.     }
  365.     /**
  366.      * Parses a query string.
  367.      *
  368.      * @return ParserResult
  369.      */
  370.     public function parse()
  371.     {
  372.         $AST = $this->getAST();
  374.         if (($customWalkers = $this->query->getHint(Query::HINT_CUSTOM_TREE_WALKERS)) !== false) {
  375.             $this->customTreeWalkers = $customWalkers;
  376.         }
  378.         if (($customOutputWalker = $this->query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER)) !== false) {
  379.             $this->customOutputWalker = $customOutputWalker;
  380.         }
  382.         // Run any custom tree walkers over the AST
  383.         if ($this->customTreeWalkers) {
  384.             $treeWalkerChain = new TreeWalkerChain($this->query, $this->parserResult, $this->queryComponents);
  386.             foreach ($this->customTreeWalkers as $walker) {
  387.                 $treeWalkerChain->addTreeWalker($walker);
  388.             }
  390.             switch (true) {
  391.                 case ($AST instanceof AST\UpdateStatement):
  392.                     $treeWalkerChain->walkUpdateStatement($AST);
  393.                     break;
  395.                 case ($AST instanceof AST\DeleteStatement):
  396.                     $treeWalkerChain->walkDeleteStatement($AST);
  397.                     break;
  399.                 case ($AST instanceof AST\SelectStatement):
  400.                 default:
  401.                     $treeWalkerChain->walkSelectStatement($AST);
  402.             }
  404.             $this->queryComponents = $treeWalkerChain->getQueryComponents();
  405.         }
  407.         $outputWalkerClass = $this->customOutputWalker ?: SqlWalker::class;
  408.         $outputWalker      = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
  410.         // Assign an SQL executor to the parser result
  411.         $this->parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
  413.         return $this->parserResult;
  414.     }
  416.     /**
  417.      * Fixes order of identification variables.
  418.      *
  419.      * They have to appear in the select clause in the same order as the
  420.      * declarations (from ... x join ... y join ... z ...) appear in the query
  421.      * as the hydration process relies on that order for proper operation.
  422.      *
  423.      * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST
  424.      *
  425.      * @return void
  426.      */
  427.     private function fixIdentificationVariableOrder($AST)
  428.     {
  429.         if (count($this->identVariableExpressions) <= 1) {
  430.             return;
  431.         }
  433.         assert($AST instanceof AST\SelectStatement);
  435.         foreach ($this->queryComponents as $dqlAlias => $qComp) {
  436.             if ( ! isset($this->identVariableExpressions[$dqlAlias])) {
  437.                 continue;
  438.             }
  440.             $expr = $this->identVariableExpressions[$dqlAlias];
  441.             $key  = array_search($expr, $AST->selectClause->selectExpressions);
  443.             unset($AST->selectClause->selectExpressions[$key]);
  445.             $AST->selectClause->selectExpressions[] = $expr;
  446.         }
  447.     }
  449.     /**
  450.      * Generates a new syntax error.
  451.      *
  452.      * @param string     $expected Expected string.
  453.      * @param array|null $token    Got token.
  454.      *
  455.      * @return void
  456.      *
  457.      * @throws \Doctrine\ORM\Query\QueryException
  458.      */
  459.     public function syntaxError($expected = '', $token = null)
  460.     {
  461.         if ($token === null) {
  462.             $token = $this->lexer->lookahead;
  463.         }
  465.         $tokenPos = (isset($token['position'])) ? $token['position'] : '-1';
  467.         $message  = "line 0, col {$tokenPos}: Error: ";
  468.         $message .= ($expected !== '') ? "Expected {$expected}, got " : 'Unexpected ';
  469.         $message .= ($this->lexer->lookahead === null) ? 'end of string.' : "'{$token['value']}'";
  471.         throw QueryException::syntaxError($message, QueryException::dqlError($this->query->getDQL()));
  472.     }
  474.     /**
  475.      * Generates a new semantical error.
  476.      *
  477.      * @param string     $message Optional message.
  478.      * @param array|null $token   Optional token.
  479.      *
  480.      * @return void
  481.      *
  482.      * @throws \Doctrine\ORM\Query\QueryException
  483.      */
  484.     public function semanticalError($message = '', $token = null)
  485.     {
  486.         if ($token === null) {
  487.             $token = $this->lexer->lookahead ?? ['position' => null];
  488.         }
  490.         // Minimum exposed chars ahead of token
  491.         $distance = 12;
  493.         // Find a position of a final word to display in error string
  494.         $dql    = $this->query->getDQL();
  495.         $length = strlen($dql);
  496.         $pos    = $token['position'] + $distance;
  497.         $pos    = strpos($dql, ' ', ($length > $pos) ? $pos : $length);
  498.         $length = ($pos !== false) ? $pos - $token['position'] : $distance;
  500.         $tokenPos = (isset($token['position']) && $token['position'] > 0) ? $token['position'] : '-1';
  501.         $tokenStr = substr($dql, $token['position'], $length);
  503.         // Building informative message
  504.         $message = 'line 0, col ' . $tokenPos . " near '" . $tokenStr . "': Error: " . $message;
  506.         throw QueryException::semanticalError($message, QueryException::dqlError($this->query->getDQL()));
  507.     }
  509.     /**
  510.      * Peeks beyond the matched closing parenthesis and returns the first token after that one.
  511.      *
  512.      * @param boolean $resetPeek Reset peek after finding the closing parenthesis.
  513.      *
  514.      * @return array
  515.      */
  516.     private function peekBeyondClosingParenthesis($resetPeek = true)
  517.     {
  518.         $token = $this->lexer->peek();
  519.         $numUnmatched = 1;
  521.         while ($numUnmatched > 0 && $token !== null) {
  522.             switch ($token['type']) {
  523.                 case Lexer::T_OPEN_PARENTHESIS:
  524.                     ++$numUnmatched;
  525.                     break;
  527.                 case Lexer::T_CLOSE_PARENTHESIS:
  528.                     --$numUnmatched;
  529.                     break;
  531.                 default:
  532.                     // Do nothing
  533.             }
  535.             $token = $this->lexer->peek();
  536.         }
  538.         if ($resetPeek) {
  539.             $this->lexer->resetPeek();
  540.         }
  542.         return $token;
  543.     }
  545.     /**
  546.      * Checks if the given token indicates a mathematical operator.
  547.      *
  548.      * @param array $token
  549.      *
  550.      * @return boolean TRUE if the token is a mathematical operator, FALSE otherwise.
  551.      */
  552.     private function isMathOperator($token)
  553.     {
  554.         return $token !== null && in_array($token['type'], [Lexer::T_PLUS, Lexer::T_MINUS, Lexer::T_DIVIDE, Lexer::T_MULTIPLY]);
  555.     }
  557.     /**
  558.      * Checks if the next-next (after lookahead) token starts a function.
  559.      *
  560.      * @return boolean TRUE if the next-next tokens start a function, FALSE otherwise.
  561.      */
  562.     private function isFunction()
  563.     {
  564.         $lookaheadType = $this->lexer->lookahead['type'];
  565.         $peek          = $this->lexer->peek();
  567.         $this->lexer->resetPeek();
  569.         return $lookaheadType >= Lexer::T_IDENTIFIER && $peek !== null && $peek['type'] === Lexer::T_OPEN_PARENTHESIS;
  570.     }
  572.     /**
  573.      * Checks whether the given token type indicates an aggregate function.
  574.      *
  575.      * @param int $tokenType
  576.      *
  577.      * @return boolean TRUE if the token type is an aggregate function, FALSE otherwise.
  578.      */
  579.     private function isAggregateFunction($tokenType)
  580.     {
  581.         return in_array($tokenType, [Lexer::T_AVG, Lexer::T_MIN, Lexer::T_MAX, Lexer::T_SUM, Lexer::T_COUNT]);
  582.     }
  584.     /**
  585.      * Checks whether the current lookahead token of the lexer has the type T_ALL, T_ANY or T_SOME.
  586.      *
  587.      * @return boolean
  588.      */
  589.     private function isNextAllAnySome()
  590.     {
  591.         return in_array($this->lexer->lookahead['type'], [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME]);
  592.     }
  594.     /**
  595.      * Validates that the given <tt>IdentificationVariable</tt> is semantically correct.
  596.      * It must exist in query components list.
  597.      *
  598.      * @return void
  599.      */
  600.     private function processDeferredIdentificationVariables()
  601.     {
  602.         foreach ($this->deferredIdentificationVariables as $deferredItem) {
  603.             $identVariable = $deferredItem['expression'];
  605.             // Check if IdentificationVariable exists in queryComponents
  606.             if ( ! isset($this->queryComponents[$identVariable])) {
  607.                 $this->semanticalError(
  608.                     "'$identVariable' is not defined.", $deferredItem['token']
  609.                 );
  610.             }
  612.             $qComp = $this->queryComponents[$identVariable];
  614.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  615.             if ( ! isset($qComp['metadata'])) {
  616.                 $this->semanticalError(
  617.                     "'$identVariable' does not point to a Class.", $deferredItem['token']
  618.                 );
  619.             }
  621.             // Validate if identification variable nesting level is lower or equal than the current one
  622.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  623.                 $this->semanticalError(
  624.                     "'$identVariable' is used outside the scope of its declaration.", $deferredItem['token']
  625.                 );
  626.             }
  627.         }
  628.     }
  630.     /**
  631.      * Validates that the given <tt>NewObjectExpression</tt>.
  632.      *
  633.      * @param SelectStatement $AST
  634.      *
  635.      * @return void
  636.      */
  637.     private function processDeferredNewObjectExpressions($AST)
  638.     {
  639.         foreach ($this->deferredNewObjectExpressions as $deferredItem) {
  640.             $expression     = $deferredItem['expression'];
  641.             $token          = $deferredItem['token'];
  642.             $className      = $expression->className;
  643.             $args           = $expression->args;
  644.             $fromClassName  = isset($AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName)
  645.                 ? $AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName
  646.                 : null;
  648.             // If the namespace is not given then assumes the first FROM entity namespace
  649.             if (strpos($className, '\\') === false && ! class_exists($className) && strpos($fromClassName, '\\') !== false) {
  650.                 $namespace  = substr($fromClassName, 0, strrpos($fromClassName, '\\'));
  651.                 $fqcn       = $namespace . '\\' . $className;
  653.                 if (class_exists($fqcn)) {
  654.                     $expression->className  = $fqcn;
  655.                     $className              = $fqcn;
  656.                 }
  657.             }
  659.             if ( ! class_exists($className)) {
  660.                 $this->semanticalError(sprintf('Class "%s" is not defined.', $className), $token);
  661.             }
  663.             $class = new \ReflectionClass($className);
  665.             if ( ! $class->isInstantiable()) {
  666.                 $this->semanticalError(sprintf('Class "%s" can not be instantiated.', $className), $token);
  667.             }
  669.             if ($class->getConstructor() === null) {
  670.                 $this->semanticalError(sprintf('Class "%s" has not a valid constructor.', $className), $token);
  671.             }
  673.             if ($class->getConstructor()->getNumberOfRequiredParameters() > count($args)) {
  674.                 $this->semanticalError(sprintf('Number of arguments does not match with "%s" constructor declaration.', $className), $token);
  675.             }
  676.         }
  677.     }
  679.     /**
  680.      * Validates that the given <tt>PartialObjectExpression</tt> is semantically correct.
  681.      * It must exist in query components list.
  682.      *
  683.      * @return void
  684.      */
  685.     private function processDeferredPartialObjectExpressions()
  686.     {
  687.         foreach ($this->deferredPartialObjectExpressions as $deferredItem) {
  688.             $expr = $deferredItem['expression'];
  689.             $class = $this->queryComponents[$expr->identificationVariable]['metadata'];
  691.             foreach ($expr->partialFieldSet as $field) {
  692.                 if (isset($class->fieldMappings[$field])) {
  693.                     continue;
  694.                 }
  696.                 if (isset($class->associationMappings[$field]) &&
  697.                     $class->associationMappings[$field]['isOwningSide'] &&
  698.                     $class->associationMappings[$field]['type'] & ClassMetadata::TO_ONE) {
  699.                     continue;
  700.                 }
  702.                 $this->semanticalError(
  703.                     "There is no mapped field named '$field' on class " . $class->name . ".", $deferredItem['token']
  704.                 );
  705.             }
  707.             if (array_intersect($class->identifier, $expr->partialFieldSet) != $class->identifier) {
  708.                 $this->semanticalError(
  709.                     "The partial field selection of class " . $class->name . " must contain the identifier.",
  710.                     $deferredItem['token']
  711.                 );
  712.             }
  713.         }
  714.     }
  716.     /**
  717.      * Validates that the given <tt>ResultVariable</tt> is semantically correct.
  718.      * It must exist in query components list.
  719.      *
  720.      * @return void
  721.      */
  722.     private function processDeferredResultVariables()
  723.     {
  724.         foreach ($this->deferredResultVariables as $deferredItem) {
  725.             $resultVariable = $deferredItem['expression'];
  727.             // Check if ResultVariable exists in queryComponents
  728.             if ( ! isset($this->queryComponents[$resultVariable])) {
  729.                 $this->semanticalError(
  730.                     "'$resultVariable' is not defined.", $deferredItem['token']
  731.                 );
  732.             }
  734.             $qComp = $this->queryComponents[$resultVariable];
  736.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  737.             if ( ! isset($qComp['resultVariable'])) {
  738.                 $this->semanticalError(
  739.                     "'$resultVariable' does not point to a ResultVariable.", $deferredItem['token']
  740.                 );
  741.             }
  743.             // Validate if identification variable nesting level is lower or equal than the current one
  744.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  745.                 $this->semanticalError(
  746.                     "'$resultVariable' is used outside the scope of its declaration.", $deferredItem['token']
  747.                 );
  748.             }
  749.         }
  750.     }
  752.     /**
  753.      * Validates that the given <tt>PathExpression</tt> is semantically correct for grammar rules:
  754.      *
  755.      * AssociationPathExpression             ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  756.      * SingleValuedPathExpression            ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  757.      * StateFieldPathExpression              ::= IdentificationVariable "." StateField
  758.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  759.      * CollectionValuedPathExpression        ::= IdentificationVariable "." CollectionValuedAssociationField
  760.      *
  761.      * @return void
  762.      */
  763.     private function processDeferredPathExpressions()
  764.     {
  765.         foreach ($this->deferredPathExpressions as $deferredItem) {
  766.             $pathExpression = $deferredItem['expression'];
  768.             $qComp = $this->queryComponents[$pathExpression->identificationVariable];
  769.             $class = $qComp['metadata'];
  771.             if (($field = $pathExpression->field) === null) {
  772.                 $field = $pathExpression->field = $class->identifier[0];
  773.             }
  775.             // Check if field or association exists
  776.             if ( ! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
  777.                 $this->semanticalError(
  778.                     'Class ' . $class->name . ' has no field or association named ' . $field,
  779.                     $deferredItem['token']
  780.                 );
  781.             }
  783.             $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
  785.             if (isset($class->associationMappings[$field])) {
  786.                 $assoc = $class->associationMappings[$field];
  788.                 $fieldType = ($assoc['type'] & ClassMetadata::TO_ONE)
  789.                     ? AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  790.                     : AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
  791.             }
  793.             // Validate if PathExpression is one of the expected types
  794.             $expectedType = $pathExpression->expectedType;
  796.             if ( ! ($expectedType & $fieldType)) {
  797.                 // We need to recognize which was expected type(s)
  798.                 $expectedStringTypes = [];
  800.                 // Validate state field type
  801.                 if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
  802.                     $expectedStringTypes[] = 'StateFieldPathExpression';
  803.                 }
  805.                 // Validate single valued association (*-to-one)
  806.                 if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
  807.                     $expectedStringTypes[] = 'SingleValuedAssociationField';
  808.                 }
  810.                 // Validate single valued association (*-to-many)
  811.                 if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
  812.                     $expectedStringTypes[] = 'CollectionValuedAssociationField';
  813.                 }
  815.                 // Build the error message
  816.                 $semanticalError  = 'Invalid PathExpression. ';
  817.                 $semanticalError .= (count($expectedStringTypes) == 1)
  818.                     ? 'Must be a ' . $expectedStringTypes[0] . '.'
  819.                     : implode(' or ', $expectedStringTypes) . ' expected.';
  821.                 $this->semanticalError($semanticalError, $deferredItem['token']);
  822.             }
  824.             // We need to force the type in PathExpression
  825.             $pathExpression->type = $fieldType;
  826.         }
  827.     }
  829.     /**
  830.      * @return void
  831.      */
  832.     private function processRootEntityAliasSelected()
  833.     {
  834.         if ( ! count($this->identVariableExpressions)) {
  835.             return;
  836.         }
  838.         foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
  839.             if (isset($this->queryComponents[$dqlAlias]) && $this->queryComponents[$dqlAlias]['parent'] === null) {
  840.                 return;
  841.             }
  842.         }
  844.         $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');
  845.     }
  847.     /**
  848.      * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
  849.      *
  850.      * @return SelectStatement|UpdateStatement|DeleteStatement
  851.      */
  852.     public function QueryLanguage()
  853.     {
  854.         $statement = null;
  856.         $this->lexer->moveNext();
  858.         switch ($this->lexer->lookahead['type'] ?? null) {
  859.             case Lexer::T_SELECT:
  860.                 $statement = $this->SelectStatement();
  861.                 break;
  863.             case Lexer::T_UPDATE:
  864.                 $statement = $this->UpdateStatement();
  865.                 break;
  867.             case Lexer::T_DELETE:
  868.                 $statement = $this->DeleteStatement();
  869.                 break;
  871.             default:
  872.                 $this->syntaxError('SELECT, UPDATE or DELETE');
  873.                 break;
  874.         }
  876.         // Check for end of string
  877.         if ($this->lexer->lookahead !== null) {
  878.             $this->syntaxError('end of string');
  879.         }
  881.         return $statement;
  882.     }
  884.     /**
  885.      * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  886.      *
  887.      * @return SelectStatement
  888.      */
  889.     public function SelectStatement()
  890.     {
  891.         $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());
  893.         $selectStatement->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  894.         $selectStatement->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  895.         $selectStatement->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  896.         $selectStatement->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  898.         return $selectStatement;
  899.     }
  901.     /**
  902.      * UpdateStatement ::= UpdateClause [WhereClause]
  903.      *
  904.      * @return UpdateStatement
  905.      */
  906.     public function UpdateStatement()
  907.     {
  908.         $updateStatement = new AST\UpdateStatement($this->UpdateClause());
  910.         $updateStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  912.         return $updateStatement;
  913.     }
  915.     /**
  916.      * DeleteStatement ::= DeleteClause [WhereClause]
  917.      *
  918.      * @return DeleteStatement
  919.      */
  920.     public function DeleteStatement()
  921.     {
  922.         $deleteStatement = new AST\DeleteStatement($this->DeleteClause());
  924.         $deleteStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  926.         return $deleteStatement;
  927.     }
  929.     /**
  930.      * IdentificationVariable ::= identifier
  931.      *
  932.      * @return string
  933.      */
  934.     public function IdentificationVariable()
  935.     {
  936.         $this->match(Lexer::T_IDENTIFIER);
  938.         $identVariable = $this->lexer->token['value'];
  940.         $this->deferredIdentificationVariables[] = [
  941.             'expression'   => $identVariable,
  942.             'nestingLevel' => $this->nestingLevel,
  943.             'token'        => $this->lexer->token,
  944.         ];
  946.         return $identVariable;
  947.     }
  949.     /**
  950.      * AliasIdentificationVariable = identifier
  951.      *
  952.      * @return string
  953.      */
  954.     public function AliasIdentificationVariable()
  955.     {
  956.         $this->match(Lexer::T_IDENTIFIER);
  958.         $aliasIdentVariable = $this->lexer->token['value'];
  959.         $exists = isset($this->queryComponents[$aliasIdentVariable]);
  961.         if ($exists) {
  962.             $this->semanticalError("'$aliasIdentVariable' is already defined.", $this->lexer->token);
  963.         }
  965.         return $aliasIdentVariable;
  966.     }
  968.     /**
  969.      * AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
  970.      *
  971.      * @return string
  972.      */
  973.     public function AbstractSchemaName()
  974.     {
  975.         if ($this->lexer->isNextToken(Lexer::T_FULLY_QUALIFIED_NAME)) {
  976.             $this->match(Lexer::T_FULLY_QUALIFIED_NAME);
  978.             return $this->lexer->token['value'];
  979.         }
  981.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  982.             $this->match(Lexer::T_IDENTIFIER);
  984.             return $this->lexer->token['value'];
  985.         }
  987.         $this->match(Lexer::T_ALIASED_NAME);
  989.         [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token['value']);
  991.         return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  992.     }
  994.     /**
  995.      * Validates an AbstractSchemaName, making sure the class exists.
  996.      *
  997.      * @param string $schemaName The name to validate.
  998.      *
  999.      * @throws QueryException if the name does not exist.
  1000.      */
  1001.     private function validateAbstractSchemaName($schemaName)
  1002.     {
  1003.         if (! (class_exists($schemaName, true) || interface_exists($schemaName, true))) {
  1004.             $this->semanticalError("Class '$schemaName' is not defined.", $this->lexer->token);
  1005.         }
  1006.     }
  1008.     /**
  1009.      * AliasResultVariable ::= identifier
  1010.      *
  1011.      * @return string
  1012.      */
  1013.     public function AliasResultVariable()
  1014.     {
  1015.         $this->match(Lexer::T_IDENTIFIER);
  1017.         $resultVariable = $this->lexer->token['value'];
  1018.         $exists = isset($this->queryComponents[$resultVariable]);
  1020.         if ($exists) {
  1021.             $this->semanticalError("'$resultVariable' is already defined.", $this->lexer->token);
  1022.         }
  1024.         return $resultVariable;
  1025.     }
  1027.     /**
  1028.      * ResultVariable ::= identifier
  1029.      *
  1030.      * @return string
  1031.      */
  1032.     public function ResultVariable()
  1033.     {
  1034.         $this->match(Lexer::T_IDENTIFIER);
  1036.         $resultVariable = $this->lexer->token['value'];
  1038.         // Defer ResultVariable validation
  1039.         $this->deferredResultVariables[] = [
  1040.             'expression'   => $resultVariable,
  1041.             'nestingLevel' => $this->nestingLevel,
  1042.             'token'        => $this->lexer->token,
  1043.         ];
  1045.         return $resultVariable;
  1046.     }
  1048.     /**
  1049.      * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
  1050.      *
  1051.      * @return \Doctrine\ORM\Query\AST\JoinAssociationPathExpression
  1052.      */
  1053.     public function JoinAssociationPathExpression()
  1054.     {
  1055.         $identVariable = $this->IdentificationVariable();
  1057.         if ( ! isset($this->queryComponents[$identVariable])) {
  1058.             $this->semanticalError(
  1059.                 'Identification Variable ' . $identVariable .' used in join path expression but was not defined before.'
  1060.             );
  1061.         }
  1063.         $this->match(Lexer::T_DOT);
  1064.         $this->match(Lexer::T_IDENTIFIER);
  1066.         $field = $this->lexer->token['value'];
  1068.         // Validate association field
  1069.         $qComp = $this->queryComponents[$identVariable];
  1070.         $class = $qComp['metadata'];
  1072.         if ( ! $class->hasAssociation($field)) {
  1073.             $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
  1074.         }
  1076.         return new AST\JoinAssociationPathExpression($identVariable, $field);
  1077.     }
  1079.     /**
  1080.      * Parses an arbitrary path expression and defers semantical validation
  1081.      * based on expected types.
  1082.      *
  1083.      * PathExpression ::= IdentificationVariable {"." identifier}*
  1084.      *
  1085.      * @param integer $expectedTypes
  1086.      *
  1087.      * @return PathExpression
  1088.      */
  1089.     public function PathExpression($expectedTypes)
  1090.     {
  1091.         $identVariable = $this->IdentificationVariable();
  1092.         $field = null;
  1094.         if ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1095.             $this->match(Lexer::T_DOT);
  1096.             $this->match(Lexer::T_IDENTIFIER);
  1098.             $field = $this->lexer->token['value'];
  1100.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1101.                 $this->match(Lexer::T_DOT);
  1102.                 $this->match(Lexer::T_IDENTIFIER);
  1103.                 $field .= '.'.$this->lexer->token['value'];
  1104.             }
  1105.         }
  1107.         // Creating AST node
  1108.         $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);
  1110.         // Defer PathExpression validation if requested to be deferred
  1111.         $this->deferredPathExpressions[] = [
  1112.             'expression'   => $pathExpr,
  1113.             'nestingLevel' => $this->nestingLevel,
  1114.             'token'        => $this->lexer->token,
  1115.         ];
  1117.         return $pathExpr;
  1118.     }
  1120.     /**
  1121.      * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  1122.      *
  1123.      * @return PathExpression
  1124.      */
  1125.     public function AssociationPathExpression()
  1126.     {
  1127.         return $this->PathExpression(
  1128.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |
  1129.             AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION
  1130.         );
  1131.     }
  1133.     /**
  1134.      * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  1135.      *
  1136.      * @return PathExpression
  1137.      */
  1138.     public function SingleValuedPathExpression()
  1139.     {
  1140.         return $this->PathExpression(
  1141.             AST\PathExpression::TYPE_STATE_FIELD |
  1142.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  1143.         );
  1144.     }
  1146.     /**
  1147.      * StateFieldPathExpression ::= IdentificationVariable "." StateField
  1148.      *
  1149.      * @return PathExpression
  1150.      */
  1151.     public function StateFieldPathExpression()
  1152.     {
  1153.         return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);
  1154.     }
  1156.     /**
  1157.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  1158.      *
  1159.      * @return PathExpression
  1160.      */
  1161.     public function SingleValuedAssociationPathExpression()
  1162.     {
  1163.         return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);
  1164.     }
  1166.     /**
  1167.      * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  1168.      *
  1169.      * @return PathExpression
  1170.      */
  1171.     public function CollectionValuedPathExpression()
  1172.     {
  1173.         return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);
  1174.     }
  1176.     /**
  1177.      * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
  1178.      *
  1179.      * @return \Doctrine\ORM\Query\AST\SelectClause
  1180.      */
  1181.     public function SelectClause()
  1182.     {
  1183.         $isDistinct = false;
  1184.         $this->match(Lexer::T_SELECT);
  1186.         // Check for DISTINCT
  1187.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1188.             $this->match(Lexer::T_DISTINCT);
  1190.             $isDistinct = true;
  1191.         }
  1193.         // Process SelectExpressions (1..N)
  1194.         $selectExpressions = [];
  1195.         $selectExpressions[] = $this->SelectExpression();
  1197.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1198.             $this->match(Lexer::T_COMMA);
  1200.             $selectExpressions[] = $this->SelectExpression();
  1201.         }
  1203.         return new AST\SelectClause($selectExpressions, $isDistinct);
  1204.     }
  1206.     /**
  1207.      * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
  1208.      *
  1209.      * @return \Doctrine\ORM\Query\AST\SimpleSelectClause
  1210.      */
  1211.     public function SimpleSelectClause()
  1212.     {
  1213.         $isDistinct = false;
  1214.         $this->match(Lexer::T_SELECT);
  1216.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1217.             $this->match(Lexer::T_DISTINCT);
  1219.             $isDistinct = true;
  1220.         }
  1222.         return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);
  1223.     }
  1225.     /**
  1226.      * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*
  1227.      *
  1228.      * @return \Doctrine\ORM\Query\AST\UpdateClause
  1229.      */
  1230.     public function UpdateClause()
  1231.     {
  1232.         $this->match(Lexer::T_UPDATE);
  1234.         $token = $this->lexer->lookahead;
  1235.         $abstractSchemaName = $this->AbstractSchemaName();
  1237.         $this->validateAbstractSchemaName($abstractSchemaName);
  1239.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1240.             $this->match(Lexer::T_AS);
  1241.         }
  1243.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1245.         $class = $this->em->getClassMetadata($abstractSchemaName);
  1247.         // Building queryComponent
  1248.         $queryComponent = [
  1249.             'metadata'     => $class,
  1250.             'parent'       => null,
  1251.             'relation'     => null,
  1252.             'map'          => null,
  1253.             'nestingLevel' => $this->nestingLevel,
  1254.             'token'        => $token,
  1255.         ];
  1257.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1259.         $this->match(Lexer::T_SET);
  1261.         $updateItems = [];
  1262.         $updateItems[] = $this->UpdateItem();
  1264.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1265.             $this->match(Lexer::T_COMMA);
  1267.             $updateItems[] = $this->UpdateItem();
  1268.         }
  1270.         $updateClause = new AST\UpdateClause($abstractSchemaName, $updateItems);
  1271.         $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1273.         return $updateClause;
  1274.     }
  1276.     /**
  1277.      * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable
  1278.      *
  1279.      * @return \Doctrine\ORM\Query\AST\DeleteClause
  1280.      */
  1281.     public function DeleteClause()
  1282.     {
  1283.         $this->match(Lexer::T_DELETE);
  1285.         if ($this->lexer->isNextToken(Lexer::T_FROM)) {
  1286.             $this->match(Lexer::T_FROM);
  1287.         }
  1289.         $token = $this->lexer->lookahead;
  1290.         $abstractSchemaName = $this->AbstractSchemaName();
  1292.         $this->validateAbstractSchemaName($abstractSchemaName);
  1294.         $deleteClause = new AST\DeleteClause($abstractSchemaName);
  1296.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1297.             $this->match(Lexer::T_AS);
  1298.         }
  1300.         $aliasIdentificationVariable = $this->lexer->isNextToken(Lexer::T_IDENTIFIER)
  1301.             ? $this->AliasIdentificationVariable()
  1302.             : 'alias_should_have_been_set';
  1304.         $deleteClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1305.         $class = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1307.         // Building queryComponent
  1308.         $queryComponent = [
  1309.             'metadata'     => $class,
  1310.             'parent'       => null,
  1311.             'relation'     => null,
  1312.             'map'          => null,
  1313.             'nestingLevel' => $this->nestingLevel,
  1314.             'token'        => $token,
  1315.         ];
  1317.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1319.         return $deleteClause;
  1320.     }
  1322.     /**
  1323.      * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}*
  1324.      *
  1325.      * @return \Doctrine\ORM\Query\AST\FromClause
  1326.      */
  1327.     public function FromClause()
  1328.     {
  1329.         $this->match(Lexer::T_FROM);
  1331.         $identificationVariableDeclarations = [];
  1332.         $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1334.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1335.             $this->match(Lexer::T_COMMA);
  1337.             $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1338.         }
  1340.         return new AST\FromClause($identificationVariableDeclarations);
  1341.     }
  1343.     /**
  1344.      * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
  1345.      *
  1346.      * @return \Doctrine\ORM\Query\AST\SubselectFromClause
  1347.      */
  1348.     public function SubselectFromClause()
  1349.     {
  1350.         $this->match(Lexer::T_FROM);
  1352.         $identificationVariables = [];
  1353.         $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1355.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1356.             $this->match(Lexer::T_COMMA);
  1358.             $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1359.         }
  1361.         return new AST\SubselectFromClause($identificationVariables);
  1362.     }
  1364.     /**
  1365.      * WhereClause ::= "WHERE" ConditionalExpression
  1366.      *
  1367.      * @return \Doctrine\ORM\Query\AST\WhereClause
  1368.      */
  1369.     public function WhereClause()
  1370.     {
  1371.         $this->match(Lexer::T_WHERE);
  1373.         return new AST\WhereClause($this->ConditionalExpression());
  1374.     }
  1376.     /**
  1377.      * HavingClause ::= "HAVING" ConditionalExpression
  1378.      *
  1379.      * @return \Doctrine\ORM\Query\AST\HavingClause
  1380.      */
  1381.     public function HavingClause()
  1382.     {
  1383.         $this->match(Lexer::T_HAVING);
  1385.         return new AST\HavingClause($this->ConditionalExpression());
  1386.     }
  1388.     /**
  1389.      * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
  1390.      *
  1391.      * @return \Doctrine\ORM\Query\AST\GroupByClause
  1392.      */
  1393.     public function GroupByClause()
  1394.     {
  1395.         $this->match(Lexer::T_GROUP);
  1396.         $this->match(Lexer::T_BY);
  1398.         $groupByItems = [$this->GroupByItem()];
  1400.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1401.             $this->match(Lexer::T_COMMA);
  1403.             $groupByItems[] = $this->GroupByItem();
  1404.         }
  1406.         return new AST\GroupByClause($groupByItems);
  1407.     }
  1409.     /**
  1410.      * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
  1411.      *
  1412.      * @return \Doctrine\ORM\Query\AST\OrderByClause
  1413.      */
  1414.     public function OrderByClause()
  1415.     {
  1416.         $this->match(Lexer::T_ORDER);
  1417.         $this->match(Lexer::T_BY);
  1419.         $orderByItems = [];
  1420.         $orderByItems[] = $this->OrderByItem();
  1422.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1423.             $this->match(Lexer::T_COMMA);
  1425.             $orderByItems[] = $this->OrderByItem();
  1426.         }
  1428.         return new AST\OrderByClause($orderByItems);
  1429.     }
  1431.     /**
  1432.      * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  1433.      *
  1434.      * @return Subselect
  1435.      */
  1436.     public function Subselect()
  1437.     {
  1438.         // Increase query nesting level
  1439.         $this->nestingLevel++;
  1441.         $subselect = new AST\Subselect($this->SimpleSelectClause(), $this->SubselectFromClause());
  1443.         $subselect->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  1444.         $subselect->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  1445.         $subselect->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  1446.         $subselect->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  1448.         // Decrease query nesting level
  1449.         $this->nestingLevel--;
  1451.         return $subselect;
  1452.     }
  1454.     /**
  1455.      * UpdateItem ::= SingleValuedPathExpression "=" NewValue
  1456.      *
  1457.      * @return \Doctrine\ORM\Query\AST\UpdateItem
  1458.      */
  1459.     public function UpdateItem()
  1460.     {
  1461.         $pathExpr = $this->SingleValuedPathExpression();
  1463.         $this->match(Lexer::T_EQUALS);
  1465.         $updateItem = new AST\UpdateItem($pathExpr, $this->NewValue());
  1467.         return $updateItem;
  1468.     }
  1470.     /**
  1471.      * GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression
  1472.      *
  1473.      * @return string|PathExpression
  1474.      */
  1475.     public function GroupByItem()
  1476.     {
  1477.         // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  1478.         $glimpse = $this->lexer->glimpse();
  1480.         if ($glimpse !== null && $glimpse['type'] === Lexer::T_DOT) {
  1481.             return $this->SingleValuedPathExpression();
  1482.         }
  1484.         // Still need to decide between IdentificationVariable or ResultVariable
  1485.         $lookaheadValue = $this->lexer->lookahead['value'];
  1487.         if ( ! isset($this->queryComponents[$lookaheadValue])) {
  1488.             $this->semanticalError('Cannot group by undefined identification or result variable.');
  1489.         }
  1491.         return (isset($this->queryComponents[$lookaheadValue]['metadata']))
  1492.             ? $this->IdentificationVariable()
  1493.             : $this->ResultVariable();
  1494.     }
  1496.     /**
  1497.      * OrderByItem ::= (
  1498.      *      SimpleArithmeticExpression | SingleValuedPathExpression |
  1499.      *      ScalarExpression | ResultVariable | FunctionDeclaration
  1500.      * ) ["ASC" | "DESC"]
  1501.      *
  1502.      * @return \Doctrine\ORM\Query\AST\OrderByItem
  1503.      */
  1504.     public function OrderByItem()
  1505.     {
  1506.         $this->lexer->peek(); // lookahead => '.'
  1507.         $this->lexer->peek(); // lookahead => token after '.'
  1509.         $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1511.         $this->lexer->resetPeek();
  1513.         $glimpse = $this->lexer->glimpse();
  1515.         switch (true) {
  1516.             case ($this->isMathOperator($peek)):
  1517.                 $expr = $this->SimpleArithmeticExpression();
  1518.                 break;
  1520.             case $glimpse !== null && $glimpse['type'] === Lexer::T_DOT:
  1521.                 $expr = $this->SingleValuedPathExpression();
  1522.                 break;
  1524.             case ($this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis())):
  1525.                 $expr = $this->ScalarExpression();
  1526.                 break;
  1528.             case $this->isFunction():
  1529.                 $expr = $this->FunctionDeclaration();
  1530.                 break;
  1532.             default:
  1533.                 $expr = $this->ResultVariable();
  1534.                 break;
  1535.         }
  1537.         $type = 'ASC';
  1538.         $item = new AST\OrderByItem($expr);
  1540.         switch (true) {
  1541.             case ($this->lexer->isNextToken(Lexer::T_DESC)):
  1542.                 $this->match(Lexer::T_DESC);
  1543.                 $type = 'DESC';
  1544.                 break;
  1546.             case ($this->lexer->isNextToken(Lexer::T_ASC)):
  1547.                 $this->match(Lexer::T_ASC);
  1548.                 break;
  1550.             default:
  1551.                 // Do nothing
  1552.         }
  1554.         $item->type = $type;
  1556.         return $item;
  1557.     }
  1559.     /**
  1560.      * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
  1561.      *      EnumPrimary | SimpleEntityExpression | "NULL"
  1562.      *
  1563.      * NOTE: Since it is not possible to correctly recognize individual types, here is the full
  1564.      * grammar that needs to be supported:
  1565.      *
  1566.      * NewValue ::= SimpleArithmeticExpression | "NULL"
  1567.      *
  1568.      * SimpleArithmeticExpression covers all *Primary grammar rules and also SimpleEntityExpression
  1569.      *
  1570.      * @return AST\ArithmeticExpression|AST\InputParameter|null
  1571.      */
  1572.     public function NewValue()
  1573.     {
  1574.         if ($this->lexer->isNextToken(Lexer::T_NULL)) {
  1575.             $this->match(Lexer::T_NULL);
  1577.             return null;
  1578.         }
  1580.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  1581.             $this->match(Lexer::T_INPUT_PARAMETER);
  1583.             return new AST\InputParameter($this->lexer->token['value']);
  1584.         }
  1586.         return $this->ArithmeticExpression();
  1587.     }
  1589.     /**
  1590.      * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*
  1591.      *
  1592.      * @return IdentificationVariableDeclaration
  1593.      */
  1594.     public function IdentificationVariableDeclaration()
  1595.     {
  1596.         $joins                    = [];
  1597.         $rangeVariableDeclaration = $this->RangeVariableDeclaration();
  1598.         $indexBy                  = $this->lexer->isNextToken(Lexer::T_INDEX)
  1599.             ? $this->IndexBy()
  1600.             : null;
  1602.         $rangeVariableDeclaration->isRoot = true;
  1604.         while (
  1605.             $this->lexer->isNextToken(Lexer::T_LEFT) ||
  1606.             $this->lexer->isNextToken(Lexer::T_INNER) ||
  1607.             $this->lexer->isNextToken(Lexer::T_JOIN)
  1608.         ) {
  1609.             $joins[] = $this->Join();
  1610.         }
  1612.         return new AST\IdentificationVariableDeclaration(
  1613.             $rangeVariableDeclaration, $indexBy, $joins
  1614.         );
  1615.     }
  1617.     /**
  1618.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration
  1619.      *
  1620.      * {Internal note: WARNING: Solution is harder than a bare implementation.
  1621.      * Desired EBNF support:
  1622.      *
  1623.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
  1624.      *
  1625.      * It demands that entire SQL generation to become programmatical. This is
  1626.      * needed because association based subselect requires "WHERE" conditional
  1627.      * expressions to be injected, but there is no scope to do that. Only scope
  1628.      * accessible is "FROM", prohibiting an easy implementation without larger
  1629.      * changes.}
  1630.      *
  1631.      * @return SubselectIdentificationVariableDeclaration|IdentificationVariableDeclaration
  1632.      */
  1633.     public function SubselectIdentificationVariableDeclaration()
  1634.     {
  1635.         /*
  1636.         NOT YET IMPLEMENTED!
  1638.         $glimpse = $this->lexer->glimpse();
  1640.         if ($glimpse['type'] == Lexer::T_DOT) {
  1641.             $associationPathExpression = $this->AssociationPathExpression();
  1643.             if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1644.                 $this->match(Lexer::T_AS);
  1645.             }
  1647.             $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1648.             $identificationVariable      = $associationPathExpression->identificationVariable;
  1649.             $field                       = $associationPathExpression->associationField;
  1651.             $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1652.             $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1654.             // Building queryComponent
  1655.             $joinQueryComponent = array(
  1656.                 'metadata'     => $targetClass,
  1657.                 'parent'       => $identificationVariable,
  1658.                 'relation'     => $class->getAssociationMapping($field),
  1659.                 'map'          => null,
  1660.                 'nestingLevel' => $this->nestingLevel,
  1661.                 'token'        => $this->lexer->lookahead
  1662.             );
  1664.             $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1666.             return new AST\SubselectIdentificationVariableDeclaration(
  1667.                 $associationPathExpression, $aliasIdentificationVariable
  1668.             );
  1669.         }
  1670.         */
  1672.         return $this->IdentificationVariableDeclaration();
  1673.     }
  1675.     /**
  1676.      * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN"
  1677.      *          (JoinAssociationDeclaration | RangeVariableDeclaration)
  1678.      *          ["WITH" ConditionalExpression]
  1679.      *
  1680.      * @return \Doctrine\ORM\Query\AST\Join
  1681.      */
  1682.     public function Join()
  1683.     {
  1684.         // Check Join type
  1685.         $joinType = AST\Join::JOIN_TYPE_INNER;
  1687.         switch (true) {
  1688.             case ($this->lexer->isNextToken(Lexer::T_LEFT)):
  1689.                 $this->match(Lexer::T_LEFT);
  1691.                 $joinType = AST\Join::JOIN_TYPE_LEFT;
  1693.                 // Possible LEFT OUTER join
  1694.                 if ($this->lexer->isNextToken(Lexer::T_OUTER)) {
  1695.                     $this->match(Lexer::T_OUTER);
  1697.                     $joinType = AST\Join::JOIN_TYPE_LEFTOUTER;
  1698.                 }
  1699.                 break;
  1701.             case ($this->lexer->isNextToken(Lexer::T_INNER)):
  1702.                 $this->match(Lexer::T_INNER);
  1703.                 break;
  1705.             default:
  1706.                 // Do nothing
  1707.         }
  1709.         $this->match(Lexer::T_JOIN);
  1711.         $next            = $this->lexer->glimpse();
  1712.         $joinDeclaration = ($next['type'] === Lexer::T_DOT) ? $this->JoinAssociationDeclaration() : $this->RangeVariableDeclaration();
  1713.         $adhocConditions = $this->lexer->isNextToken(Lexer::T_WITH);
  1714.         $join            = new AST\Join($joinType, $joinDeclaration);
  1716.         // Describe non-root join declaration
  1717.         if ($joinDeclaration instanceof AST\RangeVariableDeclaration) {
  1718.             $joinDeclaration->isRoot = false;
  1719.         }
  1721.         // Check for ad-hoc Join conditions
  1722.         if ($adhocConditions) {
  1723.             $this->match(Lexer::T_WITH);
  1725.             $join->conditionalExpression = $this->ConditionalExpression();
  1726.         }
  1728.         return $join;
  1729.     }
  1731.     /**
  1732.      * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
  1733.      *
  1734.      * @return \Doctrine\ORM\Query\AST\RangeVariableDeclaration
  1735.      *
  1736.      * @throws QueryException
  1737.      */
  1738.     public function RangeVariableDeclaration()
  1739.     {
  1740.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $this->lexer->glimpse()['type'] === Lexer::T_SELECT) {
  1741.             $this->semanticalError('Subquery is not supported here', $this->lexer->token);
  1742.         }
  1744.         $abstractSchemaName = $this->AbstractSchemaName();
  1746.         $this->validateAbstractSchemaName($abstractSchemaName);
  1748.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1749.             $this->match(Lexer::T_AS);
  1750.         }
  1752.         $token = $this->lexer->lookahead;
  1753.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1754.         $classMetadata = $this->em->getClassMetadata($abstractSchemaName);
  1756.         // Building queryComponent
  1757.         $queryComponent = [
  1758.             'metadata'     => $classMetadata,
  1759.             'parent'       => null,
  1760.             'relation'     => null,
  1761.             'map'          => null,
  1762.             'nestingLevel' => $this->nestingLevel,
  1763.             'token'        => $token
  1764.         ];
  1766.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1768.         return new AST\RangeVariableDeclaration($abstractSchemaName, $aliasIdentificationVariable);
  1769.     }
  1771.     /**
  1772.      * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [IndexBy]
  1773.      *
  1774.      * @return AST\JoinAssociationDeclaration
  1775.      */
  1776.     public function JoinAssociationDeclaration()
  1777.     {
  1778.         $joinAssociationPathExpression = $this->JoinAssociationPathExpression();
  1780.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1781.             $this->match(Lexer::T_AS);
  1782.         }
  1784.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1785.         $indexBy                     = $this->lexer->isNextToken(Lexer::T_INDEX) ? $this->IndexBy() : null;
  1787.         $identificationVariable = $joinAssociationPathExpression->identificationVariable;
  1788.         $field                  = $joinAssociationPathExpression->associationField;
  1790.         $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1791.         $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1793.         // Building queryComponent
  1794.         $joinQueryComponent = [
  1795.             'metadata'     => $targetClass,
  1796.             'parent'       => $joinAssociationPathExpression->identificationVariable,
  1797.             'relation'     => $class->getAssociationMapping($field),
  1798.             'map'          => null,
  1799.             'nestingLevel' => $this->nestingLevel,
  1800.             'token'        => $this->lexer->lookahead
  1801.         ];
  1803.         $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1805.         return new AST\JoinAssociationDeclaration($joinAssociationPathExpression, $aliasIdentificationVariable, $indexBy);
  1806.     }
  1808.     /**
  1809.      * PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
  1810.      * PartialFieldSet ::= "{" SimpleStateField {"," SimpleStateField}* "}"
  1811.      *
  1812.      * @return \Doctrine\ORM\Query\AST\PartialObjectExpression
  1813.      */
  1814.     public function PartialObjectExpression()
  1815.     {
  1816.         $this->match(Lexer::T_PARTIAL);
  1818.         $partialFieldSet = [];
  1820.         $identificationVariable = $this->IdentificationVariable();
  1822.         $this->match(Lexer::T_DOT);
  1823.         $this->match(Lexer::T_OPEN_CURLY_BRACE);
  1824.         $this->match(Lexer::T_IDENTIFIER);
  1826.         $field = $this->lexer->token['value'];
  1828.         // First field in partial expression might be embeddable property
  1829.         while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1830.             $this->match(Lexer::T_DOT);
  1831.             $this->match(Lexer::T_IDENTIFIER);
  1832.             $field .= '.'.$this->lexer->token['value'];
  1833.         }
  1835.         $partialFieldSet[] = $field;
  1837.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1838.             $this->match(Lexer::T_COMMA);
  1839.             $this->match(Lexer::T_IDENTIFIER);
  1841.             $field = $this->lexer->token['value'];
  1843.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1844.                 $this->match(Lexer::T_DOT);
  1845.                 $this->match(Lexer::T_IDENTIFIER);
  1846.                 $field .= '.'.$this->lexer->token['value'];
  1847.             }
  1849.             $partialFieldSet[] = $field;
  1850.         }
  1852.         $this->match(Lexer::T_CLOSE_CURLY_BRACE);
  1854.         $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
  1856.         // Defer PartialObjectExpression validation
  1857.         $this->deferredPartialObjectExpressions[] = [
  1858.             'expression'   => $partialObjectExpression,
  1859.             'nestingLevel' => $this->nestingLevel,
  1860.             'token'        => $this->lexer->token,
  1861.         ];
  1863.         return $partialObjectExpression;
  1864.     }
  1866.     /**
  1867.      * NewObjectExpression ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
  1868.      *
  1869.      * @return \Doctrine\ORM\Query\AST\NewObjectExpression
  1870.      */
  1871.     public function NewObjectExpression()
  1872.     {
  1873.         $this->match(Lexer::T_NEW);
  1875.         $className = $this->AbstractSchemaName(); // note that this is not yet validated
  1876.         $token = $this->lexer->token;
  1878.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  1880.         $args[] = $this->NewObjectArg();
  1882.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1883.             $this->match(Lexer::T_COMMA);
  1885.             $args[] = $this->NewObjectArg();
  1886.         }
  1888.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1890.         $expression = new AST\NewObjectExpression($className, $args);
  1892.         // Defer NewObjectExpression validation
  1893.         $this->deferredNewObjectExpressions[] = [
  1894.             'token'        => $token,
  1895.             'expression'   => $expression,
  1896.             'nestingLevel' => $this->nestingLevel,
  1897.         ];
  1899.         return $expression;
  1900.     }
  1902.     /**
  1903.      * NewObjectArg ::= ScalarExpression | "(" Subselect ")"
  1904.      *
  1905.      * @return mixed
  1906.      */
  1907.     public function NewObjectArg()
  1908.     {
  1909.         $token = $this->lexer->lookahead;
  1910.         $peek  = $this->lexer->glimpse();
  1912.         if ($token['type'] === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT) {
  1913.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  1914.             $expression = $this->Subselect();
  1915.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1917.             return $expression;
  1918.         }
  1920.         return $this->ScalarExpression();
  1921.     }
  1923.     /**
  1924.      * IndexBy ::= "INDEX" "BY" StateFieldPathExpression
  1925.      *
  1926.      * @return \Doctrine\ORM\Query\AST\IndexBy
  1927.      */
  1928.     public function IndexBy()
  1929.     {
  1930.         $this->match(Lexer::T_INDEX);
  1931.         $this->match(Lexer::T_BY);
  1932.         $pathExpr = $this->StateFieldPathExpression();
  1934.         // Add the INDEX BY info to the query component
  1935.         $this->queryComponents[$pathExpr->identificationVariable]['map'] = $pathExpr->field;
  1937.         return new AST\IndexBy($pathExpr);
  1938.     }
  1940.     /**
  1941.      * ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DateTimePrimary |
  1942.      *                      StateFieldPathExpression | BooleanPrimary | CaseExpression |
  1943.      *                      InstanceOfExpression
  1944.      *
  1945.      * @return mixed One of the possible expressions or subexpressions.
  1946.      */
  1947.     public function ScalarExpression()
  1948.     {
  1949.         $lookahead = $this->lexer->lookahead['type'];
  1950.         $peek      = $this->lexer->glimpse();
  1952.         switch (true) {
  1953.             case ($lookahead === Lexer::T_INTEGER):
  1954.             case ($lookahead === Lexer::T_FLOAT):
  1955.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )  or ( - 1 ) or ( + 1 )
  1956.             case ($lookahead === Lexer::T_MINUS):
  1957.             case ($lookahead === Lexer::T_PLUS):
  1958.                 return $this->SimpleArithmeticExpression();
  1960.             case ($lookahead === Lexer::T_STRING):
  1961.                 return $this->StringPrimary();
  1963.             case ($lookahead === Lexer::T_TRUE):
  1964.             case ($lookahead === Lexer::T_FALSE):
  1965.                 $this->match($lookahead);
  1967.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  1969.             case ($lookahead === Lexer::T_INPUT_PARAMETER):
  1970.                 switch (true) {
  1971.                     case $this->isMathOperator($peek):
  1972.                         // :param + u.value
  1973.                         return $this->SimpleArithmeticExpression();
  1974.                     default:
  1975.                         return $this->InputParameter();
  1976.                 }
  1978.             case ($lookahead === Lexer::T_CASE):
  1979.             case ($lookahead === Lexer::T_COALESCE):
  1980.             case ($lookahead === Lexer::T_NULLIF):
  1981.                 // Since NULLIF and COALESCE can be identified as a function,
  1982.                 // we need to check these before checking for FunctionDeclaration
  1983.                 return $this->CaseExpression();
  1985.             case ($lookahead === Lexer::T_OPEN_PARENTHESIS):
  1986.                 return $this->SimpleArithmeticExpression();
  1988.             // this check must be done before checking for a filed path expression
  1989.             case ($this->isFunction()):
  1990.                 $this->lexer->peek(); // "("
  1992.                 switch (true) {
  1993.                     case ($this->isMathOperator($this->peekBeyondClosingParenthesis())):
  1994.                         // SUM(u.id) + COUNT(u.id)
  1995.                         return $this->SimpleArithmeticExpression();
  1997.                     default:
  1998.                         // IDENTITY(u)
  1999.                         return $this->FunctionDeclaration();
  2000.                 }
  2002.                 break;
  2003.             // it is no function, so it must be a field path
  2004.             case ($lookahead === Lexer::T_IDENTIFIER):
  2005.                 $this->lexer->peek(); // lookahead => '.'
  2006.                 $this->lexer->peek(); // lookahead => token after '.'
  2007.                 $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  2008.                 $this->lexer->resetPeek();
  2010.                 if ($this->isMathOperator($peek)) {
  2011.                     return $this->SimpleArithmeticExpression();
  2012.                 }
  2014.                 return $this->StateFieldPathExpression();
  2016.             default:
  2017.                 $this->syntaxError();
  2018.         }
  2019.     }
  2021.     /**
  2022.      * CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullifExpression
  2023.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2024.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2025.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2026.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2027.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2028.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2029.      * NullifExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2030.      *
  2031.      * @return mixed One of the possible expressions or subexpressions.
  2032.      */
  2033.     public function CaseExpression()
  2034.     {
  2035.         $lookahead = $this->lexer->lookahead['type'];
  2037.         switch ($lookahead) {
  2038.             case Lexer::T_NULLIF:
  2039.                 return $this->NullIfExpression();
  2041.             case Lexer::T_COALESCE:
  2042.                 return $this->CoalesceExpression();
  2044.             case Lexer::T_CASE:
  2045.                 $this->lexer->resetPeek();
  2046.                 $peek = $this->lexer->peek();
  2048.                 if ($peek['type'] === Lexer::T_WHEN) {
  2049.                     return $this->GeneralCaseExpression();
  2050.                 }
  2052.                 return $this->SimpleCaseExpression();
  2054.             default:
  2055.                 // Do nothing
  2056.                 break;
  2057.         }
  2059.         $this->syntaxError();
  2060.     }
  2062.     /**
  2063.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2064.      *
  2065.      * @return \Doctrine\ORM\Query\AST\CoalesceExpression
  2066.      */
  2067.     public function CoalesceExpression()
  2068.     {
  2069.         $this->match(Lexer::T_COALESCE);
  2070.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2072.         // Process ScalarExpressions (1..N)
  2073.         $scalarExpressions = [];
  2074.         $scalarExpressions[] = $this->ScalarExpression();
  2076.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  2077.             $this->match(Lexer::T_COMMA);
  2079.             $scalarExpressions[] = $this->ScalarExpression();
  2080.         }
  2082.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2084.         return new AST\CoalesceExpression($scalarExpressions);
  2085.     }
  2087.     /**
  2088.      * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2089.      *
  2090.      * @return \Doctrine\ORM\Query\AST\NullIfExpression
  2091.      */
  2092.     public function NullIfExpression()
  2093.     {
  2094.         $this->match(Lexer::T_NULLIF);
  2095.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2097.         $firstExpression = $this->ScalarExpression();
  2098.         $this->match(Lexer::T_COMMA);
  2099.         $secondExpression = $this->ScalarExpression();
  2101.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2103.         return new AST\NullIfExpression($firstExpression, $secondExpression);
  2104.     }
  2106.     /**
  2107.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2108.      *
  2109.      * @return \Doctrine\ORM\Query\AST\GeneralCaseExpression
  2110.      */
  2111.     public function GeneralCaseExpression()
  2112.     {
  2113.         $this->match(Lexer::T_CASE);
  2115.         // Process WhenClause (1..N)
  2116.         $whenClauses = [];
  2118.         do {
  2119.             $whenClauses[] = $this->WhenClause();
  2120.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2122.         $this->match(Lexer::T_ELSE);
  2123.         $scalarExpression = $this->ScalarExpression();
  2124.         $this->match(Lexer::T_END);
  2126.         return new AST\GeneralCaseExpression($whenClauses, $scalarExpression);
  2127.     }
  2129.     /**
  2130.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2131.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2132.      *
  2133.      * @return AST\SimpleCaseExpression
  2134.      */
  2135.     public function SimpleCaseExpression()
  2136.     {
  2137.         $this->match(Lexer::T_CASE);
  2138.         $caseOperand = $this->StateFieldPathExpression();
  2140.         // Process SimpleWhenClause (1..N)
  2141.         $simpleWhenClauses = [];
  2143.         do {
  2144.             $simpleWhenClauses[] = $this->SimpleWhenClause();
  2145.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2147.         $this->match(Lexer::T_ELSE);
  2148.         $scalarExpression = $this->ScalarExpression();
  2149.         $this->match(Lexer::T_END);
  2151.         return new AST\SimpleCaseExpression($caseOperand, $simpleWhenClauses, $scalarExpression);
  2152.     }
  2154.     /**
  2155.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2156.      *
  2157.      * @return \Doctrine\ORM\Query\AST\WhenClause
  2158.      */
  2159.     public function WhenClause()
  2160.     {
  2161.         $this->match(Lexer::T_WHEN);
  2162.         $conditionalExpression = $this->ConditionalExpression();
  2163.         $this->match(Lexer::T_THEN);
  2165.         return new AST\WhenClause($conditionalExpression, $this->ScalarExpression());
  2166.     }
  2168.     /**
  2169.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2170.      *
  2171.      * @return \Doctrine\ORM\Query\AST\SimpleWhenClause
  2172.      */
  2173.     public function SimpleWhenClause()
  2174.     {
  2175.         $this->match(Lexer::T_WHEN);
  2176.         $conditionalExpression = $this->ScalarExpression();
  2177.         $this->match(Lexer::T_THEN);
  2179.         return new AST\SimpleWhenClause($conditionalExpression, $this->ScalarExpression());
  2180.     }
  2182.     /**
  2183.      * SelectExpression ::= (
  2184.      *     IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration |
  2185.      *     PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression
  2186.      * ) [["AS"] ["HIDDEN"] AliasResultVariable]
  2187.      *
  2188.      * @return \Doctrine\ORM\Query\AST\SelectExpression
  2189.      */
  2190.     public function SelectExpression()
  2191.     {
  2192.         $expression    = null;
  2193.         $identVariable = null;
  2194.         $peek          = $this->lexer->glimpse();
  2195.         $lookaheadType = $this->lexer->lookahead['type'];
  2197.         switch (true) {
  2198.             // ScalarExpression (u.name)
  2199.             case ($lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] === Lexer::T_DOT):
  2200.                 $expression = $this->ScalarExpression();
  2201.                 break;
  2203.             // IdentificationVariable (u)
  2204.             case ($lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] !== Lexer::T_OPEN_PARENTHESIS):
  2205.                 $expression = $identVariable = $this->IdentificationVariable();
  2206.                 break;
  2208.             // CaseExpression (CASE ... or NULLIF(...) or COALESCE(...))
  2209.             case ($lookaheadType === Lexer::T_CASE):
  2210.             case ($lookaheadType === Lexer::T_COALESCE):
  2211.             case ($lookaheadType === Lexer::T_NULLIF):
  2212.                 $expression = $this->CaseExpression();
  2213.                 break;
  2215.             // DQL Function (SUM(u.value) or SUM(u.value) + 1)
  2216.             case ($this->isFunction()):
  2217.                 $this->lexer->peek(); // "("
  2219.                 switch (true) {
  2220.                     case ($this->isMathOperator($this->peekBeyondClosingParenthesis())):
  2221.                         // SUM(u.id) + COUNT(u.id)
  2222.                         $expression = $this->ScalarExpression();
  2223.                         break;
  2225.                     default:
  2226.                         // IDENTITY(u)
  2227.                         $expression = $this->FunctionDeclaration();
  2228.                         break;
  2229.                 }
  2231.                 break;
  2233.             // PartialObjectExpression (PARTIAL u.{id, name})
  2234.             case ($lookaheadType === Lexer::T_PARTIAL):
  2235.                 $expression    = $this->PartialObjectExpression();
  2236.                 $identVariable = $expression->identificationVariable;
  2237.                 break;
  2239.             // Subselect
  2240.             case ($lookaheadType === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT):
  2241.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2242.                 $expression = $this->Subselect();
  2243.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2244.                 break;
  2246.             // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2247.             case ($lookaheadType === Lexer::T_OPEN_PARENTHESIS):
  2248.             case ($lookaheadType === Lexer::T_INTEGER):
  2249.             case ($lookaheadType === Lexer::T_STRING):
  2250.             case ($lookaheadType === Lexer::T_FLOAT):
  2251.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )
  2252.             case ($lookaheadType === Lexer::T_MINUS):
  2253.             case ($lookaheadType === Lexer::T_PLUS):
  2254.                 $expression = $this->SimpleArithmeticExpression();
  2255.                 break;
  2257.             // NewObjectExpression (New ClassName(id, name))
  2258.             case ($lookaheadType === Lexer::T_NEW):
  2259.                 $expression = $this->NewObjectExpression();
  2260.                 break;
  2262.             default:
  2263.                 $this->syntaxError(
  2264.                     'IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression',
  2265.                     $this->lexer->lookahead
  2266.                 );
  2267.         }
  2269.         // [["AS"] ["HIDDEN"] AliasResultVariable]
  2270.         $mustHaveAliasResultVariable = false;
  2272.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2273.             $this->match(Lexer::T_AS);
  2275.             $mustHaveAliasResultVariable = true;
  2276.         }
  2278.         $hiddenAliasResultVariable = false;
  2280.         if ($this->lexer->isNextToken(Lexer::T_HIDDEN)) {
  2281.             $this->match(Lexer::T_HIDDEN);
  2283.             $hiddenAliasResultVariable = true;
  2284.         }
  2286.         $aliasResultVariable = null;
  2288.         if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2289.             $token = $this->lexer->lookahead;
  2290.             $aliasResultVariable = $this->AliasResultVariable();
  2292.             // Include AliasResultVariable in query components.
  2293.             $this->queryComponents[$aliasResultVariable] = [
  2294.                 'resultVariable' => $expression,
  2295.                 'nestingLevel'   => $this->nestingLevel,
  2296.                 'token'          => $token,
  2297.             ];
  2298.         }
  2300.         // AST
  2302.         $expr = new AST\SelectExpression($expression, $aliasResultVariable, $hiddenAliasResultVariable);
  2304.         if ($identVariable) {
  2305.             $this->identVariableExpressions[$identVariable] = $expr;
  2306.         }
  2308.         return $expr;
  2309.     }
  2311.     /**
  2312.      * SimpleSelectExpression ::= (
  2313.      *      StateFieldPathExpression | IdentificationVariable | FunctionDeclaration |
  2314.      *      AggregateExpression | "(" Subselect ")" | ScalarExpression
  2315.      * ) [["AS"] AliasResultVariable]
  2316.      *
  2317.      * @return \Doctrine\ORM\Query\AST\SimpleSelectExpression
  2318.      */
  2319.     public function SimpleSelectExpression()
  2320.     {
  2321.         $peek = $this->lexer->glimpse();
  2323.         switch ($this->lexer->lookahead['type']) {
  2324.             case Lexer::T_IDENTIFIER:
  2325.                 switch (true) {
  2326.                     case ($peek['type'] === Lexer::T_DOT):
  2327.                         $expression = $this->StateFieldPathExpression();
  2329.                         return new AST\SimpleSelectExpression($expression);
  2331.                     case ($peek['type'] !== Lexer::T_OPEN_PARENTHESIS):
  2332.                         $expression = $this->IdentificationVariable();
  2334.                         return new AST\SimpleSelectExpression($expression);
  2336.                     case ($this->isFunction()):
  2337.                         // SUM(u.id) + COUNT(u.id)
  2338.                         if ($this->isMathOperator($this->peekBeyondClosingParenthesis())) {
  2339.                             return new AST\SimpleSelectExpression($this->ScalarExpression());
  2340.                         }
  2341.                         // COUNT(u.id)
  2342.                         if ($this->isAggregateFunction($this->lexer->lookahead['type'])) {
  2343.                             return new AST\SimpleSelectExpression($this->AggregateExpression());
  2344.                         }
  2345.                         // IDENTITY(u)
  2346.                         return new AST\SimpleSelectExpression($this->FunctionDeclaration());
  2348.                     default:
  2349.                         // Do nothing
  2350.                 }
  2351.                 break;
  2353.             case Lexer::T_OPEN_PARENTHESIS:
  2354.                 if ($peek['type'] !== Lexer::T_SELECT) {
  2355.                     // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2356.                     $expression = $this->SimpleArithmeticExpression();
  2358.                     return new AST\SimpleSelectExpression($expression);
  2359.                 }
  2361.                 // Subselect
  2362.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2363.                 $expression = $this->Subselect();
  2364.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2366.                 return new AST\SimpleSelectExpression($expression);
  2368.             default:
  2369.                 // Do nothing
  2370.         }
  2372.         $this->lexer->peek();
  2374.         $expression = $this->ScalarExpression();
  2375.         $expr       = new AST\SimpleSelectExpression($expression);
  2377.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2378.             $this->match(Lexer::T_AS);
  2379.         }
  2381.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2382.             $token = $this->lexer->lookahead;
  2383.             $resultVariable = $this->AliasResultVariable();
  2384.             $expr->fieldIdentificationVariable = $resultVariable;
  2386.             // Include AliasResultVariable in query components.
  2387.             $this->queryComponents[$resultVariable] = [
  2388.                 'resultvariable' => $expr,
  2389.                 'nestingLevel'   => $this->nestingLevel,
  2390.                 'token'          => $token,
  2391.             ];
  2392.         }
  2394.         return $expr;
  2395.     }
  2397.     /**
  2398.      * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
  2399.      *
  2400.      * @return AST\ConditionalExpression|AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2401.      */
  2402.     public function ConditionalExpression()
  2403.     {
  2404.         $conditionalTerms = [];
  2405.         $conditionalTerms[] = $this->ConditionalTerm();
  2407.         while ($this->lexer->isNextToken(Lexer::T_OR)) {
  2408.             $this->match(Lexer::T_OR);
  2410.             $conditionalTerms[] = $this->ConditionalTerm();
  2411.         }
  2413.         // Phase 1 AST optimization: Prevent AST\ConditionalExpression
  2414.         // if only one AST\ConditionalTerm is defined
  2415.         if (count($conditionalTerms) == 1) {
  2416.             return $conditionalTerms[0];
  2417.         }
  2419.         return new AST\ConditionalExpression($conditionalTerms);
  2420.     }
  2422.     /**
  2423.      * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
  2424.      *
  2425.      * @return AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2426.      */
  2427.     public function ConditionalTerm()
  2428.     {
  2429.         $conditionalFactors = [];
  2430.         $conditionalFactors[] = $this->ConditionalFactor();
  2432.         while ($this->lexer->isNextToken(Lexer::T_AND)) {
  2433.             $this->match(Lexer::T_AND);
  2435.             $conditionalFactors[] = $this->ConditionalFactor();
  2436.         }
  2438.         // Phase 1 AST optimization: Prevent AST\ConditionalTerm
  2439.         // if only one AST\ConditionalFactor is defined
  2440.         if (count($conditionalFactors) == 1) {
  2441.             return $conditionalFactors[0];
  2442.         }
  2444.         return new AST\ConditionalTerm($conditionalFactors);
  2445.     }
  2447.     /**
  2448.      * ConditionalFactor ::= ["NOT"] ConditionalPrimary
  2449.      *
  2450.      * @return AST\ConditionalFactor|AST\ConditionalPrimary
  2451.      */
  2452.     public function ConditionalFactor()
  2453.     {
  2454.         $not = false;
  2456.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2457.             $this->match(Lexer::T_NOT);
  2459.             $not = true;
  2460.         }
  2462.         $conditionalPrimary = $this->ConditionalPrimary();
  2464.         // Phase 1 AST optimization: Prevent AST\ConditionalFactor
  2465.         // if only one AST\ConditionalPrimary is defined
  2466.         if ( ! $not) {
  2467.             return $conditionalPrimary;
  2468.         }
  2470.         $conditionalFactor = new AST\ConditionalFactor($conditionalPrimary);
  2471.         $conditionalFactor->not = $not;
  2473.         return $conditionalFactor;
  2474.     }
  2476.     /**
  2477.      * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
  2478.      *
  2479.      * @return \Doctrine\ORM\Query\AST\ConditionalPrimary
  2480.      */
  2481.     public function ConditionalPrimary()
  2482.     {
  2483.         $condPrimary = new AST\ConditionalPrimary;
  2485.         if ( ! $this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2486.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2488.             return $condPrimary;
  2489.         }
  2491.         // Peek beyond the matching closing parenthesis ')'
  2492.         $peek = $this->peekBeyondClosingParenthesis();
  2494.         if ($peek !== null && (
  2495.             in_array($peek['value'], ['=', '<', '<=', '<>', '>', '>=', '!=']) ||
  2496.             in_array($peek['type'], [Lexer::T_NOT, Lexer::T_BETWEEN, Lexer::T_LIKE, Lexer::T_IN, Lexer::T_IS, Lexer::T_EXISTS]) ||
  2497.             $this->isMathOperator($peek)
  2498.         )) {
  2499.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2501.             return $condPrimary;
  2502.         }
  2504.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2505.         $condPrimary->conditionalExpression = $this->ConditionalExpression();
  2506.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2508.         return $condPrimary;
  2509.     }
  2511.     /**
  2512.      * SimpleConditionalExpression ::=
  2513.      *      ComparisonExpression | BetweenExpression | LikeExpression |
  2514.      *      InExpression | NullComparisonExpression | ExistsExpression |
  2515.      *      EmptyCollectionComparisonExpression | CollectionMemberExpression |
  2516.      *      InstanceOfExpression
  2517.      */
  2518.     public function SimpleConditionalExpression()
  2519.     {
  2520.         if ($this->lexer->isNextToken(Lexer::T_EXISTS)) {
  2521.             return $this->ExistsExpression();
  2522.         }
  2524.         $token      = $this->lexer->lookahead;
  2525.         $peek       = $this->lexer->glimpse();
  2526.         $lookahead  = $token;
  2528.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2529.             $token = $this->lexer->glimpse();
  2530.         }
  2532.         if ($token['type'] === Lexer::T_IDENTIFIER || $token['type'] === Lexer::T_INPUT_PARAMETER || $this->isFunction()) {
  2533.             // Peek beyond the matching closing parenthesis.
  2534.             $beyond = $this->lexer->peek();
  2536.             switch ($peek['value']) {
  2537.                 case '(':
  2538.                     // Peeks beyond the matched closing parenthesis.
  2539.                     $token = $this->peekBeyondClosingParenthesis(false);
  2541.                     if ($token['type'] === Lexer::T_NOT) {
  2542.                         $token = $this->lexer->peek();
  2543.                     }
  2545.                     if ($token['type'] === Lexer::T_IS) {
  2546.                         $lookahead = $this->lexer->peek();
  2547.                     }
  2548.                     break;
  2550.                 default:
  2551.                     // Peek beyond the PathExpression or InputParameter.
  2552.                     $token = $beyond;
  2554.                     while ($token['value'] === '.') {
  2555.                         $this->lexer->peek();
  2557.                         $token = $this->lexer->peek();
  2558.                     }
  2560.                     // Also peek beyond a NOT if there is one.
  2561.                     if ($token['type'] === Lexer::T_NOT) {
  2562.                         $token = $this->lexer->peek();
  2563.                     }
  2565.                     // We need to go even further in case of IS (differentiate between NULL and EMPTY)
  2566.                     $lookahead = $this->lexer->peek();
  2567.             }
  2569.             // Also peek beyond a NOT if there is one.
  2570.             if ($lookahead['type'] === Lexer::T_NOT) {
  2571.                 $lookahead = $this->lexer->peek();
  2572.             }
  2574.             $this->lexer->resetPeek();
  2575.         }
  2577.         if ($token['type'] === Lexer::T_BETWEEN) {
  2578.             return $this->BetweenExpression();
  2579.         }
  2581.         if ($token['type'] === Lexer::T_LIKE) {
  2582.             return $this->LikeExpression();
  2583.         }
  2585.         if ($token['type'] === Lexer::T_IN) {
  2586.             return $this->InExpression();
  2587.         }
  2589.         if ($token['type'] === Lexer::T_INSTANCE) {
  2590.             return $this->InstanceOfExpression();
  2591.         }
  2593.         if ($token['type'] === Lexer::T_MEMBER) {
  2594.             return $this->CollectionMemberExpression();
  2595.         }
  2597.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_NULL) {
  2598.             return $this->NullComparisonExpression();
  2599.         }
  2601.         if ($token['type'] === Lexer::T_IS  && $lookahead['type'] === Lexer::T_EMPTY) {
  2602.             return $this->EmptyCollectionComparisonExpression();
  2603.         }
  2605.         return $this->ComparisonExpression();
  2606.     }
  2608.     /**
  2609.      * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
  2610.      *
  2611.      * @return \Doctrine\ORM\Query\AST\EmptyCollectionComparisonExpression
  2612.      */
  2613.     public function EmptyCollectionComparisonExpression()
  2614.     {
  2615.         $emptyCollectionCompExpr = new AST\EmptyCollectionComparisonExpression(
  2616.             $this->CollectionValuedPathExpression()
  2617.         );
  2618.         $this->match(Lexer::T_IS);
  2620.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2621.             $this->match(Lexer::T_NOT);
  2622.             $emptyCollectionCompExpr->not = true;
  2623.         }
  2625.         $this->match(Lexer::T_EMPTY);
  2627.         return $emptyCollectionCompExpr;
  2628.     }
  2630.     /**
  2631.      * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
  2632.      *
  2633.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2634.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2635.      *
  2636.      * @return \Doctrine\ORM\Query\AST\CollectionMemberExpression
  2637.      */
  2638.     public function CollectionMemberExpression()
  2639.     {
  2640.         $not        = false;
  2641.         $entityExpr = $this->EntityExpression();
  2643.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2644.             $this->match(Lexer::T_NOT);
  2646.             $not = true;
  2647.         }
  2649.         $this->match(Lexer::T_MEMBER);
  2651.         if ($this->lexer->isNextToken(Lexer::T_OF)) {
  2652.             $this->match(Lexer::T_OF);
  2653.         }
  2655.         $collMemberExpr = new AST\CollectionMemberExpression(
  2656.             $entityExpr, $this->CollectionValuedPathExpression()
  2657.         );
  2658.         $collMemberExpr->not = $not;
  2660.         return $collMemberExpr;
  2661.     }
  2663.     /**
  2664.      * Literal ::= string | char | integer | float | boolean
  2665.      *
  2666.      * @return \Doctrine\ORM\Query\AST\Literal
  2667.      */
  2668.     public function Literal()
  2669.     {
  2670.         switch ($this->lexer->lookahead['type']) {
  2671.             case Lexer::T_STRING:
  2672.                 $this->match(Lexer::T_STRING);
  2674.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  2675.             case Lexer::T_INTEGER:
  2676.             case Lexer::T_FLOAT:
  2677.                 $this->match(
  2678.                     $this->lexer->isNextToken(Lexer::T_INTEGER) ? Lexer::T_INTEGER : Lexer::T_FLOAT
  2679.                 );
  2681.                 return new AST\Literal(AST\Literal::NUMERIC, $this->lexer->token['value']);
  2682.             case Lexer::T_TRUE:
  2683.             case Lexer::T_FALSE:
  2684.                 $this->match(
  2685.                     $this->lexer->isNextToken(Lexer::T_TRUE) ? Lexer::T_TRUE : Lexer::T_FALSE
  2686.                 );
  2688.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2689.             default:
  2690.                 $this->syntaxError('Literal');
  2691.         }
  2692.     }
  2694.     /**
  2695.      * InParameter ::= Literal | InputParameter
  2696.      *
  2697.      * @return AST\InputParameter|AST\Literal
  2698.      */
  2699.     public function InParameter()
  2700.     {
  2701.         if ($this->lexer->lookahead['type'] == Lexer::T_INPUT_PARAMETER) {
  2702.             return $this->InputParameter();
  2703.         }
  2705.         return $this->Literal();
  2706.     }
  2708.     /**
  2709.      * InputParameter ::= PositionalParameter | NamedParameter
  2710.      *
  2711.      * @return \Doctrine\ORM\Query\AST\InputParameter
  2712.      */
  2713.     public function InputParameter()
  2714.     {
  2715.         $this->match(Lexer::T_INPUT_PARAMETER);
  2717.         return new AST\InputParameter($this->lexer->token['value']);
  2718.     }
  2720.     /**
  2721.      * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
  2722.      *
  2723.      * @return \Doctrine\ORM\Query\AST\ArithmeticExpression
  2724.      */
  2725.     public function ArithmeticExpression()
  2726.     {
  2727.         $expr = new AST\ArithmeticExpression;
  2729.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2730.             $peek = $this->lexer->glimpse();
  2732.             if ($peek['type'] === Lexer::T_SELECT) {
  2733.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2734.                 $expr->subselect = $this->Subselect();
  2735.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2737.                 return $expr;
  2738.             }
  2739.         }
  2741.         $expr->simpleArithmeticExpression = $this->SimpleArithmeticExpression();
  2743.         return $expr;
  2744.     }
  2746.     /**
  2747.      * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
  2748.      *
  2749.      * @return \Doctrine\ORM\Query\AST\SimpleArithmeticExpression
  2750.      */
  2751.     public function SimpleArithmeticExpression()
  2752.     {
  2753.         $terms = [];
  2754.         $terms[] = $this->ArithmeticTerm();
  2756.         while (($isPlus = $this->lexer->isNextToken(Lexer::T_PLUS)) || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2757.             $this->match(($isPlus) ? Lexer::T_PLUS : Lexer::T_MINUS);
  2759.             $terms[] = $this->lexer->token['value'];
  2760.             $terms[] = $this->ArithmeticTerm();
  2761.         }
  2763.         // Phase 1 AST optimization: Prevent AST\SimpleArithmeticExpression
  2764.         // if only one AST\ArithmeticTerm is defined
  2765.         if (count($terms) == 1) {
  2766.             return $terms[0];
  2767.         }
  2769.         return new AST\SimpleArithmeticExpression($terms);
  2770.     }
  2772.     /**
  2773.      * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
  2774.      *
  2775.      * @return \Doctrine\ORM\Query\AST\ArithmeticTerm
  2776.      */
  2777.     public function ArithmeticTerm()
  2778.     {
  2779.         $factors = [];
  2780.         $factors[] = $this->ArithmeticFactor();
  2782.         while (($isMult = $this->lexer->isNextToken(Lexer::T_MULTIPLY)) || $this->lexer->isNextToken(Lexer::T_DIVIDE)) {
  2783.             $this->match(($isMult) ? Lexer::T_MULTIPLY : Lexer::T_DIVIDE);
  2785.             $factors[] = $this->lexer->token['value'];
  2786.             $factors[] = $this->ArithmeticFactor();
  2787.         }
  2789.         // Phase 1 AST optimization: Prevent AST\ArithmeticTerm
  2790.         // if only one AST\ArithmeticFactor is defined
  2791.         if (count($factors) == 1) {
  2792.             return $factors[0];
  2793.         }
  2795.         return new AST\ArithmeticTerm($factors);
  2796.     }
  2798.     /**
  2799.      * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
  2800.      *
  2801.      * @return \Doctrine\ORM\Query\AST\ArithmeticFactor
  2802.      */
  2803.     public function ArithmeticFactor()
  2804.     {
  2805.         $sign = null;
  2807.         if (($isPlus = $this->lexer->isNextToken(Lexer::T_PLUS)) || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2808.             $this->match(($isPlus) ? Lexer::T_PLUS : Lexer::T_MINUS);
  2809.             $sign = $isPlus;
  2810.         }
  2812.         $primary = $this->ArithmeticPrimary();
  2814.         // Phase 1 AST optimization: Prevent AST\ArithmeticFactor
  2815.         // if only one AST\ArithmeticPrimary is defined
  2816.         if ($sign === null) {
  2817.             return $primary;
  2818.         }
  2820.         return new AST\ArithmeticFactor($primary, $sign);
  2821.     }
  2823.     /**
  2824.      * ArithmeticPrimary ::= SingleValuedPathExpression | Literal | ParenthesisExpression
  2825.      *          | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings
  2826.      *          | FunctionsReturningDatetime | IdentificationVariable | ResultVariable
  2827.      *          | InputParameter | CaseExpression
  2828.      */
  2829.     public function ArithmeticPrimary()
  2830.     {
  2831.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2832.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2834.             $expr = $this->SimpleArithmeticExpression();
  2836.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2838.             return new AST\ParenthesisExpression($expr);
  2839.         }
  2841.         switch ($this->lexer->lookahead['type']) {
  2842.             case Lexer::T_COALESCE:
  2843.             case Lexer::T_NULLIF:
  2844.             case Lexer::T_CASE:
  2845.                 return $this->CaseExpression();
  2847.             case Lexer::T_IDENTIFIER:
  2848.                 $peek = $this->lexer->glimpse();
  2850.                 if ($peek !== null && $peek['value'] === '(') {
  2851.                     return $this->FunctionDeclaration();
  2852.                 }
  2854.                 if ($peek !== null && $peek['value'] === '.') {
  2855.                     return $this->SingleValuedPathExpression();
  2856.                 }
  2858.                 if (isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])) {
  2859.                     return $this->ResultVariable();
  2860.                 }
  2862.                 return $this->StateFieldPathExpression();
  2864.             case Lexer::T_INPUT_PARAMETER:
  2865.                 return $this->InputParameter();
  2867.             default:
  2868.                 $peek = $this->lexer->glimpse();
  2870.                 if ($peek !== null && $peek['value'] === '(') {
  2871.                     return $this->FunctionDeclaration();
  2872.                 }
  2874.                 return $this->Literal();
  2875.         }
  2876.     }
  2878.     /**
  2879.      * StringExpression ::= StringPrimary | ResultVariable | "(" Subselect ")"
  2880.      *
  2881.      * @return Subselect|string
  2882.      */
  2883.     public function StringExpression()
  2884.     {
  2885.         $peek = $this->lexer->glimpse();
  2887.         // Subselect
  2888.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $peek['type'] === Lexer::T_SELECT) {
  2889.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2890.             $expr = $this->Subselect();
  2891.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2893.             return $expr;
  2894.         }
  2896.         // ResultVariable (string)
  2897.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER) &&
  2898.             isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])) {
  2899.             return $this->ResultVariable();
  2900.         }
  2902.         return $this->StringPrimary();
  2903.     }
  2905.     /**
  2906.      * StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression
  2907.      */
  2908.     public function StringPrimary()
  2909.     {
  2910.         $lookaheadType = $this->lexer->lookahead['type'];
  2912.         switch ($lookaheadType) {
  2913.             case Lexer::T_IDENTIFIER:
  2914.                 $peek = $this->lexer->glimpse();
  2916.                 if ($peek['value'] == '.') {
  2917.                     return $this->StateFieldPathExpression();
  2918.                 }
  2920.                 if ($peek['value'] == '(') {
  2921.                     // do NOT directly go to FunctionsReturningString() because it doesn't check for custom functions.
  2922.                     return $this->FunctionDeclaration();
  2923.                 }
  2925.                 $this->syntaxError("'.' or '('");
  2926.                 break;
  2928.             case Lexer::T_STRING:
  2929.                 $this->match(Lexer::T_STRING);
  2931.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  2933.             case Lexer::T_INPUT_PARAMETER:
  2934.                 return $this->InputParameter();
  2936.             case Lexer::T_CASE:
  2937.             case Lexer::T_COALESCE:
  2938.             case Lexer::T_NULLIF:
  2939.                 return $this->CaseExpression();
  2940.             default:
  2941.                 if ($this->isAggregateFunction($lookaheadType)) {
  2942.                     return $this->AggregateExpression();
  2943.                 }
  2944.         }
  2946.         $this->syntaxError(
  2947.             'StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression'
  2948.         );
  2949.     }
  2951.     /**
  2952.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2953.      *
  2954.      * @return AST\InputParameter|PathExpression
  2955.      */
  2956.     public function EntityExpression()
  2957.     {
  2958.         $glimpse = $this->lexer->glimpse();
  2960.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER) && $glimpse['value'] === '.') {
  2961.             return $this->SingleValuedAssociationPathExpression();
  2962.         }
  2964.         return $this->SimpleEntityExpression();
  2965.     }
  2967.     /**
  2968.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2969.      *
  2970.      * @return AST\InputParameter|AST\PathExpression
  2971.      */
  2972.     public function SimpleEntityExpression()
  2973.     {
  2974.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  2975.             return $this->InputParameter();
  2976.         }
  2978.         return $this->StateFieldPathExpression();
  2979.     }
  2981.     /**
  2982.      * AggregateExpression ::=
  2983.      *  ("AVG" | "MAX" | "MIN" | "SUM" | "COUNT") "(" ["DISTINCT"] SimpleArithmeticExpression ")"
  2984.      *
  2985.      * @return \Doctrine\ORM\Query\AST\AggregateExpression
  2986.      */
  2987.     public function AggregateExpression()
  2988.     {
  2989.         $lookaheadType = $this->lexer->lookahead['type'];
  2990.         $isDistinct = false;
  2992.         if ( ! in_array($lookaheadType, [Lexer::T_COUNT, Lexer::T_AVG, Lexer::T_MAX, Lexer::T_MIN, Lexer::T_SUM])) {
  2993.             $this->syntaxError('One of: MAX, MIN, AVG, SUM, COUNT');
  2994.         }
  2996.         $this->match($lookaheadType);
  2997.         $functionName = $this->lexer->token['value'];
  2998.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3000.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  3001.             $this->match(Lexer::T_DISTINCT);
  3002.             $isDistinct = true;
  3003.         }
  3005.         $pathExp = $this->SimpleArithmeticExpression();
  3007.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3009.         return new AST\AggregateExpression($functionName, $pathExp, $isDistinct);
  3010.     }
  3012.     /**
  3013.      * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
  3014.      *
  3015.      * @return \Doctrine\ORM\Query\AST\QuantifiedExpression
  3016.      */
  3017.     public function QuantifiedExpression()
  3018.     {
  3019.         $lookaheadType = $this->lexer->lookahead['type'];
  3020.         $value = $this->lexer->lookahead['value'];
  3022.         if ( ! in_array($lookaheadType, [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME])) {
  3023.             $this->syntaxError('ALL, ANY or SOME');
  3024.         }
  3026.         $this->match($lookaheadType);
  3027.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3029.         $qExpr = new AST\QuantifiedExpression($this->Subselect());
  3030.         $qExpr->type = $value;
  3032.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3034.         return $qExpr;
  3035.     }
  3037.     /**
  3038.      * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
  3039.      *
  3040.      * @return \Doctrine\ORM\Query\AST\BetweenExpression
  3041.      */
  3042.     public function BetweenExpression()
  3043.     {
  3044.         $not = false;
  3045.         $arithExpr1 = $this->ArithmeticExpression();
  3047.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3048.             $this->match(Lexer::T_NOT);
  3049.             $not = true;
  3050.         }
  3052.         $this->match(Lexer::T_BETWEEN);
  3053.         $arithExpr2 = $this->ArithmeticExpression();
  3054.         $this->match(Lexer::T_AND);
  3055.         $arithExpr3 = $this->ArithmeticExpression();
  3057.         $betweenExpr = new AST\BetweenExpression($arithExpr1, $arithExpr2, $arithExpr3);
  3058.         $betweenExpr->not = $not;
  3060.         return $betweenExpr;
  3061.     }
  3063.     /**
  3064.      * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )
  3065.      *
  3066.      * @return \Doctrine\ORM\Query\AST\ComparisonExpression
  3067.      */
  3068.     public function ComparisonExpression()
  3069.     {
  3070.         $this->lexer->glimpse();
  3072.         $leftExpr  = $this->ArithmeticExpression();
  3073.         $operator  = $this->ComparisonOperator();
  3074.         $rightExpr = ($this->isNextAllAnySome())
  3075.             ? $this->QuantifiedExpression()
  3076.             : $this->ArithmeticExpression();
  3078.         return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
  3079.     }
  3081.     /**
  3082.      * InExpression ::= SingleValuedPathExpression ["NOT"] "IN" "(" (InParameter {"," InParameter}* | Subselect) ")"
  3083.      *
  3084.      * @return \Doctrine\ORM\Query\AST\InExpression
  3085.      */
  3086.     public function InExpression()
  3087.     {
  3088.         $inExpression = new AST\InExpression($this->ArithmeticExpression());
  3090.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3091.             $this->match(Lexer::T_NOT);
  3092.             $inExpression->not = true;
  3093.         }
  3095.         $this->match(Lexer::T_IN);
  3096.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3098.         if ($this->lexer->isNextToken(Lexer::T_SELECT)) {
  3099.             $inExpression->subselect = $this->Subselect();
  3100.         } else {
  3101.             $literals = [];
  3102.             $literals[] = $this->InParameter();
  3104.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3105.                 $this->match(Lexer::T_COMMA);
  3106.                 $literals[] = $this->InParameter();
  3107.             }
  3109.             $inExpression->literals = $literals;
  3110.         }
  3112.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3114.         return $inExpression;
  3115.     }
  3117.     /**
  3118.      * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
  3119.      *
  3120.      * @return \Doctrine\ORM\Query\AST\InstanceOfExpression
  3121.      */
  3122.     public function InstanceOfExpression()
  3123.     {
  3124.         $instanceOfExpression = new AST\InstanceOfExpression($this->IdentificationVariable());
  3126.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3127.             $this->match(Lexer::T_NOT);
  3128.             $instanceOfExpression->not = true;
  3129.         }
  3131.         $this->match(Lexer::T_INSTANCE);
  3132.         $this->match(Lexer::T_OF);
  3134.         $exprValues = [];
  3136.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  3137.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  3139.             $exprValues[] = $this->InstanceOfParameter();
  3141.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3142.                 $this->match(Lexer::T_COMMA);
  3144.                 $exprValues[] = $this->InstanceOfParameter();
  3145.             }
  3147.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3149.             $instanceOfExpression->value = $exprValues;
  3151.             return $instanceOfExpression;
  3152.         }
  3154.         $exprValues[] = $this->InstanceOfParameter();
  3156.         $instanceOfExpression->value = $exprValues;
  3158.         return $instanceOfExpression;
  3159.     }
  3161.     /**
  3162.      * InstanceOfParameter ::= AbstractSchemaName | InputParameter
  3163.      *
  3164.      * @return mixed
  3165.      */
  3166.     public function InstanceOfParameter()
  3167.     {
  3168.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3169.             $this->match(Lexer::T_INPUT_PARAMETER);
  3171.             return new AST\InputParameter($this->lexer->token['value']);
  3172.         }
  3174.         $abstractSchemaName = $this->AbstractSchemaName();
  3176.         $this->validateAbstractSchemaName($abstractSchemaName);
  3178.         return $abstractSchemaName;
  3179.     }
  3181.     /**
  3182.      * LikeExpression ::= StringExpression ["NOT"] "LIKE" StringPrimary ["ESCAPE" char]
  3183.      *
  3184.      * @return \Doctrine\ORM\Query\AST\LikeExpression
  3185.      */
  3186.     public function LikeExpression()
  3187.     {
  3188.         $stringExpr = $this->StringExpression();
  3189.         $not = false;
  3191.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3192.             $this->match(Lexer::T_NOT);
  3193.             $not = true;
  3194.         }
  3196.         $this->match(Lexer::T_LIKE);
  3198.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3199.             $this->match(Lexer::T_INPUT_PARAMETER);
  3200.             $stringPattern = new AST\InputParameter($this->lexer->token['value']);
  3201.         } else {
  3202.             $stringPattern = $this->StringPrimary();
  3203.         }
  3205.         $escapeChar = null;
  3207.         if ($this->lexer->lookahead !== null && $this->lexer->lookahead['type'] === Lexer::T_ESCAPE) {
  3208.             $this->match(Lexer::T_ESCAPE);
  3209.             $this->match(Lexer::T_STRING);
  3211.             $escapeChar = new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3212.         }
  3214.         $likeExpr = new AST\LikeExpression($stringExpr, $stringPattern, $escapeChar);
  3215.         $likeExpr->not = $not;
  3217.         return $likeExpr;
  3218.     }
  3220.     /**
  3221.      * NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) "IS" ["NOT"] "NULL"
  3222.      *
  3223.      * @return \Doctrine\ORM\Query\AST\NullComparisonExpression
  3224.      */
  3225.     public function NullComparisonExpression()
  3226.     {
  3227.         switch (true) {
  3228.             case $this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER):
  3229.                 $this->match(Lexer::T_INPUT_PARAMETER);
  3231.                 $expr = new AST\InputParameter($this->lexer->token['value']);
  3232.                 break;
  3234.             case $this->lexer->isNextToken(Lexer::T_NULLIF):
  3235.                 $expr = $this->NullIfExpression();
  3236.                 break;
  3238.             case $this->lexer->isNextToken(Lexer::T_COALESCE):
  3239.                 $expr = $this->CoalesceExpression();
  3240.                 break;
  3242.             case $this->isFunction():
  3243.                 $expr = $this->FunctionDeclaration();
  3244.                 break;
  3246.             default:
  3247.                 // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  3248.                 $glimpse = $this->lexer->glimpse();
  3250.                 if ($glimpse['type'] === Lexer::T_DOT) {
  3251.                     $expr = $this->SingleValuedPathExpression();
  3253.                     // Leave switch statement
  3254.                     break;
  3255.                 }
  3257.                 $lookaheadValue = $this->lexer->lookahead['value'];
  3259.                 // Validate existing component
  3260.                 if ( ! isset($this->queryComponents[$lookaheadValue])) {
  3261.                     $this->semanticalError('Cannot add having condition on undefined result variable.');
  3262.                 }
  3264.                 // Validate SingleValuedPathExpression (ie.: "product")
  3265.                 if (isset($this->queryComponents[$lookaheadValue]['metadata'])) {
  3266.                     $expr = $this->SingleValuedPathExpression();
  3267.                     break;
  3268.                 }
  3270.                 // Validating ResultVariable
  3271.                 if ( ! isset($this->queryComponents[$lookaheadValue]['resultVariable'])) {
  3272.                     $this->semanticalError('Cannot add having condition on a non result variable.');
  3273.                 }
  3275.                 $expr = $this->ResultVariable();
  3276.                 break;
  3277.         }
  3279.         $nullCompExpr = new AST\NullComparisonExpression($expr);
  3281.         $this->match(Lexer::T_IS);
  3283.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3284.             $this->match(Lexer::T_NOT);
  3286.             $nullCompExpr->not = true;
  3287.         }
  3289.         $this->match(Lexer::T_NULL);
  3291.         return $nullCompExpr;
  3292.     }
  3294.     /**
  3295.      * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
  3296.      *
  3297.      * @return \Doctrine\ORM\Query\AST\ExistsExpression
  3298.      */
  3299.     public function ExistsExpression()
  3300.     {
  3301.         $not = false;
  3303.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3304.             $this->match(Lexer::T_NOT);
  3305.             $not = true;
  3306.         }
  3308.         $this->match(Lexer::T_EXISTS);
  3309.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3311.         $existsExpression = new AST\ExistsExpression($this->Subselect());
  3312.         $existsExpression->not = $not;
  3314.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3316.         return $existsExpression;
  3317.     }
  3319.     /**
  3320.      * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
  3321.      *
  3322.      * @return string
  3323.      */
  3324.     public function ComparisonOperator()
  3325.     {
  3326.         switch ($this->lexer->lookahead['value']) {
  3327.             case '=':
  3328.                 $this->match(Lexer::T_EQUALS);
  3330.                 return '=';
  3332.             case '<':
  3333.                 $this->match(Lexer::T_LOWER_THAN);
  3334.                 $operator = '<';
  3336.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3337.                     $this->match(Lexer::T_EQUALS);
  3338.                     $operator .= '=';
  3339.                 } else if ($this->lexer->isNextToken(Lexer::T_GREATER_THAN)) {
  3340.                     $this->match(Lexer::T_GREATER_THAN);
  3341.                     $operator .= '>';
  3342.                 }
  3344.                 return $operator;
  3346.             case '>':
  3347.                 $this->match(Lexer::T_GREATER_THAN);
  3348.                 $operator = '>';
  3350.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3351.                     $this->match(Lexer::T_EQUALS);
  3352.                     $operator .= '=';
  3353.                 }
  3355.                 return $operator;
  3357.             case '!':
  3358.                 $this->match(Lexer::T_NEGATE);
  3359.                 $this->match(Lexer::T_EQUALS);
  3361.                 return '<>';
  3363.             default:
  3364.                 $this->syntaxError('=, <, <=, <>, >, >=, !=');
  3365.         }
  3366.     }
  3368.     /**
  3369.      * FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDatetime
  3370.      *
  3371.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3372.      */
  3373.     public function FunctionDeclaration()
  3374.     {
  3375.         $token = $this->lexer->lookahead;
  3376.         $funcName = strtolower($token['value']);
  3378.         $customFunctionDeclaration = $this->CustomFunctionDeclaration();
  3380.         // Check for custom functions functions first!
  3381.         switch (true) {
  3382.             case $customFunctionDeclaration !== null:
  3383.                 return $customFunctionDeclaration;
  3385.             case (isset(self::$_STRING_FUNCTIONS[$funcName])):
  3386.                 return $this->FunctionsReturningStrings();
  3388.             case (isset(self::$_NUMERIC_FUNCTIONS[$funcName])):
  3389.                 return $this->FunctionsReturningNumerics();
  3391.             case (isset(self::$_DATETIME_FUNCTIONS[$funcName])):
  3392.                 return $this->FunctionsReturningDatetime();
  3394.             default:
  3395.                 $this->syntaxError('known function', $token);
  3396.         }
  3397.     }
  3399.     /**
  3400.      * Helper function for FunctionDeclaration grammar rule.
  3401.      *
  3402.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3403.      */
  3404.     private function CustomFunctionDeclaration()
  3405.     {
  3406.         $token = $this->lexer->lookahead;
  3407.         $funcName = strtolower($token['value']);
  3409.         // Check for custom functions afterwards
  3410.         $config = $this->em->getConfiguration();
  3412.         switch (true) {
  3413.             case ($config->getCustomStringFunction($funcName) !== null):
  3414.                 return $this->CustomFunctionsReturningStrings();
  3416.             case ($config->getCustomNumericFunction($funcName) !== null):
  3417.                 return $this->CustomFunctionsReturningNumerics();
  3419.             case ($config->getCustomDatetimeFunction($funcName) !== null):
  3420.                 return $this->CustomFunctionsReturningDatetime();
  3422.             default:
  3423.                 return null;
  3424.         }
  3425.     }
  3427.     /**
  3428.      * FunctionsReturningNumerics ::=
  3429.      *      "LENGTH" "(" StringPrimary ")" |
  3430.      *      "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")" |
  3431.      *      "ABS" "(" SimpleArithmeticExpression ")" |
  3432.      *      "SQRT" "(" SimpleArithmeticExpression ")" |
  3433.      *      "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3434.      *      "SIZE" "(" CollectionValuedPathExpression ")" |
  3435.      *      "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3436.      *      "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3437.      *      "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
  3438.      *
  3439.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3440.      */
  3441.     public function FunctionsReturningNumerics()
  3442.     {
  3443.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3444.         $funcClass     = self::$_NUMERIC_FUNCTIONS[$funcNameLower];
  3446.         $function = new $funcClass($funcNameLower);
  3447.         $function->parse($this);
  3449.         return $function;
  3450.     }
  3452.     /**
  3453.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3454.      */
  3455.     public function CustomFunctionsReturningNumerics()
  3456.     {
  3457.         // getCustomNumericFunction is case-insensitive
  3458.         $functionName  = strtolower($this->lexer->lookahead['value']);
  3459.         $functionClass = $this->em->getConfiguration()->getCustomNumericFunction($functionName);
  3461.         $function = is_string($functionClass)
  3462.             ? new $functionClass($functionName)
  3463.             : call_user_func($functionClass, $functionName);
  3465.         $function->parse($this);
  3467.         return $function;
  3468.     }
  3470.     /**
  3471.      * FunctionsReturningDateTime ::=
  3472.      *     "CURRENT_DATE" |
  3473.      *     "CURRENT_TIME" |
  3474.      *     "CURRENT_TIMESTAMP" |
  3475.      *     "DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")" |
  3476.      *     "DATE_SUB" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
  3477.      *
  3478.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3479.      */
  3480.     public function FunctionsReturningDatetime()
  3481.     {
  3482.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3483.         $funcClass     = self::$_DATETIME_FUNCTIONS[$funcNameLower];
  3485.         $function = new $funcClass($funcNameLower);
  3486.         $function->parse($this);
  3488.         return $function;
  3489.     }
  3491.     /**
  3492.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3493.      */
  3494.     public function CustomFunctionsReturningDatetime()
  3495.     {
  3496.         // getCustomDatetimeFunction is case-insensitive
  3497.         $functionName  = $this->lexer->lookahead['value'];
  3498.         $functionClass = $this->em->getConfiguration()->getCustomDatetimeFunction($functionName);
  3500.         $function = is_string($functionClass)
  3501.             ? new $functionClass($functionName)
  3502.             : call_user_func($functionClass, $functionName);
  3504.         $function->parse($this);
  3506.         return $function;
  3507.     }
  3509.     /**
  3510.      * FunctionsReturningStrings ::=
  3511.      *   "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary}* ")" |
  3512.      *   "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3513.      *   "TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")" |
  3514.      *   "LOWER" "(" StringPrimary ")" |
  3515.      *   "UPPER" "(" StringPrimary ")" |
  3516.      *   "IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
  3517.      *
  3518.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3519.      */
  3520.     public function FunctionsReturningStrings()
  3521.     {
  3522.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3523.         $funcClass     = self::$_STRING_FUNCTIONS[$funcNameLower];
  3525.         $function = new $funcClass($funcNameLower);
  3526.         $function->parse($this);
  3528.         return $function;
  3529.     }
  3531.     /**
  3532.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3533.      */
  3534.     public function CustomFunctionsReturningStrings()
  3535.     {
  3536.         // getCustomStringFunction is case-insensitive
  3537.         $functionName  = $this->lexer->lookahead['value'];
  3538.         $functionClass = $this->em->getConfiguration()->getCustomStringFunction($functionName);
  3540.         $function = is_string($functionClass)
  3541.             ? new $functionClass($functionName)
  3542.             : call_user_func($functionClass, $functionName);
  3544.         $function->parse($this);
  3546.         return $function;
  3547.     }
  3548. }