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

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\Functions;
  25. use function in_array;
  26. use function strpos;
  28. /**
  29.  * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  30.  * Parses a DQL query, reports any errors in it, and generates an AST.
  31.  *
  32.  * @since   2.0
  33.  * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
  34.  * @author  Jonathan Wage <jonwage@gmail.com>
  35.  * @author  Roman Borschel <roman@code-factory.org>
  36.  * @author  Janne Vanhala <jpvanhal@cc.hut.fi>
  37.  * @author  Fabio B. Silva <fabio.bat.silva@gmail.com>
  38.  */
  39. class Parser
  40. {
  41.     /**
  42.      * READ-ONLY: Maps BUILT-IN string function names to AST class names.
  43.      *
  44.      * @var array
  45.      */
  46.     private static $_STRING_FUNCTIONS = [
  47.         'concat'    => Functions\ConcatFunction::class,
  48.         'substring' => Functions\SubstringFunction::class,
  49.         'trim'      => Functions\TrimFunction::class,
  50.         'lower'     => Functions\LowerFunction::class,
  51.         'upper'     => Functions\UpperFunction::class,
  52.         'identity'  => Functions\IdentityFunction::class,
  53.     ];
  55.     /**
  56.      * READ-ONLY: Maps BUILT-IN numeric function names to AST class names.
  57.      *
  58.      * @var array
  59.      */
  60.     private static $_NUMERIC_FUNCTIONS = [
  61.         'length'    => Functions\LengthFunction::class,
  62.         'locate'    => Functions\LocateFunction::class,
  63.         'abs'       => Functions\AbsFunction::class,
  64.         'sqrt'      => Functions\SqrtFunction::class,
  65.         'mod'       => Functions\ModFunction::class,
  66.         'size'      => Functions\SizeFunction::class,
  67.         'date_diff' => Functions\DateDiffFunction::class,
  68.         'bit_and'   => Functions\BitAndFunction::class,
  69.         'bit_or'    => Functions\BitOrFunction::class,
  71.         // Aggregate functions
  72.         'min'       => Functions\MinFunction::class,
  73.         'max'       => Functions\MaxFunction::class,
  74.         'avg'       => Functions\AvgFunction::class,
  75.         'sum'       => Functions\SumFunction::class,
  76.         'count'     => Functions\CountFunction::class,
  77.     ];
  79.     /**
  80.      * READ-ONLY: Maps BUILT-IN datetime function names to AST class names.
  81.      *
  82.      * @var array
  83.      */
  84.     private static $_DATETIME_FUNCTIONS = [
  85.         'current_date'      => Functions\CurrentDateFunction::class,
  86.         'current_time'      => Functions\CurrentTimeFunction::class,
  87.         'current_timestamp' => Functions\CurrentTimestampFunction::class,
  88.         'date_add'          => Functions\DateAddFunction::class,
  89.         'date_sub'          => Functions\DateSubFunction::class,
  90.     ];
  92.     /*
  93.      * Expressions that were encountered during parsing of identifiers and expressions
  94.      * and still need to be validated.
  95.      */
  97.     /**
  98.      * @var array
  99.      */
  100.     private $deferredIdentificationVariables = [];
  102.     /**
  103.      * @var array
  104.      */
  105.     private $deferredPartialObjectExpressions = [];
  107.     /**
  108.      * @var array
  109.      */
  110.     private $deferredPathExpressions = [];
  112.     /**
  113.      * @var array
  114.      */
  115.     private $deferredResultVariables = [];
  117.     /**
  118.      * @var array
  119.      */
  120.     private $deferredNewObjectExpressions = [];
  122.     /**
  123.      * The lexer.
  124.      *
  125.      * @var \Doctrine\ORM\Query\Lexer
  126.      */
  127.     private $lexer;
  129.     /**
  130.      * The parser result.
  131.      *
  132.      * @var \Doctrine\ORM\Query\ParserResult
  133.      */
  134.     private $parserResult;
  136.     /**
  137.      * The EntityManager.
  138.      *
  139.      * @var \Doctrine\ORM\EntityManager
  140.      */
  141.     private $em;
  143.     /**
  144.      * The Query to parse.
  145.      *
  146.      * @var Query
  147.      */
  148.     private $query;
  150.     /**
  151.      * Map of declared query components in the parsed query.
  152.      *
  153.      * @var array
  154.      */
  155.     private $queryComponents = [];
  157.     /**
  158.      * Keeps the nesting level of defined ResultVariables.
  159.      *
  160.      * @var integer
  161.      */
  162.     private $nestingLevel = 0;
  164.     /**
  165.      * Any additional custom tree walkers that modify the AST.
  166.      *
  167.      * @var array
  168.      */
  169.     private $customTreeWalkers = [];
  171.     /**
  172.      * The custom last tree walker, if any, that is responsible for producing the output.
  173.      *
  174.      * @var TreeWalker
  175.      */
  176.     private $customOutputWalker;
  178.     /**
  179.      * @var array
  180.      */
  181.     private $identVariableExpressions = [];
  183.     /**
  184.      * Creates a new query parser object.
  185.      *
  186.      * @param Query $query The Query to parse.
  187.      */
  188.     public function __construct(Query $query)
  189.     {
  190.         $this->query        = $query;
  191.         $this->em           = $query->getEntityManager();
  192.         $this->lexer        = new Lexer((string) $query->getDQL());
  193.         $this->parserResult = new ParserResult();
  194.     }
  196.     /**
  197.      * Sets a custom tree walker that produces output.
  198.      * This tree walker will be run last over the AST, after any other walkers.
  199.      *
  200.      * @param string $className
  201.      *
  202.      * @return void
  203.      */
  204.     public function setCustomOutputTreeWalker($className)
  205.     {
  206.         $this->customOutputWalker = $className;
  207.     }
  209.     /**
  210.      * Adds a custom tree walker for modifying the AST.
  211.      *
  212.      * @param string $className
  213.      *
  214.      * @return void
  215.      */
  216.     public function addCustomTreeWalker($className)
  217.     {
  218.         $this->customTreeWalkers[] = $className;
  219.     }
  221.     /**
  222.      * Gets the lexer used by the parser.
  223.      *
  224.      * @return \Doctrine\ORM\Query\Lexer
  225.      */
  226.     public function getLexer()
  227.     {
  228.         return $this->lexer;
  229.     }
  231.     /**
  232.      * Gets the ParserResult that is being filled with information during parsing.
  233.      *
  234.      * @return \Doctrine\ORM\Query\ParserResult
  235.      */
  236.     public function getParserResult()
  237.     {
  238.         return $this->parserResult;
  239.     }
  241.     /**
  242.      * Gets the EntityManager used by the parser.
  243.      *
  244.      * @return \Doctrine\ORM\EntityManager
  245.      */
  246.     public function getEntityManager()
  247.     {
  248.         return $this->em;
  249.     }
  251.     /**
  252.      * Parses and builds AST for the given Query.
  253.      *
  254.      * @return \Doctrine\ORM\Query\AST\SelectStatement |
  255.      *         \Doctrine\ORM\Query\AST\UpdateStatement |
  256.      *         \Doctrine\ORM\Query\AST\DeleteStatement
  257.      */
  258.     public function getAST()
  259.     {
  260.         // Parse & build AST
  261.         $AST = $this->QueryLanguage();
  263.         // Process any deferred validations of some nodes in the AST.
  264.         // This also allows post-processing of the AST for modification purposes.
  265.         $this->processDeferredIdentificationVariables();
  267.         if ($this->deferredPartialObjectExpressions) {
  268.             $this->processDeferredPartialObjectExpressions();
  269.         }
  271.         if ($this->deferredPathExpressions) {
  272.             $this->processDeferredPathExpressions();
  273.         }
  275.         if ($this->deferredResultVariables) {
  276.             $this->processDeferredResultVariables();
  277.         }
  279.         if ($this->deferredNewObjectExpressions) {
  280.             $this->processDeferredNewObjectExpressions($AST);
  281.         }
  283.         $this->processRootEntityAliasSelected();
  285.         // TODO: Is there a way to remove this? It may impact the mixed hydration resultset a lot!
  286.         $this->fixIdentificationVariableOrder($AST);
  288.         return $AST;
  289.     }
  291.     /**
  292.      * Attempts to match the given token with the current lookahead token.
  293.      *
  294.      * If they match, updates the lookahead token; otherwise raises a syntax
  295.      * error.
  296.      *
  297.      * @param int $token The token type.
  298.      *
  299.      * @return void
  300.      *
  301.      * @throws QueryException If the tokens don't match.
  302.      */
  303.     public function match($token)
  304.     {
  305.         $lookaheadType = $this->lexer->lookahead['type'] ?? null;
  307.         // Short-circuit on first condition, usually types match
  308.         if ($lookaheadType === $token) {
  309.             $this->lexer->moveNext();
  310.             return;
  311.         }
  313.         // If parameter is not identifier (1-99) must be exact match
  314.         if ($token < Lexer::T_IDENTIFIER) {
  315.             $this->syntaxError($this->lexer->getLiteral($token));
  316.         }
  318.         // If parameter is keyword (200+) must be exact match
  319.         if ($token > Lexer::T_IDENTIFIER) {
  320.             $this->syntaxError($this->lexer->getLiteral($token));
  321.         }
  323.         // If parameter is T_IDENTIFIER, then matches T_IDENTIFIER (100) and keywords (200+)
  324.         if ($token === Lexer::T_IDENTIFIER && $lookaheadType < Lexer::T_IDENTIFIER) {
  325.             $this->syntaxError($this->lexer->getLiteral($token));
  326.         }
  328.         $this->lexer->moveNext();
  329.     }
  331.     /**
  332.      * Frees this parser, enabling it to be reused.
  333.      *
  334.      * @param boolean $deep     Whether to clean peek and reset errors.
  335.      * @param integer $position Position to reset.
  336.      *
  337.      * @return void
  338.      */
  339.     public function free($deep = false, $position = 0)
  340.     {
  341.         // WARNING! Use this method with care. It resets the scanner!
  342.         $this->lexer->resetPosition($position);
  344.         // Deep = true cleans peek and also any previously defined errors
  345.         if ($deep) {
  346.             $this->lexer->resetPeek();
  347.         }
  349.         $this->lexer->token = null;
  350.         $this->lexer->lookahead = null;
  351.     }
  353.     /**
  354.      * Parses a query string.
  355.      *
  356.      * @return ParserResult
  357.      */
  358.     public function parse()
  359.     {
  360.         $AST = $this->getAST();
  362.         if (($customWalkers = $this->query->getHint(Query::HINT_CUSTOM_TREE_WALKERS)) !== false) {
  363.             $this->customTreeWalkers = $customWalkers;
  364.         }
  366.         if (($customOutputWalker = $this->query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER)) !== false) {
  367.             $this->customOutputWalker = $customOutputWalker;
  368.         }
  370.         // Run any custom tree walkers over the AST
  371.         if ($this->customTreeWalkers) {
  372.             $treeWalkerChain = new TreeWalkerChain($this->query, $this->parserResult, $this->queryComponents);
  374.             foreach ($this->customTreeWalkers as $walker) {
  375.                 $treeWalkerChain->addTreeWalker($walker);
  376.             }
  378.             switch (true) {
  379.                 case ($AST instanceof AST\UpdateStatement):
  380.                     $treeWalkerChain->walkUpdateStatement($AST);
  381.                     break;
  383.                 case ($AST instanceof AST\DeleteStatement):
  384.                     $treeWalkerChain->walkDeleteStatement($AST);
  385.                     break;
  387.                 case ($AST instanceof AST\SelectStatement):
  388.                 default:
  389.                     $treeWalkerChain->walkSelectStatement($AST);
  390.             }
  392.             $this->queryComponents = $treeWalkerChain->getQueryComponents();
  393.         }
  395.         $outputWalkerClass = $this->customOutputWalker ?: SqlWalker::class;
  396.         $outputWalker      = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
  398.         // Assign an SQL executor to the parser result
  399.         $this->parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
  401.         return $this->parserResult;
  402.     }
  404.     /**
  405.      * Fixes order of identification variables.
  406.      *
  407.      * They have to appear in the select clause in the same order as the
  408.      * declarations (from ... x join ... y join ... z ...) appear in the query
  409.      * as the hydration process relies on that order for proper operation.
  410.      *
  411.      * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST
  412.      *
  413.      * @return void
  414.      */
  415.     private function fixIdentificationVariableOrder($AST)
  416.     {
  417.         if (count($this->identVariableExpressions) <= 1) {
  418.             return;
  419.         }
  421.         foreach ($this->queryComponents as $dqlAlias => $qComp) {
  422.             if ( ! isset($this->identVariableExpressions[$dqlAlias])) {
  423.                 continue;
  424.             }
  426.             $expr = $this->identVariableExpressions[$dqlAlias];
  427.             $key  = array_search($expr, $AST->selectClause->selectExpressions);
  429.             unset($AST->selectClause->selectExpressions[$key]);
  431.             $AST->selectClause->selectExpressions[] = $expr;
  432.         }
  433.     }
  435.     /**
  436.      * Generates a new syntax error.
  437.      *
  438.      * @param string     $expected Expected string.
  439.      * @param array|null $token    Got token.
  440.      *
  441.      * @return void
  442.      *
  443.      * @throws \Doctrine\ORM\Query\QueryException
  444.      */
  445.     public function syntaxError($expected = '', $token = null)
  446.     {
  447.         if ($token === null) {
  448.             $token = $this->lexer->lookahead;
  449.         }
  451.         $tokenPos = (isset($token['position'])) ? $token['position'] : '-1';
  453.         $message  = "line 0, col {$tokenPos}: Error: ";
  454.         $message .= ($expected !== '') ? "Expected {$expected}, got " : 'Unexpected ';
  455.         $message .= ($this->lexer->lookahead === null) ? 'end of string.' : "'{$token['value']}'";
  457.         throw QueryException::syntaxError($message, QueryException::dqlError($this->query->getDQL()));
  458.     }
  460.     /**
  461.      * Generates a new semantical error.
  462.      *
  463.      * @param string     $message Optional message.
  464.      * @param array|null $token   Optional token.
  465.      *
  466.      * @return void
  467.      *
  468.      * @throws \Doctrine\ORM\Query\QueryException
  469.      */
  470.     public function semanticalError($message = '', $token = null)
  471.     {
  472.         if ($token === null) {
  473.             $token = $this->lexer->lookahead ?? ['position' => null];
  474.         }
  476.         // Minimum exposed chars ahead of token
  477.         $distance = 12;
  479.         // Find a position of a final word to display in error string
  480.         $dql    = $this->query->getDQL();
  481.         $length = strlen($dql);
  482.         $pos    = $token['position'] + $distance;
  483.         $pos    = strpos($dql, ' ', ($length > $pos) ? $pos : $length);
  484.         $length = ($pos !== false) ? $pos - $token['position'] : $distance;
  486.         $tokenPos = (isset($token['position']) && $token['position'] > 0) ? $token['position'] : '-1';
  487.         $tokenStr = substr($dql, $token['position'], $length);
  489.         // Building informative message
  490.         $message = 'line 0, col ' . $tokenPos . " near '" . $tokenStr . "': Error: " . $message;
  492.         throw QueryException::semanticalError($message, QueryException::dqlError($this->query->getDQL()));
  493.     }
  495.     /**
  496.      * Peeks beyond the matched closing parenthesis and returns the first token after that one.
  497.      *
  498.      * @param boolean $resetPeek Reset peek after finding the closing parenthesis.
  499.      *
  500.      * @return array
  501.      */
  502.     private function peekBeyondClosingParenthesis($resetPeek = true)
  503.     {
  504.         $token = $this->lexer->peek();
  505.         $numUnmatched = 1;
  507.         while ($numUnmatched > 0 && $token !== null) {
  508.             switch ($token['type']) {
  509.                 case Lexer::T_OPEN_PARENTHESIS:
  510.                     ++$numUnmatched;
  511.                     break;
  513.                 case Lexer::T_CLOSE_PARENTHESIS:
  514.                     --$numUnmatched;
  515.                     break;
  517.                 default:
  518.                     // Do nothing
  519.             }
  521.             $token = $this->lexer->peek();
  522.         }
  524.         if ($resetPeek) {
  525.             $this->lexer->resetPeek();
  526.         }
  528.         return $token;
  529.     }
  531.     /**
  532.      * Checks if the given token indicates a mathematical operator.
  533.      *
  534.      * @param array $token
  535.      *
  536.      * @return boolean TRUE if the token is a mathematical operator, FALSE otherwise.
  537.      */
  538.     private function isMathOperator($token)
  539.     {
  540.         return $token !== null && in_array($token['type'], [Lexer::T_PLUS, Lexer::T_MINUS, Lexer::T_DIVIDE, Lexer::T_MULTIPLY]);
  541.     }
  543.     /**
  544.      * Checks if the next-next (after lookahead) token starts a function.
  545.      *
  546.      * @return boolean TRUE if the next-next tokens start a function, FALSE otherwise.
  547.      */
  548.     private function isFunction()
  549.     {
  550.         $lookaheadType = $this->lexer->lookahead['type'];
  551.         $peek          = $this->lexer->peek();
  553.         $this->lexer->resetPeek();
  555.         return $lookaheadType >= Lexer::T_IDENTIFIER && $peek !== null && $peek['type'] === Lexer::T_OPEN_PARENTHESIS;
  556.     }
  558.     /**
  559.      * Checks whether the given token type indicates an aggregate function.
  560.      *
  561.      * @param int $tokenType
  562.      *
  563.      * @return boolean TRUE if the token type is an aggregate function, FALSE otherwise.
  564.      */
  565.     private function isAggregateFunction($tokenType)
  566.     {
  567.         return in_array($tokenType, [Lexer::T_AVG, Lexer::T_MIN, Lexer::T_MAX, Lexer::T_SUM, Lexer::T_COUNT]);
  568.     }
  570.     /**
  571.      * Checks whether the current lookahead token of the lexer has the type T_ALL, T_ANY or T_SOME.
  572.      *
  573.      * @return boolean
  574.      */
  575.     private function isNextAllAnySome()
  576.     {
  577.         return in_array($this->lexer->lookahead['type'], [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME]);
  578.     }
  580.     /**
  581.      * Validates that the given <tt>IdentificationVariable</tt> is semantically correct.
  582.      * It must exist in query components list.
  583.      *
  584.      * @return void
  585.      */
  586.     private function processDeferredIdentificationVariables()
  587.     {
  588.         foreach ($this->deferredIdentificationVariables as $deferredItem) {
  589.             $identVariable = $deferredItem['expression'];
  591.             // Check if IdentificationVariable exists in queryComponents
  592.             if ( ! isset($this->queryComponents[$identVariable])) {
  593.                 $this->semanticalError(
  594.                     "'$identVariable' is not defined.", $deferredItem['token']
  595.                 );
  596.             }
  598.             $qComp = $this->queryComponents[$identVariable];
  600.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  601.             if ( ! isset($qComp['metadata'])) {
  602.                 $this->semanticalError(
  603.                     "'$identVariable' does not point to a Class.", $deferredItem['token']
  604.                 );
  605.             }
  607.             // Validate if identification variable nesting level is lower or equal than the current one
  608.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  609.                 $this->semanticalError(
  610.                     "'$identVariable' is used outside the scope of its declaration.", $deferredItem['token']
  611.                 );
  612.             }
  613.         }
  614.     }
  616.     /**
  617.      * Validates that the given <tt>NewObjectExpression</tt>.
  618.      *
  619.      * @param \Doctrine\ORM\Query\AST\SelectClause $AST
  620.      *
  621.      * @return void
  622.      */
  623.     private function processDeferredNewObjectExpressions($AST)
  624.     {
  625.         foreach ($this->deferredNewObjectExpressions as $deferredItem) {
  626.             $expression     = $deferredItem['expression'];
  627.             $token          = $deferredItem['token'];
  628.             $className      = $expression->className;
  629.             $args           = $expression->args;
  630.             $fromClassName  = isset($AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName)
  631.                 ? $AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName
  632.                 : null;
  634.             // If the namespace is not given then assumes the first FROM entity namespace
  635.             if (strpos($className, '\\') === false && ! class_exists($className) && strpos($fromClassName, '\\') !== false) {
  636.                 $namespace  = substr($fromClassName, 0, strrpos($fromClassName, '\\'));
  637.                 $fqcn       = $namespace . '\\' . $className;
  639.                 if (class_exists($fqcn)) {
  640.                     $expression->className  = $fqcn;
  641.                     $className              = $fqcn;
  642.                 }
  643.             }
  645.             if ( ! class_exists($className)) {
  646.                 $this->semanticalError(sprintf('Class "%s" is not defined.', $className), $token);
  647.             }
  649.             $class = new \ReflectionClass($className);
  651.             if ( ! $class->isInstantiable()) {
  652.                 $this->semanticalError(sprintf('Class "%s" can not be instantiated.', $className), $token);
  653.             }
  655.             if ($class->getConstructor() === null) {
  656.                 $this->semanticalError(sprintf('Class "%s" has not a valid constructor.', $className), $token);
  657.             }
  659.             if ($class->getConstructor()->getNumberOfRequiredParameters() > count($args)) {
  660.                 $this->semanticalError(sprintf('Number of arguments does not match with "%s" constructor declaration.', $className), $token);
  661.             }
  662.         }
  663.     }
  665.     /**
  666.      * Validates that the given <tt>PartialObjectExpression</tt> is semantically correct.
  667.      * It must exist in query components list.
  668.      *
  669.      * @return void
  670.      */
  671.     private function processDeferredPartialObjectExpressions()
  672.     {
  673.         foreach ($this->deferredPartialObjectExpressions as $deferredItem) {
  674.             $expr = $deferredItem['expression'];
  675.             $class = $this->queryComponents[$expr->identificationVariable]['metadata'];
  677.             foreach ($expr->partialFieldSet as $field) {
  678.                 if (isset($class->fieldMappings[$field])) {
  679.                     continue;
  680.                 }
  682.                 if (isset($class->associationMappings[$field]) &&
  683.                     $class->associationMappings[$field]['isOwningSide'] &&
  684.                     $class->associationMappings[$field]['type'] & ClassMetadata::TO_ONE) {
  685.                     continue;
  686.                 }
  688.                 $this->semanticalError(
  689.                     "There is no mapped field named '$field' on class " . $class->name . ".", $deferredItem['token']
  690.                 );
  691.             }
  693.             if (array_intersect($class->identifier, $expr->partialFieldSet) != $class->identifier) {
  694.                 $this->semanticalError(
  695.                     "The partial field selection of class " . $class->name . " must contain the identifier.",
  696.                     $deferredItem['token']
  697.                 );
  698.             }
  699.         }
  700.     }
  702.     /**
  703.      * Validates that the given <tt>ResultVariable</tt> is semantically correct.
  704.      * It must exist in query components list.
  705.      *
  706.      * @return void
  707.      */
  708.     private function processDeferredResultVariables()
  709.     {
  710.         foreach ($this->deferredResultVariables as $deferredItem) {
  711.             $resultVariable = $deferredItem['expression'];
  713.             // Check if ResultVariable exists in queryComponents
  714.             if ( ! isset($this->queryComponents[$resultVariable])) {
  715.                 $this->semanticalError(
  716.                     "'$resultVariable' is not defined.", $deferredItem['token']
  717.                 );
  718.             }
  720.             $qComp = $this->queryComponents[$resultVariable];
  722.             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  723.             if ( ! isset($qComp['resultVariable'])) {
  724.                 $this->semanticalError(
  725.                     "'$resultVariable' does not point to a ResultVariable.", $deferredItem['token']
  726.                 );
  727.             }
  729.             // Validate if identification variable nesting level is lower or equal than the current one
  730.             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  731.                 $this->semanticalError(
  732.                     "'$resultVariable' is used outside the scope of its declaration.", $deferredItem['token']
  733.                 );
  734.             }
  735.         }
  736.     }
  738.     /**
  739.      * Validates that the given <tt>PathExpression</tt> is semantically correct for grammar rules:
  740.      *
  741.      * AssociationPathExpression             ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  742.      * SingleValuedPathExpression            ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  743.      * StateFieldPathExpression              ::= IdentificationVariable "." StateField
  744.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  745.      * CollectionValuedPathExpression        ::= IdentificationVariable "." CollectionValuedAssociationField
  746.      *
  747.      * @return void
  748.      */
  749.     private function processDeferredPathExpressions()
  750.     {
  751.         foreach ($this->deferredPathExpressions as $deferredItem) {
  752.             $pathExpression = $deferredItem['expression'];
  754.             $qComp = $this->queryComponents[$pathExpression->identificationVariable];
  755.             $class = $qComp['metadata'];
  757.             if (($field = $pathExpression->field) === null) {
  758.                 $field = $pathExpression->field = $class->identifier[0];
  759.             }
  761.             // Check if field or association exists
  762.             if ( ! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
  763.                 $this->semanticalError(
  764.                     'Class ' . $class->name . ' has no field or association named ' . $field,
  765.                     $deferredItem['token']
  766.                 );
  767.             }
  769.             $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
  771.             if (isset($class->associationMappings[$field])) {
  772.                 $assoc = $class->associationMappings[$field];
  774.                 $fieldType = ($assoc['type'] & ClassMetadata::TO_ONE)
  775.                     ? AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  776.                     : AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
  777.             }
  779.             // Validate if PathExpression is one of the expected types
  780.             $expectedType = $pathExpression->expectedType;
  782.             if ( ! ($expectedType & $fieldType)) {
  783.                 // We need to recognize which was expected type(s)
  784.                 $expectedStringTypes = [];
  786.                 // Validate state field type
  787.                 if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
  788.                     $expectedStringTypes[] = 'StateFieldPathExpression';
  789.                 }
  791.                 // Validate single valued association (*-to-one)
  792.                 if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
  793.                     $expectedStringTypes[] = 'SingleValuedAssociationField';
  794.                 }
  796.                 // Validate single valued association (*-to-many)
  797.                 if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
  798.                     $expectedStringTypes[] = 'CollectionValuedAssociationField';
  799.                 }
  801.                 // Build the error message
  802.                 $semanticalError  = 'Invalid PathExpression. ';
  803.                 $semanticalError .= (count($expectedStringTypes) == 1)
  804.                     ? 'Must be a ' . $expectedStringTypes[0] . '.'
  805.                     : implode(' or ', $expectedStringTypes) . ' expected.';
  807.                 $this->semanticalError($semanticalError, $deferredItem['token']);
  808.             }
  810.             // We need to force the type in PathExpression
  811.             $pathExpression->type = $fieldType;
  812.         }
  813.     }
  815.     /**
  816.      * @return void
  817.      */
  818.     private function processRootEntityAliasSelected()
  819.     {
  820.         if ( ! count($this->identVariableExpressions)) {
  821.             return;
  822.         }
  824.         foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
  825.             if (isset($this->queryComponents[$dqlAlias]) && $this->queryComponents[$dqlAlias]['parent'] === null) {
  826.                 return;
  827.             }
  828.         }
  830.         $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');
  831.     }
  833.     /**
  834.      * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
  835.      *
  836.      * @return \Doctrine\ORM\Query\AST\SelectStatement |
  837.      *         \Doctrine\ORM\Query\AST\UpdateStatement |
  838.      *         \Doctrine\ORM\Query\AST\DeleteStatement
  839.      */
  840.     public function QueryLanguage()
  841.     {
  842.         $statement = null;
  844.         $this->lexer->moveNext();
  846.         switch ($this->lexer->lookahead['type'] ?? null) {
  847.             case Lexer::T_SELECT:
  848.                 $statement = $this->SelectStatement();
  849.                 break;
  851.             case Lexer::T_UPDATE:
  852.                 $statement = $this->UpdateStatement();
  853.                 break;
  855.             case Lexer::T_DELETE:
  856.                 $statement = $this->DeleteStatement();
  857.                 break;
  859.             default:
  860.                 $this->syntaxError('SELECT, UPDATE or DELETE');
  861.                 break;
  862.         }
  864.         // Check for end of string
  865.         if ($this->lexer->lookahead !== null) {
  866.             $this->syntaxError('end of string');
  867.         }
  869.         return $statement;
  870.     }
  872.     /**
  873.      * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  874.      *
  875.      * @return \Doctrine\ORM\Query\AST\SelectStatement
  876.      */
  877.     public function SelectStatement()
  878.     {
  879.         $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());
  881.         $selectStatement->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  882.         $selectStatement->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  883.         $selectStatement->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  884.         $selectStatement->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  886.         return $selectStatement;
  887.     }
  889.     /**
  890.      * UpdateStatement ::= UpdateClause [WhereClause]
  891.      *
  892.      * @return \Doctrine\ORM\Query\AST\UpdateStatement
  893.      */
  894.     public function UpdateStatement()
  895.     {
  896.         $updateStatement = new AST\UpdateStatement($this->UpdateClause());
  898.         $updateStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  900.         return $updateStatement;
  901.     }
  903.     /**
  904.      * DeleteStatement ::= DeleteClause [WhereClause]
  905.      *
  906.      * @return \Doctrine\ORM\Query\AST\DeleteStatement
  907.      */
  908.     public function DeleteStatement()
  909.     {
  910.         $deleteStatement = new AST\DeleteStatement($this->DeleteClause());
  912.         $deleteStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  914.         return $deleteStatement;
  915.     }
  917.     /**
  918.      * IdentificationVariable ::= identifier
  919.      *
  920.      * @return string
  921.      */
  922.     public function IdentificationVariable()
  923.     {
  924.         $this->match(Lexer::T_IDENTIFIER);
  926.         $identVariable = $this->lexer->token['value'];
  928.         $this->deferredIdentificationVariables[] = [
  929.             'expression'   => $identVariable,
  930.             'nestingLevel' => $this->nestingLevel,
  931.             'token'        => $this->lexer->token,
  932.         ];
  934.         return $identVariable;
  935.     }
  937.     /**
  938.      * AliasIdentificationVariable = identifier
  939.      *
  940.      * @return string
  941.      */
  942.     public function AliasIdentificationVariable()
  943.     {
  944.         $this->match(Lexer::T_IDENTIFIER);
  946.         $aliasIdentVariable = $this->lexer->token['value'];
  947.         $exists = isset($this->queryComponents[$aliasIdentVariable]);
  949.         if ($exists) {
  950.             $this->semanticalError("'$aliasIdentVariable' is already defined.", $this->lexer->token);
  951.         }
  953.         return $aliasIdentVariable;
  954.     }
  956.     /**
  957.      * AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
  958.      *
  959.      * @return string
  960.      */
  961.     public function AbstractSchemaName()
  962.     {
  963.         if ($this->lexer->isNextToken(Lexer::T_FULLY_QUALIFIED_NAME)) {
  964.             $this->match(Lexer::T_FULLY_QUALIFIED_NAME);
  966.             return $this->lexer->token['value'];
  967.         }
  969.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  970.             $this->match(Lexer::T_IDENTIFIER);
  972.             return $this->lexer->token['value'];
  973.         }
  975.         $this->match(Lexer::T_ALIASED_NAME);
  977.         [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token['value']);
  979.         return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  980.     }
  982.     /**
  983.      * Validates an AbstractSchemaName, making sure the class exists.
  984.      *
  985.      * @param string $schemaName The name to validate.
  986.      *
  987.      * @throws QueryException if the name does not exist.
  988.      */
  989.     private function validateAbstractSchemaName($schemaName)
  990.     {
  991.         if (! (class_exists($schemaName, true) || interface_exists($schemaName, true))) {
  992.             $this->semanticalError("Class '$schemaName' is not defined.", $this->lexer->token);
  993.         }
  994.     }
  996.     /**
  997.      * AliasResultVariable ::= identifier
  998.      *
  999.      * @return string
  1000.      */
  1001.     public function AliasResultVariable()
  1002.     {
  1003.         $this->match(Lexer::T_IDENTIFIER);
  1005.         $resultVariable = $this->lexer->token['value'];
  1006.         $exists = isset($this->queryComponents[$resultVariable]);
  1008.         if ($exists) {
  1009.             $this->semanticalError("'$resultVariable' is already defined.", $this->lexer->token);
  1010.         }
  1012.         return $resultVariable;
  1013.     }
  1015.     /**
  1016.      * ResultVariable ::= identifier
  1017.      *
  1018.      * @return string
  1019.      */
  1020.     public function ResultVariable()
  1021.     {
  1022.         $this->match(Lexer::T_IDENTIFIER);
  1024.         $resultVariable = $this->lexer->token['value'];
  1026.         // Defer ResultVariable validation
  1027.         $this->deferredResultVariables[] = [
  1028.             'expression'   => $resultVariable,
  1029.             'nestingLevel' => $this->nestingLevel,
  1030.             'token'        => $this->lexer->token,
  1031.         ];
  1033.         return $resultVariable;
  1034.     }
  1036.     /**
  1037.      * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
  1038.      *
  1039.      * @return \Doctrine\ORM\Query\AST\JoinAssociationPathExpression
  1040.      */
  1041.     public function JoinAssociationPathExpression()
  1042.     {
  1043.         $identVariable = $this->IdentificationVariable();
  1045.         if ( ! isset($this->queryComponents[$identVariable])) {
  1046.             $this->semanticalError(
  1047.                 'Identification Variable ' . $identVariable .' used in join path expression but was not defined before.'
  1048.             );
  1049.         }
  1051.         $this->match(Lexer::T_DOT);
  1052.         $this->match(Lexer::T_IDENTIFIER);
  1054.         $field = $this->lexer->token['value'];
  1056.         // Validate association field
  1057.         $qComp = $this->queryComponents[$identVariable];
  1058.         $class = $qComp['metadata'];
  1060.         if ( ! $class->hasAssociation($field)) {
  1061.             $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
  1062.         }
  1064.         return new AST\JoinAssociationPathExpression($identVariable, $field);
  1065.     }
  1067.     /**
  1068.      * Parses an arbitrary path expression and defers semantical validation
  1069.      * based on expected types.
  1070.      *
  1071.      * PathExpression ::= IdentificationVariable {"." identifier}*
  1072.      *
  1073.      * @param integer $expectedTypes
  1074.      *
  1075.      * @return \Doctrine\ORM\Query\AST\PathExpression
  1076.      */
  1077.     public function PathExpression($expectedTypes)
  1078.     {
  1079.         $identVariable = $this->IdentificationVariable();
  1080.         $field = null;
  1082.         if ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1083.             $this->match(Lexer::T_DOT);
  1084.             $this->match(Lexer::T_IDENTIFIER);
  1086.             $field = $this->lexer->token['value'];
  1088.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1089.                 $this->match(Lexer::T_DOT);
  1090.                 $this->match(Lexer::T_IDENTIFIER);
  1091.                 $field .= '.'.$this->lexer->token['value'];
  1092.             }
  1093.         }
  1095.         // Creating AST node
  1096.         $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);
  1098.         // Defer PathExpression validation if requested to be deferred
  1099.         $this->deferredPathExpressions[] = [
  1100.             'expression'   => $pathExpr,
  1101.             'nestingLevel' => $this->nestingLevel,
  1102.             'token'        => $this->lexer->token,
  1103.         ];
  1105.         return $pathExpr;
  1106.     }
  1108.     /**
  1109.      * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  1110.      *
  1111.      * @return \Doctrine\ORM\Query\AST\PathExpression
  1112.      */
  1113.     public function AssociationPathExpression()
  1114.     {
  1115.         return $this->PathExpression(
  1116.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |
  1117.             AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION
  1118.         );
  1119.     }
  1121.     /**
  1122.      * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  1123.      *
  1124.      * @return \Doctrine\ORM\Query\AST\PathExpression
  1125.      */
  1126.     public function SingleValuedPathExpression()
  1127.     {
  1128.         return $this->PathExpression(
  1129.             AST\PathExpression::TYPE_STATE_FIELD |
  1130.             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  1131.         );
  1132.     }
  1134.     /**
  1135.      * StateFieldPathExpression ::= IdentificationVariable "." StateField
  1136.      *
  1137.      * @return \Doctrine\ORM\Query\AST\PathExpression
  1138.      */
  1139.     public function StateFieldPathExpression()
  1140.     {
  1141.         return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);
  1142.     }
  1144.     /**
  1145.      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  1146.      *
  1147.      * @return \Doctrine\ORM\Query\AST\PathExpression
  1148.      */
  1149.     public function SingleValuedAssociationPathExpression()
  1150.     {
  1151.         return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);
  1152.     }
  1154.     /**
  1155.      * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  1156.      *
  1157.      * @return \Doctrine\ORM\Query\AST\PathExpression
  1158.      */
  1159.     public function CollectionValuedPathExpression()
  1160.     {
  1161.         return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);
  1162.     }
  1164.     /**
  1165.      * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
  1166.      *
  1167.      * @return \Doctrine\ORM\Query\AST\SelectClause
  1168.      */
  1169.     public function SelectClause()
  1170.     {
  1171.         $isDistinct = false;
  1172.         $this->match(Lexer::T_SELECT);
  1174.         // Check for DISTINCT
  1175.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1176.             $this->match(Lexer::T_DISTINCT);
  1178.             $isDistinct = true;
  1179.         }
  1181.         // Process SelectExpressions (1..N)
  1182.         $selectExpressions = [];
  1183.         $selectExpressions[] = $this->SelectExpression();
  1185.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1186.             $this->match(Lexer::T_COMMA);
  1188.             $selectExpressions[] = $this->SelectExpression();
  1189.         }
  1191.         return new AST\SelectClause($selectExpressions, $isDistinct);
  1192.     }
  1194.     /**
  1195.      * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
  1196.      *
  1197.      * @return \Doctrine\ORM\Query\AST\SimpleSelectClause
  1198.      */
  1199.     public function SimpleSelectClause()
  1200.     {
  1201.         $isDistinct = false;
  1202.         $this->match(Lexer::T_SELECT);
  1204.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1205.             $this->match(Lexer::T_DISTINCT);
  1207.             $isDistinct = true;
  1208.         }
  1210.         return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);
  1211.     }
  1213.     /**
  1214.      * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*
  1215.      *
  1216.      * @return \Doctrine\ORM\Query\AST\UpdateClause
  1217.      */
  1218.     public function UpdateClause()
  1219.     {
  1220.         $this->match(Lexer::T_UPDATE);
  1222.         $token = $this->lexer->lookahead;
  1223.         $abstractSchemaName = $this->AbstractSchemaName();
  1225.         $this->validateAbstractSchemaName($abstractSchemaName);
  1227.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1228.             $this->match(Lexer::T_AS);
  1229.         }
  1231.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1233.         $class = $this->em->getClassMetadata($abstractSchemaName);
  1235.         // Building queryComponent
  1236.         $queryComponent = [
  1237.             'metadata'     => $class,
  1238.             'parent'       => null,
  1239.             'relation'     => null,
  1240.             'map'          => null,
  1241.             'nestingLevel' => $this->nestingLevel,
  1242.             'token'        => $token,
  1243.         ];
  1245.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1247.         $this->match(Lexer::T_SET);
  1249.         $updateItems = [];
  1250.         $updateItems[] = $this->UpdateItem();
  1252.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1253.             $this->match(Lexer::T_COMMA);
  1255.             $updateItems[] = $this->UpdateItem();
  1256.         }
  1258.         $updateClause = new AST\UpdateClause($abstractSchemaName, $updateItems);
  1259.         $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1261.         return $updateClause;
  1262.     }
  1264.     /**
  1265.      * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable
  1266.      *
  1267.      * @return \Doctrine\ORM\Query\AST\DeleteClause
  1268.      */
  1269.     public function DeleteClause()
  1270.     {
  1271.         $this->match(Lexer::T_DELETE);
  1273.         if ($this->lexer->isNextToken(Lexer::T_FROM)) {
  1274.             $this->match(Lexer::T_FROM);
  1275.         }
  1277.         $token = $this->lexer->lookahead;
  1278.         $abstractSchemaName = $this->AbstractSchemaName();
  1280.         $this->validateAbstractSchemaName($abstractSchemaName);
  1282.         $deleteClause = new AST\DeleteClause($abstractSchemaName);
  1284.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1285.             $this->match(Lexer::T_AS);
  1286.         }
  1288.         $aliasIdentificationVariable = $this->lexer->isNextToken(Lexer::T_IDENTIFIER)
  1289.             ? $this->AliasIdentificationVariable()
  1290.             : 'alias_should_have_been_set';
  1292.         $deleteClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1293.         $class = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1295.         // Building queryComponent
  1296.         $queryComponent = [
  1297.             'metadata'     => $class,
  1298.             'parent'       => null,
  1299.             'relation'     => null,
  1300.             'map'          => null,
  1301.             'nestingLevel' => $this->nestingLevel,
  1302.             'token'        => $token,
  1303.         ];
  1305.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1307.         return $deleteClause;
  1308.     }
  1310.     /**
  1311.      * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}*
  1312.      *
  1313.      * @return \Doctrine\ORM\Query\AST\FromClause
  1314.      */
  1315.     public function FromClause()
  1316.     {
  1317.         $this->match(Lexer::T_FROM);
  1319.         $identificationVariableDeclarations = [];
  1320.         $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1322.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1323.             $this->match(Lexer::T_COMMA);
  1325.             $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1326.         }
  1328.         return new AST\FromClause($identificationVariableDeclarations);
  1329.     }
  1331.     /**
  1332.      * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
  1333.      *
  1334.      * @return \Doctrine\ORM\Query\AST\SubselectFromClause
  1335.      */
  1336.     public function SubselectFromClause()
  1337.     {
  1338.         $this->match(Lexer::T_FROM);
  1340.         $identificationVariables = [];
  1341.         $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1343.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1344.             $this->match(Lexer::T_COMMA);
  1346.             $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1347.         }
  1349.         return new AST\SubselectFromClause($identificationVariables);
  1350.     }
  1352.     /**
  1353.      * WhereClause ::= "WHERE" ConditionalExpression
  1354.      *
  1355.      * @return \Doctrine\ORM\Query\AST\WhereClause
  1356.      */
  1357.     public function WhereClause()
  1358.     {
  1359.         $this->match(Lexer::T_WHERE);
  1361.         return new AST\WhereClause($this->ConditionalExpression());
  1362.     }
  1364.     /**
  1365.      * HavingClause ::= "HAVING" ConditionalExpression
  1366.      *
  1367.      * @return \Doctrine\ORM\Query\AST\HavingClause
  1368.      */
  1369.     public function HavingClause()
  1370.     {
  1371.         $this->match(Lexer::T_HAVING);
  1373.         return new AST\HavingClause($this->ConditionalExpression());
  1374.     }
  1376.     /**
  1377.      * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
  1378.      *
  1379.      * @return \Doctrine\ORM\Query\AST\GroupByClause
  1380.      */
  1381.     public function GroupByClause()
  1382.     {
  1383.         $this->match(Lexer::T_GROUP);
  1384.         $this->match(Lexer::T_BY);
  1386.         $groupByItems = [$this->GroupByItem()];
  1388.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1389.             $this->match(Lexer::T_COMMA);
  1391.             $groupByItems[] = $this->GroupByItem();
  1392.         }
  1394.         return new AST\GroupByClause($groupByItems);
  1395.     }
  1397.     /**
  1398.      * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
  1399.      *
  1400.      * @return \Doctrine\ORM\Query\AST\OrderByClause
  1401.      */
  1402.     public function OrderByClause()
  1403.     {
  1404.         $this->match(Lexer::T_ORDER);
  1405.         $this->match(Lexer::T_BY);
  1407.         $orderByItems = [];
  1408.         $orderByItems[] = $this->OrderByItem();
  1410.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1411.             $this->match(Lexer::T_COMMA);
  1413.             $orderByItems[] = $this->OrderByItem();
  1414.         }
  1416.         return new AST\OrderByClause($orderByItems);
  1417.     }
  1419.     /**
  1420.      * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  1421.      *
  1422.      * @return \Doctrine\ORM\Query\AST\Subselect
  1423.      */
  1424.     public function Subselect()
  1425.     {
  1426.         // Increase query nesting level
  1427.         $this->nestingLevel++;
  1429.         $subselect = new AST\Subselect($this->SimpleSelectClause(), $this->SubselectFromClause());
  1431.         $subselect->whereClause   = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  1432.         $subselect->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  1433.         $subselect->havingClause  = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  1434.         $subselect->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  1436.         // Decrease query nesting level
  1437.         $this->nestingLevel--;
  1439.         return $subselect;
  1440.     }
  1442.     /**
  1443.      * UpdateItem ::= SingleValuedPathExpression "=" NewValue
  1444.      *
  1445.      * @return \Doctrine\ORM\Query\AST\UpdateItem
  1446.      */
  1447.     public function UpdateItem()
  1448.     {
  1449.         $pathExpr = $this->SingleValuedPathExpression();
  1451.         $this->match(Lexer::T_EQUALS);
  1453.         $updateItem = new AST\UpdateItem($pathExpr, $this->NewValue());
  1455.         return $updateItem;
  1456.     }
  1458.     /**
  1459.      * GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression
  1460.      *
  1461.      * @return string | \Doctrine\ORM\Query\AST\PathExpression
  1462.      */
  1463.     public function GroupByItem()
  1464.     {
  1465.         // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  1466.         $glimpse = $this->lexer->glimpse();
  1468.         if ($glimpse !== null && $glimpse['type'] === Lexer::T_DOT) {
  1469.             return $this->SingleValuedPathExpression();
  1470.         }
  1472.         // Still need to decide between IdentificationVariable or ResultVariable
  1473.         $lookaheadValue = $this->lexer->lookahead['value'];
  1475.         if ( ! isset($this->queryComponents[$lookaheadValue])) {
  1476.             $this->semanticalError('Cannot group by undefined identification or result variable.');
  1477.         }
  1479.         return (isset($this->queryComponents[$lookaheadValue]['metadata']))
  1480.             ? $this->IdentificationVariable()
  1481.             : $this->ResultVariable();
  1482.     }
  1484.     /**
  1485.      * OrderByItem ::= (
  1486.      *      SimpleArithmeticExpression | SingleValuedPathExpression |
  1487.      *      ScalarExpression | ResultVariable | FunctionDeclaration
  1488.      * ) ["ASC" | "DESC"]
  1489.      *
  1490.      * @return \Doctrine\ORM\Query\AST\OrderByItem
  1491.      */
  1492.     public function OrderByItem()
  1493.     {
  1494.         $this->lexer->peek(); // lookahead => '.'
  1495.         $this->lexer->peek(); // lookahead => token after '.'
  1497.         $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1499.         $this->lexer->resetPeek();
  1501.         $glimpse = $this->lexer->glimpse();
  1503.         switch (true) {
  1504.             case ($this->isFunction()):
  1505.                 $expr = $this->FunctionDeclaration();
  1506.                 break;
  1508.             case ($this->isMathOperator($peek)):
  1509.                 $expr = $this->SimpleArithmeticExpression();
  1510.                 break;
  1512.             case $glimpse !== null && $glimpse['type'] === Lexer::T_DOT:
  1513.                 $expr = $this->SingleValuedPathExpression();
  1514.                 break;
  1516.             case ($this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis())):
  1517.                 $expr = $this->ScalarExpression();
  1518.                 break;
  1520.             default:
  1521.                 $expr = $this->ResultVariable();
  1522.                 break;
  1523.         }
  1525.         $type = 'ASC';
  1526.         $item = new AST\OrderByItem($expr);
  1528.         switch (true) {
  1529.             case ($this->lexer->isNextToken(Lexer::T_DESC)):
  1530.                 $this->match(Lexer::T_DESC);
  1531.                 $type = 'DESC';
  1532.                 break;
  1534.             case ($this->lexer->isNextToken(Lexer::T_ASC)):
  1535.                 $this->match(Lexer::T_ASC);
  1536.                 break;
  1538.             default:
  1539.                 // Do nothing
  1540.         }
  1542.         $item->type = $type;
  1544.         return $item;
  1545.     }
  1547.     /**
  1548.      * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
  1549.      *      EnumPrimary | SimpleEntityExpression | "NULL"
  1550.      *
  1551.      * NOTE: Since it is not possible to correctly recognize individual types, here is the full
  1552.      * grammar that needs to be supported:
  1553.      *
  1554.      * NewValue ::= SimpleArithmeticExpression | "NULL"
  1555.      *
  1556.      * SimpleArithmeticExpression covers all *Primary grammar rules and also SimpleEntityExpression
  1557.      *
  1558.      * @return AST\ArithmeticExpression
  1559.      */
  1560.     public function NewValue()
  1561.     {
  1562.         if ($this->lexer->isNextToken(Lexer::T_NULL)) {
  1563.             $this->match(Lexer::T_NULL);
  1565.             return null;
  1566.         }
  1568.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  1569.             $this->match(Lexer::T_INPUT_PARAMETER);
  1571.             return new AST\InputParameter($this->lexer->token['value']);
  1572.         }
  1574.         return $this->ArithmeticExpression();
  1575.     }
  1577.     /**
  1578.      * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*
  1579.      *
  1580.      * @return \Doctrine\ORM\Query\AST\IdentificationVariableDeclaration
  1581.      */
  1582.     public function IdentificationVariableDeclaration()
  1583.     {
  1584.         $joins                    = [];
  1585.         $rangeVariableDeclaration = $this->RangeVariableDeclaration();
  1586.         $indexBy                  = $this->lexer->isNextToken(Lexer::T_INDEX)
  1587.             ? $this->IndexBy()
  1588.             : null;
  1590.         $rangeVariableDeclaration->isRoot = true;
  1592.         while (
  1593.             $this->lexer->isNextToken(Lexer::T_LEFT) ||
  1594.             $this->lexer->isNextToken(Lexer::T_INNER) ||
  1595.             $this->lexer->isNextToken(Lexer::T_JOIN)
  1596.         ) {
  1597.             $joins[] = $this->Join();
  1598.         }
  1600.         return new AST\IdentificationVariableDeclaration(
  1601.             $rangeVariableDeclaration, $indexBy, $joins
  1602.         );
  1603.     }
  1605.     /**
  1606.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration
  1607.      *
  1608.      * {Internal note: WARNING: Solution is harder than a bare implementation.
  1609.      * Desired EBNF support:
  1610.      *
  1611.      * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
  1612.      *
  1613.      * It demands that entire SQL generation to become programmatical. This is
  1614.      * needed because association based subselect requires "WHERE" conditional
  1615.      * expressions to be injected, but there is no scope to do that. Only scope
  1616.      * accessible is "FROM", prohibiting an easy implementation without larger
  1617.      * changes.}
  1618.      *
  1619.      * @return \Doctrine\ORM\Query\AST\SubselectIdentificationVariableDeclaration |
  1620.      *         \Doctrine\ORM\Query\AST\IdentificationVariableDeclaration
  1621.      */
  1622.     public function SubselectIdentificationVariableDeclaration()
  1623.     {
  1624.         /*
  1625.         NOT YET IMPLEMENTED!
  1627.         $glimpse = $this->lexer->glimpse();
  1629.         if ($glimpse['type'] == Lexer::T_DOT) {
  1630.             $associationPathExpression = $this->AssociationPathExpression();
  1632.             if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1633.                 $this->match(Lexer::T_AS);
  1634.             }
  1636.             $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1637.             $identificationVariable      = $associationPathExpression->identificationVariable;
  1638.             $field                       = $associationPathExpression->associationField;
  1640.             $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1641.             $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1643.             // Building queryComponent
  1644.             $joinQueryComponent = array(
  1645.                 'metadata'     => $targetClass,
  1646.                 'parent'       => $identificationVariable,
  1647.                 'relation'     => $class->getAssociationMapping($field),
  1648.                 'map'          => null,
  1649.                 'nestingLevel' => $this->nestingLevel,
  1650.                 'token'        => $this->lexer->lookahead
  1651.             );
  1653.             $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1655.             return new AST\SubselectIdentificationVariableDeclaration(
  1656.                 $associationPathExpression, $aliasIdentificationVariable
  1657.             );
  1658.         }
  1659.         */
  1661.         return $this->IdentificationVariableDeclaration();
  1662.     }
  1664.     /**
  1665.      * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN"
  1666.      *          (JoinAssociationDeclaration | RangeVariableDeclaration)
  1667.      *          ["WITH" ConditionalExpression]
  1668.      *
  1669.      * @return \Doctrine\ORM\Query\AST\Join
  1670.      */
  1671.     public function Join()
  1672.     {
  1673.         // Check Join type
  1674.         $joinType = AST\Join::JOIN_TYPE_INNER;
  1676.         switch (true) {
  1677.             case ($this->lexer->isNextToken(Lexer::T_LEFT)):
  1678.                 $this->match(Lexer::T_LEFT);
  1680.                 $joinType = AST\Join::JOIN_TYPE_LEFT;
  1682.                 // Possible LEFT OUTER join
  1683.                 if ($this->lexer->isNextToken(Lexer::T_OUTER)) {
  1684.                     $this->match(Lexer::T_OUTER);
  1686.                     $joinType = AST\Join::JOIN_TYPE_LEFTOUTER;
  1687.                 }
  1688.                 break;
  1690.             case ($this->lexer->isNextToken(Lexer::T_INNER)):
  1691.                 $this->match(Lexer::T_INNER);
  1692.                 break;
  1694.             default:
  1695.                 // Do nothing
  1696.         }
  1698.         $this->match(Lexer::T_JOIN);
  1700.         $next            = $this->lexer->glimpse();
  1701.         $joinDeclaration = ($next['type'] === Lexer::T_DOT) ? $this->JoinAssociationDeclaration() : $this->RangeVariableDeclaration();
  1702.         $adhocConditions = $this->lexer->isNextToken(Lexer::T_WITH);
  1703.         $join            = new AST\Join($joinType, $joinDeclaration);
  1705.         // Describe non-root join declaration
  1706.         if ($joinDeclaration instanceof AST\RangeVariableDeclaration) {
  1707.             $joinDeclaration->isRoot = false;
  1708.         }
  1710.         // Check for ad-hoc Join conditions
  1711.         if ($adhocConditions) {
  1712.             $this->match(Lexer::T_WITH);
  1714.             $join->conditionalExpression = $this->ConditionalExpression();
  1715.         }
  1717.         return $join;
  1718.     }
  1720.     /**
  1721.      * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
  1722.      *
  1723.      * @return \Doctrine\ORM\Query\AST\RangeVariableDeclaration
  1724.      *
  1725.      * @throws QueryException
  1726.      */
  1727.     public function RangeVariableDeclaration()
  1728.     {
  1729.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $this->lexer->glimpse()['type'] === Lexer::T_SELECT) {
  1730.             $this->semanticalError('Subquery is not supported here', $this->lexer->token);
  1731.         }
  1733.         $abstractSchemaName = $this->AbstractSchemaName();
  1735.         $this->validateAbstractSchemaName($abstractSchemaName);
  1737.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1738.             $this->match(Lexer::T_AS);
  1739.         }
  1741.         $token = $this->lexer->lookahead;
  1742.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1743.         $classMetadata = $this->em->getClassMetadata($abstractSchemaName);
  1745.         // Building queryComponent
  1746.         $queryComponent = [
  1747.             'metadata'     => $classMetadata,
  1748.             'parent'       => null,
  1749.             'relation'     => null,
  1750.             'map'          => null,
  1751.             'nestingLevel' => $this->nestingLevel,
  1752.             'token'        => $token
  1753.         ];
  1755.         $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1757.         return new AST\RangeVariableDeclaration($abstractSchemaName, $aliasIdentificationVariable);
  1758.     }
  1760.     /**
  1761.      * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [IndexBy]
  1762.      *
  1763.      * @return \Doctrine\ORM\Query\AST\JoinAssociationPathExpression
  1764.      */
  1765.     public function JoinAssociationDeclaration()
  1766.     {
  1767.         $joinAssociationPathExpression = $this->JoinAssociationPathExpression();
  1769.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1770.             $this->match(Lexer::T_AS);
  1771.         }
  1773.         $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1774.         $indexBy                     = $this->lexer->isNextToken(Lexer::T_INDEX) ? $this->IndexBy() : null;
  1776.         $identificationVariable = $joinAssociationPathExpression->identificationVariable;
  1777.         $field                  = $joinAssociationPathExpression->associationField;
  1779.         $class       = $this->queryComponents[$identificationVariable]['metadata'];
  1780.         $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1782.         // Building queryComponent
  1783.         $joinQueryComponent = [
  1784.             'metadata'     => $targetClass,
  1785.             'parent'       => $joinAssociationPathExpression->identificationVariable,
  1786.             'relation'     => $class->getAssociationMapping($field),
  1787.             'map'          => null,
  1788.             'nestingLevel' => $this->nestingLevel,
  1789.             'token'        => $this->lexer->lookahead
  1790.         ];
  1792.         $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1794.         return new AST\JoinAssociationDeclaration($joinAssociationPathExpression, $aliasIdentificationVariable, $indexBy);
  1795.     }
  1797.     /**
  1798.      * PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
  1799.      * PartialFieldSet ::= "{" SimpleStateField {"," SimpleStateField}* "}"
  1800.      *
  1801.      * @return \Doctrine\ORM\Query\AST\PartialObjectExpression
  1802.      */
  1803.     public function PartialObjectExpression()
  1804.     {
  1805.         $this->match(Lexer::T_PARTIAL);
  1807.         $partialFieldSet = [];
  1809.         $identificationVariable = $this->IdentificationVariable();
  1811.         $this->match(Lexer::T_DOT);
  1812.         $this->match(Lexer::T_OPEN_CURLY_BRACE);
  1813.         $this->match(Lexer::T_IDENTIFIER);
  1815.         $field = $this->lexer->token['value'];
  1817.         // First field in partial expression might be embeddable property
  1818.         while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1819.             $this->match(Lexer::T_DOT);
  1820.             $this->match(Lexer::T_IDENTIFIER);
  1821.             $field .= '.'.$this->lexer->token['value'];
  1822.         }
  1824.         $partialFieldSet[] = $field;
  1826.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1827.             $this->match(Lexer::T_COMMA);
  1828.             $this->match(Lexer::T_IDENTIFIER);
  1830.             $field = $this->lexer->token['value'];
  1832.             while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1833.                 $this->match(Lexer::T_DOT);
  1834.                 $this->match(Lexer::T_IDENTIFIER);
  1835.                 $field .= '.'.$this->lexer->token['value'];
  1836.             }
  1838.             $partialFieldSet[] = $field;
  1839.         }
  1841.         $this->match(Lexer::T_CLOSE_CURLY_BRACE);
  1843.         $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
  1845.         // Defer PartialObjectExpression validation
  1846.         $this->deferredPartialObjectExpressions[] = [
  1847.             'expression'   => $partialObjectExpression,
  1848.             'nestingLevel' => $this->nestingLevel,
  1849.             'token'        => $this->lexer->token,
  1850.         ];
  1852.         return $partialObjectExpression;
  1853.     }
  1855.     /**
  1856.      * NewObjectExpression ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
  1857.      *
  1858.      * @return \Doctrine\ORM\Query\AST\NewObjectExpression
  1859.      */
  1860.     public function NewObjectExpression()
  1861.     {
  1862.         $this->match(Lexer::T_NEW);
  1864.         $className = $this->AbstractSchemaName(); // note that this is not yet validated
  1865.         $token = $this->lexer->token;
  1867.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  1869.         $args[] = $this->NewObjectArg();
  1871.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1872.             $this->match(Lexer::T_COMMA);
  1874.             $args[] = $this->NewObjectArg();
  1875.         }
  1877.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1879.         $expression = new AST\NewObjectExpression($className, $args);
  1881.         // Defer NewObjectExpression validation
  1882.         $this->deferredNewObjectExpressions[] = [
  1883.             'token'        => $token,
  1884.             'expression'   => $expression,
  1885.             'nestingLevel' => $this->nestingLevel,
  1886.         ];
  1888.         return $expression;
  1889.     }
  1891.     /**
  1892.      * NewObjectArg ::= ScalarExpression | "(" Subselect ")"
  1893.      *
  1894.      * @return mixed
  1895.      */
  1896.     public function NewObjectArg()
  1897.     {
  1898.         $token = $this->lexer->lookahead;
  1899.         $peek  = $this->lexer->glimpse();
  1901.         if ($token['type'] === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT) {
  1902.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  1903.             $expression = $this->Subselect();
  1904.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1906.             return $expression;
  1907.         }
  1909.         return $this->ScalarExpression();
  1910.     }
  1912.     /**
  1913.      * IndexBy ::= "INDEX" "BY" StateFieldPathExpression
  1914.      *
  1915.      * @return \Doctrine\ORM\Query\AST\IndexBy
  1916.      */
  1917.     public function IndexBy()
  1918.     {
  1919.         $this->match(Lexer::T_INDEX);
  1920.         $this->match(Lexer::T_BY);
  1921.         $pathExpr = $this->StateFieldPathExpression();
  1923.         // Add the INDEX BY info to the query component
  1924.         $this->queryComponents[$pathExpr->identificationVariable]['map'] = $pathExpr->field;
  1926.         return new AST\IndexBy($pathExpr);
  1927.     }
  1929.     /**
  1930.      * ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DateTimePrimary |
  1931.      *                      StateFieldPathExpression | BooleanPrimary | CaseExpression |
  1932.      *                      InstanceOfExpression
  1933.      *
  1934.      * @return mixed One of the possible expressions or subexpressions.
  1935.      */
  1936.     public function ScalarExpression()
  1937.     {
  1938.         $lookahead = $this->lexer->lookahead['type'];
  1939.         $peek      = $this->lexer->glimpse();
  1941.         switch (true) {
  1942.             case ($lookahead === Lexer::T_INTEGER):
  1943.             case ($lookahead === Lexer::T_FLOAT):
  1944.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )  or ( - 1 ) or ( + 1 )
  1945.             case ($lookahead === Lexer::T_MINUS):
  1946.             case ($lookahead === Lexer::T_PLUS):
  1947.                 return $this->SimpleArithmeticExpression();
  1949.             case ($lookahead === Lexer::T_STRING):
  1950.                 return $this->StringPrimary();
  1952.             case ($lookahead === Lexer::T_TRUE):
  1953.             case ($lookahead === Lexer::T_FALSE):
  1954.                 $this->match($lookahead);
  1956.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  1958.             case ($lookahead === Lexer::T_INPUT_PARAMETER):
  1959.                 switch (true) {
  1960.                     case $this->isMathOperator($peek):
  1961.                         // :param + u.value
  1962.                         return $this->SimpleArithmeticExpression();
  1963.                     default:
  1964.                         return $this->InputParameter();
  1965.                 }
  1967.             case ($lookahead === Lexer::T_CASE):
  1968.             case ($lookahead === Lexer::T_COALESCE):
  1969.             case ($lookahead === Lexer::T_NULLIF):
  1970.                 // Since NULLIF and COALESCE can be identified as a function,
  1971.                 // we need to check these before checking for FunctionDeclaration
  1972.                 return $this->CaseExpression();
  1974.             case ($lookahead === Lexer::T_OPEN_PARENTHESIS):
  1975.                 return $this->SimpleArithmeticExpression();
  1977.             // this check must be done before checking for a filed path expression
  1978.             case ($this->isFunction()):
  1979.                 $this->lexer->peek(); // "("
  1981.                 switch (true) {
  1982.                     case ($this->isMathOperator($this->peekBeyondClosingParenthesis())):
  1983.                         // SUM(u.id) + COUNT(u.id)
  1984.                         return $this->SimpleArithmeticExpression();
  1986.                     default:
  1987.                         // IDENTITY(u)
  1988.                         return $this->FunctionDeclaration();
  1989.                 }
  1991.                 break;
  1992.             // it is no function, so it must be a field path
  1993.             case ($lookahead === Lexer::T_IDENTIFIER):
  1994.                 $this->lexer->peek(); // lookahead => '.'
  1995.                 $this->lexer->peek(); // lookahead => token after '.'
  1996.                 $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1997.                 $this->lexer->resetPeek();
  1999.                 if ($this->isMathOperator($peek)) {
  2000.                     return $this->SimpleArithmeticExpression();
  2001.                 }
  2003.                 return $this->StateFieldPathExpression();
  2005.             default:
  2006.                 $this->syntaxError();
  2007.         }
  2008.     }
  2010.     /**
  2011.      * CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullifExpression
  2012.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2013.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2014.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2015.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2016.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2017.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2018.      * NullifExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2019.      *
  2020.      * @return mixed One of the possible expressions or subexpressions.
  2021.      */
  2022.     public function CaseExpression()
  2023.     {
  2024.         $lookahead = $this->lexer->lookahead['type'];
  2026.         switch ($lookahead) {
  2027.             case Lexer::T_NULLIF:
  2028.                 return $this->NullIfExpression();
  2030.             case Lexer::T_COALESCE:
  2031.                 return $this->CoalesceExpression();
  2033.             case Lexer::T_CASE:
  2034.                 $this->lexer->resetPeek();
  2035.                 $peek = $this->lexer->peek();
  2037.                 if ($peek['type'] === Lexer::T_WHEN) {
  2038.                     return $this->GeneralCaseExpression();
  2039.                 }
  2041.                 return $this->SimpleCaseExpression();
  2043.             default:
  2044.                 // Do nothing
  2045.                 break;
  2046.         }
  2048.         $this->syntaxError();
  2049.     }
  2051.     /**
  2052.      * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2053.      *
  2054.      * @return \Doctrine\ORM\Query\AST\CoalesceExpression
  2055.      */
  2056.     public function CoalesceExpression()
  2057.     {
  2058.         $this->match(Lexer::T_COALESCE);
  2059.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2061.         // Process ScalarExpressions (1..N)
  2062.         $scalarExpressions = [];
  2063.         $scalarExpressions[] = $this->ScalarExpression();
  2065.         while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  2066.             $this->match(Lexer::T_COMMA);
  2068.             $scalarExpressions[] = $this->ScalarExpression();
  2069.         }
  2071.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2073.         return new AST\CoalesceExpression($scalarExpressions);
  2074.     }
  2076.     /**
  2077.      * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2078.      *
  2079.      * @return \Doctrine\ORM\Query\AST\NullIfExpression
  2080.      */
  2081.     public function NullIfExpression()
  2082.     {
  2083.         $this->match(Lexer::T_NULLIF);
  2084.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2086.         $firstExpression = $this->ScalarExpression();
  2087.         $this->match(Lexer::T_COMMA);
  2088.         $secondExpression = $this->ScalarExpression();
  2090.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2092.         return new AST\NullIfExpression($firstExpression, $secondExpression);
  2093.     }
  2095.     /**
  2096.      * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2097.      *
  2098.      * @return \Doctrine\ORM\Query\AST\GeneralCaseExpression
  2099.      */
  2100.     public function GeneralCaseExpression()
  2101.     {
  2102.         $this->match(Lexer::T_CASE);
  2104.         // Process WhenClause (1..N)
  2105.         $whenClauses = [];
  2107.         do {
  2108.             $whenClauses[] = $this->WhenClause();
  2109.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2111.         $this->match(Lexer::T_ELSE);
  2112.         $scalarExpression = $this->ScalarExpression();
  2113.         $this->match(Lexer::T_END);
  2115.         return new AST\GeneralCaseExpression($whenClauses, $scalarExpression);
  2116.     }
  2118.     /**
  2119.      * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2120.      * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2121.      *
  2122.      * @return AST\SimpleCaseExpression
  2123.      */
  2124.     public function SimpleCaseExpression()
  2125.     {
  2126.         $this->match(Lexer::T_CASE);
  2127.         $caseOperand = $this->StateFieldPathExpression();
  2129.         // Process SimpleWhenClause (1..N)
  2130.         $simpleWhenClauses = [];
  2132.         do {
  2133.             $simpleWhenClauses[] = $this->SimpleWhenClause();
  2134.         } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2136.         $this->match(Lexer::T_ELSE);
  2137.         $scalarExpression = $this->ScalarExpression();
  2138.         $this->match(Lexer::T_END);
  2140.         return new AST\SimpleCaseExpression($caseOperand, $simpleWhenClauses, $scalarExpression);
  2141.     }
  2143.     /**
  2144.      * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2145.      *
  2146.      * @return \Doctrine\ORM\Query\AST\WhenClause
  2147.      */
  2148.     public function WhenClause()
  2149.     {
  2150.         $this->match(Lexer::T_WHEN);
  2151.         $conditionalExpression = $this->ConditionalExpression();
  2152.         $this->match(Lexer::T_THEN);
  2154.         return new AST\WhenClause($conditionalExpression, $this->ScalarExpression());
  2155.     }
  2157.     /**
  2158.      * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2159.      *
  2160.      * @return \Doctrine\ORM\Query\AST\SimpleWhenClause
  2161.      */
  2162.     public function SimpleWhenClause()
  2163.     {
  2164.         $this->match(Lexer::T_WHEN);
  2165.         $conditionalExpression = $this->ScalarExpression();
  2166.         $this->match(Lexer::T_THEN);
  2168.         return new AST\SimpleWhenClause($conditionalExpression, $this->ScalarExpression());
  2169.     }
  2171.     /**
  2172.      * SelectExpression ::= (
  2173.      *     IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration |
  2174.      *     PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression
  2175.      * ) [["AS"] ["HIDDEN"] AliasResultVariable]
  2176.      *
  2177.      * @return \Doctrine\ORM\Query\AST\SelectExpression
  2178.      */
  2179.     public function SelectExpression()
  2180.     {
  2181.         $expression    = null;
  2182.         $identVariable = null;
  2183.         $peek          = $this->lexer->glimpse();
  2184.         $lookaheadType = $this->lexer->lookahead['type'];
  2186.         switch (true) {
  2187.             // ScalarExpression (u.name)
  2188.             case ($lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] === Lexer::T_DOT):
  2189.                 $expression = $this->ScalarExpression();
  2190.                 break;
  2192.             // IdentificationVariable (u)
  2193.             case ($lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] !== Lexer::T_OPEN_PARENTHESIS):
  2194.                 $expression = $identVariable = $this->IdentificationVariable();
  2195.                 break;
  2197.             // CaseExpression (CASE ... or NULLIF(...) or COALESCE(...))
  2198.             case ($lookaheadType === Lexer::T_CASE):
  2199.             case ($lookaheadType === Lexer::T_COALESCE):
  2200.             case ($lookaheadType === Lexer::T_NULLIF):
  2201.                 $expression = $this->CaseExpression();
  2202.                 break;
  2204.             // DQL Function (SUM(u.value) or SUM(u.value) + 1)
  2205.             case ($this->isFunction()):
  2206.                 $this->lexer->peek(); // "("
  2208.                 switch (true) {
  2209.                     case ($this->isMathOperator($this->peekBeyondClosingParenthesis())):
  2210.                         // SUM(u.id) + COUNT(u.id)
  2211.                         $expression = $this->ScalarExpression();
  2212.                         break;
  2214.                     default:
  2215.                         // IDENTITY(u)
  2216.                         $expression = $this->FunctionDeclaration();
  2217.                         break;
  2218.                 }
  2220.                 break;
  2222.             // PartialObjectExpression (PARTIAL u.{id, name})
  2223.             case ($lookaheadType === Lexer::T_PARTIAL):
  2224.                 $expression    = $this->PartialObjectExpression();
  2225.                 $identVariable = $expression->identificationVariable;
  2226.                 break;
  2228.             // Subselect
  2229.             case ($lookaheadType === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT):
  2230.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2231.                 $expression = $this->Subselect();
  2232.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2233.                 break;
  2235.             // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2236.             case ($lookaheadType === Lexer::T_OPEN_PARENTHESIS):
  2237.             case ($lookaheadType === Lexer::T_INTEGER):
  2238.             case ($lookaheadType === Lexer::T_STRING):
  2239.             case ($lookaheadType === Lexer::T_FLOAT):
  2240.             // SimpleArithmeticExpression : (- u.value ) or ( + u.value )
  2241.             case ($lookaheadType === Lexer::T_MINUS):
  2242.             case ($lookaheadType === Lexer::T_PLUS):
  2243.                 $expression = $this->SimpleArithmeticExpression();
  2244.                 break;
  2246.             // NewObjectExpression (New ClassName(id, name))
  2247.             case ($lookaheadType === Lexer::T_NEW):
  2248.                 $expression = $this->NewObjectExpression();
  2249.                 break;
  2251.             default:
  2252.                 $this->syntaxError(
  2253.                     'IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression',
  2254.                     $this->lexer->lookahead
  2255.                 );
  2256.         }
  2258.         // [["AS"] ["HIDDEN"] AliasResultVariable]
  2259.         $mustHaveAliasResultVariable = false;
  2261.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2262.             $this->match(Lexer::T_AS);
  2264.             $mustHaveAliasResultVariable = true;
  2265.         }
  2267.         $hiddenAliasResultVariable = false;
  2269.         if ($this->lexer->isNextToken(Lexer::T_HIDDEN)) {
  2270.             $this->match(Lexer::T_HIDDEN);
  2272.             $hiddenAliasResultVariable = true;
  2273.         }
  2275.         $aliasResultVariable = null;
  2277.         if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2278.             $token = $this->lexer->lookahead;
  2279.             $aliasResultVariable = $this->AliasResultVariable();
  2281.             // Include AliasResultVariable in query components.
  2282.             $this->queryComponents[$aliasResultVariable] = [
  2283.                 'resultVariable' => $expression,
  2284.                 'nestingLevel'   => $this->nestingLevel,
  2285.                 'token'          => $token,
  2286.             ];
  2287.         }
  2289.         // AST
  2291.         $expr = new AST\SelectExpression($expression, $aliasResultVariable, $hiddenAliasResultVariable);
  2293.         if ($identVariable) {
  2294.             $this->identVariableExpressions[$identVariable] = $expr;
  2295.         }
  2297.         return $expr;
  2298.     }
  2300.     /**
  2301.      * SimpleSelectExpression ::= (
  2302.      *      StateFieldPathExpression | IdentificationVariable | FunctionDeclaration |
  2303.      *      AggregateExpression | "(" Subselect ")" | ScalarExpression
  2304.      * ) [["AS"] AliasResultVariable]
  2305.      *
  2306.      * @return \Doctrine\ORM\Query\AST\SimpleSelectExpression
  2307.      */
  2308.     public function SimpleSelectExpression()
  2309.     {
  2310.         $peek = $this->lexer->glimpse();
  2312.         switch ($this->lexer->lookahead['type']) {
  2313.             case Lexer::T_IDENTIFIER:
  2314.                 switch (true) {
  2315.                     case ($peek['type'] === Lexer::T_DOT):
  2316.                         $expression = $this->StateFieldPathExpression();
  2318.                         return new AST\SimpleSelectExpression($expression);
  2320.                     case ($peek['type'] !== Lexer::T_OPEN_PARENTHESIS):
  2321.                         $expression = $this->IdentificationVariable();
  2323.                         return new AST\SimpleSelectExpression($expression);
  2325.                     case ($this->isFunction()):
  2326.                         // SUM(u.id) + COUNT(u.id)
  2327.                         if ($this->isMathOperator($this->peekBeyondClosingParenthesis())) {
  2328.                             return new AST\SimpleSelectExpression($this->ScalarExpression());
  2329.                         }
  2330.                         // COUNT(u.id)
  2331.                         if ($this->isAggregateFunction($this->lexer->lookahead['type'])) {
  2332.                             return new AST\SimpleSelectExpression($this->AggregateExpression());
  2333.                         }
  2334.                         // IDENTITY(u)
  2335.                         return new AST\SimpleSelectExpression($this->FunctionDeclaration());
  2337.                     default:
  2338.                         // Do nothing
  2339.                 }
  2340.                 break;
  2342.             case Lexer::T_OPEN_PARENTHESIS:
  2343.                 if ($peek['type'] !== Lexer::T_SELECT) {
  2344.                     // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2345.                     $expression = $this->SimpleArithmeticExpression();
  2347.                     return new AST\SimpleSelectExpression($expression);
  2348.                 }
  2350.                 // Subselect
  2351.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2352.                 $expression = $this->Subselect();
  2353.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2355.                 return new AST\SimpleSelectExpression($expression);
  2357.             default:
  2358.                 // Do nothing
  2359.         }
  2361.         $this->lexer->peek();
  2363.         $expression = $this->ScalarExpression();
  2364.         $expr       = new AST\SimpleSelectExpression($expression);
  2366.         if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2367.             $this->match(Lexer::T_AS);
  2368.         }
  2370.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2371.             $token = $this->lexer->lookahead;
  2372.             $resultVariable = $this->AliasResultVariable();
  2373.             $expr->fieldIdentificationVariable = $resultVariable;
  2375.             // Include AliasResultVariable in query components.
  2376.             $this->queryComponents[$resultVariable] = [
  2377.                 'resultvariable' => $expr,
  2378.                 'nestingLevel'   => $this->nestingLevel,
  2379.                 'token'          => $token,
  2380.             ];
  2381.         }
  2383.         return $expr;
  2384.     }
  2386.     /**
  2387.      * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
  2388.      *
  2389.      * @return \Doctrine\ORM\Query\AST\ConditionalExpression
  2390.      */
  2391.     public function ConditionalExpression()
  2392.     {
  2393.         $conditionalTerms = [];
  2394.         $conditionalTerms[] = $this->ConditionalTerm();
  2396.         while ($this->lexer->isNextToken(Lexer::T_OR)) {
  2397.             $this->match(Lexer::T_OR);
  2399.             $conditionalTerms[] = $this->ConditionalTerm();
  2400.         }
  2402.         // Phase 1 AST optimization: Prevent AST\ConditionalExpression
  2403.         // if only one AST\ConditionalTerm is defined
  2404.         if (count($conditionalTerms) == 1) {
  2405.             return $conditionalTerms[0];
  2406.         }
  2408.         return new AST\ConditionalExpression($conditionalTerms);
  2409.     }
  2411.     /**
  2412.      * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
  2413.      *
  2414.      * @return \Doctrine\ORM\Query\AST\ConditionalTerm
  2415.      */
  2416.     public function ConditionalTerm()
  2417.     {
  2418.         $conditionalFactors = [];
  2419.         $conditionalFactors[] = $this->ConditionalFactor();
  2421.         while ($this->lexer->isNextToken(Lexer::T_AND)) {
  2422.             $this->match(Lexer::T_AND);
  2424.             $conditionalFactors[] = $this->ConditionalFactor();
  2425.         }
  2427.         // Phase 1 AST optimization: Prevent AST\ConditionalTerm
  2428.         // if only one AST\ConditionalFactor is defined
  2429.         if (count($conditionalFactors) == 1) {
  2430.             return $conditionalFactors[0];
  2431.         }
  2433.         return new AST\ConditionalTerm($conditionalFactors);
  2434.     }
  2436.     /**
  2437.      * ConditionalFactor ::= ["NOT"] ConditionalPrimary
  2438.      *
  2439.      * @return \Doctrine\ORM\Query\AST\ConditionalFactor
  2440.      */
  2441.     public function ConditionalFactor()
  2442.     {
  2443.         $not = false;
  2445.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2446.             $this->match(Lexer::T_NOT);
  2448.             $not = true;
  2449.         }
  2451.         $conditionalPrimary = $this->ConditionalPrimary();
  2453.         // Phase 1 AST optimization: Prevent AST\ConditionalFactor
  2454.         // if only one AST\ConditionalPrimary is defined
  2455.         if ( ! $not) {
  2456.             return $conditionalPrimary;
  2457.         }
  2459.         $conditionalFactor = new AST\ConditionalFactor($conditionalPrimary);
  2460.         $conditionalFactor->not = $not;
  2462.         return $conditionalFactor;
  2463.     }
  2465.     /**
  2466.      * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
  2467.      *
  2468.      * @return \Doctrine\ORM\Query\AST\ConditionalPrimary
  2469.      */
  2470.     public function ConditionalPrimary()
  2471.     {
  2472.         $condPrimary = new AST\ConditionalPrimary;
  2474.         if ( ! $this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2475.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2477.             return $condPrimary;
  2478.         }
  2480.         // Peek beyond the matching closing parenthesis ')'
  2481.         $peek = $this->peekBeyondClosingParenthesis();
  2483.         if ($peek !== null && (
  2484.             in_array($peek['value'], ['=', '<', '<=', '<>', '>', '>=', '!=']) ||
  2485.             in_array($peek['type'], [Lexer::T_NOT, Lexer::T_BETWEEN, Lexer::T_LIKE, Lexer::T_IN, Lexer::T_IS, Lexer::T_EXISTS]) ||
  2486.             $this->isMathOperator($peek)
  2487.         )) {
  2488.             $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2490.             return $condPrimary;
  2491.         }
  2493.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2494.         $condPrimary->conditionalExpression = $this->ConditionalExpression();
  2495.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2497.         return $condPrimary;
  2498.     }
  2500.     /**
  2501.      * SimpleConditionalExpression ::=
  2502.      *      ComparisonExpression | BetweenExpression | LikeExpression |
  2503.      *      InExpression | NullComparisonExpression | ExistsExpression |
  2504.      *      EmptyCollectionComparisonExpression | CollectionMemberExpression |
  2505.      *      InstanceOfExpression
  2506.      */
  2507.     public function SimpleConditionalExpression()
  2508.     {
  2509.         if ($this->lexer->isNextToken(Lexer::T_EXISTS)) {
  2510.             return $this->ExistsExpression();
  2511.         }
  2513.         $token      = $this->lexer->lookahead;
  2514.         $peek       = $this->lexer->glimpse();
  2515.         $lookahead  = $token;
  2517.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2518.             $token = $this->lexer->glimpse();
  2519.         }
  2521.         if ($token['type'] === Lexer::T_IDENTIFIER || $token['type'] === Lexer::T_INPUT_PARAMETER || $this->isFunction()) {
  2522.             // Peek beyond the matching closing parenthesis.
  2523.             $beyond = $this->lexer->peek();
  2525.             switch ($peek['value']) {
  2526.                 case '(':
  2527.                     // Peeks beyond the matched closing parenthesis.
  2528.                     $token = $this->peekBeyondClosingParenthesis(false);
  2530.                     if ($token['type'] === Lexer::T_NOT) {
  2531.                         $token = $this->lexer->peek();
  2532.                     }
  2534.                     if ($token['type'] === Lexer::T_IS) {
  2535.                         $lookahead = $this->lexer->peek();
  2536.                     }
  2537.                     break;
  2539.                 default:
  2540.                     // Peek beyond the PathExpression or InputParameter.
  2541.                     $token = $beyond;
  2543.                     while ($token['value'] === '.') {
  2544.                         $this->lexer->peek();
  2546.                         $token = $this->lexer->peek();
  2547.                     }
  2549.                     // Also peek beyond a NOT if there is one.
  2550.                     if ($token['type'] === Lexer::T_NOT) {
  2551.                         $token = $this->lexer->peek();
  2552.                     }
  2554.                     // We need to go even further in case of IS (differentiate between NULL and EMPTY)
  2555.                     $lookahead = $this->lexer->peek();
  2556.             }
  2558.             // Also peek beyond a NOT if there is one.
  2559.             if ($lookahead['type'] === Lexer::T_NOT) {
  2560.                 $lookahead = $this->lexer->peek();
  2561.             }
  2563.             $this->lexer->resetPeek();
  2564.         }
  2566.         if ($token['type'] === Lexer::T_BETWEEN) {
  2567.             return $this->BetweenExpression();
  2568.         }
  2570.         if ($token['type'] === Lexer::T_LIKE) {
  2571.             return $this->LikeExpression();
  2572.         }
  2574.         if ($token['type'] === Lexer::T_IN) {
  2575.             return $this->InExpression();
  2576.         }
  2578.         if ($token['type'] === Lexer::T_INSTANCE) {
  2579.             return $this->InstanceOfExpression();
  2580.         }
  2582.         if ($token['type'] === Lexer::T_MEMBER) {
  2583.             return $this->CollectionMemberExpression();
  2584.         }
  2586.         if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_NULL) {
  2587.             return $this->NullComparisonExpression();
  2588.         }
  2590.         if ($token['type'] === Lexer::T_IS  && $lookahead['type'] === Lexer::T_EMPTY) {
  2591.             return $this->EmptyCollectionComparisonExpression();
  2592.         }
  2594.         return $this->ComparisonExpression();
  2595.     }
  2597.     /**
  2598.      * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
  2599.      *
  2600.      * @return \Doctrine\ORM\Query\AST\EmptyCollectionComparisonExpression
  2601.      */
  2602.     public function EmptyCollectionComparisonExpression()
  2603.     {
  2604.         $emptyCollectionCompExpr = new AST\EmptyCollectionComparisonExpression(
  2605.             $this->CollectionValuedPathExpression()
  2606.         );
  2607.         $this->match(Lexer::T_IS);
  2609.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2610.             $this->match(Lexer::T_NOT);
  2611.             $emptyCollectionCompExpr->not = true;
  2612.         }
  2614.         $this->match(Lexer::T_EMPTY);
  2616.         return $emptyCollectionCompExpr;
  2617.     }
  2619.     /**
  2620.      * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
  2621.      *
  2622.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2623.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2624.      *
  2625.      * @return \Doctrine\ORM\Query\AST\CollectionMemberExpression
  2626.      */
  2627.     public function CollectionMemberExpression()
  2628.     {
  2629.         $not        = false;
  2630.         $entityExpr = $this->EntityExpression();
  2632.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2633.             $this->match(Lexer::T_NOT);
  2635.             $not = true;
  2636.         }
  2638.         $this->match(Lexer::T_MEMBER);
  2640.         if ($this->lexer->isNextToken(Lexer::T_OF)) {
  2641.             $this->match(Lexer::T_OF);
  2642.         }
  2644.         $collMemberExpr = new AST\CollectionMemberExpression(
  2645.             $entityExpr, $this->CollectionValuedPathExpression()
  2646.         );
  2647.         $collMemberExpr->not = $not;
  2649.         return $collMemberExpr;
  2650.     }
  2652.     /**
  2653.      * Literal ::= string | char | integer | float | boolean
  2654.      *
  2655.      * @return \Doctrine\ORM\Query\AST\Literal
  2656.      */
  2657.     public function Literal()
  2658.     {
  2659.         switch ($this->lexer->lookahead['type']) {
  2660.             case Lexer::T_STRING:
  2661.                 $this->match(Lexer::T_STRING);
  2663.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  2664.             case Lexer::T_INTEGER:
  2665.             case Lexer::T_FLOAT:
  2666.                 $this->match(
  2667.                     $this->lexer->isNextToken(Lexer::T_INTEGER) ? Lexer::T_INTEGER : Lexer::T_FLOAT
  2668.                 );
  2670.                 return new AST\Literal(AST\Literal::NUMERIC, $this->lexer->token['value']);
  2671.             case Lexer::T_TRUE:
  2672.             case Lexer::T_FALSE:
  2673.                 $this->match(
  2674.                     $this->lexer->isNextToken(Lexer::T_TRUE) ? Lexer::T_TRUE : Lexer::T_FALSE
  2675.                 );
  2677.                 return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2678.             default:
  2679.                 $this->syntaxError('Literal');
  2680.         }
  2681.     }
  2683.     /**
  2684.      * InParameter ::= Literal | InputParameter
  2685.      *
  2686.      * @return string | \Doctrine\ORM\Query\AST\InputParameter
  2687.      */
  2688.     public function InParameter()
  2689.     {
  2690.         if ($this->lexer->lookahead['type'] == Lexer::T_INPUT_PARAMETER) {
  2691.             return $this->InputParameter();
  2692.         }
  2694.         return $this->Literal();
  2695.     }
  2697.     /**
  2698.      * InputParameter ::= PositionalParameter | NamedParameter
  2699.      *
  2700.      * @return \Doctrine\ORM\Query\AST\InputParameter
  2701.      */
  2702.     public function InputParameter()
  2703.     {
  2704.         $this->match(Lexer::T_INPUT_PARAMETER);
  2706.         return new AST\InputParameter($this->lexer->token['value']);
  2707.     }
  2709.     /**
  2710.      * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
  2711.      *
  2712.      * @return \Doctrine\ORM\Query\AST\ArithmeticExpression
  2713.      */
  2714.     public function ArithmeticExpression()
  2715.     {
  2716.         $expr = new AST\ArithmeticExpression;
  2718.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2719.             $peek = $this->lexer->glimpse();
  2721.             if ($peek['type'] === Lexer::T_SELECT) {
  2722.                 $this->match(Lexer::T_OPEN_PARENTHESIS);
  2723.                 $expr->subselect = $this->Subselect();
  2724.                 $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2726.                 return $expr;
  2727.             }
  2728.         }
  2730.         $expr->simpleArithmeticExpression = $this->SimpleArithmeticExpression();
  2732.         return $expr;
  2733.     }
  2735.     /**
  2736.      * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
  2737.      *
  2738.      * @return \Doctrine\ORM\Query\AST\SimpleArithmeticExpression
  2739.      */
  2740.     public function SimpleArithmeticExpression()
  2741.     {
  2742.         $terms = [];
  2743.         $terms[] = $this->ArithmeticTerm();
  2745.         while (($isPlus = $this->lexer->isNextToken(Lexer::T_PLUS)) || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2746.             $this->match(($isPlus) ? Lexer::T_PLUS : Lexer::T_MINUS);
  2748.             $terms[] = $this->lexer->token['value'];
  2749.             $terms[] = $this->ArithmeticTerm();
  2750.         }
  2752.         // Phase 1 AST optimization: Prevent AST\SimpleArithmeticExpression
  2753.         // if only one AST\ArithmeticTerm is defined
  2754.         if (count($terms) == 1) {
  2755.             return $terms[0];
  2756.         }
  2758.         return new AST\SimpleArithmeticExpression($terms);
  2759.     }
  2761.     /**
  2762.      * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
  2763.      *
  2764.      * @return \Doctrine\ORM\Query\AST\ArithmeticTerm
  2765.      */
  2766.     public function ArithmeticTerm()
  2767.     {
  2768.         $factors = [];
  2769.         $factors[] = $this->ArithmeticFactor();
  2771.         while (($isMult = $this->lexer->isNextToken(Lexer::T_MULTIPLY)) || $this->lexer->isNextToken(Lexer::T_DIVIDE)) {
  2772.             $this->match(($isMult) ? Lexer::T_MULTIPLY : Lexer::T_DIVIDE);
  2774.             $factors[] = $this->lexer->token['value'];
  2775.             $factors[] = $this->ArithmeticFactor();
  2776.         }
  2778.         // Phase 1 AST optimization: Prevent AST\ArithmeticTerm
  2779.         // if only one AST\ArithmeticFactor is defined
  2780.         if (count($factors) == 1) {
  2781.             return $factors[0];
  2782.         }
  2784.         return new AST\ArithmeticTerm($factors);
  2785.     }
  2787.     /**
  2788.      * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
  2789.      *
  2790.      * @return \Doctrine\ORM\Query\AST\ArithmeticFactor
  2791.      */
  2792.     public function ArithmeticFactor()
  2793.     {
  2794.         $sign = null;
  2796.         if (($isPlus = $this->lexer->isNextToken(Lexer::T_PLUS)) || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2797.             $this->match(($isPlus) ? Lexer::T_PLUS : Lexer::T_MINUS);
  2798.             $sign = $isPlus;
  2799.         }
  2801.         $primary = $this->ArithmeticPrimary();
  2803.         // Phase 1 AST optimization: Prevent AST\ArithmeticFactor
  2804.         // if only one AST\ArithmeticPrimary is defined
  2805.         if ($sign === null) {
  2806.             return $primary;
  2807.         }
  2809.         return new AST\ArithmeticFactor($primary, $sign);
  2810.     }
  2812.     /**
  2813.      * ArithmeticPrimary ::= SingleValuedPathExpression | Literal | ParenthesisExpression
  2814.      *          | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings
  2815.      *          | FunctionsReturningDatetime | IdentificationVariable | ResultVariable
  2816.      *          | InputParameter | CaseExpression
  2817.      */
  2818.     public function ArithmeticPrimary()
  2819.     {
  2820.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2821.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2823.             $expr = $this->SimpleArithmeticExpression();
  2825.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2827.             return new AST\ParenthesisExpression($expr);
  2828.         }
  2830.         switch ($this->lexer->lookahead['type']) {
  2831.             case Lexer::T_COALESCE:
  2832.             case Lexer::T_NULLIF:
  2833.             case Lexer::T_CASE:
  2834.                 return $this->CaseExpression();
  2836.             case Lexer::T_IDENTIFIER:
  2837.                 $peek = $this->lexer->glimpse();
  2839.                 if ($peek !== null && $peek['value'] === '(') {
  2840.                     return $this->FunctionDeclaration();
  2841.                 }
  2843.                 if ($peek !== null && $peek['value'] === '.') {
  2844.                     return $this->SingleValuedPathExpression();
  2845.                 }
  2847.                 if (isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])) {
  2848.                     return $this->ResultVariable();
  2849.                 }
  2851.                 return $this->StateFieldPathExpression();
  2853.             case Lexer::T_INPUT_PARAMETER:
  2854.                 return $this->InputParameter();
  2856.             default:
  2857.                 $peek = $this->lexer->glimpse();
  2859.                 if ($peek !== null && $peek['value'] === '(') {
  2860.                     return $this->FunctionDeclaration();
  2861.                 }
  2863.                 return $this->Literal();
  2864.         }
  2865.     }
  2867.     /**
  2868.      * StringExpression ::= StringPrimary | ResultVariable | "(" Subselect ")"
  2869.      *
  2870.      * @return \Doctrine\ORM\Query\AST\Subselect |
  2871.      *         string
  2872.      */
  2873.     public function StringExpression()
  2874.     {
  2875.         $peek = $this->lexer->glimpse();
  2877.         // Subselect
  2878.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $peek['type'] === Lexer::T_SELECT) {
  2879.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  2880.             $expr = $this->Subselect();
  2881.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2883.             return $expr;
  2884.         }
  2886.         // ResultVariable (string)
  2887.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER) &&
  2888.             isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])) {
  2889.             return $this->ResultVariable();
  2890.         }
  2892.         return $this->StringPrimary();
  2893.     }
  2895.     /**
  2896.      * StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression
  2897.      */
  2898.     public function StringPrimary()
  2899.     {
  2900.         $lookaheadType = $this->lexer->lookahead['type'];
  2902.         switch ($lookaheadType) {
  2903.             case Lexer::T_IDENTIFIER:
  2904.                 $peek = $this->lexer->glimpse();
  2906.                 if ($peek['value'] == '.') {
  2907.                     return $this->StateFieldPathExpression();
  2908.                 }
  2910.                 if ($peek['value'] == '(') {
  2911.                     // do NOT directly go to FunctionsReturningString() because it doesn't check for custom functions.
  2912.                     return $this->FunctionDeclaration();
  2913.                 }
  2915.                 $this->syntaxError("'.' or '('");
  2916.                 break;
  2918.             case Lexer::T_STRING:
  2919.                 $this->match(Lexer::T_STRING);
  2921.                 return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  2923.             case Lexer::T_INPUT_PARAMETER:
  2924.                 return $this->InputParameter();
  2926.             case Lexer::T_CASE:
  2927.             case Lexer::T_COALESCE:
  2928.             case Lexer::T_NULLIF:
  2929.                 return $this->CaseExpression();
  2930.             default:
  2931.                 if ($this->isAggregateFunction($lookaheadType)) {
  2932.                     return $this->AggregateExpression();
  2933.                 }
  2934.         }
  2936.         $this->syntaxError(
  2937.             'StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression'
  2938.         );
  2939.     }
  2941.     /**
  2942.      * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2943.      *
  2944.      * @return \Doctrine\ORM\Query\AST\PathExpression |
  2945.      *         \Doctrine\ORM\Query\AST\SimpleEntityExpression
  2946.      */
  2947.     public function EntityExpression()
  2948.     {
  2949.         $glimpse = $this->lexer->glimpse();
  2951.         if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER) && $glimpse['value'] === '.') {
  2952.             return $this->SingleValuedAssociationPathExpression();
  2953.         }
  2955.         return $this->SimpleEntityExpression();
  2956.     }
  2958.     /**
  2959.      * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2960.      *
  2961.      * @return string | \Doctrine\ORM\Query\AST\InputParameter
  2962.      */
  2963.     public function SimpleEntityExpression()
  2964.     {
  2965.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  2966.             return $this->InputParameter();
  2967.         }
  2969.         return $this->StateFieldPathExpression();
  2970.     }
  2972.     /**
  2973.      * AggregateExpression ::=
  2974.      *  ("AVG" | "MAX" | "MIN" | "SUM" | "COUNT") "(" ["DISTINCT"] SimpleArithmeticExpression ")"
  2975.      *
  2976.      * @return \Doctrine\ORM\Query\AST\AggregateExpression
  2977.      */
  2978.     public function AggregateExpression()
  2979.     {
  2980.         $lookaheadType = $this->lexer->lookahead['type'];
  2981.         $isDistinct = false;
  2983.         if ( ! in_array($lookaheadType, [Lexer::T_COUNT, Lexer::T_AVG, Lexer::T_MAX, Lexer::T_MIN, Lexer::T_SUM])) {
  2984.             $this->syntaxError('One of: MAX, MIN, AVG, SUM, COUNT');
  2985.         }
  2987.         $this->match($lookaheadType);
  2988.         $functionName = $this->lexer->token['value'];
  2989.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  2991.         if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  2992.             $this->match(Lexer::T_DISTINCT);
  2993.             $isDistinct = true;
  2994.         }
  2996.         $pathExp = $this->SimpleArithmeticExpression();
  2998.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3000.         return new AST\AggregateExpression($functionName, $pathExp, $isDistinct);
  3001.     }
  3003.     /**
  3004.      * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
  3005.      *
  3006.      * @return \Doctrine\ORM\Query\AST\QuantifiedExpression
  3007.      */
  3008.     public function QuantifiedExpression()
  3009.     {
  3010.         $lookaheadType = $this->lexer->lookahead['type'];
  3011.         $value = $this->lexer->lookahead['value'];
  3013.         if ( ! in_array($lookaheadType, [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME])) {
  3014.             $this->syntaxError('ALL, ANY or SOME');
  3015.         }
  3017.         $this->match($lookaheadType);
  3018.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3020.         $qExpr = new AST\QuantifiedExpression($this->Subselect());
  3021.         $qExpr->type = $value;
  3023.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3025.         return $qExpr;
  3026.     }
  3028.     /**
  3029.      * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
  3030.      *
  3031.      * @return \Doctrine\ORM\Query\AST\BetweenExpression
  3032.      */
  3033.     public function BetweenExpression()
  3034.     {
  3035.         $not = false;
  3036.         $arithExpr1 = $this->ArithmeticExpression();
  3038.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3039.             $this->match(Lexer::T_NOT);
  3040.             $not = true;
  3041.         }
  3043.         $this->match(Lexer::T_BETWEEN);
  3044.         $arithExpr2 = $this->ArithmeticExpression();
  3045.         $this->match(Lexer::T_AND);
  3046.         $arithExpr3 = $this->ArithmeticExpression();
  3048.         $betweenExpr = new AST\BetweenExpression($arithExpr1, $arithExpr2, $arithExpr3);
  3049.         $betweenExpr->not = $not;
  3051.         return $betweenExpr;
  3052.     }
  3054.     /**
  3055.      * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )
  3056.      *
  3057.      * @return \Doctrine\ORM\Query\AST\ComparisonExpression
  3058.      */
  3059.     public function ComparisonExpression()
  3060.     {
  3061.         $this->lexer->glimpse();
  3063.         $leftExpr  = $this->ArithmeticExpression();
  3064.         $operator  = $this->ComparisonOperator();
  3065.         $rightExpr = ($this->isNextAllAnySome())
  3066.             ? $this->QuantifiedExpression()
  3067.             : $this->ArithmeticExpression();
  3069.         return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
  3070.     }
  3072.     /**
  3073.      * InExpression ::= SingleValuedPathExpression ["NOT"] "IN" "(" (InParameter {"," InParameter}* | Subselect) ")"
  3074.      *
  3075.      * @return \Doctrine\ORM\Query\AST\InExpression
  3076.      */
  3077.     public function InExpression()
  3078.     {
  3079.         $inExpression = new AST\InExpression($this->ArithmeticExpression());
  3081.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3082.             $this->match(Lexer::T_NOT);
  3083.             $inExpression->not = true;
  3084.         }
  3086.         $this->match(Lexer::T_IN);
  3087.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3089.         if ($this->lexer->isNextToken(Lexer::T_SELECT)) {
  3090.             $inExpression->subselect = $this->Subselect();
  3091.         } else {
  3092.             $literals = [];
  3093.             $literals[] = $this->InParameter();
  3095.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3096.                 $this->match(Lexer::T_COMMA);
  3097.                 $literals[] = $this->InParameter();
  3098.             }
  3100.             $inExpression->literals = $literals;
  3101.         }
  3103.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3105.         return $inExpression;
  3106.     }
  3108.     /**
  3109.      * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
  3110.      *
  3111.      * @return \Doctrine\ORM\Query\AST\InstanceOfExpression
  3112.      */
  3113.     public function InstanceOfExpression()
  3114.     {
  3115.         $instanceOfExpression = new AST\InstanceOfExpression($this->IdentificationVariable());
  3117.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3118.             $this->match(Lexer::T_NOT);
  3119.             $instanceOfExpression->not = true;
  3120.         }
  3122.         $this->match(Lexer::T_INSTANCE);
  3123.         $this->match(Lexer::T_OF);
  3125.         $exprValues = [];
  3127.         if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  3128.             $this->match(Lexer::T_OPEN_PARENTHESIS);
  3130.             $exprValues[] = $this->InstanceOfParameter();
  3132.             while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3133.                 $this->match(Lexer::T_COMMA);
  3135.                 $exprValues[] = $this->InstanceOfParameter();
  3136.             }
  3138.             $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3140.             $instanceOfExpression->value = $exprValues;
  3142.             return $instanceOfExpression;
  3143.         }
  3145.         $exprValues[] = $this->InstanceOfParameter();
  3147.         $instanceOfExpression->value = $exprValues;
  3149.         return $instanceOfExpression;
  3150.     }
  3152.     /**
  3153.      * InstanceOfParameter ::= AbstractSchemaName | InputParameter
  3154.      *
  3155.      * @return mixed
  3156.      */
  3157.     public function InstanceOfParameter()
  3158.     {
  3159.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3160.             $this->match(Lexer::T_INPUT_PARAMETER);
  3162.             return new AST\InputParameter($this->lexer->token['value']);
  3163.         }
  3165.         $abstractSchemaName = $this->AbstractSchemaName();
  3167.         $this->validateAbstractSchemaName($abstractSchemaName);
  3169.         return $abstractSchemaName;
  3170.     }
  3172.     /**
  3173.      * LikeExpression ::= StringExpression ["NOT"] "LIKE" StringPrimary ["ESCAPE" char]
  3174.      *
  3175.      * @return \Doctrine\ORM\Query\AST\LikeExpression
  3176.      */
  3177.     public function LikeExpression()
  3178.     {
  3179.         $stringExpr = $this->StringExpression();
  3180.         $not = false;
  3182.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3183.             $this->match(Lexer::T_NOT);
  3184.             $not = true;
  3185.         }
  3187.         $this->match(Lexer::T_LIKE);
  3189.         if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3190.             $this->match(Lexer::T_INPUT_PARAMETER);
  3191.             $stringPattern = new AST\InputParameter($this->lexer->token['value']);
  3192.         } else {
  3193.             $stringPattern = $this->StringPrimary();
  3194.         }
  3196.         $escapeChar = null;
  3198.         if ($this->lexer->lookahead !== null && $this->lexer->lookahead['type'] === Lexer::T_ESCAPE) {
  3199.             $this->match(Lexer::T_ESCAPE);
  3200.             $this->match(Lexer::T_STRING);
  3202.             $escapeChar = new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3203.         }
  3205.         $likeExpr = new AST\LikeExpression($stringExpr, $stringPattern, $escapeChar);
  3206.         $likeExpr->not = $not;
  3208.         return $likeExpr;
  3209.     }
  3211.     /**
  3212.      * NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) "IS" ["NOT"] "NULL"
  3213.      *
  3214.      * @return \Doctrine\ORM\Query\AST\NullComparisonExpression
  3215.      */
  3216.     public function NullComparisonExpression()
  3217.     {
  3218.         switch (true) {
  3219.             case $this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER):
  3220.                 $this->match(Lexer::T_INPUT_PARAMETER);
  3222.                 $expr = new AST\InputParameter($this->lexer->token['value']);
  3223.                 break;
  3225.             case $this->lexer->isNextToken(Lexer::T_NULLIF):
  3226.                 $expr = $this->NullIfExpression();
  3227.                 break;
  3229.             case $this->lexer->isNextToken(Lexer::T_COALESCE):
  3230.                 $expr = $this->CoalesceExpression();
  3231.                 break;
  3233.             case $this->isFunction():
  3234.                 $expr = $this->FunctionDeclaration();
  3235.                 break;
  3237.             default:
  3238.                 // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  3239.                 $glimpse = $this->lexer->glimpse();
  3241.                 if ($glimpse['type'] === Lexer::T_DOT) {
  3242.                     $expr = $this->SingleValuedPathExpression();
  3244.                     // Leave switch statement
  3245.                     break;
  3246.                 }
  3248.                 $lookaheadValue = $this->lexer->lookahead['value'];
  3250.                 // Validate existing component
  3251.                 if ( ! isset($this->queryComponents[$lookaheadValue])) {
  3252.                     $this->semanticalError('Cannot add having condition on undefined result variable.');
  3253.                 }
  3255.                 // Validate SingleValuedPathExpression (ie.: "product")
  3256.                 if (isset($this->queryComponents[$lookaheadValue]['metadata'])) {
  3257.                     $expr = $this->SingleValuedPathExpression();
  3258.                     break;
  3259.                 }
  3261.                 // Validating ResultVariable
  3262.                 if ( ! isset($this->queryComponents[$lookaheadValue]['resultVariable'])) {
  3263.                     $this->semanticalError('Cannot add having condition on a non result variable.');
  3264.                 }
  3266.                 $expr = $this->ResultVariable();
  3267.                 break;
  3268.         }
  3270.         $nullCompExpr = new AST\NullComparisonExpression($expr);
  3272.         $this->match(Lexer::T_IS);
  3274.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3275.             $this->match(Lexer::T_NOT);
  3277.             $nullCompExpr->not = true;
  3278.         }
  3280.         $this->match(Lexer::T_NULL);
  3282.         return $nullCompExpr;
  3283.     }
  3285.     /**
  3286.      * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
  3287.      *
  3288.      * @return \Doctrine\ORM\Query\AST\ExistsExpression
  3289.      */
  3290.     public function ExistsExpression()
  3291.     {
  3292.         $not = false;
  3294.         if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3295.             $this->match(Lexer::T_NOT);
  3296.             $not = true;
  3297.         }
  3299.         $this->match(Lexer::T_EXISTS);
  3300.         $this->match(Lexer::T_OPEN_PARENTHESIS);
  3302.         $existsExpression = new AST\ExistsExpression($this->Subselect());
  3303.         $existsExpression->not = $not;
  3305.         $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3307.         return $existsExpression;
  3308.     }
  3310.     /**
  3311.      * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
  3312.      *
  3313.      * @return string
  3314.      */
  3315.     public function ComparisonOperator()
  3316.     {
  3317.         switch ($this->lexer->lookahead['value']) {
  3318.             case '=':
  3319.                 $this->match(Lexer::T_EQUALS);
  3321.                 return '=';
  3323.             case '<':
  3324.                 $this->match(Lexer::T_LOWER_THAN);
  3325.                 $operator = '<';
  3327.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3328.                     $this->match(Lexer::T_EQUALS);
  3329.                     $operator .= '=';
  3330.                 } else if ($this->lexer->isNextToken(Lexer::T_GREATER_THAN)) {
  3331.                     $this->match(Lexer::T_GREATER_THAN);
  3332.                     $operator .= '>';
  3333.                 }
  3335.                 return $operator;
  3337.             case '>':
  3338.                 $this->match(Lexer::T_GREATER_THAN);
  3339.                 $operator = '>';
  3341.                 if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3342.                     $this->match(Lexer::T_EQUALS);
  3343.                     $operator .= '=';
  3344.                 }
  3346.                 return $operator;
  3348.             case '!':
  3349.                 $this->match(Lexer::T_NEGATE);
  3350.                 $this->match(Lexer::T_EQUALS);
  3352.                 return '<>';
  3354.             default:
  3355.                 $this->syntaxError('=, <, <=, <>, >, >=, !=');
  3356.         }
  3357.     }
  3359.     /**
  3360.      * FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDatetime
  3361.      *
  3362.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3363.      */
  3364.     public function FunctionDeclaration()
  3365.     {
  3366.         $token = $this->lexer->lookahead;
  3367.         $funcName = strtolower($token['value']);
  3369.         $customFunctionDeclaration = $this->CustomFunctionDeclaration();
  3371.         // Check for custom functions functions first!
  3372.         switch (true) {
  3373.             case $customFunctionDeclaration !== null:
  3374.                 return $customFunctionDeclaration;
  3376.             case (isset(self::$_STRING_FUNCTIONS[$funcName])):
  3377.                 return $this->FunctionsReturningStrings();
  3379.             case (isset(self::$_NUMERIC_FUNCTIONS[$funcName])):
  3380.                 return $this->FunctionsReturningNumerics();
  3382.             case (isset(self::$_DATETIME_FUNCTIONS[$funcName])):
  3383.                 return $this->FunctionsReturningDatetime();
  3385.             default:
  3386.                 $this->syntaxError('known function', $token);
  3387.         }
  3388.     }
  3390.     /**
  3391.      * Helper function for FunctionDeclaration grammar rule.
  3392.      *
  3393.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3394.      */
  3395.     private function CustomFunctionDeclaration()
  3396.     {
  3397.         $token = $this->lexer->lookahead;
  3398.         $funcName = strtolower($token['value']);
  3400.         // Check for custom functions afterwards
  3401.         $config = $this->em->getConfiguration();
  3403.         switch (true) {
  3404.             case ($config->getCustomStringFunction($funcName) !== null):
  3405.                 return $this->CustomFunctionsReturningStrings();
  3407.             case ($config->getCustomNumericFunction($funcName) !== null):
  3408.                 return $this->CustomFunctionsReturningNumerics();
  3410.             case ($config->getCustomDatetimeFunction($funcName) !== null):
  3411.                 return $this->CustomFunctionsReturningDatetime();
  3413.             default:
  3414.                 return null;
  3415.         }
  3416.     }
  3418.     /**
  3419.      * FunctionsReturningNumerics ::=
  3420.      *      "LENGTH" "(" StringPrimary ")" |
  3421.      *      "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")" |
  3422.      *      "ABS" "(" SimpleArithmeticExpression ")" |
  3423.      *      "SQRT" "(" SimpleArithmeticExpression ")" |
  3424.      *      "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3425.      *      "SIZE" "(" CollectionValuedPathExpression ")" |
  3426.      *      "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3427.      *      "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3428.      *      "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
  3429.      *
  3430.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3431.      */
  3432.     public function FunctionsReturningNumerics()
  3433.     {
  3434.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3435.         $funcClass     = self::$_NUMERIC_FUNCTIONS[$funcNameLower];
  3437.         $function = new $funcClass($funcNameLower);
  3438.         $function->parse($this);
  3440.         return $function;
  3441.     }
  3443.     /**
  3444.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3445.      */
  3446.     public function CustomFunctionsReturningNumerics()
  3447.     {
  3448.         // getCustomNumericFunction is case-insensitive
  3449.         $functionName  = strtolower($this->lexer->lookahead['value']);
  3450.         $functionClass = $this->em->getConfiguration()->getCustomNumericFunction($functionName);
  3452.         $function = is_string($functionClass)
  3453.             ? new $functionClass($functionName)
  3454.             : call_user_func($functionClass, $functionName);
  3456.         $function->parse($this);
  3458.         return $function;
  3459.     }
  3461.     /**
  3462.      * FunctionsReturningDateTime ::=
  3463.      *     "CURRENT_DATE" |
  3464.      *     "CURRENT_TIME" |
  3465.      *     "CURRENT_TIMESTAMP" |
  3466.      *     "DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")" |
  3467.      *     "DATE_SUB" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
  3468.      *
  3469.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3470.      */
  3471.     public function FunctionsReturningDatetime()
  3472.     {
  3473.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3474.         $funcClass     = self::$_DATETIME_FUNCTIONS[$funcNameLower];
  3476.         $function = new $funcClass($funcNameLower);
  3477.         $function->parse($this);
  3479.         return $function;
  3480.     }
  3482.     /**
  3483.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3484.      */
  3485.     public function CustomFunctionsReturningDatetime()
  3486.     {
  3487.         // getCustomDatetimeFunction is case-insensitive
  3488.         $functionName  = $this->lexer->lookahead['value'];
  3489.         $functionClass = $this->em->getConfiguration()->getCustomDatetimeFunction($functionName);
  3491.         $function = is_string($functionClass)
  3492.             ? new $functionClass($functionName)
  3493.             : call_user_func($functionClass, $functionName);
  3495.         $function->parse($this);
  3497.         return $function;
  3498.     }
  3500.     /**
  3501.      * FunctionsReturningStrings ::=
  3502.      *   "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary}* ")" |
  3503.      *   "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3504.      *   "TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")" |
  3505.      *   "LOWER" "(" StringPrimary ")" |
  3506.      *   "UPPER" "(" StringPrimary ")" |
  3507.      *   "IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
  3508.      *
  3509.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3510.      */
  3511.     public function FunctionsReturningStrings()
  3512.     {
  3513.         $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3514.         $funcClass     = self::$_STRING_FUNCTIONS[$funcNameLower];
  3516.         $function = new $funcClass($funcNameLower);
  3517.         $function->parse($this);
  3519.         return $function;
  3520.     }
  3522.     /**
  3523.      * @return \Doctrine\ORM\Query\AST\Functions\FunctionNode
  3524.      */
  3525.     public function CustomFunctionsReturningStrings()
  3526.     {
  3527.         // getCustomStringFunction is case-insensitive
  3528.         $functionName  = $this->lexer->lookahead['value'];
  3529.         $functionClass = $this->em->getConfiguration()->getCustomStringFunction($functionName);
  3531.         $function = is_string($functionClass)
  3532.             ? new $functionClass($functionName)
  3533.             : call_user_func($functionClass, $functionName);
  3535.         $function->parse($this);
  3537.         return $function;
  3538.     }
  3539. }