vendor/doctrine/orm/src/Query/Parser.php line 263

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Query;
  7. use Doctrine\Common\Lexer\Token;
  8. use Doctrine\Deprecations\Deprecation;
  9. use Doctrine\ORM\EntityManagerInterface;
  10. use Doctrine\ORM\Mapping\ClassMetadata;
  11. use Doctrine\ORM\Query;
  12. use Doctrine\ORM\Query\AST\Functions;
  13. use Doctrine\ORM\Query\Exec\SqlFinalizer;
  14. use LogicException;
  15. use ReflectionClass;
  17. use function array_intersect;
  18. use function array_search;
  19. use function assert;
  20. use function class_exists;
  21. use function count;
  22. use function explode;
  23. use function implode;
  24. use function in_array;
  25. use function interface_exists;
  26. use function is_string;
  27. use function sprintf;
  28. use function str_contains;
  29. use function strlen;
  30. use function strpos;
  31. use function strrpos;
  32. use function strtolower;
  33. use function substr;
  35. /**
  36. * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  37. * Parses a DQL query, reports any errors in it, and generates an AST.
  38. *
  39. * @phpstan-import-type AssociationMapping from ClassMetadata
  40. * @phpstan-type DqlToken = Token<TokenType::T_*, string>
  41. * @phpstan-type QueryComponent = array{
  42. * metadata?: ClassMetadata<object>,
  43. * parent?: string|null,
  44. * relation?: AssociationMapping|null,
  45. * map?: string|null,
  46. * resultVariable?: AST\Node|string,
  47. * nestingLevel: int,
  48. * token: DqlToken,
  49. * }
  50. */
  51. class Parser
  52. {
  53. /**
  54. * @readonly Maps BUILT-IN string function names to AST class names.
  55. * @var array<string, class-string<Functions\FunctionNode>>
  56. */
  57. private static $stringFunctions = [
  58. 'concat' => Functions\ConcatFunction::class,
  59. 'substring' => Functions\SubstringFunction::class,
  60. 'trim' => Functions\TrimFunction::class,
  61. 'lower' => Functions\LowerFunction::class,
  62. 'upper' => Functions\UpperFunction::class,
  63. 'identity' => Functions\IdentityFunction::class,
  64. ];
  66. /**
  67. * @readonly Maps BUILT-IN numeric function names to AST class names.
  68. * @var array<string, class-string<Functions\FunctionNode>>
  69. */
  70. private static $numericFunctions = [
  71. 'length' => Functions\LengthFunction::class,
  72. 'locate' => Functions\LocateFunction::class,
  73. 'abs' => Functions\AbsFunction::class,
  74. 'sqrt' => Functions\SqrtFunction::class,
  75. 'mod' => Functions\ModFunction::class,
  76. 'size' => Functions\SizeFunction::class,
  77. 'date_diff' => Functions\DateDiffFunction::class,
  78. 'bit_and' => Functions\BitAndFunction::class,
  79. 'bit_or' => Functions\BitOrFunction::class,
  81. // Aggregate functions
  82. 'min' => Functions\MinFunction::class,
  83. 'max' => Functions\MaxFunction::class,
  84. 'avg' => Functions\AvgFunction::class,
  85. 'sum' => Functions\SumFunction::class,
  86. 'count' => Functions\CountFunction::class,
  87. ];
  89. /**
  90. * @readonly Maps BUILT-IN datetime function names to AST class names.
  91. * @var array<string, class-string<Functions\FunctionNode>>
  92. */
  93. private static $datetimeFunctions = [
  94. 'current_date' => Functions\CurrentDateFunction::class,
  95. 'current_time' => Functions\CurrentTimeFunction::class,
  96. 'current_timestamp' => Functions\CurrentTimestampFunction::class,
  97. 'date_add' => Functions\DateAddFunction::class,
  98. 'date_sub' => Functions\DateSubFunction::class,
  99. ];
  101. /*
  102. * Expressions that were encountered during parsing of identifiers and expressions
  103. * and still need to be validated.
  104. */
  106. /** @phpstan-var list<array{token: DqlToken|null, expression: mixed, nestingLevel: int}> */
  107. private $deferredIdentificationVariables = [];
  109. /** @phpstan-var list<array{token: DqlToken|null, expression: AST\PartialObjectExpression, nestingLevel: int}> */
  110. private $deferredPartialObjectExpressions = [];
  112. /** @phpstan-var list<array{token: DqlToken|null, expression: AST\PathExpression, nestingLevel: int}> */
  113. private $deferredPathExpressions = [];
  115. /** @phpstan-var list<array{token: DqlToken|null, expression: mixed, nestingLevel: int}> */
  116. private $deferredResultVariables = [];
  118. /** @phpstan-var list<array{token: DqlToken|null, expression: AST\NewObjectExpression, nestingLevel: int}> */
  119. private $deferredNewObjectExpressions = [];
  121. /**
  122. * The lexer.
  123. *
  124. * @var Lexer
  125. */
  126. private $lexer;
  128. /**
  129. * The parser result.
  130. *
  131. * @var ParserResult
  132. */
  133. private $parserResult;
  135. /**
  136. * The EntityManager.
  137. *
  138. * @var EntityManagerInterface
  139. */
  140. private $em;
  142. /**
  143. * The Query to parse.
  144. *
  145. * @var Query
  146. */
  147. private $query;
  149. /**
  150. * Map of declared query components in the parsed query.
  151. *
  152. * @phpstan-var array<string, QueryComponent>
  153. */
  154. private $queryComponents = [];
  156. /**
  157. * Keeps the nesting level of defined ResultVariables.
  158. *
  159. * @var int
  160. */
  161. private $nestingLevel = 0;
  163. /** @var int */
  164. private $withJoinConditionNestingLevel = 0;
  166. /**
  167. * Any additional custom tree walkers that modify the AST.
  168. *
  169. * @var list<class-string<TreeWalker>>
  170. */
  171. private $customTreeWalkers = [];
  173. /**
  174. * The custom last tree walker, if any, that is responsible for producing the output.
  175. *
  176. * @var class-string<SqlWalker>|null
  177. */
  178. private $customOutputWalker;
  180. /** @phpstan-var array<string, AST\SelectExpression> */
  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 class-string<SqlWalker> $className
  201. *
  202. * @return void
  203. */
  204. public function setCustomOutputTreeWalker($className)
  205. {
  206. Deprecation::trigger(
  207. 'doctrine/orm',
  208. 'https://github.com/doctrine/orm/pull/11641',
  209. '%s is deprecated, set the output walker class with the \Doctrine\ORM\Query::HINT_CUSTOM_OUTPUT_WALKER query hint instead',
  210. __METHOD__
  211. );
  213. $this->customOutputWalker = $className;
  214. }
  216. /**
  217. * Adds a custom tree walker for modifying the AST.
  218. *
  219. * @param class-string<TreeWalker> $className
  220. *
  221. * @return void
  222. */
  223. public function addCustomTreeWalker($className)
  224. {
  225. $this->customTreeWalkers[] = $className;
  226. }
  228. /**
  229. * Gets the lexer used by the parser.
  230. *
  231. * @return Lexer
  232. */
  233. public function getLexer()
  234. {
  235. return $this->lexer;
  236. }
  238. /**
  239. * Gets the ParserResult that is being filled with information during parsing.
  240. *
  241. * @return ParserResult
  242. */
  243. public function getParserResult()
  244. {
  245. return $this->parserResult;
  246. }
  248. /**
  249. * Gets the EntityManager used by the parser.
  250. *
  251. * @return EntityManagerInterface
  252. */
  253. public function getEntityManager()
  254. {
  255. return $this->em;
  256. }
  258. /**
  259. * Parses and builds AST for the given Query.
  260. *
  261. * @return AST\SelectStatement|AST\UpdateStatement|AST\DeleteStatement
  262. */
  263. public function getAST()
  264. {
  265. // Parse & build AST
  266. $AST = $this->QueryLanguage();
  268. // Process any deferred validations of some nodes in the AST.
  269. // This also allows post-processing of the AST for modification purposes.
  270. $this->processDeferredIdentificationVariables();
  272. if ($this->deferredPartialObjectExpressions) {
  273. $this->processDeferredPartialObjectExpressions();
  274. }
  276. if ($this->deferredPathExpressions) {
  277. $this->processDeferredPathExpressions();
  278. }
  280. if ($this->deferredResultVariables) {
  281. $this->processDeferredResultVariables();
  282. }
  284. if ($this->deferredNewObjectExpressions) {
  285. $this->processDeferredNewObjectExpressions($AST);
  286. }
  288. $this->processRootEntityAliasSelected();
  290. // TODO: Is there a way to remove this? It may impact the mixed hydration resultset a lot!
  291. $this->fixIdentificationVariableOrder($AST);
  293. return $AST;
  294. }
  296. /**
  297. * Attempts to match the given token with the current lookahead token.
  298. *
  299. * If they match, updates the lookahead token; otherwise raises a syntax
  300. * error.
  301. *
  302. * @param TokenType::T_* $token The token type.
  303. *
  304. * @return void
  305. *
  306. * @throws QueryException If the tokens don't match.
  307. */
  308. public function match($token)
  309. {
  310. $lookaheadType = $this->lexer->lookahead->type ?? null;
  312. // Short-circuit on first condition, usually types match
  313. if ($lookaheadType === $token) {
  314. $this->lexer->moveNext();
  316. return;
  317. }
  319. // If parameter is not identifier (1-99) must be exact match
  320. if ($token < TokenType::T_IDENTIFIER) {
  321. $this->syntaxError($this->lexer->getLiteral($token));
  322. }
  324. // If parameter is keyword (200+) must be exact match
  325. if ($token > TokenType::T_IDENTIFIER) {
  326. $this->syntaxError($this->lexer->getLiteral($token));
  327. }
  329. // If parameter is T_IDENTIFIER, then matches T_IDENTIFIER (100) and keywords (200+)
  330. if ($token === TokenType::T_IDENTIFIER && $lookaheadType < TokenType::T_IDENTIFIER) {
  331. $this->syntaxError($this->lexer->getLiteral($token));
  332. }
  334. $this->lexer->moveNext();
  335. }
  337. /**
  338. * Frees this parser, enabling it to be reused.
  339. *
  340. * @param bool $deep Whether to clean peek and reset errors.
  341. * @param int $position Position to reset.
  342. *
  343. * @return void
  344. */
  345. public function free($deep = false, $position = 0)
  346. {
  347. // WARNING! Use this method with care. It resets the scanner!
  348. $this->lexer->resetPosition($position);
  350. // Deep = true cleans peek and also any previously defined errors
  351. if ($deep) {
  352. $this->lexer->resetPeek();
  353. }
  355. $this->lexer->token = null;
  356. $this->lexer->lookahead = null;
  357. }
  359. /**
  360. * Parses a query string.
  361. *
  362. * @return ParserResult
  363. */
  364. public function parse()
  365. {
  366. $AST = $this->getAST();
  368. $customWalkers = $this->query->getHint(Query::HINT_CUSTOM_TREE_WALKERS);
  369. if ($customWalkers !== false) {
  370. $this->customTreeWalkers = $customWalkers;
  371. }
  373. $customOutputWalker = $this->query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER);
  374. if ($customOutputWalker !== false) {
  375. $this->customOutputWalker = $customOutputWalker;
  376. }
  378. // Run any custom tree walkers over the AST
  379. if ($this->customTreeWalkers) {
  380. $treeWalkerChain = new TreeWalkerChain($this->query, $this->parserResult, $this->queryComponents);
  382. foreach ($this->customTreeWalkers as $walker) {
  383. $treeWalkerChain->addTreeWalker($walker);
  384. }
  386. switch (true) {
  387. case $AST instanceof AST\UpdateStatement:
  388. $treeWalkerChain->walkUpdateStatement($AST);
  389. break;
  391. case $AST instanceof AST\DeleteStatement:
  392. $treeWalkerChain->walkDeleteStatement($AST);
  393. break;
  395. case $AST instanceof AST\SelectStatement:
  396. default:
  397. $treeWalkerChain->walkSelectStatement($AST);
  398. }
  400. $this->queryComponents = $treeWalkerChain->getQueryComponents();
  401. }
  403. $outputWalkerClass = $this->customOutputWalker ?: SqlOutputWalker::class;
  404. $outputWalker = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
  406. if ($outputWalker instanceof OutputWalker) {
  407. $finalizer = $outputWalker->getFinalizer($AST);
  408. $this->parserResult->setSqlFinalizer($finalizer);
  409. } else {
  410. Deprecation::trigger(
  411. 'doctrine/orm',
  412. 'https://github.com/doctrine/orm/pull/11188/',
  413. 'Your output walker class %s should implement %s in order to provide a %s. This also means the output walker should not use the query firstResult/maxResult values, which should be read from the query by the SqlFinalizer only.',
  414. $outputWalkerClass,
  415. OutputWalker::class,
  416. SqlFinalizer::class
  417. );
  418. // @phpstan-ignore method.deprecated
  419. $executor = $outputWalker->getExecutor($AST);
  420. // @phpstan-ignore method.deprecated
  421. $this->parserResult->setSqlExecutor($executor);
  422. }
  424. return $this->parserResult;
  425. }
  427. /**
  428. * Fixes order of identification variables.
  429. *
  430. * They have to appear in the select clause in the same order as the
  431. * declarations (from ... x join ... y join ... z ...) appear in the query
  432. * as the hydration process relies on that order for proper operation.
  433. *
  434. * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST
  435. */
  436. private function fixIdentificationVariableOrder(AST\Node $AST): void
  437. {
  438. if (count($this->identVariableExpressions) <= 1) {
  439. return;
  440. }
  442. assert($AST instanceof AST\SelectStatement);
  444. foreach ($this->queryComponents as $dqlAlias => $qComp) {
  445. if (! isset($this->identVariableExpressions[$dqlAlias])) {
  446. continue;
  447. }
  449. $expr = $this->identVariableExpressions[$dqlAlias];
  450. $key = array_search($expr, $AST->selectClause->selectExpressions, true);
  452. unset($AST->selectClause->selectExpressions[$key]);
  454. $AST->selectClause->selectExpressions[] = $expr;
  455. }
  456. }
  458. /**
  459. * Generates a new syntax error.
  460. *
  461. * @param string $expected Expected string.
  462. * @param mixed[]|null $token Got token.
  463. * @phpstan-param DqlToken|null $token
  464. *
  465. * @return void
  466. * @phpstan-return no-return
  467. *
  468. * @throws QueryException
  469. */
  470. public function syntaxError($expected = '', $token = null)
  471. {
  472. if ($token === null) {
  473. $token = $this->lexer->lookahead;
  474. }
  476. $tokenPos = $token->position ?? '-1';
  478. $message = sprintf('line 0, col %d: Error: ', $tokenPos);
  479. $message .= $expected !== '' ? sprintf('Expected %s, got ', $expected) : 'Unexpected ';
  480. $message .= $this->lexer->lookahead === null ? 'end of string.' : sprintf("'%s'", $token->value);
  482. throw QueryException::syntaxError($message, QueryException::dqlError($this->query->getDQL() ?? ''));
  483. }
  485. /**
  486. * Generates a new semantical error.
  487. *
  488. * @param string $message Optional message.
  489. * @param mixed[]|null $token Optional token.
  490. * @phpstan-param DqlToken|null $token
  491. *
  492. * @return void
  493. * @phpstan-return no-return
  494. *
  495. * @throws QueryException
  496. */
  497. public function semanticalError($message = '', $token = null)
  498. {
  499. if ($token === null) {
  500. $token = $this->lexer->lookahead ?? new Token('fake token', 42, 0);
  501. }
  503. // Minimum exposed chars ahead of token
  504. $distance = 12;
  506. // Find a position of a final word to display in error string
  507. $dql = $this->query->getDQL();
  508. $length = strlen($dql);
  509. $pos = $token->position + $distance;
  510. $pos = strpos($dql, ' ', $length > $pos ? $pos : $length);
  511. $length = $pos !== false ? $pos - $token->position : $distance;
  513. $tokenPos = $token->position > 0 ? $token->position : '-1';
  514. $tokenStr = substr($dql, $token->position, $length);
  516. // Building informative message
  517. $message = 'line 0, col ' . $tokenPos . " near '" . $tokenStr . "': Error: " . $message;
  519. throw QueryException::semanticalError($message, QueryException::dqlError($this->query->getDQL()));
  520. }
  522. /**
  523. * Peeks beyond the matched closing parenthesis and returns the first token after that one.
  524. *
  525. * @param bool $resetPeek Reset peek after finding the closing parenthesis.
  526. *
  527. * @return mixed[]
  528. * @phpstan-return DqlToken|null
  529. */
  530. private function peekBeyondClosingParenthesis(bool $resetPeek = true)
  531. {
  532. $token = $this->lexer->peek();
  533. $numUnmatched = 1;
  535. while ($numUnmatched > 0 && $token !== null) {
  536. switch ($token->type) {
  537. case TokenType::T_OPEN_PARENTHESIS:
  538. ++$numUnmatched;
  539. break;
  541. case TokenType::T_CLOSE_PARENTHESIS:
  542. --$numUnmatched;
  543. break;
  545. default:
  546. // Do nothing
  547. }
  549. $token = $this->lexer->peek();
  550. }
  552. if ($resetPeek) {
  553. $this->lexer->resetPeek();
  554. }
  556. return $token;
  557. }
  559. /**
  560. * Checks if the given token indicates a mathematical operator.
  561. *
  562. * @phpstan-param DqlToken|null $token
  563. */
  564. private function isMathOperator($token): bool
  565. {
  566. return $token !== null && in_array($token->type, [TokenType::T_PLUS, TokenType::T_MINUS, TokenType::T_DIVIDE, TokenType::T_MULTIPLY], true);
  567. }
  569. /**
  570. * Checks if the next-next (after lookahead) token starts a function.
  571. *
  572. * @return bool TRUE if the next-next tokens start a function, FALSE otherwise.
  573. */
  574. private function isFunction(): bool
  575. {
  576. assert($this->lexer->lookahead !== null);
  577. $lookaheadType = $this->lexer->lookahead->type;
  578. $peek = $this->lexer->peek();
  580. $this->lexer->resetPeek();
  582. return $lookaheadType >= TokenType::T_IDENTIFIER && $peek !== null && $peek->type === TokenType::T_OPEN_PARENTHESIS;
  583. }
  585. /**
  586. * Checks whether the given token type indicates an aggregate function.
  587. *
  588. * @phpstan-param TokenType::T_* $tokenType
  589. *
  590. * @return bool TRUE if the token type is an aggregate function, FALSE otherwise.
  591. */
  592. private function isAggregateFunction(int $tokenType): bool
  593. {
  594. return in_array(
  595. $tokenType,
  596. [TokenType::T_AVG, TokenType::T_MIN, TokenType::T_MAX, TokenType::T_SUM, TokenType::T_COUNT],
  597. true
  598. );
  599. }
  601. /**
  602. * Checks whether the current lookahead token of the lexer has the type T_ALL, T_ANY or T_SOME.
  603. */
  604. private function isNextAllAnySome(): bool
  605. {
  606. assert($this->lexer->lookahead !== null);
  608. return in_array(
  609. $this->lexer->lookahead->type,
  610. [TokenType::T_ALL, TokenType::T_ANY, TokenType::T_SOME],
  611. true
  612. );
  613. }
  615. /**
  616. * Validates that the given <tt>IdentificationVariable</tt> is semantically correct.
  617. * It must exist in query components list.
  618. */
  619. private function processDeferredIdentificationVariables(): void
  620. {
  621. foreach ($this->deferredIdentificationVariables as $deferredItem) {
  622. $identVariable = $deferredItem['expression'];
  624. // Check if IdentificationVariable exists in queryComponents
  625. if (! isset($this->queryComponents[$identVariable])) {
  626. $this->semanticalError(
  627. sprintf("'%s' is not defined.", $identVariable),
  628. $deferredItem['token']
  629. );
  630. }
  632. $qComp = $this->queryComponents[$identVariable];
  634. // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  635. if (! isset($qComp['metadata'])) {
  636. $this->semanticalError(
  637. sprintf("'%s' does not point to a Class.", $identVariable),
  638. $deferredItem['token']
  639. );
  640. }
  642. // Validate if identification variable nesting level is lower or equal than the current one
  643. if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  644. $this->semanticalError(
  645. sprintf("'%s' is used outside the scope of its declaration.", $identVariable),
  646. $deferredItem['token']
  647. );
  648. }
  649. }
  650. }
  652. /**
  653. * Validates that the given <tt>NewObjectExpression</tt>.
  654. */
  655. private function processDeferredNewObjectExpressions(AST\SelectStatement $AST): void
  656. {
  657. foreach ($this->deferredNewObjectExpressions as $deferredItem) {
  658. $expression = $deferredItem['expression'];
  659. $token = $deferredItem['token'];
  660. $className = $expression->className;
  661. $args = $expression->args;
  662. $fromClassName = $AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName ?? null;
  664. // If the namespace is not given then assumes the first FROM entity namespace
  665. if (! str_contains($className, '\\') && ! class_exists($className) && is_string($fromClassName) && str_contains($fromClassName, '\\')) {
  666. $namespace = substr($fromClassName, 0, strrpos($fromClassName, '\\'));
  667. $fqcn = $namespace . '\\' . $className;
  669. if (class_exists($fqcn)) {
  670. $expression->className = $fqcn;
  671. $className = $fqcn;
  672. }
  673. }
  675. if (! class_exists($className)) {
  676. $this->semanticalError(sprintf('Class "%s" is not defined.', $className), $token);
  677. }
  679. $class = new ReflectionClass($className);
  681. if (! $class->isInstantiable()) {
  682. $this->semanticalError(sprintf('Class "%s" can not be instantiated.', $className), $token);
  683. }
  685. if ($class->getConstructor() === null) {
  686. $this->semanticalError(sprintf('Class "%s" has not a valid constructor.', $className), $token);
  687. }
  689. if ($class->getConstructor()->getNumberOfRequiredParameters() > count($args)) {
  690. $this->semanticalError(sprintf('Number of arguments does not match with "%s" constructor declaration.', $className), $token);
  691. }
  692. }
  693. }
  695. /**
  696. * Validates that the given <tt>PartialObjectExpression</tt> is semantically correct.
  697. * It must exist in query components list.
  698. */
  699. private function processDeferredPartialObjectExpressions(): void
  700. {
  701. foreach ($this->deferredPartialObjectExpressions as $deferredItem) {
  702. $expr = $deferredItem['expression'];
  703. $class = $this->getMetadataForDqlAlias($expr->identificationVariable);
  705. foreach ($expr->partialFieldSet as $field) {
  706. if (isset($class->fieldMappings[$field])) {
  707. continue;
  708. }
  710. if (
  711. isset($class->associationMappings[$field]) &&
  712. $class->associationMappings[$field]['isOwningSide'] &&
  713. $class->associationMappings[$field]['type'] & ClassMetadata::TO_ONE
  714. ) {
  715. continue;
  716. }
  718. $this->semanticalError(sprintf(
  719. "There is no mapped field named '%s' on class %s.",
  720. $field,
  721. $class->name
  722. ), $deferredItem['token']);
  723. }
  725. if (array_intersect($class->identifier, $expr->partialFieldSet) !== $class->identifier) {
  726. $this->semanticalError(
  727. 'The partial field selection of class ' . $class->name . ' must contain the identifier.',
  728. $deferredItem['token']
  729. );
  730. }
  731. }
  732. }
  734. /**
  735. * Validates that the given <tt>ResultVariable</tt> is semantically correct.
  736. * It must exist in query components list.
  737. */
  738. private function processDeferredResultVariables(): void
  739. {
  740. foreach ($this->deferredResultVariables as $deferredItem) {
  741. $resultVariable = $deferredItem['expression'];
  743. // Check if ResultVariable exists in queryComponents
  744. if (! isset($this->queryComponents[$resultVariable])) {
  745. $this->semanticalError(
  746. sprintf("'%s' is not defined.", $resultVariable),
  747. $deferredItem['token']
  748. );
  749. }
  751. $qComp = $this->queryComponents[$resultVariable];
  753. // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  754. if (! isset($qComp['resultVariable'])) {
  755. $this->semanticalError(
  756. sprintf("'%s' does not point to a ResultVariable.", $resultVariable),
  757. $deferredItem['token']
  758. );
  759. }
  761. // Validate if identification variable nesting level is lower or equal than the current one
  762. if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  763. $this->semanticalError(
  764. sprintf("'%s' is used outside the scope of its declaration.", $resultVariable),
  765. $deferredItem['token']
  766. );
  767. }
  768. }
  769. }
  771. /**
  772. * Validates that the given <tt>PathExpression</tt> is semantically correct for grammar rules:
  773. *
  774. * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  775. * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  776. * StateFieldPathExpression ::= IdentificationVariable "." StateField
  777. * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  778. * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  779. */
  780. private function processDeferredPathExpressions(): void
  781. {
  782. foreach ($this->deferredPathExpressions as $deferredItem) {
  783. $pathExpression = $deferredItem['expression'];
  785. $class = $this->getMetadataForDqlAlias($pathExpression->identificationVariable);
  787. $field = $pathExpression->field;
  788. if ($field === null) {
  789. $field = $pathExpression->field = $class->identifier[0];
  790. }
  792. // Check if field or association exists
  793. if (! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
  794. $this->semanticalError(
  795. 'Class ' . $class->name . ' has no field or association named ' . $field,
  796. $deferredItem['token']
  797. );
  798. }
  800. $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
  802. if (isset($class->associationMappings[$field])) {
  803. $assoc = $class->associationMappings[$field];
  805. $fieldType = $assoc['type'] & ClassMetadata::TO_ONE
  806. ? AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  807. : AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
  808. }
  810. // Validate if PathExpression is one of the expected types
  811. $expectedType = $pathExpression->expectedType;
  813. if (! ($expectedType & $fieldType)) {
  814. // We need to recognize which was expected type(s)
  815. $expectedStringTypes = [];
  817. // Validate state field type
  818. if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
  819. $expectedStringTypes[] = 'StateFieldPathExpression';
  820. }
  822. // Validate single valued association (*-to-one)
  823. if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
  824. $expectedStringTypes[] = 'SingleValuedAssociationField';
  825. }
  827. // Validate single valued association (*-to-many)
  828. if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
  829. $expectedStringTypes[] = 'CollectionValuedAssociationField';
  830. }
  832. // Build the error message
  833. $semanticalError = 'Invalid PathExpression. ';
  834. $semanticalError .= count($expectedStringTypes) === 1
  835. ? 'Must be a ' . $expectedStringTypes[0] . '.'
  836. : implode(' or ', $expectedStringTypes) . ' expected.';
  838. $this->semanticalError($semanticalError, $deferredItem['token']);
  839. }
  841. // We need to force the type in PathExpression
  842. $pathExpression->type = $fieldType;
  843. }
  844. }
  846. private function processRootEntityAliasSelected(): void
  847. {
  848. if (! count($this->identVariableExpressions)) {
  849. return;
  850. }
  852. foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
  853. if (isset($this->queryComponents[$dqlAlias]) && ! isset($this->queryComponents[$dqlAlias]['parent'])) {
  854. return;
  855. }
  856. }
  858. $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');
  859. }
  861. /**
  862. * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
  863. *
  864. * @return AST\SelectStatement|AST\UpdateStatement|AST\DeleteStatement
  865. */
  866. public function QueryLanguage()
  867. {
  868. $statement = null;
  870. $this->lexer->moveNext();
  872. switch ($this->lexer->lookahead->type ?? null) {
  873. case TokenType::T_SELECT:
  874. $statement = $this->SelectStatement();
  875. break;
  877. case TokenType::T_UPDATE:
  878. $statement = $this->UpdateStatement();
  879. break;
  881. case TokenType::T_DELETE:
  882. $statement = $this->DeleteStatement();
  883. break;
  885. default:
  886. $this->syntaxError('SELECT, UPDATE or DELETE');
  887. break;
  888. }
  890. // Check for end of string
  891. if ($this->lexer->lookahead !== null) {
  892. $this->syntaxError('end of string');
  893. }
  895. return $statement;
  896. }
  898. /**
  899. * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  900. *
  901. * @return AST\SelectStatement
  902. */
  903. public function SelectStatement()
  904. {
  905. $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());
  907. $selectStatement->whereClause = $this->lexer->isNextToken(TokenType::T_WHERE) ? $this->WhereClause() : null;
  908. $selectStatement->groupByClause = $this->lexer->isNextToken(TokenType::T_GROUP) ? $this->GroupByClause() : null;
  909. $selectStatement->havingClause = $this->lexer->isNextToken(TokenType::T_HAVING) ? $this->HavingClause() : null;
  910. $selectStatement->orderByClause = $this->lexer->isNextToken(TokenType::T_ORDER) ? $this->OrderByClause() : null;
  912. return $selectStatement;
  913. }
  915. /**
  916. * UpdateStatement ::= UpdateClause [WhereClause]
  917. *
  918. * @return AST\UpdateStatement
  919. */
  920. public function UpdateStatement()
  921. {
  922. $updateStatement = new AST\UpdateStatement($this->UpdateClause());
  924. $updateStatement->whereClause = $this->lexer->isNextToken(TokenType::T_WHERE) ? $this->WhereClause() : null;
  926. return $updateStatement;
  927. }
  929. /**
  930. * DeleteStatement ::= DeleteClause [WhereClause]
  931. *
  932. * @return AST\DeleteStatement
  933. */
  934. public function DeleteStatement()
  935. {
  936. $deleteStatement = new AST\DeleteStatement($this->DeleteClause());
  938. $deleteStatement->whereClause = $this->lexer->isNextToken(TokenType::T_WHERE) ? $this->WhereClause() : null;
  940. return $deleteStatement;
  941. }
  943. /**
  944. * IdentificationVariable ::= identifier
  945. *
  946. * @return string
  947. */
  948. public function IdentificationVariable()
  949. {
  950. $this->match(TokenType::T_IDENTIFIER);
  952. assert($this->lexer->token !== null);
  953. $identVariable = $this->lexer->token->value;
  955. $this->deferredIdentificationVariables[] = [
  956. 'expression' => $identVariable,
  957. 'nestingLevel' => $this->nestingLevel,
  958. 'token' => $this->lexer->token,
  959. ];
  961. return $identVariable;
  962. }
  964. /**
  965. * AliasIdentificationVariable = identifier
  966. *
  967. * @return string
  968. */
  969. public function AliasIdentificationVariable()
  970. {
  971. $this->match(TokenType::T_IDENTIFIER);
  973. assert($this->lexer->token !== null);
  974. $aliasIdentVariable = $this->lexer->token->value;
  975. $exists = isset($this->queryComponents[$aliasIdentVariable]);
  977. if ($exists) {
  978. $this->semanticalError(
  979. sprintf("'%s' is already defined.", $aliasIdentVariable),
  980. $this->lexer->token
  981. );
  982. }
  984. return $aliasIdentVariable;
  985. }
  987. /**
  988. * AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
  989. *
  990. * @return string
  991. */
  992. public function AbstractSchemaName()
  993. {
  994. if ($this->lexer->isNextToken(TokenType::T_FULLY_QUALIFIED_NAME)) {
  995. $this->match(TokenType::T_FULLY_QUALIFIED_NAME);
  996. assert($this->lexer->token !== null);
  998. return $this->lexer->token->value;
  999. }
  1001. if ($this->lexer->isNextToken(TokenType::T_IDENTIFIER)) {
  1002. $this->match(TokenType::T_IDENTIFIER);
  1003. assert($this->lexer->token !== null);
  1005. return $this->lexer->token->value;
  1006. }
  1008. // @phpstan-ignore classConstant.deprecated
  1009. $this->match(TokenType::T_ALIASED_NAME);
  1011. assert($this->lexer->token !== null);
  1013. Deprecation::trigger(
  1014. 'doctrine/orm',
  1015. 'https://github.com/doctrine/orm/issues/8818',
  1016. 'Short namespace aliases such as "%s" are deprecated and will be removed in Doctrine ORM 3.0.',
  1017. $this->lexer->token->value
  1018. );
  1020. [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token->value);
  1022. return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  1023. }
  1025. /**
  1026. * Validates an AbstractSchemaName, making sure the class exists.
  1027. *
  1028. * @param string $schemaName The name to validate.
  1029. *
  1030. * @throws QueryException if the name does not exist.
  1031. */
  1032. private function validateAbstractSchemaName(string $schemaName): void
  1033. {
  1034. assert($this->lexer->token !== null);
  1035. if (! (class_exists($schemaName, true) || interface_exists($schemaName, true))) {
  1036. $this->semanticalError(
  1037. sprintf("Class '%s' is not defined.", $schemaName),
  1038. $this->lexer->token
  1039. );
  1040. }
  1041. }
  1043. /**
  1044. * AliasResultVariable ::= identifier
  1045. *
  1046. * @return string
  1047. */
  1048. public function AliasResultVariable()
  1049. {
  1050. $this->match(TokenType::T_IDENTIFIER);
  1052. assert($this->lexer->token !== null);
  1053. $resultVariable = $this->lexer->token->value;
  1054. $exists = isset($this->queryComponents[$resultVariable]);
  1056. if ($exists) {
  1057. $this->semanticalError(
  1058. sprintf("'%s' is already defined.", $resultVariable),
  1059. $this->lexer->token
  1060. );
  1061. }
  1063. return $resultVariable;
  1064. }
  1066. /**
  1067. * ResultVariable ::= identifier
  1068. *
  1069. * @return string
  1070. */
  1071. public function ResultVariable()
  1072. {
  1073. $this->match(TokenType::T_IDENTIFIER);
  1075. assert($this->lexer->token !== null);
  1076. $resultVariable = $this->lexer->token->value;
  1078. // Defer ResultVariable validation
  1079. $this->deferredResultVariables[] = [
  1080. 'expression' => $resultVariable,
  1081. 'nestingLevel' => $this->nestingLevel,
  1082. 'token' => $this->lexer->token,
  1083. ];
  1085. return $resultVariable;
  1086. }
  1088. /**
  1089. * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
  1090. *
  1091. * @return AST\JoinAssociationPathExpression
  1092. */
  1093. public function JoinAssociationPathExpression()
  1094. {
  1095. $identVariable = $this->IdentificationVariable();
  1097. if (! isset($this->queryComponents[$identVariable])) {
  1098. $this->semanticalError(
  1099. 'Identification Variable ' . $identVariable . ' used in join path expression but was not defined before.'
  1100. );
  1101. }
  1103. $this->match(TokenType::T_DOT);
  1104. $this->match(TokenType::T_IDENTIFIER);
  1106. assert($this->lexer->token !== null);
  1107. $field = $this->lexer->token->value;
  1109. // Validate association field
  1110. $class = $this->getMetadataForDqlAlias($identVariable);
  1112. if (! $class->hasAssociation($field)) {
  1113. $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
  1114. }
  1116. return new AST\JoinAssociationPathExpression($identVariable, $field);
  1117. }
  1119. /**
  1120. * Parses an arbitrary path expression and defers semantical validation
  1121. * based on expected types.
  1122. *
  1123. * PathExpression ::= IdentificationVariable {"." identifier}*
  1124. *
  1125. * @param int $expectedTypes
  1126. * @phpstan-param int-mask-of<AST\PathExpression::TYPE_*> $expectedTypes
  1127. *
  1128. * @return AST\PathExpression
  1129. */
  1130. public function PathExpression($expectedTypes)
  1131. {
  1132. $identVariable = $this->IdentificationVariable();
  1133. $field = null;
  1135. assert($this->lexer->token !== null);
  1136. if ($this->lexer->isNextToken(TokenType::T_DOT)) {
  1137. $this->match(TokenType::T_DOT);
  1138. $this->match(TokenType::T_IDENTIFIER);
  1140. $field = $this->lexer->token->value;
  1142. while ($this->lexer->isNextToken(TokenType::T_DOT)) {
  1143. $this->match(TokenType::T_DOT);
  1144. $this->match(TokenType::T_IDENTIFIER);
  1145. $field .= '.' . $this->lexer->token->value;
  1146. }
  1147. }
  1149. // Creating AST node
  1150. $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);
  1152. // Defer PathExpression validation if requested to be deferred
  1153. $this->deferredPathExpressions[] = [
  1154. 'expression' => $pathExpr,
  1155. 'nestingLevel' => $this->nestingLevel,
  1156. 'token' => $this->lexer->token,
  1157. ];
  1159. return $pathExpr;
  1160. }
  1162. /**
  1163. * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  1164. *
  1165. * @return AST\PathExpression
  1166. */
  1167. public function AssociationPathExpression()
  1168. {
  1169. return $this->PathExpression(
  1170. AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |
  1171. AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION
  1172. );
  1173. }
  1175. /**
  1176. * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  1177. *
  1178. * @return AST\PathExpression
  1179. */
  1180. public function SingleValuedPathExpression()
  1181. {
  1182. return $this->PathExpression(
  1183. AST\PathExpression::TYPE_STATE_FIELD |
  1184. AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  1185. );
  1186. }
  1188. /**
  1189. * StateFieldPathExpression ::= IdentificationVariable "." StateField
  1190. *
  1191. * @return AST\PathExpression
  1192. */
  1193. public function StateFieldPathExpression()
  1194. {
  1195. return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);
  1196. }
  1198. /**
  1199. * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  1200. *
  1201. * @return AST\PathExpression
  1202. */
  1203. public function SingleValuedAssociationPathExpression()
  1204. {
  1205. return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);
  1206. }
  1208. /**
  1209. * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  1210. *
  1211. * @return AST\PathExpression
  1212. */
  1213. public function CollectionValuedPathExpression()
  1214. {
  1215. return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);
  1216. }
  1218. /**
  1219. * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
  1220. *
  1221. * @return AST\SelectClause
  1222. */
  1223. public function SelectClause()
  1224. {
  1225. $isDistinct = false;
  1226. $this->match(TokenType::T_SELECT);
  1228. // Check for DISTINCT
  1229. if ($this->lexer->isNextToken(TokenType::T_DISTINCT)) {
  1230. $this->match(TokenType::T_DISTINCT);
  1232. $isDistinct = true;
  1233. }
  1235. // Process SelectExpressions (1..N)
  1236. $selectExpressions = [];
  1237. $selectExpressions[] = $this->SelectExpression();
  1239. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1240. $this->match(TokenType::T_COMMA);
  1242. $selectExpressions[] = $this->SelectExpression();
  1243. }
  1245. return new AST\SelectClause($selectExpressions, $isDistinct);
  1246. }
  1248. /**
  1249. * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
  1250. *
  1251. * @return AST\SimpleSelectClause
  1252. */
  1253. public function SimpleSelectClause()
  1254. {
  1255. $isDistinct = false;
  1256. $this->match(TokenType::T_SELECT);
  1258. if ($this->lexer->isNextToken(TokenType::T_DISTINCT)) {
  1259. $this->match(TokenType::T_DISTINCT);
  1261. $isDistinct = true;
  1262. }
  1264. return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);
  1265. }
  1267. /**
  1268. * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*
  1269. *
  1270. * @return AST\UpdateClause
  1271. */
  1272. public function UpdateClause()
  1273. {
  1274. $this->match(TokenType::T_UPDATE);
  1275. assert($this->lexer->lookahead !== null);
  1277. $token = $this->lexer->lookahead;
  1278. $abstractSchemaName = $this->AbstractSchemaName();
  1280. $this->validateAbstractSchemaName($abstractSchemaName);
  1282. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  1283. $this->match(TokenType::T_AS);
  1284. }
  1286. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1288. $class = $this->em->getClassMetadata($abstractSchemaName);
  1290. // Building queryComponent
  1291. $queryComponent = [
  1292. 'metadata' => $class,
  1293. 'parent' => null,
  1294. 'relation' => null,
  1295. 'map' => null,
  1296. 'nestingLevel' => $this->nestingLevel,
  1297. 'token' => $token,
  1298. ];
  1300. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1302. $this->match(TokenType::T_SET);
  1304. $updateItems = [];
  1305. $updateItems[] = $this->UpdateItem();
  1307. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1308. $this->match(TokenType::T_COMMA);
  1310. $updateItems[] = $this->UpdateItem();
  1311. }
  1313. $updateClause = new AST\UpdateClause($abstractSchemaName, $updateItems);
  1314. $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1316. return $updateClause;
  1317. }
  1319. /**
  1320. * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable
  1321. *
  1322. * @return AST\DeleteClause
  1323. */
  1324. public function DeleteClause()
  1325. {
  1326. $this->match(TokenType::T_DELETE);
  1328. if ($this->lexer->isNextToken(TokenType::T_FROM)) {
  1329. $this->match(TokenType::T_FROM);
  1330. }
  1332. assert($this->lexer->lookahead !== null);
  1333. $token = $this->lexer->lookahead;
  1334. $abstractSchemaName = $this->AbstractSchemaName();
  1336. $this->validateAbstractSchemaName($abstractSchemaName);
  1338. $deleteClause = new AST\DeleteClause($abstractSchemaName);
  1340. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  1341. $this->match(TokenType::T_AS);
  1342. }
  1344. $aliasIdentificationVariable = $this->lexer->isNextToken(TokenType::T_IDENTIFIER)
  1345. ? $this->AliasIdentificationVariable()
  1346. : 'alias_should_have_been_set';
  1348. $deleteClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1349. $class = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1351. // Building queryComponent
  1352. $queryComponent = [
  1353. 'metadata' => $class,
  1354. 'parent' => null,
  1355. 'relation' => null,
  1356. 'map' => null,
  1357. 'nestingLevel' => $this->nestingLevel,
  1358. 'token' => $token,
  1359. ];
  1361. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1363. return $deleteClause;
  1364. }
  1366. /**
  1367. * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}*
  1368. *
  1369. * @return AST\FromClause
  1370. */
  1371. public function FromClause()
  1372. {
  1373. $this->match(TokenType::T_FROM);
  1375. $identificationVariableDeclarations = [];
  1376. $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1378. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1379. $this->match(TokenType::T_COMMA);
  1381. $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1382. }
  1384. return new AST\FromClause($identificationVariableDeclarations);
  1385. }
  1387. /**
  1388. * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
  1389. *
  1390. * @return AST\SubselectFromClause
  1391. */
  1392. public function SubselectFromClause()
  1393. {
  1394. $this->match(TokenType::T_FROM);
  1396. $identificationVariables = [];
  1397. $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1399. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1400. $this->match(TokenType::T_COMMA);
  1402. $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1403. }
  1405. return new AST\SubselectFromClause($identificationVariables);
  1406. }
  1408. /**
  1409. * WhereClause ::= "WHERE" ConditionalExpression
  1410. *
  1411. * @return AST\WhereClause
  1412. */
  1413. public function WhereClause()
  1414. {
  1415. $this->match(TokenType::T_WHERE);
  1417. return new AST\WhereClause($this->ConditionalExpression());
  1418. }
  1420. /**
  1421. * HavingClause ::= "HAVING" ConditionalExpression
  1422. *
  1423. * @return AST\HavingClause
  1424. */
  1425. public function HavingClause()
  1426. {
  1427. $this->match(TokenType::T_HAVING);
  1429. return new AST\HavingClause($this->ConditionalExpression());
  1430. }
  1432. /**
  1433. * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
  1434. *
  1435. * @return AST\GroupByClause
  1436. */
  1437. public function GroupByClause()
  1438. {
  1439. $this->match(TokenType::T_GROUP);
  1440. $this->match(TokenType::T_BY);
  1442. $groupByItems = [$this->GroupByItem()];
  1444. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1445. $this->match(TokenType::T_COMMA);
  1447. $groupByItems[] = $this->GroupByItem();
  1448. }
  1450. return new AST\GroupByClause($groupByItems);
  1451. }
  1453. /**
  1454. * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
  1455. *
  1456. * @return AST\OrderByClause
  1457. */
  1458. public function OrderByClause()
  1459. {
  1460. $this->match(TokenType::T_ORDER);
  1461. $this->match(TokenType::T_BY);
  1463. $orderByItems = [];
  1464. $orderByItems[] = $this->OrderByItem();
  1466. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1467. $this->match(TokenType::T_COMMA);
  1469. $orderByItems[] = $this->OrderByItem();
  1470. }
  1472. return new AST\OrderByClause($orderByItems, $this->withJoinConditionNestingLevel === 0);
  1473. }
  1475. /**
  1476. * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  1477. *
  1478. * @return AST\Subselect
  1479. */
  1480. public function Subselect()
  1481. {
  1482. // Increase query nesting level
  1483. $this->nestingLevel++;
  1485. $subselect = new AST\Subselect($this->SimpleSelectClause(), $this->SubselectFromClause());
  1487. $subselect->whereClause = $this->lexer->isNextToken(TokenType::T_WHERE) ? $this->WhereClause() : null;
  1488. $subselect->groupByClause = $this->lexer->isNextToken(TokenType::T_GROUP) ? $this->GroupByClause() : null;
  1489. $subselect->havingClause = $this->lexer->isNextToken(TokenType::T_HAVING) ? $this->HavingClause() : null;
  1490. $subselect->orderByClause = $this->lexer->isNextToken(TokenType::T_ORDER) ? $this->OrderByClause() : null;
  1492. // Decrease query nesting level
  1493. $this->nestingLevel--;
  1495. return $subselect;
  1496. }
  1498. /**
  1499. * UpdateItem ::= SingleValuedPathExpression "=" NewValue
  1500. *
  1501. * @return AST\UpdateItem
  1502. */
  1503. public function UpdateItem()
  1504. {
  1505. $pathExpr = $this->SingleValuedPathExpression();
  1507. $this->match(TokenType::T_EQUALS);
  1509. return new AST\UpdateItem($pathExpr, $this->NewValue());
  1510. }
  1512. /**
  1513. * GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression
  1514. *
  1515. * @return string|AST\PathExpression
  1516. */
  1517. public function GroupByItem()
  1518. {
  1519. // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  1520. $glimpse = $this->lexer->glimpse();
  1522. if ($glimpse !== null && $glimpse->type === TokenType::T_DOT) {
  1523. return $this->SingleValuedPathExpression();
  1524. }
  1526. assert($this->lexer->lookahead !== null);
  1527. // Still need to decide between IdentificationVariable or ResultVariable
  1528. $lookaheadValue = $this->lexer->lookahead->value;
  1530. if (! isset($this->queryComponents[$lookaheadValue])) {
  1531. $this->semanticalError('Cannot group by undefined identification or result variable.');
  1532. }
  1534. return isset($this->queryComponents[$lookaheadValue]['metadata'])
  1535. ? $this->IdentificationVariable()
  1536. : $this->ResultVariable();
  1537. }
  1539. /**
  1540. * OrderByItem ::= (
  1541. * SimpleArithmeticExpression | SingleValuedPathExpression | CaseExpression |
  1542. * ScalarExpression | ResultVariable | FunctionDeclaration
  1543. * ) ["ASC" | "DESC"]
  1544. *
  1545. * @return AST\OrderByItem
  1546. */
  1547. public function OrderByItem()
  1548. {
  1549. $this->lexer->peek(); // lookahead => '.'
  1550. $this->lexer->peek(); // lookahead => token after '.'
  1552. $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1554. $this->lexer->resetPeek();
  1556. $glimpse = $this->lexer->glimpse();
  1558. assert($this->lexer->lookahead !== null);
  1559. switch (true) {
  1560. case $this->isMathOperator($peek) || $this->isMathOperator($glimpse):
  1561. $expr = $this->SimpleArithmeticExpression();
  1562. break;
  1564. case $glimpse !== null && $glimpse->type === TokenType::T_DOT:
  1565. $expr = $this->SingleValuedPathExpression();
  1566. break;
  1568. case $this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  1569. $expr = $this->ScalarExpression();
  1570. break;
  1572. case $this->lexer->lookahead->type === TokenType::T_CASE:
  1573. $expr = $this->CaseExpression();
  1574. break;
  1576. case $this->isFunction():
  1577. $expr = $this->FunctionDeclaration();
  1578. break;
  1580. default:
  1581. $expr = $this->ResultVariable();
  1582. break;
  1583. }
  1585. $type = 'ASC';
  1586. $item = new AST\OrderByItem($expr);
  1588. switch (true) {
  1589. case $this->lexer->isNextToken(TokenType::T_DESC):
  1590. $this->match(TokenType::T_DESC);
  1591. $type = 'DESC';
  1592. break;
  1594. case $this->lexer->isNextToken(TokenType::T_ASC):
  1595. $this->match(TokenType::T_ASC);
  1596. break;
  1598. default:
  1599. // Do nothing
  1600. }
  1602. $item->type = $type;
  1604. return $item;
  1605. }
  1607. /**
  1608. * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
  1609. * EnumPrimary | SimpleEntityExpression | "NULL"
  1610. *
  1611. * NOTE: Since it is not possible to correctly recognize individual types, here is the full
  1612. * grammar that needs to be supported:
  1613. *
  1614. * NewValue ::= SimpleArithmeticExpression | "NULL"
  1615. *
  1616. * SimpleArithmeticExpression covers all *Primary grammar rules and also SimpleEntityExpression
  1617. *
  1618. * @return AST\ArithmeticExpression|AST\InputParameter|null
  1619. */
  1620. public function NewValue()
  1621. {
  1622. if ($this->lexer->isNextToken(TokenType::T_NULL)) {
  1623. $this->match(TokenType::T_NULL);
  1625. return null;
  1626. }
  1628. if ($this->lexer->isNextToken(TokenType::T_INPUT_PARAMETER)) {
  1629. $this->match(TokenType::T_INPUT_PARAMETER);
  1630. assert($this->lexer->token !== null);
  1632. return new AST\InputParameter($this->lexer->token->value);
  1633. }
  1635. return $this->ArithmeticExpression();
  1636. }
  1638. /**
  1639. * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*
  1640. *
  1641. * @return AST\IdentificationVariableDeclaration
  1642. */
  1643. public function IdentificationVariableDeclaration()
  1644. {
  1645. $joins = [];
  1646. $rangeVariableDeclaration = $this->RangeVariableDeclaration();
  1647. $indexBy = $this->lexer->isNextToken(TokenType::T_INDEX)
  1648. ? $this->IndexBy()
  1649. : null;
  1651. $rangeVariableDeclaration->isRoot = true;
  1653. while (
  1654. $this->lexer->isNextToken(TokenType::T_LEFT) ||
  1655. $this->lexer->isNextToken(TokenType::T_INNER) ||
  1656. $this->lexer->isNextToken(TokenType::T_JOIN)
  1657. ) {
  1658. $joins[] = $this->Join();
  1659. }
  1661. return new AST\IdentificationVariableDeclaration(
  1662. $rangeVariableDeclaration,
  1663. $indexBy,
  1664. $joins
  1665. );
  1666. }
  1668. /**
  1669. * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration
  1670. *
  1671. * {Internal note: WARNING: Solution is harder than a bare implementation.
  1672. * Desired EBNF support:
  1673. *
  1674. * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
  1675. *
  1676. * It demands that entire SQL generation to become programmatical. This is
  1677. * needed because association based subselect requires "WHERE" conditional
  1678. * expressions to be injected, but there is no scope to do that. Only scope
  1679. * accessible is "FROM", prohibiting an easy implementation without larger
  1680. * changes.}
  1681. *
  1682. * @return AST\IdentificationVariableDeclaration
  1683. */
  1684. public function SubselectIdentificationVariableDeclaration()
  1685. {
  1686. /*
  1687. NOT YET IMPLEMENTED!
  1689. $glimpse = $this->lexer->glimpse();
  1691. if ($glimpse->type == TokenType::T_DOT) {
  1692. $associationPathExpression = $this->AssociationPathExpression();
  1694. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  1695. $this->match(TokenType::T_AS);
  1696. }
  1698. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1699. $identificationVariable = $associationPathExpression->identificationVariable;
  1700. $field = $associationPathExpression->associationField;
  1702. $class = $this->queryComponents[$identificationVariable]['metadata'];
  1703. $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1705. // Building queryComponent
  1706. $joinQueryComponent = array(
  1707. 'metadata' => $targetClass,
  1708. 'parent' => $identificationVariable,
  1709. 'relation' => $class->getAssociationMapping($field),
  1710. 'map' => null,
  1711. 'nestingLevel' => $this->nestingLevel,
  1712. 'token' => $this->lexer->lookahead
  1713. );
  1715. $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1717. return new AST\SubselectIdentificationVariableDeclaration(
  1718. $associationPathExpression, $aliasIdentificationVariable
  1719. );
  1720. }
  1721. */
  1723. return $this->IdentificationVariableDeclaration();
  1724. }
  1726. /**
  1727. * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN"
  1728. * (JoinAssociationDeclaration | RangeVariableDeclaration)
  1729. * ["WITH" ConditionalExpression]
  1730. *
  1731. * @return AST\Join
  1732. */
  1733. public function Join()
  1734. {
  1735. // Check Join type
  1736. $joinType = AST\Join::JOIN_TYPE_INNER;
  1738. switch (true) {
  1739. case $this->lexer->isNextToken(TokenType::T_LEFT):
  1740. $this->match(TokenType::T_LEFT);
  1742. $joinType = AST\Join::JOIN_TYPE_LEFT;
  1744. // Possible LEFT OUTER join
  1745. if ($this->lexer->isNextToken(TokenType::T_OUTER)) {
  1746. $this->match(TokenType::T_OUTER);
  1748. $joinType = AST\Join::JOIN_TYPE_LEFTOUTER;
  1749. }
  1751. break;
  1753. case $this->lexer->isNextToken(TokenType::T_INNER):
  1754. $this->match(TokenType::T_INNER);
  1755. break;
  1757. default:
  1758. // Do nothing
  1759. }
  1761. $this->match(TokenType::T_JOIN);
  1763. $next = $this->lexer->glimpse();
  1764. assert($next !== null);
  1765. $joinDeclaration = $next->type === TokenType::T_DOT ? $this->JoinAssociationDeclaration() : $this->RangeVariableDeclaration();
  1766. $adhocConditions = $this->lexer->isNextToken(TokenType::T_WITH);
  1767. $join = new AST\Join($joinType, $joinDeclaration);
  1769. // Describe non-root join declaration
  1770. if ($joinDeclaration instanceof AST\RangeVariableDeclaration) {
  1771. $joinDeclaration->isRoot = false;
  1772. }
  1774. // Check for ad-hoc Join conditions
  1775. if ($adhocConditions) {
  1776. $this->match(TokenType::T_WITH);
  1778. try {
  1779. $this->withJoinConditionNestingLevel++;
  1781. $join->conditionalExpression = $this->ConditionalExpression();
  1782. } finally {
  1783. $this->withJoinConditionNestingLevel--;
  1784. }
  1785. }
  1787. return $join;
  1788. }
  1790. /**
  1791. * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
  1792. *
  1793. * @return AST\RangeVariableDeclaration
  1794. *
  1795. * @throws QueryException
  1796. */
  1797. public function RangeVariableDeclaration()
  1798. {
  1799. if ($this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS) && $this->lexer->glimpse()->type === TokenType::T_SELECT) {
  1800. $this->semanticalError('Subquery is not supported here', $this->lexer->token);
  1801. }
  1803. $abstractSchemaName = $this->AbstractSchemaName();
  1805. $this->validateAbstractSchemaName($abstractSchemaName);
  1807. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  1808. $this->match(TokenType::T_AS);
  1809. }
  1811. assert($this->lexer->lookahead !== null);
  1812. $token = $this->lexer->lookahead;
  1813. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1814. $classMetadata = $this->em->getClassMetadata($abstractSchemaName);
  1816. // Building queryComponent
  1817. $queryComponent = [
  1818. 'metadata' => $classMetadata,
  1819. 'parent' => null,
  1820. 'relation' => null,
  1821. 'map' => null,
  1822. 'nestingLevel' => $this->nestingLevel,
  1823. 'token' => $token,
  1824. ];
  1826. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1828. return new AST\RangeVariableDeclaration($abstractSchemaName, $aliasIdentificationVariable);
  1829. }
  1831. /**
  1832. * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [IndexBy]
  1833. *
  1834. * @return AST\JoinAssociationDeclaration
  1835. */
  1836. public function JoinAssociationDeclaration()
  1837. {
  1838. $joinAssociationPathExpression = $this->JoinAssociationPathExpression();
  1840. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  1841. $this->match(TokenType::T_AS);
  1842. }
  1844. assert($this->lexer->lookahead !== null);
  1846. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1847. $indexBy = $this->lexer->isNextToken(TokenType::T_INDEX) ? $this->IndexBy() : null;
  1849. $identificationVariable = $joinAssociationPathExpression->identificationVariable;
  1850. $field = $joinAssociationPathExpression->associationField;
  1852. $class = $this->getMetadataForDqlAlias($identificationVariable);
  1853. $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1855. // Building queryComponent
  1856. $joinQueryComponent = [
  1857. 'metadata' => $targetClass,
  1858. 'parent' => $joinAssociationPathExpression->identificationVariable,
  1859. 'relation' => $class->getAssociationMapping($field),
  1860. 'map' => null,
  1861. 'nestingLevel' => $this->nestingLevel,
  1862. 'token' => $this->lexer->lookahead,
  1863. ];
  1865. $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1867. return new AST\JoinAssociationDeclaration($joinAssociationPathExpression, $aliasIdentificationVariable, $indexBy);
  1868. }
  1870. /**
  1871. * PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
  1872. * PartialFieldSet ::= "{" SimpleStateField {"," SimpleStateField}* "}"
  1873. *
  1874. * @return AST\PartialObjectExpression
  1875. */
  1876. public function PartialObjectExpression()
  1877. {
  1878. $this->match(TokenType::T_PARTIAL);
  1880. $partialFieldSet = [];
  1882. $identificationVariable = $this->IdentificationVariable();
  1884. $this->match(TokenType::T_DOT);
  1885. $this->match(TokenType::T_OPEN_CURLY_BRACE);
  1886. $this->match(TokenType::T_IDENTIFIER);
  1888. assert($this->lexer->token !== null);
  1889. $field = $this->lexer->token->value;
  1891. // First field in partial expression might be embeddable property
  1892. while ($this->lexer->isNextToken(TokenType::T_DOT)) {
  1893. $this->match(TokenType::T_DOT);
  1894. $this->match(TokenType::T_IDENTIFIER);
  1895. $field .= '.' . $this->lexer->token->value;
  1896. }
  1898. $partialFieldSet[] = $field;
  1900. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1901. $this->match(TokenType::T_COMMA);
  1902. $this->match(TokenType::T_IDENTIFIER);
  1904. $field = $this->lexer->token->value;
  1906. while ($this->lexer->isNextToken(TokenType::T_DOT)) {
  1907. $this->match(TokenType::T_DOT);
  1908. $this->match(TokenType::T_IDENTIFIER);
  1909. $field .= '.' . $this->lexer->token->value;
  1910. }
  1912. $partialFieldSet[] = $field;
  1913. }
  1915. $this->match(TokenType::T_CLOSE_CURLY_BRACE);
  1917. $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
  1919. // Defer PartialObjectExpression validation
  1920. $this->deferredPartialObjectExpressions[] = [
  1921. 'expression' => $partialObjectExpression,
  1922. 'nestingLevel' => $this->nestingLevel,
  1923. 'token' => $this->lexer->token,
  1924. ];
  1926. return $partialObjectExpression;
  1927. }
  1929. /**
  1930. * NewObjectExpression ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
  1931. *
  1932. * @return AST\NewObjectExpression
  1933. */
  1934. public function NewObjectExpression()
  1935. {
  1936. $this->match(TokenType::T_NEW);
  1938. $className = $this->AbstractSchemaName(); // note that this is not yet validated
  1939. $token = $this->lexer->token;
  1941. $this->match(TokenType::T_OPEN_PARENTHESIS);
  1943. $args[] = $this->NewObjectArg();
  1945. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1946. $this->match(TokenType::T_COMMA);
  1948. $args[] = $this->NewObjectArg();
  1949. }
  1951. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  1953. $expression = new AST\NewObjectExpression($className, $args);
  1955. // Defer NewObjectExpression validation
  1956. $this->deferredNewObjectExpressions[] = [
  1957. 'token' => $token,
  1958. 'expression' => $expression,
  1959. 'nestingLevel' => $this->nestingLevel,
  1960. ];
  1962. return $expression;
  1963. }
  1965. /**
  1966. * NewObjectArg ::= ScalarExpression | "(" Subselect ")"
  1967. *
  1968. * @return mixed
  1969. */
  1970. public function NewObjectArg()
  1971. {
  1972. assert($this->lexer->lookahead !== null);
  1973. $token = $this->lexer->lookahead;
  1974. $peek = $this->lexer->glimpse();
  1976. assert($peek !== null);
  1977. if ($token->type === TokenType::T_OPEN_PARENTHESIS && $peek->type === TokenType::T_SELECT) {
  1978. $this->match(TokenType::T_OPEN_PARENTHESIS);
  1979. $expression = $this->Subselect();
  1980. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  1982. return $expression;
  1983. }
  1985. return $this->ScalarExpression();
  1986. }
  1988. /**
  1989. * IndexBy ::= "INDEX" "BY" SingleValuedPathExpression
  1990. *
  1991. * @return AST\IndexBy
  1992. */
  1993. public function IndexBy()
  1994. {
  1995. $this->match(TokenType::T_INDEX);
  1996. $this->match(TokenType::T_BY);
  1997. $pathExpr = $this->SingleValuedPathExpression();
  1999. // Add the INDEX BY info to the query component
  2000. $this->queryComponents[$pathExpr->identificationVariable]['map'] = $pathExpr->field;
  2002. return new AST\IndexBy($pathExpr);
  2003. }
  2005. /**
  2006. * ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary |
  2007. * StateFieldPathExpression | BooleanPrimary | CaseExpression |
  2008. * InstanceOfExpression
  2009. *
  2010. * @return mixed One of the possible expressions or subexpressions.
  2011. */
  2012. public function ScalarExpression()
  2013. {
  2014. assert($this->lexer->token !== null);
  2015. assert($this->lexer->lookahead !== null);
  2016. $lookahead = $this->lexer->lookahead->type;
  2017. $peek = $this->lexer->glimpse();
  2019. switch (true) {
  2020. case $lookahead === TokenType::T_INTEGER:
  2021. case $lookahead === TokenType::T_FLOAT:
  2022. // SimpleArithmeticExpression : (- u.value ) or ( + u.value ) or ( - 1 ) or ( + 1 )
  2023. case $lookahead === TokenType::T_MINUS:
  2024. case $lookahead === TokenType::T_PLUS:
  2025. return $this->SimpleArithmeticExpression();
  2027. case $lookahead === TokenType::T_STRING:
  2028. return $this->StringPrimary();
  2030. case $lookahead === TokenType::T_TRUE:
  2031. case $lookahead === TokenType::T_FALSE:
  2032. $this->match($lookahead);
  2034. return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token->value);
  2036. case $lookahead === TokenType::T_INPUT_PARAMETER:
  2037. switch (true) {
  2038. case $this->isMathOperator($peek):
  2039. // :param + u.value
  2040. return $this->SimpleArithmeticExpression();
  2042. default:
  2043. return $this->InputParameter();
  2044. }
  2045. case $lookahead === TokenType::T_CASE:
  2046. case $lookahead === TokenType::T_COALESCE:
  2047. case $lookahead === TokenType::T_NULLIF:
  2048. // Since NULLIF and COALESCE can be identified as a function,
  2049. // we need to check these before checking for FunctionDeclaration
  2050. return $this->CaseExpression();
  2052. case $lookahead === TokenType::T_OPEN_PARENTHESIS:
  2053. return $this->SimpleArithmeticExpression();
  2055. // this check must be done before checking for a filed path expression
  2056. case $this->isFunction():
  2057. $this->lexer->peek(); // "("
  2059. switch (true) {
  2060. case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2061. // SUM(u.id) + COUNT(u.id)
  2062. return $this->SimpleArithmeticExpression();
  2064. default:
  2065. // IDENTITY(u)
  2066. return $this->FunctionDeclaration();
  2067. }
  2069. break;
  2070. // it is no function, so it must be a field path
  2071. case $lookahead === TokenType::T_IDENTIFIER:
  2072. $this->lexer->peek(); // lookahead => '.'
  2073. $this->lexer->peek(); // lookahead => token after '.'
  2074. $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  2075. $this->lexer->resetPeek();
  2077. if ($this->isMathOperator($peek)) {
  2078. return $this->SimpleArithmeticExpression();
  2079. }
  2081. return $this->StateFieldPathExpression();
  2083. default:
  2084. $this->syntaxError();
  2085. }
  2086. }
  2088. /**
  2089. * CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullIfExpression
  2090. * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2091. * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2092. * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2093. * CaseOperand ::= StateFieldPathExpression
  2094. * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2095. * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2096. * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2097. *
  2098. * @return mixed One of the possible expressions or subexpressions.
  2099. */
  2100. public function CaseExpression()
  2101. {
  2102. assert($this->lexer->lookahead !== null);
  2103. $lookahead = $this->lexer->lookahead->type;
  2105. switch ($lookahead) {
  2106. case TokenType::T_NULLIF:
  2107. return $this->NullIfExpression();
  2109. case TokenType::T_COALESCE:
  2110. return $this->CoalesceExpression();
  2112. case TokenType::T_CASE:
  2113. $this->lexer->resetPeek();
  2114. $peek = $this->lexer->peek();
  2116. assert($peek !== null);
  2117. if ($peek->type === TokenType::T_WHEN) {
  2118. return $this->GeneralCaseExpression();
  2119. }
  2121. return $this->SimpleCaseExpression();
  2123. default:
  2124. // Do nothing
  2125. break;
  2126. }
  2128. $this->syntaxError();
  2129. }
  2131. /**
  2132. * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2133. *
  2134. * @return AST\CoalesceExpression
  2135. */
  2136. public function CoalesceExpression()
  2137. {
  2138. $this->match(TokenType::T_COALESCE);
  2139. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2141. // Process ScalarExpressions (1..N)
  2142. $scalarExpressions = [];
  2143. $scalarExpressions[] = $this->ScalarExpression();
  2145. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  2146. $this->match(TokenType::T_COMMA);
  2148. $scalarExpressions[] = $this->ScalarExpression();
  2149. }
  2151. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2153. return new AST\CoalesceExpression($scalarExpressions);
  2154. }
  2156. /**
  2157. * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2158. *
  2159. * @return AST\NullIfExpression
  2160. */
  2161. public function NullIfExpression()
  2162. {
  2163. $this->match(TokenType::T_NULLIF);
  2164. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2166. $firstExpression = $this->ScalarExpression();
  2167. $this->match(TokenType::T_COMMA);
  2168. $secondExpression = $this->ScalarExpression();
  2170. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2172. return new AST\NullIfExpression($firstExpression, $secondExpression);
  2173. }
  2175. /**
  2176. * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2177. *
  2178. * @return AST\GeneralCaseExpression
  2179. */
  2180. public function GeneralCaseExpression()
  2181. {
  2182. $this->match(TokenType::T_CASE);
  2184. // Process WhenClause (1..N)
  2185. $whenClauses = [];
  2187. do {
  2188. $whenClauses[] = $this->WhenClause();
  2189. } while ($this->lexer->isNextToken(TokenType::T_WHEN));
  2191. $this->match(TokenType::T_ELSE);
  2192. $scalarExpression = $this->ScalarExpression();
  2193. $this->match(TokenType::T_END);
  2195. return new AST\GeneralCaseExpression($whenClauses, $scalarExpression);
  2196. }
  2198. /**
  2199. * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2200. * CaseOperand ::= StateFieldPathExpression
  2201. *
  2202. * @return AST\SimpleCaseExpression
  2203. */
  2204. public function SimpleCaseExpression()
  2205. {
  2206. $this->match(TokenType::T_CASE);
  2207. $caseOperand = $this->StateFieldPathExpression();
  2209. // Process SimpleWhenClause (1..N)
  2210. $simpleWhenClauses = [];
  2212. do {
  2213. $simpleWhenClauses[] = $this->SimpleWhenClause();
  2214. } while ($this->lexer->isNextToken(TokenType::T_WHEN));
  2216. $this->match(TokenType::T_ELSE);
  2217. $scalarExpression = $this->ScalarExpression();
  2218. $this->match(TokenType::T_END);
  2220. return new AST\SimpleCaseExpression($caseOperand, $simpleWhenClauses, $scalarExpression);
  2221. }
  2223. /**
  2224. * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2225. *
  2226. * @return AST\WhenClause
  2227. */
  2228. public function WhenClause()
  2229. {
  2230. $this->match(TokenType::T_WHEN);
  2231. $conditionalExpression = $this->ConditionalExpression();
  2232. $this->match(TokenType::T_THEN);
  2234. return new AST\WhenClause($conditionalExpression, $this->ScalarExpression());
  2235. }
  2237. /**
  2238. * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2239. *
  2240. * @return AST\SimpleWhenClause
  2241. */
  2242. public function SimpleWhenClause()
  2243. {
  2244. $this->match(TokenType::T_WHEN);
  2245. $conditionalExpression = $this->ScalarExpression();
  2246. $this->match(TokenType::T_THEN);
  2248. return new AST\SimpleWhenClause($conditionalExpression, $this->ScalarExpression());
  2249. }
  2251. /**
  2252. * SelectExpression ::= (
  2253. * IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration |
  2254. * PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression
  2255. * ) [["AS"] ["HIDDEN"] AliasResultVariable]
  2256. *
  2257. * @return AST\SelectExpression
  2258. */
  2259. public function SelectExpression()
  2260. {
  2261. assert($this->lexer->lookahead !== null);
  2262. $expression = null;
  2263. $identVariable = null;
  2264. $peek = $this->lexer->glimpse();
  2265. $lookaheadType = $this->lexer->lookahead->type;
  2266. assert($peek !== null);
  2268. switch (true) {
  2269. // ScalarExpression (u.name)
  2270. case $lookaheadType === TokenType::T_IDENTIFIER && $peek->type === TokenType::T_DOT:
  2271. $expression = $this->ScalarExpression();
  2272. break;
  2274. // IdentificationVariable (u)
  2275. case $lookaheadType === TokenType::T_IDENTIFIER && $peek->type !== TokenType::T_OPEN_PARENTHESIS:
  2276. $expression = $identVariable = $this->IdentificationVariable();
  2277. break;
  2279. // CaseExpression (CASE ... or NULLIF(...) or COALESCE(...))
  2280. case $lookaheadType === TokenType::T_CASE:
  2281. case $lookaheadType === TokenType::T_COALESCE:
  2282. case $lookaheadType === TokenType::T_NULLIF:
  2283. $expression = $this->CaseExpression();
  2284. break;
  2286. // DQL Function (SUM(u.value) or SUM(u.value) + 1)
  2287. case $this->isFunction():
  2288. $this->lexer->peek(); // "("
  2290. switch (true) {
  2291. case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2292. // SUM(u.id) + COUNT(u.id)
  2293. $expression = $this->ScalarExpression();
  2294. break;
  2296. default:
  2297. // IDENTITY(u)
  2298. $expression = $this->FunctionDeclaration();
  2299. break;
  2300. }
  2302. break;
  2304. // PartialObjectExpression (PARTIAL u.{id, name})
  2305. case $lookaheadType === TokenType::T_PARTIAL:
  2306. $expression = $this->PartialObjectExpression();
  2307. $identVariable = $expression->identificationVariable;
  2308. break;
  2310. // Subselect
  2311. case $lookaheadType === TokenType::T_OPEN_PARENTHESIS && $peek->type === TokenType::T_SELECT:
  2312. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2313. $expression = $this->Subselect();
  2314. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2315. break;
  2317. // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2318. case $lookaheadType === TokenType::T_OPEN_PARENTHESIS:
  2319. case $lookaheadType === TokenType::T_INTEGER:
  2320. case $lookaheadType === TokenType::T_STRING:
  2321. case $lookaheadType === TokenType::T_FLOAT:
  2322. // SimpleArithmeticExpression : (- u.value ) or ( + u.value )
  2323. case $lookaheadType === TokenType::T_MINUS:
  2324. case $lookaheadType === TokenType::T_PLUS:
  2325. $expression = $this->SimpleArithmeticExpression();
  2326. break;
  2328. // NewObjectExpression (New ClassName(id, name))
  2329. case $lookaheadType === TokenType::T_NEW:
  2330. $expression = $this->NewObjectExpression();
  2331. break;
  2333. default:
  2334. $this->syntaxError(
  2335. 'IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression',
  2336. $this->lexer->lookahead
  2337. );
  2338. }
  2340. // [["AS"] ["HIDDEN"] AliasResultVariable]
  2341. $mustHaveAliasResultVariable = false;
  2343. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  2344. $this->match(TokenType::T_AS);
  2346. $mustHaveAliasResultVariable = true;
  2347. }
  2349. $hiddenAliasResultVariable = false;
  2351. if ($this->lexer->isNextToken(TokenType::T_HIDDEN)) {
  2352. $this->match(TokenType::T_HIDDEN);
  2354. $hiddenAliasResultVariable = true;
  2355. }
  2357. $aliasResultVariable = null;
  2359. if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(TokenType::T_IDENTIFIER)) {
  2360. assert($expression instanceof AST\Node || is_string($expression));
  2361. $token = $this->lexer->lookahead;
  2362. $aliasResultVariable = $this->AliasResultVariable();
  2364. // Include AliasResultVariable in query components.
  2365. $this->queryComponents[$aliasResultVariable] = [
  2366. 'resultVariable' => $expression,
  2367. 'nestingLevel' => $this->nestingLevel,
  2368. 'token' => $token,
  2369. ];
  2370. }
  2372. // AST
  2374. $expr = new AST\SelectExpression($expression, $aliasResultVariable, $hiddenAliasResultVariable);
  2376. if ($identVariable) {
  2377. $this->identVariableExpressions[$identVariable] = $expr;
  2378. }
  2380. return $expr;
  2381. }
  2383. /**
  2384. * SimpleSelectExpression ::= (
  2385. * StateFieldPathExpression | IdentificationVariable | FunctionDeclaration |
  2386. * AggregateExpression | "(" Subselect ")" | ScalarExpression
  2387. * ) [["AS"] AliasResultVariable]
  2388. *
  2389. * @return AST\SimpleSelectExpression
  2390. */
  2391. public function SimpleSelectExpression()
  2392. {
  2393. assert($this->lexer->lookahead !== null);
  2394. $peek = $this->lexer->glimpse();
  2395. assert($peek !== null);
  2397. switch ($this->lexer->lookahead->type) {
  2398. case TokenType::T_IDENTIFIER:
  2399. switch (true) {
  2400. case $peek->type === TokenType::T_DOT:
  2401. $expression = $this->StateFieldPathExpression();
  2403. return new AST\SimpleSelectExpression($expression);
  2405. case $peek->type !== TokenType::T_OPEN_PARENTHESIS:
  2406. $expression = $this->IdentificationVariable();
  2408. return new AST\SimpleSelectExpression($expression);
  2410. case $this->isFunction():
  2411. // SUM(u.id) + COUNT(u.id)
  2412. if ($this->isMathOperator($this->peekBeyondClosingParenthesis())) {
  2413. return new AST\SimpleSelectExpression($this->ScalarExpression());
  2414. }
  2416. // COUNT(u.id)
  2417. if ($this->isAggregateFunction($this->lexer->lookahead->type)) {
  2418. return new AST\SimpleSelectExpression($this->AggregateExpression());
  2419. }
  2421. // IDENTITY(u)
  2422. return new AST\SimpleSelectExpression($this->FunctionDeclaration());
  2424. default:
  2425. // Do nothing
  2426. }
  2428. break;
  2430. case TokenType::T_OPEN_PARENTHESIS:
  2431. if ($peek->type !== TokenType::T_SELECT) {
  2432. // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2433. $expression = $this->SimpleArithmeticExpression();
  2435. return new AST\SimpleSelectExpression($expression);
  2436. }
  2438. // Subselect
  2439. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2440. $expression = $this->Subselect();
  2441. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2443. return new AST\SimpleSelectExpression($expression);
  2445. default:
  2446. // Do nothing
  2447. }
  2449. $this->lexer->peek();
  2451. $expression = $this->ScalarExpression();
  2452. $expr = new AST\SimpleSelectExpression($expression);
  2454. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  2455. $this->match(TokenType::T_AS);
  2456. }
  2458. if ($this->lexer->isNextToken(TokenType::T_IDENTIFIER)) {
  2459. $token = $this->lexer->lookahead;
  2460. $resultVariable = $this->AliasResultVariable();
  2461. $expr->fieldIdentificationVariable = $resultVariable;
  2463. // Include AliasResultVariable in query components.
  2464. $this->queryComponents[$resultVariable] = [
  2465. 'resultvariable' => $expr,
  2466. 'nestingLevel' => $this->nestingLevel,
  2467. 'token' => $token,
  2468. ];
  2469. }
  2471. return $expr;
  2472. }
  2474. /**
  2475. * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
  2476. *
  2477. * @return AST\ConditionalExpression|AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2478. */
  2479. public function ConditionalExpression()
  2480. {
  2481. $conditionalTerms = [];
  2482. $conditionalTerms[] = $this->ConditionalTerm();
  2484. while ($this->lexer->isNextToken(TokenType::T_OR)) {
  2485. $this->match(TokenType::T_OR);
  2487. $conditionalTerms[] = $this->ConditionalTerm();
  2488. }
  2490. // Phase 1 AST optimization: Prevent AST\ConditionalExpression
  2491. // if only one AST\ConditionalTerm is defined
  2492. if (count($conditionalTerms) === 1) {
  2493. return $conditionalTerms[0];
  2494. }
  2496. return new AST\ConditionalExpression($conditionalTerms);
  2497. }
  2499. /**
  2500. * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
  2501. *
  2502. * @return AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2503. */
  2504. public function ConditionalTerm()
  2505. {
  2506. $conditionalFactors = [];
  2507. $conditionalFactors[] = $this->ConditionalFactor();
  2509. while ($this->lexer->isNextToken(TokenType::T_AND)) {
  2510. $this->match(TokenType::T_AND);
  2512. $conditionalFactors[] = $this->ConditionalFactor();
  2513. }
  2515. // Phase 1 AST optimization: Prevent AST\ConditionalTerm
  2516. // if only one AST\ConditionalFactor is defined
  2517. if (count($conditionalFactors) === 1) {
  2518. return $conditionalFactors[0];
  2519. }
  2521. return new AST\ConditionalTerm($conditionalFactors);
  2522. }
  2524. /**
  2525. * ConditionalFactor ::= ["NOT"] ConditionalPrimary
  2526. *
  2527. * @return AST\ConditionalFactor|AST\ConditionalPrimary
  2528. */
  2529. public function ConditionalFactor()
  2530. {
  2531. $not = false;
  2533. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  2534. $this->match(TokenType::T_NOT);
  2536. $not = true;
  2537. }
  2539. $conditionalPrimary = $this->ConditionalPrimary();
  2541. // Phase 1 AST optimization: Prevent AST\ConditionalFactor
  2542. // if only one AST\ConditionalPrimary is defined
  2543. if (! $not) {
  2544. return $conditionalPrimary;
  2545. }
  2547. return new AST\ConditionalFactor($conditionalPrimary, $not);
  2548. }
  2550. /**
  2551. * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
  2552. *
  2553. * @return AST\ConditionalPrimary
  2554. */
  2555. public function ConditionalPrimary()
  2556. {
  2557. $condPrimary = new AST\ConditionalPrimary();
  2559. if (! $this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS)) {
  2560. $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2562. return $condPrimary;
  2563. }
  2565. // Peek beyond the matching closing parenthesis ')'
  2566. $peek = $this->peekBeyondClosingParenthesis();
  2568. if (
  2569. $peek !== null && (
  2570. in_array($peek->value, ['=', '<', '<=', '<>', '>', '>=', '!='], true) ||
  2571. in_array($peek->type, [TokenType::T_NOT, TokenType::T_BETWEEN, TokenType::T_LIKE, TokenType::T_IN, TokenType::T_IS, TokenType::T_EXISTS], true) ||
  2572. $this->isMathOperator($peek)
  2573. )
  2574. ) {
  2575. $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2577. return $condPrimary;
  2578. }
  2580. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2581. $condPrimary->conditionalExpression = $this->ConditionalExpression();
  2582. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2584. return $condPrimary;
  2585. }
  2587. /**
  2588. * SimpleConditionalExpression ::=
  2589. * ComparisonExpression | BetweenExpression | LikeExpression |
  2590. * InExpression | NullComparisonExpression | ExistsExpression |
  2591. * EmptyCollectionComparisonExpression | CollectionMemberExpression |
  2592. * InstanceOfExpression
  2593. *
  2594. * @return (AST\BetweenExpression|
  2595. * AST\CollectionMemberExpression|
  2596. * AST\ComparisonExpression|
  2597. * AST\EmptyCollectionComparisonExpression|
  2598. * AST\ExistsExpression|
  2599. * AST\InExpression|
  2600. * AST\InstanceOfExpression|
  2601. * AST\LikeExpression|
  2602. * AST\NullComparisonExpression)
  2603. *
  2604. * @phpstan-ignore return.deprecatedClass
  2605. */
  2606. public function SimpleConditionalExpression()
  2607. {
  2608. assert($this->lexer->lookahead !== null);
  2609. if ($this->lexer->isNextToken(TokenType::T_EXISTS)) {
  2610. return $this->ExistsExpression();
  2611. }
  2613. $token = $this->lexer->lookahead;
  2614. $peek = $this->lexer->glimpse();
  2615. $lookahead = $token;
  2617. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  2618. $token = $this->lexer->glimpse();
  2619. }
  2621. assert($token !== null);
  2622. assert($peek !== null);
  2623. if ($token->type === TokenType::T_IDENTIFIER || $token->type === TokenType::T_INPUT_PARAMETER || $this->isFunction()) {
  2624. // Peek beyond the matching closing parenthesis.
  2625. $beyond = $this->lexer->peek();
  2627. switch ($peek->value) {
  2628. case '(':
  2629. // Peeks beyond the matched closing parenthesis.
  2630. $token = $this->peekBeyondClosingParenthesis(false);
  2631. assert($token !== null);
  2633. if ($token->type === TokenType::T_NOT) {
  2634. $token = $this->lexer->peek();
  2635. assert($token !== null);
  2636. }
  2638. if ($token->type === TokenType::T_IS) {
  2639. $lookahead = $this->lexer->peek();
  2640. }
  2642. break;
  2644. default:
  2645. // Peek beyond the PathExpression or InputParameter.
  2646. $token = $beyond;
  2648. while ($token->value === '.') {
  2649. $this->lexer->peek();
  2651. $token = $this->lexer->peek();
  2652. assert($token !== null);
  2653. }
  2655. // Also peek beyond a NOT if there is one.
  2656. assert($token !== null);
  2657. if ($token->type === TokenType::T_NOT) {
  2658. $token = $this->lexer->peek();
  2659. assert($token !== null);
  2660. }
  2662. // We need to go even further in case of IS (differentiate between NULL and EMPTY)
  2663. $lookahead = $this->lexer->peek();
  2664. }
  2666. assert($lookahead !== null);
  2667. // Also peek beyond a NOT if there is one.
  2668. if ($lookahead->type === TokenType::T_NOT) {
  2669. $lookahead = $this->lexer->peek();
  2670. }
  2672. $this->lexer->resetPeek();
  2673. }
  2675. if ($token->type === TokenType::T_BETWEEN) {
  2676. return $this->BetweenExpression();
  2677. }
  2679. if ($token->type === TokenType::T_LIKE) {
  2680. return $this->LikeExpression();
  2681. }
  2683. if ($token->type === TokenType::T_IN) {
  2684. return $this->InExpression();
  2685. }
  2687. if ($token->type === TokenType::T_INSTANCE) {
  2688. return $this->InstanceOfExpression();
  2689. }
  2691. if ($token->type === TokenType::T_MEMBER) {
  2692. return $this->CollectionMemberExpression();
  2693. }
  2695. assert($lookahead !== null);
  2696. if ($token->type === TokenType::T_IS && $lookahead->type === TokenType::T_NULL) {
  2697. return $this->NullComparisonExpression();
  2698. }
  2700. if ($token->type === TokenType::T_IS && $lookahead->type === TokenType::T_EMPTY) {
  2701. return $this->EmptyCollectionComparisonExpression();
  2702. }
  2704. return $this->ComparisonExpression();
  2705. }
  2707. /**
  2708. * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
  2709. *
  2710. * @return AST\EmptyCollectionComparisonExpression
  2711. */
  2712. public function EmptyCollectionComparisonExpression()
  2713. {
  2714. $pathExpression = $this->CollectionValuedPathExpression();
  2715. $this->match(TokenType::T_IS);
  2717. $not = false;
  2718. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  2719. $this->match(TokenType::T_NOT);
  2720. $not = true;
  2721. }
  2723. $this->match(TokenType::T_EMPTY);
  2725. return new AST\EmptyCollectionComparisonExpression(
  2726. $pathExpression,
  2727. $not
  2728. );
  2729. }
  2731. /**
  2732. * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
  2733. *
  2734. * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2735. * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2736. *
  2737. * @return AST\CollectionMemberExpression
  2738. */
  2739. public function CollectionMemberExpression()
  2740. {
  2741. $not = false;
  2742. $entityExpr = $this->EntityExpression();
  2744. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  2745. $this->match(TokenType::T_NOT);
  2747. $not = true;
  2748. }
  2750. $this->match(TokenType::T_MEMBER);
  2752. if ($this->lexer->isNextToken(TokenType::T_OF)) {
  2753. $this->match(TokenType::T_OF);
  2754. }
  2756. return new AST\CollectionMemberExpression(
  2757. $entityExpr,
  2758. $this->CollectionValuedPathExpression(),
  2759. $not
  2760. );
  2761. }
  2763. /**
  2764. * Literal ::= string | char | integer | float | boolean
  2765. *
  2766. * @return AST\Literal
  2767. */
  2768. public function Literal()
  2769. {
  2770. assert($this->lexer->lookahead !== null);
  2771. assert($this->lexer->token !== null);
  2772. switch ($this->lexer->lookahead->type) {
  2773. case TokenType::T_STRING:
  2774. $this->match(TokenType::T_STRING);
  2776. return new AST\Literal(AST\Literal::STRING, $this->lexer->token->value);
  2778. case TokenType::T_INTEGER:
  2779. case TokenType::T_FLOAT:
  2780. $this->match(
  2781. $this->lexer->isNextToken(TokenType::T_INTEGER) ? TokenType::T_INTEGER : TokenType::T_FLOAT
  2782. );
  2784. return new AST\Literal(AST\Literal::NUMERIC, $this->lexer->token->value);
  2786. case TokenType::T_TRUE:
  2787. case TokenType::T_FALSE:
  2788. $this->match(
  2789. $this->lexer->isNextToken(TokenType::T_TRUE) ? TokenType::T_TRUE : TokenType::T_FALSE
  2790. );
  2792. return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token->value);
  2794. default:
  2795. $this->syntaxError('Literal');
  2796. }
  2797. }
  2799. /**
  2800. * InParameter ::= ArithmeticExpression | InputParameter
  2801. *
  2802. * @return AST\InputParameter|AST\ArithmeticExpression
  2803. */
  2804. public function InParameter()
  2805. {
  2806. assert($this->lexer->lookahead !== null);
  2807. if ($this->lexer->lookahead->type === TokenType::T_INPUT_PARAMETER) {
  2808. return $this->InputParameter();
  2809. }
  2811. return $this->ArithmeticExpression();
  2812. }
  2814. /**
  2815. * InputParameter ::= PositionalParameter | NamedParameter
  2816. *
  2817. * @return AST\InputParameter
  2818. */
  2819. public function InputParameter()
  2820. {
  2821. $this->match(TokenType::T_INPUT_PARAMETER);
  2822. assert($this->lexer->token !== null);
  2824. return new AST\InputParameter($this->lexer->token->value);
  2825. }
  2827. /**
  2828. * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
  2829. *
  2830. * @return AST\ArithmeticExpression
  2831. */
  2832. public function ArithmeticExpression()
  2833. {
  2834. $expr = new AST\ArithmeticExpression();
  2836. if ($this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS)) {
  2837. $peek = $this->lexer->glimpse();
  2838. assert($peek !== null);
  2840. if ($peek->type === TokenType::T_SELECT) {
  2841. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2842. $expr->subselect = $this->Subselect();
  2843. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2845. return $expr;
  2846. }
  2847. }
  2849. $expr->simpleArithmeticExpression = $this->SimpleArithmeticExpression();
  2851. return $expr;
  2852. }
  2854. /**
  2855. * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
  2856. *
  2857. * @return AST\SimpleArithmeticExpression|AST\ArithmeticTerm
  2858. */
  2859. public function SimpleArithmeticExpression()
  2860. {
  2861. $terms = [];
  2862. $terms[] = $this->ArithmeticTerm();
  2864. while (($isPlus = $this->lexer->isNextToken(TokenType::T_PLUS)) || $this->lexer->isNextToken(TokenType::T_MINUS)) {
  2865. $this->match($isPlus ? TokenType::T_PLUS : TokenType::T_MINUS);
  2867. assert($this->lexer->token !== null);
  2868. $terms[] = $this->lexer->token->value;
  2869. $terms[] = $this->ArithmeticTerm();
  2870. }
  2872. // Phase 1 AST optimization: Prevent AST\SimpleArithmeticExpression
  2873. // if only one AST\ArithmeticTerm is defined
  2874. if (count($terms) === 1) {
  2875. return $terms[0];
  2876. }
  2878. return new AST\SimpleArithmeticExpression($terms);
  2879. }
  2881. /**
  2882. * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
  2883. *
  2884. * @return AST\ArithmeticTerm
  2885. */
  2886. public function ArithmeticTerm()
  2887. {
  2888. $factors = [];
  2889. $factors[] = $this->ArithmeticFactor();
  2891. while (($isMult = $this->lexer->isNextToken(TokenType::T_MULTIPLY)) || $this->lexer->isNextToken(TokenType::T_DIVIDE)) {
  2892. $this->match($isMult ? TokenType::T_MULTIPLY : TokenType::T_DIVIDE);
  2894. assert($this->lexer->token !== null);
  2895. $factors[] = $this->lexer->token->value;
  2896. $factors[] = $this->ArithmeticFactor();
  2897. }
  2899. // Phase 1 AST optimization: Prevent AST\ArithmeticTerm
  2900. // if only one AST\ArithmeticFactor is defined
  2901. if (count($factors) === 1) {
  2902. return $factors[0];
  2903. }
  2905. return new AST\ArithmeticTerm($factors);
  2906. }
  2908. /**
  2909. * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
  2910. *
  2911. * @return AST\ArithmeticFactor
  2912. */
  2913. public function ArithmeticFactor()
  2914. {
  2915. $sign = null;
  2917. $isPlus = $this->lexer->isNextToken(TokenType::T_PLUS);
  2918. if ($isPlus || $this->lexer->isNextToken(TokenType::T_MINUS)) {
  2919. $this->match($isPlus ? TokenType::T_PLUS : TokenType::T_MINUS);
  2920. $sign = $isPlus;
  2921. }
  2923. $primary = $this->ArithmeticPrimary();
  2925. // Phase 1 AST optimization: Prevent AST\ArithmeticFactor
  2926. // if only one AST\ArithmeticPrimary is defined
  2927. if ($sign === null) {
  2928. return $primary;
  2929. }
  2931. return new AST\ArithmeticFactor($primary, $sign);
  2932. }
  2934. /**
  2935. * ArithmeticPrimary ::= SingleValuedPathExpression | Literal | ParenthesisExpression
  2936. * | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings
  2937. * | FunctionsReturningDatetime | IdentificationVariable | ResultVariable
  2938. * | InputParameter | CaseExpression
  2939. *
  2940. * @return AST\Node|string
  2941. */
  2942. public function ArithmeticPrimary()
  2943. {
  2944. if ($this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS)) {
  2945. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2947. $expr = $this->SimpleArithmeticExpression();
  2949. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2951. return new AST\ParenthesisExpression($expr);
  2952. }
  2954. if ($this->lexer->lookahead === null) {
  2955. $this->syntaxError('ArithmeticPrimary');
  2956. }
  2958. switch ($this->lexer->lookahead->type) {
  2959. case TokenType::T_COALESCE:
  2960. case TokenType::T_NULLIF:
  2961. case TokenType::T_CASE:
  2962. return $this->CaseExpression();
  2964. case TokenType::T_IDENTIFIER:
  2965. $peek = $this->lexer->glimpse();
  2967. if ($peek !== null && $peek->value === '(') {
  2968. return $this->FunctionDeclaration();
  2969. }
  2971. if ($peek !== null && $peek->value === '.') {
  2972. return $this->SingleValuedPathExpression();
  2973. }
  2975. if (isset($this->queryComponents[$this->lexer->lookahead->value]['resultVariable'])) {
  2976. return $this->ResultVariable();
  2977. }
  2979. return $this->StateFieldPathExpression();
  2981. case TokenType::T_INPUT_PARAMETER:
  2982. return $this->InputParameter();
  2984. default:
  2985. $peek = $this->lexer->glimpse();
  2987. if ($peek !== null && $peek->value === '(') {
  2988. return $this->FunctionDeclaration();
  2989. }
  2991. return $this->Literal();
  2992. }
  2993. }
  2995. /**
  2996. * StringExpression ::= StringPrimary | ResultVariable | "(" Subselect ")"
  2997. *
  2998. * @return AST\Subselect|AST\Node|string
  2999. */
  3000. public function StringExpression()
  3001. {
  3002. $peek = $this->lexer->glimpse();
  3003. assert($peek !== null);
  3005. // Subselect
  3006. if ($this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS) && $peek->type === TokenType::T_SELECT) {
  3007. $this->match(TokenType::T_OPEN_PARENTHESIS);
  3008. $expr = $this->Subselect();
  3009. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3011. return $expr;
  3012. }
  3014. assert($this->lexer->lookahead !== null);
  3015. // ResultVariable (string)
  3016. if (
  3017. $this->lexer->isNextToken(TokenType::T_IDENTIFIER) &&
  3018. isset($this->queryComponents[$this->lexer->lookahead->value]['resultVariable'])
  3019. ) {
  3020. return $this->ResultVariable();
  3021. }
  3023. return $this->StringPrimary();
  3024. }
  3026. /**
  3027. * StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression
  3028. *
  3029. * @return AST\Node
  3030. */
  3031. public function StringPrimary()
  3032. {
  3033. assert($this->lexer->lookahead !== null);
  3034. $lookaheadType = $this->lexer->lookahead->type;
  3036. switch ($lookaheadType) {
  3037. case TokenType::T_IDENTIFIER:
  3038. $peek = $this->lexer->glimpse();
  3039. assert($peek !== null);
  3041. if ($peek->value === '.') {
  3042. return $this->StateFieldPathExpression();
  3043. }
  3045. if ($peek->value === '(') {
  3046. // do NOT directly go to FunctionsReturningString() because it doesn't check for custom functions.
  3047. return $this->FunctionDeclaration();
  3048. }
  3050. $this->syntaxError("'.' or '('");
  3051. break;
  3053. case TokenType::T_STRING:
  3054. $this->match(TokenType::T_STRING);
  3055. assert($this->lexer->token !== null);
  3057. return new AST\Literal(AST\Literal::STRING, $this->lexer->token->value);
  3059. case TokenType::T_INPUT_PARAMETER:
  3060. return $this->InputParameter();
  3062. case TokenType::T_CASE:
  3063. case TokenType::T_COALESCE:
  3064. case TokenType::T_NULLIF:
  3065. return $this->CaseExpression();
  3067. default:
  3068. assert($lookaheadType !== null);
  3069. if ($this->isAggregateFunction($lookaheadType)) {
  3070. return $this->AggregateExpression();
  3071. }
  3072. }
  3074. $this->syntaxError(
  3075. 'StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression'
  3076. );
  3077. }
  3079. /**
  3080. * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  3081. *
  3082. * @return AST\InputParameter|AST\PathExpression
  3083. */
  3084. public function EntityExpression()
  3085. {
  3086. $glimpse = $this->lexer->glimpse();
  3087. assert($glimpse !== null);
  3089. if ($this->lexer->isNextToken(TokenType::T_IDENTIFIER) && $glimpse->value === '.') {
  3090. return $this->SingleValuedAssociationPathExpression();
  3091. }
  3093. return $this->SimpleEntityExpression();
  3094. }
  3096. /**
  3097. * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  3098. *
  3099. * @return AST\InputParameter|AST\PathExpression
  3100. */
  3101. public function SimpleEntityExpression()
  3102. {
  3103. if ($this->lexer->isNextToken(TokenType::T_INPUT_PARAMETER)) {
  3104. return $this->InputParameter();
  3105. }
  3107. return $this->StateFieldPathExpression();
  3108. }
  3110. /**
  3111. * AggregateExpression ::=
  3112. * ("AVG" | "MAX" | "MIN" | "SUM" | "COUNT") "(" ["DISTINCT"] SimpleArithmeticExpression ")"
  3113. *
  3114. * @return AST\AggregateExpression
  3115. */
  3116. public function AggregateExpression()
  3117. {
  3118. assert($this->lexer->lookahead !== null);
  3119. $lookaheadType = $this->lexer->lookahead->type;
  3120. $isDistinct = false;
  3122. if (! in_array($lookaheadType, [TokenType::T_COUNT, TokenType::T_AVG, TokenType::T_MAX, TokenType::T_MIN, TokenType::T_SUM], true)) {
  3123. $this->syntaxError('One of: MAX, MIN, AVG, SUM, COUNT');
  3124. }
  3126. $this->match($lookaheadType);
  3127. assert($this->lexer->token !== null);
  3128. $functionName = $this->lexer->token->value;
  3129. $this->match(TokenType::T_OPEN_PARENTHESIS);
  3131. if ($this->lexer->isNextToken(TokenType::T_DISTINCT)) {
  3132. $this->match(TokenType::T_DISTINCT);
  3133. $isDistinct = true;
  3134. }
  3136. $pathExp = $this->SimpleArithmeticExpression();
  3138. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3140. return new AST\AggregateExpression($functionName, $pathExp, $isDistinct);
  3141. }
  3143. /**
  3144. * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
  3145. *
  3146. * @return AST\QuantifiedExpression
  3147. */
  3148. public function QuantifiedExpression()
  3149. {
  3150. assert($this->lexer->lookahead !== null);
  3151. $lookaheadType = $this->lexer->lookahead->type;
  3152. $value = $this->lexer->lookahead->value;
  3154. if (! in_array($lookaheadType, [TokenType::T_ALL, TokenType::T_ANY, TokenType::T_SOME], true)) {
  3155. $this->syntaxError('ALL, ANY or SOME');
  3156. }
  3158. $this->match($lookaheadType);
  3159. $this->match(TokenType::T_OPEN_PARENTHESIS);
  3161. $qExpr = new AST\QuantifiedExpression($this->Subselect());
  3162. $qExpr->type = $value;
  3164. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3166. return $qExpr;
  3167. }
  3169. /**
  3170. * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
  3171. *
  3172. * @return AST\BetweenExpression
  3173. */
  3174. public function BetweenExpression()
  3175. {
  3176. $not = false;
  3177. $arithExpr1 = $this->ArithmeticExpression();
  3179. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3180. $this->match(TokenType::T_NOT);
  3181. $not = true;
  3182. }
  3184. $this->match(TokenType::T_BETWEEN);
  3185. $arithExpr2 = $this->ArithmeticExpression();
  3186. $this->match(TokenType::T_AND);
  3187. $arithExpr3 = $this->ArithmeticExpression();
  3189. return new AST\BetweenExpression($arithExpr1, $arithExpr2, $arithExpr3, $not);
  3190. }
  3192. /**
  3193. * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )
  3194. *
  3195. * @return AST\ComparisonExpression
  3196. */
  3197. public function ComparisonExpression()
  3198. {
  3199. $this->lexer->glimpse();
  3201. $leftExpr = $this->ArithmeticExpression();
  3202. $operator = $this->ComparisonOperator();
  3203. $rightExpr = $this->isNextAllAnySome()
  3204. ? $this->QuantifiedExpression()
  3205. : $this->ArithmeticExpression();
  3207. return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
  3208. }
  3210. /**
  3211. * InExpression ::= SingleValuedPathExpression ["NOT"] "IN" "(" (InParameter {"," InParameter}* | Subselect) ")"
  3212. *
  3213. * @return AST\InListExpression|AST\InSubselectExpression
  3214. */
  3215. public function InExpression()
  3216. {
  3217. $expression = $this->ArithmeticExpression();
  3219. $not = false;
  3220. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3221. $this->match(TokenType::T_NOT);
  3222. $not = true;
  3223. }
  3225. $this->match(TokenType::T_IN);
  3226. $this->match(TokenType::T_OPEN_PARENTHESIS);
  3228. if ($this->lexer->isNextToken(TokenType::T_SELECT)) {
  3229. $inExpression = new AST\InSubselectExpression(
  3230. $expression,
  3231. $this->Subselect(),
  3232. $not
  3233. );
  3234. } else {
  3235. $literals = [$this->InParameter()];
  3237. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  3238. $this->match(TokenType::T_COMMA);
  3239. $literals[] = $this->InParameter();
  3240. }
  3242. $inExpression = new AST\InListExpression(
  3243. $expression,
  3244. $literals,
  3245. $not
  3246. );
  3247. }
  3249. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3251. return $inExpression;
  3252. }
  3254. /**
  3255. * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
  3256. *
  3257. * @return AST\InstanceOfExpression
  3258. */
  3259. public function InstanceOfExpression()
  3260. {
  3261. $identificationVariable = $this->IdentificationVariable();
  3263. $not = false;
  3264. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3265. $this->match(TokenType::T_NOT);
  3266. $not = true;
  3267. }
  3269. $this->match(TokenType::T_INSTANCE);
  3270. $this->match(TokenType::T_OF);
  3272. $exprValues = $this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS)
  3273. ? $this->InstanceOfParameterList()
  3274. : [$this->InstanceOfParameter()];
  3276. return new AST\InstanceOfExpression(
  3277. $identificationVariable,
  3278. $exprValues,
  3279. $not
  3280. );
  3281. }
  3283. /** @return non-empty-list<AST\InputParameter|string> */
  3284. public function InstanceOfParameterList(): array
  3285. {
  3286. $this->match(TokenType::T_OPEN_PARENTHESIS);
  3288. $exprValues = [$this->InstanceOfParameter()];
  3290. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  3291. $this->match(TokenType::T_COMMA);
  3293. $exprValues[] = $this->InstanceOfParameter();
  3294. }
  3296. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3298. return $exprValues;
  3299. }
  3301. /**
  3302. * InstanceOfParameter ::= AbstractSchemaName | InputParameter
  3303. *
  3304. * @return AST\InputParameter|string
  3305. */
  3306. public function InstanceOfParameter()
  3307. {
  3308. if ($this->lexer->isNextToken(TokenType::T_INPUT_PARAMETER)) {
  3309. $this->match(TokenType::T_INPUT_PARAMETER);
  3310. assert($this->lexer->token !== null);
  3312. return new AST\InputParameter($this->lexer->token->value);
  3313. }
  3315. $abstractSchemaName = $this->AbstractSchemaName();
  3317. $this->validateAbstractSchemaName($abstractSchemaName);
  3319. return $abstractSchemaName;
  3320. }
  3322. /**
  3323. * LikeExpression ::= StringExpression ["NOT"] "LIKE" StringPrimary ["ESCAPE" char]
  3324. *
  3325. * @return AST\LikeExpression
  3326. */
  3327. public function LikeExpression()
  3328. {
  3329. $stringExpr = $this->StringExpression();
  3330. $not = false;
  3332. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3333. $this->match(TokenType::T_NOT);
  3334. $not = true;
  3335. }
  3337. $this->match(TokenType::T_LIKE);
  3339. if ($this->lexer->isNextToken(TokenType::T_INPUT_PARAMETER)) {
  3340. $this->match(TokenType::T_INPUT_PARAMETER);
  3341. assert($this->lexer->token !== null);
  3342. $stringPattern = new AST\InputParameter($this->lexer->token->value);
  3343. } else {
  3344. $stringPattern = $this->StringPrimary();
  3345. }
  3347. $escapeChar = null;
  3349. if ($this->lexer->lookahead !== null && $this->lexer->lookahead->type === TokenType::T_ESCAPE) {
  3350. $this->match(TokenType::T_ESCAPE);
  3351. $this->match(TokenType::T_STRING);
  3352. assert($this->lexer->token !== null);
  3354. $escapeChar = new AST\Literal(AST\Literal::STRING, $this->lexer->token->value);
  3355. }
  3357. return new AST\LikeExpression($stringExpr, $stringPattern, $escapeChar, $not);
  3358. }
  3360. /**
  3361. * NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) "IS" ["NOT"] "NULL"
  3362. *
  3363. * @return AST\NullComparisonExpression
  3364. */
  3365. public function NullComparisonExpression()
  3366. {
  3367. switch (true) {
  3368. case $this->lexer->isNextToken(TokenType::T_INPUT_PARAMETER):
  3369. $this->match(TokenType::T_INPUT_PARAMETER);
  3370. assert($this->lexer->token !== null);
  3372. $expr = new AST\InputParameter($this->lexer->token->value);
  3373. break;
  3375. case $this->lexer->isNextToken(TokenType::T_NULLIF):
  3376. $expr = $this->NullIfExpression();
  3377. break;
  3379. case $this->lexer->isNextToken(TokenType::T_COALESCE):
  3380. $expr = $this->CoalesceExpression();
  3381. break;
  3383. case $this->isFunction():
  3384. $expr = $this->FunctionDeclaration();
  3385. break;
  3387. default:
  3388. // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  3389. $glimpse = $this->lexer->glimpse();
  3390. assert($glimpse !== null);
  3392. if ($glimpse->type === TokenType::T_DOT) {
  3393. $expr = $this->SingleValuedPathExpression();
  3395. // Leave switch statement
  3396. break;
  3397. }
  3399. assert($this->lexer->lookahead !== null);
  3400. $lookaheadValue = $this->lexer->lookahead->value;
  3402. // Validate existing component
  3403. if (! isset($this->queryComponents[$lookaheadValue])) {
  3404. $this->semanticalError('Cannot add having condition on undefined result variable.');
  3405. }
  3407. // Validate SingleValuedPathExpression (ie.: "product")
  3408. if (isset($this->queryComponents[$lookaheadValue]['metadata'])) {
  3409. $expr = $this->SingleValuedPathExpression();
  3410. break;
  3411. }
  3413. // Validating ResultVariable
  3414. if (! isset($this->queryComponents[$lookaheadValue]['resultVariable'])) {
  3415. $this->semanticalError('Cannot add having condition on a non result variable.');
  3416. }
  3418. $expr = $this->ResultVariable();
  3419. break;
  3420. }
  3422. $this->match(TokenType::T_IS);
  3424. $not = false;
  3425. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3426. $this->match(TokenType::T_NOT);
  3428. $not = true;
  3429. }
  3431. $this->match(TokenType::T_NULL);
  3433. return new AST\NullComparisonExpression($expr, $not);
  3434. }
  3436. /**
  3437. * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
  3438. *
  3439. * @return AST\ExistsExpression
  3440. */
  3441. public function ExistsExpression()
  3442. {
  3443. $not = false;
  3445. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3446. $this->match(TokenType::T_NOT);
  3447. $not = true;
  3448. }
  3450. $this->match(TokenType::T_EXISTS);
  3451. $this->match(TokenType::T_OPEN_PARENTHESIS);
  3453. $subselect = $this->Subselect();
  3455. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3457. return new AST\ExistsExpression($subselect, $not);
  3458. }
  3460. /**
  3461. * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
  3462. *
  3463. * @return string
  3464. */
  3465. public function ComparisonOperator()
  3466. {
  3467. assert($this->lexer->lookahead !== null);
  3468. switch ($this->lexer->lookahead->value) {
  3469. case '=':
  3470. $this->match(TokenType::T_EQUALS);
  3472. return '=';
  3474. case '<':
  3475. $this->match(TokenType::T_LOWER_THAN);
  3476. $operator = '<';
  3478. if ($this->lexer->isNextToken(TokenType::T_EQUALS)) {
  3479. $this->match(TokenType::T_EQUALS);
  3480. $operator .= '=';
  3481. } elseif ($this->lexer->isNextToken(TokenType::T_GREATER_THAN)) {
  3482. $this->match(TokenType::T_GREATER_THAN);
  3483. $operator .= '>';
  3484. }
  3486. return $operator;
  3488. case '>':
  3489. $this->match(TokenType::T_GREATER_THAN);
  3490. $operator = '>';
  3492. if ($this->lexer->isNextToken(TokenType::T_EQUALS)) {
  3493. $this->match(TokenType::T_EQUALS);
  3494. $operator .= '=';
  3495. }
  3497. return $operator;
  3499. case '!':
  3500. $this->match(TokenType::T_NEGATE);
  3501. $this->match(TokenType::T_EQUALS);
  3503. return '<>';
  3505. default:
  3506. $this->syntaxError('=, <, <=, <>, >, >=, !=');
  3507. }
  3508. }
  3510. /**
  3511. * FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDatetime
  3512. *
  3513. * @return Functions\FunctionNode
  3514. */
  3515. public function FunctionDeclaration()
  3516. {
  3517. assert($this->lexer->lookahead !== null);
  3518. $token = $this->lexer->lookahead;
  3519. $funcName = strtolower($token->value);
  3521. $customFunctionDeclaration = $this->CustomFunctionDeclaration();
  3523. // Check for custom functions functions first!
  3524. switch (true) {
  3525. case $customFunctionDeclaration !== null:
  3526. return $customFunctionDeclaration;
  3528. case isset(self::$stringFunctions[$funcName]):
  3529. return $this->FunctionsReturningStrings();
  3531. case isset(self::$numericFunctions[$funcName]):
  3532. return $this->FunctionsReturningNumerics();
  3534. case isset(self::$datetimeFunctions[$funcName]):
  3535. return $this->FunctionsReturningDatetime();
  3537. default:
  3538. $this->syntaxError('known function', $token);
  3539. }
  3540. }
  3542. /**
  3543. * Helper function for FunctionDeclaration grammar rule.
  3544. */
  3545. private function CustomFunctionDeclaration(): ?Functions\FunctionNode
  3546. {
  3547. assert($this->lexer->lookahead !== null);
  3548. $token = $this->lexer->lookahead;
  3549. $funcName = strtolower($token->value);
  3551. // Check for custom functions afterwards
  3552. $config = $this->em->getConfiguration();
  3554. switch (true) {
  3555. case $config->getCustomStringFunction($funcName) !== null:
  3556. return $this->CustomFunctionsReturningStrings();
  3558. case $config->getCustomNumericFunction($funcName) !== null:
  3559. return $this->CustomFunctionsReturningNumerics();
  3561. case $config->getCustomDatetimeFunction($funcName) !== null:
  3562. return $this->CustomFunctionsReturningDatetime();
  3564. default:
  3565. return null;
  3566. }
  3567. }
  3569. /**
  3570. * FunctionsReturningNumerics ::=
  3571. * "LENGTH" "(" StringPrimary ")" |
  3572. * "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")" |
  3573. * "ABS" "(" SimpleArithmeticExpression ")" |
  3574. * "SQRT" "(" SimpleArithmeticExpression ")" |
  3575. * "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3576. * "SIZE" "(" CollectionValuedPathExpression ")" |
  3577. * "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3578. * "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3579. * "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
  3580. *
  3581. * @return Functions\FunctionNode
  3582. */
  3583. public function FunctionsReturningNumerics()
  3584. {
  3585. assert($this->lexer->lookahead !== null);
  3586. $funcNameLower = strtolower($this->lexer->lookahead->value);
  3587. $funcClass = self::$numericFunctions[$funcNameLower];
  3589. $function = new $funcClass($funcNameLower);
  3590. $function->parse($this);
  3592. return $function;
  3593. }
  3595. /** @return Functions\FunctionNode */
  3596. public function CustomFunctionsReturningNumerics()
  3597. {
  3598. assert($this->lexer->lookahead !== null);
  3599. // getCustomNumericFunction is case-insensitive
  3600. $functionName = strtolower($this->lexer->lookahead->value);
  3601. $functionClass = $this->em->getConfiguration()->getCustomNumericFunction($functionName);
  3603. assert($functionClass !== null);
  3605. $function = is_string($functionClass)
  3606. ? new $functionClass($functionName)
  3607. : $functionClass($functionName);
  3609. $function->parse($this);
  3611. return $function;
  3612. }
  3614. /**
  3615. * FunctionsReturningDatetime ::=
  3616. * "CURRENT_DATE" |
  3617. * "CURRENT_TIME" |
  3618. * "CURRENT_TIMESTAMP" |
  3619. * "DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")" |
  3620. * "DATE_SUB" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
  3621. *
  3622. * @return Functions\FunctionNode
  3623. */
  3624. public function FunctionsReturningDatetime()
  3625. {
  3626. assert($this->lexer->lookahead !== null);
  3627. $funcNameLower = strtolower($this->lexer->lookahead->value);
  3628. $funcClass = self::$datetimeFunctions[$funcNameLower];
  3630. $function = new $funcClass($funcNameLower);
  3631. $function->parse($this);
  3633. return $function;
  3634. }
  3636. /** @return Functions\FunctionNode */
  3637. public function CustomFunctionsReturningDatetime()
  3638. {
  3639. assert($this->lexer->lookahead !== null);
  3640. // getCustomDatetimeFunction is case-insensitive
  3641. $functionName = $this->lexer->lookahead->value;
  3642. $functionClass = $this->em->getConfiguration()->getCustomDatetimeFunction($functionName);
  3644. assert($functionClass !== null);
  3646. $function = is_string($functionClass)
  3647. ? new $functionClass($functionName)
  3648. : $functionClass($functionName);
  3650. $function->parse($this);
  3652. return $function;
  3653. }
  3655. /**
  3656. * FunctionsReturningStrings ::=
  3657. * "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary}* ")" |
  3658. * "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3659. * "TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")" |
  3660. * "LOWER" "(" StringPrimary ")" |
  3661. * "UPPER" "(" StringPrimary ")" |
  3662. * "IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
  3663. *
  3664. * @return Functions\FunctionNode
  3665. */
  3666. public function FunctionsReturningStrings()
  3667. {
  3668. assert($this->lexer->lookahead !== null);
  3669. $funcNameLower = strtolower($this->lexer->lookahead->value);
  3670. $funcClass = self::$stringFunctions[$funcNameLower];
  3672. $function = new $funcClass($funcNameLower);
  3673. $function->parse($this);
  3675. return $function;
  3676. }
  3678. /** @return Functions\FunctionNode */
  3679. public function CustomFunctionsReturningStrings()
  3680. {
  3681. assert($this->lexer->lookahead !== null);
  3682. // getCustomStringFunction is case-insensitive
  3683. $functionName = $this->lexer->lookahead->value;
  3684. $functionClass = $this->em->getConfiguration()->getCustomStringFunction($functionName);
  3686. assert($functionClass !== null);
  3688. $function = is_string($functionClass)
  3689. ? new $functionClass($functionName)
  3690. : $functionClass($functionName);
  3692. $function->parse($this);
  3694. return $function;
  3695. }
  3697. private function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
  3698. {
  3699. if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
  3700. throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
  3701. }
  3703. return $this->queryComponents[$dqlAlias]['metadata'];
  3704. }
  3705. }