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

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Query;
  7. use Doctrine\Deprecations\Deprecation;
  8. use Doctrine\ORM\EntityManagerInterface;
  9. use Doctrine\ORM\Mapping\ClassMetadata;
  10. use Doctrine\ORM\Query;
  11. use Doctrine\ORM\Query\AST\AggregateExpression;
  12. use Doctrine\ORM\Query\AST\ArithmeticExpression;
  13. use Doctrine\ORM\Query\AST\ArithmeticFactor;
  14. use Doctrine\ORM\Query\AST\ArithmeticTerm;
  15. use Doctrine\ORM\Query\AST\BetweenExpression;
  16. use Doctrine\ORM\Query\AST\CoalesceExpression;
  17. use Doctrine\ORM\Query\AST\CollectionMemberExpression;
  18. use Doctrine\ORM\Query\AST\ComparisonExpression;
  19. use Doctrine\ORM\Query\AST\ConditionalPrimary;
  20. use Doctrine\ORM\Query\AST\DeleteClause;
  21. use Doctrine\ORM\Query\AST\DeleteStatement;
  22. use Doctrine\ORM\Query\AST\EmptyCollectionComparisonExpression;
  23. use Doctrine\ORM\Query\AST\ExistsExpression;
  24. use Doctrine\ORM\Query\AST\FromClause;
  25. use Doctrine\ORM\Query\AST\Functions;
  26. use Doctrine\ORM\Query\AST\Functions\FunctionNode;
  27. use Doctrine\ORM\Query\AST\GeneralCaseExpression;
  28. use Doctrine\ORM\Query\AST\GroupByClause;
  29. use Doctrine\ORM\Query\AST\HavingClause;
  30. use Doctrine\ORM\Query\AST\IdentificationVariableDeclaration;
  31. use Doctrine\ORM\Query\AST\IndexBy;
  32. use Doctrine\ORM\Query\AST\InExpression;
  33. use Doctrine\ORM\Query\AST\InputParameter;
  34. use Doctrine\ORM\Query\AST\InstanceOfExpression;
  35. use Doctrine\ORM\Query\AST\Join;
  36. use Doctrine\ORM\Query\AST\JoinAssociationPathExpression;
  37. use Doctrine\ORM\Query\AST\LikeExpression;
  38. use Doctrine\ORM\Query\AST\Literal;
  39. use Doctrine\ORM\Query\AST\NewObjectExpression;
  40. use Doctrine\ORM\Query\AST\Node;
  41. use Doctrine\ORM\Query\AST\NullComparisonExpression;
  42. use Doctrine\ORM\Query\AST\NullIfExpression;
  43. use Doctrine\ORM\Query\AST\OrderByClause;
  44. use Doctrine\ORM\Query\AST\OrderByItem;
  45. use Doctrine\ORM\Query\AST\PartialObjectExpression;
  46. use Doctrine\ORM\Query\AST\PathExpression;
  47. use Doctrine\ORM\Query\AST\QuantifiedExpression;
  48. use Doctrine\ORM\Query\AST\RangeVariableDeclaration;
  49. use Doctrine\ORM\Query\AST\SelectClause;
  50. use Doctrine\ORM\Query\AST\SelectExpression;
  51. use Doctrine\ORM\Query\AST\SelectStatement;
  52. use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
  53. use Doctrine\ORM\Query\AST\SimpleSelectClause;
  54. use Doctrine\ORM\Query\AST\SimpleSelectExpression;
  55. use Doctrine\ORM\Query\AST\SimpleWhenClause;
  56. use Doctrine\ORM\Query\AST\Subselect;
  57. use Doctrine\ORM\Query\AST\SubselectFromClause;
  58. use Doctrine\ORM\Query\AST\UpdateClause;
  59. use Doctrine\ORM\Query\AST\UpdateItem;
  60. use Doctrine\ORM\Query\AST\UpdateStatement;
  61. use Doctrine\ORM\Query\AST\WhenClause;
  62. use Doctrine\ORM\Query\AST\WhereClause;
  63. use ReflectionClass;
  65. use function array_intersect;
  66. use function array_search;
  67. use function assert;
  68. use function call_user_func;
  69. use function class_exists;
  70. use function count;
  71. use function explode;
  72. use function implode;
  73. use function in_array;
  74. use function interface_exists;
  75. use function is_string;
  76. use function sprintf;
  77. use function strlen;
  78. use function strpos;
  79. use function strrpos;
  80. use function strtolower;
  81. use function substr;
  83. /**
  84. * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
  85. * Parses a DQL query, reports any errors in it, and generates an AST.
  86. */
  87. class Parser
  88. {
  89. /**
  90. * @readonly Maps BUILT-IN string function names to AST class names.
  91. * @psalm-var array<string, class-string<Functions\FunctionNode>>
  92. */
  93. private static $stringFunctions = [
  94. 'concat' => Functions\ConcatFunction::class,
  95. 'substring' => Functions\SubstringFunction::class,
  96. 'trim' => Functions\TrimFunction::class,
  97. 'lower' => Functions\LowerFunction::class,
  98. 'upper' => Functions\UpperFunction::class,
  99. 'identity' => Functions\IdentityFunction::class,
  100. ];
  102. /**
  103. * @readonly Maps BUILT-IN numeric function names to AST class names.
  104. * @psalm-var array<string, class-string<Functions\FunctionNode>>
  105. */
  106. private static $numericFunctions = [
  107. 'length' => Functions\LengthFunction::class,
  108. 'locate' => Functions\LocateFunction::class,
  109. 'abs' => Functions\AbsFunction::class,
  110. 'sqrt' => Functions\SqrtFunction::class,
  111. 'mod' => Functions\ModFunction::class,
  112. 'size' => Functions\SizeFunction::class,
  113. 'date_diff' => Functions\DateDiffFunction::class,
  114. 'bit_and' => Functions\BitAndFunction::class,
  115. 'bit_or' => Functions\BitOrFunction::class,
  117. // Aggregate functions
  118. 'min' => Functions\MinFunction::class,
  119. 'max' => Functions\MaxFunction::class,
  120. 'avg' => Functions\AvgFunction::class,
  121. 'sum' => Functions\SumFunction::class,
  122. 'count' => Functions\CountFunction::class,
  123. ];
  125. /**
  126. * @readonly Maps BUILT-IN datetime function names to AST class names.
  127. * @psalm-var array<string, class-string<Functions\FunctionNode>>
  128. */
  129. private static $datetimeFunctions = [
  130. 'current_date' => Functions\CurrentDateFunction::class,
  131. 'current_time' => Functions\CurrentTimeFunction::class,
  132. 'current_timestamp' => Functions\CurrentTimestampFunction::class,
  133. 'date_add' => Functions\DateAddFunction::class,
  134. 'date_sub' => Functions\DateSubFunction::class,
  135. ];
  137. /*
  138. * Expressions that were encountered during parsing of identifiers and expressions
  139. * and still need to be validated.
  140. */
  142. /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  143. private $deferredIdentificationVariables = [];
  145. /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  146. private $deferredPartialObjectExpressions = [];
  148. /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  149. private $deferredPathExpressions = [];
  151. /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  152. private $deferredResultVariables = [];
  154. /** @psalm-var list<array{token: mixed, expression: mixed, nestingLevel: int}> */
  155. private $deferredNewObjectExpressions = [];
  157. /**
  158. * The lexer.
  159. *
  160. * @var Lexer
  161. */
  162. private $lexer;
  164. /**
  165. * The parser result.
  166. *
  167. * @var ParserResult
  168. */
  169. private $parserResult;
  171. /**
  172. * The EntityManager.
  173. *
  174. * @var EntityManagerInterface
  175. */
  176. private $em;
  178. /**
  179. * The Query to parse.
  180. *
  181. * @var Query
  182. */
  183. private $query;
  185. /**
  186. * Map of declared query components in the parsed query.
  187. *
  188. * @psalm-var array<string, array<string, mixed>>
  189. */
  190. private $queryComponents = [];
  192. /**
  193. * Keeps the nesting level of defined ResultVariables.
  194. *
  195. * @var int
  196. */
  197. private $nestingLevel = 0;
  199. /**
  200. * Any additional custom tree walkers that modify the AST.
  201. *
  202. * @psalm-var list<class-string<TreeWalker>>
  203. */
  204. private $customTreeWalkers = [];
  206. /**
  207. * The custom last tree walker, if any, that is responsible for producing the output.
  208. *
  209. * @var class-string<TreeWalker>
  210. */
  211. private $customOutputWalker;
  213. /** @psalm-var array<string, AST\SelectExpression> */
  214. private $identVariableExpressions = [];
  216. /**
  217. * Creates a new query parser object.
  218. *
  219. * @param Query $query The Query to parse.
  220. */
  221. public function __construct(Query $query)
  222. {
  223. $this->query = $query;
  224. $this->em = $query->getEntityManager();
  225. $this->lexer = new Lexer((string) $query->getDQL());
  226. $this->parserResult = new ParserResult();
  227. }
  229. /**
  230. * Sets a custom tree walker that produces output.
  231. * This tree walker will be run last over the AST, after any other walkers.
  232. *
  233. * @param string $className
  234. *
  235. * @return void
  236. */
  237. public function setCustomOutputTreeWalker($className)
  238. {
  239. $this->customOutputWalker = $className;
  240. }
  242. /**
  243. * Adds a custom tree walker for modifying the AST.
  244. *
  245. * @param string $className
  246. * @psalm-param class-string $className
  247. *
  248. * @return void
  249. */
  250. public function addCustomTreeWalker($className)
  251. {
  252. $this->customTreeWalkers[] = $className;
  253. }
  255. /**
  256. * Gets the lexer used by the parser.
  257. *
  258. * @return Lexer
  259. */
  260. public function getLexer()
  261. {
  262. return $this->lexer;
  263. }
  265. /**
  266. * Gets the ParserResult that is being filled with information during parsing.
  267. *
  268. * @return ParserResult
  269. */
  270. public function getParserResult()
  271. {
  272. return $this->parserResult;
  273. }
  275. /**
  276. * Gets the EntityManager used by the parser.
  277. *
  278. * @return EntityManagerInterface
  279. */
  280. public function getEntityManager()
  281. {
  282. return $this->em;
  283. }
  285. /**
  286. * Parses and builds AST for the given Query.
  287. *
  288. * @return SelectStatement|UpdateStatement|DeleteStatement
  289. */
  290. public function getAST()
  291. {
  292. // Parse & build AST
  293. $AST = $this->QueryLanguage();
  295. // Process any deferred validations of some nodes in the AST.
  296. // This also allows post-processing of the AST for modification purposes.
  297. $this->processDeferredIdentificationVariables();
  299. if ($this->deferredPartialObjectExpressions) {
  300. $this->processDeferredPartialObjectExpressions();
  301. }
  303. if ($this->deferredPathExpressions) {
  304. $this->processDeferredPathExpressions();
  305. }
  307. if ($this->deferredResultVariables) {
  308. $this->processDeferredResultVariables();
  309. }
  311. if ($this->deferredNewObjectExpressions) {
  312. $this->processDeferredNewObjectExpressions($AST);
  313. }
  315. $this->processRootEntityAliasSelected();
  317. // TODO: Is there a way to remove this? It may impact the mixed hydration resultset a lot!
  318. $this->fixIdentificationVariableOrder($AST);
  320. return $AST;
  321. }
  323. /**
  324. * Attempts to match the given token with the current lookahead token.
  325. *
  326. * If they match, updates the lookahead token; otherwise raises a syntax
  327. * error.
  328. *
  329. * @param int $token The token type.
  330. *
  331. * @return void
  332. *
  333. * @throws QueryException If the tokens don't match.
  334. */
  335. public function match($token)
  336. {
  337. $lookaheadType = $this->lexer->lookahead['type'] ?? null;
  339. // Short-circuit on first condition, usually types match
  340. if ($lookaheadType === $token) {
  341. $this->lexer->moveNext();
  343. return;
  344. }
  346. // If parameter is not identifier (1-99) must be exact match
  347. if ($token < Lexer::T_IDENTIFIER) {
  348. $this->syntaxError($this->lexer->getLiteral($token));
  349. }
  351. // If parameter is keyword (200+) must be exact match
  352. if ($token > Lexer::T_IDENTIFIER) {
  353. $this->syntaxError($this->lexer->getLiteral($token));
  354. }
  356. // If parameter is T_IDENTIFIER, then matches T_IDENTIFIER (100) and keywords (200+)
  357. if ($token === Lexer::T_IDENTIFIER && $lookaheadType < Lexer::T_IDENTIFIER) {
  358. $this->syntaxError($this->lexer->getLiteral($token));
  359. }
  361. $this->lexer->moveNext();
  362. }
  364. /**
  365. * Frees this parser, enabling it to be reused.
  366. *
  367. * @param bool $deep Whether to clean peek and reset errors.
  368. * @param int $position Position to reset.
  369. *
  370. * @return void
  371. */
  372. public function free($deep = false, $position = 0)
  373. {
  374. // WARNING! Use this method with care. It resets the scanner!
  375. $this->lexer->resetPosition($position);
  377. // Deep = true cleans peek and also any previously defined errors
  378. if ($deep) {
  379. $this->lexer->resetPeek();
  380. }
  382. $this->lexer->token = null;
  383. $this->lexer->lookahead = null;
  384. }
  386. /**
  387. * Parses a query string.
  388. *
  389. * @return ParserResult
  390. */
  391. public function parse()
  392. {
  393. $AST = $this->getAST();
  395. $customWalkers = $this->query->getHint(Query::HINT_CUSTOM_TREE_WALKERS);
  396. if ($customWalkers !== false) {
  397. $this->customTreeWalkers = $customWalkers;
  398. }
  400. $customOutputWalker = $this->query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER);
  401. if ($customOutputWalker !== false) {
  402. $this->customOutputWalker = $customOutputWalker;
  403. }
  405. // Run any custom tree walkers over the AST
  406. if ($this->customTreeWalkers) {
  407. $treeWalkerChain = new TreeWalkerChain($this->query, $this->parserResult, $this->queryComponents);
  409. foreach ($this->customTreeWalkers as $walker) {
  410. $treeWalkerChain->addTreeWalker($walker);
  411. }
  413. switch (true) {
  414. case $AST instanceof AST\UpdateStatement:
  415. $treeWalkerChain->walkUpdateStatement($AST);
  416. break;
  418. case $AST instanceof AST\DeleteStatement:
  419. $treeWalkerChain->walkDeleteStatement($AST);
  420. break;
  422. case $AST instanceof AST\SelectStatement:
  423. default:
  424. $treeWalkerChain->walkSelectStatement($AST);
  425. }
  427. $this->queryComponents = $treeWalkerChain->getQueryComponents();
  428. }
  430. $outputWalkerClass = $this->customOutputWalker ?: SqlWalker::class;
  431. $outputWalker = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
  433. // Assign an SQL executor to the parser result
  434. $this->parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
  436. return $this->parserResult;
  437. }
  439. /**
  440. * Fixes order of identification variables.
  441. *
  442. * They have to appear in the select clause in the same order as the
  443. * declarations (from ... x join ... y join ... z ...) appear in the query
  444. * as the hydration process relies on that order for proper operation.
  445. *
  446. * @param AST\SelectStatement|AST\DeleteStatement|AST\UpdateStatement $AST
  447. */
  448. private function fixIdentificationVariableOrder(Node $AST): void
  449. {
  450. if (count($this->identVariableExpressions) <= 1) {
  451. return;
  452. }
  454. assert($AST instanceof AST\SelectStatement);
  456. foreach ($this->queryComponents as $dqlAlias => $qComp) {
  457. if (! isset($this->identVariableExpressions[$dqlAlias])) {
  458. continue;
  459. }
  461. $expr = $this->identVariableExpressions[$dqlAlias];
  462. $key = array_search($expr, $AST->selectClause->selectExpressions, true);
  464. unset($AST->selectClause->selectExpressions[$key]);
  466. $AST->selectClause->selectExpressions[] = $expr;
  467. }
  468. }
  470. /**
  471. * Generates a new syntax error.
  472. *
  473. * @param string $expected Expected string.
  474. * @param mixed[]|null $token Got token.
  475. * @psalm-param array<string, mixed>|null $token
  476. *
  477. * @return void
  478. * @psalm-return no-return
  479. *
  480. * @throws QueryException
  481. */
  482. public function syntaxError($expected = '', $token = null)
  483. {
  484. if ($token === null) {
  485. $token = $this->lexer->lookahead;
  486. }
  488. $tokenPos = $token['position'] ?? '-1';
  490. $message = sprintf('line 0, col %d: Error: ', $tokenPos);
  491. $message .= $expected !== '' ? sprintf('Expected %s, got ', $expected) : 'Unexpected ';
  492. $message .= $this->lexer->lookahead === null ? 'end of string.' : sprintf("'%s'", $token['value']);
  494. throw QueryException::syntaxError($message, QueryException::dqlError($this->query->getDQL() ?? ''));
  495. }
  497. /**
  498. * Generates a new semantical error.
  499. *
  500. * @param string $message Optional message.
  501. * @param mixed[]|null $token Optional token.
  502. * @psalm-param array<string, mixed>|null $token
  503. *
  504. * @return void
  505. *
  506. * @throws QueryException
  507. */
  508. public function semanticalError($message = '', $token = null)
  509. {
  510. if ($token === null) {
  511. $token = $this->lexer->lookahead ?? ['position' => 0];
  512. }
  514. // Minimum exposed chars ahead of token
  515. $distance = 12;
  517. // Find a position of a final word to display in error string
  518. $dql = $this->query->getDQL();
  519. $length = strlen($dql);
  520. $pos = $token['position'] + $distance;
  521. $pos = strpos($dql, ' ', $length > $pos ? $pos : $length);
  522. $length = $pos !== false ? $pos - $token['position'] : $distance;
  524. $tokenPos = $token['position'] > 0 ? $token['position'] : '-1';
  525. $tokenStr = substr($dql, $token['position'], $length);
  527. // Building informative message
  528. $message = 'line 0, col ' . $tokenPos . " near '" . $tokenStr . "': Error: " . $message;
  530. throw QueryException::semanticalError($message, QueryException::dqlError($this->query->getDQL()));
  531. }
  533. /**
  534. * Peeks beyond the matched closing parenthesis and returns the first token after that one.
  535. *
  536. * @param bool $resetPeek Reset peek after finding the closing parenthesis.
  537. *
  538. * @return mixed[]
  539. * @psalm-return array{value: string, type: int|null|string, position: int}|null
  540. */
  541. private function peekBeyondClosingParenthesis(bool $resetPeek = true): ?array
  542. {
  543. $token = $this->lexer->peek();
  544. $numUnmatched = 1;
  546. while ($numUnmatched > 0 && $token !== null) {
  547. switch ($token['type']) {
  548. case Lexer::T_OPEN_PARENTHESIS:
  549. ++$numUnmatched;
  550. break;
  552. case Lexer::T_CLOSE_PARENTHESIS:
  553. --$numUnmatched;
  554. break;
  556. default:
  557. // Do nothing
  558. }
  560. $token = $this->lexer->peek();
  561. }
  563. if ($resetPeek) {
  564. $this->lexer->resetPeek();
  565. }
  567. return $token;
  568. }
  570. /**
  571. * Checks if the given token indicates a mathematical operator.
  572. *
  573. * @psalm-param array<string, mixed>|null $token
  574. */
  575. private function isMathOperator(?array $token): bool
  576. {
  577. return $token !== null && in_array($token['type'], [Lexer::T_PLUS, Lexer::T_MINUS, Lexer::T_DIVIDE, Lexer::T_MULTIPLY], true);
  578. }
  580. /**
  581. * Checks if the next-next (after lookahead) token starts a function.
  582. *
  583. * @return bool TRUE if the next-next tokens start a function, FALSE otherwise.
  584. */
  585. private function isFunction(): bool
  586. {
  587. $lookaheadType = $this->lexer->lookahead['type'];
  588. $peek = $this->lexer->peek();
  590. $this->lexer->resetPeek();
  592. return $lookaheadType >= Lexer::T_IDENTIFIER && $peek !== null && $peek['type'] === Lexer::T_OPEN_PARENTHESIS;
  593. }
  595. /**
  596. * Checks whether the given token type indicates an aggregate function.
  597. *
  598. * @psalm-param Lexer::T_* $tokenType
  599. *
  600. * @return bool TRUE if the token type is an aggregate function, FALSE otherwise.
  601. */
  602. private function isAggregateFunction(int $tokenType): bool
  603. {
  604. return in_array(
  605. $tokenType,
  606. [Lexer::T_AVG, Lexer::T_MIN, Lexer::T_MAX, Lexer::T_SUM, Lexer::T_COUNT],
  607. true
  608. );
  609. }
  611. /**
  612. * Checks whether the current lookahead token of the lexer has the type T_ALL, T_ANY or T_SOME.
  613. */
  614. private function isNextAllAnySome(): bool
  615. {
  616. return in_array(
  617. $this->lexer->lookahead['type'],
  618. [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME],
  619. true
  620. );
  621. }
  623. /**
  624. * Validates that the given <tt>IdentificationVariable</tt> is semantically correct.
  625. * It must exist in query components list.
  626. */
  627. private function processDeferredIdentificationVariables(): void
  628. {
  629. foreach ($this->deferredIdentificationVariables as $deferredItem) {
  630. $identVariable = $deferredItem['expression'];
  632. // Check if IdentificationVariable exists in queryComponents
  633. if (! isset($this->queryComponents[$identVariable])) {
  634. $this->semanticalError(
  635. sprintf("'%s' is not defined.", $identVariable),
  636. $deferredItem['token']
  637. );
  638. }
  640. $qComp = $this->queryComponents[$identVariable];
  642. // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  643. if (! isset($qComp['metadata'])) {
  644. $this->semanticalError(
  645. sprintf("'%s' does not point to a Class.", $identVariable),
  646. $deferredItem['token']
  647. );
  648. }
  650. // Validate if identification variable nesting level is lower or equal than the current one
  651. if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  652. $this->semanticalError(
  653. sprintf("'%s' is used outside the scope of its declaration.", $identVariable),
  654. $deferredItem['token']
  655. );
  656. }
  657. }
  658. }
  660. /**
  661. * Validates that the given <tt>NewObjectExpression</tt>.
  662. */
  663. private function processDeferredNewObjectExpressions(SelectStatement $AST): void
  664. {
  665. foreach ($this->deferredNewObjectExpressions as $deferredItem) {
  666. $expression = $deferredItem['expression'];
  667. $token = $deferredItem['token'];
  668. $className = $expression->className;
  669. $args = $expression->args;
  670. $fromClassName = $AST->fromClause->identificationVariableDeclarations[0]->rangeVariableDeclaration->abstractSchemaName ?? null;
  672. // If the namespace is not given then assumes the first FROM entity namespace
  673. if (strpos($className, '\\') === false && ! class_exists($className) && strpos($fromClassName, '\\') !== false) {
  674. $namespace = substr($fromClassName, 0, strrpos($fromClassName, '\\'));
  675. $fqcn = $namespace . '\\' . $className;
  677. if (class_exists($fqcn)) {
  678. $expression->className = $fqcn;
  679. $className = $fqcn;
  680. }
  681. }
  683. if (! class_exists($className)) {
  684. $this->semanticalError(sprintf('Class "%s" is not defined.', $className), $token);
  685. }
  687. $class = new ReflectionClass($className);
  689. if (! $class->isInstantiable()) {
  690. $this->semanticalError(sprintf('Class "%s" can not be instantiated.', $className), $token);
  691. }
  693. if ($class->getConstructor() === null) {
  694. $this->semanticalError(sprintf('Class "%s" has not a valid constructor.', $className), $token);
  695. }
  697. if ($class->getConstructor()->getNumberOfRequiredParameters() > count($args)) {
  698. $this->semanticalError(sprintf('Number of arguments does not match with "%s" constructor declaration.', $className), $token);
  699. }
  700. }
  701. }
  703. /**
  704. * Validates that the given <tt>PartialObjectExpression</tt> is semantically correct.
  705. * It must exist in query components list.
  706. */
  707. private function processDeferredPartialObjectExpressions(): void
  708. {
  709. foreach ($this->deferredPartialObjectExpressions as $deferredItem) {
  710. $expr = $deferredItem['expression'];
  711. $class = $this->queryComponents[$expr->identificationVariable]['metadata'];
  713. foreach ($expr->partialFieldSet as $field) {
  714. if (isset($class->fieldMappings[$field])) {
  715. continue;
  716. }
  718. if (
  719. isset($class->associationMappings[$field]) &&
  720. $class->associationMappings[$field]['isOwningSide'] &&
  721. $class->associationMappings[$field]['type'] & ClassMetadata::TO_ONE
  722. ) {
  723. continue;
  724. }
  726. $this->semanticalError(sprintf(
  727. "There is no mapped field named '%s' on class %s.",
  728. $field,
  729. $class->name
  730. ), $deferredItem['token']);
  731. }
  733. if (array_intersect($class->identifier, $expr->partialFieldSet) !== $class->identifier) {
  734. $this->semanticalError(
  735. 'The partial field selection of class ' . $class->name . ' must contain the identifier.',
  736. $deferredItem['token']
  737. );
  738. }
  739. }
  740. }
  742. /**
  743. * Validates that the given <tt>ResultVariable</tt> is semantically correct.
  744. * It must exist in query components list.
  745. */
  746. private function processDeferredResultVariables(): void
  747. {
  748. foreach ($this->deferredResultVariables as $deferredItem) {
  749. $resultVariable = $deferredItem['expression'];
  751. // Check if ResultVariable exists in queryComponents
  752. if (! isset($this->queryComponents[$resultVariable])) {
  753. $this->semanticalError(
  754. sprintf("'%s' is not defined.", $resultVariable),
  755. $deferredItem['token']
  756. );
  757. }
  759. $qComp = $this->queryComponents[$resultVariable];
  761. // Check if queryComponent points to an AbstractSchemaName or a ResultVariable
  762. if (! isset($qComp['resultVariable'])) {
  763. $this->semanticalError(
  764. sprintf("'%s' does not point to a ResultVariable.", $resultVariable),
  765. $deferredItem['token']
  766. );
  767. }
  769. // Validate if identification variable nesting level is lower or equal than the current one
  770. if ($qComp['nestingLevel'] > $deferredItem['nestingLevel']) {
  771. $this->semanticalError(
  772. sprintf("'%s' is used outside the scope of its declaration.", $resultVariable),
  773. $deferredItem['token']
  774. );
  775. }
  776. }
  777. }
  779. /**
  780. * Validates that the given <tt>PathExpression</tt> is semantically correct for grammar rules:
  781. *
  782. * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  783. * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  784. * StateFieldPathExpression ::= IdentificationVariable "." StateField
  785. * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  786. * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  787. */
  788. private function processDeferredPathExpressions(): void
  789. {
  790. foreach ($this->deferredPathExpressions as $deferredItem) {
  791. $pathExpression = $deferredItem['expression'];
  793. $qComp = $this->queryComponents[$pathExpression->identificationVariable];
  794. $class = $qComp['metadata'];
  796. $field = $pathExpression->field;
  797. if ($field === null) {
  798. $field = $pathExpression->field = $class->identifier[0];
  799. }
  801. // Check if field or association exists
  802. if (! isset($class->associationMappings[$field]) && ! isset($class->fieldMappings[$field])) {
  803. $this->semanticalError(
  804. 'Class ' . $class->name . ' has no field or association named ' . $field,
  805. $deferredItem['token']
  806. );
  807. }
  809. $fieldType = AST\PathExpression::TYPE_STATE_FIELD;
  811. if (isset($class->associationMappings[$field])) {
  812. $assoc = $class->associationMappings[$field];
  814. $fieldType = $assoc['type'] & ClassMetadata::TO_ONE
  815. ? AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  816. : AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION;
  817. }
  819. // Validate if PathExpression is one of the expected types
  820. $expectedType = $pathExpression->expectedType;
  822. if (! ($expectedType & $fieldType)) {
  823. // We need to recognize which was expected type(s)
  824. $expectedStringTypes = [];
  826. // Validate state field type
  827. if ($expectedType & AST\PathExpression::TYPE_STATE_FIELD) {
  828. $expectedStringTypes[] = 'StateFieldPathExpression';
  829. }
  831. // Validate single valued association (*-to-one)
  832. if ($expectedType & AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION) {
  833. $expectedStringTypes[] = 'SingleValuedAssociationField';
  834. }
  836. // Validate single valued association (*-to-many)
  837. if ($expectedType & AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION) {
  838. $expectedStringTypes[] = 'CollectionValuedAssociationField';
  839. }
  841. // Build the error message
  842. $semanticalError = 'Invalid PathExpression. ';
  843. $semanticalError .= count($expectedStringTypes) === 1
  844. ? 'Must be a ' . $expectedStringTypes[0] . '.'
  845. : implode(' or ', $expectedStringTypes) . ' expected.';
  847. $this->semanticalError($semanticalError, $deferredItem['token']);
  848. }
  850. // We need to force the type in PathExpression
  851. $pathExpression->type = $fieldType;
  852. }
  853. }
  855. private function processRootEntityAliasSelected(): void
  856. {
  857. if (! count($this->identVariableExpressions)) {
  858. return;
  859. }
  861. foreach ($this->identVariableExpressions as $dqlAlias => $expr) {
  862. if (isset($this->queryComponents[$dqlAlias]) && $this->queryComponents[$dqlAlias]['parent'] === null) {
  863. return;
  864. }
  865. }
  867. $this->semanticalError('Cannot select entity through identification variables without choosing at least one root entity alias.');
  868. }
  870. /**
  871. * QueryLanguage ::= SelectStatement | UpdateStatement | DeleteStatement
  872. *
  873. * @return SelectStatement|UpdateStatement|DeleteStatement
  874. */
  875. public function QueryLanguage()
  876. {
  877. $statement = null;
  879. $this->lexer->moveNext();
  881. switch ($this->lexer->lookahead['type'] ?? null) {
  882. case Lexer::T_SELECT:
  883. $statement = $this->SelectStatement();
  884. break;
  886. case Lexer::T_UPDATE:
  887. $statement = $this->UpdateStatement();
  888. break;
  890. case Lexer::T_DELETE:
  891. $statement = $this->DeleteStatement();
  892. break;
  894. default:
  895. $this->syntaxError('SELECT, UPDATE or DELETE');
  896. break;
  897. }
  899. // Check for end of string
  900. if ($this->lexer->lookahead !== null) {
  901. $this->syntaxError('end of string');
  902. }
  904. return $statement;
  905. }
  907. /**
  908. * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  909. *
  910. * @return SelectStatement
  911. */
  912. public function SelectStatement()
  913. {
  914. $selectStatement = new AST\SelectStatement($this->SelectClause(), $this->FromClause());
  916. $selectStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  917. $selectStatement->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  918. $selectStatement->havingClause = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  919. $selectStatement->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  921. return $selectStatement;
  922. }
  924. /**
  925. * UpdateStatement ::= UpdateClause [WhereClause]
  926. *
  927. * @return UpdateStatement
  928. */
  929. public function UpdateStatement()
  930. {
  931. $updateStatement = new AST\UpdateStatement($this->UpdateClause());
  933. $updateStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  935. return $updateStatement;
  936. }
  938. /**
  939. * DeleteStatement ::= DeleteClause [WhereClause]
  940. *
  941. * @return DeleteStatement
  942. */
  943. public function DeleteStatement()
  944. {
  945. $deleteStatement = new AST\DeleteStatement($this->DeleteClause());
  947. $deleteStatement->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  949. return $deleteStatement;
  950. }
  952. /**
  953. * IdentificationVariable ::= identifier
  954. *
  955. * @return string
  956. */
  957. public function IdentificationVariable()
  958. {
  959. $this->match(Lexer::T_IDENTIFIER);
  961. $identVariable = $this->lexer->token['value'];
  963. $this->deferredIdentificationVariables[] = [
  964. 'expression' => $identVariable,
  965. 'nestingLevel' => $this->nestingLevel,
  966. 'token' => $this->lexer->token,
  967. ];
  969. return $identVariable;
  970. }
  972. /**
  973. * AliasIdentificationVariable = identifier
  974. *
  975. * @return string
  976. */
  977. public function AliasIdentificationVariable()
  978. {
  979. $this->match(Lexer::T_IDENTIFIER);
  981. $aliasIdentVariable = $this->lexer->token['value'];
  982. $exists = isset($this->queryComponents[$aliasIdentVariable]);
  984. if ($exists) {
  985. $this->semanticalError(
  986. sprintf("'%s' is already defined.", $aliasIdentVariable),
  987. $this->lexer->token
  988. );
  989. }
  991. return $aliasIdentVariable;
  992. }
  994. /**
  995. * AbstractSchemaName ::= fully_qualified_name | aliased_name | identifier
  996. *
  997. * @return string
  998. */
  999. public function AbstractSchemaName()
  1000. {
  1001. if ($this->lexer->isNextToken(Lexer::T_FULLY_QUALIFIED_NAME)) {
  1002. $this->match(Lexer::T_FULLY_QUALIFIED_NAME);
  1004. return $this->lexer->token['value'];
  1005. }
  1007. if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  1008. $this->match(Lexer::T_IDENTIFIER);
  1010. return $this->lexer->token['value'];
  1011. }
  1013. $this->match(Lexer::T_ALIASED_NAME);
  1015. [$namespaceAlias, $simpleClassName] = explode(':', $this->lexer->token['value']);
  1017. return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  1018. }
  1020. /**
  1021. * Validates an AbstractSchemaName, making sure the class exists.
  1022. *
  1023. * @param string $schemaName The name to validate.
  1024. *
  1025. * @throws QueryException if the name does not exist.
  1026. */
  1027. private function validateAbstractSchemaName(string $schemaName): void
  1028. {
  1029. if (! (class_exists($schemaName, true) || interface_exists($schemaName, true))) {
  1030. $this->semanticalError(
  1031. sprintf("Class '%s' is not defined.", $schemaName),
  1032. $this->lexer->token
  1033. );
  1034. }
  1035. }
  1037. /**
  1038. * AliasResultVariable ::= identifier
  1039. *
  1040. * @return string
  1041. */
  1042. public function AliasResultVariable()
  1043. {
  1044. $this->match(Lexer::T_IDENTIFIER);
  1046. $resultVariable = $this->lexer->token['value'];
  1047. $exists = isset($this->queryComponents[$resultVariable]);
  1049. if ($exists) {
  1050. $this->semanticalError(
  1051. sprintf("'%s' is already defined.", $resultVariable),
  1052. $this->lexer->token
  1053. );
  1054. }
  1056. return $resultVariable;
  1057. }
  1059. /**
  1060. * ResultVariable ::= identifier
  1061. *
  1062. * @return string
  1063. */
  1064. public function ResultVariable()
  1065. {
  1066. $this->match(Lexer::T_IDENTIFIER);
  1068. $resultVariable = $this->lexer->token['value'];
  1070. // Defer ResultVariable validation
  1071. $this->deferredResultVariables[] = [
  1072. 'expression' => $resultVariable,
  1073. 'nestingLevel' => $this->nestingLevel,
  1074. 'token' => $this->lexer->token,
  1075. ];
  1077. return $resultVariable;
  1078. }
  1080. /**
  1081. * JoinAssociationPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
  1082. *
  1083. * @return JoinAssociationPathExpression
  1084. */
  1085. public function JoinAssociationPathExpression()
  1086. {
  1087. $identVariable = $this->IdentificationVariable();
  1089. if (! isset($this->queryComponents[$identVariable])) {
  1090. $this->semanticalError(
  1091. 'Identification Variable ' . $identVariable . ' used in join path expression but was not defined before.'
  1092. );
  1093. }
  1095. $this->match(Lexer::T_DOT);
  1096. $this->match(Lexer::T_IDENTIFIER);
  1098. $field = $this->lexer->token['value'];
  1100. // Validate association field
  1101. $qComp = $this->queryComponents[$identVariable];
  1102. $class = $qComp['metadata'];
  1104. if (! $class->hasAssociation($field)) {
  1105. $this->semanticalError('Class ' . $class->name . ' has no association named ' . $field);
  1106. }
  1108. return new AST\JoinAssociationPathExpression($identVariable, $field);
  1109. }
  1111. /**
  1112. * Parses an arbitrary path expression and defers semantical validation
  1113. * based on expected types.
  1114. *
  1115. * PathExpression ::= IdentificationVariable {"." identifier}*
  1116. *
  1117. * @param int $expectedTypes
  1118. *
  1119. * @return PathExpression
  1120. */
  1121. public function PathExpression($expectedTypes)
  1122. {
  1123. $identVariable = $this->IdentificationVariable();
  1124. $field = null;
  1126. if ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1127. $this->match(Lexer::T_DOT);
  1128. $this->match(Lexer::T_IDENTIFIER);
  1130. $field = $this->lexer->token['value'];
  1132. while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1133. $this->match(Lexer::T_DOT);
  1134. $this->match(Lexer::T_IDENTIFIER);
  1135. $field .= '.' . $this->lexer->token['value'];
  1136. }
  1137. }
  1139. // Creating AST node
  1140. $pathExpr = new AST\PathExpression($expectedTypes, $identVariable, $field);
  1142. // Defer PathExpression validation if requested to be deferred
  1143. $this->deferredPathExpressions[] = [
  1144. 'expression' => $pathExpr,
  1145. 'nestingLevel' => $this->nestingLevel,
  1146. 'token' => $this->lexer->token,
  1147. ];
  1149. return $pathExpr;
  1150. }
  1152. /**
  1153. * AssociationPathExpression ::= CollectionValuedPathExpression | SingleValuedAssociationPathExpression
  1154. *
  1155. * @return PathExpression
  1156. */
  1157. public function AssociationPathExpression()
  1158. {
  1159. return $this->PathExpression(
  1160. AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION |
  1161. AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION
  1162. );
  1163. }
  1165. /**
  1166. * SingleValuedPathExpression ::= StateFieldPathExpression | SingleValuedAssociationPathExpression
  1167. *
  1168. * @return PathExpression
  1169. */
  1170. public function SingleValuedPathExpression()
  1171. {
  1172. return $this->PathExpression(
  1173. AST\PathExpression::TYPE_STATE_FIELD |
  1174. AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION
  1175. );
  1176. }
  1178. /**
  1179. * StateFieldPathExpression ::= IdentificationVariable "." StateField
  1180. *
  1181. * @return PathExpression
  1182. */
  1183. public function StateFieldPathExpression()
  1184. {
  1185. return $this->PathExpression(AST\PathExpression::TYPE_STATE_FIELD);
  1186. }
  1188. /**
  1189. * SingleValuedAssociationPathExpression ::= IdentificationVariable "." SingleValuedAssociationField
  1190. *
  1191. * @return PathExpression
  1192. */
  1193. public function SingleValuedAssociationPathExpression()
  1194. {
  1195. return $this->PathExpression(AST\PathExpression::TYPE_SINGLE_VALUED_ASSOCIATION);
  1196. }
  1198. /**
  1199. * CollectionValuedPathExpression ::= IdentificationVariable "." CollectionValuedAssociationField
  1200. *
  1201. * @return PathExpression
  1202. */
  1203. public function CollectionValuedPathExpression()
  1204. {
  1205. return $this->PathExpression(AST\PathExpression::TYPE_COLLECTION_VALUED_ASSOCIATION);
  1206. }
  1208. /**
  1209. * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
  1210. *
  1211. * @return SelectClause
  1212. */
  1213. public function SelectClause()
  1214. {
  1215. $isDistinct = false;
  1216. $this->match(Lexer::T_SELECT);
  1218. // Check for DISTINCT
  1219. if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1220. $this->match(Lexer::T_DISTINCT);
  1222. $isDistinct = true;
  1223. }
  1225. // Process SelectExpressions (1..N)
  1226. $selectExpressions = [];
  1227. $selectExpressions[] = $this->SelectExpression();
  1229. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1230. $this->match(Lexer::T_COMMA);
  1232. $selectExpressions[] = $this->SelectExpression();
  1233. }
  1235. return new AST\SelectClause($selectExpressions, $isDistinct);
  1236. }
  1238. /**
  1239. * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
  1240. *
  1241. * @return SimpleSelectClause
  1242. */
  1243. public function SimpleSelectClause()
  1244. {
  1245. $isDistinct = false;
  1246. $this->match(Lexer::T_SELECT);
  1248. if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  1249. $this->match(Lexer::T_DISTINCT);
  1251. $isDistinct = true;
  1252. }
  1254. return new AST\SimpleSelectClause($this->SimpleSelectExpression(), $isDistinct);
  1255. }
  1257. /**
  1258. * UpdateClause ::= "UPDATE" AbstractSchemaName ["AS"] AliasIdentificationVariable "SET" UpdateItem {"," UpdateItem}*
  1259. *
  1260. * @return UpdateClause
  1261. */
  1262. public function UpdateClause()
  1263. {
  1264. $this->match(Lexer::T_UPDATE);
  1266. $token = $this->lexer->lookahead;
  1267. $abstractSchemaName = $this->AbstractSchemaName();
  1269. $this->validateAbstractSchemaName($abstractSchemaName);
  1271. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1272. $this->match(Lexer::T_AS);
  1273. }
  1275. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1277. $class = $this->em->getClassMetadata($abstractSchemaName);
  1279. // Building queryComponent
  1280. $queryComponent = [
  1281. 'metadata' => $class,
  1282. 'parent' => null,
  1283. 'relation' => null,
  1284. 'map' => null,
  1285. 'nestingLevel' => $this->nestingLevel,
  1286. 'token' => $token,
  1287. ];
  1289. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1291. $this->match(Lexer::T_SET);
  1293. $updateItems = [];
  1294. $updateItems[] = $this->UpdateItem();
  1296. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1297. $this->match(Lexer::T_COMMA);
  1299. $updateItems[] = $this->UpdateItem();
  1300. }
  1302. $updateClause = new AST\UpdateClause($abstractSchemaName, $updateItems);
  1303. $updateClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1305. return $updateClause;
  1306. }
  1308. /**
  1309. * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName ["AS"] AliasIdentificationVariable
  1310. *
  1311. * @return DeleteClause
  1312. */
  1313. public function DeleteClause()
  1314. {
  1315. $this->match(Lexer::T_DELETE);
  1317. if ($this->lexer->isNextToken(Lexer::T_FROM)) {
  1318. $this->match(Lexer::T_FROM);
  1319. }
  1321. $token = $this->lexer->lookahead;
  1322. $abstractSchemaName = $this->AbstractSchemaName();
  1324. $this->validateAbstractSchemaName($abstractSchemaName);
  1326. $deleteClause = new AST\DeleteClause($abstractSchemaName);
  1328. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1329. $this->match(Lexer::T_AS);
  1330. }
  1332. $aliasIdentificationVariable = $this->lexer->isNextToken(Lexer::T_IDENTIFIER)
  1333. ? $this->AliasIdentificationVariable()
  1334. : 'alias_should_have_been_set';
  1336. $deleteClause->aliasIdentificationVariable = $aliasIdentificationVariable;
  1337. $class = $this->em->getClassMetadata($deleteClause->abstractSchemaName);
  1339. // Building queryComponent
  1340. $queryComponent = [
  1341. 'metadata' => $class,
  1342. 'parent' => null,
  1343. 'relation' => null,
  1344. 'map' => null,
  1345. 'nestingLevel' => $this->nestingLevel,
  1346. 'token' => $token,
  1347. ];
  1349. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1351. return $deleteClause;
  1352. }
  1354. /**
  1355. * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}*
  1356. *
  1357. * @return FromClause
  1358. */
  1359. public function FromClause()
  1360. {
  1361. $this->match(Lexer::T_FROM);
  1363. $identificationVariableDeclarations = [];
  1364. $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1366. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1367. $this->match(Lexer::T_COMMA);
  1369. $identificationVariableDeclarations[] = $this->IdentificationVariableDeclaration();
  1370. }
  1372. return new AST\FromClause($identificationVariableDeclarations);
  1373. }
  1375. /**
  1376. * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
  1377. *
  1378. * @return SubselectFromClause
  1379. */
  1380. public function SubselectFromClause()
  1381. {
  1382. $this->match(Lexer::T_FROM);
  1384. $identificationVariables = [];
  1385. $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1387. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1388. $this->match(Lexer::T_COMMA);
  1390. $identificationVariables[] = $this->SubselectIdentificationVariableDeclaration();
  1391. }
  1393. return new AST\SubselectFromClause($identificationVariables);
  1394. }
  1396. /**
  1397. * WhereClause ::= "WHERE" ConditionalExpression
  1398. *
  1399. * @return WhereClause
  1400. */
  1401. public function WhereClause()
  1402. {
  1403. $this->match(Lexer::T_WHERE);
  1405. return new AST\WhereClause($this->ConditionalExpression());
  1406. }
  1408. /**
  1409. * HavingClause ::= "HAVING" ConditionalExpression
  1410. *
  1411. * @return HavingClause
  1412. */
  1413. public function HavingClause()
  1414. {
  1415. $this->match(Lexer::T_HAVING);
  1417. return new AST\HavingClause($this->ConditionalExpression());
  1418. }
  1420. /**
  1421. * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
  1422. *
  1423. * @return GroupByClause
  1424. */
  1425. public function GroupByClause()
  1426. {
  1427. $this->match(Lexer::T_GROUP);
  1428. $this->match(Lexer::T_BY);
  1430. $groupByItems = [$this->GroupByItem()];
  1432. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1433. $this->match(Lexer::T_COMMA);
  1435. $groupByItems[] = $this->GroupByItem();
  1436. }
  1438. return new AST\GroupByClause($groupByItems);
  1439. }
  1441. /**
  1442. * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
  1443. *
  1444. * @return OrderByClause
  1445. */
  1446. public function OrderByClause()
  1447. {
  1448. $this->match(Lexer::T_ORDER);
  1449. $this->match(Lexer::T_BY);
  1451. $orderByItems = [];
  1452. $orderByItems[] = $this->OrderByItem();
  1454. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1455. $this->match(Lexer::T_COMMA);
  1457. $orderByItems[] = $this->OrderByItem();
  1458. }
  1460. return new AST\OrderByClause($orderByItems);
  1461. }
  1463. /**
  1464. * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
  1465. *
  1466. * @return Subselect
  1467. */
  1468. public function Subselect()
  1469. {
  1470. // Increase query nesting level
  1471. $this->nestingLevel++;
  1473. $subselect = new AST\Subselect($this->SimpleSelectClause(), $this->SubselectFromClause());
  1475. $subselect->whereClause = $this->lexer->isNextToken(Lexer::T_WHERE) ? $this->WhereClause() : null;
  1476. $subselect->groupByClause = $this->lexer->isNextToken(Lexer::T_GROUP) ? $this->GroupByClause() : null;
  1477. $subselect->havingClause = $this->lexer->isNextToken(Lexer::T_HAVING) ? $this->HavingClause() : null;
  1478. $subselect->orderByClause = $this->lexer->isNextToken(Lexer::T_ORDER) ? $this->OrderByClause() : null;
  1480. // Decrease query nesting level
  1481. $this->nestingLevel--;
  1483. return $subselect;
  1484. }
  1486. /**
  1487. * UpdateItem ::= SingleValuedPathExpression "=" NewValue
  1488. *
  1489. * @return UpdateItem
  1490. */
  1491. public function UpdateItem()
  1492. {
  1493. $pathExpr = $this->SingleValuedPathExpression();
  1495. $this->match(Lexer::T_EQUALS);
  1497. return new AST\UpdateItem($pathExpr, $this->NewValue());
  1498. }
  1500. /**
  1501. * GroupByItem ::= IdentificationVariable | ResultVariable | SingleValuedPathExpression
  1502. *
  1503. * @return string|PathExpression
  1504. */
  1505. public function GroupByItem()
  1506. {
  1507. // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  1508. $glimpse = $this->lexer->glimpse();
  1510. if ($glimpse !== null && $glimpse['type'] === Lexer::T_DOT) {
  1511. return $this->SingleValuedPathExpression();
  1512. }
  1514. // Still need to decide between IdentificationVariable or ResultVariable
  1515. $lookaheadValue = $this->lexer->lookahead['value'];
  1517. if (! isset($this->queryComponents[$lookaheadValue])) {
  1518. $this->semanticalError('Cannot group by undefined identification or result variable.');
  1519. }
  1521. return isset($this->queryComponents[$lookaheadValue]['metadata'])
  1522. ? $this->IdentificationVariable()
  1523. : $this->ResultVariable();
  1524. }
  1526. /**
  1527. * OrderByItem ::= (
  1528. * SimpleArithmeticExpression | SingleValuedPathExpression | CaseExpression |
  1529. * ScalarExpression | ResultVariable | FunctionDeclaration
  1530. * ) ["ASC" | "DESC"]
  1531. *
  1532. * @return OrderByItem
  1533. */
  1534. public function OrderByItem()
  1535. {
  1536. $this->lexer->peek(); // lookahead => '.'
  1537. $this->lexer->peek(); // lookahead => token after '.'
  1539. $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  1541. $this->lexer->resetPeek();
  1543. $glimpse = $this->lexer->glimpse();
  1545. switch (true) {
  1546. case $this->isMathOperator($peek):
  1547. $expr = $this->SimpleArithmeticExpression();
  1548. break;
  1550. case $glimpse !== null && $glimpse['type'] === Lexer::T_DOT:
  1551. $expr = $this->SingleValuedPathExpression();
  1552. break;
  1554. case $this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  1555. $expr = $this->ScalarExpression();
  1556. break;
  1558. case $this->lexer->lookahead['type'] === Lexer::T_CASE:
  1559. $expr = $this->CaseExpression();
  1560. break;
  1562. case $this->isFunction():
  1563. $expr = $this->FunctionDeclaration();
  1564. break;
  1566. default:
  1567. $expr = $this->ResultVariable();
  1568. break;
  1569. }
  1571. $type = 'ASC';
  1572. $item = new AST\OrderByItem($expr);
  1574. switch (true) {
  1575. case $this->lexer->isNextToken(Lexer::T_DESC):
  1576. $this->match(Lexer::T_DESC);
  1577. $type = 'DESC';
  1578. break;
  1580. case $this->lexer->isNextToken(Lexer::T_ASC):
  1581. $this->match(Lexer::T_ASC);
  1582. break;
  1584. default:
  1585. // Do nothing
  1586. }
  1588. $item->type = $type;
  1590. return $item;
  1591. }
  1593. /**
  1594. * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
  1595. * EnumPrimary | SimpleEntityExpression | "NULL"
  1596. *
  1597. * NOTE: Since it is not possible to correctly recognize individual types, here is the full
  1598. * grammar that needs to be supported:
  1599. *
  1600. * NewValue ::= SimpleArithmeticExpression | "NULL"
  1601. *
  1602. * SimpleArithmeticExpression covers all *Primary grammar rules and also SimpleEntityExpression
  1603. *
  1604. * @return AST\ArithmeticExpression|AST\InputParameter|null
  1605. */
  1606. public function NewValue()
  1607. {
  1608. if ($this->lexer->isNextToken(Lexer::T_NULL)) {
  1609. $this->match(Lexer::T_NULL);
  1611. return null;
  1612. }
  1614. if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  1615. $this->match(Lexer::T_INPUT_PARAMETER);
  1617. return new AST\InputParameter($this->lexer->token['value']);
  1618. }
  1620. return $this->ArithmeticExpression();
  1621. }
  1623. /**
  1624. * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {Join}*
  1625. *
  1626. * @return IdentificationVariableDeclaration
  1627. */
  1628. public function IdentificationVariableDeclaration()
  1629. {
  1630. $joins = [];
  1631. $rangeVariableDeclaration = $this->RangeVariableDeclaration();
  1632. $indexBy = $this->lexer->isNextToken(Lexer::T_INDEX)
  1633. ? $this->IndexBy()
  1634. : null;
  1636. $rangeVariableDeclaration->isRoot = true;
  1638. while (
  1639. $this->lexer->isNextToken(Lexer::T_LEFT) ||
  1640. $this->lexer->isNextToken(Lexer::T_INNER) ||
  1641. $this->lexer->isNextToken(Lexer::T_JOIN)
  1642. ) {
  1643. $joins[] = $this->Join();
  1644. }
  1646. return new AST\IdentificationVariableDeclaration(
  1647. $rangeVariableDeclaration,
  1648. $indexBy,
  1649. $joins
  1650. );
  1651. }
  1653. /**
  1654. * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration
  1655. *
  1656. * {Internal note: WARNING: Solution is harder than a bare implementation.
  1657. * Desired EBNF support:
  1658. *
  1659. * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
  1660. *
  1661. * It demands that entire SQL generation to become programmatical. This is
  1662. * needed because association based subselect requires "WHERE" conditional
  1663. * expressions to be injected, but there is no scope to do that. Only scope
  1664. * accessible is "FROM", prohibiting an easy implementation without larger
  1665. * changes.}
  1666. *
  1667. * @return IdentificationVariableDeclaration
  1668. */
  1669. public function SubselectIdentificationVariableDeclaration()
  1670. {
  1671. /*
  1672. NOT YET IMPLEMENTED!
  1674. $glimpse = $this->lexer->glimpse();
  1676. if ($glimpse['type'] == Lexer::T_DOT) {
  1677. $associationPathExpression = $this->AssociationPathExpression();
  1679. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1680. $this->match(Lexer::T_AS);
  1681. }
  1683. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1684. $identificationVariable = $associationPathExpression->identificationVariable;
  1685. $field = $associationPathExpression->associationField;
  1687. $class = $this->queryComponents[$identificationVariable]['metadata'];
  1688. $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1690. // Building queryComponent
  1691. $joinQueryComponent = array(
  1692. 'metadata' => $targetClass,
  1693. 'parent' => $identificationVariable,
  1694. 'relation' => $class->getAssociationMapping($field),
  1695. 'map' => null,
  1696. 'nestingLevel' => $this->nestingLevel,
  1697. 'token' => $this->lexer->lookahead
  1698. );
  1700. $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1702. return new AST\SubselectIdentificationVariableDeclaration(
  1703. $associationPathExpression, $aliasIdentificationVariable
  1704. );
  1705. }
  1706. */
  1708. return $this->IdentificationVariableDeclaration();
  1709. }
  1711. /**
  1712. * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN"
  1713. * (JoinAssociationDeclaration | RangeVariableDeclaration)
  1714. * ["WITH" ConditionalExpression]
  1715. *
  1716. * @return Join
  1717. */
  1718. public function Join()
  1719. {
  1720. // Check Join type
  1721. $joinType = AST\Join::JOIN_TYPE_INNER;
  1723. switch (true) {
  1724. case $this->lexer->isNextToken(Lexer::T_LEFT):
  1725. $this->match(Lexer::T_LEFT);
  1727. $joinType = AST\Join::JOIN_TYPE_LEFT;
  1729. // Possible LEFT OUTER join
  1730. if ($this->lexer->isNextToken(Lexer::T_OUTER)) {
  1731. $this->match(Lexer::T_OUTER);
  1733. $joinType = AST\Join::JOIN_TYPE_LEFTOUTER;
  1734. }
  1736. break;
  1738. case $this->lexer->isNextToken(Lexer::T_INNER):
  1739. $this->match(Lexer::T_INNER);
  1740. break;
  1742. default:
  1743. // Do nothing
  1744. }
  1746. $this->match(Lexer::T_JOIN);
  1748. $next = $this->lexer->glimpse();
  1749. $joinDeclaration = $next['type'] === Lexer::T_DOT ? $this->JoinAssociationDeclaration() : $this->RangeVariableDeclaration();
  1750. $adhocConditions = $this->lexer->isNextToken(Lexer::T_WITH);
  1751. $join = new AST\Join($joinType, $joinDeclaration);
  1753. // Describe non-root join declaration
  1754. if ($joinDeclaration instanceof AST\RangeVariableDeclaration) {
  1755. $joinDeclaration->isRoot = false;
  1756. }
  1758. // Check for ad-hoc Join conditions
  1759. if ($adhocConditions) {
  1760. $this->match(Lexer::T_WITH);
  1762. $join->conditionalExpression = $this->ConditionalExpression();
  1763. }
  1765. return $join;
  1766. }
  1768. /**
  1769. * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
  1770. *
  1771. * @return RangeVariableDeclaration
  1772. *
  1773. * @throws QueryException
  1774. */
  1775. public function RangeVariableDeclaration()
  1776. {
  1777. if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $this->lexer->glimpse()['type'] === Lexer::T_SELECT) {
  1778. $this->semanticalError('Subquery is not supported here', $this->lexer->token);
  1779. }
  1781. $abstractSchemaName = $this->AbstractSchemaName();
  1783. $this->validateAbstractSchemaName($abstractSchemaName);
  1785. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1786. $this->match(Lexer::T_AS);
  1787. }
  1789. $token = $this->lexer->lookahead;
  1790. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1791. $classMetadata = $this->em->getClassMetadata($abstractSchemaName);
  1793. // Building queryComponent
  1794. $queryComponent = [
  1795. 'metadata' => $classMetadata,
  1796. 'parent' => null,
  1797. 'relation' => null,
  1798. 'map' => null,
  1799. 'nestingLevel' => $this->nestingLevel,
  1800. 'token' => $token,
  1801. ];
  1803. $this->queryComponents[$aliasIdentificationVariable] = $queryComponent;
  1805. return new AST\RangeVariableDeclaration($abstractSchemaName, $aliasIdentificationVariable);
  1806. }
  1808. /**
  1809. * JoinAssociationDeclaration ::= JoinAssociationPathExpression ["AS"] AliasIdentificationVariable [IndexBy]
  1810. *
  1811. * @return AST\JoinAssociationDeclaration
  1812. */
  1813. public function JoinAssociationDeclaration()
  1814. {
  1815. $joinAssociationPathExpression = $this->JoinAssociationPathExpression();
  1817. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  1818. $this->match(Lexer::T_AS);
  1819. }
  1821. $aliasIdentificationVariable = $this->AliasIdentificationVariable();
  1822. $indexBy = $this->lexer->isNextToken(Lexer::T_INDEX) ? $this->IndexBy() : null;
  1824. $identificationVariable = $joinAssociationPathExpression->identificationVariable;
  1825. $field = $joinAssociationPathExpression->associationField;
  1827. $class = $this->queryComponents[$identificationVariable]['metadata'];
  1828. $targetClass = $this->em->getClassMetadata($class->associationMappings[$field]['targetEntity']);
  1830. // Building queryComponent
  1831. $joinQueryComponent = [
  1832. 'metadata' => $targetClass,
  1833. 'parent' => $joinAssociationPathExpression->identificationVariable,
  1834. 'relation' => $class->getAssociationMapping($field),
  1835. 'map' => null,
  1836. 'nestingLevel' => $this->nestingLevel,
  1837. 'token' => $this->lexer->lookahead,
  1838. ];
  1840. $this->queryComponents[$aliasIdentificationVariable] = $joinQueryComponent;
  1842. return new AST\JoinAssociationDeclaration($joinAssociationPathExpression, $aliasIdentificationVariable, $indexBy);
  1843. }
  1845. /**
  1846. * PartialObjectExpression ::= "PARTIAL" IdentificationVariable "." PartialFieldSet
  1847. * PartialFieldSet ::= "{" SimpleStateField {"," SimpleStateField}* "}"
  1848. *
  1849. * @return PartialObjectExpression
  1850. */
  1851. public function PartialObjectExpression()
  1852. {
  1853. Deprecation::trigger(
  1854. 'doctrine/orm',
  1855. 'https://github.com/doctrine/orm/issues/8471',
  1856. 'PARTIAL syntax in DQL is deprecated.'
  1857. );
  1859. $this->match(Lexer::T_PARTIAL);
  1861. $partialFieldSet = [];
  1863. $identificationVariable = $this->IdentificationVariable();
  1865. $this->match(Lexer::T_DOT);
  1866. $this->match(Lexer::T_OPEN_CURLY_BRACE);
  1867. $this->match(Lexer::T_IDENTIFIER);
  1869. $field = $this->lexer->token['value'];
  1871. // First field in partial expression might be embeddable property
  1872. while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1873. $this->match(Lexer::T_DOT);
  1874. $this->match(Lexer::T_IDENTIFIER);
  1875. $field .= '.' . $this->lexer->token['value'];
  1876. }
  1878. $partialFieldSet[] = $field;
  1880. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1881. $this->match(Lexer::T_COMMA);
  1882. $this->match(Lexer::T_IDENTIFIER);
  1884. $field = $this->lexer->token['value'];
  1886. while ($this->lexer->isNextToken(Lexer::T_DOT)) {
  1887. $this->match(Lexer::T_DOT);
  1888. $this->match(Lexer::T_IDENTIFIER);
  1889. $field .= '.' . $this->lexer->token['value'];
  1890. }
  1892. $partialFieldSet[] = $field;
  1893. }
  1895. $this->match(Lexer::T_CLOSE_CURLY_BRACE);
  1897. $partialObjectExpression = new AST\PartialObjectExpression($identificationVariable, $partialFieldSet);
  1899. // Defer PartialObjectExpression validation
  1900. $this->deferredPartialObjectExpressions[] = [
  1901. 'expression' => $partialObjectExpression,
  1902. 'nestingLevel' => $this->nestingLevel,
  1903. 'token' => $this->lexer->token,
  1904. ];
  1906. return $partialObjectExpression;
  1907. }
  1909. /**
  1910. * NewObjectExpression ::= "NEW" AbstractSchemaName "(" NewObjectArg {"," NewObjectArg}* ")"
  1911. *
  1912. * @return NewObjectExpression
  1913. */
  1914. public function NewObjectExpression()
  1915. {
  1916. $this->match(Lexer::T_NEW);
  1918. $className = $this->AbstractSchemaName(); // note that this is not yet validated
  1919. $token = $this->lexer->token;
  1921. $this->match(Lexer::T_OPEN_PARENTHESIS);
  1923. $args[] = $this->NewObjectArg();
  1925. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  1926. $this->match(Lexer::T_COMMA);
  1928. $args[] = $this->NewObjectArg();
  1929. }
  1931. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1933. $expression = new AST\NewObjectExpression($className, $args);
  1935. // Defer NewObjectExpression validation
  1936. $this->deferredNewObjectExpressions[] = [
  1937. 'token' => $token,
  1938. 'expression' => $expression,
  1939. 'nestingLevel' => $this->nestingLevel,
  1940. ];
  1942. return $expression;
  1943. }
  1945. /**
  1946. * NewObjectArg ::= ScalarExpression | "(" Subselect ")"
  1947. *
  1948. * @return mixed
  1949. */
  1950. public function NewObjectArg()
  1951. {
  1952. $token = $this->lexer->lookahead;
  1953. $peek = $this->lexer->glimpse();
  1955. if ($token['type'] === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT) {
  1956. $this->match(Lexer::T_OPEN_PARENTHESIS);
  1957. $expression = $this->Subselect();
  1958. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  1960. return $expression;
  1961. }
  1963. return $this->ScalarExpression();
  1964. }
  1966. /**
  1967. * IndexBy ::= "INDEX" "BY" SingleValuedPathExpression
  1968. *
  1969. * @return IndexBy
  1970. */
  1971. public function IndexBy()
  1972. {
  1973. $this->match(Lexer::T_INDEX);
  1974. $this->match(Lexer::T_BY);
  1975. $pathExpr = $this->SingleValuedPathExpression();
  1977. // Add the INDEX BY info to the query component
  1978. $this->queryComponents[$pathExpr->identificationVariable]['map'] = $pathExpr->field;
  1980. return new AST\IndexBy($pathExpr);
  1981. }
  1983. /**
  1984. * ScalarExpression ::= SimpleArithmeticExpression | StringPrimary | DateTimePrimary |
  1985. * StateFieldPathExpression | BooleanPrimary | CaseExpression |
  1986. * InstanceOfExpression
  1987. *
  1988. * @return mixed One of the possible expressions or subexpressions.
  1989. */
  1990. public function ScalarExpression()
  1991. {
  1992. $lookahead = $this->lexer->lookahead['type'];
  1993. $peek = $this->lexer->glimpse();
  1995. switch (true) {
  1996. case $lookahead === Lexer::T_INTEGER:
  1997. case $lookahead === Lexer::T_FLOAT:
  1998. // SimpleArithmeticExpression : (- u.value ) or ( + u.value ) or ( - 1 ) or ( + 1 )
  1999. case $lookahead === Lexer::T_MINUS:
  2000. case $lookahead === Lexer::T_PLUS:
  2001. return $this->SimpleArithmeticExpression();
  2003. case $lookahead === Lexer::T_STRING:
  2004. return $this->StringPrimary();
  2006. case $lookahead === Lexer::T_TRUE:
  2007. case $lookahead === Lexer::T_FALSE:
  2008. $this->match($lookahead);
  2010. return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2012. case $lookahead === Lexer::T_INPUT_PARAMETER:
  2013. switch (true) {
  2014. case $this->isMathOperator($peek):
  2015. // :param + u.value
  2016. return $this->SimpleArithmeticExpression();
  2018. default:
  2019. return $this->InputParameter();
  2020. }
  2021. case $lookahead === Lexer::T_CASE:
  2022. case $lookahead === Lexer::T_COALESCE:
  2023. case $lookahead === Lexer::T_NULLIF:
  2024. // Since NULLIF and COALESCE can be identified as a function,
  2025. // we need to check these before checking for FunctionDeclaration
  2026. return $this->CaseExpression();
  2028. case $lookahead === Lexer::T_OPEN_PARENTHESIS:
  2029. return $this->SimpleArithmeticExpression();
  2031. // this check must be done before checking for a filed path expression
  2032. case $this->isFunction():
  2033. $this->lexer->peek(); // "("
  2035. switch (true) {
  2036. case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2037. // SUM(u.id) + COUNT(u.id)
  2038. return $this->SimpleArithmeticExpression();
  2040. default:
  2041. // IDENTITY(u)
  2042. return $this->FunctionDeclaration();
  2043. }
  2045. break;
  2046. // it is no function, so it must be a field path
  2047. case $lookahead === Lexer::T_IDENTIFIER:
  2048. $this->lexer->peek(); // lookahead => '.'
  2049. $this->lexer->peek(); // lookahead => token after '.'
  2050. $peek = $this->lexer->peek(); // lookahead => token after the token after the '.'
  2051. $this->lexer->resetPeek();
  2053. if ($this->isMathOperator($peek)) {
  2054. return $this->SimpleArithmeticExpression();
  2055. }
  2057. return $this->StateFieldPathExpression();
  2059. default:
  2060. $this->syntaxError();
  2061. }
  2062. }
  2064. /**
  2065. * CaseExpression ::= GeneralCaseExpression | SimpleCaseExpression | CoalesceExpression | NullifExpression
  2066. * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2067. * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2068. * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2069. * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2070. * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2071. * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2072. * NullifExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2073. *
  2074. * @return mixed One of the possible expressions or subexpressions.
  2075. */
  2076. public function CaseExpression()
  2077. {
  2078. $lookahead = $this->lexer->lookahead['type'];
  2080. switch ($lookahead) {
  2081. case Lexer::T_NULLIF:
  2082. return $this->NullIfExpression();
  2084. case Lexer::T_COALESCE:
  2085. return $this->CoalesceExpression();
  2087. case Lexer::T_CASE:
  2088. $this->lexer->resetPeek();
  2089. $peek = $this->lexer->peek();
  2091. if ($peek['type'] === Lexer::T_WHEN) {
  2092. return $this->GeneralCaseExpression();
  2093. }
  2095. return $this->SimpleCaseExpression();
  2097. default:
  2098. // Do nothing
  2099. break;
  2100. }
  2102. $this->syntaxError();
  2103. }
  2105. /**
  2106. * CoalesceExpression ::= "COALESCE" "(" ScalarExpression {"," ScalarExpression}* ")"
  2107. *
  2108. * @return CoalesceExpression
  2109. */
  2110. public function CoalesceExpression()
  2111. {
  2112. $this->match(Lexer::T_COALESCE);
  2113. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2115. // Process ScalarExpressions (1..N)
  2116. $scalarExpressions = [];
  2117. $scalarExpressions[] = $this->ScalarExpression();
  2119. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  2120. $this->match(Lexer::T_COMMA);
  2122. $scalarExpressions[] = $this->ScalarExpression();
  2123. }
  2125. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2127. return new AST\CoalesceExpression($scalarExpressions);
  2128. }
  2130. /**
  2131. * NullIfExpression ::= "NULLIF" "(" ScalarExpression "," ScalarExpression ")"
  2132. *
  2133. * @return NullIfExpression
  2134. */
  2135. public function NullIfExpression()
  2136. {
  2137. $this->match(Lexer::T_NULLIF);
  2138. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2140. $firstExpression = $this->ScalarExpression();
  2141. $this->match(Lexer::T_COMMA);
  2142. $secondExpression = $this->ScalarExpression();
  2144. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2146. return new AST\NullIfExpression($firstExpression, $secondExpression);
  2147. }
  2149. /**
  2150. * GeneralCaseExpression ::= "CASE" WhenClause {WhenClause}* "ELSE" ScalarExpression "END"
  2151. *
  2152. * @return GeneralCaseExpression
  2153. */
  2154. public function GeneralCaseExpression()
  2155. {
  2156. $this->match(Lexer::T_CASE);
  2158. // Process WhenClause (1..N)
  2159. $whenClauses = [];
  2161. do {
  2162. $whenClauses[] = $this->WhenClause();
  2163. } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2165. $this->match(Lexer::T_ELSE);
  2166. $scalarExpression = $this->ScalarExpression();
  2167. $this->match(Lexer::T_END);
  2169. return new AST\GeneralCaseExpression($whenClauses, $scalarExpression);
  2170. }
  2172. /**
  2173. * SimpleCaseExpression ::= "CASE" CaseOperand SimpleWhenClause {SimpleWhenClause}* "ELSE" ScalarExpression "END"
  2174. * CaseOperand ::= StateFieldPathExpression | TypeDiscriminator
  2175. *
  2176. * @return AST\SimpleCaseExpression
  2177. */
  2178. public function SimpleCaseExpression()
  2179. {
  2180. $this->match(Lexer::T_CASE);
  2181. $caseOperand = $this->StateFieldPathExpression();
  2183. // Process SimpleWhenClause (1..N)
  2184. $simpleWhenClauses = [];
  2186. do {
  2187. $simpleWhenClauses[] = $this->SimpleWhenClause();
  2188. } while ($this->lexer->isNextToken(Lexer::T_WHEN));
  2190. $this->match(Lexer::T_ELSE);
  2191. $scalarExpression = $this->ScalarExpression();
  2192. $this->match(Lexer::T_END);
  2194. return new AST\SimpleCaseExpression($caseOperand, $simpleWhenClauses, $scalarExpression);
  2195. }
  2197. /**
  2198. * WhenClause ::= "WHEN" ConditionalExpression "THEN" ScalarExpression
  2199. *
  2200. * @return WhenClause
  2201. */
  2202. public function WhenClause()
  2203. {
  2204. $this->match(Lexer::T_WHEN);
  2205. $conditionalExpression = $this->ConditionalExpression();
  2206. $this->match(Lexer::T_THEN);
  2208. return new AST\WhenClause($conditionalExpression, $this->ScalarExpression());
  2209. }
  2211. /**
  2212. * SimpleWhenClause ::= "WHEN" ScalarExpression "THEN" ScalarExpression
  2213. *
  2214. * @return SimpleWhenClause
  2215. */
  2216. public function SimpleWhenClause()
  2217. {
  2218. $this->match(Lexer::T_WHEN);
  2219. $conditionalExpression = $this->ScalarExpression();
  2220. $this->match(Lexer::T_THEN);
  2222. return new AST\SimpleWhenClause($conditionalExpression, $this->ScalarExpression());
  2223. }
  2225. /**
  2226. * SelectExpression ::= (
  2227. * IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration |
  2228. * PartialObjectExpression | "(" Subselect ")" | CaseExpression | NewObjectExpression
  2229. * ) [["AS"] ["HIDDEN"] AliasResultVariable]
  2230. *
  2231. * @return SelectExpression
  2232. */
  2233. public function SelectExpression()
  2234. {
  2235. $expression = null;
  2236. $identVariable = null;
  2237. $peek = $this->lexer->glimpse();
  2238. $lookaheadType = $this->lexer->lookahead['type'];
  2240. switch (true) {
  2241. // ScalarExpression (u.name)
  2242. case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] === Lexer::T_DOT:
  2243. $expression = $this->ScalarExpression();
  2244. break;
  2246. // IdentificationVariable (u)
  2247. case $lookaheadType === Lexer::T_IDENTIFIER && $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2248. $expression = $identVariable = $this->IdentificationVariable();
  2249. break;
  2251. // CaseExpression (CASE ... or NULLIF(...) or COALESCE(...))
  2252. case $lookaheadType === Lexer::T_CASE:
  2253. case $lookaheadType === Lexer::T_COALESCE:
  2254. case $lookaheadType === Lexer::T_NULLIF:
  2255. $expression = $this->CaseExpression();
  2256. break;
  2258. // DQL Function (SUM(u.value) or SUM(u.value) + 1)
  2259. case $this->isFunction():
  2260. $this->lexer->peek(); // "("
  2262. switch (true) {
  2263. case $this->isMathOperator($this->peekBeyondClosingParenthesis()):
  2264. // SUM(u.id) + COUNT(u.id)
  2265. $expression = $this->ScalarExpression();
  2266. break;
  2268. default:
  2269. // IDENTITY(u)
  2270. $expression = $this->FunctionDeclaration();
  2271. break;
  2272. }
  2274. break;
  2276. // PartialObjectExpression (PARTIAL u.{id, name})
  2277. case $lookaheadType === Lexer::T_PARTIAL:
  2278. $expression = $this->PartialObjectExpression();
  2279. $identVariable = $expression->identificationVariable;
  2280. break;
  2282. // Subselect
  2283. case $lookaheadType === Lexer::T_OPEN_PARENTHESIS && $peek['type'] === Lexer::T_SELECT:
  2284. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2285. $expression = $this->Subselect();
  2286. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2287. break;
  2289. // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2290. case $lookaheadType === Lexer::T_OPEN_PARENTHESIS:
  2291. case $lookaheadType === Lexer::T_INTEGER:
  2292. case $lookaheadType === Lexer::T_STRING:
  2293. case $lookaheadType === Lexer::T_FLOAT:
  2294. // SimpleArithmeticExpression : (- u.value ) or ( + u.value )
  2295. case $lookaheadType === Lexer::T_MINUS:
  2296. case $lookaheadType === Lexer::T_PLUS:
  2297. $expression = $this->SimpleArithmeticExpression();
  2298. break;
  2300. // NewObjectExpression (New ClassName(id, name))
  2301. case $lookaheadType === Lexer::T_NEW:
  2302. $expression = $this->NewObjectExpression();
  2303. break;
  2305. default:
  2306. $this->syntaxError(
  2307. 'IdentificationVariable | ScalarExpression | AggregateExpression | FunctionDeclaration | PartialObjectExpression | "(" Subselect ")" | CaseExpression',
  2308. $this->lexer->lookahead
  2309. );
  2310. }
  2312. // [["AS"] ["HIDDEN"] AliasResultVariable]
  2313. $mustHaveAliasResultVariable = false;
  2315. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2316. $this->match(Lexer::T_AS);
  2318. $mustHaveAliasResultVariable = true;
  2319. }
  2321. $hiddenAliasResultVariable = false;
  2323. if ($this->lexer->isNextToken(Lexer::T_HIDDEN)) {
  2324. $this->match(Lexer::T_HIDDEN);
  2326. $hiddenAliasResultVariable = true;
  2327. }
  2329. $aliasResultVariable = null;
  2331. if ($mustHaveAliasResultVariable || $this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2332. $token = $this->lexer->lookahead;
  2333. $aliasResultVariable = $this->AliasResultVariable();
  2335. // Include AliasResultVariable in query components.
  2336. $this->queryComponents[$aliasResultVariable] = [
  2337. 'resultVariable' => $expression,
  2338. 'nestingLevel' => $this->nestingLevel,
  2339. 'token' => $token,
  2340. ];
  2341. }
  2343. // AST
  2345. $expr = new AST\SelectExpression($expression, $aliasResultVariable, $hiddenAliasResultVariable);
  2347. if ($identVariable) {
  2348. $this->identVariableExpressions[$identVariable] = $expr;
  2349. }
  2351. return $expr;
  2352. }
  2354. /**
  2355. * SimpleSelectExpression ::= (
  2356. * StateFieldPathExpression | IdentificationVariable | FunctionDeclaration |
  2357. * AggregateExpression | "(" Subselect ")" | ScalarExpression
  2358. * ) [["AS"] AliasResultVariable]
  2359. *
  2360. * @return SimpleSelectExpression
  2361. */
  2362. public function SimpleSelectExpression()
  2363. {
  2364. $peek = $this->lexer->glimpse();
  2366. switch ($this->lexer->lookahead['type']) {
  2367. case Lexer::T_IDENTIFIER:
  2368. switch (true) {
  2369. case $peek['type'] === Lexer::T_DOT:
  2370. $expression = $this->StateFieldPathExpression();
  2372. return new AST\SimpleSelectExpression($expression);
  2374. case $peek['type'] !== Lexer::T_OPEN_PARENTHESIS:
  2375. $expression = $this->IdentificationVariable();
  2377. return new AST\SimpleSelectExpression($expression);
  2379. case $this->isFunction():
  2380. // SUM(u.id) + COUNT(u.id)
  2381. if ($this->isMathOperator($this->peekBeyondClosingParenthesis())) {
  2382. return new AST\SimpleSelectExpression($this->ScalarExpression());
  2383. }
  2385. // COUNT(u.id)
  2386. if ($this->isAggregateFunction($this->lexer->lookahead['type'])) {
  2387. return new AST\SimpleSelectExpression($this->AggregateExpression());
  2388. }
  2390. // IDENTITY(u)
  2391. return new AST\SimpleSelectExpression($this->FunctionDeclaration());
  2393. default:
  2394. // Do nothing
  2395. }
  2397. break;
  2399. case Lexer::T_OPEN_PARENTHESIS:
  2400. if ($peek['type'] !== Lexer::T_SELECT) {
  2401. // Shortcut: ScalarExpression => SimpleArithmeticExpression
  2402. $expression = $this->SimpleArithmeticExpression();
  2404. return new AST\SimpleSelectExpression($expression);
  2405. }
  2407. // Subselect
  2408. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2409. $expression = $this->Subselect();
  2410. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2412. return new AST\SimpleSelectExpression($expression);
  2414. default:
  2415. // Do nothing
  2416. }
  2418. $this->lexer->peek();
  2420. $expression = $this->ScalarExpression();
  2421. $expr = new AST\SimpleSelectExpression($expression);
  2423. if ($this->lexer->isNextToken(Lexer::T_AS)) {
  2424. $this->match(Lexer::T_AS);
  2425. }
  2427. if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER)) {
  2428. $token = $this->lexer->lookahead;
  2429. $resultVariable = $this->AliasResultVariable();
  2430. $expr->fieldIdentificationVariable = $resultVariable;
  2432. // Include AliasResultVariable in query components.
  2433. $this->queryComponents[$resultVariable] = [
  2434. 'resultvariable' => $expr,
  2435. 'nestingLevel' => $this->nestingLevel,
  2436. 'token' => $token,
  2437. ];
  2438. }
  2440. return $expr;
  2441. }
  2443. /**
  2444. * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
  2445. *
  2446. * @return AST\ConditionalExpression|AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2447. */
  2448. public function ConditionalExpression()
  2449. {
  2450. $conditionalTerms = [];
  2451. $conditionalTerms[] = $this->ConditionalTerm();
  2453. while ($this->lexer->isNextToken(Lexer::T_OR)) {
  2454. $this->match(Lexer::T_OR);
  2456. $conditionalTerms[] = $this->ConditionalTerm();
  2457. }
  2459. // Phase 1 AST optimization: Prevent AST\ConditionalExpression
  2460. // if only one AST\ConditionalTerm is defined
  2461. if (count($conditionalTerms) === 1) {
  2462. return $conditionalTerms[0];
  2463. }
  2465. return new AST\ConditionalExpression($conditionalTerms);
  2466. }
  2468. /**
  2469. * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
  2470. *
  2471. * @return AST\ConditionalFactor|AST\ConditionalPrimary|AST\ConditionalTerm
  2472. */
  2473. public function ConditionalTerm()
  2474. {
  2475. $conditionalFactors = [];
  2476. $conditionalFactors[] = $this->ConditionalFactor();
  2478. while ($this->lexer->isNextToken(Lexer::T_AND)) {
  2479. $this->match(Lexer::T_AND);
  2481. $conditionalFactors[] = $this->ConditionalFactor();
  2482. }
  2484. // Phase 1 AST optimization: Prevent AST\ConditionalTerm
  2485. // if only one AST\ConditionalFactor is defined
  2486. if (count($conditionalFactors) === 1) {
  2487. return $conditionalFactors[0];
  2488. }
  2490. return new AST\ConditionalTerm($conditionalFactors);
  2491. }
  2493. /**
  2494. * ConditionalFactor ::= ["NOT"] ConditionalPrimary
  2495. *
  2496. * @return AST\ConditionalFactor|AST\ConditionalPrimary
  2497. */
  2498. public function ConditionalFactor()
  2499. {
  2500. $not = false;
  2502. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2503. $this->match(Lexer::T_NOT);
  2505. $not = true;
  2506. }
  2508. $conditionalPrimary = $this->ConditionalPrimary();
  2510. // Phase 1 AST optimization: Prevent AST\ConditionalFactor
  2511. // if only one AST\ConditionalPrimary is defined
  2512. if (! $not) {
  2513. return $conditionalPrimary;
  2514. }
  2516. $conditionalFactor = new AST\ConditionalFactor($conditionalPrimary);
  2517. $conditionalFactor->not = $not;
  2519. return $conditionalFactor;
  2520. }
  2522. /**
  2523. * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
  2524. *
  2525. * @return ConditionalPrimary
  2526. */
  2527. public function ConditionalPrimary()
  2528. {
  2529. $condPrimary = new AST\ConditionalPrimary();
  2531. if (! $this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2532. $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2534. return $condPrimary;
  2535. }
  2537. // Peek beyond the matching closing parenthesis ')'
  2538. $peek = $this->peekBeyondClosingParenthesis();
  2540. if (
  2541. $peek !== null && (
  2542. in_array($peek['value'], ['=', '<', '<=', '<>', '>', '>=', '!='], true) ||
  2543. in_array($peek['type'], [Lexer::T_NOT, Lexer::T_BETWEEN, Lexer::T_LIKE, Lexer::T_IN, Lexer::T_IS, Lexer::T_EXISTS], true) ||
  2544. $this->isMathOperator($peek)
  2545. )
  2546. ) {
  2547. $condPrimary->simpleConditionalExpression = $this->SimpleConditionalExpression();
  2549. return $condPrimary;
  2550. }
  2552. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2553. $condPrimary->conditionalExpression = $this->ConditionalExpression();
  2554. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2556. return $condPrimary;
  2557. }
  2559. /**
  2560. * SimpleConditionalExpression ::=
  2561. * ComparisonExpression | BetweenExpression | LikeExpression |
  2562. * InExpression | NullComparisonExpression | ExistsExpression |
  2563. * EmptyCollectionComparisonExpression | CollectionMemberExpression |
  2564. * InstanceOfExpression
  2565. *
  2566. * @return AST\BetweenExpression|
  2567. * AST\CollectionMemberExpression|
  2568. * AST\ComparisonExpression|
  2569. * AST\EmptyCollectionComparisonExpression|
  2570. * AST\ExistsExpression|
  2571. * AST\InExpression|
  2572. * AST\InstanceOfExpression|
  2573. * AST\LikeExpression|
  2574. * AST\NullComparisonExpression
  2575. */
  2576. public function SimpleConditionalExpression()
  2577. {
  2578. if ($this->lexer->isNextToken(Lexer::T_EXISTS)) {
  2579. return $this->ExistsExpression();
  2580. }
  2582. $token = $this->lexer->lookahead;
  2583. $peek = $this->lexer->glimpse();
  2584. $lookahead = $token;
  2586. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2587. $token = $this->lexer->glimpse();
  2588. }
  2590. if ($token['type'] === Lexer::T_IDENTIFIER || $token['type'] === Lexer::T_INPUT_PARAMETER || $this->isFunction()) {
  2591. // Peek beyond the matching closing parenthesis.
  2592. $beyond = $this->lexer->peek();
  2594. switch ($peek['value']) {
  2595. case '(':
  2596. // Peeks beyond the matched closing parenthesis.
  2597. $token = $this->peekBeyondClosingParenthesis(false);
  2599. if ($token['type'] === Lexer::T_NOT) {
  2600. $token = $this->lexer->peek();
  2601. }
  2603. if ($token['type'] === Lexer::T_IS) {
  2604. $lookahead = $this->lexer->peek();
  2605. }
  2607. break;
  2609. default:
  2610. // Peek beyond the PathExpression or InputParameter.
  2611. $token = $beyond;
  2613. while ($token['value'] === '.') {
  2614. $this->lexer->peek();
  2616. $token = $this->lexer->peek();
  2617. }
  2619. // Also peek beyond a NOT if there is one.
  2620. if ($token['type'] === Lexer::T_NOT) {
  2621. $token = $this->lexer->peek();
  2622. }
  2624. // We need to go even further in case of IS (differentiate between NULL and EMPTY)
  2625. $lookahead = $this->lexer->peek();
  2626. }
  2628. // Also peek beyond a NOT if there is one.
  2629. if ($lookahead['type'] === Lexer::T_NOT) {
  2630. $lookahead = $this->lexer->peek();
  2631. }
  2633. $this->lexer->resetPeek();
  2634. }
  2636. if ($token['type'] === Lexer::T_BETWEEN) {
  2637. return $this->BetweenExpression();
  2638. }
  2640. if ($token['type'] === Lexer::T_LIKE) {
  2641. return $this->LikeExpression();
  2642. }
  2644. if ($token['type'] === Lexer::T_IN) {
  2645. return $this->InExpression();
  2646. }
  2648. if ($token['type'] === Lexer::T_INSTANCE) {
  2649. return $this->InstanceOfExpression();
  2650. }
  2652. if ($token['type'] === Lexer::T_MEMBER) {
  2653. return $this->CollectionMemberExpression();
  2654. }
  2656. if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_NULL) {
  2657. return $this->NullComparisonExpression();
  2658. }
  2660. if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_EMPTY) {
  2661. return $this->EmptyCollectionComparisonExpression();
  2662. }
  2664. return $this->ComparisonExpression();
  2665. }
  2667. /**
  2668. * EmptyCollectionComparisonExpression ::= CollectionValuedPathExpression "IS" ["NOT"] "EMPTY"
  2669. *
  2670. * @return EmptyCollectionComparisonExpression
  2671. */
  2672. public function EmptyCollectionComparisonExpression()
  2673. {
  2674. $emptyCollectionCompExpr = new AST\EmptyCollectionComparisonExpression(
  2675. $this->CollectionValuedPathExpression()
  2676. );
  2677. $this->match(Lexer::T_IS);
  2679. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2680. $this->match(Lexer::T_NOT);
  2681. $emptyCollectionCompExpr->not = true;
  2682. }
  2684. $this->match(Lexer::T_EMPTY);
  2686. return $emptyCollectionCompExpr;
  2687. }
  2689. /**
  2690. * CollectionMemberExpression ::= EntityExpression ["NOT"] "MEMBER" ["OF"] CollectionValuedPathExpression
  2691. *
  2692. * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  2693. * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  2694. *
  2695. * @return CollectionMemberExpression
  2696. */
  2697. public function CollectionMemberExpression()
  2698. {
  2699. $not = false;
  2700. $entityExpr = $this->EntityExpression();
  2702. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  2703. $this->match(Lexer::T_NOT);
  2705. $not = true;
  2706. }
  2708. $this->match(Lexer::T_MEMBER);
  2710. if ($this->lexer->isNextToken(Lexer::T_OF)) {
  2711. $this->match(Lexer::T_OF);
  2712. }
  2714. $collMemberExpr = new AST\CollectionMemberExpression(
  2715. $entityExpr,
  2716. $this->CollectionValuedPathExpression()
  2717. );
  2718. $collMemberExpr->not = $not;
  2720. return $collMemberExpr;
  2721. }
  2723. /**
  2724. * Literal ::= string | char | integer | float | boolean
  2725. *
  2726. * @return Literal
  2727. */
  2728. public function Literal()
  2729. {
  2730. switch ($this->lexer->lookahead['type']) {
  2731. case Lexer::T_STRING:
  2732. $this->match(Lexer::T_STRING);
  2734. return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  2736. case Lexer::T_INTEGER:
  2737. case Lexer::T_FLOAT:
  2738. $this->match(
  2739. $this->lexer->isNextToken(Lexer::T_INTEGER) ? Lexer::T_INTEGER : Lexer::T_FLOAT
  2740. );
  2742. return new AST\Literal(AST\Literal::NUMERIC, $this->lexer->token['value']);
  2744. case Lexer::T_TRUE:
  2745. case Lexer::T_FALSE:
  2746. $this->match(
  2747. $this->lexer->isNextToken(Lexer::T_TRUE) ? Lexer::T_TRUE : Lexer::T_FALSE
  2748. );
  2750. return new AST\Literal(AST\Literal::BOOLEAN, $this->lexer->token['value']);
  2752. default:
  2753. $this->syntaxError('Literal');
  2754. }
  2755. }
  2757. /**
  2758. * InParameter ::= ArithmeticExpression | InputParameter
  2759. *
  2760. * @return AST\InputParameter|AST\ArithmeticExpression
  2761. */
  2762. public function InParameter()
  2763. {
  2764. if ($this->lexer->lookahead['type'] === Lexer::T_INPUT_PARAMETER) {
  2765. return $this->InputParameter();
  2766. }
  2768. return $this->ArithmeticExpression();
  2769. }
  2771. /**
  2772. * InputParameter ::= PositionalParameter | NamedParameter
  2773. *
  2774. * @return InputParameter
  2775. */
  2776. public function InputParameter()
  2777. {
  2778. $this->match(Lexer::T_INPUT_PARAMETER);
  2780. return new AST\InputParameter($this->lexer->token['value']);
  2781. }
  2783. /**
  2784. * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
  2785. *
  2786. * @return ArithmeticExpression
  2787. */
  2788. public function ArithmeticExpression()
  2789. {
  2790. $expr = new AST\ArithmeticExpression();
  2792. if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2793. $peek = $this->lexer->glimpse();
  2795. if ($peek['type'] === Lexer::T_SELECT) {
  2796. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2797. $expr->subselect = $this->Subselect();
  2798. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2800. return $expr;
  2801. }
  2802. }
  2804. $expr->simpleArithmeticExpression = $this->SimpleArithmeticExpression();
  2806. return $expr;
  2807. }
  2809. /**
  2810. * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
  2811. *
  2812. * @return SimpleArithmeticExpression|ArithmeticTerm
  2813. */
  2814. public function SimpleArithmeticExpression()
  2815. {
  2816. $terms = [];
  2817. $terms[] = $this->ArithmeticTerm();
  2819. while (($isPlus = $this->lexer->isNextToken(Lexer::T_PLUS)) || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2820. $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2822. $terms[] = $this->lexer->token['value'];
  2823. $terms[] = $this->ArithmeticTerm();
  2824. }
  2826. // Phase 1 AST optimization: Prevent AST\SimpleArithmeticExpression
  2827. // if only one AST\ArithmeticTerm is defined
  2828. if (count($terms) === 1) {
  2829. return $terms[0];
  2830. }
  2832. return new AST\SimpleArithmeticExpression($terms);
  2833. }
  2835. /**
  2836. * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
  2837. *
  2838. * @return ArithmeticTerm
  2839. */
  2840. public function ArithmeticTerm()
  2841. {
  2842. $factors = [];
  2843. $factors[] = $this->ArithmeticFactor();
  2845. while (($isMult = $this->lexer->isNextToken(Lexer::T_MULTIPLY)) || $this->lexer->isNextToken(Lexer::T_DIVIDE)) {
  2846. $this->match($isMult ? Lexer::T_MULTIPLY : Lexer::T_DIVIDE);
  2848. $factors[] = $this->lexer->token['value'];
  2849. $factors[] = $this->ArithmeticFactor();
  2850. }
  2852. // Phase 1 AST optimization: Prevent AST\ArithmeticTerm
  2853. // if only one AST\ArithmeticFactor is defined
  2854. if (count($factors) === 1) {
  2855. return $factors[0];
  2856. }
  2858. return new AST\ArithmeticTerm($factors);
  2859. }
  2861. /**
  2862. * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
  2863. *
  2864. * @return ArithmeticFactor
  2865. */
  2866. public function ArithmeticFactor()
  2867. {
  2868. $sign = null;
  2870. $isPlus = $this->lexer->isNextToken(Lexer::T_PLUS);
  2871. if ($isPlus || $this->lexer->isNextToken(Lexer::T_MINUS)) {
  2872. $this->match($isPlus ? Lexer::T_PLUS : Lexer::T_MINUS);
  2873. $sign = $isPlus;
  2874. }
  2876. $primary = $this->ArithmeticPrimary();
  2878. // Phase 1 AST optimization: Prevent AST\ArithmeticFactor
  2879. // if only one AST\ArithmeticPrimary is defined
  2880. if ($sign === null) {
  2881. return $primary;
  2882. }
  2884. return new AST\ArithmeticFactor($primary, $sign);
  2885. }
  2887. /**
  2888. * ArithmeticPrimary ::= SingleValuedPathExpression | Literal | ParenthesisExpression
  2889. * | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings
  2890. * | FunctionsReturningDatetime | IdentificationVariable | ResultVariable
  2891. * | InputParameter | CaseExpression
  2892. *
  2893. * @return Node|string
  2894. */
  2895. public function ArithmeticPrimary()
  2896. {
  2897. if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  2898. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2900. $expr = $this->SimpleArithmeticExpression();
  2902. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2904. return new AST\ParenthesisExpression($expr);
  2905. }
  2907. switch ($this->lexer->lookahead['type']) {
  2908. case Lexer::T_COALESCE:
  2909. case Lexer::T_NULLIF:
  2910. case Lexer::T_CASE:
  2911. return $this->CaseExpression();
  2913. case Lexer::T_IDENTIFIER:
  2914. $peek = $this->lexer->glimpse();
  2916. if ($peek !== null && $peek['value'] === '(') {
  2917. return $this->FunctionDeclaration();
  2918. }
  2920. if ($peek !== null && $peek['value'] === '.') {
  2921. return $this->SingleValuedPathExpression();
  2922. }
  2924. if (isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])) {
  2925. return $this->ResultVariable();
  2926. }
  2928. return $this->StateFieldPathExpression();
  2930. case Lexer::T_INPUT_PARAMETER:
  2931. return $this->InputParameter();
  2933. default:
  2934. $peek = $this->lexer->glimpse();
  2936. if ($peek !== null && $peek['value'] === '(') {
  2937. return $this->FunctionDeclaration();
  2938. }
  2940. return $this->Literal();
  2941. }
  2942. }
  2944. /**
  2945. * StringExpression ::= StringPrimary | ResultVariable | "(" Subselect ")"
  2946. *
  2947. * @return Subselect|Node|string
  2948. */
  2949. public function StringExpression()
  2950. {
  2951. $peek = $this->lexer->glimpse();
  2953. // Subselect
  2954. if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) && $peek['type'] === Lexer::T_SELECT) {
  2955. $this->match(Lexer::T_OPEN_PARENTHESIS);
  2956. $expr = $this->Subselect();
  2957. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  2959. return $expr;
  2960. }
  2962. // ResultVariable (string)
  2963. if (
  2964. $this->lexer->isNextToken(Lexer::T_IDENTIFIER) &&
  2965. isset($this->queryComponents[$this->lexer->lookahead['value']]['resultVariable'])
  2966. ) {
  2967. return $this->ResultVariable();
  2968. }
  2970. return $this->StringPrimary();
  2971. }
  2973. /**
  2974. * StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression | CaseExpression
  2975. *
  2976. * @return Node
  2977. */
  2978. public function StringPrimary()
  2979. {
  2980. $lookaheadType = $this->lexer->lookahead['type'];
  2982. switch ($lookaheadType) {
  2983. case Lexer::T_IDENTIFIER:
  2984. $peek = $this->lexer->glimpse();
  2986. if ($peek['value'] === '.') {
  2987. return $this->StateFieldPathExpression();
  2988. }
  2990. if ($peek['value'] === '(') {
  2991. // do NOT directly go to FunctionsReturningString() because it doesn't check for custom functions.
  2992. return $this->FunctionDeclaration();
  2993. }
  2995. $this->syntaxError("'.' or '('");
  2996. break;
  2998. case Lexer::T_STRING:
  2999. $this->match(Lexer::T_STRING);
  3001. return new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3003. case Lexer::T_INPUT_PARAMETER:
  3004. return $this->InputParameter();
  3006. case Lexer::T_CASE:
  3007. case Lexer::T_COALESCE:
  3008. case Lexer::T_NULLIF:
  3009. return $this->CaseExpression();
  3011. default:
  3012. if ($this->isAggregateFunction($lookaheadType)) {
  3013. return $this->AggregateExpression();
  3014. }
  3015. }
  3017. $this->syntaxError(
  3018. 'StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression'
  3019. );
  3020. }
  3022. /**
  3023. * EntityExpression ::= SingleValuedAssociationPathExpression | SimpleEntityExpression
  3024. *
  3025. * @return AST\InputParameter|PathExpression
  3026. */
  3027. public function EntityExpression()
  3028. {
  3029. $glimpse = $this->lexer->glimpse();
  3031. if ($this->lexer->isNextToken(Lexer::T_IDENTIFIER) && $glimpse['value'] === '.') {
  3032. return $this->SingleValuedAssociationPathExpression();
  3033. }
  3035. return $this->SimpleEntityExpression();
  3036. }
  3038. /**
  3039. * SimpleEntityExpression ::= IdentificationVariable | InputParameter
  3040. *
  3041. * @return AST\InputParameter|AST\PathExpression
  3042. */
  3043. public function SimpleEntityExpression()
  3044. {
  3045. if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3046. return $this->InputParameter();
  3047. }
  3049. return $this->StateFieldPathExpression();
  3050. }
  3052. /**
  3053. * AggregateExpression ::=
  3054. * ("AVG" | "MAX" | "MIN" | "SUM" | "COUNT") "(" ["DISTINCT"] SimpleArithmeticExpression ")"
  3055. *
  3056. * @return AggregateExpression
  3057. */
  3058. public function AggregateExpression()
  3059. {
  3060. $lookaheadType = $this->lexer->lookahead['type'];
  3061. $isDistinct = false;
  3063. if (! in_array($lookaheadType, [Lexer::T_COUNT, Lexer::T_AVG, Lexer::T_MAX, Lexer::T_MIN, Lexer::T_SUM], true)) {
  3064. $this->syntaxError('One of: MAX, MIN, AVG, SUM, COUNT');
  3065. }
  3067. $this->match($lookaheadType);
  3068. $functionName = $this->lexer->token['value'];
  3069. $this->match(Lexer::T_OPEN_PARENTHESIS);
  3071. if ($this->lexer->isNextToken(Lexer::T_DISTINCT)) {
  3072. $this->match(Lexer::T_DISTINCT);
  3073. $isDistinct = true;
  3074. }
  3076. $pathExp = $this->SimpleArithmeticExpression();
  3078. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3080. return new AST\AggregateExpression($functionName, $pathExp, $isDistinct);
  3081. }
  3083. /**
  3084. * QuantifiedExpression ::= ("ALL" | "ANY" | "SOME") "(" Subselect ")"
  3085. *
  3086. * @return QuantifiedExpression
  3087. */
  3088. public function QuantifiedExpression()
  3089. {
  3090. $lookaheadType = $this->lexer->lookahead['type'];
  3091. $value = $this->lexer->lookahead['value'];
  3093. if (! in_array($lookaheadType, [Lexer::T_ALL, Lexer::T_ANY, Lexer::T_SOME], true)) {
  3094. $this->syntaxError('ALL, ANY or SOME');
  3095. }
  3097. $this->match($lookaheadType);
  3098. $this->match(Lexer::T_OPEN_PARENTHESIS);
  3100. $qExpr = new AST\QuantifiedExpression($this->Subselect());
  3101. $qExpr->type = $value;
  3103. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3105. return $qExpr;
  3106. }
  3108. /**
  3109. * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
  3110. *
  3111. * @return BetweenExpression
  3112. */
  3113. public function BetweenExpression()
  3114. {
  3115. $not = false;
  3116. $arithExpr1 = $this->ArithmeticExpression();
  3118. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3119. $this->match(Lexer::T_NOT);
  3120. $not = true;
  3121. }
  3123. $this->match(Lexer::T_BETWEEN);
  3124. $arithExpr2 = $this->ArithmeticExpression();
  3125. $this->match(Lexer::T_AND);
  3126. $arithExpr3 = $this->ArithmeticExpression();
  3128. $betweenExpr = new AST\BetweenExpression($arithExpr1, $arithExpr2, $arithExpr3);
  3129. $betweenExpr->not = $not;
  3131. return $betweenExpr;
  3132. }
  3134. /**
  3135. * ComparisonExpression ::= ArithmeticExpression ComparisonOperator ( QuantifiedExpression | ArithmeticExpression )
  3136. *
  3137. * @return ComparisonExpression
  3138. */
  3139. public function ComparisonExpression()
  3140. {
  3141. $this->lexer->glimpse();
  3143. $leftExpr = $this->ArithmeticExpression();
  3144. $operator = $this->ComparisonOperator();
  3145. $rightExpr = $this->isNextAllAnySome()
  3146. ? $this->QuantifiedExpression()
  3147. : $this->ArithmeticExpression();
  3149. return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
  3150. }
  3152. /**
  3153. * InExpression ::= SingleValuedPathExpression ["NOT"] "IN" "(" (InParameter {"," InParameter}* | Subselect) ")"
  3154. *
  3155. * @return InExpression
  3156. */
  3157. public function InExpression()
  3158. {
  3159. $inExpression = new AST\InExpression($this->ArithmeticExpression());
  3161. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3162. $this->match(Lexer::T_NOT);
  3163. $inExpression->not = true;
  3164. }
  3166. $this->match(Lexer::T_IN);
  3167. $this->match(Lexer::T_OPEN_PARENTHESIS);
  3169. if ($this->lexer->isNextToken(Lexer::T_SELECT)) {
  3170. $inExpression->subselect = $this->Subselect();
  3171. } else {
  3172. $literals = [];
  3173. $literals[] = $this->InParameter();
  3175. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3176. $this->match(Lexer::T_COMMA);
  3177. $literals[] = $this->InParameter();
  3178. }
  3180. $inExpression->literals = $literals;
  3181. }
  3183. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3185. return $inExpression;
  3186. }
  3188. /**
  3189. * InstanceOfExpression ::= IdentificationVariable ["NOT"] "INSTANCE" ["OF"] (InstanceOfParameter | "(" InstanceOfParameter {"," InstanceOfParameter}* ")")
  3190. *
  3191. * @return InstanceOfExpression
  3192. */
  3193. public function InstanceOfExpression()
  3194. {
  3195. $instanceOfExpression = new AST\InstanceOfExpression($this->IdentificationVariable());
  3197. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3198. $this->match(Lexer::T_NOT);
  3199. $instanceOfExpression->not = true;
  3200. }
  3202. $this->match(Lexer::T_INSTANCE);
  3203. $this->match(Lexer::T_OF);
  3205. $exprValues = [];
  3207. if ($this->lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
  3208. $this->match(Lexer::T_OPEN_PARENTHESIS);
  3210. $exprValues[] = $this->InstanceOfParameter();
  3212. while ($this->lexer->isNextToken(Lexer::T_COMMA)) {
  3213. $this->match(Lexer::T_COMMA);
  3215. $exprValues[] = $this->InstanceOfParameter();
  3216. }
  3218. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3220. $instanceOfExpression->value = $exprValues;
  3222. return $instanceOfExpression;
  3223. }
  3225. $exprValues[] = $this->InstanceOfParameter();
  3227. $instanceOfExpression->value = $exprValues;
  3229. return $instanceOfExpression;
  3230. }
  3232. /**
  3233. * InstanceOfParameter ::= AbstractSchemaName | InputParameter
  3234. *
  3235. * @return mixed
  3236. */
  3237. public function InstanceOfParameter()
  3238. {
  3239. if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3240. $this->match(Lexer::T_INPUT_PARAMETER);
  3242. return new AST\InputParameter($this->lexer->token['value']);
  3243. }
  3245. $abstractSchemaName = $this->AbstractSchemaName();
  3247. $this->validateAbstractSchemaName($abstractSchemaName);
  3249. return $abstractSchemaName;
  3250. }
  3252. /**
  3253. * LikeExpression ::= StringExpression ["NOT"] "LIKE" StringPrimary ["ESCAPE" char]
  3254. *
  3255. * @return LikeExpression
  3256. */
  3257. public function LikeExpression()
  3258. {
  3259. $stringExpr = $this->StringExpression();
  3260. $not = false;
  3262. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3263. $this->match(Lexer::T_NOT);
  3264. $not = true;
  3265. }
  3267. $this->match(Lexer::T_LIKE);
  3269. if ($this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
  3270. $this->match(Lexer::T_INPUT_PARAMETER);
  3271. $stringPattern = new AST\InputParameter($this->lexer->token['value']);
  3272. } else {
  3273. $stringPattern = $this->StringPrimary();
  3274. }
  3276. $escapeChar = null;
  3278. if ($this->lexer->lookahead !== null && $this->lexer->lookahead['type'] === Lexer::T_ESCAPE) {
  3279. $this->match(Lexer::T_ESCAPE);
  3280. $this->match(Lexer::T_STRING);
  3282. $escapeChar = new AST\Literal(AST\Literal::STRING, $this->lexer->token['value']);
  3283. }
  3285. $likeExpr = new AST\LikeExpression($stringExpr, $stringPattern, $escapeChar);
  3286. $likeExpr->not = $not;
  3288. return $likeExpr;
  3289. }
  3291. /**
  3292. * NullComparisonExpression ::= (InputParameter | NullIfExpression | CoalesceExpression | AggregateExpression | FunctionDeclaration | IdentificationVariable | SingleValuedPathExpression | ResultVariable) "IS" ["NOT"] "NULL"
  3293. *
  3294. * @return NullComparisonExpression
  3295. */
  3296. public function NullComparisonExpression()
  3297. {
  3298. switch (true) {
  3299. case $this->lexer->isNextToken(Lexer::T_INPUT_PARAMETER):
  3300. $this->match(Lexer::T_INPUT_PARAMETER);
  3302. $expr = new AST\InputParameter($this->lexer->token['value']);
  3303. break;
  3305. case $this->lexer->isNextToken(Lexer::T_NULLIF):
  3306. $expr = $this->NullIfExpression();
  3307. break;
  3309. case $this->lexer->isNextToken(Lexer::T_COALESCE):
  3310. $expr = $this->CoalesceExpression();
  3311. break;
  3313. case $this->isFunction():
  3314. $expr = $this->FunctionDeclaration();
  3315. break;
  3317. default:
  3318. // We need to check if we are in a IdentificationVariable or SingleValuedPathExpression
  3319. $glimpse = $this->lexer->glimpse();
  3321. if ($glimpse['type'] === Lexer::T_DOT) {
  3322. $expr = $this->SingleValuedPathExpression();
  3324. // Leave switch statement
  3325. break;
  3326. }
  3328. $lookaheadValue = $this->lexer->lookahead['value'];
  3330. // Validate existing component
  3331. if (! isset($this->queryComponents[$lookaheadValue])) {
  3332. $this->semanticalError('Cannot add having condition on undefined result variable.');
  3333. }
  3335. // Validate SingleValuedPathExpression (ie.: "product")
  3336. if (isset($this->queryComponents[$lookaheadValue]['metadata'])) {
  3337. $expr = $this->SingleValuedPathExpression();
  3338. break;
  3339. }
  3341. // Validating ResultVariable
  3342. if (! isset($this->queryComponents[$lookaheadValue]['resultVariable'])) {
  3343. $this->semanticalError('Cannot add having condition on a non result variable.');
  3344. }
  3346. $expr = $this->ResultVariable();
  3347. break;
  3348. }
  3350. $nullCompExpr = new AST\NullComparisonExpression($expr);
  3352. $this->match(Lexer::T_IS);
  3354. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3355. $this->match(Lexer::T_NOT);
  3357. $nullCompExpr->not = true;
  3358. }
  3360. $this->match(Lexer::T_NULL);
  3362. return $nullCompExpr;
  3363. }
  3365. /**
  3366. * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
  3367. *
  3368. * @return ExistsExpression
  3369. */
  3370. public function ExistsExpression()
  3371. {
  3372. $not = false;
  3374. if ($this->lexer->isNextToken(Lexer::T_NOT)) {
  3375. $this->match(Lexer::T_NOT);
  3376. $not = true;
  3377. }
  3379. $this->match(Lexer::T_EXISTS);
  3380. $this->match(Lexer::T_OPEN_PARENTHESIS);
  3382. $existsExpression = new AST\ExistsExpression($this->Subselect());
  3383. $existsExpression->not = $not;
  3385. $this->match(Lexer::T_CLOSE_PARENTHESIS);
  3387. return $existsExpression;
  3388. }
  3390. /**
  3391. * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
  3392. *
  3393. * @return string
  3394. */
  3395. public function ComparisonOperator()
  3396. {
  3397. switch ($this->lexer->lookahead['value']) {
  3398. case '=':
  3399. $this->match(Lexer::T_EQUALS);
  3401. return '=';
  3403. case '<':
  3404. $this->match(Lexer::T_LOWER_THAN);
  3405. $operator = '<';
  3407. if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3408. $this->match(Lexer::T_EQUALS);
  3409. $operator .= '=';
  3410. } elseif ($this->lexer->isNextToken(Lexer::T_GREATER_THAN)) {
  3411. $this->match(Lexer::T_GREATER_THAN);
  3412. $operator .= '>';
  3413. }
  3415. return $operator;
  3417. case '>':
  3418. $this->match(Lexer::T_GREATER_THAN);
  3419. $operator = '>';
  3421. if ($this->lexer->isNextToken(Lexer::T_EQUALS)) {
  3422. $this->match(Lexer::T_EQUALS);
  3423. $operator .= '=';
  3424. }
  3426. return $operator;
  3428. case '!':
  3429. $this->match(Lexer::T_NEGATE);
  3430. $this->match(Lexer::T_EQUALS);
  3432. return '<>';
  3434. default:
  3435. $this->syntaxError('=, <, <=, <>, >, >=, !=');
  3436. }
  3437. }
  3439. /**
  3440. * FunctionDeclaration ::= FunctionsReturningStrings | FunctionsReturningNumerics | FunctionsReturningDatetime
  3441. *
  3442. * @return FunctionNode
  3443. */
  3444. public function FunctionDeclaration()
  3445. {
  3446. $token = $this->lexer->lookahead;
  3447. $funcName = strtolower($token['value']);
  3449. $customFunctionDeclaration = $this->CustomFunctionDeclaration();
  3451. // Check for custom functions functions first!
  3452. switch (true) {
  3453. case $customFunctionDeclaration !== null:
  3454. return $customFunctionDeclaration;
  3456. case isset(self::$stringFunctions[$funcName]):
  3457. return $this->FunctionsReturningStrings();
  3459. case isset(self::$numericFunctions[$funcName]):
  3460. return $this->FunctionsReturningNumerics();
  3462. case isset(self::$datetimeFunctions[$funcName]):
  3463. return $this->FunctionsReturningDatetime();
  3465. default:
  3466. $this->syntaxError('known function', $token);
  3467. }
  3468. }
  3470. /**
  3471. * Helper function for FunctionDeclaration grammar rule.
  3472. */
  3473. private function CustomFunctionDeclaration(): ?FunctionNode
  3474. {
  3475. $token = $this->lexer->lookahead;
  3476. $funcName = strtolower($token['value']);
  3478. // Check for custom functions afterwards
  3479. $config = $this->em->getConfiguration();
  3481. switch (true) {
  3482. case $config->getCustomStringFunction($funcName) !== null:
  3483. return $this->CustomFunctionsReturningStrings();
  3485. case $config->getCustomNumericFunction($funcName) !== null:
  3486. return $this->CustomFunctionsReturningNumerics();
  3488. case $config->getCustomDatetimeFunction($funcName) !== null:
  3489. return $this->CustomFunctionsReturningDatetime();
  3491. default:
  3492. return null;
  3493. }
  3494. }
  3496. /**
  3497. * FunctionsReturningNumerics ::=
  3498. * "LENGTH" "(" StringPrimary ")" |
  3499. * "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")" |
  3500. * "ABS" "(" SimpleArithmeticExpression ")" |
  3501. * "SQRT" "(" SimpleArithmeticExpression ")" |
  3502. * "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3503. * "SIZE" "(" CollectionValuedPathExpression ")" |
  3504. * "DATE_DIFF" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3505. * "BIT_AND" "(" ArithmeticPrimary "," ArithmeticPrimary ")" |
  3506. * "BIT_OR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
  3507. *
  3508. * @return FunctionNode
  3509. */
  3510. public function FunctionsReturningNumerics()
  3511. {
  3512. $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3513. $funcClass = self::$numericFunctions[$funcNameLower];
  3515. $function = new $funcClass($funcNameLower);
  3516. $function->parse($this);
  3518. return $function;
  3519. }
  3521. /**
  3522. * @return FunctionNode
  3523. */
  3524. public function CustomFunctionsReturningNumerics()
  3525. {
  3526. // getCustomNumericFunction is case-insensitive
  3527. $functionName = strtolower($this->lexer->lookahead['value']);
  3528. $functionClass = $this->em->getConfiguration()->getCustomNumericFunction($functionName);
  3530. assert($functionClass !== null);
  3532. $function = is_string($functionClass)
  3533. ? new $functionClass($functionName)
  3534. : call_user_func($functionClass, $functionName);
  3536. $function->parse($this);
  3538. return $function;
  3539. }
  3541. /**
  3542. * FunctionsReturningDateTime ::=
  3543. * "CURRENT_DATE" |
  3544. * "CURRENT_TIME" |
  3545. * "CURRENT_TIMESTAMP" |
  3546. * "DATE_ADD" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")" |
  3547. * "DATE_SUB" "(" ArithmeticPrimary "," ArithmeticPrimary "," StringPrimary ")"
  3548. *
  3549. * @return FunctionNode
  3550. */
  3551. public function FunctionsReturningDatetime()
  3552. {
  3553. $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3554. $funcClass = self::$datetimeFunctions[$funcNameLower];
  3556. $function = new $funcClass($funcNameLower);
  3557. $function->parse($this);
  3559. return $function;
  3560. }
  3562. /**
  3563. * @return FunctionNode
  3564. */
  3565. public function CustomFunctionsReturningDatetime()
  3566. {
  3567. // getCustomDatetimeFunction is case-insensitive
  3568. $functionName = $this->lexer->lookahead['value'];
  3569. $functionClass = $this->em->getConfiguration()->getCustomDatetimeFunction($functionName);
  3571. assert($functionClass !== null);
  3573. $function = is_string($functionClass)
  3574. ? new $functionClass($functionName)
  3575. : call_user_func($functionClass, $functionName);
  3577. $function->parse($this);
  3579. return $function;
  3580. }
  3582. /**
  3583. * FunctionsReturningStrings ::=
  3584. * "CONCAT" "(" StringPrimary "," StringPrimary {"," StringPrimary}* ")" |
  3585. * "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
  3586. * "TRIM" "(" [["LEADING" | "TRAILING" | "BOTH"] [char] "FROM"] StringPrimary ")" |
  3587. * "LOWER" "(" StringPrimary ")" |
  3588. * "UPPER" "(" StringPrimary ")" |
  3589. * "IDENTITY" "(" SingleValuedAssociationPathExpression {"," string} ")"
  3590. *
  3591. * @return FunctionNode
  3592. */
  3593. public function FunctionsReturningStrings()
  3594. {
  3595. $funcNameLower = strtolower($this->lexer->lookahead['value']);
  3596. $funcClass = self::$stringFunctions[$funcNameLower];
  3598. $function = new $funcClass($funcNameLower);
  3599. $function->parse($this);
  3601. return $function;
  3602. }
  3604. /**
  3605. * @return FunctionNode
  3606. */
  3607. public function CustomFunctionsReturningStrings()
  3608. {
  3609. // getCustomStringFunction is case-insensitive
  3610. $functionName = $this->lexer->lookahead['value'];
  3611. $functionClass = $this->em->getConfiguration()->getCustomStringFunction($functionName);
  3613. assert($functionClass !== null);
  3615. $function = is_string($functionClass)
  3616. ? new $functionClass($functionName)
  3617. : call_user_func($functionClass, $functionName);
  3619. $function->parse($this);
  3621. return $function;
  3622. }
  3623. }