vendor/phpcr/phpcr-utils/src/PHPCR/Util/QOM/Sql2ToQomQueryConverter.php line 359

Open in your IDE?
  1. <?php
  3. namespace PHPCR\Util\QOM;
  5. use DateTime;
  6. use Exception;
  7. use InvalidArgumentException;
  8. use LogicException;
  9. use PHPCR\PropertyType;
  10. use PHPCR\Query\InvalidQueryException;
  11. use PHPCR\Query\QOM\ChildNodeJoinConditionInterface;
  12. use PHPCR\Query\QOM\ColumnInterface;
  13. use PHPCR\Query\QOM\ComparisonInterface;
  14. use PHPCR\Query\QOM\ConstraintInterface;
  15. use PHPCR\Query\QOM\DescendantNodeJoinConditionInterface;
  16. use PHPCR\Query\QOM\DynamicOperandInterface;
  17. use PHPCR\Query\QOM\EquiJoinConditionInterface;
  18. use PHPCR\Query\QOM\FullTextSearchInterface;
  19. use PHPCR\Query\QOM\JoinConditionInterface;
  20. use PHPCR\Query\QOM\JoinInterface;
  21. use PHPCR\Query\QOM\NotInterface;
  22. use PHPCR\Query\QOM\OrderingInterface;
  23. use PHPCR\Query\QOM\PropertyValueInterface;
  24. use PHPCR\Query\QOM\QueryObjectModelConstantsInterface as Constants;
  25. use PHPCR\Query\QOM\QueryObjectModelFactoryInterface;
  26. use PHPCR\Query\QOM\QueryObjectModelInterface;
  27. use PHPCR\Query\QOM\SameNodeJoinConditionInterface;
  28. use PHPCR\Query\QOM\SelectorInterface;
  29. use PHPCR\Query\QOM\SourceInterface;
  30. use PHPCR\Query\QOM\StaticOperandInterface;
  31. use PHPCR\Util\ValueConverter;
  33. /**
  34. * Parse SQL2 statements and output a corresponding QOM objects tree.
  35. *
  36. * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  37. * @license http://opensource.org/licenses/MIT MIT License
  38. */
  39. class Sql2ToQomQueryConverter
  40. {
  41. /**
  42. * The factory to create QOM objects.
  43. *
  44. * @var QueryObjectModelFactoryInterface
  45. */
  46. protected $factory;
  48. /**
  49. * Scanner to parse SQL2.
  50. *
  51. * @var Sql2Scanner;
  52. */
  53. protected $scanner;
  55. /**
  56. * The SQL2 query (the converter is not reentrant).
  57. *
  58. * @var string
  59. */
  60. protected $sql2;
  62. /**
  63. * The selector is not required for SQL2 but for QOM.
  64. *
  65. * We keep all selectors we encounter. If there is exactly one, it is used
  66. * whenever we encounter non-qualified names.
  67. *
  68. * @var string|array
  69. */
  70. protected $implicitSelectorName = null;
  72. /**
  73. * @var ValueConverter
  74. */
  75. private $valueConverter;
  77. /**
  78. * Instantiate a converter.
  79. *
  80. * @param QueryObjectModelFactoryInterface $factory
  81. * @param ValueConverter $valueConverter To override default converter.
  82. */
  83. public function __construct(QueryObjectModelFactoryInterface $factory, ValueConverter $valueConverter = null)
  84. {
  85. $this->factory = $factory;
  86. $this->valueConverter = $valueConverter ?: new ValueConverter();
  87. }
  89. /**
  90. * 6.7.1. Query
  91. * Parse an SQL2 query and return the corresponding QOM QueryObjectModel.
  92. *
  93. * @param string $sql2
  94. *
  95. * @throws InvalidQueryException
  96. *
  97. * @return QueryObjectModelInterface
  98. */
  99. public function parse($sql2)
  100. {
  101. $this->implicitSelectorName = null;
  102. $this->sql2 = $sql2;
  103. $this->scanner = new Sql2Scanner($sql2);
  104. $source = null;
  105. $columnData = [];
  106. $constraint = null;
  107. $orderings = [];
  109. while ($this->scanner->lookupNextToken() !== '') {
  110. switch (strtoupper($this->scanner->lookupNextToken())) {
  111. case 'SELECT':
  112. $this->scanner->expectToken('SELECT');
  113. $columnData = $this->scanColumns();
  114. break;
  115. case 'FROM':
  116. $this->scanner->expectToken('FROM');
  117. $source = $this->parseSource();
  118. break;
  119. case 'WHERE':
  120. $this->scanner->expectToken('WHERE');
  121. $constraint = $this->parseConstraint();
  122. break;
  123. case 'ORDER':
  124. // Ordering, check there is a BY
  125. $this->scanner->expectTokens(['ORDER', 'BY']);
  126. $orderings = $this->parseOrderings();
  127. break;
  128. default:
  129. throw new InvalidQueryException('Error parsing query, unknown query part "'.$this->scanner->lookupNextToken().'" in: '.$this->sql2);
  130. }
  131. }
  133. if (!$source instanceof SourceInterface) {
  134. throw new InvalidQueryException('Invalid query, source could not be determined: '.$sql2);
  135. }
  137. $columns = $this->buildColumns($columnData);
  139. return $this->factory->createQuery($source, $constraint, $orderings, $columns);
  140. }
  142. /**
  143. * 6.7.2. Source
  144. * Parse an SQL2 source definition and return the corresponding QOM Source.
  145. *
  146. * @return SourceInterface
  147. */
  148. protected function parseSource()
  149. {
  150. $selector = $this->parseSelector();
  152. $next = $this->scanner->lookupNextToken();
  153. $left = $selector;
  155. while (in_array(strtoupper($next), ['JOIN', 'INNER', 'RIGHT', 'LEFT'])) {
  156. $left = $this->parseJoin($left);
  157. $next = $this->scanner->lookupNextToken();
  158. }
  160. return $left;
  161. }
  163. /**
  164. * 6.7.3. Selector
  165. * Parse an SQL2 selector and return a QOM\SelectorInterface.
  166. *
  167. * @return SelectorInterface
  168. */
  169. protected function parseSelector()
  170. {
  171. $nodetype = $this->fetchTokenWithoutBrackets();
  173. if ($this->scanner->tokenIs($this->scanner->lookupNextToken(), 'AS')) {
  174. $this->scanner->fetchNextToken(); // Consume the AS
  175. $selectorName = $this->parseName();
  176. $this->updateImplicitSelectorName($selectorName);
  178. return $this->factory->selector($selectorName, $nodetype);
  179. }
  180. $this->updateImplicitSelectorName($nodetype);
  182. return $this->factory->selector($nodetype, $nodetype);
  183. }
  185. /**
  186. * 6.7.4. Name.
  187. *
  188. * @return string
  189. */
  190. protected function parseName()
  191. {
  192. return $this->scanner->fetchNextToken();
  193. }
  195. /**
  196. * 6.7.5. Join
  197. * 6.7.6. Join type
  198. * Parse an SQL2 join source and return a QOM\Join.
  199. *
  200. * @param SourceInterface $leftSelector the left selector as it has been read by parseSource
  201. *
  202. * @return JoinInterface
  203. */
  204. protected function parseJoin(SourceInterface $leftSelector)
  205. {
  206. $joinType = $this->parseJoinType();
  207. $right = $this->parseSelector();
  208. $joinCondition = $this->parseJoinCondition();
  210. return $this->factory->join($leftSelector, $right, $joinType, $joinCondition);
  211. }
  213. /**
  214. * 6.7.6. Join type.
  215. *
  216. * @throws InvalidQueryException
  217. *
  218. * @return string
  219. */
  220. protected function parseJoinType()
  221. {
  222. $joinType = Constants::JCR_JOIN_TYPE_INNER;
  223. $token = $this->scanner->fetchNextToken();
  225. switch ($token) {
  226. case 'JOIN':
  227. // Token already fetched, nothing to do
  228. break;
  229. case 'INNER':
  230. $this->scanner->fetchNextToken();
  231. break;
  232. case 'LEFT':
  233. $this->scanner->expectTokens(['OUTER', 'JOIN']);
  234. $joinType = Constants::JCR_JOIN_TYPE_LEFT_OUTER;
  235. break;
  236. case 'RIGHT':
  237. $this->scanner->expectTokens(['OUTER', 'JOIN']);
  238. $joinType = Constants::JCR_JOIN_TYPE_RIGHT_OUTER;
  239. break;
  240. default:
  241. throw new InvalidQueryException("Syntax error: Expected JOIN, INNER JOIN, RIGHT JOIN or LEFT JOIN in '{$this->sql2}'");
  242. }
  244. return $joinType;
  245. }
  247. /**
  248. * 6.7.7. JoinCondition
  249. * Parse an SQL2 join condition and return a JoinConditionInterface.
  250. *
  251. * @return JoinConditionInterface
  252. */
  253. protected function parseJoinCondition()
  254. {
  255. $this->scanner->expectToken('ON');
  257. $token = $this->scanner->lookupNextToken();
  258. if ($this->scanner->tokenIs($token, 'ISSAMENODE')) {
  259. return $this->parseSameNodeJoinCondition();
  260. }
  262. if ($this->scanner->tokenIs($token, 'ISCHILDNODE')) {
  263. return $this->parseChildNodeJoinCondition();
  264. }
  266. if ($this->scanner->tokenIs($token, 'ISDESCENDANTNODE')) {
  267. return $this->parseDescendantNodeJoinCondition();
  268. }
  270. return $this->parseEquiJoin();
  271. }
  273. /**
  274. * 6.7.8. EquiJoinCondition
  275. * Parse an SQL2 equijoin condition and return a EquiJoinConditionInterface.
  276. *
  277. * @return EquiJoinConditionInterface
  278. */
  279. protected function parseEquiJoin()
  280. {
  281. list($selectorName1, $prop1) = $this->parseIdentifier();
  282. $this->scanner->expectToken('=');
  283. list($selectorName2, $prop2) = $this->parseIdentifier();
  285. return $this->factory->equiJoinCondition($selectorName1, $prop1, $selectorName2, $prop2);
  286. }
  288. /**
  289. * 6.7.9 SameNodeJoinCondition
  290. * Parse an SQL2 same node join condition and return a SameNodeJoinConditionInterface.
  291. *
  292. * @return SameNodeJoinConditionInterface
  293. */
  294. protected function parseSameNodeJoinCondition()
  295. {
  296. $this->scanner->expectTokens(['ISSAMENODE', '(']);
  297. $selectorName1 = $this->fetchTokenWithoutBrackets();
  298. $this->scanner->expectToken(',');
  299. $selectorName2 = $this->fetchTokenWithoutBrackets();
  301. $token = $this->scanner->lookupNextToken();
  302. if ($this->scanner->tokenIs($token, ',')) {
  303. $this->scanner->fetchNextToken(); // consume the coma
  304. $path = $this->parsePath();
  305. } else {
  306. $path = null;
  307. }
  309. $this->scanner->expectToken(')');
  311. return $this->factory->sameNodeJoinCondition($selectorName1, $selectorName2, $path);
  312. }
  314. /**
  315. * 6.7.10 ChildNodeJoinCondition
  316. * Parse an SQL2 child node join condition and return a ChildNodeJoinConditionInterface.
  317. *
  318. * @return ChildNodeJoinConditionInterface
  319. */
  320. protected function parseChildNodeJoinCondition()
  321. {
  322. $this->scanner->expectTokens(['ISCHILDNODE', '(']);
  323. $child = $this->fetchTokenWithoutBrackets();
  324. $this->scanner->expectToken(',');
  325. $parent = $this->fetchTokenWithoutBrackets();
  326. $this->scanner->expectToken(')');
  328. return $this->factory->childNodeJoinCondition($child, $parent);
  329. }
  331. /**
  332. * 6.7.11 DescendantNodeJoinCondition
  333. * Parse an SQL2 descendant node join condition and return a DescendantNodeJoinConditionInterface.
  334. *
  335. * @return DescendantNodeJoinConditionInterface
  336. */
  337. protected function parseDescendantNodeJoinCondition()
  338. {
  339. $this->scanner->expectTokens(['ISDESCENDANTNODE', '(']);
  340. $descendant = $this->fetchTokenWithoutBrackets();
  341. $this->scanner->expectToken(',');
  342. $parent = $this->fetchTokenWithoutBrackets();
  343. $this->scanner->expectToken(')');
  345. return $this->factory->descendantNodeJoinCondition($descendant, $parent);
  346. }
  348. /**
  349. * 6.7.13 And
  350. * 6.7.14 Or.
  351. *
  352. * @param ConstraintInterface $lhs Left hand side
  353. * @param int $minprec Precedence
  354. *
  355. * @throws Exception
  356. *
  357. * @return ConstraintInterface
  358. */
  359. protected function parseConstraint($lhs = null, $minprec = 0)
  360. {
  361. if ($lhs === null) {
  362. $lhs = $this->parsePrimaryConstraint();
  363. }
  365. $opprec = [
  366. 'OR' => 1,
  367. 'AND' => 2,
  368. ];
  370. $op = strtoupper($this->scanner->lookupNextToken());
  371. while (isset($opprec[$op]) && $opprec[$op] >= $minprec) {
  372. $this->scanner->fetchNextToken();
  374. $rhs = $this->parsePrimaryConstraint();
  376. $nextop = strtoupper($this->scanner->lookupNextToken());
  378. while (isset($opprec[$nextop]) && $opprec[$nextop] > $opprec[$op]) {
  379. $rhs = $this->parseConstraint($rhs, $opprec[$nextop]);
  380. $nextop = strtoupper($this->scanner->lookupNextToken());
  381. }
  383. switch ($op) {
  384. case 'AND':
  385. $lhs = $this->factory->andConstraint($lhs, $rhs);
  386. break;
  387. case 'OR':
  388. $lhs = $this->factory->orConstraint($lhs, $rhs);
  389. break;
  390. default:
  391. // this only happens if the operator is
  392. // in the $opprec-array but there is no
  393. // "elseif"-branch here for this operator.
  394. throw new Exception("Internal error: No action is defined for operator '$op'");
  395. }
  397. $op = strtoupper($this->scanner->lookupNextToken());
  398. }
  400. return $lhs;
  401. }
  403. /**
  404. * 6.7.12 Constraint.
  405. *
  406. * @return ConstraintInterface
  407. */
  408. protected function parsePrimaryConstraint()
  409. {
  410. $constraint = null;
  411. $token = $this->scanner->lookupNextToken();
  413. if ($this->scanner->tokenIs($token, 'NOT')) {
  414. // NOT
  415. $constraint = $this->parseNot();
  416. } elseif ($this->scanner->tokenIs($token, '(')) {
  417. // Grouping with parenthesis
  418. $this->scanner->expectToken('(');
  419. $constraint = $this->parseConstraint();
  420. $this->scanner->expectToken(')');
  421. } elseif ($this->scanner->tokenIs($token, 'CONTAINS')) {
  422. // Full Text Search
  423. $constraint = $this->parseFullTextSearch();
  424. } elseif ($this->scanner->tokenIs($token, 'ISSAMENODE')) {
  425. // SameNode
  426. $constraint = $this->parseSameNode();
  427. } elseif ($this->scanner->tokenIs($token, 'ISCHILDNODE')) {
  428. // ChildNode
  429. $constraint = $this->parseChildNode();
  430. } elseif ($this->scanner->tokenIs($token, 'ISDESCENDANTNODE')) {
  431. // DescendantNode
  432. $constraint = $this->parseDescendantNode();
  433. } else {
  434. // Is it a property existence?
  435. $next1 = $this->scanner->lookupNextToken(1);
  436. if ($this->scanner->tokenIs($next1, 'IS')) {
  437. $constraint = $this->parsePropertyExistence();
  438. } elseif ($this->scanner->tokenIs($next1, '.')) {
  439. $next2 = $this->scanner->lookupNextToken(3);
  440. if ($this->scanner->tokenIs($next2, 'IS')) {
  441. $constraint = $this->parsePropertyExistence();
  442. }
  443. }
  445. if ($constraint === null) {
  446. // It's not a property existence neither, then it's a comparison
  447. $constraint = $this->parseComparison();
  448. }
  449. }
  451. // No constraint read,
  452. if ($constraint === null) {
  453. throw new InvalidQueryException("Syntax error: constraint expected in '{$this->sql2}'");
  454. }
  456. return $constraint;
  457. }
  459. /**
  460. * 6.7.15 Not.
  461. *
  462. * @return NotInterface
  463. */
  464. protected function parseNot()
  465. {
  466. $this->scanner->expectToken('NOT');
  468. return $this->factory->notConstraint($this->parsePrimaryConstraint());
  469. }
  471. /**
  472. * 6.7.16 Comparison.
  473. *
  474. * @throws InvalidQueryException
  475. *
  476. * @return ComparisonInterface
  477. */
  478. protected function parseComparison()
  479. {
  480. $op1 = $this->parseDynamicOperand();
  482. if (null === $op1) {
  483. throw new InvalidQueryException("Syntax error: dynamic operator expected in '{$this->sql2}'");
  484. }
  486. $operator = $this->parseOperator();
  487. $op2 = $this->parseStaticOperand();
  489. return $this->factory->comparison($op1, $operator, $op2);
  490. }
  492. /**
  493. * 6.7.17 Operator.
  494. *
  495. * @return string a constant from QueryObjectModelConstantsInterface
  496. */
  497. protected function parseOperator()
  498. {
  499. $token = $this->scanner->fetchNextToken();
  500. switch (strtoupper($token)) {
  501. case '=':
  502. return Constants::JCR_OPERATOR_EQUAL_TO;
  503. case '<>':
  504. return Constants::JCR_OPERATOR_NOT_EQUAL_TO;
  505. case '<':
  506. return Constants::JCR_OPERATOR_LESS_THAN;
  507. case '<=':
  508. return Constants::JCR_OPERATOR_LESS_THAN_OR_EQUAL_TO;
  509. case '>':
  510. return Constants::JCR_OPERATOR_GREATER_THAN;
  511. case '>=':
  512. return Constants::JCR_OPERATOR_GREATER_THAN_OR_EQUAL_TO;
  513. case 'LIKE':
  514. return Constants::JCR_OPERATOR_LIKE;
  515. }
  517. throw new InvalidQueryException("Syntax error: operator expected in '{$this->sql2}'");
  518. }
  520. /**
  521. * 6.7.18 PropertyExistence.
  522. *
  523. * @return ConstraintInterface
  524. */
  525. protected function parsePropertyExistence()
  526. {
  527. list($selectorName, $prop) = $this->parseIdentifier();
  529. $this->scanner->expectToken('IS');
  530. $token = $this->scanner->lookupNextToken();
  531. if ($this->scanner->tokenIs($token, 'NULL')) {
  532. $this->scanner->fetchNextToken();
  534. return $this->factory->notConstraint($this->factory->propertyExistence($selectorName, $prop));
  535. }
  537. $this->scanner->expectTokens(['NOT', 'NULL']);
  539. return $this->factory->propertyExistence($selectorName, $prop);
  540. }
  542. /**
  543. * 6.7.19 FullTextSearch.
  544. *
  545. * @return FullTextSearchInterface
  546. */
  547. protected function parseFullTextSearch()
  548. {
  549. $this->scanner->expectTokens(['CONTAINS', '(']);
  551. list($selectorName, $propertyName) = $this->parseIdentifier();
  552. $this->scanner->expectToken(',');
  553. $expression = $this->parseLiteralValue();
  554. $this->scanner->expectToken(')');
  556. return $this->factory->fullTextSearch($selectorName, $propertyName, $expression);
  557. }
  559. /**
  560. * 6.7.20 SameNode.
  561. */
  562. protected function parseSameNode()
  563. {
  564. $this->scanner->expectTokens(['ISSAMENODE', '(']);
  565. if ($this->scanner->tokenIs($this->scanner->lookupNextToken(1), ',')) {
  566. $selectorName = $this->scanner->fetchNextToken();
  567. $this->scanner->expectToken(',');
  568. $path = $this->parsePath();
  569. } else {
  570. $selectorName = $this->implicitSelectorName;
  571. $path = $this->parsePath();
  572. }
  573. $this->scanner->expectToken(')');
  575. return $this->factory->sameNode($selectorName, $path);
  576. }
  578. /**
  579. * 6.7.21 ChildNode.
  580. */
  581. protected function parseChildNode()
  582. {
  583. $this->scanner->expectTokens(['ISCHILDNODE', '(']);
  584. if ($this->scanner->tokenIs($this->scanner->lookupNextToken(1), ',')) {
  585. $selectorName = $this->scanner->fetchNextToken();
  586. $this->scanner->expectToken(',');
  587. $path = $this->parsePath();
  588. } else {
  589. $selectorName = $this->implicitSelectorName;
  590. $path = $this->parsePath();
  591. }
  592. $this->scanner->expectToken(')');
  594. return $this->factory->childNode($selectorName, $path);
  595. }
  597. /**
  598. * 6.7.22 DescendantNode.
  599. */
  600. protected function parseDescendantNode()
  601. {
  602. $this->scanner->expectTokens(['ISDESCENDANTNODE', '(']);
  603. if ($this->scanner->tokenIs($this->scanner->lookupNextToken(1), ',')) {
  604. $selectorName = $this->scanner->fetchNextToken();
  605. $this->scanner->expectToken(',');
  606. $path = $this->parsePath();
  607. } else {
  608. $selectorName = $this->implicitSelectorName;
  609. $path = $this->parsePath();
  610. }
  611. $this->scanner->expectToken(')');
  613. return $this->factory->descendantNode($selectorName, $path);
  614. }
  616. /**
  617. * Parse a JCR path consisting of either a simple path (a JCR name that contains
  618. * only SQL-legal characters) or a path (simple path or quoted path) enclosed in
  619. * square brackets. See JCR Spec § 6.7.23.
  620. *
  621. * 6.7.23. Path
  622. */
  623. protected function parsePath()
  624. {
  625. $path = $this->parseLiteralValue();
  626. if (substr($path, 0, 1) === '[' && substr($path, -1) === ']') {
  627. $path = substr($path, 1, -1);
  628. }
  630. return $path;
  631. }
  633. /**
  634. * Parse an SQL2 static operand
  635. * 6.7.35 BindVariable
  636. * 6.7.36 Prefix.
  637. *
  638. * @return StaticOperandInterface
  639. */
  640. protected function parseStaticOperand()
  641. {
  642. $token = $this->scanner->lookupNextToken();
  643. if (substr($token, 0, 1) === '$') {
  644. return $this->factory->bindVariable(substr($this->scanner->fetchNextToken(), 1));
  645. }
  647. return $this->factory->literal($this->parseLiteralValue());
  648. }
  650. /**
  651. * 6.7.26 DynamicOperand
  652. * 6.7.28 Length
  653. * 6.7.29 NodeName
  654. * 6.7.30 NodeLocalName
  655. * 6.7.31 FullTextSearchScore
  656. * 6.7.32 LowerCase
  657. * 6.7.33 UpperCase
  658. * Parse an SQL2 dynamic operand.
  659. *
  660. * @return DynamicOperandInterface
  661. */
  662. protected function parseDynamicOperand()
  663. {
  664. $token = $this->scanner->lookupNextToken();
  666. if ($this->scanner->tokenIs($token, 'LENGTH')) {
  667. $this->scanner->fetchNextToken();
  668. $this->scanner->expectToken('(');
  669. $val = $this->parsePropertyValue();
  670. $this->scanner->expectToken(')');
  672. return $this->factory->length($val);
  673. }
  675. if ($this->scanner->tokenIs($token, 'NAME')) {
  676. $this->scanner->fetchNextToken();
  677. $this->scanner->expectToken('(');
  679. $token = $this->scanner->fetchNextToken();
  680. if ($this->scanner->tokenIs($token, ')')) {
  681. return $this->factory->nodeName($this->implicitSelectorName);
  682. }
  684. $this->scanner->expectToken(')');
  686. return $this->factory->nodeName($token);
  687. }
  689. if ($this->scanner->tokenIs($token, 'LOCALNAME')) {
  690. $this->scanner->fetchNextToken();
  691. $this->scanner->expectToken('(');
  693. $token = $this->scanner->fetchNextToken();
  694. if ($this->scanner->tokenIs($token, ')')) {
  695. return $this->factory->nodeLocalName($this->implicitSelectorName);
  696. }
  698. $this->scanner->expectToken(')');
  700. return $this->factory->nodeLocalName($token);
  701. }
  703. if ($this->scanner->tokenIs($token, 'SCORE')) {
  704. $this->scanner->fetchNextToken();
  705. $this->scanner->expectToken('(');
  707. $token = $this->scanner->fetchNextToken();
  708. if ($this->scanner->tokenIs($token, ')')) {
  709. return $this->factory->fullTextSearchScore($this->implicitSelectorName);
  710. }
  712. $this->scanner->expectToken(')');
  714. return $this->factory->fullTextSearchScore($token);
  715. }
  717. if ($this->scanner->tokenIs($token, 'LOWER')) {
  718. $this->scanner->fetchNextToken();
  719. $this->scanner->expectToken('(');
  720. $op = $this->parseDynamicOperand();
  721. $this->scanner->expectToken(')');
  723. return $this->factory->lowerCase($op);
  724. }
  726. if ($this->scanner->tokenIs($token, 'UPPER')) {
  727. $this->scanner->fetchNextToken();
  728. $this->scanner->expectToken('(');
  729. $op = $this->parseDynamicOperand();
  730. $this->scanner->expectToken(')');
  732. return $this->factory->upperCase($op);
  733. }
  735. return $this->parsePropertyValue();
  736. }
  738. /**
  739. * 6.7.27 PropertyValue
  740. * Parse an SQL2 property value.
  741. *
  742. * @return PropertyValueInterface
  743. */
  744. protected function parsePropertyValue()
  745. {
  746. list($selectorName, $prop) = $this->parseIdentifier();
  748. return $this->factory->propertyValue($selectorName, $prop);
  749. }
  751. protected function parseCastLiteral($token)
  752. {
  753. if (!$this->scanner->tokenIs($token, 'CAST')) {
  754. throw new LogicException('parseCastLiteral when not a CAST');
  755. }
  757. $this->scanner->expectToken('(');
  758. $token = $this->scanner->fetchNextToken();
  760. $quoteString = in_array($token[0], ['\'', '"'], true);
  762. if ($quoteString) {
  763. $quotesUsed = $token[0];
  764. $token = substr($token, 1, -1);
  765. // Un-escaping quotes
  766. $token = str_replace('\\'.$quotesUsed, $quotesUsed, $token);
  767. }
  769. $this->scanner->expectToken('AS');
  771. $type = $this->scanner->fetchNextToken();
  773. try {
  774. $typeValue = PropertyType::valueFromName($type);
  775. } catch (InvalidArgumentException $e) {
  776. throw new InvalidQueryException("Syntax error: attempting to cast to an invalid type '$type'");
  777. }
  779. $this->scanner->expectToken(')');
  781. try {
  782. $token = $this->valueConverter->convertType($token, $typeValue, PropertyType::STRING);
  783. } catch (Exception $e) {
  784. throw new InvalidQueryException("Syntax error: attempting to cast string '$token' to type '$type'");
  785. }
  787. return $token;
  788. }
  790. /**
  791. * 6.7.34 Literal
  792. * Parse an SQL2 literal value.
  793. *
  794. * @return mixed
  795. */
  796. protected function parseLiteralValue()
  797. {
  798. $token = $this->scanner->fetchNextToken();
  799. if ($this->scanner->tokenIs($token, 'CAST')) {
  800. return $this->parseCastLiteral($token);
  801. }
  803. $quoteString = in_array($token[0], ['"', "'"], true);
  805. if ($quoteString) {
  806. $quotesUsed = $token[0];
  807. $token = substr($token, 1, -1);
  808. // Unescape quotes
  809. $token = str_replace('\\'.$quotesUsed, $quotesUsed, $token);
  810. $token = str_replace("''", "'", $token);
  811. if (preg_match('/^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d+)?$/', $token)) {
  812. if (preg_match('/^\d{4}-\d{2}-\d{2}$/', $token)) {
  813. $token .= ' 00:00:00';
  814. }
  815. $token = DateTime::createFromFormat('Y-m-d H:i:s', $token);
  816. }
  817. } elseif (is_numeric($token)) {
  818. $token = strpos($token, '.') === false ? (int) $token : (float) $token;
  819. } elseif ($token === 'true') {
  820. $token = true;
  821. } elseif ($token === 'false') {
  822. $token = false;
  823. }
  825. return $token;
  826. }
  828. /**
  829. * 6.7.37 Ordering.
  830. */
  831. protected function parseOrderings()
  832. {
  833. $orderings = [];
  834. $continue = true;
  836. while ($continue) {
  837. $orderings[] = $this->parseOrdering();
  838. if ($this->scanner->tokenIs($this->scanner->lookupNextToken(), ',')) {
  839. $this->scanner->expectToken(',');
  840. } else {
  841. $continue = false;
  842. }
  843. }
  845. return $orderings;
  846. }
  848. /**
  849. * 6.7.38 Order.
  850. *
  851. * @return OrderingInterface
  852. */
  853. protected function parseOrdering()
  854. {
  855. $operand = $this->parseDynamicOperand();
  856. $token = $this->scanner->lookupNextToken();
  858. if ($this->scanner->tokenIs($token, 'DESC')) {
  859. $this->scanner->expectToken('DESC');
  861. return $this->factory->descending($operand);
  862. }
  864. if ($this->scanner->tokenIs($token, 'ASC') || ',' === $token || '' === $token) {
  865. if ($this->scanner->tokenIs($token, 'ASC')) {
  866. $this->scanner->expectToken('ASC');
  867. }
  869. return $this->factory->ascending($operand);
  870. }
  872. throw new InvalidQueryException("Syntax error: invalid ordering in '{$this->sql2}'");
  873. }
  875. /**
  876. * 6.7.39 Column.
  877. *
  878. * Scan the SQL2 columns definitions and return data arrays to convert to
  879. * columns once the FROM is parsed.
  880. *
  881. * @return array of array
  882. */
  883. protected function scanColumns()
  884. {
  885. // Wildcard
  886. if ($this->scanner->lookupNextToken() === '*') {
  887. $this->scanner->fetchNextToken();
  889. return [];
  890. }
  892. $columns = [];
  893. $hasNext = true;
  895. while ($hasNext) {
  896. $columns[] = $this->scanColumn();
  898. // Are there more columns?
  899. if ($this->scanner->lookupNextToken() !== ',') {
  900. $hasNext = false;
  901. } else {
  902. $this->scanner->fetchNextToken();
  903. }
  904. }
  906. return $columns;
  907. }
  909. /**
  910. * Build the columns from the scanned column data.
  911. *
  912. * @param array $data
  913. *
  914. * @return ColumnInterface[]
  915. */
  916. protected function buildColumns($data)
  917. {
  918. $columns = [];
  919. foreach ($data as $col) {
  920. $columns[] = $this->buildColumn($col);
  921. }
  923. return $columns;
  924. }
  926. /**
  927. * Get the next token and make sure to remove the brackets if the token is
  928. * in the [ns:name] notation.
  929. *
  930. * @return string
  931. */
  932. private function fetchTokenWithoutBrackets()
  933. {
  934. $token = $this->scanner->fetchNextToken();
  936. if (substr($token, 0, 1) === '[' && substr($token, -1) === ']') {
  937. // Remove brackets around the selector name
  938. $token = substr($token, 1, -1);
  939. }
  941. return $token;
  942. }
  944. /**
  945. * Parse something that is expected to be a property identifier.
  946. *
  947. * @param bool $checkSelector whether we need to ensure a valid selector.
  948. *
  949. * @return array with selectorName and propertyName. If no selectorName is
  950. * specified, defaults to $this->defaultSelectorName
  951. */
  952. private function parseIdentifier($checkSelector = true)
  953. {
  954. $token = $this->fetchTokenWithoutBrackets();
  956. // selector.property
  957. if ($this->scanner->lookupNextToken() === '.') {
  958. $selectorName = $token;
  959. $this->scanner->fetchNextToken();
  960. $propertyName = $this->fetchTokenWithoutBrackets();
  961. } else {
  962. $selectorName = null;
  963. $propertyName = $token;
  964. }
  966. if ($checkSelector) {
  967. $selectorName = $this->ensureSelectorName($selectorName);
  968. }
  970. return [$selectorName, $propertyName];
  971. }
  973. /**
  974. * Add a selector name to the known selector names.
  975. *
  976. * @param string $selectorName
  977. *
  978. * @throws InvalidQueryException
  979. */
  980. protected function updateImplicitSelectorName($selectorName)
  981. {
  982. if (null === $this->implicitSelectorName) {
  983. $this->implicitSelectorName = $selectorName;
  984. } else {
  985. if (!is_array($this->implicitSelectorName)) {
  986. $this->implicitSelectorName = [$this->implicitSelectorName => $this->implicitSelectorName];
  987. }
  988. if (isset($this->implicitSelectorName[$selectorName])) {
  989. throw new InvalidQueryException("Selector $selectorName is already in use");
  990. }
  991. $this->implicitSelectorName[$selectorName] = $selectorName;
  992. }
  993. }
  995. /**
  996. * Ensure that the parsedName is a valid selector, or return the implicit
  997. * selector if its non-ambigous.
  998. *
  999. * @param string|null $parsedName
  1000. *
  1001. * @throws InvalidQueryException if there was no explicit selector and
  1002. * there is more than one selector available.
  1003. *
  1004. * @return string the selector to use
  1005. */
  1006. protected function ensureSelectorName($parsedName)
  1007. {
  1008. if (null !== $parsedName) {
  1009. if (is_array($this->implicitSelectorName) && !isset($this->implicitSelectorName[$parsedName])
  1010. || !is_array($this->implicitSelectorName) && $this->implicitSelectorName !== $parsedName
  1011. ) {
  1012. throw new InvalidQueryException("Unknown selector $parsedName in '{$this->sql2}'");
  1013. }
  1015. return $parsedName;
  1016. }
  1017. if (is_array($this->implicitSelectorName)) {
  1018. throw new InvalidQueryException('Need an explicit selector name in join queries');
  1019. }
  1021. return $this->implicitSelectorName;
  1022. }
  1024. /**
  1025. * Scan a single SQL2 column definition and return an array of information.
  1026. *
  1027. * @return array
  1028. */
  1029. protected function scanColumn()
  1030. {
  1031. list($selectorName, $propertyName) = $this->parseIdentifier(false);
  1033. // AS name
  1034. if ($this->scanner->tokenIs($this->scanner->lookupNextToken(), 'AS')) {
  1035. $this->scanner->fetchNextToken();
  1036. $columnName = $this->scanner->fetchNextToken();
  1037. } else {
  1038. $columnName = $propertyName;
  1039. }
  1041. return [$selectorName, $propertyName, $columnName];
  1042. }
  1044. /**
  1045. * Build a single SQL2 column definition.
  1046. *
  1047. * @param array $data with selector name, property name and column name.
  1048. *
  1049. * @return ColumnInterface
  1050. */
  1051. protected function buildColumn(array $data)
  1052. {
  1053. list($selectorName, $propertyName, $columnName) = $data;
  1054. $selectorName = $this->ensureSelectorName($selectorName);
  1056. return $this->factory->column($selectorName, $propertyName, $columnName);
  1057. }
  1058. }