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 LGPL. For more information, see

    17  * <http://www.doctrine-project.org>.

    18  */

    19 

    20 namespace Doctrine\ORM\Query;

    21 

    22 use Doctrine\ORM\Query;

    23 use Doctrine\ORM\Mapping\ClassMetadata;

    24 

    25 /**

    26  * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.

    27  * Parses a DQL query, reports any errors in it, and generates an AST.

    28  *

    29  * @since   2.0

    30  * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>

    31  * @author  Jonathan Wage <jonwage@gmail.com>

    32  * @author  Roman Borschel <roman@code-factory.org>

    33  * @author  Janne Vanhala <jpvanhal@cc.hut.fi>

    34  */

    35 class Parser

    36 {

    37     /** READ-ONLY: Maps BUILT-IN string function names to AST class names. */

    38     private static $_STRING_FUNCTIONS = array(

    39         'concat'    => 'Doctrine\ORM\Query\AST\Functions\ConcatFunction',

    40         'substring' => 'Doctrine\ORM\Query\AST\Functions\SubstringFunction',

    41         'trim'      => 'Doctrine\ORM\Query\AST\Functions\TrimFunction',

    42         'lower'     => 'Doctrine\ORM\Query\AST\Functions\LowerFunction',

    43         'upper'     => 'Doctrine\ORM\Query\AST\Functions\UpperFunction'

    44     );

    45 

    46     /** READ-ONLY: Maps BUILT-IN numeric function names to AST class names. */

    47     private static $_NUMERIC_FUNCTIONS = array(

    48         'length'    => 'Doctrine\ORM\Query\AST\Functions\LengthFunction',

    49         'locate'    => 'Doctrine\ORM\Query\AST\Functions\LocateFunction',

    50         'abs'       => 'Doctrine\ORM\Query\AST\Functions\AbsFunction',

    51         'sqrt'      => 'Doctrine\ORM\Query\AST\Functions\SqrtFunction',

    52         'mod'       => 'Doctrine\ORM\Query\AST\Functions\ModFunction',

    53         'size'      => 'Doctrine\ORM\Query\AST\Functions\SizeFunction',

    54         'date_diff' => 'Doctrine\ORM\Query\AST\Functions\DateDiffFunction',

    55     );

    56 

    57     /** READ-ONLY: Maps BUILT-IN datetime function names to AST class names. */

    58     private static $_DATETIME_FUNCTIONS = array(

    59         'current_date'      => 'Doctrine\ORM\Query\AST\Functions\CurrentDateFunction',

    60         'current_time'      => 'Doctrine\ORM\Query\AST\Functions\CurrentTimeFunction',

    61         'current_timestamp' => 'Doctrine\ORM\Query\AST\Functions\CurrentTimestampFunction',

    62         'date_add'          => 'Doctrine\ORM\Query\AST\Functions\DateAddFunction',

    63         'date_sub'          => 'Doctrine\ORM\Query\AST\Functions\DateSubFunction',

    64     );

    65 

    66     /**

    67      * Expressions that were encountered during parsing of identifiers and expressions

    68      * and still need to be validated.

    69      */

    70     private $_deferredIdentificationVariables = array();

    71     private $_deferredPartialObjectExpressions = array();

    72     private $_deferredPathExpressions = array();

    73     private $_deferredResultVariables = array();

    74 

    75     /**

    76      * The lexer.

    77      *

    78      * @var Doctrine\ORM\Query\Lexer

    79      */

    80     private $_lexer;

    81 

    82     /**

    83      * The parser result.

    84      *

    85      * @var Doctrine\ORM\Query\ParserResult

    86      */

    87     private $_parserResult;

    88 

    89     /**

    90      * The EntityManager.

    91      *

    92      * @var EnityManager

    93      */

    94     private $_em;

    95 

    96     /**

    97      * The Query to parse.

    98      *

    99      * @var Query

   100      */

   101     private $_query;

   102 

   103     /**

   104      * Map of declared query components in the parsed query.

   105      *

   106      * @var array

   107      */

   108     private $_queryComponents = array();

   109 

   110     /**

   111      * Keeps the nesting level of defined ResultVariables

   112      *

   113      * @var integer

   114      */

   115     private $_nestingLevel = 0;

   116 

   117     /**

   118      * Any additional custom tree walkers that modify the AST.

   119      *

   120      * @var array

   121      */

   122     private $_customTreeWalkers = array();

   123 

   124     /**

   125      * The custom last tree walker, if any, that is responsible for producing the output.

   126      *

   127      * @var TreeWalker

   128      */

   129     private $_customOutputWalker;

   130 

   131     /**

   132      * @var array

   133      */

   134     private $_identVariableExpressions = array();

   135 

   136     /**

   137      * Creates a new query parser object.

   138      *

   139      * @param Query $query The Query to parse.

   140      */

   141     public function __construct(Query $query)

   142     {

   143         $this->_query = $query;

   144         $this->_em = $query->getEntityManager();

   145         $this->_lexer = new Lexer($query->getDql());

   146         $this->_parserResult = new ParserResult();

   147     }

   148 

   149     /**

   150      * Sets a custom tree walker that produces output.

   151      * This tree walker will be run last over the AST, after any other walkers.

   152      *

   153      * @param string $className

   154      */

   155     public function setCustomOutputTreeWalker($className)

   156     {

   157         $this->_customOutputWalker = $className;

   158     }

   159 

   160     /**

   161      * Adds a custom tree walker for modifying the AST.

   162      *

   163      * @param string $className

   164      */

   165     public function addCustomTreeWalker($className)

   166     {

   167         $this->_customTreeWalkers[] = $className;

   168     }

   169 

   170     /**

   171      * Gets the lexer used by the parser.

   172      *

   173      * @return Doctrine\ORM\Query\Lexer

   174      */

   175     public function getLexer()

   176     {

   177         return $this->_lexer;

   178     }

   179 

   180     /**

   181      * Gets the ParserResult that is being filled with information during parsing.

   182      *

   183      * @return Doctrine\ORM\Query\ParserResult

   184      */

   185     public function getParserResult()

   186     {

   187         return $this->_parserResult;

   188     }

   189 

   190     /**

   191      * Gets the EntityManager used by the parser.

   192      *

   193      * @return EntityManager

   194      */

   195     public function getEntityManager()

   196     {

   197         return $this->_em;

   198     }

   199 

   200     /**

   201      * Parse and build AST for the given Query.

   202      *

   203      * @return \Doctrine\ORM\Query\AST\SelectStatement |

   204      *         \Doctrine\ORM\Query\AST\UpdateStatement |

   205      *         \Doctrine\ORM\Query\AST\DeleteStatement

   206      */

   207     public function getAST()

   208     {

   209         // Parse & build AST

   210         $AST = $this->QueryLanguage();

   211 

   212         // Process any deferred validations of some nodes in the AST.

   213         // This also allows post-processing of the AST for modification purposes.

   214         $this->_processDeferredIdentificationVariables();

   215 

   216         if ($this->_deferredPartialObjectExpressions) {

   217             $this->_processDeferredPartialObjectExpressions();

   218         }

   219 

   220         if ($this->_deferredPathExpressions) {

   221             $this->_processDeferredPathExpressions($AST);

   222         }

   223 

   224         if ($this->_deferredResultVariables) {

   225             $this->_processDeferredResultVariables();

   226         }

   227 

   228         return $AST;

   229     }

   230 

   231     /**

   232      * Attempts to match the given token with the current lookahead token.

   233      *

   234      * If they match, updates the lookahead token; otherwise raises a syntax

   235      * error.

   236      *

   237      * @param int token type

   238      * @return void

   239      * @throws QueryException If the tokens dont match.

   240      */

   241     public function match($token)

   242     {

   243         // short-circuit on first condition, usually types match

   244         if ($this->_lexer->lookahead['type'] !== $token &&

   245                 $token !== Lexer::T_IDENTIFIER &&

   246                 $this->_lexer->lookahead['type'] <= Lexer::T_IDENTIFIER

   247          ) {

   248             $this->syntaxError($this->_lexer->getLiteral($token));

   249         }

   250 

   251         $this->_lexer->moveNext();

   252     }

   253 

   254     /**

   255      * Free this parser enabling it to be reused

   256      *

   257      * @param boolean $deep     Whether to clean peek and reset errors

   258      * @param integer $position Position to reset

   259      */

   260     public function free($deep = false, $position = 0)

   261     {

   262         // WARNING! Use this method with care. It resets the scanner!

   263         $this->_lexer->resetPosition($position);

   264 

   265         // Deep = true cleans peek and also any previously defined errors

   266         if ($deep) {

   267             $this->_lexer->resetPeek();

   268         }

   269 

   270         $this->_lexer->token = null;

   271         $this->_lexer->lookahead = null;

   272     }

   273 

   274     /**

   275      * Parses a query string.

   276      *

   277      * @return ParserResult

   278      */

   279     public function parse()

   280     {

   281         $AST = $this->getAST();

   282 

   283         $this->fixIdentificationVariableOrder($AST);

   284         $this->assertSelectEntityRootAliasRequirement();

   285 

   286         if (($customWalkers = $this->_query->getHint(Query::HINT_CUSTOM_TREE_WALKERS)) !== false) {

   287             $this->_customTreeWalkers = $customWalkers;

   288         }

   289 

   290         if (($customOutputWalker = $this->_query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER)) !== false) {

   291             $this->_customOutputWalker = $customOutputWalker;

   292         }

   293 

   294         // Run any custom tree walkers over the AST

   295         if ($this->_customTreeWalkers) {

   296             $treeWalkerChain = new TreeWalkerChain($this->_query, $this->_parserResult, $this->_queryComponents);

   297 

   298             foreach ($this->_customTreeWalkers as $walker) {

   299                 $treeWalkerChain->addTreeWalker($walker);

   300             }

   301 

   302             if ($AST instanceof AST\SelectStatement) {

   303                 $treeWalkerChain->walkSelectStatement($AST);

   304             } else if ($AST instanceof AST\UpdateStatement) {

   305                 $treeWalkerChain->walkUpdateStatement($AST);

   306             } else {

   307                 $treeWalkerChain->walkDeleteStatement($AST);

   308             }

   309         }

   310 

   311         if ($this->_customOutputWalker) {

   312             $outputWalker = new $this->_customOutputWalker(

   313                 $this->_query, $this->_parserResult, $this->_queryComponents

   314             );

   315         } else {

   316             $outputWalker = new SqlWalker(

   317                 $this->_query, $this->_parserResult, $this->_queryComponents

   318             );

   319         }

   320 

   321         // Assign an SQL executor to the parser result

   322         $this->_parserResult->setSqlExecutor($outputWalker->getExecutor($AST));

   323 

   324         return $this->_parserResult;

   325     }

   326     

   327     private function assertSelectEntityRootAliasRequirement()

   328     {

   329         if ( count($this->_identVariableExpressions) > 0) {

   330             $foundRootEntity = false;

   331             foreach ($this->_identVariableExpressions AS $dqlAlias => $expr) {

   332                 if (isset($this->_queryComponents[$dqlAlias]) && $this->_queryComponents[$dqlAlias]['parent'] === null) {

   333                     $foundRootEntity = true;

   334                 }

   335             }

   336             

   337             if (!$foundRootEntity) {

   338                 $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');

   339             }

   340         }

   341     }

   342     

   343     /**

   344      * Fix order of identification variables.

   345      * 

   346      * They have to appear in the select clause in the same order as the

   347      * declarations (from ... x join ... y join ... z ...) appear in the query

   348      * as the hydration process relies on that order for proper operation.

   349      * 

   350      * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST

   351      * @return void

   352      */

   353     private function fixIdentificationVariableOrder($AST)

   354     {

   355         if ( count($this->_identVariableExpressions) > 1) {

   356             foreach ($this->_queryComponents as $dqlAlias => $qComp) {

   357                 if (isset($this->_identVariableExpressions[$dqlAlias])) {

   358                     $expr = $this->_identVariableExpressions[$dqlAlias];

   359                     $key = array_search($expr, $AST->selectClause->selectExpressions);

   360                     unset($AST->selectClause->selectExpressions[$key]);

   361                     $AST->selectClause->selectExpressions[] = $expr;

   362                 }

   363             }

   364         }

   365     }

   366 

   367     /**

   368      * Generates a new syntax error.

   369      *

   370      * @param string $expected Expected string.

   371      * @param array $token Got token.

   372      *

   373      * @throws \Doctrine\ORM\Query\QueryException

   374      */

   375     public function syntaxError($expected = '', $token = null)

   376     {

   377         if ($token === null) {

   378             $token = $this->_lexer->lookahead;

   379         }

   380 

   381         $tokenPos = (isset($token['position'])) ? $token['position'] : '-1';

   382         $message  = "line 0, col {$tokenPos}: Error: ";

   383 

   384         if ($expected !== '') {

   385             $message .= "Expected {$expected}, got ";

   386         } else {

   387             $message .= 'Unexpected ';

   388         }

   389 

   390         if ($this->_lexer->lookahead === null) {

   391             $message .= 'end of string.';

   392         } else {

   393             $message .= "'{$token['value']}'";

   394         }

   395 

   396         throw QueryException::syntaxError($message);

   397     }

   398 

   399     /**

   400      * Generates a new semantical error.

   401      *

   402      * @param string $message Optional message.

   403      * @param array $token Optional token.

   404      *

   405      * @throws \Doctrine\ORM\Query\QueryException

   406      */

   407     public function semanticalError($message = '', $token = null)

   408     {

   409         if ($token === null) {

   410             $token = $this->_lexer->lookahead;

   411         }

   412 

   413         // Minimum exposed chars ahead of token

   414         $distance = 12;

   415 

   416         // Find a position of a final word to display in error string

   417         $dql = $this->_query->getDql();

   418         $length = strlen($dql);

   419         $pos = $token['position'] + $distance;

   420         $pos = strpos($dql, ' ', ($length > $pos) ? $pos : $length);

   421         $length = ($pos !== false) ? $pos - $token['position'] : $distance;

   422 

   423         // Building informative message

   424         $message = 'line 0, col ' . (

   425             (isset($token['position']) && $token['position'] > 0) ? $token['position'] : '-1'

   426         ) . " near '" . substr($dql, $token['position'], $length) . "': Error: " . $message;

   427 

   428         throw \Doctrine\ORM\Query\QueryException::semanticalError($message);

   429     }

   430 

   431     /**

   432      * Peeks beyond the specified token and returns the first token after that one.

   433      *

   434      * @param array $token

   435      * @return array

   436      */

   437     private function _peekBeyond($token)

   438     {

   439         $peek = $this->_lexer->peek();

   440 

   441         while ($peek['value'] != $token) {

   442             $peek = $this->_lexer->peek();

   443         }

   444 

   445         $peek = $this->_lexer->peek();

   446         $this->_lexer->resetPeek();

   447 

   448         return $peek;

   449     }

   450 

   451     /**

   452      * Peek beyond the matched closing parenthesis and return the first token after that one.

   453      *

   454      * @return array

   455      */

   456     private function _peekBeyondClosingParenthesis()

   457     {

   458         $token = $this->_lexer->peek();

   459         $numUnmatched = 1;

   460 

   461         while ($numUnmatched > 0 && $token !== null) {

   462             if ($token['value'] == ')') {

   463                 --$numUnmatched;

   464             } else if ($token['value'] == '(') {

   465                 ++$numUnmatched;

   466             }

   467 

   468             $token = $this->_lexer->peek();

   469         }

   470         

   471         $this->_lexer->resetPeek();

   472 

   473         return $token;

   474     }

   475 

   476     /**

   477      * Checks if the given token indicates a mathematical operator.

   478      *

   479      * @return boolean TRUE if the token is a mathematical operator, FALSE otherwise.

   480      */

   481     private function _isMathOperator($token)

   482     {

   483         return in_array($token['value'], array("+", "-", "/", "*"));

   484     }

   485 

   486     /**

   487      * Checks if the next-next (after lookahead) token starts a function.

   488      *

   489      * @return boolean TRUE if the next-next tokens start a function, FALSE otherwise.

   490      */

   491     private function _isFunction()

   492     {

   493         $peek = $this->_lexer->peek();

   494         $nextpeek = $this->_lexer->peek();

   495         $this->_lexer->resetPeek();

   496 

   497         // We deny the COUNT(SELECT * FROM User u) here. COUNT won't be considered a function

   498         return ($peek['value'] === '(' && $nextpeek['type'] !== Lexer::T_SELECT);

   499     }

   500 

   501     /**

   502      * Checks whether the given token type indicates an aggregate function.

   503      *

   504      * @return boolean TRUE if the token type is an aggregate function, FALSE otherwise.

   505      */

   506     private function _isAggregateFunction($tokenType)

   507     {

   508         return $tokenType == Lexer::T_AVG || $tokenType == Lexer::T_MIN ||

   509                $tokenType == Lexer::T_MAX || $tokenType == Lexer::T_SUM ||

   510                $tokenType == Lexer::T_COUNT;

   511     }

   512 

   513     /**

   514      * Checks whether the current lookahead token of the lexer has the type

   515      * T_ALL, T_ANY or T_SOME.

   516      *

   517      * @return boolean

   518      */

   519     private function _isNextAllAnySome()

   520     {

   521         return $this->_lexer->lookahead['type'] === Lexer::T_ALL ||

   522                $this->_lexer->lookahead['type'] === Lexer::T_ANY ||

   523                $this->_lexer->lookahead['type'] === Lexer::T_SOME;

   524     }

   525 

   526     /**

   527      * Checks whether the next 2 tokens start a subselect.

   528      *

   529      * @return boolean TRUE if the next 2 tokens start a subselect, FALSE otherwise.

   530      */

   531     private function _isSubselect()

   532     {

   533         $la = $this->_lexer->lookahead;

   534         $next = $this->_lexer->glimpse();

   535 

   536         return ($la['value'] === '(' && $next['type'] === Lexer::T_SELECT);

   537     }

   538 

   539     /**

   540      * Validates that the given <tt>IdentificationVariable</tt> is semantically correct.

   541      * It must exist in query components list.

   542      *

   543      * @return void

   544      */

   545     private function _processDeferredIdentificationVariables()

   546     {

   547         foreach ($this->_deferredIdentificationVariables as $deferredItem) {

   548             $identVariable = $deferredItem['expression'];

   549 

   550             // Check if IdentificationVariable exists in queryComponents

   551             if ( ! isset($this->_queryComponents[$identVariable])) {

   552                 $this->semanticalError(

   553                     "'$identVariable' is not defined.", $deferredItem['token']

   554                 );

   555             }

   556 

   557             $qComp = $this->_queryComponents[$identVariable];

   558 

   559             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable

   560             if ( ! isset($qComp['metadata'])) {

   561                 $this->semanticalError(

   562                     "'$identVariable' does not point to a Class.", $deferredItem['token']

   563                 );

   564             }

   565 

   566             // Validate if identification variable nesting level is lower or equal than the current one

   567             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {

   568                 $this->semanticalError(

   569                     "'$identVariable' is used outside the scope of its declaration.", $deferredItem['token']

   570                 );

   571             }

   572         }

   573     }

   574 

   575     /**

   576      * Validates that the given <tt>PartialObjectExpression</tt> is semantically correct.

   577      * It must exist in query components list.

   578      *

   579      * @return void

   580      */

   581     private function _processDeferredPartialObjectExpressions()

   582     {

   583         foreach ($this->_deferredPartialObjectExpressions as $deferredItem) {

   584             $expr = $deferredItem['expression'];

   585             $class = $this->_queryComponents[$expr->identificationVariable]['metadata'];

   586 

   587             foreach ($expr->partialFieldSet as $field) {

   588                 if ( ! isset($class->fieldMappings[$field])) {

   589                     $this->semanticalError(

   590                         "There is no mapped field named '$field' on class " . $class->name . ".",

   591                         $deferredItem['token']

   592                     );

   593                 }

   594             }

   595 

   596             if (array_intersect($class->identifier, $expr->partialFieldSet) != $class->identifier) {

   597                 $this->semanticalError(

   598                     "The partial field selection of class " . $class->name . " must contain the identifier.",

   599                     $deferredItem['token']

   600                 );

   601             }

   602         }

   603     }

   604 

   605     /**

   606      * Validates that the given <tt>ResultVariable</tt> is semantically correct.

   607      * It must exist in query components list.

   608      *

   609      * @return void

   610      */

   611     private function _processDeferredResultVariables()

   612     {

   613         foreach ($this->_deferredResultVariables as $deferredItem) {

   614             $resultVariable = $deferredItem['expression'];

   615 

   616             // Check if ResultVariable exists in queryComponents

   617             if ( ! isset($this->_queryComponents[$resultVariable])) {

   618                 $this->semanticalError(

   619                     "'$resultVariable' is not defined.", $deferredItem['token']

   620                 );

   621             }

   622 

   623             $qComp = $this->_queryComponents[$resultVariable];

   624 

   625             // Check if queryComponent points to an AbstractSchemaName or a ResultVariable

   626             if ( ! isset($qComp['resultVariable'])) {

   627                 $this->semanticalError(

   628                     "'$identVariable' does not point to a ResultVariable.", $deferredItem['token']

   629                 );

   630             }

   631 

   632             // Validate if identification variable nesting level is lower or equal than the current one

   633             if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {

   634                 $this->semanticalError(

   635                     "'$resultVariable' is used outside the scope of its declaration.", $deferredItem['token']

   636                 );

   637             }

   638         }

   639     }

   640 

   641     /**

   642      * Validates that the given <tt>PathExpression</tt> is semantically correct for grammar rules:

   643      *

   644      * AssociationPathExpression             ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression

   645      * SingleValuedPathExpression            ::= StateFieldPathExpression | SingleValuedAssociationPathExpression

   646      * StateFieldPathExpression              ::= IdentificationVariable "." StateField

   647      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField

   648      * CollectionValuedPathExpression        ::= IdentificationVariable "." CollectionValuedAssociationField

   649      *

   650      * @param array $deferredItem

   651      * @param mixed $AST

   652      */

   653     private function _processDeferredPathExpressions($AST)

   654     {

   655         foreach ($this->_deferredPathExpressions as $deferredItem) {

   656             $pathExpression = $deferredItem['expression'];

   657 

   658             $qComp = $this->_queryComponents[$pathExpression->identificationVariable];

   659             $class = $qComp['metadata'];

   660 

   661             if (($field = $pathExpression->field) === null) {

   662                 $field = $pathExpression->field = $class->identifier[0];

   663             }

   664             

   665             // Check if field or association exists

   666             if ( ! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {

   667                 $this->semanticalError(

   668                     'Class ' . $class->name . ' has no field or association named ' . $field,

   669                     $deferredItem['token']

   670                 );

   671             }

   672 

   673             if (isset($class->fieldMappings[$field])) {

   674                 $fieldType = AST\PathExpression::TYPE_STATE_FIELD;

   675             } else {

   676                 $assoc = $class->associationMappings[$field];

   677                 $class = $this->_em->getClassMetadata($assoc['targetEntity']);

   678 

   679                 if ($assoc['type'] & ClassMetadata::TO_ONE) {

   680                     $fieldType = AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION;

   681                 } else {

   682                     $fieldType = AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;

   683                 }

   684             }

   685 

   686             // Validate if PathExpression is one of the expected types

   687             $expectedType = $pathExpression->expectedType;

   688 

   689             if ( ! ($expectedType & $fieldType)) {

   690                 // We need to recognize which was expected type(s)

   691                 $expectedStringTypes = array();

   692 

   693                 // Validate state field type

   694                 if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {

   695                     $expectedStringTypes[] = 'StateFieldPathExpression';

   696                 }

   697 

   698                 // Validate single valued association (*-to-one)

   699                 if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {

   700                     $expectedStringTypes[] = 'SingleValuedAssociationField';

   701                 }

   702 

   703                 // Validate single valued association (*-to-many)

   704                 if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {

   705                     $expectedStringTypes[] = 'CollectionValuedAssociationField';

   706                 }

   707 

   708                 // Build the error message

   709                 $semanticalError = 'Invalid PathExpression. ';

   710 

   711                 if (count($expectedStringTypes) == 1) {

   712                     $semanticalError .= 'Must be a ' . $expectedStringTypes[0] . '.';

   713                 } else {

   714                     $semanticalError .= implode(' or ', $expectedStringTypes) . ' expected.';

   715                 }

   716 

   717                 $this->semanticalError($semanticalError, $deferredItem['token']);

   718             }

   719             

   720             // We need to force the type in PathExpression

   721             $pathExpression->type = $fieldType;

   722         }

   723     }

   724 

   725     /**

   726      * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement

   727      *

   728      * @return \Doctrine\ORM\Query\AST\SelectStatement |

   729      *         \Doctrine\ORM\Query\AST\UpdateStatement |

   730      *         \Doctrine\ORM\Query\AST\DeleteStatement

   731      */

   732     public function QueryLanguage()

   733     {

   734         $this->_lexer->moveNext();

   735 

   736         switch ($this->_lexer->lookahead['type']) {

   737             case Lexer::T_SELECT:

   738                 $statement = $this->SelectStatement();

   739                 break;

   740             case Lexer::T_UPDATE:

   741                 $statement = $this->UpdateStatement();

   742                 break;

   743             case Lexer::T_DELETE:

   744                 $statement = $this->DeleteStatement();

   745                 break;

   746             default:

   747                 $this->syntaxError('SELECT, UPDATE or DELETE');

   748                 break;

   749         }

   750 

   751         // Check for end of string

   752         if ($this->_lexer->lookahead !== null) {

   753             $this->syntaxError('end of string');

   754         }

   755 

   756         return $statement;

   757     }

   758 

   759     /**

   760      * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]

   761      *

   762      * @return \Doctrine\ORM\Query\AST\SelectStatement

   763      */

   764     public function SelectStatement()

   765     {

   766         $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());

   767 

   768         $selectStatement->whereClause = $this->_lexer->isNextToken(Lexer::T_WHERE)

   769             ? $this->WhereClause() : null;

   770 

   771         $selectStatement->groupByClause = $this->_lexer->isNextToken(Lexer::T_GROUP)

   772             ? $this->GroupByClause() : null;

   773 

   774         $selectStatement->havingClause = $this->_lexer->isNextToken(Lexer::T_HAVING)

   775             ? $this->HavingClause() : null;

   776 

   777         $selectStatement->orderByClause = $this->_lexer->isNextToken(Lexer::T_ORDER)

   778             ? $this->OrderByClause() : null;

   779 

   780         return $selectStatement;

   781     }

   782 

   783     /**

   784      * UpdateStatement ::= UpdateClause [WhereClause]

   785      *

   786      * @return \Doctrine\ORM\Query\AST\UpdateStatement

   787      */

   788     public function UpdateStatement()

   789     {

   790         $updateStatement = new AST\UpdateStatement($this->UpdateClause());

   791         $updateStatement->whereClause = $this->_lexer->isNextToken(Lexer::T_WHERE)

   792                 ? $this->WhereClause() : null;

   793 

   794         return $updateStatement;

   795     }

   796 

   797     /**

   798      * DeleteStatement ::= DeleteClause [WhereClause]

   799      *

   800      * @return \Doctrine\ORM\Query\AST\DeleteStatement

   801      */

   802     public function DeleteStatement()

   803     {

   804         $deleteStatement = new AST\DeleteStatement($this->DeleteClause());

   805         $deleteStatement->whereClause = $this->_lexer->isNextToken(Lexer::T_WHERE)

   806                 ? $this->WhereClause() : null;

   807 

   808         return $deleteStatement;

   809     }

   810 

   811     /**

   812      * IdentificationVariable ::= identifier

   813      *

   814      * @return string

   815      */

   816     public function IdentificationVariable()

   817     {

   818         $this->match(Lexer::T_IDENTIFIER);

   819 

   820         $identVariable = $this->_lexer->token['value'];

   821 

   822         $this->_deferredIdentificationVariables[] = array(

   823             'expression'   => $identVariable,

   824             'nestingLevel' => $this->_nestingLevel,

   825             'token'        => $this->_lexer->token,

   826         );

   827 

   828         return $identVariable;

   829     }

   830 

   831     /**

   832      * AliasIdentificationVariable = identifier

   833      *

   834      * @return string

   835      */

   836     public function AliasIdentificationVariable()

   837     {

   838         $this->match(Lexer::T_IDENTIFIER);

   839 

   840         $aliasIdentVariable = $this->_lexer->token['value'];

   841         $exists = isset($this->_queryComponents[$aliasIdentVariable]);

   842 

   843         if ($exists) {

   844             $this->semanticalError(

   845                 "'$aliasIdentVariable' is already defined.", $this->_lexer->token

   846             );

   847         }

   848 

   849         return $aliasIdentVariable;

   850     }

   851 

   852     /**

   853      * AbstractSchemaName ::= identifier

   854      *

   855      * @return string

   856      */

   857     public function AbstractSchemaName()

   858     {

   859         $this->match(Lexer::T_IDENTIFIER);

   860 

   861         $schemaName = ltrim($this->_lexer->token['value'], '\\');

   862 

   863         if (strrpos($schemaName, ':') !== false) {

   864             list($namespaceAlias, $simpleClassName) = explode(':', $schemaName);

   865             $schemaName = $this->_em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;

   866         }

   867 

   868         $exists = class_exists($schemaName, true);

   869 

   870         if ( ! $exists) {

   871             $this->semanticalError("Class '$schemaName' is not defined.", $this->_lexer->token);

   872         }

   873 

   874         return $schemaName;

   875     }

   876 

   877     /**

   878      * AliasResultVariable ::= identifier

   879      *

   880      * @return string

   881      */

   882     public function AliasResultVariable()

   883     {

   884         $this->match(Lexer::T_IDENTIFIER);

   885 

   886         $resultVariable = $this->_lexer->token['value'];

   887         $exists = isset($this->_queryComponents[$resultVariable]);

   888 

   889         if ($exists) {

   890             $this->semanticalError(

   891                 "'$resultVariable' is already defined.", $this->_lexer->token

   892             );

   893         }

   894 

   895         return $resultVariable;

   896     }

   897 

   898     /**

   899      * ResultVariable ::= identifier

   900      *

   901      * @return string

   902      */

   903     public function ResultVariable()

   904     {

   905         $this->match(Lexer::T_IDENTIFIER);

   906 

   907         $resultVariable = $this->_lexer->token['value'];

   908 

   909         // Defer ResultVariable validation

   910         $this->_deferredResultVariables[] = array(

   911             'expression'   => $resultVariable,

   912             'nestingLevel' => $this->_nestingLevel,

   913             'token'        => $this->_lexer->token,

   914         );

   915 

   916         return $resultVariable;

   917     }

   918 

   919     /**

   920      * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)

   921      *

   922      * @return \Doctrine\ORM\Query\AST\JoinAssociationPathExpression

   923      */

   924     public function JoinAssociationPathExpression()

   925     {

   926         $token = $this->_lexer->lookahead;

   927         $identVariable = $this->IdentificationVariable();

   928 

   929         if (!isset($this->_queryComponents[$identVariable])) {

   930             $this->semanticalError('Identification Variable ' . $identVariable .' used in join path expression but was not defined before.');

   931         }

   932 

   933         $this->match(Lexer::T_DOT);

   934         $this->match(Lexer::T_IDENTIFIER);

   935 

   936         $field = $this->_lexer->token['value'];

   937 

   938         // Validate association field

   939         $qComp = $this->_queryComponents[$identVariable];

   940         $class = $qComp['metadata'];

   941 

   942         if ( ! isset($class->associationMappings[$field])) {

   943             $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);

   944         }

   945 

   946         return new AST\JoinAssociationPathExpression($identVariable, $field);

   947     }

   948 

   949     /**

   950      * Parses an arbitrary path expression and defers semantical validation

   951      * based on expected types.

   952      *

   953      * PathExpression ::= IdentificationVariable "." identifier

   954      *

   955      * @param integer $expectedTypes

   956      * @return \Doctrine\ORM\Query\AST\PathExpression

   957      */

   958     public function PathExpression($expectedTypes)

   959     {

   960         $token = $this->_lexer->lookahead;

   961         $identVariable = $this->IdentificationVariable();

   962         $field = null;

   963 

   964         if ($this->_lexer->isNextToken(Lexer::T_DOT)) {

   965             $this->match(Lexer::T_DOT);

   966             $this->match(Lexer::T_IDENTIFIER);

   967 

   968             $field = $this->_lexer->token['value'];

   969         }

   970         

   971         // Creating AST node

   972         $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);

   973 

   974         // Defer PathExpression validation if requested to be defered

   975         $this->_deferredPathExpressions[] = array(

   976             'expression'   => $pathExpr,

   977             'nestingLevel' => $this->_nestingLevel,

   978             'token'        => $this->_lexer->token,

   979         );

   980 

   981         return $pathExpr;

   982     }

   983 

   984     /**

   985      * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression

   986      *

   987      * @return \Doctrine\ORM\Query\AST\PathExpression

   988      */

   989     public function AssociationPathExpression()

   990     {

   991         return $this->PathExpression(

   992             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |

   993             AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION

   994         );

   995     }

   996 

   997     /**

   998      * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression

   999      *

  1000      * @return \Doctrine\ORM\Query\AST\PathExpression

  1001      */

  1002     public function SingleValuedPathExpression()

  1003     {

  1004         return $this->PathExpression(

  1005             AST\PathExpression::TYPE_STATE_FIELD |

  1006             AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION

  1007         );

  1008     }

  1009 

  1010     /**

  1011      * StateFieldPathExpression ::= IdentificationVariable "." StateField

  1012      *

  1013      * @return \Doctrine\ORM\Query\AST\PathExpression

  1014      */

  1015     public function StateFieldPathExpression()

  1016     {

  1017         return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);

  1018     }

  1019 

  1020     /**

  1021      * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField

  1022      *

  1023      * @return \Doctrine\ORM\Query\AST\PathExpression

  1024      */

  1025     public function SingleValuedAssociationPathExpression()

  1026     {

  1027         return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);

  1028     }

  1029 

  1030     /**

  1031      * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField

  1032      *

  1033      * @return \Doctrine\ORM\Query\AST\PathExpression

  1034      */

  1035     public function CollectionValuedPathExpression()

  1036     {

  1037         return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);

  1038     }

  1039 

  1040     /**

  1041      * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}

  1042      *

  1043      * @return \Doctrine\ORM\Query\AST\SelectClause

  1044      */

  1045     public function SelectClause()

  1046     {

  1047         $isDistinct = false;

  1048         $this->match(Lexer::T_SELECT);

  1049 

  1050         // Check for DISTINCT

  1051         if ($this->_lexer->isNextToken(Lexer::T_DISTINCT)) {

  1052             $this->match(Lexer::T_DISTINCT);

  1053             $isDistinct = true;

  1054         }

  1055 

  1056         // Process SelectExpressions (1..N)

  1057         $selectExpressions = array();

  1058         $selectExpressions[] = $this->SelectExpression();

  1059 

  1060         while ($this->_lexer->isNextToken(Lexer::T_COMMA)) {

  1061             $this->match(Lexer::T_COMMA);

  1062             $selectExpressions[] = $this->SelectExpression();

  1063         }

  1064 

  1065         return new AST\SelectClause($selectExpressions, $isDistinct);

  1066     }

  1067 

  1068     /**

  1069      * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression

  1070      *

  1071      * @return \Doctrine\ORM\Query\AST\SimpleSelectClause

  1072      */

  1073     public function SimpleSelectClause()

  1074     {

  1075         $isDistinct = false;

  1076         $this->match(Lexer::T_SELECT);

  1077 

  1078         if ($this->_lexer->isNextToken(Lexer::T_DISTINCT)) {

  1079             $this->match(Lexer::T_DISTINCT);

  1080             $isDistinct = true;

  1081         }

  1082 

  1083         return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);

  1084     }

  1085 

  1086     /**

  1087      * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*

  1088      *

  1089      * @return \Doctrine\ORM\Query\AST\UpdateClause

  1090      */

  1091     public function UpdateClause()

  1092     {

  1093         $this->match(Lexer::T_UPDATE);

  1094         $token = $this->_lexer->lookahead;

  1095         $abstractSchemaName = $this->AbstractSchemaName();

  1096 

  1097         if ($this->_lexer->isNextToken(Lexer::T_AS)) {

  1098             $this->match(Lexer::T_AS);

  1099         }

  1100 

  1101         $aliasIdentificationVariable = $this->AliasIdentificationVariable();

  1102 

  1103         $class = $this->_em->getClassMetadata($abstractSchemaName);

  1104 

  1105         // Building queryComponent

  1106         $queryComponent = array(

  1107             'metadata'     => $class,

  1108             'parent'       => null,

  1109             'relation'     => null,

  1110             'map'          => null,

  1111             'nestingLevel' => $this->_nestingLevel,

  1112             'token'        => $token,

  1113         );

  1114         $this->_queryComponents[$aliasIdentificationVariable] = $queryComponent;

  1115 

  1116         $this->match(Lexer::T_SET);

  1117 

  1118         $updateItems = array();

  1119         $updateItems[] = $this->UpdateItem();

  1120 

  1121         while ($this->_lexer->isNextToken(Lexer::T_COMMA)) {

  1122             $this->match(Lexer::T_COMMA);

  1123             $updateItems[] = $this->UpdateItem();

  1124         }

  1125 

  1126         $updateClause = new AST\UpdateClause($abstractSchemaName, $updateItems);

  1127         $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;

  1128 

  1129         return $updateClause;

  1130     }

  1131 

  1132     /**

  1133      * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable

  1134      *

  1135      * @return \Doctrine\ORM\Query\AST\DeleteClause

  1136      */