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

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 LogicException;
  14. use ReflectionClass;
  16. use function array_intersect;
  17. use function array_search;
  18. use function assert;
  19. use function class_exists;
  20. use function count;
  21. use function explode;
  22. use function implode;
  23. use function in_array;
  24. use function interface_exists;
  25. use function is_string;
  26. use function sprintf;
  27. use function str_contains;
  28. use function strlen;
  29. use function strpos;
  30. use function strrpos;
  31. use function strtolower;
  32. use function substr;
  34. /**
  35. * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  36. * Parses a DQL query, reports any errors in it, and generates an AST.
  37. *
  38. * @psalm-type DqlToken = Token<Lexer::T_*, string>
  39. * @psalm-type QueryComponent = array{
  40. * metadata?: ClassMetadata<object>,
  41. * parent?: string|null,
  42. * relation?: mixed[]|null,
  43. * map?: string|null,
  44. * resultVariable?: AST\Node|string,
  45. * nestingLevel: int,
  46. * token: DqlToken,
  47. * }
  48. */
  49. class Parser
  50. {
  51. /**
  52. * @readonly Maps BUILT-IN string function names to AST class names.
  53. * @psalm-var array<string, class-string<Functions\FunctionNode>>
  54. */
  55. private static $stringFunctions = [
  56. 'concat' => Functions\ConcatFunction::class,
  57. 'substring' => Functions\SubstringFunction::class,
  58. 'trim' => Functions\TrimFunction::class,
  59. 'lower' => Functions\LowerFunction::class,
  60. 'upper' => Functions\UpperFunction::class,
  61. 'identity' => Functions\IdentityFunction::class,
  62. ];
  64. /**
  65. * @readonly Maps BUILT-IN numeric function names to AST class names.
  66. * @psalm-var array<string, class-string<Functions\FunctionNode>>
  67. */
  68. private static $numericFunctions = [
  69. 'length' => Functions\LengthFunction::class,
  70. 'locate' => Functions\LocateFunction::class,
  71. 'abs' => Functions\AbsFunction::class,
  72. 'sqrt' => Functions\SqrtFunction::class,
  73. 'mod' => Functions\ModFunction::class,
  74. 'size' => Functions\SizeFunction::class,
  75. 'date_diff' => Functions\DateDiffFunction::class,
  76. 'bit_and' => Functions\BitAndFunction::class,
  77. 'bit_or' => Functions\BitOrFunction::class,
  79. // Aggregate functions
  80. 'min' => Functions\MinFunction::class,
  81. 'max' => Functions\MaxFunction::class,
  82. 'avg' => Functions\AvgFunction::class,
  83. 'sum' => Functions\SumFunction::class,
  84. 'count' => Functions\CountFunction::class,
  85. ];
  87. /**
  88. * @readonly Maps BUILT-IN datetime function names to AST class names.
  89. * @psalm-var array<string, class-string<Functions\FunctionNode>>
  90. */
  91. private static $datetimeFunctions = [
  92. 'current_date' => Functions\CurrentDateFunction::class,
  93. 'current_time' => Functions\CurrentTimeFunction::class,
  94. 'current_timestamp' => Functions\CurrentTimestampFunction::class,
  95. 'date_add' => Functions\DateAddFunction::class,
  96. 'date_sub' => Functions\DateSubFunction::class,
  97. ];
  99. /*
  100. * Expressions that were encountered during parsing of identifiers and expressions
  101. * and still need to be validated.
  102. */
  104. /** @psalm-var list<array{token: DqlToken|null, expression: mixed, nestingLevel: int}> */
  105. private $deferredIdentificationVariables = [];
  107. /** @psalm-var list<array{token: DqlToken|null, expression: AST\PartialObjectExpression, nestingLevel: int}> */
  108. private $deferredPartialObjectExpressions = [];
  110. /** @psalm-var list<array{token: DqlToken|null, expression: AST\PathExpression, nestingLevel: int}> */
  111. private $deferredPathExpressions = [];
  113. /** @psalm-var list<array{token: DqlToken|null, expression: mixed, nestingLevel: int}> */
  114. private $deferredResultVariables = [];
  116. /** @psalm-var list<array{token: DqlToken|null, expression: AST\NewObjectExpression, nestingLevel: int}> */
  117. private $deferredNewObjectExpressions = [];
  119. /**
  120. * The lexer.
  121. *
  122. * @var Lexer
  123. */
  124. private $lexer;
  126. /**
  127. * The parser result.
  128. *
  129. * @var ParserResult
  130. */
  131. private $parserResult;
  133. /**
  134. * The EntityManager.
  135. *
  136. * @var EntityManagerInterface
  137. */
  138. private $em;
  140. /**
  141. * The Query to parse.
  142. *
  143. * @var Query
  144. */
  145. private $query;
  147. /**
  148. * Map of declared query components in the parsed query.
  149. *
  150. * @psalm-var array<string, QueryComponent>
  151. */
  152. private $queryComponents = [];
  154. /**
  155. * Keeps the nesting level of defined ResultVariables.
  156. *
  157. * @var int
  158. */
  159. private $nestingLevel = 0;
  161. /**
  162. * Any additional custom tree walkers that modify the AST.
  163. *
  164. * @psalm-var list<class-string<TreeWalker>>
  165. */
  166. private $customTreeWalkers = [];
  168. /**
  169. * The custom last tree walker, if any, that is responsible for producing the output.
  170. *
  171. * @var class-string<SqlWalker>|null
  172. */
  173. private $customOutputWalker;
  175. /** @psalm-var array<string, AST\SelectExpression> */
  176. private $identVariableExpressions = [];
  178. /**
  179. * Creates a new query parser object.
  180. *
  181. * @param Query $query The Query to parse.
  182. */
  183. public function __construct(Query $query)
  184. {
  185. $this->query = $query;
  186. $this->em = $query->getEntityManager();
  187. $this->lexer = new Lexer((string) $query->getDQL());
  188. $this->parserResult = new ParserResult();
  189. }
  191. /**
  192. * Sets a custom tree walker that produces output.
  193. * This tree walker will be run last over the AST, after any other walkers.
  194. *
  195. * @param string $className
  196. * @psalm-param class-string<SqlWalker> $className
  197. *
  198. * @return void
  199. */
  200. public function setCustomOutputTreeWalker($className)
  201. {
  202. $this->customOutputWalker = $className;
  203. }
  205. /**
  206. * Adds a custom tree walker for modifying the AST.
  207. *
  208. * @param string $className
  209. * @psalm-param class-string<TreeWalker> $className
  210. *
  211. * @return void
  212. */
  213. public function addCustomTreeWalker($className)
  214. {
  215. $this->customTreeWalkers[] = $className;
  216. }
  218. /**
  219. * Gets the lexer used by the parser.
  220. *
  221. * @return Lexer
  222. */
  223. public function getLexer()
  224. {
  225. return $this->lexer;
  226. }
  228. /**
  229. * Gets the ParserResult that is being filled with information during parsing.
  230. *
  231. * @return ParserResult
  232. */
  233. public function getParserResult()
  234. {
  235. return $this->parserResult;
  236. }
  238. /**
  239. * Gets the EntityManager used by the parser.
  240. *
  241. * @return EntityManagerInterface
  242. */
  243. public function getEntityManager()
  244. {
  245. return $this->em;
  246. }
  248. /**
  249. * Parses and builds AST for the given Query.
  250. *
  251. * @return AST\SelectStatement|AST\UpdateStatement|AST\DeleteStatement
  252. */
  253. public function getAST()
  254. {
  255. // Parse & build AST
  256. $AST = $this->QueryLanguage();
  258. // Process any deferred validations of some nodes in the AST.
  259. // This also allows post-processing of the AST for modification purposes.
  260. $this->processDeferredIdentificationVariables();
  262. if ($this->deferredPartialObjectExpressions) {
  263. $this->processDeferredPartialObjectExpressions();
  264. }
  266. if ($this->deferredPathExpressions) {
  267. $this->processDeferredPathExpressions();
  268. }
  270. if ($this->deferredResultVariables) {
  271. $this->processDeferredResultVariables();
  272. }
  274. if ($this->deferredNewObjectExpressions) {
  275. $this->processDeferredNewObjectExpressions($AST);
  276. }
  278. $this->processRootEntityAliasSelected();
  280. // TODO: Is there a way to remove this? It may impact the mixed hydration resultset a lot!
  281. $this->fixIdentificationVariableOrder($AST);
  283. return $AST;
  284. }
  286. /**
  287. * Attempts to match the given token with the current lookahead token.
  288. *
  289. * If they match, updates the lookahead token; otherwise raises a syntax
  290. * error.
  291. *
  292. * @param Lexer::T_* $token The token type.
  293. *
  294. * @return void
  295. *
  296. * @throws QueryException If the tokens don't match.
  297. */
  298. public function match($token)
  299. {
  300. $lookaheadType = $this->lexer->lookahead['type'] ?? null;
  302. // Short-circuit on first condition, usually types match
  303. if ($lookaheadType === $token) {
  304. $this->lexer->moveNext();
  306. return;
  307. }
  309. // If parameter is not identifier (1-99) must be exact match
  310. if ($token < Lexer::T_IDENTIFIER) {
  311. $this->syntaxError($this->lexer->getLiteral($token));
  312. }
  314. // If parameter is keyword (200+) must be exact match
  315. if ($token > Lexer::T_IDENTIFIER) {
  316. $this->syntaxError($this->lexer->getLiteral($token));
  317. }
  319. // If parameter is T_IDENTIFIER, then matches T_IDENTIFIER (100) and keywords (200+)
  320. if ($token === Lexer::T_IDENTIFIER && $lookaheadType < Lexer::T_IDENTIFIER) {
  321. $this->syntaxError($this->lexer->getLiteral($token));
  322. }
  324. $this->lexer->moveNext();
  325. }
  327. /**
  328. * Frees this parser, enabling it to be reused.
  329. *
  330. * @param bool $deep Whether to clean peek and reset errors.
  331. * @param int $position Position to reset.
  332. *
  333. * @return void
  334. */
  335. public function free($deep = false, $position = 0)
  336. {
  337. // WARNING! Use this method with care. It resets the scanner!
  338. $this->lexer->resetPosition($position);
  340. // Deep = true cleans peek and also any previously defined errors
  341. if ($deep) {
  342. $this->lexer->resetPeek();
  343. }
  345. $this->lexer->token = null;
  346. $this->lexer->lookahead = null;
  347. }
  349. /**
  350. * Parses a query string.
  351. *
  352. * @return ParserResult
  353. */
  354. public function parse()
  355. {
  356. $AST = $this->getAST();
  358. $customWalkers = $this->query->getHint(Query::HINT_CUSTOM_TREE_WALKERS);
  359. if ($customWalkers !== false) {
  360. $this->customTreeWalkers = $customWalkers;
  361. }
  363. $customOutputWalker = $this->query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER);
  364. if ($customOutputWalker !== false) {
  365. $this->customOutputWalker = $customOutputWalker;
  366. }
  368. // Run any custom tree walkers over the AST
  369. if ($this->customTreeWalkers) {
  370. $treeWalkerChain = new TreeWalkerChain($this->query, $this->parserResult, $this->queryComponents);
  372. foreach ($this->customTreeWalkers as $walker) {
  373. $treeWalkerChain->addTreeWalker($walker);
  374. }
  376. switch (true) {
  377. case $AST instanceof AST\UpdateStatement:
  378. $treeWalkerChain->walkUpdateStatement($AST);
  379. break;
  381. case $AST instanceof AST\DeleteStatement:
  382. $treeWalkerChain->walkDeleteStatement($AST);
  383. break;
  385. case $AST instanceof AST\SelectStatement:
  386. default:
  387. $treeWalkerChain->walkSelectStatement($AST);
  388. }
  390. $this->queryComponents = $treeWalkerChain->getQueryComponents();
  391. }
  393. $outputWalkerClass = $this->customOutputWalker ?: SqlWalker::class;
  394. $outputWalker = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
  396. // Assign an SQL executor to the parser result
  397. $this->parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
  399. return $this->parserResult;
  400. }
  402. /**
  403. * Fixes order of identification variables.
  404. *
  405. * They have to appear in the select clause in the same order as the
  406. * declarations (from ... x join ... y join ... z ...) appear in the query
  407. * as the hydration process relies on that order for proper operation.
  408. *
  409. * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST
  410. */
  411. private function fixIdentificationVariableOrder(AST\Node $AST): void
  412. {
  413. if (count($this->identVariableExpressions) <= 1) {
  414. return;
  415. }
  417. assert($AST instanceof AST\SelectStatement);
  419. foreach ($this->queryComponents as $dqlAlias => $qComp) {
  420. if (! isset($this->identVariableExpressions[$dqlAlias])) {
  421. continue;
  422. }
  424. $expr = $this->identVariableExpressions[$dqlAlias];
  425. $key = array_search($expr, $AST->selectClause->selectExpressions, true);
  427. unset($AST->selectClause->selectExpressions[$key]);
  429. $AST->selectClause->selectExpressions[] = $expr;
  430. }
  431. }
  433. /**
  434. * Generates a new syntax error.
  435. *
  436. * @param string $expected Expected string.
  437. * @param mixed[]|null $token Got token.
  438. * @psalm-param DqlToken|null $token
  439. *
  440. * @return void
  441. * @psalm-return no-return
  442. *
  443. * @throws QueryException
  444. */
  445. public function syntaxError($expected = '', $token = null)
  446. {
  447. if ($token === null) {
  448. $token = $this->lexer->lookahead;
  449. }
  451. $tokenPos = $token['position'] ?? '-1';
  453. $message = sprintf('line 0, col %d: Error: ', $tokenPos);
  454. $message .= $expected !== '' ? sprintf('Expected %s, got ', $expected) : 'Unexpected ';
  455. $message .= $this->lexer->lookahead === null ? 'end of string.' : sprintf("'%s'", $token['value']);
  457. throw QueryException::syntaxError($message, QueryException::dqlError($this->query->getDQL() ?? ''));
  458. }
  460. /**
  461. * Generates a new semantical error.
  462. *
  463. * @param string $message Optional message.
  464. * @param mixed[]|null $token Optional token.
  465. * @psalm-param DqlToken|null $token
  466. *
  467. * @return void
  468. * @psalm-return no-return
  469. *
  470. * @throws QueryException
  471. */
  472. public function semanticalError($message = '', $token = null)
  473. {
  474. if ($token === null) {
  475. $token = $this->lexer->lookahead ?? ['position' => 0];
  476. }
  478. // Minimum exposed chars ahead of token
  479. $distance = 12;
  481. // Find a position of a final word to display in error string
  482. $dql = $this->query->getDQL();
  483. $length = strlen($dql);
  484. $pos = $token['position'] + $distance;
  485. $pos = strpos($dql, ' ', $length > $pos ? $pos : $length);
  486. $length = $pos !== false ? $pos - $token['position'] : $distance;
  488. $tokenPos = $token['position'] > 0 ? $token['position'] : '-1';
  489. $tokenStr = substr($dql, $token['position'], $length);
  491. // Building informative message
  492. $message = 'line 0, col ' . $tokenPos . " near '" . $tokenStr . "': Error: " . $message;
  494. throw QueryException::semanticalError($message, QueryException::dqlError($this->query->getDQL()));
  495. }
  497. /**
  498. * Peeks beyond the matched closing parenthesis and returns the first token after that one.
  499. *
  500. * @param bool $resetPeek Reset peek after finding the closing parenthesis.
  501. *
  502. * @return mixed[]
  503. * @psalm-return DqlToken|null
  504. */
  505. private function peekBeyondClosingParenthesis(bool $resetPeek = true)
  506. {
  507. $token = $this->lexer->peek();
  508. $numUnmatched = 1;
  510. while ($numUnmatched > 0 && $token !== null) {
  511. switch ($token['type']) {
  512. case Lexer::T_OPEN_PARENTHESIS:
  513. ++$numUnmatched;
  514. break;
  516. case Lexer::T_CLOSE_PARENTHESIS:
  517. --$numUnmatched;
  518. break;
  520. default:
  521. // Do nothing
  522. }
  524. $token = $this->lexer->peek();
  525. }
  527. if ($resetPeek) {
  528. $this->lexer->resetPeek();
  529. }
  531. return $token;
  532. }
  534. /**
  535. * Checks if the given token indicates a mathematical operator.
  536. *
  537. * @psalm-param DqlToken|null $token
  538. */
  539. private function isMathOperator($token): bool
  540. {
  541. return $token !== null && in_array($token['type'], [Lexer::T_PLUS, Lexer::T_MINUS, Lexer::T_DIVIDE, Lexer::T_MULTIPLY], true);
  542. }
  544. /**
  545. * Checks if the next-next (after lookahead) token starts a function.
  546. *
  547. * @return bool TRUE if the next-next tokens start a function, FALSE otherwise.
  548. */
  549. private function isFunction(): bool
  550. {
  551. assert($this->lexer->lookahead !== null);
  552. $lookaheadType = $this->lexer->lookahead['type'];
  553. $peek = $this->lexer->peek();
  555. $this->lexer->resetPeek();
  557. return $lookaheadType >= Lexer::T_IDENTIFIER && $peek !== null && $peek['type'] === Lexer::T_OPEN_PARENTHESIS;
  558. }
  560. /**
  561. * Checks whether the given token type indicates an aggregate function.
  562. *
  563. * @psalm-param Lexer::T_* $tokenType
  564. *
  565. * @return bool TRUE if the token type is an aggregate function, FALSE otherwise.
  566. */
  567. private function isAggregateFunction(int $tokenType): bool
  568. {
  569. return in_array(
  570. $tokenType,
  571. [Lexer::T_AVG, Lexer::T_MIN, Lexer::T_MAX, Lexer::T_SUM, Lexer::T_COUNT],
  572. true
  573. );
  574. }
  576. /**
  577. * Checks whether the current lookahead token of the lexer has the type T_ALL, T_ANY or T_SOME.
  578. */
  579. private function isNextAllAnySome(): bool
  580. {
  581. assert($this->lexer->lookahead !== null);
  583. return in_array(
  584. $this->lexer->lookahead['type'],
  585. [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME],
  586. true
  587. );
  588. }
  590. /**
  591. * Validates that the given <tt>IdentificationVariable</tt> is semantically correct.
  592. * It must exist in query components list.
  593. */
  594. private function processDeferredIdentificationVariables(): void
  595. {
  596. foreach ($this->deferredIdentificationVariables as $deferredItem) {
  597. $identVariable = $deferredItem['expression'];
  599. // Check if IdentificationVariable exists in queryComponents
  600. if (! isset($this->queryComponents[$identVariable])) {
  601. $this->semanticalError(
  602. sprintf("'%s' is not defined.", $identVariable),
  603. $deferredItem['token']
  604. );
  605. }
  607. $qComp = $this->queryComponents[$identVariable];
  609. // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  610. if (! isset($qComp['metadata'])) {
  611. $this->semanticalError(
  612. sprintf("'%s' does not point to a Class.", $identVariable),
  613. $deferredItem['token']
  614. );
  615. }
  617. // Validate if identification variable nesting level is lower or equal than the current one
  618. if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  619. $this->semanticalError(
  620. sprintf("'%s' is used outside the scope of its declaration.", $identVariable),
  621. $deferredItem['token']
  622. );
  623. }
  624. }
  625. }
  627. /**
  628. * Validates that the given <tt>NewObjectExpression</tt>.
  629. */
  630. private function processDeferredNewObjectExpressions(AST\SelectStatement $AST): void
  631. {
  632. foreach ($this->deferredNewObjectExpressions as $deferredItem) {
  633. $expression = $deferredItem['expression'];
  634. $token = $deferredItem['token'];
  635. $className = $expression->className;
  636. $args = $expression->args;
  637. $fromClassName = $AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName ?? null;
  639. // If the namespace is not given then assumes the first FROM entity namespace
  640. if (! str_contains($className, '\\') && ! class_exists($className) && is_string($fromClassName) && str_contains($fromClassName, '\\')) {
  641. $namespace = substr($fromClassName, 0, strrpos($fromClassName, '\\'));
  642. $fqcn = $namespace . '\\' . $className;
  644. if (class_exists($fqcn)) {
  645. $expression->className = $fqcn;
  646. $className = $fqcn;
  647. }
  648. }
  650. if (! class_exists($className)) {
  651. $this->semanticalError(sprintf('Class "%s" is not defined.', $className), $token);
  652. }
  654. $class = new ReflectionClass($className);
  656. if (! $class->isInstantiable()) {
  657. $this->semanticalError(sprintf('Class "%s" can not be instantiated.', $className), $token);
  658. }
  660. if ($class->getConstructor() === null) {
  661. $this->semanticalError(sprintf('Class "%s" has not a valid constructor.', $className), $token);
  662. }
  664. if ($class->getConstructor()->getNumberOfRequiredParameters() > count($args)) {
  665. $this->semanticalError(sprintf('Number of arguments does not match with "%s" constructor declaration.', $className), $token);
  666. }
  667. }
  668. }
  670. /**
  671. * Validates that the given <tt>PartialObjectExpression</tt> is semantically correct.
  672. * It must exist in query components list.
  673. */
  674. private function processDeferredPartialObjectExpressions(): void
  675. {
  676. foreach ($this->deferredPartialObjectExpressions as $deferredItem) {
  677. $expr = $deferredItem['expression'];
  678. $class = $this->getMetadataForDqlAlias($expr->identificationVariable);
  680. foreach ($expr->partialFieldSet as $field) {
  681. if (isset($class->fieldMappings[$field])) {
  682. continue;
  683. }
  685. if (
  686. isset($class->associationMappings[$field]) &&
  687. $class->associationMappings[$field]['isOwningSide'] &&
  688. $class->associationMappings[$field]['type'] & ClassMetadata::TO_ONE
  689. ) {
  690. continue;
  691. }
  693. $this->semanticalError(sprintf(
  694. "There is no mapped field named '%s' on class %s.",
  695. $field,
  696. $class->name
  697. ), $deferredItem['token']);
  698. }
  700. if (array_intersect($class->identifier, $expr->partialFieldSet) !== $class->identifier) {
  701. $this->semanticalError(
  702. 'The partial field selection of class ' . $class->name . ' must contain the identifier.',
  703. $deferredItem['token']
  704. );
  705. }
  706. }
  707. }
  709. /**
  710. * Validates that the given <tt>ResultVariable</tt> is semantically correct.
  711. * It must exist in query components list.
  712. */
  713. private function processDeferredResultVariables(): void
  714. {
  715. foreach ($this->deferredResultVariables as $deferredItem) {
  716. $resultVariable = $deferredItem['expression'];
  718. // Check if ResultVariable exists in queryComponents
  719. if (! isset($this->queryComponents[$resultVariable])) {
  720. $this->semanticalError(
  721. sprintf("'%s' is not defined.", $resultVariable),
  722. $deferredItem['token']
  723. );
  724. }
  726. $qComp = $this->queryComponents[$resultVariable];
  728. // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  729. if (! isset($qComp['resultVariable'])) {
  730. $this->semanticalError(
  731. sprintf("'%s' does not point to a ResultVariable.", $resultVariable),
  732. $deferredItem['token']
  733. );
  734. }
  736. // Validate if identification variable nesting level is lower or equal than the current one
  737. if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  738. $this->semanticalError(
  739. sprintf("'%s' is used outside the scope of its declaration.", $resultVariable),
  740. $deferredItem['token']
  741. );
  742. }
  743. }
  744. }
  746. /**
  747. * Validates that the given <tt>PathExpression</tt> is semantically correct for grammar rules:
  748. *
  749. * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  750. * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  751. * StateFieldPathExpression ::= IdentificationVariable "." StateField
  752. * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  753. * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  754. */
  755. private function processDeferredPathExpressions(): void
  756. {
  757. foreach ($this->deferredPathExpressions as $deferredItem) {
  758. $pathExpression = $deferredItem['expression'];
  760. $class = $this->getMetadataForDqlAlias($pathExpression->identificationVariable);
  762. $field = $pathExpression->field;
  763. if ($field === null) {
  764. $field = $pathExpression->field = $class->identifier[0];
  765. }
  767. // Check if field or association exists
  768. if (! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
  769. $this->semanticalError(
  770. 'Class ' . $class->name . ' has no field or association named ' . $field,
  771. $deferredItem['token']
  772. );
  773. }
  775. $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
  777. if (isset($class->associationMappings[$field])) {
  778. $assoc = $class->associationMappings[$field];
  780. $fieldType = $assoc['type'] & ClassMetadata::TO_ONE
  781. ? AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  782. : AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
  783. }
  785. // Validate if PathExpression is one of the expected types
  786. $expectedType = $pathExpression->expectedType;
  788. if (! ($expectedType & $fieldType)) {
  789. // We need to recognize which was expected type(s)
  790. $expectedStringTypes = [];
  792. // Validate state field type
  793. if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
  794. $expectedStringTypes[] = 'StateFieldPathExpression';
  795. }
  797. // Validate single valued association (*-to-one)
  798. if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
  799. $expectedStringTypes[] = 'SingleValuedAssociationField';
  800. }
  802. // Validate single valued association (*-to-many)
  803. if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
  804. $expectedStringTypes[] = 'CollectionValuedAssociationField';
  805. }
  807. // Build the error message
  808. $semanticalError = 'Invalid PathExpression. ';
  809. $semanticalError .= count($expectedStringTypes) === 1
  810. ? 'Must be a ' . $expectedStringTypes[0] . '.'
  811. : implode(' or ', $expectedStringTypes) . ' expected.';
  813. $this->semanticalError($semanticalError, $deferredItem['token']);
  814. }
  816. // We need to force the type in PathExpression
  817. $pathExpression->type = $fieldType;
  818. }
  819. }
  821. private function processRootEntityAliasSelected(): void
  822. {
  823. if (! count($this->identVariableExpressions)) {
  824. return;
  825. }
  827. foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
  828. if (isset($this->queryComponents[$dqlAlias]) && ! isset($this->queryComponents[$dqlAlias]['parent'])) {
  829. return;
  830. }
  831. }
  833. $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');
  834. }
  836. /**
  837. * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
  838. *
  839. * @return AST\SelectStatement|AST\UpdateStatement|AST\DeleteStatement
  840. */
  841. public function QueryLanguage()
  842. {
  843. $statement = null;
  845. $this->lexer->moveNext();
  847. switch ($this->lexer->lookahead['type'] ?? null) {
  848. case Lexer::T_SELECT:
  849. $statement = $this->SelectStatement();
  850. break;
  852. case Lexer::T_UPDATE:
  853. $statement = $this->UpdateStatement();
  854. break;
  856. case Lexer::T_DELETE:
  857. $statement = $this->DeleteStatement();
  858. break;
  860. default:
  861. $this->syntaxError('SELECT, UPDATE or DELETE');
  862. break;
  863. }
  865. // Check for end of string
  866. if ($this->lexer->lookahead !== null) {
  867. $this->syntaxError('end of string');
  868. }
  870. return $statement;
  871. }
  873. /**
  874. * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  875. *
  876. * @return AST\SelectStatement
  877. */
  878. public function SelectStatement()
  879. {
  880. $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());
  882. $selectStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  883. $selectStatement->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  884. $selectStatement->havingClause = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  885. $selectStatement->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  887. return $selectStatement;
  888. }
  890. /**
  891. * UpdateStatement ::= UpdateClause [WhereClause]
  892. *
  893. * @return AST\UpdateStatement
  894. */
  895. public function UpdateStatement()
  896. {
  897. $updateStatement = new AST\UpdateStatement($this->UpdateClause());
  899. $updateStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  901. return $updateStatement;
  902. }
  904. /**
  905. * DeleteStatement ::= DeleteClause [WhereClause]
  906. *
  907. * @return AST\DeleteStatement
  908. */
  909. public function DeleteStatement()
  910. {
  911. $deleteStatement = new AST\DeleteStatement($this->DeleteClause());
  913. $deleteStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  915. return $deleteStatement;
  916. }
  918. /**
  919. * IdentificationVariable ::= identifier
  920. *
  921. * @return string
  922. */
  923. public function IdentificationVariable()
  924. {
  925. $this->match(Lexer::T_IDENTIFIER);
  927. assert($this->lexer->token !== null);
  928. $identVariable = $this->lexer->token['value'];
  930. $this->deferredIdentificationVariables[] = [
  931. 'expression' => $identVariable,
  932. 'nestingLevel' => $this->nestingLevel,
  933. 'token' => $this->lexer->token,
  934. ];
  936. return $identVariable;
  937. }
  939. /**
  940. * AliasIdentificationVariable = identifier
  941. *
  942. * @return string
  943. */
  944. public function AliasIdentificationVariable()
  945. {
  946. $this->match(Lexer::T_IDENTIFIER);
  948. assert($this->lexer->token !== null);
  949. $aliasIdentVariable = $this->lexer->token['value'];
  950. $exists = isset($this->queryComponents[$aliasIdentVariable]);
  952. if ($exists) {
  953. $this->semanticalError(
  954. sprintf("'%s' is already defined.", $aliasIdentVariable),
  955. $this->lexer->token
  956. );
  957. }
  959. return $aliasIdentVariable;
  960. }
  962. /**
  963. * AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
  964. *
  965. * @return string
  966. */
  967. public function AbstractSchemaName()
  968. {
  969. if ($this->lexer->isNextToken(Lexer::T_FULLY_QUALIFIED_NAME)) {
  970. $this->match(Lexer::T_FULLY_QUALIFIED_NAME);
  971. assert($this->lexer->token !== null);
  973. return $this->lexer->token['value'];
  974. }
  976. if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  977. $this->match(Lexer::T_IDENTIFIER);
  978. assert($this->lexer->token !== null);
  980. return $this->lexer->token['value'];
  981. }
  983. $this->match(Lexer::T_ALIASED_NAME);
  985. assert($this->lexer->token !== null);
  987. Deprecation::trigger(
  988. 'doctrine/orm',
  989. 'https://github.com/doctrine/orm/issues/8818',
  990. 'Short namespace aliases such as "%s" are deprecated and will be removed in Doctrine ORM 3.0.',
  991. $this->lexer->token['value']
  992. );
  994. [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token['value']);
  996. return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  997. }
  999. /**
  1000. * Validates an AbstractSchemaName, making sure the class exists.
  1001. *
  1002. * @param string $schemaName The name to validate.
  1003. *
  1004. * @throws QueryException if the name does not exist.
  1005. */
  1006. private function validateAbstractSchemaName(string $schemaName): void
  1007. {
  1008. assert($this->lexer->token !== null);
  1009. if (! (class_exists($schemaName, true) || interface_exists($schemaName, true))) {
  1010. $this->semanticalError(
  1011. sprintf("Class '%s' is not defined.", $schemaName),
  1012. $this->lexer->token
  1013. );
  1014. }
  1015. }
  1017. /**
  1018. * AliasResultVariable ::= identifier
  1019. *
  1020. * @return string
  1021. */
  1022. public function AliasResultVariable()
  1023. {
  1024. $this->match(Lexer::T_IDENTIFIER);
  1026. assert($this->lexer->token !== null);
  1027. $resultVariable = $this->lexer->token['value'];
  1028. $exists = isset($this->queryComponents[$resultVariable]);
  1030. if ($exists) {
  1031. $this->semanticalError(
  1032. sprintf("'%s' is already defined.", $resultVariable),
  1033. $this->lexer->token
  1034. );
  1035. }
  1037. return $resultVariable;
  1038. }
  1040. /**
  1041. * ResultVariable ::= identifier
  1042. *
  1043. * @return string
  1044. */
  1045. public function ResultVariable()
  1046. {
  1047. $this->match(Lexer::T_IDENTIFIER);
  1049. assert($this->lexer->token !== null);
  1050. $resultVariable = $this->lexer->token['value'];
  1052. // Defer ResultVariable validation
  1053. $this->deferredResultVariables[] = [
  1054. 'expression' => $resultVariable,
  1055. 'nestingLevel' => $this->nestingLevel,
  1056. 'token' => $this->lexer->token,
  1057. ];
  1059. return $resultVariable;
  1060. }
  1062. /**
  1063. * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
  1064. *
  1065. * @return AST\JoinAssociationPathExpression
  1066. */
  1067. public function JoinAssociationPathExpression()
  1068. {
  1069. $identVariable = $this->IdentificationVariable();
  1071. if (! isset($this->queryComponents[$identVariable])) {
  1072. $this->semanticalError(
  1073. 'Identification Variable ' . $identVariable . ' used in join path expression but was not defined before.'
  1074. );
  1075. }
  1077. $this->match(Lexer::T_DOT);
  1078. $this->match(Lexer::T_IDENTIFIER);
  1080. assert($this->lexer->token !== null);
  1081. $field = $this->lexer->token['value'];
  1083. // Validate association field
  1084. $class = $this->getMetadataForDqlAlias($identVariable);
  1086. if (! $class->hasAssociation($field)) {
  1087. $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
  1088. }
  1090. return new AST\JoinAssociationPathExpression($identVariable, $field);
  1091. }
  1093. /**
  1094. * Parses an arbitrary path expression and defers semantical validation
  1095. * based on expected types.
  1096. *
  1097. * PathExpression ::= IdentificationVariable {"." identifier}*
  1098. *
  1099. * @param int $expectedTypes
  1100. * @psalm-param int-mask-of<AST\PathExpression::TYPE_*> $expectedTypes
  1101. *
  1102. * @return AST\PathExpression
  1103. */
  1104. public function PathExpression($expectedTypes)
  1105. {
  1106. $identVariable = $this->IdentificationVariable();
  1107. $field = null;
  1109. assert($this->lexer->token !== null);
  1110. if ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1111. $this->match(Lexer::T_DOT);
  1112. $this->match(Lexer::T_IDENTIFIER);
  1114. $field = $this->lexer->token['value'];
  1116. while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1117. $this->match(Lexer::T_DOT);
  1118. $this->match(Lexer::T_IDENTIFIER);
  1119. $field .= '.' . $this->lexer->token['value'];
  1120. }
  1121. }
  1123. // Creating AST node
  1124. $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);
  1126. // Defer PathExpression validation if requested to be deferred
  1127. $this->deferredPathExpressions[] = [
  1128. 'expression' => $pathExpr,
  1129. 'nestingLevel' => $this->nestingLevel,
  1130. 'token' => $this->lexer->token,
  1131. ];
  1133. return $pathExpr;
  1134. }
  1136. /**
  1137. * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  1138. *
  1139. * @return AST\PathExpression
  1140. */
  1141. public function AssociationPathExpression()
  1142. {
  1143. return $this->PathExpression(
  1144. AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |
  1145. AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION
  1146. );
  1147. }
  1149. /**
  1150. * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  1151. *
  1152. * @return AST\PathExpression
  1153. */
  1154. public function SingleValuedPathExpression()
  1155. {
  1156. return $this->PathExpression(
  1157. AST\PathExpression::TYPE_STATE_FIELD |
  1158. AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  1159. );
  1160. }
  1162. /**
  1163. * StateFieldPathExpression ::= IdentificationVariable "." StateField
  1164. *
  1165. * @return AST\PathExpression
  1166. */
  1167. public function StateFieldPathExpression()
  1168. {
  1169. return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);
  1170. }
  1172. /**
  1173. * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  1174. *
  1175. * @return AST\PathExpression
  1176. */
  1177. public function SingleValuedAssociationPathExpression()
  1178. {
  1179. return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);
  1180. }
  1182. /**
  1183. * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  1184. *
  1185. * @return AST\PathExpression
  1186. */
  1187. public function CollectionValuedPathExpression()
  1188. {
  1189. return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);
  1190. }
  1192. /**
  1193. * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
  1194. *
  1195. * @return AST\SelectClause
  1196. */
  1197. public function SelectClause()
  1198. {
  1199. $isDistinct = false;
  1200. $this->match(Lexer::T_SELECT);
  1202. // Check for DISTINCT
  1203. if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1204. $this->match(Lexer::T_DISTINCT);
  1206. $isDistinct = true;
  1207. }
  1209. // Process SelectExpressions (1..N)
  1210. $selectExpressions = [];
  1211. $selectExpressions[] = $this->SelectExpression();
  1213. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1214. $this->match(Lexer::T_COMMA);
  1216. $selectExpressions[] = $this->SelectExpression();
  1217. }
  1219. return new AST\SelectClause($selectExpressions, $isDistinct);
  1220. }
  1222. /**
  1223. * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
  1224. *
  1225. * @return AST\SimpleSelectClause
  1226. */
  1227. public function SimpleSelectClause()
  1228. {
  1229. $isDistinct = false;
  1230. $this->match(Lexer::T_SELECT);
  1232. if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1233. $this->match(Lexer::T_DISTINCT);
  1235. $isDistinct = true;
  1236. }
  1238. return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);
  1239. }
  1241. /**
  1242. * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*
  1243. *
  1244. * @return AST\UpdateClause
  1245. */
  1246. public function UpdateClause()
  1247. {
  1248. $this->match(Lexer::T_UPDATE);
  1249. assert($this->lexer->lookahead !== null);
  1251. $token = $this->lexer->lookahead;
  1252. $abstractSchemaName = $this->AbstractSchemaName();
  1254. $this->validateAbstractSchemaName($abstractSchemaName);
  1256. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1257. $this->match(Lexer::T_AS);
  1258. }
  1260. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1262. $class = $this->em->getClassMetadata($abstractSchemaName);
  1264. // Building queryComponent
  1265. $queryComponent = [
  1266. 'metadata' => $class,
  1267. 'parent' => null,
  1268. 'relation' => null,
  1269. 'map' => null,
  1270. 'nestingLevel' => $this->nestingLevel,
  1271. 'token' => $token,
  1272. ];
  1274. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1276. $this->match(Lexer::T_SET);
  1278. $updateItems = [];
  1279. $updateItems[] = $this->UpdateItem();
  1281. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1282. $this->match(Lexer::T_COMMA);
  1284. $updateItems[] = $this->UpdateItem();
  1285. }
  1287. $updateClause = new AST\UpdateClause($abstractSchemaName, $updateItems);
  1288. $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1290. return $updateClause;
  1291. }
  1293. /**
  1294. * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable
  1295. *
  1296. * @return AST\DeleteClause
  1297. */
  1298. public function DeleteClause()
  1299. {
  1300. $this->match(Lexer::T_DELETE);
  1302. if ($this->lexer->isNextToken(Lexer::T_FROM)) {
  1303. $this->match(Lexer::T_FROM);
  1304. }
  1306. assert($this->lexer->lookahead !== null);
  1307. $token = $this->lexer->lookahead;
  1308. $abstractSchemaName = $this->AbstractSchemaName();
  1310. $this->validateAbstractSchemaName($abstractSchemaName);
  1312. $deleteClause = new AST\DeleteClause($abstractSchemaName);
  1314. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1315. $this->match(Lexer::T_AS);
  1316. }
  1318. $aliasIdentificationVariable = $this->lexer->isNextToken(Lexer::T_IDENTIFIER)
  1319. ? $this->AliasIdentificationVariable()
  1320. : 'alias_should_have_been_set';
  1322. $deleteClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1323. $class = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1325. // Building queryComponent
  1326. $queryComponent = [
  1327. 'metadata' => $class,
  1328. 'parent' => null,
  1329. 'relation' => null,
  1330. 'map' => null,
  1331. 'nestingLevel' => $this->nestingLevel,
  1332. 'token' => $token,
  1333. ];
  1335. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1337. return $deleteClause;
  1338. }
  1340. /**
  1341. * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}*
  1342. *
  1343. * @return AST\FromClause
  1344. */
  1345. public function FromClause()
  1346. {
  1347. $this->match(Lexer::T_FROM);
  1349. $identificationVariableDeclarations = [];
  1350. $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1352. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1353. $this->match(Lexer::T_COMMA);
  1355. $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1356. }
  1358. return new AST\FromClause($identificationVariableDeclarations);
  1359. }
  1361. /**
  1362. * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
  1363. *
  1364. * @return AST\SubselectFromClause
  1365. */
  1366. public function SubselectFromClause()
  1367. {
  1368. $this->match(Lexer::T_FROM);
  1370. $identificationVariables = [];
  1371. $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1373. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1374. $this->match(Lexer::T_COMMA);
  1376. $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1377. }
  1379. return new AST\SubselectFromClause($identificationVariables);
  1380. }
  1382. /**
  1383. * WhereClause ::= "WHERE" ConditionalExpression
  1384. *
  1385. * @return AST\WhereClause
  1386. */
  1387. public function WhereClause()
  1388. {
  1389. $this->match(Lexer::T_WHERE);
  1391. return new AST\WhereClause($this->ConditionalExpression());
  1392. }
  1394. /**
  1395. * HavingClause ::= "HAVING" ConditionalExpression
  1396. *
  1397. * @return AST\HavingClause
  1398. */
  1399. public function HavingClause()
  1400. {
  1401. $this->match(Lexer::T_HAVING);
  1403. return new AST\HavingClause($this->ConditionalExpression());
  1404. }
  1406. /**
  1407. * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
  1408. *
  1409. * @return AST\GroupByClause
  1410. */
  1411. public function GroupByClause()
  1412. {
  1413. $this->match(Lexer::T_GROUP);
  1414. $this->match(Lexer::T_BY);
  1416. $groupByItems = [$this->GroupByItem()];
  1418. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1419. $this->match(Lexer::T_COMMA);
  1421. $groupByItems[] = $this->GroupByItem();
  1422. }
  1424. return new AST\GroupByClause($groupByItems);
  1425. }
  1427. /**
  1428. * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
  1429. *
  1430. * @return AST\OrderByClause
  1431. */
  1432. public function OrderByClause()
  1433. {
  1434. $this->match(Lexer::T_ORDER);
  1435. $this->match(Lexer::T_BY);
  1437. $orderByItems = [];
  1438. $orderByItems[] = $this->OrderByItem();
  1440. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1441. $this->match(Lexer::T_COMMA);
  1443. $orderByItems[] = $this->OrderByItem();
  1444. }
  1446. return new AST\OrderByClause($orderByItems);
  1447. }
  1449. /**
  1450. * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  1451. *
  1452. * @return AST\Subselect
  1453. */
  1454. public function Subselect()
  1455. {
  1456. // Increase query nesting level
  1457. $this->nestingLevel++;
  1459. $subselect = new AST\Subselect($this->SimpleSelectClause(), $this->SubselectFromClause());
  1461. $subselect->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  1462. $subselect->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  1463. $subselect->havingClause = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  1464. $subselect->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  1466. // Decrease query nesting level
  1467. $this->nestingLevel--;
  1469. return $subselect;
  1470. }
  1472. /**
  1473. * UpdateItem ::= SingleValuedPathExpression "=" NewValue
  1474. *
  1475. * @return AST\UpdateItem
  1476. */
  1477. public function UpdateItem()
  1478. {
  1479. $pathExpr = $this->SingleValuedPathExpression();
  1481. $this->match(Lexer::T_EQUALS);
  1483. return new AST\UpdateItem($pathExpr, $this->NewValue());
  1484. }
  1486. /**
  1487. * GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression
  1488. *
  1489. * @return string|AST\PathExpression
  1490. */
  1491. public function GroupByItem()
  1492. {
  1493. // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  1494. $glimpse = $this->lexer->glimpse();
  1496. if ($glimpse !== null && $glimpse['type'] === Lexer::T_DOT) {
  1497. return $this->SingleValuedPathExpression();
  1498. }
  1500. assert($this->lexer->lookahead !== null);
  1501. // Still need to decide between IdentificationVariable or ResultVariable
  1502. $lookaheadValue = $this->lexer->lookahead['value'];
  1504. if (! isset($this->queryComponents[$lookaheadValue])) {
  1505. $this->semanticalError('Cannot group by undefined identification or result variable.');
  1506. }
  1508. return isset($this->queryComponents[$lookaheadValue]['metadata'])
  1509. ? $this->IdentificationVariable()
  1510. : $this->ResultVariable();
  1511. }
  1513. /**
  1514. * OrderByItem ::= (
  1515. * SimpleArithmeticExpression | SingleValuedPathExpression | CaseExpression |
  1516. * ScalarExpression | ResultVariable | FunctionDeclaration
  1517. * ) ["ASC" | "DESC"]
  1518. *
  1519. * @return AST\OrderByItem
  1520. */
  1521. public function OrderByItem()
  1522. {
  1523. $this->lexer->peek(); // lookahead => '.'
  1524. $this->lexer->peek(); // lookahead => token after '.'
  1526. $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1528. $this->lexer->resetPeek();
  1530. $glimpse = $this->lexer->glimpse();
  1532. assert($this->lexer->lookahead !== null);
  1533. switch (true) {
  1534. case $this->isMathOperator($peek):
  1535. $expr = $this->SimpleArithmeticExpression();
  1536. break;
  1538. case $glimpse !== null && $glimpse['type'] === Lexer::T_DOT:
  1539. $expr = $this->SingleValuedPathExpression();
  1540. break;
  1542. case $this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  1543. $expr = $this->ScalarExpression();
  1544. break;
  1546. case $this->lexer->lookahead['type'] === Lexer::T_CASE:
  1547. $expr = $this->CaseExpression();
  1548. break;
  1550. case $this->isFunction():
  1551. $expr = $this->FunctionDeclaration();
  1552. break;
  1554. default:
  1555. $expr = $this->ResultVariable();
  1556. break;
  1557. }
  1559. $type = 'ASC';
  1560. $item = new AST\OrderByItem($expr);
  1562. switch (true) {
  1563. case $this->lexer->isNextToken(Lexer::T_DESC):
  1564. $this->match(Lexer::T_DESC);
  1565. $type = 'DESC';
  1566. break;
  1568. case $this->lexer->isNextToken(Lexer::T_ASC):
  1569. $this->match(Lexer::T_ASC);
  1570. break;
  1572. default:
  1573. // Do nothing
  1574. }
  1576. $item->type = $type;
  1578. return $item;
  1579. }
  1581. /**
  1582. * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
  1583. * EnumPrimary | SimpleEntityExpression | "NULL"
  1584. *
  1585. * NOTE: Since it is not possible to correctly recognize individual types, here is the full
  1586. * grammar that needs to be supported:
  1587. *
  1588. * NewValue ::= SimpleArithmeticExpression | "NULL"
  1589. *
  1590. * SimpleArithmeticExpression covers all *Primary grammar rules and also SimpleEntityExpression
  1591. *
  1592. * @return AST\ArithmeticExpression|AST\InputParameter|null
  1593. */
  1594. public function NewValue()
  1595. {
  1596. if ($this->lexer->isNextToken(Lexer::T_NULL)) {
  1597. $this->match(Lexer::T_NULL);
  1599. return null;
  1600. }
  1602. if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  1603. $this->match(Lexer::T_INPUT_PARAMETER);
  1604. assert($this->lexer->token !== null);
  1606. return new AST\InputParameter($this->lexer->token['value']);
  1607. }
  1609. return $this->ArithmeticExpression();
  1610. }
  1612. /**
  1613. * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*
  1614. *
  1615. * @return AST\IdentificationVariableDeclaration
  1616. */
  1617. public function IdentificationVariableDeclaration()
  1618. {
  1619. $joins = [];
  1620. $rangeVariableDeclaration = $this->RangeVariableDeclaration();
  1621. $indexBy = $this->lexer->isNextToken(Lexer::T_INDEX)
  1622. ? $this->IndexBy()
  1623. : null;
  1625. $rangeVariableDeclaration->isRoot = true;
  1627. while (
  1628. $this->lexer->isNextToken(Lexer::T_LEFT) ||
  1629. $this->lexer->isNextToken(Lexer::T_INNER) ||
  1630. $this->lexer->isNextToken(Lexer::T_JOIN)
  1631. ) {
  1632. $joins[] = $this->Join();
  1633. }
  1635. return new AST\IdentificationVariableDeclaration(
  1636. $rangeVariableDeclaration,
  1637. $indexBy,
  1638. $joins
  1639. );
  1640. }
  1642. /**
  1643. * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration
  1644. *
  1645. * {Internal note: WARNING: Solution is harder than a bare implementation.
  1646. * Desired EBNF support:
  1647. *
  1648. * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
  1649. *
  1650. * It demands that entire SQL generation to become programmatical. This is
  1651. * needed because association based subselect requires "WHERE" conditional
  1652. * expressions to be injected, but there is no scope to do that. Only scope
  1653. * accessible is "FROM", prohibiting an easy implementation without larger
  1654. * changes.}
  1655. *
  1656. * @return AST\IdentificationVariableDeclaration
  1657. */
  1658. public function SubselectIdentificationVariableDeclaration()
  1659. {
  1660. /*
  1661. NOT YET IMPLEMENTED!
  1663. $glimpse = $this->lexer->glimpse();
  1665. if ($glimpse['type'] == Lexer::T_DOT) {
  1666. $associationPathExpression = $this->AssociationPathExpression();
  1668. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1669. $this->match(Lexer::T_AS);
  1670. }
  1672. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1673. $identificationVariable = $associationPathExpression->identificationVariable;
  1674. $field = $associationPathExpression->associationField;
  1676. $class = $this->queryComponents[$identificationVariable]['metadata'];
  1677. $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1679. // Building queryComponent
  1680. $joinQueryComponent = array(
  1681. 'metadata' => $targetClass,
  1682. 'parent' => $identificationVariable,
  1683. 'relation' => $class->getAssociationMapping($field),
  1684. 'map' => null,
  1685. 'nestingLevel' => $this->nestingLevel,
  1686. 'token' => $this->lexer->lookahead
  1687. );
  1689. $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1691. return new AST\SubselectIdentificationVariableDeclaration(
  1692. $associationPathExpression, $aliasIdentificationVariable
  1693. );
  1694. }
  1695. */
  1697. return $this->IdentificationVariableDeclaration();
  1698. }
  1700. /**
  1701. * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN"
  1702. * (JoinAssociationDeclaration | RangeVariableDeclaration)
  1703. * ["WITH" ConditionalExpression]
  1704. *
  1705. * @return AST\Join
  1706. */
  1707. public function Join()
  1708. {
  1709. // Check Join type
  1710. $joinType = AST\Join::JOIN_TYPE_INNER;
  1712. switch (true) {
  1713. case $this->lexer->isNextToken(Lexer::T_LEFT):
  1714. $this->match(Lexer::T_LEFT);
  1716. $joinType = AST\Join::JOIN_TYPE_LEFT;
  1718. // Possible LEFT OUTER join
  1719. if ($this->lexer->isNextToken(Lexer::T_OUTER)) {
  1720. $this->match(Lexer::T_OUTER);
  1722. $joinType = AST\Join::JOIN_TYPE_LEFTOUTER;
  1723. }
  1725. break;
  1727. case $this->lexer->isNextToken(Lexer::T_INNER):
  1728. $this->match(Lexer::T_INNER);
  1729. break;
  1731. default:
  1732. // Do nothing
  1733. }
  1735. $this->match(Lexer::T_JOIN);
  1737. $next = $this->lexer->glimpse();
  1738. assert($next !== null);
  1739. $joinDeclaration = $next['type'] === Lexer::T_DOT ? $this->JoinAssociationDeclaration() : $this->RangeVariableDeclaration();
  1740. $adhocConditions = $this->lexer->isNextToken(Lexer::T_WITH);
  1741. $join = new AST\Join($joinType, $joinDeclaration);
  1743. // Describe non-root join declaration
  1744. if ($joinDeclaration instanceof AST\RangeVariableDeclaration) {
  1745. $joinDeclaration->isRoot = false;
  1746. }
  1748. // Check for ad-hoc Join conditions
  1749. if ($adhocConditions) {
  1750. $this->match(Lexer::T_WITH);
  1752. $join->conditionalExpression = $this->ConditionalExpression();
  1753. }
  1755. return $join;
  1756. }
  1758. /**
  1759. * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
  1760. *
  1761. * @return AST\RangeVariableDeclaration
  1762. *
  1763. * @throws QueryException
  1764. */
  1765. public function RangeVariableDeclaration()
  1766. {
  1767. if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $this->lexer->glimpse()['type'] === Lexer::T_SELECT) {
  1768. $this->semanticalError('Subquery is not supported here', $this->lexer->token);
  1769. }
  1771. $abstractSchemaName = $this->AbstractSchemaName();
  1773. $this->validateAbstractSchemaName($abstractSchemaName);
  1775. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1776. $this->match(Lexer::T_AS);
  1777. }
  1779. assert($this->lexer->lookahead !== null);
  1780. $token = $this->lexer->lookahead;
  1781. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1782. $classMetadata = $this->em->getClassMetadata($abstractSchemaName);
  1784. // Building queryComponent
  1785. $queryComponent = [
  1786. 'metadata' => $classMetadata,
  1787. 'parent' => null,
  1788. 'relation' => null,
  1789. 'map' => null,
  1790. 'nestingLevel' => $this->nestingLevel,
  1791. 'token' => $token,
  1792. ];
  1794. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1796. return new AST\RangeVariableDeclaration($abstractSchemaName, $aliasIdentificationVariable);
  1797. }
  1799. /**
  1800. * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [IndexBy]
  1801. *
  1802. * @return AST\JoinAssociationDeclaration
  1803. */
  1804. public function JoinAssociationDeclaration()
  1805. {
  1806. $joinAssociationPathExpression = $this->JoinAssociationPathExpression();
  1808. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1809. $this->match(Lexer::T_AS);
  1810. }
  1812. assert($this->lexer->lookahead !== null);
  1814. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1815. $indexBy = $this->lexer->isNextToken(Lexer::T_INDEX) ? $this->IndexBy() : null;
  1817. $identificationVariable = $joinAssociationPathExpression->identificationVariable;
  1818. $field = $joinAssociationPathExpression->associationField;
  1820. $class = $this->getMetadataForDqlAlias($identificationVariable);
  1821. $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1823. // Building queryComponent
  1824. $joinQueryComponent = [
  1825. 'metadata' => $targetClass,
  1826. 'parent' => $joinAssociationPathExpression->identificationVariable,
  1827. 'relation' => $class->getAssociationMapping($field),
  1828. 'map' => null,
  1829. 'nestingLevel' => $this->nestingLevel,
  1830. 'token' => $this->lexer->lookahead,
  1831. ];
  1833. $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1835. return new AST\JoinAssociationDeclaration($joinAssociationPathExpression, $aliasIdentificationVariable, $indexBy);
  1836. }
  1838. /**
  1839. * PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
  1840. * PartialFieldSet ::= "{" SimpleStateField {"," SimpleStateField}* "}"
  1841. *
  1842. * @return AST\PartialObjectExpression
  1843. */
  1844. public function PartialObjectExpression()
  1845. {
  1846. Deprecation::trigger(
  1847. 'doctrine/orm',
  1848. 'https://github.com/doctrine/orm/issues/8471',
  1849. 'PARTIAL syntax in DQL is deprecated.'
  1850. );
  1852. $this->match(Lexer::T_PARTIAL);
  1854. $partialFieldSet = [];
  1856. $identificationVariable = $this->IdentificationVariable();
  1858. $this->match(Lexer::T_DOT);
  1859. $this->match(Lexer::T_OPEN_CURLY_BRACE);
  1860. $this->match(Lexer::T_IDENTIFIER);
  1862. assert($this->lexer->token !== null);
  1863. $field = $this->lexer->token['value'];
  1865. // First field in partial expression might be embeddable property
  1866. while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1867. $this->match(Lexer::T_DOT);
  1868. $this->match(Lexer::T_IDENTIFIER);
  1869. $field .= '.' . $this->lexer->token['value'];
  1870. }
  1872. $partialFieldSet[] = $field;
  1874. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1875. $this->match(Lexer::T_COMMA);
  1876. $this->match(Lexer::T_IDENTIFIER);
  1878. $field = $this->lexer->token['value'];
  1880. while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1881. $this->match(Lexer::T_DOT);
  1882. $this->match(Lexer::T_IDENTIFIER);
  1883. $field .= '.' . $this->lexer->token['value'];
  1884. }
  1886. $partialFieldSet[] = $field;
  1887. }
  1889. $this->match(Lexer::T_CLOSE_CURLY_BRACE);
  1891. $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
  1893. // Defer PartialObjectExpression validation
  1894. $this->deferredPartialObjectExpressions[] = [
  1895. 'expression' => $partialObjectExpression,
  1896. 'nestingLevel' => $this->nestingLevel,
  1897. 'token' => $this->lexer->token,
  1898. ];
  1900. return $partialObjectExpression;
  1901. }
  1903. /**
  1904. * NewObjectExpression ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
  1905. *
  1906. * @return AST\NewObjectExpression
  1907. */
  1908. public function NewObjectExpression()
  1909. {
  1910. $this->match(Lexer::T_NEW);
  1912. $className = $this->AbstractSchemaName(); // note that this is not yet validated
  1913. $token = $this->lexer->token;
  1915. $this->match(Lexer::T_OPEN_PARENTHESIS);
  1917. $args[] = $this->NewObjectArg();
  1919. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1920. $this->match(Lexer::T_COMMA);
  1922. $args[] = $this->NewObjectArg();
  1923. }
  1925. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1927. $expression = new AST\NewObjectExpression($className, $args);
  1929. // Defer NewObjectExpression validation
  1930. $this->deferredNewObjectExpressions[] = [
  1931. 'token' => $token,
  1932. 'expression' => $expression,
  1933. 'nestingLevel' => $this->nestingLevel,
  1934. ];
  1936. return $expression;
  1937. }
  1939. /**
  1940. * NewObjectArg ::= ScalarExpression | "(" Subselect ")"
  1941. *
  1942. * @return mixed
  1943. */
  1944. public function NewObjectArg()
  1945. {
  1946. assert($this->lexer->lookahead !== null);
  1947. $token = $this->lexer->lookahead;
  1948. $peek = $this->lexer->glimpse();
  1950. assert($peek !== null);
  1951. if ($token['type'] === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT) {
  1952. $this->match(Lexer::T_OPEN_PARENTHESIS);
  1953. $expression = $this->Subselect();
  1954. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1956. return $expression;
  1957. }
  1959. return $this->ScalarExpression();
  1960. }
  1962. /**
  1963. * IndexBy ::= "INDEX" "BY" SingleValuedPathExpression
  1964. *
  1965. * @return AST\IndexBy
  1966. */
  1967. public function IndexBy()
  1968. {
  1969. $this->match(Lexer::T_INDEX);
  1970. $this->match(Lexer::T_BY);
  1971. $pathExpr = $this->SingleValuedPathExpression();
  1973. // Add the INDEX BY info to the query component
  1974. $this->queryComponents[$pathExpr->identificationVariable]['map'] = $pathExpr->field;
  1976. return new AST\IndexBy($pathExpr);
  1977. }
  1979. /**
  1980. * ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DateTimePrimary |
  1981. * StateFieldPathExpression | BooleanPrimary | CaseExpression |
  1982. * InstanceOfExpression
  1983. *
  1984. * @return mixed One of the possible expressions or subexpressions.
  1985. */
  1986. public function ScalarExpression()
  1987. {
  1988. assert($this->lexer->token !== null);
  1989. assert($this->lexer->lookahead !== null);
  1990. $lookahead = $this->lexer->lookahead['type'];
  1991. $peek = $this->lexer->glimpse();
  1993. switch (true) {
  1994. case $lookahead === Lexer::T_INTEGER:
  1995. case $lookahead === Lexer::T_FLOAT:
  1996. // SimpleArithmeticExpression : (- u.value ) or ( + u.value ) or ( - 1 ) or ( + 1 )
  1997. case $lookahead === Lexer::T_MINUS:
  1998. case $lookahead === Lexer::T_PLUS:
  1999. return $this->SimpleArithmeticExpression();
  2001. case $lookahead === Lexer::T_STRING:
  2002. return $this->StringPrimary();
  2004. case $lookahead === Lexer::T_TRUE:
  2005. case $lookahead === Lexer::T_FALSE:
  2006. $this->match($lookahead);
  2008. return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2010. case $lookahead === Lexer::T_INPUT_PARAMETER:
  2011. switch (true) {
  2012. case $this->isMathOperator($peek):
  2013. // :param + u.value
  2014. return $this->SimpleArithmeticExpression();
  2016. default:
  2017. return $this->InputParameter();
  2018. }
  2019. case $lookahead === Lexer::T_CASE:
  2020. case $lookahead === Lexer::T_COALESCE:
  2021. case $lookahead === Lexer::T_NULLIF:
  2022. // Since NULLIF and COALESCE can be identified as a function,
  2023. // we need to check these before checking for FunctionDeclaration
  2024. return $this->CaseExpression();
  2026. case $lookahead === Lexer::T_OPEN_PARENTHESIS:
  2027. return $this->SimpleArithmeticExpression();
  2029. // this check must be done before checking for a filed path expression
  2030. case $this->isFunction():
  2031. $this->lexer->peek(); // "("
  2033. switch (true) {
  2034. case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2035. // SUM(u.id) + COUNT(u.id)
  2036. return $this->SimpleArithmeticExpression();
  2038. default:
  2039. // IDENTITY(u)
  2040. return $this->FunctionDeclaration();
  2041. }
  2043. break;
  2044. // it is no function, so it must be a field path
  2045. case $lookahead === Lexer::T_IDENTIFIER:
  2046. $this->lexer->peek(); // lookahead => '.'
  2047. $this->lexer->peek(); // lookahead => token after '.'
  2048. $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  2049. $this->lexer->resetPeek();
  2051. if ($this->isMathOperator($peek)) {
  2052. return $this->SimpleArithmeticExpression();
  2053. }
  2055. return $this->StateFieldPathExpression();
  2057. default:
  2058. $this->syntaxError();
  2059. }
  2060. }
  2062. /**
  2063. * CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullifExpression
  2064. * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2065. * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2066. * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2067. * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2068. * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2069. * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2070. * NullifExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2071. *
  2072. * @return mixed One of the possible expressions or subexpressions.
  2073. */
  2074. public function CaseExpression()
  2075. {
  2076. assert($this->lexer->lookahead !== null);
  2077. $lookahead = $this->lexer->lookahead['type'];
  2079. switch ($lookahead) {
  2080. case Lexer::T_NULLIF:
  2081. return $this->NullIfExpression();
  2083. case Lexer::T_COALESCE:
  2084. return $this->CoalesceExpression();
  2086. case Lexer::T_CASE:
  2087. $this->lexer->resetPeek();
  2088. $peek = $this->lexer->peek();
  2090. assert($peek !== null);
  2091. if ($peek['type'] === Lexer::T_WHEN) {
  2092. return $this->GeneralCaseExpression();
  2093. }
  2095. return $this->SimpleCaseExpression();
  2097. default:
  2098. // Do nothing
  2099. break;
  2100. }
  2102. $this->syntaxError();
  2103. }
  2105. /**
  2106. * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2107. *
  2108. * @return AST\CoalesceExpression
  2109. */
  2110. public function CoalesceExpression()
  2111. {
  2112. $this->match(Lexer::T_COALESCE);
  2113. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2115. // Process ScalarExpressions (1..N)
  2116. $scalarExpressions = [];
  2117. $scalarExpressions[] = $this->ScalarExpression();
  2119. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  2120. $this->match(Lexer::T_COMMA);
  2122. $scalarExpressions[] = $this->ScalarExpression();
  2123. }
  2125. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2127. return new AST\CoalesceExpression($scalarExpressions);
  2128. }
  2130. /**
  2131. * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2132. *
  2133. * @return AST\NullIfExpression
  2134. */
  2135. public function NullIfExpression()
  2136. {
  2137. $this->match(Lexer::T_NULLIF);
  2138. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2140. $firstExpression = $this->ScalarExpression();
  2141. $this->match(Lexer::T_COMMA);
  2142. $secondExpression = $this->ScalarExpression();
  2144. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2146. return new AST\NullIfExpression($firstExpression, $secondExpression);
  2147. }
  2149. /**
  2150. * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2151. *
  2152. * @return AST\GeneralCaseExpression
  2153. */
  2154. public function GeneralCaseExpression()
  2155. {
  2156. $this->match(Lexer::T_CASE);
  2158. // Process WhenClause (1..N)
  2159. $whenClauses = [];
  2161. do {
  2162. $whenClauses[] = $this->WhenClause();
  2163. } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2165. $this->match(Lexer::T_ELSE);
  2166. $scalarExpression = $this->ScalarExpression();
  2167. $this->match(Lexer::T_END);
  2169. return new AST\GeneralCaseExpression($whenClauses, $scalarExpression);
  2170. }
  2172. /**
  2173. * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2174. * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2175. *
  2176. * @return AST\SimpleCaseExpression
  2177. */
  2178. public function SimpleCaseExpression()
  2179. {
  2180. $this->match(Lexer::T_CASE);
  2181. $caseOperand = $this->StateFieldPathExpression();
  2183. // Process SimpleWhenClause (1..N)
  2184. $simpleWhenClauses = [];
  2186. do {
  2187. $simpleWhenClauses[] = $this->SimpleWhenClause();
  2188. } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2190. $this->match(Lexer::T_ELSE);
  2191. $scalarExpression = $this->ScalarExpression();
  2192. $this->match(Lexer::T_END);
  2194. return new AST\SimpleCaseExpression($caseOperand, $simpleWhenClauses, $scalarExpression);
  2195. }
  2197. /**
  2198. * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2199. *
  2200. * @return AST\WhenClause
  2201. */
  2202. public function WhenClause()
  2203. {
  2204. $this->match(Lexer::T_WHEN);
  2205. $conditionalExpression = $this->ConditionalExpression();
  2206. $this->match(Lexer::T_THEN);
  2208. return new AST\WhenClause($conditionalExpression, $this->ScalarExpression());
  2209. }
  2211. /**
  2212. * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2213. *
  2214. * @return AST\SimpleWhenClause
  2215. */
  2216. public function SimpleWhenClause()
  2217. {
  2218. $this->match(Lexer::T_WHEN);
  2219. $conditionalExpression = $this->ScalarExpression();
  2220. $this->match(Lexer::T_THEN);
  2222. return new AST\SimpleWhenClause($conditionalExpression, $this->ScalarExpression());
  2223. }
  2225. /**
  2226. * SelectExpression ::= (
  2227. * IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration |
  2228. * PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression
  2229. * ) [["AS"] ["HIDDEN"] AliasResultVariable]
  2230. *
  2231. * @return AST\SelectExpression
  2232. */
  2233. public function SelectExpression()
  2234. {
  2235. assert($this->lexer->lookahead !== null);
  2236. $expression = null;
  2237. $identVariable = null;
  2238. $peek = $this->lexer->glimpse();
  2239. $lookaheadType = $this->lexer->lookahead['type'];
  2240. assert($peek !== null);
  2242. switch (true) {
  2243. // ScalarExpression (u.name)
  2244. case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] === Lexer::T_DOT:
  2245. $expression = $this->ScalarExpression();
  2246. break;
  2248. // IdentificationVariable (u)
  2249. case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2250. $expression = $identVariable = $this->IdentificationVariable();
  2251. break;
  2253. // CaseExpression (CASE ... or NULLIF(...) or COALESCE(...))
  2254. case $lookaheadType === Lexer::T_CASE:
  2255. case $lookaheadType === Lexer::T_COALESCE:
  2256. case $lookaheadType === Lexer::T_NULLIF:
  2257. $expression = $this->CaseExpression();
  2258. break;
  2260. // DQL Function (SUM(u.value) or SUM(u.value) + 1)
  2261. case $this->isFunction():
  2262. $this->lexer->peek(); // "("
  2264. switch (true) {
  2265. case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2266. // SUM(u.id) + COUNT(u.id)
  2267. $expression = $this->ScalarExpression();
  2268. break;
  2270. default:
  2271. // IDENTITY(u)
  2272. $expression = $this->FunctionDeclaration();
  2273. break;
  2274. }
  2276. break;
  2278. // PartialObjectExpression (PARTIAL u.{id, name})
  2279. case $lookaheadType === Lexer::T_PARTIAL:
  2280. $expression = $this->PartialObjectExpression();
  2281. $identVariable = $expression->identificationVariable;
  2282. break;
  2284. // Subselect
  2285. case $lookaheadType === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT:
  2286. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2287. $expression = $this->Subselect();
  2288. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2289. break;
  2291. // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2292. case $lookaheadType === Lexer::T_OPEN_PARENTHESIS:
  2293. case $lookaheadType === Lexer::T_INTEGER:
  2294. case $lookaheadType === Lexer::T_STRING:
  2295. case $lookaheadType === Lexer::T_FLOAT:
  2296. // SimpleArithmeticExpression : (- u.value ) or ( + u.value )
  2297. case $lookaheadType === Lexer::T_MINUS:
  2298. case $lookaheadType === Lexer::T_PLUS:
  2299. $expression = $this->SimpleArithmeticExpression();
  2300. break;
  2302. // NewObjectExpression (New ClassName(id, name))
  2303. case $lookaheadType === Lexer::T_NEW:
  2304. $expression = $this->NewObjectExpression();
  2305. break;
  2307. default:
  2308. $this->syntaxError(
  2309. 'IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression',
  2310. $this->lexer->lookahead
  2311. );
  2312. }
  2314. // [["AS"] ["HIDDEN"] AliasResultVariable]
  2315. $mustHaveAliasResultVariable = false;
  2317. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2318. $this->match(Lexer::T_AS);
  2320. $mustHaveAliasResultVariable = true;
  2321. }
  2323. $hiddenAliasResultVariable = false;
  2325. if ($this->lexer->isNextToken(Lexer::T_HIDDEN)) {
  2326. $this->match(Lexer::T_HIDDEN);
  2328. $hiddenAliasResultVariable = true;
  2329. }
  2331. $aliasResultVariable = null;
  2333. if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2334. assert($expression instanceof AST\Node || is_string($expression));
  2335. $token = $this->lexer->lookahead;
  2336. $aliasResultVariable = $this->AliasResultVariable();
  2338. // Include AliasResultVariable in query components.
  2339. $this->queryComponents[$aliasResultVariable] = [
  2340. 'resultVariable' => $expression,
  2341. 'nestingLevel' => $this->nestingLevel,
  2342. 'token' => $token,
  2343. ];
  2344. }
  2346. // AST
  2348. $expr = new AST\SelectExpression($expression, $aliasResultVariable, $hiddenAliasResultVariable);
  2350. if ($identVariable) {
  2351. $this->identVariableExpressions[$identVariable] = $expr;
  2352. }
  2354. return $expr;
  2355. }
  2357. /**
  2358. * SimpleSelectExpression ::= (
  2359. * StateFieldPathExpression | IdentificationVariable | FunctionDeclaration |
  2360. * AggregateExpression | "(" Subselect ")" | ScalarExpression
  2361. * ) [["AS"] AliasResultVariable]
  2362. *
  2363. * @return AST\SimpleSelectExpression
  2364. */
  2365. public function SimpleSelectExpression()
  2366. {
  2367. assert($this->lexer->lookahead !== null);
  2368. $peek = $this->lexer->glimpse();
  2369. assert($peek !== null);
  2371. switch ($this->lexer->lookahead['type']) {
  2372. case Lexer::T_IDENTIFIER:
  2373. switch (true) {
  2374. case $peek['type'] === Lexer::T_DOT:
  2375. $expression = $this->StateFieldPathExpression();
  2377. return new AST\SimpleSelectExpression($expression);
  2379. case $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2380. $expression = $this->IdentificationVariable();
  2382. return new AST\SimpleSelectExpression($expression);
  2384. case $this->isFunction():
  2385. // SUM(u.id) + COUNT(u.id)
  2386. if ($this->isMathOperator($this->peekBeyondClosingParenthesis())) {
  2387. return new AST\SimpleSelectExpression($this->ScalarExpression());
  2388. }
  2390. // COUNT(u.id)
  2391. if ($this->isAggregateFunction($this->lexer->lookahead['type'])) {
  2392. return new AST\SimpleSelectExpression($this->AggregateExpression());
  2393. }
  2395. // IDENTITY(u)
  2396. return new AST\SimpleSelectExpression($this->FunctionDeclaration());
  2398. default:
  2399. // Do nothing
  2400. }
  2402. break;
  2404. case Lexer::T_OPEN_PARENTHESIS:
  2405. if ($peek['type'] !== Lexer::T_SELECT) {
  2406. // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2407. $expression = $this->SimpleArithmeticExpression();
  2409. return new AST\SimpleSelectExpression($expression);
  2410. }
  2412. // Subselect
  2413. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2414. $expression = $this->Subselect();
  2415. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2417. return new AST\SimpleSelectExpression($expression);
  2419. default:
  2420. // Do nothing
  2421. }
  2423. $this->lexer->peek();
  2425. $expression = $this->ScalarExpression();
  2426. $expr = new AST\SimpleSelectExpression($expression);
  2428. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2429. $this->match(Lexer::T_AS);
  2430. }
  2432. if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2433. $token = $this->lexer->lookahead;
  2434. $resultVariable = $this->AliasResultVariable();
  2435. $expr->fieldIdentificationVariable = $resultVariable;
  2437. // Include AliasResultVariable in query components.
  2438. $this->queryComponents[$resultVariable] = [
  2439. 'resultvariable' => $expr,
  2440. 'nestingLevel' => $this->nestingLevel,
  2441. 'token' => $token,
  2442. ];
  2443. }
  2445. return $expr;
  2446. }
  2448. /**
  2449. * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
  2450. *
  2451. * @return AST\ConditionalExpression|AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2452. */
  2453. public function ConditionalExpression()
  2454. {
  2455. $conditionalTerms = [];
  2456. $conditionalTerms[] = $this->ConditionalTerm();
  2458. while ($this->lexer->isNextToken(Lexer::T_OR)) {
  2459. $this->match(Lexer::T_OR);
  2461. $conditionalTerms[] = $this->ConditionalTerm();
  2462. }
  2464. // Phase 1 AST optimization: Prevent AST\ConditionalExpression
  2465. // if only one AST\ConditionalTerm is defined
  2466. if (count($conditionalTerms) === 1) {
  2467. return $conditionalTerms[0];
  2468. }
  2470. return new AST\ConditionalExpression($conditionalTerms);
  2471. }
  2473. /**
  2474. * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
  2475. *
  2476. * @return AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2477. */
  2478. public function ConditionalTerm()
  2479. {
  2480. $conditionalFactors = [];
  2481. $conditionalFactors[] = $this->ConditionalFactor();
  2483. while ($this->lexer->isNextToken(Lexer::T_AND)) {
  2484. $this->match(Lexer::T_AND);
  2486. $conditionalFactors[] = $this->ConditionalFactor();
  2487. }
  2489. // Phase 1 AST optimization: Prevent AST\ConditionalTerm
  2490. // if only one AST\ConditionalFactor is defined
  2491. if (count($conditionalFactors) === 1) {
  2492. return $conditionalFactors[0];
  2493. }
  2495. return new AST\ConditionalTerm($conditionalFactors);
  2496. }
  2498. /**
  2499. * ConditionalFactor ::= ["NOT"] ConditionalPrimary
  2500. *
  2501. * @return AST\ConditionalFactor|AST\ConditionalPrimary
  2502. */
  2503. public function ConditionalFactor()
  2504. {
  2505. $not = false;
  2507. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2508. $this->match(Lexer::T_NOT);
  2510. $not = true;
  2511. }
  2513. $conditionalPrimary = $this->ConditionalPrimary();
  2515. // Phase 1 AST optimization: Prevent AST\ConditionalFactor
  2516. // if only one AST\ConditionalPrimary is defined
  2517. if (! $not) {
  2518. return $conditionalPrimary;
  2519. }
  2521. return new AST\ConditionalFactor($conditionalPrimary, $not);
  2522. }
  2524. /**
  2525. * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
  2526. *
  2527. * @return AST\ConditionalPrimary
  2528. */
  2529. public function ConditionalPrimary()
  2530. {
  2531. $condPrimary = new AST\ConditionalPrimary();
  2533. if (! $this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2534. $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2536. return $condPrimary;
  2537. }
  2539. // Peek beyond the matching closing parenthesis ')'
  2540. $peek = $this->peekBeyondClosingParenthesis();
  2542. if (
  2543. $peek !== null && (
  2544. in_array($peek['value'], ['=', '<', '<=', '<>', '>', '>=', '!='], true) ||
  2545. in_array($peek['type'], [Lexer::T_NOT, Lexer::T_BETWEEN, Lexer::T_LIKE, Lexer::T_IN, Lexer::T_IS, Lexer::T_EXISTS], true) ||
  2546. $this->isMathOperator($peek)
  2547. )
  2548. ) {
  2549. $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2551. return $condPrimary;
  2552. }
  2554. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2555. $condPrimary->conditionalExpression = $this->ConditionalExpression();
  2556. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2558. return $condPrimary;
  2559. }
  2561. /**
  2562. * SimpleConditionalExpression ::=
  2563. * ComparisonExpression | BetweenExpression | LikeExpression |
  2564. * InExpression | NullComparisonExpression | ExistsExpression |
  2565. * EmptyCollectionComparisonExpression | CollectionMemberExpression |
  2566. * InstanceOfExpression
  2567. *
  2568. * @return AST\BetweenExpression|
  2569. * AST\CollectionMemberExpression|
  2570. * AST\ComparisonExpression|
  2571. * AST\EmptyCollectionComparisonExpression|
  2572. * AST\ExistsExpression|
  2573. * AST\InExpression|
  2574. * AST\InstanceOfExpression|
  2575. * AST\LikeExpression|
  2576. * AST\NullComparisonExpression
  2577. */
  2578. public function SimpleConditionalExpression()
  2579. {
  2580. assert($this->lexer->lookahead !== null);
  2581. if ($this->lexer->isNextToken(Lexer::T_EXISTS)) {
  2582. return $this->ExistsExpression();
  2583. }
  2585. $token = $this->lexer->lookahead;
  2586. $peek = $this->lexer->glimpse();
  2587. $lookahead = $token;
  2589. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2590. $token = $this->lexer->glimpse();
  2591. }
  2593. assert($token !== null);
  2594. assert($peek !== null);
  2595. if ($token['type'] === Lexer::T_IDENTIFIER || $token['type'] === Lexer::T_INPUT_PARAMETER || $this->isFunction()) {
  2596. // Peek beyond the matching closing parenthesis.
  2597. $beyond = $this->lexer->peek();
  2599. switch ($peek['value']) {
  2600. case '(':
  2601. // Peeks beyond the matched closing parenthesis.
  2602. $token = $this->peekBeyondClosingParenthesis(false);
  2603. assert($token !== null);
  2605. if ($token['type'] === Lexer::T_NOT) {
  2606. $token = $this->lexer->peek();
  2607. assert($token !== null);
  2608. }
  2610. if ($token['type'] === Lexer::T_IS) {
  2611. $lookahead = $this->lexer->peek();
  2612. }
  2614. break;
  2616. default:
  2617. // Peek beyond the PathExpression or InputParameter.
  2618. $token = $beyond;
  2620. while ($token['value'] === '.') {
  2621. $this->lexer->peek();
  2623. $token = $this->lexer->peek();
  2624. assert($token !== null);
  2625. }
  2627. // Also peek beyond a NOT if there is one.
  2628. assert($token !== null);
  2629. if ($token['type'] === Lexer::T_NOT) {
  2630. $token = $this->lexer->peek();
  2631. assert($token !== null);
  2632. }
  2634. // We need to go even further in case of IS (differentiate between NULL and EMPTY)
  2635. $lookahead = $this->lexer->peek();
  2636. }
  2638. assert($lookahead !== null);
  2639. // Also peek beyond a NOT if there is one.
  2640. if ($lookahead['type'] === Lexer::T_NOT) {
  2641. $lookahead = $this->lexer->peek();
  2642. }
  2644. $this->lexer->resetPeek();
  2645. }
  2647. if ($token['type'] === Lexer::T_BETWEEN) {
  2648. return $this->BetweenExpression();
  2649. }
  2651. if ($token['type'] === Lexer::T_LIKE) {
  2652. return $this->LikeExpression();
  2653. }
  2655. if ($token['type'] === Lexer::T_IN) {
  2656. return $this->InExpression();
  2657. }
  2659. if ($token['type'] === Lexer::T_INSTANCE) {
  2660. return $this->InstanceOfExpression();
  2661. }
  2663. if ($token['type'] === Lexer::T_MEMBER) {
  2664. return $this->CollectionMemberExpression();
  2665. }
  2667. assert($lookahead !== null);
  2668. if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_NULL) {
  2669. return $this->NullComparisonExpression();
  2670. }
  2672. if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_EMPTY) {
  2673. return $this->EmptyCollectionComparisonExpression();
  2674. }
  2676. return $this->ComparisonExpression();
  2677. }
  2679. /**
  2680. * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
  2681. *
  2682. * @return AST\EmptyCollectionComparisonExpression
  2683. */
  2684. public function EmptyCollectionComparisonExpression()
  2685. {
  2686. $pathExpression = $this->CollectionValuedPathExpression();
  2687. $this->match(Lexer::T_IS);
  2689. $not = false;
  2690. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2691. $this->match(Lexer::T_NOT);
  2692. $not = true;
  2693. }
  2695. $this->match(Lexer::T_EMPTY);
  2697. return new AST\EmptyCollectionComparisonExpression(
  2698. $pathExpression,
  2699. $not
  2700. );
  2701. }
  2703. /**
  2704. * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
  2705. *
  2706. * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2707. * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2708. *
  2709. * @return AST\CollectionMemberExpression
  2710. */
  2711. public function CollectionMemberExpression()
  2712. {
  2713. $not = false;
  2714. $entityExpr = $this->EntityExpression();
  2716. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2717. $this->match(Lexer::T_NOT);
  2719. $not = true;
  2720. }
  2722. $this->match(Lexer::T_MEMBER);
  2724. if ($this->lexer->isNextToken(Lexer::T_OF)) {
  2725. $this->match(Lexer::T_OF);
  2726. }
  2728. return new AST\CollectionMemberExpression(
  2729. $entityExpr,
  2730. $this->CollectionValuedPathExpression(),
  2731. $not
  2732. );
  2733. }
  2735. /**
  2736. * Literal ::= string | char | integer | float | boolean
  2737. *
  2738. * @return AST\Literal
  2739. */
  2740. public function Literal()
  2741. {
  2742. assert($this->lexer->lookahead !== null);
  2743. assert($this->lexer->token !== null);
  2744. switch ($this->lexer->lookahead['type']) {
  2745. case Lexer::T_STRING:
  2746. $this->match(Lexer::T_STRING);
  2748. return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  2750. case Lexer::T_INTEGER:
  2751. case Lexer::T_FLOAT:
  2752. $this->match(
  2753. $this->lexer->isNextToken(Lexer::T_INTEGER) ? Lexer::T_INTEGER : Lexer::T_FLOAT
  2754. );
  2756. return new AST\Literal(AST\Literal::NUMERIC, $this->lexer->token['value']);
  2758. case Lexer::T_TRUE:
  2759. case Lexer::T_FALSE:
  2760. $this->match(
  2761. $this->lexer->isNextToken(Lexer::T_TRUE) ? Lexer::T_TRUE : Lexer::T_FALSE
  2762. );
  2764. return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2766. default:
  2767. $this->syntaxError('Literal');
  2768. }
  2769. }
  2771. /**
  2772. * InParameter ::= ArithmeticExpression | InputParameter
  2773. *
  2774. * @return AST\InputParameter|AST\ArithmeticExpression
  2775. */
  2776. public function InParameter()
  2777. {
  2778. assert($this->lexer->lookahead !== null);
  2779. if ($this->lexer->lookahead['type'] === Lexer::T_INPUT_PARAMETER) {
  2780. return $this->InputParameter();
  2781. }
  2783. return $this->ArithmeticExpression();
  2784. }
  2786. /**
  2787. * InputParameter ::= PositionalParameter | NamedParameter
  2788. *
  2789. * @return AST\InputParameter
  2790. */
  2791. public function InputParameter()
  2792. {
  2793. $this->match(Lexer::T_INPUT_PARAMETER);
  2794. assert($this->lexer->token !== null);
  2796. return new AST\InputParameter($this->lexer->token['value']);
  2797. }
  2799. /**
  2800. * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
  2801. *
  2802. * @return AST\ArithmeticExpression
  2803. */
  2804. public function ArithmeticExpression()
  2805. {
  2806. $expr = new AST\ArithmeticExpression();
  2808. if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2809. $peek = $this->lexer->glimpse();
  2810. assert($peek !== null);
  2812. if ($peek['type'] === Lexer::T_SELECT) {
  2813. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2814. $expr->subselect = $this->Subselect();
  2815. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2817. return $expr;
  2818. }
  2819. }
  2821. $expr->simpleArithmeticExpression = $this->SimpleArithmeticExpression();
  2823. return $expr;
  2824. }
  2826. /**
  2827. * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
  2828. *
  2829. * @return AST\SimpleArithmeticExpression|AST\ArithmeticTerm
  2830. */
  2831. public function SimpleArithmeticExpression()
  2832. {
  2833. $terms = [];
  2834. $terms[] = $this->ArithmeticTerm();
  2836. while (($isPlus = $this->lexer->isNextToken(Lexer::T_PLUS)) || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2837. $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2839. assert($this->lexer->token !== null);
  2840. $terms[] = $this->lexer->token['value'];
  2841. $terms[] = $this->ArithmeticTerm();
  2842. }
  2844. // Phase 1 AST optimization: Prevent AST\SimpleArithmeticExpression
  2845. // if only one AST\ArithmeticTerm is defined
  2846. if (count($terms) === 1) {
  2847. return $terms[0];
  2848. }
  2850. return new AST\SimpleArithmeticExpression($terms);
  2851. }
  2853. /**
  2854. * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
  2855. *
  2856. * @return AST\ArithmeticTerm
  2857. */
  2858. public function ArithmeticTerm()
  2859. {
  2860. $factors = [];
  2861. $factors[] = $this->ArithmeticFactor();
  2863. while (($isMult = $this->lexer->isNextToken(Lexer::T_MULTIPLY)) || $this->lexer->isNextToken(Lexer::T_DIVIDE)) {
  2864. $this->match($isMult ? Lexer::T_MULTIPLY : Lexer::T_DIVIDE);
  2866. assert($this->lexer->token !== null);
  2867. $factors[] = $this->lexer->token['value'];
  2868. $factors[] = $this->ArithmeticFactor();
  2869. }
  2871. // Phase 1 AST optimization: Prevent AST\ArithmeticTerm
  2872. // if only one AST\ArithmeticFactor is defined
  2873. if (count($factors) === 1) {
  2874. return $factors[0];
  2875. }
  2877. return new AST\ArithmeticTerm($factors);
  2878. }
  2880. /**
  2881. * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
  2882. *
  2883. * @return AST\ArithmeticFactor
  2884. */
  2885. public function ArithmeticFactor()
  2886. {
  2887. $sign = null;
  2889. $isPlus = $this->lexer->isNextToken(Lexer::T_PLUS);
  2890. if ($isPlus || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2891. $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2892. $sign = $isPlus;
  2893. }
  2895. $primary = $this->ArithmeticPrimary();
  2897. // Phase 1 AST optimization: Prevent AST\ArithmeticFactor
  2898. // if only one AST\ArithmeticPrimary is defined
  2899. if ($sign === null) {
  2900. return $primary;
  2901. }
  2903. return new AST\ArithmeticFactor($primary, $sign);
  2904. }
  2906. /**
  2907. * ArithmeticPrimary ::= SingleValuedPathExpression | Literal | ParenthesisExpression
  2908. * | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings
  2909. * | FunctionsReturningDatetime | IdentificationVariable | ResultVariable
  2910. * | InputParameter | CaseExpression
  2911. *
  2912. * @return AST\Node|string
  2913. */
  2914. public function ArithmeticPrimary()
  2915. {
  2916. if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2917. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2919. $expr = $this->SimpleArithmeticExpression();
  2921. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2923. return new AST\ParenthesisExpression($expr);
  2924. }
  2926. assert($this->lexer->lookahead !== null);
  2927. switch ($this->lexer->lookahead['type']) {
  2928. case Lexer::T_COALESCE:
  2929. case Lexer::T_NULLIF:
  2930. case Lexer::T_CASE:
  2931. return $this->CaseExpression();
  2933. case Lexer::T_IDENTIFIER:
  2934. $peek = $this->lexer->glimpse();
  2936. if ($peek !== null && $peek['value'] === '(') {
  2937. return $this->FunctionDeclaration();
  2938. }
  2940. if ($peek !== null && $peek['value'] === '.') {
  2941. return $this->SingleValuedPathExpression();
  2942. }
  2944. if (isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])) {
  2945. return $this->ResultVariable();
  2946. }
  2948. return $this->StateFieldPathExpression();
  2950. case Lexer::T_INPUT_PARAMETER:
  2951. return $this->InputParameter();
  2953. default:
  2954. $peek = $this->lexer->glimpse();
  2956. if ($peek !== null && $peek['value'] === '(') {
  2957. return $this->FunctionDeclaration();
  2958. }
  2960. return $this->Literal();
  2961. }
  2962. }
  2964. /**
  2965. * StringExpression ::= StringPrimary | ResultVariable | "(" Subselect ")"
  2966. *
  2967. * @return AST\Subselect|AST\Node|string
  2968. */
  2969. public function StringExpression()
  2970. {
  2971. $peek = $this->lexer->glimpse();
  2972. assert($peek !== null);
  2974. // Subselect
  2975. if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $peek['type'] === Lexer::T_SELECT) {
  2976. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2977. $expr = $this->Subselect();
  2978. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2980. return $expr;
  2981. }
  2983. assert($this->lexer->lookahead !== null);
  2984. // ResultVariable (string)
  2985. if (
  2986. $this->lexer->isNextToken(Lexer::T_IDENTIFIER) &&
  2987. isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])
  2988. ) {
  2989. return $this->ResultVariable();
  2990. }
  2992. return $this->StringPrimary();
  2993. }
  2995. /**
  2996. * StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression
  2997. *
  2998. * @return AST\Node
  2999. */
  3000. public function StringPrimary()
  3001. {
  3002. assert($this->lexer->lookahead !== null);
  3003. $lookaheadType = $this->lexer->lookahead['type'];
  3005. switch ($lookaheadType) {
  3006. case Lexer::T_IDENTIFIER:
  3007. $peek = $this->lexer->glimpse();
  3008. assert($peek !== null);
  3010. if ($peek['value'] === '.') {
  3011. return $this->StateFieldPathExpression();
  3012. }
  3014. if ($peek['value'] === '(') {
  3015. // do NOT directly go to FunctionsReturningString() because it doesn't check for custom functions.
  3016. return $this->FunctionDeclaration();
  3017. }
  3019. $this->syntaxError("'.' or '('");
  3020. break;
  3022. case Lexer::T_STRING:
  3023. $this->match(Lexer::T_STRING);
  3024. assert($this->lexer->token !== null);
  3026. return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3028. case Lexer::T_INPUT_PARAMETER:
  3029. return $this->InputParameter();
  3031. case Lexer::T_CASE:
  3032. case Lexer::T_COALESCE:
  3033. case Lexer::T_NULLIF:
  3034. return $this->CaseExpression();
  3036. default:
  3037. assert($lookaheadType !== null);
  3038. if ($this->isAggregateFunction($lookaheadType)) {
  3039. return $this->AggregateExpression();
  3040. }
  3041. }
  3043. $this->syntaxError(
  3044. 'StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression'
  3045. );
  3046. }
  3048. /**
  3049. * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  3050. *
  3051. * @return AST\InputParameter|AST\PathExpression
  3052. */
  3053. public function EntityExpression()
  3054. {
  3055. $glimpse = $this->lexer->glimpse();
  3056. assert($glimpse !== null);
  3058. if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER) && $glimpse['value'] === '.') {
  3059. return $this->SingleValuedAssociationPathExpression();
  3060. }
  3062. return $this->SimpleEntityExpression();
  3063. }
  3065. /**
  3066. * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  3067. *
  3068. * @return AST\InputParameter|AST\PathExpression
  3069. */
  3070. public function SimpleEntityExpression()
  3071. {
  3072. if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3073. return $this->InputParameter();
  3074. }
  3076. return $this->StateFieldPathExpression();
  3077. }
  3079. /**
  3080. * AggregateExpression ::=
  3081. * ("AVG" | "MAX" | "MIN" | "SUM" | "COUNT") "(" ["DISTINCT"] SimpleArithmeticExpression ")"
  3082. *
  3083. * @return AST\AggregateExpression
  3084. */
  3085. public function AggregateExpression()
  3086. {
  3087. assert($this->lexer->lookahead !== null);
  3088. $lookaheadType = $this->lexer->lookahead['type'];
  3089. $isDistinct = false;
  3091. if (! in_array($lookaheadType, [Lexer::T_COUNT, Lexer::T_AVG, Lexer::T_MAX, Lexer::T_MIN, Lexer::T_SUM], true)) {
  3092. $this->syntaxError('One of: MAX, MIN, AVG, SUM, COUNT');
  3093. }
  3095. $this->match($lookaheadType);
  3096. assert($this->lexer->token !== null);
  3097. $functionName = $this->lexer->token['value'];
  3098. $this->match(Lexer::T_OPEN_PARENTHESIS);
  3100. if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  3101. $this->match(Lexer::T_DISTINCT);
  3102. $isDistinct = true;
  3103. }
  3105. $pathExp = $this->SimpleArithmeticExpression();
  3107. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3109. return new AST\AggregateExpression($functionName, $pathExp, $isDistinct);
  3110. }
  3112. /**
  3113. * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
  3114. *
  3115. * @return AST\QuantifiedExpression
  3116. */
  3117. public function QuantifiedExpression()
  3118. {
  3119. assert($this->lexer->lookahead !== null);
  3120. $lookaheadType = $this->lexer->lookahead['type'];
  3121. $value = $this->lexer->lookahead['value'];
  3123. if (! in_array($lookaheadType, [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME], true)) {
  3124. $this->syntaxError('ALL, ANY or SOME');
  3125. }
  3127. $this->match($lookaheadType);
  3128. $this->match(Lexer::T_OPEN_PARENTHESIS);
  3130. $qExpr = new AST\QuantifiedExpression($this->Subselect());
  3131. $qExpr->type = $value;
  3133. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3135. return $qExpr;
  3136. }
  3138. /**
  3139. * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
  3140. *
  3141. * @return AST\BetweenExpression
  3142. */
  3143. public function BetweenExpression()
  3144. {
  3145. $not = false;
  3146. $arithExpr1 = $this->ArithmeticExpression();
  3148. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3149. $this->match(Lexer::T_NOT);
  3150. $not = true;
  3151. }
  3153. $this->match(Lexer::T_BETWEEN);
  3154. $arithExpr2 = $this->ArithmeticExpression();
  3155. $this->match(Lexer::T_AND);
  3156. $arithExpr3 = $this->ArithmeticExpression();
  3158. return new AST\BetweenExpression($arithExpr1, $arithExpr2, $arithExpr3, $not);
  3159. }
  3161. /**
  3162. * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )
  3163. *
  3164. * @return AST\ComparisonExpression
  3165. */
  3166. public function ComparisonExpression()
  3167. {
  3168. $this->lexer->glimpse();
  3170. $leftExpr = $this->ArithmeticExpression();
  3171. $operator = $this->ComparisonOperator();
  3172. $rightExpr = $this->isNextAllAnySome()
  3173. ? $this->QuantifiedExpression()
  3174. : $this->ArithmeticExpression();
  3176. return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
  3177. }
  3179. /**
  3180. * InExpression ::= SingleValuedPathExpression ["NOT"] "IN" "(" (InParameter {"," InParameter}* | Subselect) ")"
  3181. *
  3182. * @return AST\InListExpression|AST\InSubselectExpression
  3183. */
  3184. public function InExpression()
  3185. {
  3186. $expression = $this->ArithmeticExpression();
  3188. $not = false;
  3189. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3190. $this->match(Lexer::T_NOT);
  3191. $not = true;
  3192. }
  3194. $this->match(Lexer::T_IN);
  3195. $this->match(Lexer::T_OPEN_PARENTHESIS);
  3197. if ($this->lexer->isNextToken(Lexer::T_SELECT)) {
  3198. $inExpression = new AST\InSubselectExpression(
  3199. $expression,
  3200. $this->Subselect(),
  3201. $not
  3202. );
  3203. } else {
  3204. $literals = [$this->InParameter()];
  3206. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3207. $this->match(Lexer::T_COMMA);
  3208. $literals[] = $this->InParameter();
  3209. }
  3211. $inExpression = new AST\InListExpression(
  3212. $expression,
  3213. $literals,
  3214. $not
  3215. );
  3216. }
  3218. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3220. return $inExpression;
  3221. }
  3223. /**
  3224. * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
  3225. *
  3226. * @return AST\InstanceOfExpression
  3227. */
  3228. public function InstanceOfExpression()
  3229. {
  3230. $identificationVariable = $this->IdentificationVariable();
  3232. $not = false;
  3233. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3234. $this->match(Lexer::T_NOT);
  3235. $not = true;
  3236. }
  3238. $this->match(Lexer::T_INSTANCE);
  3239. $this->match(Lexer::T_OF);
  3241. $exprValues = $this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)
  3242. ? $this->InstanceOfParameterList()
  3243. : [$this->InstanceOfParameter()];
  3245. return new AST\InstanceOfExpression(
  3246. $identificationVariable,
  3247. $exprValues,
  3248. $not
  3249. );
  3250. }
  3252. /** @return non-empty-list<AST\InputParameter|string> */
  3253. public function InstanceOfParameterList(): array
  3254. {
  3255. $this->match(Lexer::T_OPEN_PARENTHESIS);
  3257. $exprValues = [$this->InstanceOfParameter()];
  3259. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3260. $this->match(Lexer::T_COMMA);
  3262. $exprValues[] = $this->InstanceOfParameter();
  3263. }
  3265. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3267. return $exprValues;
  3268. }
  3270. /**
  3271. * InstanceOfParameter ::= AbstractSchemaName | InputParameter
  3272. *
  3273. * @return AST\InputParameter|string
  3274. */
  3275. public function InstanceOfParameter()
  3276. {
  3277. if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3278. $this->match(Lexer::T_INPUT_PARAMETER);
  3279. assert($this->lexer->token !== null);
  3281. return new AST\InputParameter($this->lexer->token['value']);
  3282. }
  3284. $abstractSchemaName = $this->AbstractSchemaName();
  3286. $this->validateAbstractSchemaName($abstractSchemaName);
  3288. return $abstractSchemaName;
  3289. }
  3291. /**
  3292. * LikeExpression ::= StringExpression ["NOT"] "LIKE" StringPrimary ["ESCAPE" char]
  3293. *
  3294. * @return AST\LikeExpression
  3295. */
  3296. public function LikeExpression()
  3297. {
  3298. $stringExpr = $this->StringExpression();
  3299. $not = false;
  3301. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3302. $this->match(Lexer::T_NOT);
  3303. $not = true;
  3304. }
  3306. $this->match(Lexer::T_LIKE);
  3308. if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3309. $this->match(Lexer::T_INPUT_PARAMETER);
  3310. assert($this->lexer->token !== null);
  3311. $stringPattern = new AST\InputParameter($this->lexer->token['value']);
  3312. } else {
  3313. $stringPattern = $this->StringPrimary();
  3314. }
  3316. $escapeChar = null;
  3318. if ($this->lexer->lookahead !== null && $this->lexer->lookahead['type'] === Lexer::T_ESCAPE) {
  3319. $this->match(Lexer::T_ESCAPE);
  3320. $this->match(Lexer::T_STRING);
  3321. assert($this->lexer->token !== null);
  3323. $escapeChar = new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3324. }
  3326. return new AST\LikeExpression($stringExpr, $stringPattern, $escapeChar, $not);
  3327. }
  3329. /**
  3330. * NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) "IS" ["NOT"] "NULL"
  3331. *
  3332. * @return AST\NullComparisonExpression
  3333. */
  3334. public function NullComparisonExpression()
  3335. {
  3336. switch (true) {
  3337. case $this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER):
  3338. $this->match(Lexer::T_INPUT_PARAMETER);
  3339. assert($this->lexer->token !== null);
  3341. $expr = new AST\InputParameter($this->lexer->token['value']);
  3342. break;
  3344. case $this->lexer->isNextToken(Lexer::T_NULLIF):
  3345. $expr = $this->NullIfExpression();
  3346. break;
  3348. case $this->lexer->isNextToken(Lexer::T_COALESCE):
  3349. $expr = $this->CoalesceExpression();
  3350. break;
  3352. case $this->isFunction():
  3353. $expr = $this->FunctionDeclaration();
  3354. break;
  3356. default:
  3357. // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  3358. $glimpse = $this->lexer->glimpse();
  3359. assert($glimpse !== null);
  3361. if ($glimpse['type'] === Lexer::T_DOT) {
  3362. $expr = $this->SingleValuedPathExpression();
  3364. // Leave switch statement
  3365. break;
  3366. }
  3368. assert($this->lexer->lookahead !== null);
  3369. $lookaheadValue = $this->lexer->lookahead['value'];
  3371. // Validate existing component
  3372. if (! isset($this->queryComponents[$lookaheadValue])) {
  3373. $this->semanticalError('Cannot add having condition on undefined result variable.');
  3374. }
  3376. // Validate SingleValuedPathExpression (ie.: "product")
  3377. if (isset($this->queryComponents[$lookaheadValue]['metadata'])) {
  3378. $expr = $this->SingleValuedPathExpression();
  3379. break;
  3380. }
  3382. // Validating ResultVariable
  3383. if (! isset($this->queryComponents[$lookaheadValue]['resultVariable'])) {
  3384. $this->semanticalError('Cannot add having condition on a non result variable.');
  3385. }
  3387. $expr = $this->ResultVariable();
  3388. break;
  3389. }
  3391. $this->match(Lexer::T_IS);
  3393. $not = false;
  3394. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3395. $this->match(Lexer::T_NOT);
  3397. $not = true;
  3398. }
  3400. $this->match(Lexer::T_NULL);
  3402. return new AST\NullComparisonExpression($expr, $not);
  3403. }
  3405. /**
  3406. * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
  3407. *
  3408. * @return AST\ExistsExpression
  3409. */
  3410. public function ExistsExpression()
  3411. {
  3412. $not = false;
  3414. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3415. $this->match(Lexer::T_NOT);
  3416. $not = true;
  3417. }
  3419. $this->match(Lexer::T_EXISTS);
  3420. $this->match(Lexer::T_OPEN_PARENTHESIS);
  3422. $subselect = $this->Subselect();
  3424. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3426. return new AST\ExistsExpression($subselect, $not);
  3427. }
  3429. /**
  3430. * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
  3431. *
  3432. * @return string
  3433. */
  3434. public function ComparisonOperator()
  3435. {
  3436. assert($this->lexer->lookahead !== null);
  3437. switch ($this->lexer->lookahead['value']) {
  3438. case '=':
  3439. $this->match(Lexer::T_EQUALS);
  3441. return '=';
  3443. case '<':
  3444. $this->match(Lexer::T_LOWER_THAN);
  3445. $operator = '<';
  3447. if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3448. $this->match(Lexer::T_EQUALS);
  3449. $operator .= '=';
  3450. } elseif ($this->lexer->isNextToken(Lexer::T_GREATER_THAN)) {
  3451. $this->match(Lexer::T_GREATER_THAN);
  3452. $operator .= '>';
  3453. }
  3455. return $operator;
  3457. case '>':
  3458. $this->match(Lexer::T_GREATER_THAN);
  3459. $operator = '>';
  3461. if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3462. $this->match(Lexer::T_EQUALS);
  3463. $operator .= '=';
  3464. }
  3466. return $operator;
  3468. case '!':
  3469. $this->match(Lexer::T_NEGATE);
  3470. $this->match(Lexer::T_EQUALS);
  3472. return '<>';
  3474. default:
  3475. $this->syntaxError('=, <, <=, <>, >, >=, !=');
  3476. }
  3477. }
  3479. /**
  3480. * FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDatetime
  3481. *
  3482. * @return Functions\FunctionNode
  3483. */
  3484. public function FunctionDeclaration()
  3485. {
  3486. assert($this->lexer->lookahead !== null);
  3487. $token = $this->lexer->lookahead;
  3488. $funcName = strtolower($token['value']);
  3490. $customFunctionDeclaration = $this->CustomFunctionDeclaration();
  3492. // Check for custom functions functions first!
  3493. switch (true) {
  3494. case $customFunctionDeclaration !== null:
  3495. return $customFunctionDeclaration;
  3497. case isset(self::$stringFunctions[$funcName]):
  3498. return $this->FunctionsReturningStrings();
  3500. case isset(self::$numericFunctions[$funcName]):
  3501. return $this->FunctionsReturningNumerics();
  3503. case isset(self::$datetimeFunctions[$funcName]):
  3504. return $this->FunctionsReturningDatetime();
  3506. default:
  3507. $this->syntaxError('known function', $token);
  3508. }
  3509. }
  3511. /**
  3512. * Helper function for FunctionDeclaration grammar rule.
  3513. */
  3514. private function CustomFunctionDeclaration(): ?Functions\FunctionNode
  3515. {
  3516. assert($this->lexer->lookahead !== null);
  3517. $token = $this->lexer->lookahead;
  3518. $funcName = strtolower($token['value']);
  3520. // Check for custom functions afterwards
  3521. $config = $this->em->getConfiguration();
  3523. switch (true) {
  3524. case $config->getCustomStringFunction($funcName) !== null:
  3525. return $this->CustomFunctionsReturningStrings();
  3527. case $config->getCustomNumericFunction($funcName) !== null:
  3528. return $this->CustomFunctionsReturningNumerics();
  3530. case $config->getCustomDatetimeFunction($funcName) !== null:
  3531. return $this->CustomFunctionsReturningDatetime();
  3533. default:
  3534. return null;
  3535. }
  3536. }
  3538. /**
  3539. * FunctionsReturningNumerics ::=
  3540. * "LENGTH" "(" StringPrimary ")" |
  3541. * "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")" |
  3542. * "ABS" "(" SimpleArithmeticExpression ")" |
  3543. * "SQRT" "(" SimpleArithmeticExpression ")" |
  3544. * "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3545. * "SIZE" "(" CollectionValuedPathExpression ")" |
  3546. * "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3547. * "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3548. * "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
  3549. *
  3550. * @return Functions\FunctionNode
  3551. */
  3552. public function FunctionsReturningNumerics()
  3553. {
  3554. assert($this->lexer->lookahead !== null);
  3555. $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3556. $funcClass = self::$numericFunctions[$funcNameLower];
  3558. $function = new $funcClass($funcNameLower);
  3559. $function->parse($this);
  3561. return $function;
  3562. }
  3564. /** @return Functions\FunctionNode */
  3565. public function CustomFunctionsReturningNumerics()
  3566. {
  3567. assert($this->lexer->lookahead !== null);
  3568. // getCustomNumericFunction is case-insensitive
  3569. $functionName = strtolower($this->lexer->lookahead['value']);
  3570. $functionClass = $this->em->getConfiguration()->getCustomNumericFunction($functionName);
  3572. assert($functionClass !== null);
  3574. $function = is_string($functionClass)
  3575. ? new $functionClass($functionName)
  3576. : $functionClass($functionName);
  3578. $function->parse($this);
  3580. return $function;
  3581. }
  3583. /**
  3584. * FunctionsReturningDateTime ::=
  3585. * "CURRENT_DATE" |
  3586. * "CURRENT_TIME" |
  3587. * "CURRENT_TIMESTAMP" |
  3588. * "DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")" |
  3589. * "DATE_SUB" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
  3590. *
  3591. * @return Functions\FunctionNode
  3592. */
  3593. public function FunctionsReturningDatetime()
  3594. {
  3595. assert($this->lexer->lookahead !== null);
  3596. $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3597. $funcClass = self::$datetimeFunctions[$funcNameLower];
  3599. $function = new $funcClass($funcNameLower);
  3600. $function->parse($this);
  3602. return $function;
  3603. }
  3605. /** @return Functions\FunctionNode */
  3606. public function CustomFunctionsReturningDatetime()
  3607. {
  3608. assert($this->lexer->lookahead !== null);
  3609. // getCustomDatetimeFunction is case-insensitive
  3610. $functionName = $this->lexer->lookahead['value'];
  3611. $functionClass = $this->em->getConfiguration()->getCustomDatetimeFunction($functionName);
  3613. assert($functionClass !== null);
  3615. $function = is_string($functionClass)
  3616. ? new $functionClass($functionName)
  3617. : $functionClass($functionName);
  3619. $function->parse($this);
  3621. return $function;
  3622. }
  3624. /**
  3625. * FunctionsReturningStrings ::=
  3626. * "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary}* ")" |
  3627. * "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3628. * "TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")" |
  3629. * "LOWER" "(" StringPrimary ")" |
  3630. * "UPPER" "(" StringPrimary ")" |
  3631. * "IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
  3632. *
  3633. * @return Functions\FunctionNode
  3634. */
  3635. public function FunctionsReturningStrings()
  3636. {
  3637. assert($this->lexer->lookahead !== null);
  3638. $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3639. $funcClass = self::$stringFunctions[$funcNameLower];
  3641. $function = new $funcClass($funcNameLower);
  3642. $function->parse($this);
  3644. return $function;
  3645. }
  3647. /** @return Functions\FunctionNode */
  3648. public function CustomFunctionsReturningStrings()
  3649. {
  3650. assert($this->lexer->lookahead !== null);
  3651. // getCustomStringFunction is case-insensitive
  3652. $functionName = $this->lexer->lookahead['value'];
  3653. $functionClass = $this->em->getConfiguration()->getCustomStringFunction($functionName);
  3655. assert($functionClass !== null);
  3657. $function = is_string($functionClass)
  3658. ? new $functionClass($functionName)
  3659. : $functionClass($functionName);
  3661. $function->parse($this);
  3663. return $function;
  3664. }
  3666. private function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
  3667. {
  3668. if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
  3669. throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
  3670. }
  3672. return $this->queryComponents[$dqlAlias]['metadata'];
  3673. }
  3674. }