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

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Query;
  7. use Doctrine\Common\Lexer\Token;
  8. use Doctrine\Deprecations\Deprecation;
  9. use Doctrine\ORM\EntityManagerInterface;
  10. use Doctrine\ORM\Mapping\ClassMetadata;
  11. use Doctrine\ORM\Query;
  12. use Doctrine\ORM\Query\AST\Functions;
  13. use Doctrine\ORM\Query\Exec\SqlFinalizer;
  14. use LogicException;
  15. use ReflectionClass;
  17. use function array_intersect;
  18. use function array_search;
  19. use function assert;
  20. use function class_exists;
  21. use function count;
  22. use function explode;
  23. use function implode;
  24. use function in_array;
  25. use function interface_exists;
  26. use function is_string;
  27. use function sprintf;
  28. use function str_contains;
  29. use function strlen;
  30. use function strpos;
  31. use function strrpos;
  32. use function strtolower;
  33. use function substr;
  35. /**
  36. * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  37. * Parses a DQL query, reports any errors in it, and generates an AST.
  38. *
  39. * @phpstan-import-type AssociationMapping from ClassMetadata
  40. * @phpstan-type DqlToken = Token<TokenType::T_*, string>
  41. * @phpstan-type QueryComponent = array{
  42. * metadata?: ClassMetadata<object>,
  43. * parent?: string|null,
  44. * relation?: AssociationMapping|null,
  45. * map?: string|null,
  46. * resultVariable?: AST\Node|string,
  47. * nestingLevel: int,
  48. * token: DqlToken,
  49. * }
  50. */
  51. class Parser
  52. {
  53. /**
  54. * @readonly Maps BUILT-IN string function names to AST class names.
  55. * @var array<string, class-string<Functions\FunctionNode>>
  56. */
  57. private static $stringFunctions = [
  58. 'concat' => Functions\ConcatFunction::class,
  59. 'substring' => Functions\SubstringFunction::class,
  60. 'trim' => Functions\TrimFunction::class,
  61. 'lower' => Functions\LowerFunction::class,
  62. 'upper' => Functions\UpperFunction::class,
  63. 'identity' => Functions\IdentityFunction::class,
  64. ];
  66. /**
  67. * @readonly Maps BUILT-IN numeric function names to AST class names.
  68. * @var array<string, class-string<Functions\FunctionNode>>
  69. */
  70. private static $numericFunctions = [
  71. 'length' => Functions\LengthFunction::class,
  72. 'locate' => Functions\LocateFunction::class,
  73. 'abs' => Functions\AbsFunction::class,
  74. 'sqrt' => Functions\SqrtFunction::class,
  75. 'mod' => Functions\ModFunction::class,
  76. 'size' => Functions\SizeFunction::class,
  77. 'date_diff' => Functions\DateDiffFunction::class,
  78. 'bit_and' => Functions\BitAndFunction::class,
  79. 'bit_or' => Functions\BitOrFunction::class,
  81. // Aggregate functions
  82. 'min' => Functions\MinFunction::class,
  83. 'max' => Functions\MaxFunction::class,
  84. 'avg' => Functions\AvgFunction::class,
  85. 'sum' => Functions\SumFunction::class,
  86. 'count' => Functions\CountFunction::class,
  87. ];
  89. /**
  90. * @readonly Maps BUILT-IN datetime function names to AST class names.
  91. * @var array<string, class-string<Functions\FunctionNode>>
  92. */
  93. private static $datetimeFunctions = [
  94. 'current_date' => Functions\CurrentDateFunction::class,
  95. 'current_time' => Functions\CurrentTimeFunction::class,
  96. 'current_timestamp' => Functions\CurrentTimestampFunction::class,
  97. 'date_add' => Functions\DateAddFunction::class,
  98. 'date_sub' => Functions\DateSubFunction::class,
  99. ];
  101. /*
  102. * Expressions that were encountered during parsing of identifiers and expressions
  103. * and still need to be validated.
  104. */
  106. /** @phpstan-var list<array{token: DqlToken|null, expression: mixed, nestingLevel: int}> */
  107. private $deferredIdentificationVariables = [];
  109. /** @phpstan-var list<array{token: DqlToken|null, expression: AST\PartialObjectExpression, nestingLevel: int}> */
  110. private $deferredPartialObjectExpressions = [];
  112. /** @phpstan-var list<array{token: DqlToken|null, expression: AST\PathExpression, nestingLevel: int}> */
  113. private $deferredPathExpressions = [];
  115. /** @phpstan-var list<array{token: DqlToken|null, expression: mixed, nestingLevel: int}> */
  116. private $deferredResultVariables = [];
  118. /** @phpstan-var list<array{token: DqlToken|null, expression: AST\NewObjectExpression, nestingLevel: int}> */
  119. private $deferredNewObjectExpressions = [];
  121. /**
  122. * The lexer.
  123. *
  124. * @var Lexer
  125. */
  126. private $lexer;
  128. /**
  129. * The parser result.
  130. *
  131. * @var ParserResult
  132. */
  133. private $parserResult;
  135. /**
  136. * The EntityManager.
  137. *
  138. * @var EntityManagerInterface
  139. */
  140. private $em;
  142. /**
  143. * The Query to parse.
  144. *
  145. * @var Query
  146. */
  147. private $query;
  149. /**
  150. * Map of declared query components in the parsed query.
  151. *
  152. * @phpstan-var array<string, QueryComponent>
  153. */
  154. private $queryComponents = [];
  156. /**
  157. * Keeps the nesting level of defined ResultVariables.
  158. *
  159. * @var int
  160. */
  161. private $nestingLevel = 0;
  163. /**
  164. * Any additional custom tree walkers that modify the AST.
  165. *
  166. * @var list<class-string<TreeWalker>>
  167. */
  168. private $customTreeWalkers = [];
  170. /**
  171. * The custom last tree walker, if any, that is responsible for producing the output.
  172. *
  173. * @var class-string<SqlWalker>|null
  174. */
  175. private $customOutputWalker;
  177. /** @phpstan-var array<string, AST\SelectExpression> */
  178. private $identVariableExpressions = [];
  180. /**
  181. * Creates a new query parser object.
  182. *
  183. * @param Query $query The Query to parse.
  184. */
  185. public function __construct(Query $query)
  186. {
  187. $this->query = $query;
  188. $this->em = $query->getEntityManager();
  189. $this->lexer = new Lexer((string) $query->getDQL());
  190. $this->parserResult = new ParserResult();
  191. }
  193. /**
  194. * Sets a custom tree walker that produces output.
  195. * This tree walker will be run last over the AST, after any other walkers.
  196. *
  197. * @param class-string<SqlWalker> $className
  198. *
  199. * @return void
  200. */
  201. public function setCustomOutputTreeWalker($className)
  202. {
  203. Deprecation::trigger(
  204. 'doctrine/orm',
  205. 'https://github.com/doctrine/orm/pull/11641',
  206. '%s is deprecated, set the output walker class with the \Doctrine\ORM\Query::HINT_CUSTOM_OUTPUT_WALKER query hint instead',
  207. __METHOD__
  208. );
  210. $this->customOutputWalker = $className;
  211. }
  213. /**
  214. * Adds a custom tree walker for modifying the AST.
  215. *
  216. * @param class-string<TreeWalker> $className
  217. *
  218. * @return void
  219. */
  220. public function addCustomTreeWalker($className)
  221. {
  222. $this->customTreeWalkers[] = $className;
  223. }
  225. /**
  226. * Gets the lexer used by the parser.
  227. *
  228. * @return Lexer
  229. */
  230. public function getLexer()
  231. {
  232. return $this->lexer;
  233. }
  235. /**
  236. * Gets the ParserResult that is being filled with information during parsing.
  237. *
  238. * @return ParserResult
  239. */
  240. public function getParserResult()
  241. {
  242. return $this->parserResult;
  243. }
  245. /**
  246. * Gets the EntityManager used by the parser.
  247. *
  248. * @return EntityManagerInterface
  249. */
  250. public function getEntityManager()
  251. {
  252. return $this->em;
  253. }
  255. /**
  256. * Parses and builds AST for the given Query.
  257. *
  258. * @return AST\SelectStatement|AST\UpdateStatement|AST\DeleteStatement
  259. */
  260. public function getAST()
  261. {
  262. // Parse & build AST
  263. $AST = $this->QueryLanguage();
  265. // Process any deferred validations of some nodes in the AST.
  266. // This also allows post-processing of the AST for modification purposes.
  267. $this->processDeferredIdentificationVariables();
  269. if ($this->deferredPartialObjectExpressions) {
  270. $this->processDeferredPartialObjectExpressions();
  271. }
  273. if ($this->deferredPathExpressions) {
  274. $this->processDeferredPathExpressions();
  275. }
  277. if ($this->deferredResultVariables) {
  278. $this->processDeferredResultVariables();
  279. }
  281. if ($this->deferredNewObjectExpressions) {
  282. $this->processDeferredNewObjectExpressions($AST);
  283. }
  285. $this->processRootEntityAliasSelected();
  287. // TODO: Is there a way to remove this? It may impact the mixed hydration resultset a lot!
  288. $this->fixIdentificationVariableOrder($AST);
  290. return $AST;
  291. }
  293. /**
  294. * Attempts to match the given token with the current lookahead token.
  295. *
  296. * If they match, updates the lookahead token; otherwise raises a syntax
  297. * error.
  298. *
  299. * @param TokenType::T_* $token The token type.
  300. *
  301. * @return void
  302. *
  303. * @throws QueryException If the tokens don't match.
  304. */
  305. public function match($token)
  306. {
  307. $lookaheadType = $this->lexer->lookahead->type ?? null;
  309. // Short-circuit on first condition, usually types match
  310. if ($lookaheadType === $token) {
  311. $this->lexer->moveNext();
  313. return;
  314. }
  316. // If parameter is not identifier (1-99) must be exact match
  317. if ($token < TokenType::T_IDENTIFIER) {
  318. $this->syntaxError($this->lexer->getLiteral($token));
  319. }
  321. // If parameter is keyword (200+) must be exact match
  322. if ($token > TokenType::T_IDENTIFIER) {
  323. $this->syntaxError($this->lexer->getLiteral($token));
  324. }
  326. // If parameter is T_IDENTIFIER, then matches T_IDENTIFIER (100) and keywords (200+)
  327. if ($token === TokenType::T_IDENTIFIER && $lookaheadType < TokenType::T_IDENTIFIER) {
  328. $this->syntaxError($this->lexer->getLiteral($token));
  329. }
  331. $this->lexer->moveNext();
  332. }
  334. /**
  335. * Frees this parser, enabling it to be reused.
  336. *
  337. * @param bool $deep Whether to clean peek and reset errors.
  338. * @param int $position Position to reset.
  339. *
  340. * @return void
  341. */
  342. public function free($deep = false, $position = 0)
  343. {
  344. // WARNING! Use this method with care. It resets the scanner!
  345. $this->lexer->resetPosition($position);
  347. // Deep = true cleans peek and also any previously defined errors
  348. if ($deep) {
  349. $this->lexer->resetPeek();
  350. }
  352. $this->lexer->token = null;
  353. $this->lexer->lookahead = null;
  354. }
  356. /**
  357. * Parses a query string.
  358. *
  359. * @return ParserResult
  360. */
  361. public function parse()
  362. {
  363. $AST = $this->getAST();
  365. $customWalkers = $this->query->getHint(Query::HINT_CUSTOM_TREE_WALKERS);
  366. if ($customWalkers !== false) {
  367. $this->customTreeWalkers = $customWalkers;
  368. }
  370. $customOutputWalker = $this->query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER);
  371. if ($customOutputWalker !== false) {
  372. $this->customOutputWalker = $customOutputWalker;
  373. }
  375. // Run any custom tree walkers over the AST
  376. if ($this->customTreeWalkers) {
  377. $treeWalkerChain = new TreeWalkerChain($this->query, $this->parserResult, $this->queryComponents);
  379. foreach ($this->customTreeWalkers as $walker) {
  380. $treeWalkerChain->addTreeWalker($walker);
  381. }
  383. switch (true) {
  384. case $AST instanceof AST\UpdateStatement:
  385. $treeWalkerChain->walkUpdateStatement($AST);
  386. break;
  388. case $AST instanceof AST\DeleteStatement:
  389. $treeWalkerChain->walkDeleteStatement($AST);
  390. break;
  392. case $AST instanceof AST\SelectStatement:
  393. default:
  394. $treeWalkerChain->walkSelectStatement($AST);
  395. }
  397. $this->queryComponents = $treeWalkerChain->getQueryComponents();
  398. }
  400. $outputWalkerClass = $this->customOutputWalker ?: SqlOutputWalker::class;
  401. $outputWalker = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
  403. if ($outputWalker instanceof OutputWalker) {
  404. $finalizer = $outputWalker->getFinalizer($AST);
  405. $this->parserResult->setSqlFinalizer($finalizer);
  406. } else {
  407. Deprecation::trigger(
  408. 'doctrine/orm',
  409. 'https://github.com/doctrine/orm/pull/11188/',
  410. 'Your output walker class %s should implement %s in order to provide a %s. This also means the output walker should not use the query firstResult/maxResult values, which should be read from the query by the SqlFinalizer only.',
  411. $outputWalkerClass,
  412. OutputWalker::class,
  413. SqlFinalizer::class
  414. );
  415. // @phpstan-ignore method.deprecated
  416. $executor = $outputWalker->getExecutor($AST);
  417. // @phpstan-ignore method.deprecated
  418. $this->parserResult->setSqlExecutor($executor);
  419. }
  421. return $this->parserResult;
  422. }
  424. /**
  425. * Fixes order of identification variables.
  426. *
  427. * They have to appear in the select clause in the same order as the
  428. * declarations (from ... x join ... y join ... z ...) appear in the query
  429. * as the hydration process relies on that order for proper operation.
  430. *
  431. * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST
  432. */
  433. private function fixIdentificationVariableOrder(AST\Node $AST): void
  434. {
  435. if (count($this->identVariableExpressions) <= 1) {
  436. return;
  437. }
  439. assert($AST instanceof AST\SelectStatement);
  441. foreach ($this->queryComponents as $dqlAlias => $qComp) {
  442. if (! isset($this->identVariableExpressions[$dqlAlias])) {
  443. continue;
  444. }
  446. $expr = $this->identVariableExpressions[$dqlAlias];
  447. $key = array_search($expr, $AST->selectClause->selectExpressions, true);
  449. unset($AST->selectClause->selectExpressions[$key]);
  451. $AST->selectClause->selectExpressions[] = $expr;
  452. }
  453. }
  455. /**
  456. * Generates a new syntax error.
  457. *
  458. * @param string $expected Expected string.
  459. * @param mixed[]|null $token Got token.
  460. * @phpstan-param DqlToken|null $token
  461. *
  462. * @return void
  463. * @phpstan-return no-return
  464. *
  465. * @throws QueryException
  466. */
  467. public function syntaxError($expected = '', $token = null)
  468. {
  469. if ($token === null) {
  470. $token = $this->lexer->lookahead;
  471. }
  473. $tokenPos = $token->position ?? '-1';
  475. $message = sprintf('line 0, col %d: Error: ', $tokenPos);
  476. $message .= $expected !== '' ? sprintf('Expected %s, got ', $expected) : 'Unexpected ';
  477. $message .= $this->lexer->lookahead === null ? 'end of string.' : sprintf("'%s'", $token->value);
  479. throw QueryException::syntaxError($message, QueryException::dqlError($this->query->getDQL() ?? ''));
  480. }
  482. /**
  483. * Generates a new semantical error.
  484. *
  485. * @param string $message Optional message.
  486. * @param mixed[]|null $token Optional token.
  487. * @phpstan-param DqlToken|null $token
  488. *
  489. * @return void
  490. * @phpstan-return no-return
  491. *
  492. * @throws QueryException
  493. */
  494. public function semanticalError($message = '', $token = null)
  495. {
  496. if ($token === null) {
  497. $token = $this->lexer->lookahead ?? new Token('fake token', 42, 0);
  498. }
  500. // Minimum exposed chars ahead of token
  501. $distance = 12;
  503. // Find a position of a final word to display in error string
  504. $dql = $this->query->getDQL();
  505. $length = strlen($dql);
  506. $pos = $token->position + $distance;
  507. $pos = strpos($dql, ' ', $length > $pos ? $pos : $length);
  508. $length = $pos !== false ? $pos - $token->position : $distance;
  510. $tokenPos = $token->position > 0 ? $token->position : '-1';
  511. $tokenStr = substr($dql, $token->position, $length);
  513. // Building informative message
  514. $message = 'line 0, col ' . $tokenPos . " near '" . $tokenStr . "': Error: " . $message;
  516. throw QueryException::semanticalError($message, QueryException::dqlError($this->query->getDQL()));
  517. }
  519. /**
  520. * Peeks beyond the matched closing parenthesis and returns the first token after that one.
  521. *
  522. * @param bool $resetPeek Reset peek after finding the closing parenthesis.
  523. *
  524. * @return mixed[]
  525. * @phpstan-return DqlToken|null
  526. */
  527. private function peekBeyondClosingParenthesis(bool $resetPeek = true)
  528. {
  529. $token = $this->lexer->peek();
  530. $numUnmatched = 1;
  532. while ($numUnmatched > 0 && $token !== null) {
  533. switch ($token->type) {
  534. case TokenType::T_OPEN_PARENTHESIS:
  535. ++$numUnmatched;
  536. break;
  538. case TokenType::T_CLOSE_PARENTHESIS:
  539. --$numUnmatched;
  540. break;
  542. default:
  543. // Do nothing
  544. }
  546. $token = $this->lexer->peek();
  547. }
  549. if ($resetPeek) {
  550. $this->lexer->resetPeek();
  551. }
  553. return $token;
  554. }
  556. /**
  557. * Checks if the given token indicates a mathematical operator.
  558. *
  559. * @phpstan-param DqlToken|null $token
  560. */
  561. private function isMathOperator($token): bool
  562. {
  563. return $token !== null && in_array($token->type, [TokenType::T_PLUS, TokenType::T_MINUS, TokenType::T_DIVIDE, TokenType::T_MULTIPLY], true);
  564. }
  566. /**
  567. * Checks if the next-next (after lookahead) token starts a function.
  568. *
  569. * @return bool TRUE if the next-next tokens start a function, FALSE otherwise.
  570. */
  571. private function isFunction(): bool
  572. {
  573. assert($this->lexer->lookahead !== null);
  574. $lookaheadType = $this->lexer->lookahead->type;
  575. $peek = $this->lexer->peek();
  577. $this->lexer->resetPeek();
  579. return $lookaheadType >= TokenType::T_IDENTIFIER && $peek !== null && $peek->type === TokenType::T_OPEN_PARENTHESIS;
  580. }
  582. /**
  583. * Checks whether the given token type indicates an aggregate function.
  584. *
  585. * @phpstan-param TokenType::T_* $tokenType
  586. *
  587. * @return bool TRUE if the token type is an aggregate function, FALSE otherwise.
  588. */
  589. private function isAggregateFunction(int $tokenType): bool
  590. {
  591. return in_array(
  592. $tokenType,
  593. [TokenType::T_AVG, TokenType::T_MIN, TokenType::T_MAX, TokenType::T_SUM, TokenType::T_COUNT],
  594. true
  595. );
  596. }
  598. /**
  599. * Checks whether the current lookahead token of the lexer has the type T_ALL, T_ANY or T_SOME.
  600. */
  601. private function isNextAllAnySome(): bool
  602. {
  603. assert($this->lexer->lookahead !== null);
  605. return in_array(
  606. $this->lexer->lookahead->type,
  607. [TokenType::T_ALL, TokenType::T_ANY, TokenType::T_SOME],
  608. true
  609. );
  610. }
  612. /**
  613. * Validates that the given <tt>IdentificationVariable</tt> is semantically correct.
  614. * It must exist in query components list.
  615. */
  616. private function processDeferredIdentificationVariables(): void
  617. {
  618. foreach ($this->deferredIdentificationVariables as $deferredItem) {
  619. $identVariable = $deferredItem['expression'];
  621. // Check if IdentificationVariable exists in queryComponents
  622. if (! isset($this->queryComponents[$identVariable])) {
  623. $this->semanticalError(
  624. sprintf("'%s' is not defined.", $identVariable),
  625. $deferredItem['token']
  626. );
  627. }
  629. $qComp = $this->queryComponents[$identVariable];
  631. // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  632. if (! isset($qComp['metadata'])) {
  633. $this->semanticalError(
  634. sprintf("'%s' does not point to a Class.", $identVariable),
  635. $deferredItem['token']
  636. );
  637. }
  639. // Validate if identification variable nesting level is lower or equal than the current one
  640. if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  641. $this->semanticalError(
  642. sprintf("'%s' is used outside the scope of its declaration.", $identVariable),
  643. $deferredItem['token']
  644. );
  645. }
  646. }
  647. }
  649. /**
  650. * Validates that the given <tt>NewObjectExpression</tt>.
  651. */
  652. private function processDeferredNewObjectExpressions(AST\SelectStatement $AST): void
  653. {
  654. foreach ($this->deferredNewObjectExpressions as $deferredItem) {
  655. $expression = $deferredItem['expression'];
  656. $token = $deferredItem['token'];
  657. $className = $expression->className;
  658. $args = $expression->args;
  659. $fromClassName = $AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName ?? null;
  661. // If the namespace is not given then assumes the first FROM entity namespace
  662. if (! str_contains($className, '\\') && ! class_exists($className) && is_string($fromClassName) && str_contains($fromClassName, '\\')) {
  663. $namespace = substr($fromClassName, 0, strrpos($fromClassName, '\\'));
  664. $fqcn = $namespace . '\\' . $className;
  666. if (class_exists($fqcn)) {
  667. $expression->className = $fqcn;
  668. $className = $fqcn;
  669. }
  670. }
  672. if (! class_exists($className)) {
  673. $this->semanticalError(sprintf('Class "%s" is not defined.', $className), $token);
  674. }
  676. $class = new ReflectionClass($className);
  678. if (! $class->isInstantiable()) {
  679. $this->semanticalError(sprintf('Class "%s" can not be instantiated.', $className), $token);
  680. }
  682. if ($class->getConstructor() === null) {
  683. $this->semanticalError(sprintf('Class "%s" has not a valid constructor.', $className), $token);
  684. }
  686. if ($class->getConstructor()->getNumberOfRequiredParameters() > count($args)) {
  687. $this->semanticalError(sprintf('Number of arguments does not match with "%s" constructor declaration.', $className), $token);
  688. }
  689. }
  690. }
  692. /**
  693. * Validates that the given <tt>PartialObjectExpression</tt> is semantically correct.
  694. * It must exist in query components list.
  695. */
  696. private function processDeferredPartialObjectExpressions(): void
  697. {
  698. foreach ($this->deferredPartialObjectExpressions as $deferredItem) {
  699. $expr = $deferredItem['expression'];
  700. $class = $this->getMetadataForDqlAlias($expr->identificationVariable);
  702. foreach ($expr->partialFieldSet as $field) {
  703. if (isset($class->fieldMappings[$field])) {
  704. continue;
  705. }
  707. if (
  708. isset($class->associationMappings[$field]) &&
  709. $class->associationMappings[$field]['isOwningSide'] &&
  710. $class->associationMappings[$field]['type'] & ClassMetadata::TO_ONE
  711. ) {
  712. continue;
  713. }
  715. $this->semanticalError(sprintf(
  716. "There is no mapped field named '%s' on class %s.",
  717. $field,
  718. $class->name
  719. ), $deferredItem['token']);
  720. }
  722. if (array_intersect($class->identifier, $expr->partialFieldSet) !== $class->identifier) {
  723. $this->semanticalError(
  724. 'The partial field selection of class ' . $class->name . ' must contain the identifier.',
  725. $deferredItem['token']
  726. );
  727. }
  728. }
  729. }
  731. /**
  732. * Validates that the given <tt>ResultVariable</tt> is semantically correct.
  733. * It must exist in query components list.
  734. */
  735. private function processDeferredResultVariables(): void
  736. {
  737. foreach ($this->deferredResultVariables as $deferredItem) {
  738. $resultVariable = $deferredItem['expression'];
  740. // Check if ResultVariable exists in queryComponents
  741. if (! isset($this->queryComponents[$resultVariable])) {
  742. $this->semanticalError(
  743. sprintf("'%s' is not defined.", $resultVariable),
  744. $deferredItem['token']
  745. );
  746. }
  748. $qComp = $this->queryComponents[$resultVariable];
  750. // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  751. if (! isset($qComp['resultVariable'])) {
  752. $this->semanticalError(
  753. sprintf("'%s' does not point to a ResultVariable.", $resultVariable),
  754. $deferredItem['token']
  755. );
  756. }
  758. // Validate if identification variable nesting level is lower or equal than the current one
  759. if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  760. $this->semanticalError(
  761. sprintf("'%s' is used outside the scope of its declaration.", $resultVariable),
  762. $deferredItem['token']
  763. );
  764. }
  765. }
  766. }
  768. /**
  769. * Validates that the given <tt>PathExpression</tt> is semantically correct for grammar rules:
  770. *
  771. * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  772. * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  773. * StateFieldPathExpression ::= IdentificationVariable "." StateField
  774. * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  775. * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  776. */
  777. private function processDeferredPathExpressions(): void
  778. {
  779. foreach ($this->deferredPathExpressions as $deferredItem) {
  780. $pathExpression = $deferredItem['expression'];
  782. $class = $this->getMetadataForDqlAlias($pathExpression->identificationVariable);
  784. $field = $pathExpression->field;
  785. if ($field === null) {
  786. $field = $pathExpression->field = $class->identifier[0];
  787. }
  789. // Check if field or association exists
  790. if (! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
  791. $this->semanticalError(
  792. 'Class ' . $class->name . ' has no field or association named ' . $field,
  793. $deferredItem['token']
  794. );
  795. }
  797. $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
  799. if (isset($class->associationMappings[$field])) {
  800. $assoc = $class->associationMappings[$field];
  802. $fieldType = $assoc['type'] & ClassMetadata::TO_ONE
  803. ? AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  804. : AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
  805. }
  807. // Validate if PathExpression is one of the expected types
  808. $expectedType = $pathExpression->expectedType;
  810. if (! ($expectedType & $fieldType)) {
  811. // We need to recognize which was expected type(s)
  812. $expectedStringTypes = [];
  814. // Validate state field type
  815. if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
  816. $expectedStringTypes[] = 'StateFieldPathExpression';
  817. }
  819. // Validate single valued association (*-to-one)
  820. if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
  821. $expectedStringTypes[] = 'SingleValuedAssociationField';
  822. }
  824. // Validate single valued association (*-to-many)
  825. if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
  826. $expectedStringTypes[] = 'CollectionValuedAssociationField';
  827. }
  829. // Build the error message
  830. $semanticalError = 'Invalid PathExpression. ';
  831. $semanticalError .= count($expectedStringTypes) === 1
  832. ? 'Must be a ' . $expectedStringTypes[0] . '.'
  833. : implode(' or ', $expectedStringTypes) . ' expected.';
  835. $this->semanticalError($semanticalError, $deferredItem['token']);
  836. }
  838. // We need to force the type in PathExpression
  839. $pathExpression->type = $fieldType;
  840. }
  841. }
  843. private function processRootEntityAliasSelected(): void
  844. {
  845. if (! count($this->identVariableExpressions)) {
  846. return;
  847. }
  849. foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
  850. if (isset($this->queryComponents[$dqlAlias]) && ! isset($this->queryComponents[$dqlAlias]['parent'])) {
  851. return;
  852. }
  853. }
  855. $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');
  856. }
  858. /**
  859. * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
  860. *
  861. * @return AST\SelectStatement|AST\UpdateStatement|AST\DeleteStatement
  862. */
  863. public function QueryLanguage()
  864. {
  865. $statement = null;
  867. $this->lexer->moveNext();
  869. switch ($this->lexer->lookahead->type ?? null) {
  870. case TokenType::T_SELECT:
  871. $statement = $this->SelectStatement();
  872. break;
  874. case TokenType::T_UPDATE:
  875. $statement = $this->UpdateStatement();
  876. break;
  878. case TokenType::T_DELETE:
  879. $statement = $this->DeleteStatement();
  880. break;
  882. default:
  883. $this->syntaxError('SELECT, UPDATE or DELETE');
  884. break;
  885. }
  887. // Check for end of string
  888. if ($this->lexer->lookahead !== null) {
  889. $this->syntaxError('end of string');
  890. }
  892. return $statement;
  893. }
  895. /**
  896. * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  897. *
  898. * @return AST\SelectStatement
  899. */
  900. public function SelectStatement()
  901. {
  902. $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());
  904. $selectStatement->whereClause = $this->lexer->isNextToken(TokenType::T_WHERE) ? $this->WhereClause() : null;
  905. $selectStatement->groupByClause = $this->lexer->isNextToken(TokenType::T_GROUP) ? $this->GroupByClause() : null;
  906. $selectStatement->havingClause = $this->lexer->isNextToken(TokenType::T_HAVING) ? $this->HavingClause() : null;
  907. $selectStatement->orderByClause = $this->lexer->isNextToken(TokenType::T_ORDER) ? $this->OrderByClause() : null;
  909. return $selectStatement;
  910. }
  912. /**
  913. * UpdateStatement ::= UpdateClause [WhereClause]
  914. *
  915. * @return AST\UpdateStatement
  916. */
  917. public function UpdateStatement()
  918. {
  919. $updateStatement = new AST\UpdateStatement($this->UpdateClause());
  921. $updateStatement->whereClause = $this->lexer->isNextToken(TokenType::T_WHERE) ? $this->WhereClause() : null;
  923. return $updateStatement;
  924. }
  926. /**
  927. * DeleteStatement ::= DeleteClause [WhereClause]
  928. *
  929. * @return AST\DeleteStatement
  930. */
  931. public function DeleteStatement()
  932. {
  933. $deleteStatement = new AST\DeleteStatement($this->DeleteClause());
  935. $deleteStatement->whereClause = $this->lexer->isNextToken(TokenType::T_WHERE) ? $this->WhereClause() : null;
  937. return $deleteStatement;
  938. }
  940. /**
  941. * IdentificationVariable ::= identifier
  942. *
  943. * @return string
  944. */
  945. public function IdentificationVariable()
  946. {
  947. $this->match(TokenType::T_IDENTIFIER);
  949. assert($this->lexer->token !== null);
  950. $identVariable = $this->lexer->token->value;
  952. $this->deferredIdentificationVariables[] = [
  953. 'expression' => $identVariable,
  954. 'nestingLevel' => $this->nestingLevel,
  955. 'token' => $this->lexer->token,
  956. ];
  958. return $identVariable;
  959. }
  961. /**
  962. * AliasIdentificationVariable = identifier
  963. *
  964. * @return string
  965. */
  966. public function AliasIdentificationVariable()
  967. {
  968. $this->match(TokenType::T_IDENTIFIER);
  970. assert($this->lexer->token !== null);
  971. $aliasIdentVariable = $this->lexer->token->value;
  972. $exists = isset($this->queryComponents[$aliasIdentVariable]);
  974. if ($exists) {
  975. $this->semanticalError(
  976. sprintf("'%s' is already defined.", $aliasIdentVariable),
  977. $this->lexer->token
  978. );
  979. }
  981. return $aliasIdentVariable;
  982. }
  984. /**
  985. * AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
  986. *
  987. * @return string
  988. */
  989. public function AbstractSchemaName()
  990. {
  991. if ($this->lexer->isNextToken(TokenType::T_FULLY_QUALIFIED_NAME)) {
  992. $this->match(TokenType::T_FULLY_QUALIFIED_NAME);
  993. assert($this->lexer->token !== null);
  995. return $this->lexer->token->value;
  996. }
  998. if ($this->lexer->isNextToken(TokenType::T_IDENTIFIER)) {
  999. $this->match(TokenType::T_IDENTIFIER);
  1000. assert($this->lexer->token !== null);
  1002. return $this->lexer->token->value;
  1003. }
  1005. // @phpstan-ignore classConstant.deprecated
  1006. $this->match(TokenType::T_ALIASED_NAME);
  1008. assert($this->lexer->token !== null);
  1010. Deprecation::trigger(
  1011. 'doctrine/orm',
  1012. 'https://github.com/doctrine/orm/issues/8818',
  1013. 'Short namespace aliases such as "%s" are deprecated and will be removed in Doctrine ORM 3.0.',
  1014. $this->lexer->token->value
  1015. );
  1017. [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token->value);
  1019. return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  1020. }
  1022. /**
  1023. * Validates an AbstractSchemaName, making sure the class exists.
  1024. *
  1025. * @param string $schemaName The name to validate.
  1026. *
  1027. * @throws QueryException if the name does not exist.
  1028. */
  1029. private function validateAbstractSchemaName(string $schemaName): void
  1030. {
  1031. assert($this->lexer->token !== null);
  1032. if (! (class_exists($schemaName, true) || interface_exists($schemaName, true))) {
  1033. $this->semanticalError(
  1034. sprintf("Class '%s' is not defined.", $schemaName),
  1035. $this->lexer->token
  1036. );
  1037. }
  1038. }
  1040. /**
  1041. * AliasResultVariable ::= identifier
  1042. *
  1043. * @return string
  1044. */
  1045. public function AliasResultVariable()
  1046. {
  1047. $this->match(TokenType::T_IDENTIFIER);
  1049. assert($this->lexer->token !== null);
  1050. $resultVariable = $this->lexer->token->value;
  1051. $exists = isset($this->queryComponents[$resultVariable]);
  1053. if ($exists) {
  1054. $this->semanticalError(
  1055. sprintf("'%s' is already defined.", $resultVariable),
  1056. $this->lexer->token
  1057. );
  1058. }
  1060. return $resultVariable;
  1061. }
  1063. /**
  1064. * ResultVariable ::= identifier
  1065. *
  1066. * @return string
  1067. */
  1068. public function ResultVariable()
  1069. {
  1070. $this->match(TokenType::T_IDENTIFIER);
  1072. assert($this->lexer->token !== null);
  1073. $resultVariable = $this->lexer->token->value;
  1075. // Defer ResultVariable validation
  1076. $this->deferredResultVariables[] = [
  1077. 'expression' => $resultVariable,
  1078. 'nestingLevel' => $this->nestingLevel,
  1079. 'token' => $this->lexer->token,
  1080. ];
  1082. return $resultVariable;
  1083. }
  1085. /**
  1086. * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
  1087. *
  1088. * @return AST\JoinAssociationPathExpression
  1089. */
  1090. public function JoinAssociationPathExpression()
  1091. {
  1092. $identVariable = $this->IdentificationVariable();
  1094. if (! isset($this->queryComponents[$identVariable])) {
  1095. $this->semanticalError(
  1096. 'Identification Variable ' . $identVariable . ' used in join path expression but was not defined before.'
  1097. );
  1098. }
  1100. $this->match(TokenType::T_DOT);
  1101. $this->match(TokenType::T_IDENTIFIER);
  1103. assert($this->lexer->token !== null);
  1104. $field = $this->lexer->token->value;
  1106. // Validate association field
  1107. $class = $this->getMetadataForDqlAlias($identVariable);
  1109. if (! $class->hasAssociation($field)) {
  1110. $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
  1111. }
  1113. return new AST\JoinAssociationPathExpression($identVariable, $field);
  1114. }
  1116. /**
  1117. * Parses an arbitrary path expression and defers semantical validation
  1118. * based on expected types.
  1119. *
  1120. * PathExpression ::= IdentificationVariable {"." identifier}*
  1121. *
  1122. * @param int $expectedTypes
  1123. * @phpstan-param int-mask-of<AST\PathExpression::TYPE_*> $expectedTypes
  1124. *
  1125. * @return AST\PathExpression
  1126. */
  1127. public function PathExpression($expectedTypes)
  1128. {
  1129. $identVariable = $this->IdentificationVariable();
  1130. $field = null;
  1132. assert($this->lexer->token !== null);
  1133. if ($this->lexer->isNextToken(TokenType::T_DOT)) {
  1134. $this->match(TokenType::T_DOT);
  1135. $this->match(TokenType::T_IDENTIFIER);
  1137. $field = $this->lexer->token->value;
  1139. while ($this->lexer->isNextToken(TokenType::T_DOT)) {
  1140. $this->match(TokenType::T_DOT);
  1141. $this->match(TokenType::T_IDENTIFIER);
  1142. $field .= '.' . $this->lexer->token->value;
  1143. }
  1144. }
  1146. // Creating AST node
  1147. $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);
  1149. // Defer PathExpression validation if requested to be deferred
  1150. $this->deferredPathExpressions[] = [
  1151. 'expression' => $pathExpr,
  1152. 'nestingLevel' => $this->nestingLevel,
  1153. 'token' => $this->lexer->token,
  1154. ];
  1156. return $pathExpr;
  1157. }
  1159. /**
  1160. * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  1161. *
  1162. * @return AST\PathExpression
  1163. */
  1164. public function AssociationPathExpression()
  1165. {
  1166. return $this->PathExpression(
  1167. AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |
  1168. AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION
  1169. );
  1170. }
  1172. /**
  1173. * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  1174. *
  1175. * @return AST\PathExpression
  1176. */
  1177. public function SingleValuedPathExpression()
  1178. {
  1179. return $this->PathExpression(
  1180. AST\PathExpression::TYPE_STATE_FIELD |
  1181. AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  1182. );
  1183. }
  1185. /**
  1186. * StateFieldPathExpression ::= IdentificationVariable "." StateField
  1187. *
  1188. * @return AST\PathExpression
  1189. */
  1190. public function StateFieldPathExpression()
  1191. {
  1192. return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);
  1193. }
  1195. /**
  1196. * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  1197. *
  1198. * @return AST\PathExpression
  1199. */
  1200. public function SingleValuedAssociationPathExpression()
  1201. {
  1202. return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);
  1203. }
  1205. /**
  1206. * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  1207. *
  1208. * @return AST\PathExpression
  1209. */
  1210. public function CollectionValuedPathExpression()
  1211. {
  1212. return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);
  1213. }
  1215. /**
  1216. * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
  1217. *
  1218. * @return AST\SelectClause
  1219. */
  1220. public function SelectClause()
  1221. {
  1222. $isDistinct = false;
  1223. $this->match(TokenType::T_SELECT);
  1225. // Check for DISTINCT
  1226. if ($this->lexer->isNextToken(TokenType::T_DISTINCT)) {
  1227. $this->match(TokenType::T_DISTINCT);
  1229. $isDistinct = true;
  1230. }
  1232. // Process SelectExpressions (1..N)
  1233. $selectExpressions = [];
  1234. $selectExpressions[] = $this->SelectExpression();
  1236. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1237. $this->match(TokenType::T_COMMA);
  1239. $selectExpressions[] = $this->SelectExpression();
  1240. }
  1242. return new AST\SelectClause($selectExpressions, $isDistinct);
  1243. }
  1245. /**
  1246. * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
  1247. *
  1248. * @return AST\SimpleSelectClause
  1249. */
  1250. public function SimpleSelectClause()
  1251. {
  1252. $isDistinct = false;
  1253. $this->match(TokenType::T_SELECT);
  1255. if ($this->lexer->isNextToken(TokenType::T_DISTINCT)) {
  1256. $this->match(TokenType::T_DISTINCT);
  1258. $isDistinct = true;
  1259. }
  1261. return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);
  1262. }
  1264. /**
  1265. * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*
  1266. *
  1267. * @return AST\UpdateClause
  1268. */
  1269. public function UpdateClause()
  1270. {
  1271. $this->match(TokenType::T_UPDATE);
  1272. assert($this->lexer->lookahead !== null);
  1274. $token = $this->lexer->lookahead;
  1275. $abstractSchemaName = $this->AbstractSchemaName();
  1277. $this->validateAbstractSchemaName($abstractSchemaName);
  1279. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  1280. $this->match(TokenType::T_AS);
  1281. }
  1283. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1285. $class = $this->em->getClassMetadata($abstractSchemaName);
  1287. // Building queryComponent
  1288. $queryComponent = [
  1289. 'metadata' => $class,
  1290. 'parent' => null,
  1291. 'relation' => null,
  1292. 'map' => null,
  1293. 'nestingLevel' => $this->nestingLevel,
  1294. 'token' => $token,
  1295. ];
  1297. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1299. $this->match(TokenType::T_SET);
  1301. $updateItems = [];
  1302. $updateItems[] = $this->UpdateItem();
  1304. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1305. $this->match(TokenType::T_COMMA);
  1307. $updateItems[] = $this->UpdateItem();
  1308. }
  1310. $updateClause = new AST\UpdateClause($abstractSchemaName, $updateItems);
  1311. $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1313. return $updateClause;
  1314. }
  1316. /**
  1317. * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable
  1318. *
  1319. * @return AST\DeleteClause
  1320. */
  1321. public function DeleteClause()
  1322. {
  1323. $this->match(TokenType::T_DELETE);
  1325. if ($this->lexer->isNextToken(TokenType::T_FROM)) {
  1326. $this->match(TokenType::T_FROM);
  1327. }
  1329. assert($this->lexer->lookahead !== null);
  1330. $token = $this->lexer->lookahead;
  1331. $abstractSchemaName = $this->AbstractSchemaName();
  1333. $this->validateAbstractSchemaName($abstractSchemaName);
  1335. $deleteClause = new AST\DeleteClause($abstractSchemaName);
  1337. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  1338. $this->match(TokenType::T_AS);
  1339. }
  1341. $aliasIdentificationVariable = $this->lexer->isNextToken(TokenType::T_IDENTIFIER)
  1342. ? $this->AliasIdentificationVariable()
  1343. : 'alias_should_have_been_set';
  1345. $deleteClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1346. $class = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1348. // Building queryComponent
  1349. $queryComponent = [
  1350. 'metadata' => $class,
  1351. 'parent' => null,
  1352. 'relation' => null,
  1353. 'map' => null,
  1354. 'nestingLevel' => $this->nestingLevel,
  1355. 'token' => $token,
  1356. ];
  1358. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1360. return $deleteClause;
  1361. }
  1363. /**
  1364. * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}*
  1365. *
  1366. * @return AST\FromClause
  1367. */
  1368. public function FromClause()
  1369. {
  1370. $this->match(TokenType::T_FROM);
  1372. $identificationVariableDeclarations = [];
  1373. $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1375. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1376. $this->match(TokenType::T_COMMA);
  1378. $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1379. }
  1381. return new AST\FromClause($identificationVariableDeclarations);
  1382. }
  1384. /**
  1385. * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
  1386. *
  1387. * @return AST\SubselectFromClause
  1388. */
  1389. public function SubselectFromClause()
  1390. {
  1391. $this->match(TokenType::T_FROM);
  1393. $identificationVariables = [];
  1394. $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1396. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1397. $this->match(TokenType::T_COMMA);
  1399. $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1400. }
  1402. return new AST\SubselectFromClause($identificationVariables);
  1403. }
  1405. /**
  1406. * WhereClause ::= "WHERE" ConditionalExpression
  1407. *
  1408. * @return AST\WhereClause
  1409. */
  1410. public function WhereClause()
  1411. {
  1412. $this->match(TokenType::T_WHERE);
  1414. return new AST\WhereClause($this->ConditionalExpression());
  1415. }
  1417. /**
  1418. * HavingClause ::= "HAVING" ConditionalExpression
  1419. *
  1420. * @return AST\HavingClause
  1421. */
  1422. public function HavingClause()
  1423. {
  1424. $this->match(TokenType::T_HAVING);
  1426. return new AST\HavingClause($this->ConditionalExpression());
  1427. }
  1429. /**
  1430. * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
  1431. *
  1432. * @return AST\GroupByClause
  1433. */
  1434. public function GroupByClause()
  1435. {
  1436. $this->match(TokenType::T_GROUP);
  1437. $this->match(TokenType::T_BY);
  1439. $groupByItems = [$this->GroupByItem()];
  1441. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1442. $this->match(TokenType::T_COMMA);
  1444. $groupByItems[] = $this->GroupByItem();
  1445. }
  1447. return new AST\GroupByClause($groupByItems);
  1448. }
  1450. /**
  1451. * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
  1452. *
  1453. * @return AST\OrderByClause
  1454. */
  1455. public function OrderByClause()
  1456. {
  1457. $this->match(TokenType::T_ORDER);
  1458. $this->match(TokenType::T_BY);
  1460. $orderByItems = [];
  1461. $orderByItems[] = $this->OrderByItem();
  1463. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1464. $this->match(TokenType::T_COMMA);
  1466. $orderByItems[] = $this->OrderByItem();
  1467. }
  1469. return new AST\OrderByClause($orderByItems);
  1470. }
  1472. /**
  1473. * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  1474. *
  1475. * @return AST\Subselect
  1476. */
  1477. public function Subselect()
  1478. {
  1479. // Increase query nesting level
  1480. $this->nestingLevel++;
  1482. $subselect = new AST\Subselect($this->SimpleSelectClause(), $this->SubselectFromClause());
  1484. $subselect->whereClause = $this->lexer->isNextToken(TokenType::T_WHERE) ? $this->WhereClause() : null;
  1485. $subselect->groupByClause = $this->lexer->isNextToken(TokenType::T_GROUP) ? $this->GroupByClause() : null;
  1486. $subselect->havingClause = $this->lexer->isNextToken(TokenType::T_HAVING) ? $this->HavingClause() : null;
  1487. $subselect->orderByClause = $this->lexer->isNextToken(TokenType::T_ORDER) ? $this->OrderByClause() : null;
  1489. // Decrease query nesting level
  1490. $this->nestingLevel--;
  1492. return $subselect;
  1493. }
  1495. /**
  1496. * UpdateItem ::= SingleValuedPathExpression "=" NewValue
  1497. *
  1498. * @return AST\UpdateItem
  1499. */
  1500. public function UpdateItem()
  1501. {
  1502. $pathExpr = $this->SingleValuedPathExpression();
  1504. $this->match(TokenType::T_EQUALS);
  1506. return new AST\UpdateItem($pathExpr, $this->NewValue());
  1507. }
  1509. /**
  1510. * GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression
  1511. *
  1512. * @return string|AST\PathExpression
  1513. */
  1514. public function GroupByItem()
  1515. {
  1516. // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  1517. $glimpse = $this->lexer->glimpse();
  1519. if ($glimpse !== null && $glimpse->type === TokenType::T_DOT) {
  1520. return $this->SingleValuedPathExpression();
  1521. }
  1523. assert($this->lexer->lookahead !== null);
  1524. // Still need to decide between IdentificationVariable or ResultVariable
  1525. $lookaheadValue = $this->lexer->lookahead->value;
  1527. if (! isset($this->queryComponents[$lookaheadValue])) {
  1528. $this->semanticalError('Cannot group by undefined identification or result variable.');
  1529. }
  1531. return isset($this->queryComponents[$lookaheadValue]['metadata'])
  1532. ? $this->IdentificationVariable()
  1533. : $this->ResultVariable();
  1534. }
  1536. /**
  1537. * OrderByItem ::= (
  1538. * SimpleArithmeticExpression | SingleValuedPathExpression | CaseExpression |
  1539. * ScalarExpression | ResultVariable | FunctionDeclaration
  1540. * ) ["ASC" | "DESC"]
  1541. *
  1542. * @return AST\OrderByItem
  1543. */
  1544. public function OrderByItem()
  1545. {
  1546. $this->lexer->peek(); // lookahead => '.'
  1547. $this->lexer->peek(); // lookahead => token after '.'
  1549. $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1551. $this->lexer->resetPeek();
  1553. $glimpse = $this->lexer->glimpse();
  1555. assert($this->lexer->lookahead !== null);
  1556. switch (true) {
  1557. case $this->isMathOperator($peek):
  1558. $expr = $this->SimpleArithmeticExpression();
  1559. break;
  1561. case $glimpse !== null && $glimpse->type === TokenType::T_DOT:
  1562. $expr = $this->SingleValuedPathExpression();
  1563. break;
  1565. case $this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  1566. $expr = $this->ScalarExpression();
  1567. break;
  1569. case $this->lexer->lookahead->type === TokenType::T_CASE:
  1570. $expr = $this->CaseExpression();
  1571. break;
  1573. case $this->isFunction():
  1574. $expr = $this->FunctionDeclaration();
  1575. break;
  1577. default:
  1578. $expr = $this->ResultVariable();
  1579. break;
  1580. }
  1582. $type = 'ASC';
  1583. $item = new AST\OrderByItem($expr);
  1585. switch (true) {
  1586. case $this->lexer->isNextToken(TokenType::T_DESC):
  1587. $this->match(TokenType::T_DESC);
  1588. $type = 'DESC';
  1589. break;
  1591. case $this->lexer->isNextToken(TokenType::T_ASC):
  1592. $this->match(TokenType::T_ASC);
  1593. break;
  1595. default:
  1596. // Do nothing
  1597. }
  1599. $item->type = $type;
  1601. return $item;
  1602. }
  1604. /**
  1605. * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
  1606. * EnumPrimary | SimpleEntityExpression | "NULL"
  1607. *
  1608. * NOTE: Since it is not possible to correctly recognize individual types, here is the full
  1609. * grammar that needs to be supported:
  1610. *
  1611. * NewValue ::= SimpleArithmeticExpression | "NULL"
  1612. *
  1613. * SimpleArithmeticExpression covers all *Primary grammar rules and also SimpleEntityExpression
  1614. *
  1615. * @return AST\ArithmeticExpression|AST\InputParameter|null
  1616. */
  1617. public function NewValue()
  1618. {
  1619. if ($this->lexer->isNextToken(TokenType::T_NULL)) {
  1620. $this->match(TokenType::T_NULL);
  1622. return null;
  1623. }
  1625. if ($this->lexer->isNextToken(TokenType::T_INPUT_PARAMETER)) {
  1626. $this->match(TokenType::T_INPUT_PARAMETER);
  1627. assert($this->lexer->token !== null);
  1629. return new AST\InputParameter($this->lexer->token->value);
  1630. }
  1632. return $this->ArithmeticExpression();
  1633. }
  1635. /**
  1636. * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*
  1637. *
  1638. * @return AST\IdentificationVariableDeclaration
  1639. */
  1640. public function IdentificationVariableDeclaration()
  1641. {
  1642. $joins = [];
  1643. $rangeVariableDeclaration = $this->RangeVariableDeclaration();
  1644. $indexBy = $this->lexer->isNextToken(TokenType::T_INDEX)
  1645. ? $this->IndexBy()
  1646. : null;
  1648. $rangeVariableDeclaration->isRoot = true;
  1650. while (
  1651. $this->lexer->isNextToken(TokenType::T_LEFT) ||
  1652. $this->lexer->isNextToken(TokenType::T_INNER) ||
  1653. $this->lexer->isNextToken(TokenType::T_JOIN)
  1654. ) {
  1655. $joins[] = $this->Join();
  1656. }
  1658. return new AST\IdentificationVariableDeclaration(
  1659. $rangeVariableDeclaration,
  1660. $indexBy,
  1661. $joins
  1662. );
  1663. }
  1665. /**
  1666. * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration
  1667. *
  1668. * {Internal note: WARNING: Solution is harder than a bare implementation.
  1669. * Desired EBNF support:
  1670. *
  1671. * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
  1672. *
  1673. * It demands that entire SQL generation to become programmatical. This is
  1674. * needed because association based subselect requires "WHERE" conditional
  1675. * expressions to be injected, but there is no scope to do that. Only scope
  1676. * accessible is "FROM", prohibiting an easy implementation without larger
  1677. * changes.}
  1678. *
  1679. * @return AST\IdentificationVariableDeclaration
  1680. */
  1681. public function SubselectIdentificationVariableDeclaration()
  1682. {
  1683. /*
  1684. NOT YET IMPLEMENTED!
  1686. $glimpse = $this->lexer->glimpse();
  1688. if ($glimpse->type == TokenType::T_DOT) {
  1689. $associationPathExpression = $this->AssociationPathExpression();
  1691. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  1692. $this->match(TokenType::T_AS);
  1693. }
  1695. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1696. $identificationVariable = $associationPathExpression->identificationVariable;
  1697. $field = $associationPathExpression->associationField;
  1699. $class = $this->queryComponents[$identificationVariable]['metadata'];
  1700. $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1702. // Building queryComponent
  1703. $joinQueryComponent = array(
  1704. 'metadata' => $targetClass,
  1705. 'parent' => $identificationVariable,
  1706. 'relation' => $class->getAssociationMapping($field),
  1707. 'map' => null,
  1708. 'nestingLevel' => $this->nestingLevel,
  1709. 'token' => $this->lexer->lookahead
  1710. );
  1712. $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1714. return new AST\SubselectIdentificationVariableDeclaration(
  1715. $associationPathExpression, $aliasIdentificationVariable
  1716. );
  1717. }
  1718. */
  1720. return $this->IdentificationVariableDeclaration();
  1721. }
  1723. /**
  1724. * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN"
  1725. * (JoinAssociationDeclaration | RangeVariableDeclaration)
  1726. * ["WITH" ConditionalExpression]
  1727. *
  1728. * @return AST\Join
  1729. */
  1730. public function Join()
  1731. {
  1732. // Check Join type
  1733. $joinType = AST\Join::JOIN_TYPE_INNER;
  1735. switch (true) {
  1736. case $this->lexer->isNextToken(TokenType::T_LEFT):
  1737. $this->match(TokenType::T_LEFT);
  1739. $joinType = AST\Join::JOIN_TYPE_LEFT;
  1741. // Possible LEFT OUTER join
  1742. if ($this->lexer->isNextToken(TokenType::T_OUTER)) {
  1743. $this->match(TokenType::T_OUTER);
  1745. $joinType = AST\Join::JOIN_TYPE_LEFTOUTER;
  1746. }
  1748. break;
  1750. case $this->lexer->isNextToken(TokenType::T_INNER):
  1751. $this->match(TokenType::T_INNER);
  1752. break;
  1754. default:
  1755. // Do nothing
  1756. }
  1758. $this->match(TokenType::T_JOIN);
  1760. $next = $this->lexer->glimpse();
  1761. assert($next !== null);
  1762. $joinDeclaration = $next->type === TokenType::T_DOT ? $this->JoinAssociationDeclaration() : $this->RangeVariableDeclaration();
  1763. $adhocConditions = $this->lexer->isNextToken(TokenType::T_WITH);
  1764. $join = new AST\Join($joinType, $joinDeclaration);
  1766. // Describe non-root join declaration
  1767. if ($joinDeclaration instanceof AST\RangeVariableDeclaration) {
  1768. $joinDeclaration->isRoot = false;
  1769. }
  1771. // Check for ad-hoc Join conditions
  1772. if ($adhocConditions) {
  1773. $this->match(TokenType::T_WITH);
  1775. $join->conditionalExpression = $this->ConditionalExpression();
  1776. }
  1778. return $join;
  1779. }
  1781. /**
  1782. * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
  1783. *
  1784. * @return AST\RangeVariableDeclaration
  1785. *
  1786. * @throws QueryException
  1787. */
  1788. public function RangeVariableDeclaration()
  1789. {
  1790. if ($this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS) && $this->lexer->glimpse()->type === TokenType::T_SELECT) {
  1791. $this->semanticalError('Subquery is not supported here', $this->lexer->token);
  1792. }
  1794. $abstractSchemaName = $this->AbstractSchemaName();
  1796. $this->validateAbstractSchemaName($abstractSchemaName);
  1798. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  1799. $this->match(TokenType::T_AS);
  1800. }
  1802. assert($this->lexer->lookahead !== null);
  1803. $token = $this->lexer->lookahead;
  1804. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1805. $classMetadata = $this->em->getClassMetadata($abstractSchemaName);
  1807. // Building queryComponent
  1808. $queryComponent = [
  1809. 'metadata' => $classMetadata,
  1810. 'parent' => null,
  1811. 'relation' => null,
  1812. 'map' => null,
  1813. 'nestingLevel' => $this->nestingLevel,
  1814. 'token' => $token,
  1815. ];
  1817. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1819. return new AST\RangeVariableDeclaration($abstractSchemaName, $aliasIdentificationVariable);
  1820. }
  1822. /**
  1823. * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [IndexBy]
  1824. *
  1825. * @return AST\JoinAssociationDeclaration
  1826. */
  1827. public function JoinAssociationDeclaration()
  1828. {
  1829. $joinAssociationPathExpression = $this->JoinAssociationPathExpression();
  1831. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  1832. $this->match(TokenType::T_AS);
  1833. }
  1835. assert($this->lexer->lookahead !== null);
  1837. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1838. $indexBy = $this->lexer->isNextToken(TokenType::T_INDEX) ? $this->IndexBy() : null;
  1840. $identificationVariable = $joinAssociationPathExpression->identificationVariable;
  1841. $field = $joinAssociationPathExpression->associationField;
  1843. $class = $this->getMetadataForDqlAlias($identificationVariable);
  1844. $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1846. // Building queryComponent
  1847. $joinQueryComponent = [
  1848. 'metadata' => $targetClass,
  1849. 'parent' => $joinAssociationPathExpression->identificationVariable,
  1850. 'relation' => $class->getAssociationMapping($field),
  1851. 'map' => null,
  1852. 'nestingLevel' => $this->nestingLevel,
  1853. 'token' => $this->lexer->lookahead,
  1854. ];
  1856. $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1858. return new AST\JoinAssociationDeclaration($joinAssociationPathExpression, $aliasIdentificationVariable, $indexBy);
  1859. }
  1861. /**
  1862. * PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
  1863. * PartialFieldSet ::= "{" SimpleStateField {"," SimpleStateField}* "}"
  1864. *
  1865. * @return AST\PartialObjectExpression
  1866. */
  1867. public function PartialObjectExpression()
  1868. {
  1869. $this->match(TokenType::T_PARTIAL);
  1871. $partialFieldSet = [];
  1873. $identificationVariable = $this->IdentificationVariable();
  1875. $this->match(TokenType::T_DOT);
  1876. $this->match(TokenType::T_OPEN_CURLY_BRACE);
  1877. $this->match(TokenType::T_IDENTIFIER);
  1879. assert($this->lexer->token !== null);
  1880. $field = $this->lexer->token->value;
  1882. // First field in partial expression might be embeddable property
  1883. while ($this->lexer->isNextToken(TokenType::T_DOT)) {
  1884. $this->match(TokenType::T_DOT);
  1885. $this->match(TokenType::T_IDENTIFIER);
  1886. $field .= '.' . $this->lexer->token->value;
  1887. }
  1889. $partialFieldSet[] = $field;
  1891. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1892. $this->match(TokenType::T_COMMA);
  1893. $this->match(TokenType::T_IDENTIFIER);
  1895. $field = $this->lexer->token->value;
  1897. while ($this->lexer->isNextToken(TokenType::T_DOT)) {
  1898. $this->match(TokenType::T_DOT);
  1899. $this->match(TokenType::T_IDENTIFIER);
  1900. $field .= '.' . $this->lexer->token->value;
  1901. }
  1903. $partialFieldSet[] = $field;
  1904. }
  1906. $this->match(TokenType::T_CLOSE_CURLY_BRACE);
  1908. $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
  1910. // Defer PartialObjectExpression validation
  1911. $this->deferredPartialObjectExpressions[] = [
  1912. 'expression' => $partialObjectExpression,
  1913. 'nestingLevel' => $this->nestingLevel,
  1914. 'token' => $this->lexer->token,
  1915. ];
  1917. return $partialObjectExpression;
  1918. }
  1920. /**
  1921. * NewObjectExpression ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
  1922. *
  1923. * @return AST\NewObjectExpression
  1924. */
  1925. public function NewObjectExpression()
  1926. {
  1927. $this->match(TokenType::T_NEW);
  1929. $className = $this->AbstractSchemaName(); // note that this is not yet validated
  1930. $token = $this->lexer->token;
  1932. $this->match(TokenType::T_OPEN_PARENTHESIS);
  1934. $args[] = $this->NewObjectArg();
  1936. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  1937. $this->match(TokenType::T_COMMA);
  1939. $args[] = $this->NewObjectArg();
  1940. }
  1942. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  1944. $expression = new AST\NewObjectExpression($className, $args);
  1946. // Defer NewObjectExpression validation
  1947. $this->deferredNewObjectExpressions[] = [
  1948. 'token' => $token,
  1949. 'expression' => $expression,
  1950. 'nestingLevel' => $this->nestingLevel,
  1951. ];
  1953. return $expression;
  1954. }
  1956. /**
  1957. * NewObjectArg ::= ScalarExpression | "(" Subselect ")"
  1958. *
  1959. * @return mixed
  1960. */
  1961. public function NewObjectArg()
  1962. {
  1963. assert($this->lexer->lookahead !== null);
  1964. $token = $this->lexer->lookahead;
  1965. $peek = $this->lexer->glimpse();
  1967. assert($peek !== null);
  1968. if ($token->type === TokenType::T_OPEN_PARENTHESIS && $peek->type === TokenType::T_SELECT) {
  1969. $this->match(TokenType::T_OPEN_PARENTHESIS);
  1970. $expression = $this->Subselect();
  1971. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  1973. return $expression;
  1974. }
  1976. return $this->ScalarExpression();
  1977. }
  1979. /**
  1980. * IndexBy ::= "INDEX" "BY" SingleValuedPathExpression
  1981. *
  1982. * @return AST\IndexBy
  1983. */
  1984. public function IndexBy()
  1985. {
  1986. $this->match(TokenType::T_INDEX);
  1987. $this->match(TokenType::T_BY);
  1988. $pathExpr = $this->SingleValuedPathExpression();
  1990. // Add the INDEX BY info to the query component
  1991. $this->queryComponents[$pathExpr->identificationVariable]['map'] = $pathExpr->field;
  1993. return new AST\IndexBy($pathExpr);
  1994. }
  1996. /**
  1997. * ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DateTimePrimary |
  1998. * StateFieldPathExpression | BooleanPrimary | CaseExpression |
  1999. * InstanceOfExpression
  2000. *
  2001. * @return mixed One of the possible expressions or subexpressions.
  2002. */
  2003. public function ScalarExpression()
  2004. {
  2005. assert($this->lexer->token !== null);
  2006. assert($this->lexer->lookahead !== null);
  2007. $lookahead = $this->lexer->lookahead->type;
  2008. $peek = $this->lexer->glimpse();
  2010. switch (true) {
  2011. case $lookahead === TokenType::T_INTEGER:
  2012. case $lookahead === TokenType::T_FLOAT:
  2013. // SimpleArithmeticExpression : (- u.value ) or ( + u.value ) or ( - 1 ) or ( + 1 )
  2014. case $lookahead === TokenType::T_MINUS:
  2015. case $lookahead === TokenType::T_PLUS:
  2016. return $this->SimpleArithmeticExpression();
  2018. case $lookahead === TokenType::T_STRING:
  2019. return $this->StringPrimary();
  2021. case $lookahead === TokenType::T_TRUE:
  2022. case $lookahead === TokenType::T_FALSE:
  2023. $this->match($lookahead);
  2025. return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token->value);
  2027. case $lookahead === TokenType::T_INPUT_PARAMETER:
  2028. switch (true) {
  2029. case $this->isMathOperator($peek):
  2030. // :param + u.value
  2031. return $this->SimpleArithmeticExpression();
  2033. default:
  2034. return $this->InputParameter();
  2035. }
  2036. case $lookahead === TokenType::T_CASE:
  2037. case $lookahead === TokenType::T_COALESCE:
  2038. case $lookahead === TokenType::T_NULLIF:
  2039. // Since NULLIF and COALESCE can be identified as a function,
  2040. // we need to check these before checking for FunctionDeclaration
  2041. return $this->CaseExpression();
  2043. case $lookahead === TokenType::T_OPEN_PARENTHESIS:
  2044. return $this->SimpleArithmeticExpression();
  2046. // this check must be done before checking for a filed path expression
  2047. case $this->isFunction():
  2048. $this->lexer->peek(); // "("
  2050. switch (true) {
  2051. case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2052. // SUM(u.id) + COUNT(u.id)
  2053. return $this->SimpleArithmeticExpression();
  2055. default:
  2056. // IDENTITY(u)
  2057. return $this->FunctionDeclaration();
  2058. }
  2060. break;
  2061. // it is no function, so it must be a field path
  2062. case $lookahead === TokenType::T_IDENTIFIER:
  2063. $this->lexer->peek(); // lookahead => '.'
  2064. $this->lexer->peek(); // lookahead => token after '.'
  2065. $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  2066. $this->lexer->resetPeek();
  2068. if ($this->isMathOperator($peek)) {
  2069. return $this->SimpleArithmeticExpression();
  2070. }
  2072. return $this->StateFieldPathExpression();
  2074. default:
  2075. $this->syntaxError();
  2076. }
  2077. }
  2079. /**
  2080. * CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullifExpression
  2081. * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2082. * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2083. * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2084. * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2085. * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2086. * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2087. * NullifExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2088. *
  2089. * @return mixed One of the possible expressions or subexpressions.
  2090. */
  2091. public function CaseExpression()
  2092. {
  2093. assert($this->lexer->lookahead !== null);
  2094. $lookahead = $this->lexer->lookahead->type;
  2096. switch ($lookahead) {
  2097. case TokenType::T_NULLIF:
  2098. return $this->NullIfExpression();
  2100. case TokenType::T_COALESCE:
  2101. return $this->CoalesceExpression();
  2103. case TokenType::T_CASE:
  2104. $this->lexer->resetPeek();
  2105. $peek = $this->lexer->peek();
  2107. assert($peek !== null);
  2108. if ($peek->type === TokenType::T_WHEN) {
  2109. return $this->GeneralCaseExpression();
  2110. }
  2112. return $this->SimpleCaseExpression();
  2114. default:
  2115. // Do nothing
  2116. break;
  2117. }
  2119. $this->syntaxError();
  2120. }
  2122. /**
  2123. * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2124. *
  2125. * @return AST\CoalesceExpression
  2126. */
  2127. public function CoalesceExpression()
  2128. {
  2129. $this->match(TokenType::T_COALESCE);
  2130. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2132. // Process ScalarExpressions (1..N)
  2133. $scalarExpressions = [];
  2134. $scalarExpressions[] = $this->ScalarExpression();
  2136. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  2137. $this->match(TokenType::T_COMMA);
  2139. $scalarExpressions[] = $this->ScalarExpression();
  2140. }
  2142. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2144. return new AST\CoalesceExpression($scalarExpressions);
  2145. }
  2147. /**
  2148. * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2149. *
  2150. * @return AST\NullIfExpression
  2151. */
  2152. public function NullIfExpression()
  2153. {
  2154. $this->match(TokenType::T_NULLIF);
  2155. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2157. $firstExpression = $this->ScalarExpression();
  2158. $this->match(TokenType::T_COMMA);
  2159. $secondExpression = $this->ScalarExpression();
  2161. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2163. return new AST\NullIfExpression($firstExpression, $secondExpression);
  2164. }
  2166. /**
  2167. * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2168. *
  2169. * @return AST\GeneralCaseExpression
  2170. */
  2171. public function GeneralCaseExpression()
  2172. {
  2173. $this->match(TokenType::T_CASE);
  2175. // Process WhenClause (1..N)
  2176. $whenClauses = [];
  2178. do {
  2179. $whenClauses[] = $this->WhenClause();
  2180. } while ($this->lexer->isNextToken(TokenType::T_WHEN));
  2182. $this->match(TokenType::T_ELSE);
  2183. $scalarExpression = $this->ScalarExpression();
  2184. $this->match(TokenType::T_END);
  2186. return new AST\GeneralCaseExpression($whenClauses, $scalarExpression);
  2187. }
  2189. /**
  2190. * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2191. * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2192. *
  2193. * @return AST\SimpleCaseExpression
  2194. */
  2195. public function SimpleCaseExpression()
  2196. {
  2197. $this->match(TokenType::T_CASE);
  2198. $caseOperand = $this->StateFieldPathExpression();
  2200. // Process SimpleWhenClause (1..N)
  2201. $simpleWhenClauses = [];
  2203. do {
  2204. $simpleWhenClauses[] = $this->SimpleWhenClause();
  2205. } while ($this->lexer->isNextToken(TokenType::T_WHEN));
  2207. $this->match(TokenType::T_ELSE);
  2208. $scalarExpression = $this->ScalarExpression();
  2209. $this->match(TokenType::T_END);
  2211. return new AST\SimpleCaseExpression($caseOperand, $simpleWhenClauses, $scalarExpression);
  2212. }
  2214. /**
  2215. * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2216. *
  2217. * @return AST\WhenClause
  2218. */
  2219. public function WhenClause()
  2220. {
  2221. $this->match(TokenType::T_WHEN);
  2222. $conditionalExpression = $this->ConditionalExpression();
  2223. $this->match(TokenType::T_THEN);
  2225. return new AST\WhenClause($conditionalExpression, $this->ScalarExpression());
  2226. }
  2228. /**
  2229. * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2230. *
  2231. * @return AST\SimpleWhenClause
  2232. */
  2233. public function SimpleWhenClause()
  2234. {
  2235. $this->match(TokenType::T_WHEN);
  2236. $conditionalExpression = $this->ScalarExpression();
  2237. $this->match(TokenType::T_THEN);
  2239. return new AST\SimpleWhenClause($conditionalExpression, $this->ScalarExpression());
  2240. }
  2242. /**
  2243. * SelectExpression ::= (
  2244. * IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration |
  2245. * PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression
  2246. * ) [["AS"] ["HIDDEN"] AliasResultVariable]
  2247. *
  2248. * @return AST\SelectExpression
  2249. */
  2250. public function SelectExpression()
  2251. {
  2252. assert($this->lexer->lookahead !== null);
  2253. $expression = null;
  2254. $identVariable = null;
  2255. $peek = $this->lexer->glimpse();
  2256. $lookaheadType = $this->lexer->lookahead->type;
  2257. assert($peek !== null);
  2259. switch (true) {
  2260. // ScalarExpression (u.name)
  2261. case $lookaheadType === TokenType::T_IDENTIFIER && $peek->type === TokenType::T_DOT:
  2262. $expression = $this->ScalarExpression();
  2263. break;
  2265. // IdentificationVariable (u)
  2266. case $lookaheadType === TokenType::T_IDENTIFIER && $peek->type !== TokenType::T_OPEN_PARENTHESIS:
  2267. $expression = $identVariable = $this->IdentificationVariable();
  2268. break;
  2270. // CaseExpression (CASE ... or NULLIF(...) or COALESCE(...))
  2271. case $lookaheadType === TokenType::T_CASE:
  2272. case $lookaheadType === TokenType::T_COALESCE:
  2273. case $lookaheadType === TokenType::T_NULLIF:
  2274. $expression = $this->CaseExpression();
  2275. break;
  2277. // DQL Function (SUM(u.value) or SUM(u.value) + 1)
  2278. case $this->isFunction():
  2279. $this->lexer->peek(); // "("
  2281. switch (true) {
  2282. case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2283. // SUM(u.id) + COUNT(u.id)
  2284. $expression = $this->ScalarExpression();
  2285. break;
  2287. default:
  2288. // IDENTITY(u)
  2289. $expression = $this->FunctionDeclaration();
  2290. break;
  2291. }
  2293. break;
  2295. // PartialObjectExpression (PARTIAL u.{id, name})
  2296. case $lookaheadType === TokenType::T_PARTIAL:
  2297. $expression = $this->PartialObjectExpression();
  2298. $identVariable = $expression->identificationVariable;
  2299. break;
  2301. // Subselect
  2302. case $lookaheadType === TokenType::T_OPEN_PARENTHESIS && $peek->type === TokenType::T_SELECT:
  2303. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2304. $expression = $this->Subselect();
  2305. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2306. break;
  2308. // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2309. case $lookaheadType === TokenType::T_OPEN_PARENTHESIS:
  2310. case $lookaheadType === TokenType::T_INTEGER:
  2311. case $lookaheadType === TokenType::T_STRING:
  2312. case $lookaheadType === TokenType::T_FLOAT:
  2313. // SimpleArithmeticExpression : (- u.value ) or ( + u.value )
  2314. case $lookaheadType === TokenType::T_MINUS:
  2315. case $lookaheadType === TokenType::T_PLUS:
  2316. $expression = $this->SimpleArithmeticExpression();
  2317. break;
  2319. // NewObjectExpression (New ClassName(id, name))
  2320. case $lookaheadType === TokenType::T_NEW:
  2321. $expression = $this->NewObjectExpression();
  2322. break;
  2324. default:
  2325. $this->syntaxError(
  2326. 'IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression',
  2327. $this->lexer->lookahead
  2328. );
  2329. }
  2331. // [["AS"] ["HIDDEN"] AliasResultVariable]
  2332. $mustHaveAliasResultVariable = false;
  2334. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  2335. $this->match(TokenType::T_AS);
  2337. $mustHaveAliasResultVariable = true;
  2338. }
  2340. $hiddenAliasResultVariable = false;
  2342. if ($this->lexer->isNextToken(TokenType::T_HIDDEN)) {
  2343. $this->match(TokenType::T_HIDDEN);
  2345. $hiddenAliasResultVariable = true;
  2346. }
  2348. $aliasResultVariable = null;
  2350. if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(TokenType::T_IDENTIFIER)) {
  2351. assert($expression instanceof AST\Node || is_string($expression));
  2352. $token = $this->lexer->lookahead;
  2353. $aliasResultVariable = $this->AliasResultVariable();
  2355. // Include AliasResultVariable in query components.
  2356. $this->queryComponents[$aliasResultVariable] = [
  2357. 'resultVariable' => $expression,
  2358. 'nestingLevel' => $this->nestingLevel,
  2359. 'token' => $token,
  2360. ];
  2361. }
  2363. // AST
  2365. $expr = new AST\SelectExpression($expression, $aliasResultVariable, $hiddenAliasResultVariable);
  2367. if ($identVariable) {
  2368. $this->identVariableExpressions[$identVariable] = $expr;
  2369. }
  2371. return $expr;
  2372. }
  2374. /**
  2375. * SimpleSelectExpression ::= (
  2376. * StateFieldPathExpression | IdentificationVariable | FunctionDeclaration |
  2377. * AggregateExpression | "(" Subselect ")" | ScalarExpression
  2378. * ) [["AS"] AliasResultVariable]
  2379. *
  2380. * @return AST\SimpleSelectExpression
  2381. */
  2382. public function SimpleSelectExpression()
  2383. {
  2384. assert($this->lexer->lookahead !== null);
  2385. $peek = $this->lexer->glimpse();
  2386. assert($peek !== null);
  2388. switch ($this->lexer->lookahead->type) {
  2389. case TokenType::T_IDENTIFIER:
  2390. switch (true) {
  2391. case $peek->type === TokenType::T_DOT:
  2392. $expression = $this->StateFieldPathExpression();
  2394. return new AST\SimpleSelectExpression($expression);
  2396. case $peek->type !== TokenType::T_OPEN_PARENTHESIS:
  2397. $expression = $this->IdentificationVariable();
  2399. return new AST\SimpleSelectExpression($expression);
  2401. case $this->isFunction():
  2402. // SUM(u.id) + COUNT(u.id)
  2403. if ($this->isMathOperator($this->peekBeyondClosingParenthesis())) {
  2404. return new AST\SimpleSelectExpression($this->ScalarExpression());
  2405. }
  2407. // COUNT(u.id)
  2408. if ($this->isAggregateFunction($this->lexer->lookahead->type)) {
  2409. return new AST\SimpleSelectExpression($this->AggregateExpression());
  2410. }
  2412. // IDENTITY(u)
  2413. return new AST\SimpleSelectExpression($this->FunctionDeclaration());
  2415. default:
  2416. // Do nothing
  2417. }
  2419. break;
  2421. case TokenType::T_OPEN_PARENTHESIS:
  2422. if ($peek->type !== TokenType::T_SELECT) {
  2423. // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2424. $expression = $this->SimpleArithmeticExpression();
  2426. return new AST\SimpleSelectExpression($expression);
  2427. }
  2429. // Subselect
  2430. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2431. $expression = $this->Subselect();
  2432. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2434. return new AST\SimpleSelectExpression($expression);
  2436. default:
  2437. // Do nothing
  2438. }
  2440. $this->lexer->peek();
  2442. $expression = $this->ScalarExpression();
  2443. $expr = new AST\SimpleSelectExpression($expression);
  2445. if ($this->lexer->isNextToken(TokenType::T_AS)) {
  2446. $this->match(TokenType::T_AS);
  2447. }
  2449. if ($this->lexer->isNextToken(TokenType::T_IDENTIFIER)) {
  2450. $token = $this->lexer->lookahead;
  2451. $resultVariable = $this->AliasResultVariable();
  2452. $expr->fieldIdentificationVariable = $resultVariable;
  2454. // Include AliasResultVariable in query components.
  2455. $this->queryComponents[$resultVariable] = [
  2456. 'resultvariable' => $expr,
  2457. 'nestingLevel' => $this->nestingLevel,
  2458. 'token' => $token,
  2459. ];
  2460. }
  2462. return $expr;
  2463. }
  2465. /**
  2466. * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
  2467. *
  2468. * @return AST\ConditionalExpression|AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2469. */
  2470. public function ConditionalExpression()
  2471. {
  2472. $conditionalTerms = [];
  2473. $conditionalTerms[] = $this->ConditionalTerm();
  2475. while ($this->lexer->isNextToken(TokenType::T_OR)) {
  2476. $this->match(TokenType::T_OR);
  2478. $conditionalTerms[] = $this->ConditionalTerm();
  2479. }
  2481. // Phase 1 AST optimization: Prevent AST\ConditionalExpression
  2482. // if only one AST\ConditionalTerm is defined
  2483. if (count($conditionalTerms) === 1) {
  2484. return $conditionalTerms[0];
  2485. }
  2487. return new AST\ConditionalExpression($conditionalTerms);
  2488. }
  2490. /**
  2491. * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
  2492. *
  2493. * @return AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2494. */
  2495. public function ConditionalTerm()
  2496. {
  2497. $conditionalFactors = [];
  2498. $conditionalFactors[] = $this->ConditionalFactor();
  2500. while ($this->lexer->isNextToken(TokenType::T_AND)) {
  2501. $this->match(TokenType::T_AND);
  2503. $conditionalFactors[] = $this->ConditionalFactor();
  2504. }
  2506. // Phase 1 AST optimization: Prevent AST\ConditionalTerm
  2507. // if only one AST\ConditionalFactor is defined
  2508. if (count($conditionalFactors) === 1) {
  2509. return $conditionalFactors[0];
  2510. }
  2512. return new AST\ConditionalTerm($conditionalFactors);
  2513. }
  2515. /**
  2516. * ConditionalFactor ::= ["NOT"] ConditionalPrimary
  2517. *
  2518. * @return AST\ConditionalFactor|AST\ConditionalPrimary
  2519. */
  2520. public function ConditionalFactor()
  2521. {
  2522. $not = false;
  2524. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  2525. $this->match(TokenType::T_NOT);
  2527. $not = true;
  2528. }
  2530. $conditionalPrimary = $this->ConditionalPrimary();
  2532. // Phase 1 AST optimization: Prevent AST\ConditionalFactor
  2533. // if only one AST\ConditionalPrimary is defined
  2534. if (! $not) {
  2535. return $conditionalPrimary;
  2536. }
  2538. return new AST\ConditionalFactor($conditionalPrimary, $not);
  2539. }
  2541. /**
  2542. * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
  2543. *
  2544. * @return AST\ConditionalPrimary
  2545. */
  2546. public function ConditionalPrimary()
  2547. {
  2548. $condPrimary = new AST\ConditionalPrimary();
  2550. if (! $this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS)) {
  2551. $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2553. return $condPrimary;
  2554. }
  2556. // Peek beyond the matching closing parenthesis ')'
  2557. $peek = $this->peekBeyondClosingParenthesis();
  2559. if (
  2560. $peek !== null && (
  2561. in_array($peek->value, ['=', '<', '<=', '<>', '>', '>=', '!='], true) ||
  2562. in_array($peek->type, [TokenType::T_NOT, TokenType::T_BETWEEN, TokenType::T_LIKE, TokenType::T_IN, TokenType::T_IS, TokenType::T_EXISTS], true) ||
  2563. $this->isMathOperator($peek)
  2564. )
  2565. ) {
  2566. $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2568. return $condPrimary;
  2569. }
  2571. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2572. $condPrimary->conditionalExpression = $this->ConditionalExpression();
  2573. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2575. return $condPrimary;
  2576. }
  2578. /**
  2579. * SimpleConditionalExpression ::=
  2580. * ComparisonExpression | BetweenExpression | LikeExpression |
  2581. * InExpression | NullComparisonExpression | ExistsExpression |
  2582. * EmptyCollectionComparisonExpression | CollectionMemberExpression |
  2583. * InstanceOfExpression
  2584. *
  2585. * @return (AST\BetweenExpression|
  2586. * AST\CollectionMemberExpression|
  2587. * AST\ComparisonExpression|
  2588. * AST\EmptyCollectionComparisonExpression|
  2589. * AST\ExistsExpression|
  2590. * AST\InExpression|
  2591. * AST\InstanceOfExpression|
  2592. * AST\LikeExpression|
  2593. * AST\NullComparisonExpression)
  2594. *
  2595. * @phpstan-ignore return.deprecatedClass
  2596. */
  2597. public function SimpleConditionalExpression()
  2598. {
  2599. assert($this->lexer->lookahead !== null);
  2600. if ($this->lexer->isNextToken(TokenType::T_EXISTS)) {
  2601. return $this->ExistsExpression();
  2602. }
  2604. $token = $this->lexer->lookahead;
  2605. $peek = $this->lexer->glimpse();
  2606. $lookahead = $token;
  2608. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  2609. $token = $this->lexer->glimpse();
  2610. }
  2612. assert($token !== null);
  2613. assert($peek !== null);
  2614. if ($token->type === TokenType::T_IDENTIFIER || $token->type === TokenType::T_INPUT_PARAMETER || $this->isFunction()) {
  2615. // Peek beyond the matching closing parenthesis.
  2616. $beyond = $this->lexer->peek();
  2618. switch ($peek->value) {
  2619. case '(':
  2620. // Peeks beyond the matched closing parenthesis.
  2621. $token = $this->peekBeyondClosingParenthesis(false);
  2622. assert($token !== null);
  2624. if ($token->type === TokenType::T_NOT) {
  2625. $token = $this->lexer->peek();
  2626. assert($token !== null);
  2627. }
  2629. if ($token->type === TokenType::T_IS) {
  2630. $lookahead = $this->lexer->peek();
  2631. }
  2633. break;
  2635. default:
  2636. // Peek beyond the PathExpression or InputParameter.
  2637. $token = $beyond;
  2639. while ($token->value === '.') {
  2640. $this->lexer->peek();
  2642. $token = $this->lexer->peek();
  2643. assert($token !== null);
  2644. }
  2646. // Also peek beyond a NOT if there is one.
  2647. assert($token !== null);
  2648. if ($token->type === TokenType::T_NOT) {
  2649. $token = $this->lexer->peek();
  2650. assert($token !== null);
  2651. }
  2653. // We need to go even further in case of IS (differentiate between NULL and EMPTY)
  2654. $lookahead = $this->lexer->peek();
  2655. }
  2657. assert($lookahead !== null);
  2658. // Also peek beyond a NOT if there is one.
  2659. if ($lookahead->type === TokenType::T_NOT) {
  2660. $lookahead = $this->lexer->peek();
  2661. }
  2663. $this->lexer->resetPeek();
  2664. }
  2666. if ($token->type === TokenType::T_BETWEEN) {
  2667. return $this->BetweenExpression();
  2668. }
  2670. if ($token->type === TokenType::T_LIKE) {
  2671. return $this->LikeExpression();
  2672. }
  2674. if ($token->type === TokenType::T_IN) {
  2675. return $this->InExpression();
  2676. }
  2678. if ($token->type === TokenType::T_INSTANCE) {
  2679. return $this->InstanceOfExpression();
  2680. }
  2682. if ($token->type === TokenType::T_MEMBER) {
  2683. return $this->CollectionMemberExpression();
  2684. }
  2686. assert($lookahead !== null);
  2687. if ($token->type === TokenType::T_IS && $lookahead->type === TokenType::T_NULL) {
  2688. return $this->NullComparisonExpression();
  2689. }
  2691. if ($token->type === TokenType::T_IS && $lookahead->type === TokenType::T_EMPTY) {
  2692. return $this->EmptyCollectionComparisonExpression();
  2693. }
  2695. return $this->ComparisonExpression();
  2696. }
  2698. /**
  2699. * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
  2700. *
  2701. * @return AST\EmptyCollectionComparisonExpression
  2702. */
  2703. public function EmptyCollectionComparisonExpression()
  2704. {
  2705. $pathExpression = $this->CollectionValuedPathExpression();
  2706. $this->match(TokenType::T_IS);
  2708. $not = false;
  2709. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  2710. $this->match(TokenType::T_NOT);
  2711. $not = true;
  2712. }
  2714. $this->match(TokenType::T_EMPTY);
  2716. return new AST\EmptyCollectionComparisonExpression(
  2717. $pathExpression,
  2718. $not
  2719. );
  2720. }
  2722. /**
  2723. * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
  2724. *
  2725. * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2726. * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2727. *
  2728. * @return AST\CollectionMemberExpression
  2729. */
  2730. public function CollectionMemberExpression()
  2731. {
  2732. $not = false;
  2733. $entityExpr = $this->EntityExpression();
  2735. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  2736. $this->match(TokenType::T_NOT);
  2738. $not = true;
  2739. }
  2741. $this->match(TokenType::T_MEMBER);
  2743. if ($this->lexer->isNextToken(TokenType::T_OF)) {
  2744. $this->match(TokenType::T_OF);
  2745. }
  2747. return new AST\CollectionMemberExpression(
  2748. $entityExpr,
  2749. $this->CollectionValuedPathExpression(),
  2750. $not
  2751. );
  2752. }
  2754. /**
  2755. * Literal ::= string | char | integer | float | boolean
  2756. *
  2757. * @return AST\Literal
  2758. */
  2759. public function Literal()
  2760. {
  2761. assert($this->lexer->lookahead !== null);
  2762. assert($this->lexer->token !== null);
  2763. switch ($this->lexer->lookahead->type) {
  2764. case TokenType::T_STRING:
  2765. $this->match(TokenType::T_STRING);
  2767. return new AST\Literal(AST\Literal::STRING, $this->lexer->token->value);
  2769. case TokenType::T_INTEGER:
  2770. case TokenType::T_FLOAT:
  2771. $this->match(
  2772. $this->lexer->isNextToken(TokenType::T_INTEGER) ? TokenType::T_INTEGER : TokenType::T_FLOAT
  2773. );
  2775. return new AST\Literal(AST\Literal::NUMERIC, $this->lexer->token->value);
  2777. case TokenType::T_TRUE:
  2778. case TokenType::T_FALSE:
  2779. $this->match(
  2780. $this->lexer->isNextToken(TokenType::T_TRUE) ? TokenType::T_TRUE : TokenType::T_FALSE
  2781. );
  2783. return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token->value);
  2785. default:
  2786. $this->syntaxError('Literal');
  2787. }
  2788. }
  2790. /**
  2791. * InParameter ::= ArithmeticExpression | InputParameter
  2792. *
  2793. * @return AST\InputParameter|AST\ArithmeticExpression
  2794. */
  2795. public function InParameter()
  2796. {
  2797. assert($this->lexer->lookahead !== null);
  2798. if ($this->lexer->lookahead->type === TokenType::T_INPUT_PARAMETER) {
  2799. return $this->InputParameter();
  2800. }
  2802. return $this->ArithmeticExpression();
  2803. }
  2805. /**
  2806. * InputParameter ::= PositionalParameter | NamedParameter
  2807. *
  2808. * @return AST\InputParameter
  2809. */
  2810. public function InputParameter()
  2811. {
  2812. $this->match(TokenType::T_INPUT_PARAMETER);
  2813. assert($this->lexer->token !== null);
  2815. return new AST\InputParameter($this->lexer->token->value);
  2816. }
  2818. /**
  2819. * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
  2820. *
  2821. * @return AST\ArithmeticExpression
  2822. */
  2823. public function ArithmeticExpression()
  2824. {
  2825. $expr = new AST\ArithmeticExpression();
  2827. if ($this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS)) {
  2828. $peek = $this->lexer->glimpse();
  2829. assert($peek !== null);
  2831. if ($peek->type === TokenType::T_SELECT) {
  2832. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2833. $expr->subselect = $this->Subselect();
  2834. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2836. return $expr;
  2837. }
  2838. }
  2840. $expr->simpleArithmeticExpression = $this->SimpleArithmeticExpression();
  2842. return $expr;
  2843. }
  2845. /**
  2846. * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
  2847. *
  2848. * @return AST\SimpleArithmeticExpression|AST\ArithmeticTerm
  2849. */
  2850. public function SimpleArithmeticExpression()
  2851. {
  2852. $terms = [];
  2853. $terms[] = $this->ArithmeticTerm();
  2855. while (($isPlus = $this->lexer->isNextToken(TokenType::T_PLUS)) || $this->lexer->isNextToken(TokenType::T_MINUS)) {
  2856. $this->match($isPlus ? TokenType::T_PLUS : TokenType::T_MINUS);
  2858. assert($this->lexer->token !== null);
  2859. $terms[] = $this->lexer->token->value;
  2860. $terms[] = $this->ArithmeticTerm();
  2861. }
  2863. // Phase 1 AST optimization: Prevent AST\SimpleArithmeticExpression
  2864. // if only one AST\ArithmeticTerm is defined
  2865. if (count($terms) === 1) {
  2866. return $terms[0];
  2867. }
  2869. return new AST\SimpleArithmeticExpression($terms);
  2870. }
  2872. /**
  2873. * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
  2874. *
  2875. * @return AST\ArithmeticTerm
  2876. */
  2877. public function ArithmeticTerm()
  2878. {
  2879. $factors = [];
  2880. $factors[] = $this->ArithmeticFactor();
  2882. while (($isMult = $this->lexer->isNextToken(TokenType::T_MULTIPLY)) || $this->lexer->isNextToken(TokenType::T_DIVIDE)) {
  2883. $this->match($isMult ? TokenType::T_MULTIPLY : TokenType::T_DIVIDE);
  2885. assert($this->lexer->token !== null);
  2886. $factors[] = $this->lexer->token->value;
  2887. $factors[] = $this->ArithmeticFactor();
  2888. }
  2890. // Phase 1 AST optimization: Prevent AST\ArithmeticTerm
  2891. // if only one AST\ArithmeticFactor is defined
  2892. if (count($factors) === 1) {
  2893. return $factors[0];
  2894. }
  2896. return new AST\ArithmeticTerm($factors);
  2897. }
  2899. /**
  2900. * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
  2901. *
  2902. * @return AST\ArithmeticFactor
  2903. */
  2904. public function ArithmeticFactor()
  2905. {
  2906. $sign = null;
  2908. $isPlus = $this->lexer->isNextToken(TokenType::T_PLUS);
  2909. if ($isPlus || $this->lexer->isNextToken(TokenType::T_MINUS)) {
  2910. $this->match($isPlus ? TokenType::T_PLUS : TokenType::T_MINUS);
  2911. $sign = $isPlus;
  2912. }
  2914. $primary = $this->ArithmeticPrimary();
  2916. // Phase 1 AST optimization: Prevent AST\ArithmeticFactor
  2917. // if only one AST\ArithmeticPrimary is defined
  2918. if ($sign === null) {
  2919. return $primary;
  2920. }
  2922. return new AST\ArithmeticFactor($primary, $sign);
  2923. }
  2925. /**
  2926. * ArithmeticPrimary ::= SingleValuedPathExpression | Literal | ParenthesisExpression
  2927. * | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings
  2928. * | FunctionsReturningDatetime | IdentificationVariable | ResultVariable
  2929. * | InputParameter | CaseExpression
  2930. *
  2931. * @return AST\Node|string
  2932. */
  2933. public function ArithmeticPrimary()
  2934. {
  2935. if ($this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS)) {
  2936. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2938. $expr = $this->SimpleArithmeticExpression();
  2940. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  2942. return new AST\ParenthesisExpression($expr);
  2943. }
  2945. if ($this->lexer->lookahead === null) {
  2946. $this->syntaxError('ArithmeticPrimary');
  2947. }
  2949. switch ($this->lexer->lookahead->type) {
  2950. case TokenType::T_COALESCE:
  2951. case TokenType::T_NULLIF:
  2952. case TokenType::T_CASE:
  2953. return $this->CaseExpression();
  2955. case TokenType::T_IDENTIFIER:
  2956. $peek = $this->lexer->glimpse();
  2958. if ($peek !== null && $peek->value === '(') {
  2959. return $this->FunctionDeclaration();
  2960. }
  2962. if ($peek !== null && $peek->value === '.') {
  2963. return $this->SingleValuedPathExpression();
  2964. }
  2966. if (isset($this->queryComponents[$this->lexer->lookahead->value]['resultVariable'])) {
  2967. return $this->ResultVariable();
  2968. }
  2970. return $this->StateFieldPathExpression();
  2972. case TokenType::T_INPUT_PARAMETER:
  2973. return $this->InputParameter();
  2975. default:
  2976. $peek = $this->lexer->glimpse();
  2978. if ($peek !== null && $peek->value === '(') {
  2979. return $this->FunctionDeclaration();
  2980. }
  2982. return $this->Literal();
  2983. }
  2984. }
  2986. /**
  2987. * StringExpression ::= StringPrimary | ResultVariable | "(" Subselect ")"
  2988. *
  2989. * @return AST\Subselect|AST\Node|string
  2990. */
  2991. public function StringExpression()
  2992. {
  2993. $peek = $this->lexer->glimpse();
  2994. assert($peek !== null);
  2996. // Subselect
  2997. if ($this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS) && $peek->type === TokenType::T_SELECT) {
  2998. $this->match(TokenType::T_OPEN_PARENTHESIS);
  2999. $expr = $this->Subselect();
  3000. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3002. return $expr;
  3003. }
  3005. assert($this->lexer->lookahead !== null);
  3006. // ResultVariable (string)
  3007. if (
  3008. $this->lexer->isNextToken(TokenType::T_IDENTIFIER) &&
  3009. isset($this->queryComponents[$this->lexer->lookahead->value]['resultVariable'])
  3010. ) {
  3011. return $this->ResultVariable();
  3012. }
  3014. return $this->StringPrimary();
  3015. }
  3017. /**
  3018. * StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression
  3019. *
  3020. * @return AST\Node
  3021. */
  3022. public function StringPrimary()
  3023. {
  3024. assert($this->lexer->lookahead !== null);
  3025. $lookaheadType = $this->lexer->lookahead->type;
  3027. switch ($lookaheadType) {
  3028. case TokenType::T_IDENTIFIER:
  3029. $peek = $this->lexer->glimpse();
  3030. assert($peek !== null);
  3032. if ($peek->value === '.') {
  3033. return $this->StateFieldPathExpression();
  3034. }
  3036. if ($peek->value === '(') {
  3037. // do NOT directly go to FunctionsReturningString() because it doesn't check for custom functions.
  3038. return $this->FunctionDeclaration();
  3039. }
  3041. $this->syntaxError("'.' or '('");
  3042. break;
  3044. case TokenType::T_STRING:
  3045. $this->match(TokenType::T_STRING);
  3046. assert($this->lexer->token !== null);
  3048. return new AST\Literal(AST\Literal::STRING, $this->lexer->token->value);
  3050. case TokenType::T_INPUT_PARAMETER:
  3051. return $this->InputParameter();
  3053. case TokenType::T_CASE:
  3054. case TokenType::T_COALESCE:
  3055. case TokenType::T_NULLIF:
  3056. return $this->CaseExpression();
  3058. default:
  3059. assert($lookaheadType !== null);
  3060. if ($this->isAggregateFunction($lookaheadType)) {
  3061. return $this->AggregateExpression();
  3062. }
  3063. }
  3065. $this->syntaxError(
  3066. 'StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression'
  3067. );
  3068. }
  3070. /**
  3071. * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  3072. *
  3073. * @return AST\InputParameter|AST\PathExpression
  3074. */
  3075. public function EntityExpression()
  3076. {
  3077. $glimpse = $this->lexer->glimpse();
  3078. assert($glimpse !== null);
  3080. if ($this->lexer->isNextToken(TokenType::T_IDENTIFIER) && $glimpse->value === '.') {
  3081. return $this->SingleValuedAssociationPathExpression();
  3082. }
  3084. return $this->SimpleEntityExpression();
  3085. }
  3087. /**
  3088. * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  3089. *
  3090. * @return AST\InputParameter|AST\PathExpression
  3091. */
  3092. public function SimpleEntityExpression()
  3093. {
  3094. if ($this->lexer->isNextToken(TokenType::T_INPUT_PARAMETER)) {
  3095. return $this->InputParameter();
  3096. }
  3098. return $this->StateFieldPathExpression();
  3099. }
  3101. /**
  3102. * AggregateExpression ::=
  3103. * ("AVG" | "MAX" | "MIN" | "SUM" | "COUNT") "(" ["DISTINCT"] SimpleArithmeticExpression ")"
  3104. *
  3105. * @return AST\AggregateExpression
  3106. */
  3107. public function AggregateExpression()
  3108. {
  3109. assert($this->lexer->lookahead !== null);
  3110. $lookaheadType = $this->lexer->lookahead->type;
  3111. $isDistinct = false;
  3113. if (! in_array($lookaheadType, [TokenType::T_COUNT, TokenType::T_AVG, TokenType::T_MAX, TokenType::T_MIN, TokenType::T_SUM], true)) {
  3114. $this->syntaxError('One of: MAX, MIN, AVG, SUM, COUNT');
  3115. }
  3117. $this->match($lookaheadType);
  3118. assert($this->lexer->token !== null);
  3119. $functionName = $this->lexer->token->value;
  3120. $this->match(TokenType::T_OPEN_PARENTHESIS);
  3122. if ($this->lexer->isNextToken(TokenType::T_DISTINCT)) {
  3123. $this->match(TokenType::T_DISTINCT);
  3124. $isDistinct = true;
  3125. }
  3127. $pathExp = $this->SimpleArithmeticExpression();
  3129. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3131. return new AST\AggregateExpression($functionName, $pathExp, $isDistinct);
  3132. }
  3134. /**
  3135. * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
  3136. *
  3137. * @return AST\QuantifiedExpression
  3138. */
  3139. public function QuantifiedExpression()
  3140. {
  3141. assert($this->lexer->lookahead !== null);
  3142. $lookaheadType = $this->lexer->lookahead->type;
  3143. $value = $this->lexer->lookahead->value;
  3145. if (! in_array($lookaheadType, [TokenType::T_ALL, TokenType::T_ANY, TokenType::T_SOME], true)) {
  3146. $this->syntaxError('ALL, ANY or SOME');
  3147. }
  3149. $this->match($lookaheadType);
  3150. $this->match(TokenType::T_OPEN_PARENTHESIS);
  3152. $qExpr = new AST\QuantifiedExpression($this->Subselect());
  3153. $qExpr->type = $value;
  3155. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3157. return $qExpr;
  3158. }
  3160. /**
  3161. * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
  3162. *
  3163. * @return AST\BetweenExpression
  3164. */
  3165. public function BetweenExpression()
  3166. {
  3167. $not = false;
  3168. $arithExpr1 = $this->ArithmeticExpression();
  3170. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3171. $this->match(TokenType::T_NOT);
  3172. $not = true;
  3173. }
  3175. $this->match(TokenType::T_BETWEEN);
  3176. $arithExpr2 = $this->ArithmeticExpression();
  3177. $this->match(TokenType::T_AND);
  3178. $arithExpr3 = $this->ArithmeticExpression();
  3180. return new AST\BetweenExpression($arithExpr1, $arithExpr2, $arithExpr3, $not);
  3181. }
  3183. /**
  3184. * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )
  3185. *
  3186. * @return AST\ComparisonExpression
  3187. */
  3188. public function ComparisonExpression()
  3189. {
  3190. $this->lexer->glimpse();
  3192. $leftExpr = $this->ArithmeticExpression();
  3193. $operator = $this->ComparisonOperator();
  3194. $rightExpr = $this->isNextAllAnySome()
  3195. ? $this->QuantifiedExpression()
  3196. : $this->ArithmeticExpression();
  3198. return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
  3199. }
  3201. /**
  3202. * InExpression ::= SingleValuedPathExpression ["NOT"] "IN" "(" (InParameter {"," InParameter}* | Subselect) ")"
  3203. *
  3204. * @return AST\InListExpression|AST\InSubselectExpression
  3205. */
  3206. public function InExpression()
  3207. {
  3208. $expression = $this->ArithmeticExpression();
  3210. $not = false;
  3211. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3212. $this->match(TokenType::T_NOT);
  3213. $not = true;
  3214. }
  3216. $this->match(TokenType::T_IN);
  3217. $this->match(TokenType::T_OPEN_PARENTHESIS);
  3219. if ($this->lexer->isNextToken(TokenType::T_SELECT)) {
  3220. $inExpression = new AST\InSubselectExpression(
  3221. $expression,
  3222. $this->Subselect(),
  3223. $not
  3224. );
  3225. } else {
  3226. $literals = [$this->InParameter()];
  3228. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  3229. $this->match(TokenType::T_COMMA);
  3230. $literals[] = $this->InParameter();
  3231. }
  3233. $inExpression = new AST\InListExpression(
  3234. $expression,
  3235. $literals,
  3236. $not
  3237. );
  3238. }
  3240. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3242. return $inExpression;
  3243. }
  3245. /**
  3246. * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
  3247. *
  3248. * @return AST\InstanceOfExpression
  3249. */
  3250. public function InstanceOfExpression()
  3251. {
  3252. $identificationVariable = $this->IdentificationVariable();
  3254. $not = false;
  3255. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3256. $this->match(TokenType::T_NOT);
  3257. $not = true;
  3258. }
  3260. $this->match(TokenType::T_INSTANCE);
  3261. $this->match(TokenType::T_OF);
  3263. $exprValues = $this->lexer->isNextToken(TokenType::T_OPEN_PARENTHESIS)
  3264. ? $this->InstanceOfParameterList()
  3265. : [$this->InstanceOfParameter()];
  3267. return new AST\InstanceOfExpression(
  3268. $identificationVariable,
  3269. $exprValues,
  3270. $not
  3271. );
  3272. }
  3274. /** @return non-empty-list<AST\InputParameter|string> */
  3275. public function InstanceOfParameterList(): array
  3276. {
  3277. $this->match(TokenType::T_OPEN_PARENTHESIS);
  3279. $exprValues = [$this->InstanceOfParameter()];
  3281. while ($this->lexer->isNextToken(TokenType::T_COMMA)) {
  3282. $this->match(TokenType::T_COMMA);
  3284. $exprValues[] = $this->InstanceOfParameter();
  3285. }
  3287. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3289. return $exprValues;
  3290. }
  3292. /**
  3293. * InstanceOfParameter ::= AbstractSchemaName | InputParameter
  3294. *
  3295. * @return AST\InputParameter|string
  3296. */
  3297. public function InstanceOfParameter()
  3298. {
  3299. if ($this->lexer->isNextToken(TokenType::T_INPUT_PARAMETER)) {
  3300. $this->match(TokenType::T_INPUT_PARAMETER);
  3301. assert($this->lexer->token !== null);
  3303. return new AST\InputParameter($this->lexer->token->value);
  3304. }
  3306. $abstractSchemaName = $this->AbstractSchemaName();
  3308. $this->validateAbstractSchemaName($abstractSchemaName);
  3310. return $abstractSchemaName;
  3311. }
  3313. /**
  3314. * LikeExpression ::= StringExpression ["NOT"] "LIKE" StringPrimary ["ESCAPE" char]
  3315. *
  3316. * @return AST\LikeExpression
  3317. */
  3318. public function LikeExpression()
  3319. {
  3320. $stringExpr = $this->StringExpression();
  3321. $not = false;
  3323. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3324. $this->match(TokenType::T_NOT);
  3325. $not = true;
  3326. }
  3328. $this->match(TokenType::T_LIKE);
  3330. if ($this->lexer->isNextToken(TokenType::T_INPUT_PARAMETER)) {
  3331. $this->match(TokenType::T_INPUT_PARAMETER);
  3332. assert($this->lexer->token !== null);
  3333. $stringPattern = new AST\InputParameter($this->lexer->token->value);
  3334. } else {
  3335. $stringPattern = $this->StringPrimary();
  3336. }
  3338. $escapeChar = null;
  3340. if ($this->lexer->lookahead !== null && $this->lexer->lookahead->type === TokenType::T_ESCAPE) {
  3341. $this->match(TokenType::T_ESCAPE);
  3342. $this->match(TokenType::T_STRING);
  3343. assert($this->lexer->token !== null);
  3345. $escapeChar = new AST\Literal(AST\Literal::STRING, $this->lexer->token->value);
  3346. }
  3348. return new AST\LikeExpression($stringExpr, $stringPattern, $escapeChar, $not);
  3349. }
  3351. /**
  3352. * NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) "IS" ["NOT"] "NULL"
  3353. *
  3354. * @return AST\NullComparisonExpression
  3355. */
  3356. public function NullComparisonExpression()
  3357. {
  3358. switch (true) {
  3359. case $this->lexer->isNextToken(TokenType::T_INPUT_PARAMETER):
  3360. $this->match(TokenType::T_INPUT_PARAMETER);
  3361. assert($this->lexer->token !== null);
  3363. $expr = new AST\InputParameter($this->lexer->token->value);
  3364. break;
  3366. case $this->lexer->isNextToken(TokenType::T_NULLIF):
  3367. $expr = $this->NullIfExpression();
  3368. break;
  3370. case $this->lexer->isNextToken(TokenType::T_COALESCE):
  3371. $expr = $this->CoalesceExpression();
  3372. break;
  3374. case $this->isFunction():
  3375. $expr = $this->FunctionDeclaration();
  3376. break;
  3378. default:
  3379. // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  3380. $glimpse = $this->lexer->glimpse();
  3381. assert($glimpse !== null);
  3383. if ($glimpse->type === TokenType::T_DOT) {
  3384. $expr = $this->SingleValuedPathExpression();
  3386. // Leave switch statement
  3387. break;
  3388. }
  3390. assert($this->lexer->lookahead !== null);
  3391. $lookaheadValue = $this->lexer->lookahead->value;
  3393. // Validate existing component
  3394. if (! isset($this->queryComponents[$lookaheadValue])) {
  3395. $this->semanticalError('Cannot add having condition on undefined result variable.');
  3396. }
  3398. // Validate SingleValuedPathExpression (ie.: "product")
  3399. if (isset($this->queryComponents[$lookaheadValue]['metadata'])) {
  3400. $expr = $this->SingleValuedPathExpression();
  3401. break;
  3402. }
  3404. // Validating ResultVariable
  3405. if (! isset($this->queryComponents[$lookaheadValue]['resultVariable'])) {
  3406. $this->semanticalError('Cannot add having condition on a non result variable.');
  3407. }
  3409. $expr = $this->ResultVariable();
  3410. break;
  3411. }
  3413. $this->match(TokenType::T_IS);
  3415. $not = false;
  3416. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3417. $this->match(TokenType::T_NOT);
  3419. $not = true;
  3420. }
  3422. $this->match(TokenType::T_NULL);
  3424. return new AST\NullComparisonExpression($expr, $not);
  3425. }
  3427. /**
  3428. * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
  3429. *
  3430. * @return AST\ExistsExpression
  3431. */
  3432. public function ExistsExpression()
  3433. {
  3434. $not = false;
  3436. if ($this->lexer->isNextToken(TokenType::T_NOT)) {
  3437. $this->match(TokenType::T_NOT);
  3438. $not = true;
  3439. }
  3441. $this->match(TokenType::T_EXISTS);
  3442. $this->match(TokenType::T_OPEN_PARENTHESIS);
  3444. $subselect = $this->Subselect();
  3446. $this->match(TokenType::T_CLOSE_PARENTHESIS);
  3448. return new AST\ExistsExpression($subselect, $not);
  3449. }
  3451. /**
  3452. * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
  3453. *
  3454. * @return string
  3455. */
  3456. public function ComparisonOperator()
  3457. {
  3458. assert($this->lexer->lookahead !== null);
  3459. switch ($this->lexer->lookahead->value) {
  3460. case '=':
  3461. $this->match(TokenType::T_EQUALS);
  3463. return '=';
  3465. case '<':
  3466. $this->match(TokenType::T_LOWER_THAN);
  3467. $operator = '<';
  3469. if ($this->lexer->isNextToken(TokenType::T_EQUALS)) {
  3470. $this->match(TokenType::T_EQUALS);
  3471. $operator .= '=';
  3472. } elseif ($this->lexer->isNextToken(TokenType::T_GREATER_THAN)) {
  3473. $this->match(TokenType::T_GREATER_THAN);
  3474. $operator .= '>';
  3475. }
  3477. return $operator;
  3479. case '>':
  3480. $this->match(TokenType::T_GREATER_THAN);
  3481. $operator = '>';
  3483. if ($this->lexer->isNextToken(TokenType::T_EQUALS)) {
  3484. $this->match(TokenType::T_EQUALS);
  3485. $operator .= '=';
  3486. }
  3488. return $operator;
  3490. case '!':
  3491. $this->match(TokenType::T_NEGATE);
  3492. $this->match(TokenType::T_EQUALS);
  3494. return '<>';
  3496. default:
  3497. $this->syntaxError('=, <, <=, <>, >, >=, !=');
  3498. }
  3499. }
  3501. /**
  3502. * FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDatetime
  3503. *
  3504. * @return Functions\FunctionNode
  3505. */
  3506. public function FunctionDeclaration()
  3507. {
  3508. assert($this->lexer->lookahead !== null);
  3509. $token = $this->lexer->lookahead;
  3510. $funcName = strtolower($token->value);
  3512. $customFunctionDeclaration = $this->CustomFunctionDeclaration();
  3514. // Check for custom functions functions first!
  3515. switch (true) {
  3516. case $customFunctionDeclaration !== null:
  3517. return $customFunctionDeclaration;
  3519. case isset(self::$stringFunctions[$funcName]):
  3520. return $this->FunctionsReturningStrings();
  3522. case isset(self::$numericFunctions[$funcName]):
  3523. return $this->FunctionsReturningNumerics();
  3525. case isset(self::$datetimeFunctions[$funcName]):
  3526. return $this->FunctionsReturningDatetime();
  3528. default:
  3529. $this->syntaxError('known function', $token);
  3530. }
  3531. }
  3533. /**
  3534. * Helper function for FunctionDeclaration grammar rule.
  3535. */
  3536. private function CustomFunctionDeclaration(): ?Functions\FunctionNode
  3537. {
  3538. assert($this->lexer->lookahead !== null);
  3539. $token = $this->lexer->lookahead;
  3540. $funcName = strtolower($token->value);
  3542. // Check for custom functions afterwards
  3543. $config = $this->em->getConfiguration();
  3545. switch (true) {
  3546. case $config->getCustomStringFunction($funcName) !== null:
  3547. return $this->CustomFunctionsReturningStrings();
  3549. case $config->getCustomNumericFunction($funcName) !== null:
  3550. return $this->CustomFunctionsReturningNumerics();
  3552. case $config->getCustomDatetimeFunction($funcName) !== null:
  3553. return $this->CustomFunctionsReturningDatetime();
  3555. default:
  3556. return null;
  3557. }
  3558. }
  3560. /**
  3561. * FunctionsReturningNumerics ::=
  3562. * "LENGTH" "(" StringPrimary ")" |
  3563. * "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")" |
  3564. * "ABS" "(" SimpleArithmeticExpression ")" |
  3565. * "SQRT" "(" SimpleArithmeticExpression ")" |
  3566. * "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3567. * "SIZE" "(" CollectionValuedPathExpression ")" |
  3568. * "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3569. * "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3570. * "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
  3571. *
  3572. * @return Functions\FunctionNode
  3573. */
  3574. public function FunctionsReturningNumerics()
  3575. {
  3576. assert($this->lexer->lookahead !== null);
  3577. $funcNameLower = strtolower($this->lexer->lookahead->value);
  3578. $funcClass = self::$numericFunctions[$funcNameLower];
  3580. $function = new $funcClass($funcNameLower);
  3581. $function->parse($this);
  3583. return $function;
  3584. }
  3586. /** @return Functions\FunctionNode */
  3587. public function CustomFunctionsReturningNumerics()
  3588. {
  3589. assert($this->lexer->lookahead !== null);
  3590. // getCustomNumericFunction is case-insensitive
  3591. $functionName = strtolower($this->lexer->lookahead->value);
  3592. $functionClass = $this->em->getConfiguration()->getCustomNumericFunction($functionName);
  3594. assert($functionClass !== null);
  3596. $function = is_string($functionClass)
  3597. ? new $functionClass($functionName)
  3598. : $functionClass($functionName);
  3600. $function->parse($this);
  3602. return $function;
  3603. }
  3605. /**
  3606. * FunctionsReturningDateTime ::=
  3607. * "CURRENT_DATE" |
  3608. * "CURRENT_TIME" |
  3609. * "CURRENT_TIMESTAMP" |
  3610. * "DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")" |
  3611. * "DATE_SUB" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
  3612. *
  3613. * @return Functions\FunctionNode
  3614. */
  3615. public function FunctionsReturningDatetime()
  3616. {
  3617. assert($this->lexer->lookahead !== null);
  3618. $funcNameLower = strtolower($this->lexer->lookahead->value);
  3619. $funcClass = self::$datetimeFunctions[$funcNameLower];
  3621. $function = new $funcClass($funcNameLower);
  3622. $function->parse($this);
  3624. return $function;
  3625. }
  3627. /** @return Functions\FunctionNode */
  3628. public function CustomFunctionsReturningDatetime()
  3629. {
  3630. assert($this->lexer->lookahead !== null);
  3631. // getCustomDatetimeFunction is case-insensitive
  3632. $functionName = $this->lexer->lookahead->value;
  3633. $functionClass = $this->em->getConfiguration()->getCustomDatetimeFunction($functionName);
  3635. assert($functionClass !== null);
  3637. $function = is_string($functionClass)
  3638. ? new $functionClass($functionName)
  3639. : $functionClass($functionName);
  3641. $function->parse($this);
  3643. return $function;
  3644. }
  3646. /**
  3647. * FunctionsReturningStrings ::=
  3648. * "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary}* ")" |
  3649. * "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3650. * "TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")" |
  3651. * "LOWER" "(" StringPrimary ")" |
  3652. * "UPPER" "(" StringPrimary ")" |
  3653. * "IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
  3654. *
  3655. * @return Functions\FunctionNode
  3656. */
  3657. public function FunctionsReturningStrings()
  3658. {
  3659. assert($this->lexer->lookahead !== null);
  3660. $funcNameLower = strtolower($this->lexer->lookahead->value);
  3661. $funcClass = self::$stringFunctions[$funcNameLower];
  3663. $function = new $funcClass($funcNameLower);
  3664. $function->parse($this);
  3666. return $function;
  3667. }
  3669. /** @return Functions\FunctionNode */
  3670. public function CustomFunctionsReturningStrings()
  3671. {
  3672. assert($this->lexer->lookahead !== null);
  3673. // getCustomStringFunction is case-insensitive
  3674. $functionName = $this->lexer->lookahead->value;
  3675. $functionClass = $this->em->getConfiguration()->getCustomStringFunction($functionName);
  3677. assert($functionClass !== null);
  3679. $function = is_string($functionClass)
  3680. ? new $functionClass($functionName)
  3681. : $functionClass($functionName);
  3683. $function->parse($this);
  3685. return $function;
  3686. }
  3688. private function getMetadataForDqlAlias(string $dqlAlias): ClassMetadata
  3689. {
  3690. if (! isset($this->queryComponents[$dqlAlias]['metadata'])) {
  3691. throw new LogicException(sprintf('No metadata for DQL alias: %s', $dqlAlias));
  3692. }
  3694. return $this->queryComponents[$dqlAlias]['metadata'];
  3695. }
  3696. }