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

  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.      * Instantiate a converter.
  74.      *
  75.      * @param QueryObjectModelFactoryInterface $factory
  76.      * @param ValueConverter                   $valueConverter To override default converter.
  77.      */
  78.     public function __construct(QueryObjectModelFactoryInterface $factory, ValueConverter $valueConverter = null)
  79.     {
  80.         $this->factory = $factory;
  81.         $this->valueConverter = $valueConverter ?: new ValueConverter();
  82.     }
  84.     /**
  85.      * 6.7.1. Query
  86.      * Parse an SQL2 query and return the corresponding QOM QueryObjectModel.
  87.      *
  88.      * @param string $sql2
  89.      *
  90.      * @throws InvalidQueryException
  91.      *
  92.      * @return QueryObjectModelInterface
  93.      */
  94.     public function parse($sql2)
  95.     {
  96.         $this->implicitSelectorName = null;
  97.         $this->sql2 = $sql2;
  98.         $this->scanner = new Sql2Scanner($sql2);
  99.         $source = null;
  100.         $columnData = [];
  101.         $constraint = null;
  102.         $orderings = [];
  104.         while ($this->scanner->lookupNextToken() !== '') {
  105.             switch (strtoupper($this->scanner->lookupNextToken())) {
  106.                 case 'SELECT':
  107.                     $this->scanner->expectToken('SELECT');
  108.                     $columnData = $this->scanColumns();
  109.                     break;
  110.                 case 'FROM':
  111.                     $this->scanner->expectToken('FROM');
  112.                     $source = $this->parseSource();
  113.                     break;
  114.                 case 'WHERE':
  115.                     $this->scanner->expectToken('WHERE');
  116.                     $constraint = $this->parseConstraint();
  117.                     break;
  118.                 case 'ORDER':
  119.                     // Ordering, check there is a BY
  120.                     $this->scanner->expectTokens(['ORDER', 'BY']);
  121.                     $orderings = $this->parseOrderings();
  122.                     break;
  123.                 default:
  124.                     throw new InvalidQueryException('Error parsing query, unknown query part "'.$this->scanner->lookupNextToken().'" in: '.$this->sql2);
  125.             }
  126.         }
  128.         if (!$source instanceof SourceInterface) {
  129.             throw new InvalidQueryException('Invalid query, source could not be determined: '.$sql2);
  130.         }
  132.         $columns = $this->buildColumns($columnData);
  134.         return $this->factory->createQuery($source, $constraint, $orderings, $columns);
  135.     }
  137.     /**
  138.      * 6.7.2. Source
  139.      * Parse an SQL2 source definition and return the corresponding QOM Source.
  140.      *
  141.      * @return SourceInterface
  142.      */
  143.     protected function parseSource()
  144.     {
  145.         $selector = $this->parseSelector();
  147.         $next = $this->scanner->lookupNextToken();
  148.         $left = $selector;
  150.         while (in_array(strtoupper($next), ['JOIN', 'INNER', 'RIGHT', 'LEFT'])) {
  151.             $left = $this->parseJoin($left);
  152.             $next = $this->scanner->lookupNextToken();
  153.         }
  155.         return $left;
  156.     }
  158.     /**
  159.      * 6.7.3. Selector
  160.      * Parse an SQL2 selector and return a QOM\SelectorInterface.
  161.      *
  162.      * @return SelectorInterface
  163.      */
  164.     protected function parseSelector()
  165.     {
  166.         $nodetype = $this->fetchTokenWithoutBrackets();
  168.         if ($this->scanner->tokenIs($this->scanner->lookupNextToken(), 'AS')) {
  169.             $this->scanner->fetchNextToken(); // Consume the AS
  170.             $selectorName = $this->parseName();
  171.             $this->updateImplicitSelectorName($selectorName);
  173.             return $this->factory->selector($selectorName, $nodetype);
  174.         }
  175.         $this->updateImplicitSelectorName($nodetype);
  177.         return $this->factory->selector($nodetype, $nodetype);
  178.     }
  180.     /**
  181.      * 6.7.4. Name.
  182.      *
  183.      * @return string
  184.      */
  185.     protected function parseName()
  186.     {
  187.         return $this->scanner->fetchNextToken();
  188.     }
  190.     /**
  191.      * 6.7.5. Join
  192.      * 6.7.6. Join type
  193.      * Parse an SQL2 join source and return a QOM\Join.
  194.      *
  195.      * @param SourceInterface $leftSelector the left selector as it has been read by parseSource
  196.      *
  197.      * @return JoinInterface
  198.      */
  199.     protected function parseJoin(SourceInterface $leftSelector)
  200.     {
  201.         $joinType = $this->parseJoinType();
  202.         $right = $this->parseSelector();
  203.         $joinCondition = $this->parseJoinCondition();
  205.         return $this->factory->join($leftSelector, $right, $joinType, $joinCondition);
  206.     }
  208.     /**
  209.      * 6.7.6. Join type.
  210.      *
  211.      * @throws InvalidQueryException
  212.      *
  213.      * @return string
  214.      */
  215.     protected function parseJoinType()
  216.     {
  217.         $joinType = Constants::JCR_JOIN_TYPE_INNER;
  218.         $token = $this->scanner->fetchNextToken();
  220.         switch ($token) {
  221.             case 'JOIN':
  222.                 // Token already fetched, nothing to do
  223.                 break;
  224.             case 'INNER':
  225.                 $this->scanner->fetchNextToken();
  226.                 break;
  227.             case 'LEFT':
  228.                 $this->scanner->expectTokens(['OUTER', 'JOIN']);
  229.                 $joinType = Constants::JCR_JOIN_TYPE_LEFT_OUTER;
  230.                 break;
  231.             case 'RIGHT':
  232.                 $this->scanner->expectTokens(['OUTER', 'JOIN']);
  233.                 $joinType = Constants::JCR_JOIN_TYPE_RIGHT_OUTER;
  234.                 break;
  235.             default:
  236.                 throw new InvalidQueryException("Syntax error: Expected JOIN, INNER JOIN, RIGHT JOIN or LEFT JOIN in '{$this->sql2}'");
  237.         }
  239.         return $joinType;
  240.     }
  242.     /**
  243.      * 6.7.7. JoinCondition
  244.      * Parse an SQL2 join condition and return a JoinConditionInterface.
  245.      *
  246.      * @return JoinConditionInterface
  247.      */
  248.     protected function parseJoinCondition()
  249.     {
  250.         $this->scanner->expectToken('ON');
  252.         $token = $this->scanner->lookupNextToken();
  253.         if ($this->scanner->tokenIs($token, 'ISSAMENODE')) {
  254.             return $this->parseSameNodeJoinCondition();
  255.         }
  257.         if ($this->scanner->tokenIs($token, 'ISCHILDNODE')) {
  258.             return $this->parseChildNodeJoinCondition();
  259.         }
  261.         if ($this->scanner->tokenIs($token, 'ISDESCENDANTNODE')) {
  262.             return $this->parseDescendantNodeJoinCondition();
  263.         }
  265.         return $this->parseEquiJoin();
  266.     }
  268.     /**
  269.      * 6.7.8. EquiJoinCondition
  270.      * Parse an SQL2 equijoin condition and return a EquiJoinConditionInterface.
  271.      *
  272.      * @return EquiJoinConditionInterface
  273.      */
  274.     protected function parseEquiJoin()
  275.     {
  276.         list($selectorName1, $prop1) = $this->parseIdentifier();
  277.         $this->scanner->expectToken('=');
  278.         list($selectorName2, $prop2) = $this->parseIdentifier();
  280.         return $this->factory->equiJoinCondition($selectorName1, $prop1, $selectorName2, $prop2);
  281.     }
  283.     /**
  284.      * 6.7.9 SameNodeJoinCondition
  285.      * Parse an SQL2 same node join condition and return a SameNodeJoinConditionInterface.
  286.      *
  287.      * @return SameNodeJoinConditionInterface
  288.      */
  289.     protected function parseSameNodeJoinCondition()
  290.     {
  291.         $this->scanner->expectTokens(['ISSAMENODE', '(']);
  292.         $selectorName1 = $this->fetchTokenWithoutBrackets();
  293.         $this->scanner->expectToken(',');
  294.         $selectorName2 = $this->fetchTokenWithoutBrackets();
  296.         $token = $this->scanner->lookupNextToken();
  297.         if ($this->scanner->tokenIs($token, ',')) {
  298.             $this->scanner->fetchNextToken(); // consume the coma
  299.             $path = $this->parsePath();
  300.         } else {
  301.             $path = null;
  302.         }
  304.         $this->scanner->expectToken(')');
  306.         return $this->factory->sameNodeJoinCondition($selectorName1, $selectorName2, $path);
  307.     }
  309.     /**
  310.      * 6.7.10 ChildNodeJoinCondition
  311.      * Parse an SQL2 child node join condition and return a ChildNodeJoinConditionInterface.
  312.      *
  313.      * @return ChildNodeJoinConditionInterface
  314.      */
  315.     protected function parseChildNodeJoinCondition()
  316.     {
  317.         $this->scanner->expectTokens(['ISCHILDNODE', '(']);
  318.         $child = $this->fetchTokenWithoutBrackets();
  319.         $this->scanner->expectToken(',');
  320.         $parent = $this->fetchTokenWithoutBrackets();
  321.         $this->scanner->expectToken(')');
  323.         return $this->factory->childNodeJoinCondition($child, $parent);
  324.     }
  326.     /**
  327.      * 6.7.11 DescendantNodeJoinCondition
  328.      * Parse an SQL2 descendant node join condition and return a DescendantNodeJoinConditionInterface.
  329.      *
  330.      * @return DescendantNodeJoinConditionInterface
  331.      */
  332.     protected function parseDescendantNodeJoinCondition()
  333.     {
  334.         $this->scanner->expectTokens(['ISDESCENDANTNODE', '(']);
  335.         $descendant = $this->fetchTokenWithoutBrackets();
  336.         $this->scanner->expectToken(',');
  337.         $parent = $this->fetchTokenWithoutBrackets();
  338.         $this->scanner->expectToken(')');
  340.         return $this->factory->descendantNodeJoinCondition($descendant, $parent);
  341.     }
  343.     /**
  344.      * 6.7.13 And
  345.      * 6.7.14 Or.
  346.      *
  347.      * @param ConstraintInterface $lhs     Left hand side
  348.      * @param int                 $minprec Precedence
  349.      *
  350.      * @throws Exception
  351.      *
  352.      * @return ConstraintInterface
  353.      */
  354.     protected function parseConstraint($lhs = null, $minprec = 0)
  355.     {
  356.         if ($lhs === null) {
  357.             $lhs = $this->parsePrimaryConstraint();
  358.         }
  360.         $opprec = [
  361.             'OR'  => 1,
  362.             'AND' => 2,
  363.         ];
  365.         $op = strtoupper($this->scanner->lookupNextToken());
  366.         while (isset($opprec[$op]) && $opprec[$op] >= $minprec) {
  367.             $this->scanner->fetchNextToken();
  369.             $rhs = $this->parsePrimaryConstraint();
  371.             $nextop = strtoupper($this->scanner->lookupNextToken());
  373.             while (isset($opprec[$nextop]) && $opprec[$nextop] > $opprec[$op]) {
  374.                 $rhs = $this->parseConstraint($rhs, $opprec[$nextop]);
  375.                 $nextop = strtoupper($this->scanner->lookupNextToken());
  376.             }
  378.             switch ($op) {
  379.                 case 'AND':
  380.                     $lhs = $this->factory->andConstraint($lhs, $rhs);
  381.                     break;
  382.                 case 'OR':
  383.                     $lhs = $this->factory->orConstraint($lhs, $rhs);
  384.                     break;
  385.                 default:
  386.                     // this only happens if the operator is
  387.                     // in the $opprec-array but there is no
  388.                     // "elseif"-branch here for this operator.
  389.                     throw new Exception("Internal error: No action is defined for operator '$op'");
  390.             }
  392.             $op = strtoupper($this->scanner->lookupNextToken());
  393.         }
  395.         return $lhs;
  396.     }
  398.     /**
  399.      * 6.7.12 Constraint.
  400.      *
  401.      * @return ConstraintInterface
  402.      */
  403.     protected function parsePrimaryConstraint()
  404.     {
  405.         $constraint = null;
  406.         $token = $this->scanner->lookupNextToken();
  408.         if ($this->scanner->tokenIs($token, 'NOT')) {
  409.             // NOT
  410.             $constraint = $this->parseNot();
  411.         } elseif ($this->scanner->tokenIs($token, '(')) {
  412.             // Grouping with parenthesis
  413.             $this->scanner->expectToken('(');
  414.             $constraint = $this->parseConstraint();
  415.             $this->scanner->expectToken(')');
  416.         } elseif ($this->scanner->tokenIs($token, 'CONTAINS')) {
  417.             // Full Text Search
  418.             $constraint = $this->parseFullTextSearch();
  419.         } elseif ($this->scanner->tokenIs($token, 'ISSAMENODE')) {
  420.             // SameNode
  421.             $constraint = $this->parseSameNode();
  422.         } elseif ($this->scanner->tokenIs($token, 'ISCHILDNODE')) {
  423.             // ChildNode
  424.             $constraint = $this->parseChildNode();
  425.         } elseif ($this->scanner->tokenIs($token, 'ISDESCENDANTNODE')) {
  426.             // DescendantNode
  427.             $constraint = $this->parseDescendantNode();
  428.         } else {
  429.             // Is it a property existence?
  430.             $next1 = $this->scanner->lookupNextToken(1);
  431.             if ($this->scanner->tokenIs($next1, 'IS')) {
  432.                 $constraint = $this->parsePropertyExistence();
  433.             } elseif ($this->scanner->tokenIs($next1, '.')) {
  434.                 $next2 = $this->scanner->lookupNextToken(3);
  435.                 if ($this->scanner->tokenIs($next2, 'IS')) {
  436.                     $constraint = $this->parsePropertyExistence();
  437.                 }
  438.             }
  440.             if ($constraint === null) {
  441.                 // It's not a property existence neither, then it's a comparison
  442.                 $constraint = $this->parseComparison();
  443.             }
  444.         }
  446.         // No constraint read,
  447.         if ($constraint === null) {
  448.             throw new InvalidQueryException("Syntax error: constraint expected in '{$this->sql2}'");
  449.         }
  451.         return $constraint;
  452.     }
  454.     /**
  455.      * 6.7.15 Not.
  456.      *
  457.      * @return NotInterface
  458.      */
  459.     protected function parseNot()
  460.     {
  461.         $this->scanner->expectToken('NOT');
  463.         return $this->factory->notConstraint($this->parsePrimaryConstraint());
  464.     }
  466.     /**
  467.      * 6.7.16 Comparison.
  468.      *
  469.      * @throws InvalidQueryException
  470.      *
  471.      * @return ComparisonInterface
  472.      */
  473.     protected function parseComparison()
  474.     {
  475.         $op1 = $this->parseDynamicOperand();
  477.         if (null === $op1) {
  478.             throw new InvalidQueryException("Syntax error: dynamic operator expected in '{$this->sql2}'");
  479.         }
  481.         $operator = $this->parseOperator();
  482.         $op2 = $this->parseStaticOperand();
  484.         return $this->factory->comparison($op1, $operator, $op2);
  485.     }
  487.     /**
  488.      * 6.7.17 Operator.
  489.      *
  490.      * @return string a constant from QueryObjectModelConstantsInterface
  491.      */
  492.     protected function parseOperator()
  493.     {
  494.         $token = $this->scanner->fetchNextToken();
  495.         switch (strtoupper($token)) {
  496.             case '=':
  497.                 return Constants::JCR_OPERATOR_EQUAL_TO;
  498.             case '<>':
  499.                 return Constants::JCR_OPERATOR_NOT_EQUAL_TO;
  500.             case '<':
  501.                 return Constants::JCR_OPERATOR_LESS_THAN;
  502.             case '<=':
  503.                 return Constants::JCR_OPERATOR_LESS_THAN_OR_EQUAL_TO;
  504.             case '>':
  505.                 return Constants::JCR_OPERATOR_GREATER_THAN;
  506.             case '>=':
  507.                 return Constants::JCR_OPERATOR_GREATER_THAN_OR_EQUAL_TO;
  508.             case 'LIKE':
  509.                 return Constants::JCR_OPERATOR_LIKE;
  510.         }
  512.         throw new InvalidQueryException("Syntax error: operator expected in '{$this->sql2}'");
  513.     }
  515.     /**
  516.      * 6.7.18 PropertyExistence.
  517.      *
  518.      * @return ConstraintInterface
  519.      */
  520.     protected function parsePropertyExistence()
  521.     {
  522.         list($selectorName, $prop) = $this->parseIdentifier();
  524.         $this->scanner->expectToken('IS');
  525.         $token = $this->scanner->lookupNextToken();
  526.         if ($this->scanner->tokenIs($token, 'NULL')) {
  527.             $this->scanner->fetchNextToken();
  529.             return $this->factory->notConstraint($this->factory->propertyExistence($selectorName, $prop));
  530.         }
  532.         $this->scanner->expectTokens(['NOT', 'NULL']);
  534.         return $this->factory->propertyExistence($selectorName, $prop);
  535.     }
  537.     /**
  538.      * 6.7.19 FullTextSearch.
  539.      *
  540.      * @return FullTextSearchInterface
  541.      */
  542.     protected function parseFullTextSearch()
  543.     {
  544.         $this->scanner->expectTokens(['CONTAINS', '(']);
  546.         list($selectorName, $propertyName) = $this->parseIdentifier();
  547.         $this->scanner->expectToken(',');
  548.         $expression = $this->parseLiteralValue();
  549.         $this->scanner->expectToken(')');
  551.         return $this->factory->fullTextSearch($selectorName, $propertyName, $expression);
  552.     }
  554.     /**
  555.      * 6.7.20 SameNode.
  556.      */
  557.     protected function parseSameNode()
  558.     {
  559.         $this->scanner->expectTokens(['ISSAMENODE', '(']);
  560.         if ($this->scanner->tokenIs($this->scanner->lookupNextToken(1), ',')) {
  561.             $selectorName = $this->scanner->fetchNextToken();
  562.             $this->scanner->expectToken(',');
  563.             $path = $this->parsePath();
  564.         } else {
  565.             $selectorName = $this->implicitSelectorName;
  566.             $path = $this->parsePath();
  567.         }
  568.         $this->scanner->expectToken(')');
  570.         return $this->factory->sameNode($selectorName, $path);
  571.     }
  573.     /**
  574.      * 6.7.21 ChildNode.
  575.      */
  576.     protected function parseChildNode()
  577.     {
  578.         $this->scanner->expectTokens(['ISCHILDNODE', '(']);
  579.         if ($this->scanner->tokenIs($this->scanner->lookupNextToken(1), ',')) {
  580.             $selectorName = $this->scanner->fetchNextToken();
  581.             $this->scanner->expectToken(',');
  582.             $path = $this->parsePath();
  583.         } else {
  584.             $selectorName = $this->implicitSelectorName;
  585.             $path = $this->parsePath();
  586.         }
  587.         $this->scanner->expectToken(')');
  589.         return $this->factory->childNode($selectorName, $path);
  590.     }
  592.     /**
  593.      * 6.7.22 DescendantNode.
  594.      */
  595.     protected function parseDescendantNode()
  596.     {
  597.         $this->scanner->expectTokens(['ISDESCENDANTNODE', '(']);
  598.         if ($this->scanner->tokenIs($this->scanner->lookupNextToken(1), ',')) {
  599.             $selectorName = $this->scanner->fetchNextToken();
  600.             $this->scanner->expectToken(',');
  601.             $path = $this->parsePath();
  602.         } else {
  603.             $selectorName = $this->implicitSelectorName;
  604.             $path = $this->parsePath();
  605.         }
  606.         $this->scanner->expectToken(')');
  608.         return $this->factory->descendantNode($selectorName, $path);
  609.     }
  611.     /**
  612.      * Parse a JCR path consisting of either a simple path (a JCR name that contains
  613.      * only SQL-legal characters) or a path (simple path or quoted path) enclosed in
  614.      * square brackets. See JCR Spec § 6.7.23.
  615.      *
  616.      * 6.7.23. Path
  617.      */
  618.     protected function parsePath()
  619.     {
  620.         $path = $this->parseLiteralValue();
  621.         if (substr($path, 0, 1) === '[' && substr($path, -1) === ']') {
  622.             $path = substr($path, 1, -1);
  623.         }
  625.         return $path;
  626.     }
  628.     /**
  629.      * Parse an SQL2 static operand
  630.      * 6.7.35 BindVariable
  631.      * 6.7.36 Prefix.
  632.      *
  633.      * @return StaticOperandInterface
  634.      */
  635.     protected function parseStaticOperand()
  636.     {
  637.         $token = $this->scanner->lookupNextToken();
  638.         if (substr($token, 0, 1) === '$') {
  639.             return $this->factory->bindVariable(substr($this->scanner->fetchNextToken(), 1));
  640.         }
  642.         return $this->factory->literal($this->parseLiteralValue());
  643.     }
  645.     /**
  646.      * 6.7.26 DynamicOperand
  647.      * 6.7.28 Length
  648.      * 6.7.29 NodeName
  649.      * 6.7.30 NodeLocalName
  650.      * 6.7.31 FullTextSearchScore
  651.      * 6.7.32 LowerCase
  652.      * 6.7.33 UpperCase
  653.      * Parse an SQL2 dynamic operand.
  654.      *
  655.      * @return DynamicOperandInterface
  656.      */
  657.     protected function parseDynamicOperand()
  658.     {
  659.         $token = $this->scanner->lookupNextToken();
  661.         if ($this->scanner->tokenIs($token, 'LENGTH')) {
  662.             $this->scanner->fetchNextToken();
  663.             $this->scanner->expectToken('(');
  664.             $val = $this->parsePropertyValue();
  665.             $this->scanner->expectToken(')');
  667.             return $this->factory->length($val);
  668.         }
  670.         if ($this->scanner->tokenIs($token, 'NAME')) {
  671.             $this->scanner->fetchNextToken();
  672.             $this->scanner->expectToken('(');
  674.             $token = $this->scanner->fetchNextToken();
  675.             if ($this->scanner->tokenIs($token, ')')) {
  676.                 return $this->factory->nodeName($this->implicitSelectorName);
  677.             }
  679.             $this->scanner->expectToken(')');
  681.             return $this->factory->nodeName($token);
  682.         }
  684.         if ($this->scanner->tokenIs($token, 'LOCALNAME')) {
  685.             $this->scanner->fetchNextToken();
  686.             $this->scanner->expectToken('(');
  688.             $token = $this->scanner->fetchNextToken();
  689.             if ($this->scanner->tokenIs($token, ')')) {
  690.                 return $this->factory->nodeLocalName($this->implicitSelectorName);
  691.             }
  693.             $this->scanner->expectToken(')');
  695.             return $this->factory->nodeLocalName($token);
  696.         }
  698.         if ($this->scanner->tokenIs($token, 'SCORE')) {
  699.             $this->scanner->fetchNextToken();
  700.             $this->scanner->expectToken('(');
  702.             $token = $this->scanner->fetchNextToken();
  703.             if ($this->scanner->tokenIs($token, ')')) {
  704.                 return $this->factory->fullTextSearchScore($this->implicitSelectorName);
  705.             }
  707.             $this->scanner->expectToken(')');
  709.             return $this->factory->fullTextSearchScore($token);
  710.         }
  712.         if ($this->scanner->tokenIs($token, 'LOWER')) {
  713.             $this->scanner->fetchNextToken();
  714.             $this->scanner->expectToken('(');
  715.             $op = $this->parseDynamicOperand();
  716.             $this->scanner->expectToken(')');
  718.             return $this->factory->lowerCase($op);
  719.         }
  721.         if ($this->scanner->tokenIs($token, 'UPPER')) {
  722.             $this->scanner->fetchNextToken();
  723.             $this->scanner->expectToken('(');
  724.             $op = $this->parseDynamicOperand();
  725.             $this->scanner->expectToken(')');
  727.             return $this->factory->upperCase($op);
  728.         }
  730.         return $this->parsePropertyValue();
  731.     }
  733.     /**
  734.      * 6.7.27 PropertyValue
  735.      * Parse an SQL2 property value.
  736.      *
  737.      * @return PropertyValueInterface
  738.      */
  739.     protected function parsePropertyValue()
  740.     {
  741.         list($selectorName, $prop) = $this->parseIdentifier();
  743.         return $this->factory->propertyValue($selectorName, $prop);
  744.     }
  746.     protected function parseCastLiteral($token)
  747.     {
  748.         if (!$this->scanner->tokenIs($token, 'CAST')) {
  749.             throw new LogicException('parseCastLiteral when not a CAST');
  750.         }
  752.         $this->scanner->expectToken('(');
  753.         $token = $this->scanner->fetchNextToken();
  755.         $quoteString = in_array($token[0], ['\'', '"'], true);
  757.         if ($quoteString) {
  758.             $quotesUsed = $token[0];
  759.             $token = substr($token, 1, -1);
  760.             // Un-escaping quotes
  761.             $token = str_replace('\\'.$quotesUsed, $quotesUsed, $token);
  762.         }
  764.         $this->scanner->expectToken('AS');
  766.         $type = $this->scanner->fetchNextToken();
  768.         try {
  769.             $typeValue = PropertyType::valueFromName($type);
  770.         } catch (InvalidArgumentException $e) {
  771.             throw new InvalidQueryException("Syntax error: attempting to cast to an invalid type '$type'");
  772.         }
  774.         $this->scanner->expectToken(')');
  776.         try {
  777.             $token = $this->valueConverter->convertType($token, $typeValue, PropertyType::STRING);
  778.         } catch (Exception $e) {
  779.             throw new InvalidQueryException("Syntax error: attempting to cast string '$token' to type '$type'");
  780.         }
  782.         return $token;
  783.     }
  785.     /**
  786.      * 6.7.34 Literal
  787.      * Parse an SQL2 literal value.
  788.      *
  789.      * @return mixed
  790.      */
  791.     protected function parseLiteralValue()
  792.     {
  793.         $token = $this->scanner->fetchNextToken();
  794.         if ($this->scanner->tokenIs($token, 'CAST')) {
  795.             return $this->parseCastLiteral($token);
  796.         }
  798.         $quoteString = in_array($token[0], ['"', "'"], true);
  800.         if ($quoteString) {
  801.             $quotesUsed = $token[0];
  802.             $token = substr($token, 1, -1);
  803.             // Unescape quotes
  804.             $token = str_replace('\\'.$quotesUsed, $quotesUsed, $token);
  805.             $token = str_replace("''", "'", $token);
  806.             if (preg_match('/^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d+)?$/', $token)) {
  807.                 if (preg_match('/^\d{4}-\d{2}-\d{2}$/', $token)) {
  808.                     $token .= ' 00:00:00';
  809.                 }
  810.                 $token = DateTime::createFromFormat('Y-m-d H:i:s', $token);
  811.             }
  812.         } elseif (is_numeric($token)) {
  813.             $token = strpos($token, '.') === false ? (int) $token : (float) $token;
  814.         } elseif ($token === 'true') {
  815.             $token = true;
  816.         } elseif ($token === 'false') {
  817.             $token = false;
  818.         }
  820.         return $token;
  821.     }
  823.     /**
  824.      * 6.7.37 Ordering.
  825.      */
  826.     protected function parseOrderings()
  827.     {
  828.         $orderings = [];
  829.         $continue = true;
  831.         while ($continue) {
  832.             $orderings[] = $this->parseOrdering();
  833.             if ($this->scanner->tokenIs($this->scanner->lookupNextToken(), ',')) {
  834.                 $this->scanner->expectToken(',');
  835.             } else {
  836.                 $continue = false;
  837.             }
  838.         }
  840.         return $orderings;
  841.     }
  843.     /**
  844.      * 6.7.38 Order.
  845.      *
  846.      * @return OrderingInterface
  847.      */
  848.     protected function parseOrdering()
  849.     {
  850.         $operand = $this->parseDynamicOperand();
  851.         $token = $this->scanner->lookupNextToken();
  853.         if ($this->scanner->tokenIs($token, 'DESC')) {
  854.             $this->scanner->expectToken('DESC');
  856.             return $this->factory->descending($operand);
  857.         }
  859.         if ($this->scanner->tokenIs($token, 'ASC') || ',' === $token || '' === $token) {
  860.             if ($this->scanner->tokenIs($token, 'ASC')) {
  861.                 $this->scanner->expectToken('ASC');
  862.             }
  864.             return $this->factory->ascending($operand);
  865.         }
  867.         throw new InvalidQueryException("Syntax error: invalid ordering in '{$this->sql2}'");
  868.     }
  870.     /**
  871.      * 6.7.39 Column.
  872.      *
  873.      * Scan the SQL2 columns definitions and return data arrays to convert to
  874.      * columns once the FROM is parsed.
  875.      *
  876.      * @return array of array
  877.      */
  878.     protected function scanColumns()
  879.     {
  880.         // Wildcard
  881.         if ($this->scanner->lookupNextToken() === '*') {
  882.             $this->scanner->fetchNextToken();
  884.             return [];
  885.         }
  887.         $columns = [];
  888.         $hasNext = true;
  890.         while ($hasNext) {
  891.             $columns[] = $this->scanColumn();
  893.             // Are there more columns?
  894.             if ($this->scanner->lookupNextToken() !== ',') {
  895.                 $hasNext = false;
  896.             } else {
  897.                 $this->scanner->fetchNextToken();
  898.             }
  899.         }
  901.         return $columns;
  902.     }
  904.     /**
  905.      * Build the columns from the scanned column data.
  906.      *
  907.      * @param array $data
  908.      *
  909.      * @return ColumnInterface[]
  910.      */
  911.     protected function buildColumns($data)
  912.     {
  913.         $columns = [];
  914.         foreach ($data as $col) {
  915.             $columns[] = $this->buildColumn($col);
  916.         }
  918.         return $columns;
  919.     }
  921.     /**
  922.      * Get the next token and make sure to remove the brackets if the token is
  923.      * in the [ns:name] notation.
  924.      *
  925.      * @return string
  926.      */
  927.     private function fetchTokenWithoutBrackets()
  928.     {
  929.         $token = $this->scanner->fetchNextToken();
  931.         if (substr($token, 0, 1) === '[' && substr($token, -1) === ']') {
  932.             // Remove brackets around the selector name
  933.             $token = substr($token, 1, -1);
  934.         }
  936.         return $token;
  937.     }
  939.     /**
  940.      * Parse something that is expected to be a property identifier.
  941.      *
  942.      * @param bool $checkSelector whether we need to ensure a valid selector.
  943.      *
  944.      * @return array with selectorName and propertyName. If no selectorName is
  945.      *               specified, defaults to $this->defaultSelectorName
  946.      */
  947.     private function parseIdentifier($checkSelector = true)
  948.     {
  949.         $token = $this->fetchTokenWithoutBrackets();
  951.         // selector.property
  952.         if ($this->scanner->lookupNextToken() === '.') {
  953.             $selectorName = $token;
  954.             $this->scanner->fetchNextToken();
  955.             $propertyName = $this->fetchTokenWithoutBrackets();
  956.         } else {
  957.             $selectorName = null;
  958.             $propertyName = $token;
  959.         }
  961.         if ($checkSelector) {
  962.             $selectorName = $this->ensureSelectorName($selectorName);
  963.         }
  965.         return [$selectorName, $propertyName];
  966.     }
  968.     /**
  969.      * Add a selector name to the known selector names.
  970.      *
  971.      * @param string $selectorName
  972.      *
  973.      * @throws InvalidQueryException
  974.      */
  975.     protected function updateImplicitSelectorName($selectorName)
  976.     {
  977.         if (null === $this->implicitSelectorName) {
  978.             $this->implicitSelectorName = $selectorName;
  979.         } else {
  980.             if (!is_array($this->implicitSelectorName)) {
  981.                 $this->implicitSelectorName = [$this->implicitSelectorName => $this->implicitSelectorName];
  982.             }
  983.             if (isset($this->implicitSelectorName[$selectorName])) {
  984.                 throw new InvalidQueryException("Selector $selectorName is already in use");
  985.             }
  986.             $this->implicitSelectorName[$selectorName] = $selectorName;
  987.         }
  988.     }
  990.     /**
  991.      * Ensure that the parsedName is a valid selector, or return the implicit
  992.      * selector if its non-ambigous.
  993.      *
  994.      * @param string|null $parsedName
  995.      *
  996.      * @throws InvalidQueryException if there was no explicit selector and
  997.      *                               there is more than one selector available.
  998.      *
  999.      * @return string the selector to use
  1000.      */
  1001.     protected function ensureSelectorName($parsedName)
  1002.     {
  1003.         if (null !== $parsedName) {
  1004.             if (is_array($this->implicitSelectorName) && !isset($this->implicitSelectorName[$parsedName])
  1005.                 || !is_array($this->implicitSelectorName) && $this->implicitSelectorName !== $parsedName
  1006.             ) {
  1007.                 throw new InvalidQueryException("Unknown selector $parsedName in '{$this->sql2}'");
  1008.             }
  1010.             return $parsedName;
  1011.         }
  1012.         if (is_array($this->implicitSelectorName)) {
  1013.             throw new InvalidQueryException('Need an explicit selector name in join queries');
  1014.         }
  1016.         return $this->implicitSelectorName;
  1017.     }
  1019.     /**
  1020.      * Scan a single SQL2 column definition and return an array of information.
  1021.      *
  1022.      * @return array
  1023.      */
  1024.     protected function scanColumn()
  1025.     {
  1026.         list($selectorName, $propertyName) = $this->parseIdentifier(false);
  1028.         // AS name
  1029.         if ($this->scanner->tokenIs($this->scanner->lookupNextToken(), 'AS')) {
  1030.             $this->scanner->fetchNextToken();
  1031.             $columnName = $this->scanner->fetchNextToken();
  1032.         } else {
  1033.             $columnName = $propertyName;
  1034.         }
  1036.         return [$selectorName, $propertyName, $columnName];
  1037.     }
  1039.     /**
  1040.      * Build a single SQL2 column definition.
  1041.      *
  1042.      * @param array $data with selector name, property name and column name.
  1043.      *
  1044.      * @return ColumnInterface
  1045.      */
  1046.     protected function buildColumn(array $data)
  1047.     {
  1048.         list($selectorName, $propertyName, $columnName) = $data;
  1049.         $selectorName = $this->ensureSelectorName($selectorName);
  1051.         return $this->factory->column($selectorName, $propertyName, $columnName);
  1052.     }
  1053. }