vendor/jackalope/jackalope-doctrine-dbal/src/Jackalope/Transport/DoctrineDBAL/Query/QOMWalker.php line 202

  1. <?php
  3. namespace Jackalope\Transport\DoctrineDBAL\Query;
  5. use BadMethodCallException;
  6. use DateTime;
  7. use DateTimeZone;
  8. use Doctrine\DBAL\Platforms\MySQLPlatform;
  9. use Doctrine\DBAL\Platforms\PostgreSqlPlatform;
  10. use Doctrine\DBAL\Platforms\PostgreSQL94Platform;
  11. use Doctrine\DBAL\Schema\Schema;
  12. use Jackalope\NotImplementedException;
  13. use Jackalope\Query\QOM\PropertyValue;
  14. use Jackalope\Query\QOM\QueryObjectModel;
  15. use Jackalope\Transport\DoctrineDBAL\RepositorySchema;
  16. use Jackalope\Transport\DoctrineDBAL\Util\Xpath;
  17. use PHPCR\NamespaceException;
  18. use PHPCR\NodeType\NodeTypeInterface;
  19. use PHPCR\NodeType\NodeTypeManagerInterface;
  20. use PHPCR\Query\InvalidQueryException;
  21. use PHPCR\Query\QOM;
  22. use Doctrine\DBAL\Connection;
  23. use Doctrine\DBAL\Platforms\AbstractPlatform;
  24. use Doctrine\DBAL\Platforms\SqlitePlatform;
  26. /**
  27.  * Converts QOM to SQL Statements for the Doctrine DBAL database backend.
  28.  *
  29.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  30.  * @license http://opensource.org/licenses/MIT MIT License
  31.  */
  32. class QOMWalker
  33. {
  34.     /**
  35.      * @var NodeTypeManagerInterface
  36.      */
  37.     private $nodeTypeManager;
  39.     /**
  40.      * @var array
  41.      */
  42.     private $alias = [];
  44.     /**
  45.      * @var QOM\SelectorInterface
  46.      */
  47.     private $source;
  49.     /**
  50.      * @var Connection
  51.      */
  52.     private $conn;
  54.     /**
  55.      * @var AbstractPlatform
  56.      */
  57.     private $platform;
  59.     /**
  60.      * @var array
  61.      */
  62.     private $namespaces;
  64.     /**
  65.      * @var Schema
  66.      */
  67.     private $schema;
  69.     /**
  70.      * @param NodeTypeManagerInterface $manager
  71.      * @param Connection               $conn
  72.      * @param array                    $namespaces
  73.      */
  74.     public function __construct(NodeTypeManagerInterface $manager, Connection $conn, array $namespaces = [])
  75.     {
  76.         $this->conn = $conn;
  77.         $this->nodeTypeManager = $manager;
  78.         $this->platform = $conn->getDatabasePlatform();
  79.         $this->namespaces = $namespaces;
  80.         $this->schema = new RepositorySchema([], $this->conn);
  81.     }
  83.     /**
  84.      * Generate a table alias
  85.      *
  86.      * @param string $selectorName
  87.      *
  88.      * @return string
  89.      */
  90.     private function getTableAlias($selectorName)
  91.     {
  92.         $selectorAlias = $this->getSelectorAlias($selectorName);
  94.         if (!isset($this->alias[$selectorAlias])) {
  95.             $this->alias[$selectorAlias] = 'n' . count($this->alias);
  96.         }
  98.         return $this->alias[$selectorAlias];
  99.     }
  101.     /**
  102.      * @param string $selectorName
  103.      *
  104.      * @return string
  105.      */
  106.     private function getSelectorAlias($selectorName)
  107.     {
  108.         if (null === $selectorName) {
  109.             if (count($this->alias)) { // We have aliases, use the first
  110.                 $selectorAlias = array_search('n0', $this->alias);
  111.             } else { // Currently no aliases, use an empty string as index
  112.                 $selectorAlias = '';
  113.             }
  114.         } elseif (strpos($selectorName, '.') === false) {
  115.             $selectorAlias = $selectorName;
  116.         } else {
  117.             $parts = explode('.', $selectorName);
  118.             $selectorAlias = reset($parts);
  119.         }
  121.         if (strpos($selectorAlias, '[') === 0) {
  122.             $selectorAlias = substr($selectorAlias, 1, -1);
  123.         }
  125.         if ($this->source && $this->source->getNodeTypeName() === $selectorAlias) {
  126.             $selectorAlias = '';
  127.         }
  129.         return $selectorAlias;
  130.     }
  132.     /**
  133.      * @param QueryObjectModel $qom
  134.      *
  135.      * @return string
  136.      */
  137.     public function walkQOMQuery(QueryObjectModel $qom)
  138.     {
  139.         $source = $qom->getSource();
  140.         $selectors = $this->validateSource($source);
  142.         $sourceSql = ' ' . $this->walkSource($source);
  143.         $constraintSql = '';
  144.         if ($constraint = $qom->getConstraint()) {
  145.             $constraintSql = ' AND ' . $this->walkConstraint($constraint);
  146.         }
  148.         $orderingSql = '';
  149.         if ($orderings = $qom->getOrderings()) {
  150.             $orderingSql = ' ' . $this->walkOrderings($orderings);
  151.         }
  153.         $sql = 'SELECT ' . $this->getColumns($qom);
  154.         $sql .= $sourceSql;
  155.         $sql .= $constraintSql;
  156.         $sql .= $orderingSql;
  158.         $limit = $qom->getLimit();
  159.         $offset = $qom->getOffset();
  161.         if (null !== $offset && null === $limit
  162.             && ($this->platform instanceof MySQLPlatform || $this->platform instanceof SqlitePlatform)
  163.         ) {
  164.             $limit = PHP_INT_MAX;
  165.         }
  166.         $sql = $this->platform->modifyLimitQuery($sql, $limit, $offset);
  168.         return [$selectors, $this->alias, $sql];
  169.     }
  171.     /**
  172.      * @return string
  173.      */
  174.     public function getColumns(QueryObjectModel $qom)
  175.     {
  176.         // TODO we should actually build Xpath statements for each column we actually need in the result and not fetch all 'props'
  177.         $sqlColumns = ['path', 'identifier', 'props'];
  179.         if (count($this->alias)) {
  180.             $aliasSql = [];
  181.             foreach ($this->alias as $alias) {
  182.                 foreach ($sqlColumns as $sqlColumn) {
  183.                     $aliasSql[] = sprintf('%s.%s AS %s_%s', $alias, $sqlColumn, $alias, $sqlColumn);
  184.                 }
  185.             }
  187.             return implode(', ', $aliasSql);
  188.         }
  190.         return '*';
  191.     }
  193.     /**
  194.      * Validates the nodeTypes in given source
  195.      *
  196.      * @param QOM\SourceInterface $source
  197.      *
  198.      * @return QOM\SelectorInterface[]
  199.      *
  200.      * @throws InvalidQueryException
  201.      */
  202.     protected function validateSource(QOM\SourceInterface $source)
  203.     {
  204.         if ($source instanceof QOM\SelectorInterface) {
  205.             $selectors = [$source];
  206.             $this->validateSelectorSource($source);
  207.         } elseif ($source instanceof QOM\JoinInterface) {
  208.             $selectors = $this->validateJoinSource($source);
  209.         } else {
  210.             $selectors = [];
  211.         }
  213.         return $selectors;
  214.     }
  216.     /**
  217.      * @param QOM\SelectorInterface $source
  218.      *
  219.      * @throws InvalidQueryException
  220.      */
  221.     protected function validateSelectorSource(QOM\SelectorInterface $source)
  222.     {
  223.         $nodeType = $source->getNodeTypeName();
  225.         if (!$this->nodeTypeManager->hasNodeType($nodeType)) {
  226.             $msg = 'Selected node type does not exist: ' . $nodeType;
  227.             if ($alias = $source->getSelectorName()) {
  228.                 $msg .= ' AS ' . $alias;
  229.             }
  231.             throw new InvalidQueryException($msg);
  232.         }
  233.     }
  235.     /**
  236.      * @param QOM\JoinInterface $source
  237.      *
  238.      * @return QOM\SelectorInterface[]
  239.      *
  240.      * @throws InvalidQueryException
  241.      */
  242.     protected function validateJoinSource(QOM\JoinInterface $source)
  243.     {
  244.         $left = $source->getLeft();
  245.         $right = $source->getRight();
  247.         if ($left) {
  248.             $selectors = $this->validateSource($left);
  249.         } else {
  250.             $selectors = [];
  251.         }
  253.         if ($right) {
  254.             // Ensure that the primary selector is first
  255.             if (QOM\QueryObjectModelConstantsInterface::JCR_JOIN_TYPE_RIGHT_OUTER === $source->getJoinType()) {
  256.                 $selectors = array_merge($this->validateSource($right), $selectors);
  257.             } else {
  258.                 $selectors = array_merge($selectors, $this->validateSource($right));
  259.             }
  260.         }
  262.         return $selectors;
  263.     }
  265.     /**
  266.      * @param QOM\SourceInterface $source
  267.      *
  268.      * @return string
  269.      *
  270.      * @throws NotImplementedException
  271.      */
  272.     public function walkSource(QOM\SourceInterface $source)
  273.     {
  274.         if ($source instanceof QOM\SelectorInterface) {
  275.             return $this->walkSelectorSource($source);
  276.         }
  278.         if ($source instanceof QOM\JoinInterface) {
  279.             return $this->walkJoinSource($source);
  280.         }
  282.         throw new NotImplementedException(sprintf("The source class '%s' is not supported", get_class($source)));
  283.     }
  285.     /**
  286.      * @param QOM\SelectorInterface $source
  287.      *
  288.      * @return string
  289.      */
  290.     public function walkSelectorSource(QOM\SelectorInterface $source)
  291.     {
  292.         $this->source = $source;
  293.         $alias = $this->getTableAlias($source->getSelectorName());
  294.         $nodeTypeClause = $this->sqlNodeTypeClause($alias, $source);
  295.         $sql = "FROM phpcr_nodes $alias WHERE $alias.workspace_name = ? AND $nodeTypeClause";
  297.         return $sql;
  298.     }
  300.     /**
  301.      * @param QOM\JoinConditionInterface $right
  302.      *
  303.      * @return string the alias on the right side of a join
  304.      *
  305.      * @throws BadMethodCallException if the provided JoinCondition has no valid way of getting the right selector
  306.      */
  307.     private function getRightJoinSelector(QOM\JoinConditionInterface $right)
  308.     {
  309.         if ($right instanceof QOM\ChildNodeJoinConditionInterface) {
  310.             return $right->getParentSelectorName();
  311.         } elseif ($right instanceof QOM\DescendantNodeJoinConditionInterface) {
  312.             return $right->getAncestorSelectorName();
  313.         } elseif ($right instanceof QOM\SameNodeJoinConditionInterface || $right instanceof QOM\EquiJoinConditionInterface) {
  314.             return $right->getSelector2Name();
  315.         }
  316.         throw new BadMethodCallException('Supplied join type should implement getSelector2Name() or be an instance of ChildNodeJoinConditionInterface or DescendantNodeJoinConditionInterface');
  317.     }
  320.     /**
  321.      * @param QOM\JoinConditionInterface $right
  322.      *
  323.      * @return string the alias on the left side of a join
  324.      *
  325.      * @throws BadMethodCallException if the provided JoinCondition has no valid way of getting the left selector
  326.      */
  327.     private function getLeftJoinSelector(QOM\JoinConditionInterface $left)
  328.     {
  329.         if ($left instanceof QOM\ChildNodeJoinConditionInterface) {
  330.             return $left->getChildSelectorName();
  331.         } elseif ($left instanceof QOM\DescendantNodeJoinConditionInterface) {
  332.             return $left->getAncestorSelectorName();
  333.         } elseif ($left instanceof QOM\SameNodeJoinConditionInterface || $left instanceof QOM\EquiJoinConditionInterface) {
  334.             return $left->getSelector1Name();
  335.         }
  336.         throw new BadMethodCallException('Supplied join type should implement getSelector2Name() or be an instance of ChildNodeJoinConditionInterface or DescendantNodeJoinConditionInterface');
  337.     }
  339.     /**
  340.      * find the most left join in a tree
  341.      *
  342.      * @param QOM\JoinInterface $source
  343.      *
  344.      * @return QOM\JoinInterface
  345.      */
  346.     private function getLeftMostJoin(QOM\JoinInterface $source)
  347.     {
  348.         if ($source->getLeft() instanceof QOM\JoinInterface) {
  349.             return $this->getLeftMostJoin($source->getLeft());
  350.         }
  351.         return $source;
  352.     }
  354.     /**
  355.      * @param QOM\JoinInterface $source
  356.      * @param boolean $root whether the method call is recursed for nested joins. If true, it will add a WHERE clause
  357.      *        that checks the workspace_name and type
  358.      *
  359.      * @return string
  360.      *
  361.      * @throws NotImplementedException if the right side of the join consists of another join
  362.      */
  363.     public function walkJoinSource(QOM\JoinInterface $source, $root = true)
  364.     {
  365.         $this->source = $left = $source->getLeft(); // The $left variable is used for storing the leftmost selector
  367.         if (!$source->getRight() instanceof QOM\SelectorInterface) {
  368.             throw new NotImplementedException('The right side of the join should not consist of another join');
  369.         }
  371.         if ($source->getLeft() instanceof QOM\SelectorInterface) {
  372.             $leftAlias = $this->getTableAlias($source->getLeft()->getSelectorName());
  373.             $this->getTableAlias($source->getLeft()->getSelectorName());
  374.             $sql = "FROM phpcr_nodes $leftAlias ";
  375.         } else {
  376.             $sql = $this->walkJoinSource($left, false) . ' '; // One step left, until we're at the selector
  377.             $leftMostJoin = $this->getLeftMostJoin($source);
  378.             $leftAlias = $this->getTableAlias(
  379.                 $this->getLeftJoinSelector($leftMostJoin->getJoinCondition())
  380.             );
  381.             $left = $leftMostJoin->getLeft();
  382.         }
  383.         $rightAlias = $this->getTableAlias($source->getRight()->getSelectorName());
  384.         $nodeTypeClause = $this->sqlNodeTypeClause($rightAlias, $source->getRight());
  386.         switch ($source->getJoinType()) {
  387.             case QOM\QueryObjectModelConstantsInterface::JCR_JOIN_TYPE_INNER:
  388.                 $sql .= sprintf("INNER JOIN phpcr_nodes %s ", $rightAlias);
  389.                 break;
  390.             case QOM\QueryObjectModelConstantsInterface::JCR_JOIN_TYPE_LEFT_OUTER:
  391.                 $sql .= sprintf("LEFT JOIN phpcr_nodes %s ", $rightAlias);
  392.                 break;
  393.             case QOM\QueryObjectModelConstantsInterface::JCR_JOIN_TYPE_RIGHT_OUTER:
  394.                 $sql .= sprintf("RIGHT JOIN phpcr_nodes %s ", $rightAlias);
  395.                 break;
  396.         }
  398.         $sql .= sprintf("ON ( %s.workspace_name = %s.workspace_name AND %s ", $leftAlias, $rightAlias, $nodeTypeClause);
  399.         $sql .= 'AND ' . $this->walkJoinCondition($source->getLeft(), $source->getRight(), $source->getJoinCondition()) . ' ';
  400.         $sql .= ') '; // close on-clause
  403.         if ($root) { // The method call is not recursed when $root is true, so we can add a WHERE clause
  404.             // TODO: revise this part for alternatives
  405.             $sql .= sprintf("WHERE %s.workspace_name = ? AND %s.type IN ('%s'", $leftAlias, $leftAlias, $left->getNodeTypeName());
  406.             $subTypes = $this->nodeTypeManager->getSubtypes($left->getNodeTypeName());
  407.             foreach ($subTypes as $subType) {
  408.                 /* @var $subType NodeTypeInterface */
  409.                 $sql .= sprintf(", '%s'", $subType->getName());
  410.             }
  411.             $sql .= ')';
  412.         }
  414.         return $sql;
  415.     }
  417.     /**
  418.      * @param QOM\SelectorInterface|QOM\JoinInterface $left
  419.      * @param QOM\SelectorInterface $right
  420.      * @param QOM\JoinConditionInterface $condition
  421.      *
  422.      * @return string
  423.      *
  424.      * @throws NotImplementedException if a SameNodeJoinCondtion is used.
  425.      */
  426.     public function walkJoinCondition($left, QOM\SelectorInterface $right, QOM\JoinConditionInterface $condition)
  427.     {
  428.         if ($condition instanceof QOM\ChildNodeJoinConditionInterface) {
  429.             return $this->walkChildNodeJoinCondition($condition);
  430.         }
  431.         if ($condition instanceof QOM\DescendantNodeJoinConditionInterface) {
  432.             return $this->walkDescendantNodeJoinCondition($condition);
  433.         }
  434.         if ($condition instanceof QOM\EquiJoinConditionInterface) {
  435.             if ($left instanceof QOM\SelectorInterface) {
  436.                 $selectorName = $left->getSelectorName();
  437.             } else {
  438.                 $selectorName = $this->getLeftJoinSelector($this->getLeftMostJoin($left)->getJoinCondition());
  439.             }
  440.             return $this->walkEquiJoinCondition($selectorName, $right->getSelectorName(), $condition);
  441.         }
  442.         if ($condition instanceof QOM\SameNodeJoinConditionInterface) {
  443.             throw new NotImplementedException('SameNodeJoinCondtion');
  444.         }
  445.     }
  447.     /**
  448.      * @param QOM\ChildNodeJoinConditionInterface $condition
  449.      *
  450.      * @return string
  451.      */
  452.     public function walkChildNodeJoinCondition(QOM\ChildNodeJoinConditionInterface $condition)
  453.     {
  454.         $rightAlias = $this->getTableAlias($condition->getChildSelectorName());
  455.         $leftAlias = $this->getTableAlias($condition->getParentSelectorName());
  456.         $concatExpression = $this->platform->getConcatExpression("$leftAlias.path", "'/%'");
  458.         return sprintf("(%s.path LIKE %s AND %s.depth = %s.depth + 1) ", $rightAlias, $concatExpression, $rightAlias, $leftAlias);
  459.     }
  461.     /**
  462.      * @param QOM\DescendantNodeJoinConditionInterface $condition
  463.      *
  464.      * @return string
  465.      */
  466.     public function walkDescendantNodeJoinCondition(QOM\DescendantNodeJoinConditionInterface $condition)
  467.     {
  468.         $rightAlias = $this->getTableAlias($condition->getDescendantSelectorName());
  469.         $leftAlias = $this->getTableAlias($condition->getAncestorSelectorName());
  470.         $concatExpression = $this->platform->getConcatExpression("$leftAlias.path", "'/%'");
  472.         return sprintf("%s.path LIKE %s ", $rightAlias, $concatExpression);
  473.     }
  475.     /**
  476.      * @param QOM\EquiJoinConditionInterface $condition
  477.      *
  478.      * @return string
  479.      */
  480.     public function walkEquiJoinCondition($leftSelectorName, $rightSelectorName, QOM\EquiJoinConditionInterface $condition)
  481.     {
  482.         return $this->walkOperand(new PropertyValue($leftSelectorName, $condition->getProperty1Name())) . ' ' .
  483.                $this->walkOperator(QOM\QueryObjectModelConstantsInterface::JCR_OPERATOR_EQUAL_TO) . ' ' .
  484.                $this->walkOperand(new PropertyValue($rightSelectorName, $condition->getProperty2Name()));
  485.     }
  487.     /**
  488.      * @param \PHPCR\Query\QOM\ConstraintInterface $constraint
  489.      *
  490.      * @return string
  491.      *
  492.      * @throws InvalidQueryException
  493.      */
  494.     public function walkConstraint(QOM\ConstraintInterface $constraint)
  495.     {
  496.         if ($constraint instanceof QOM\AndInterface) {
  497.             return $this->walkAndConstraint($constraint);
  498.         }
  499.         if ($constraint instanceof QOM\OrInterface) {
  500.             return $this->walkOrConstraint($constraint);
  501.         }
  502.         if ($constraint instanceof QOM\NotInterface) {
  503.             return $this->walkNotConstraint($constraint);
  504.         }
  505.         if ($constraint instanceof QOM\ComparisonInterface) {
  506.             return $this->walkComparisonConstraint($constraint);
  507.         }
  508.         if ($constraint instanceof QOM\DescendantNodeInterface) {
  509.             return $this->walkDescendantNodeConstraint($constraint);
  510.         }
  511.         if ($constraint instanceof QOM\ChildNodeInterface) {
  512.             return $this->walkChildNodeConstraint($constraint);
  513.         }
  514.         if ($constraint instanceof QOM\PropertyExistenceInterface) {
  515.             return $this->walkPropertyExistenceConstraint($constraint);
  516.         }
  517.         if ($constraint instanceof QOM\SameNodeInterface) {
  518.             return $this->walkSameNodeConstraint($constraint);
  519.         }
  520.         if ($constraint instanceof QOM\FullTextSearchInterface) {
  521.             return $this->walkFullTextSearchConstraint($constraint);
  522.         }
  524.         throw new InvalidQueryException(sprintf("Constraint %s not yet supported.", get_class($constraint)));
  525.     }
  527.     /**
  528.      * @param QOM\SameNodeInterface $constraint
  529.      *
  530.      * @return string
  531.      */
  532.     public function walkSameNodeConstraint(QOM\SameNodeInterface $constraint)
  533.     {
  534.         return sprintf(
  535.             "%s.path = '%s'",
  536.             $this->getTableAlias($constraint->getSelectorName()),
  537.             $constraint->getPath()
  538.         );
  539.     }
  541.     /**
  542.      * @param QOM\FullTextSearchInterface $constraint
  543.      *
  544.      * @return string
  545.      */
  546.     public function walkFullTextSearchConstraint(QOM\FullTextSearchInterface $constraint)
  547.     {
  548.         return sprintf('%s LIKE %s',
  549.             $this->sqlXpathExtractValue($this->getTableAlias($constraint->getSelectorName()), $constraint->getPropertyName()),
  550.             $this->conn->quote('%'.$constraint->getFullTextSearchExpression().'%')
  551.         );
  552.     }
  554.     /**
  555.      * @param QOM\PropertyExistenceInterface $constraint
  556.      *
  557.      * @return string
  558.      */
  559.     public function walkPropertyExistenceConstraint(QOM\PropertyExistenceInterface $constraint)
  560.     {
  561.         return $this->sqlXpathValueExists($this->getTableAlias($constraint->getSelectorName()), $constraint->getPropertyName());
  562.     }
  564.     /**
  565.      * @param QOM\DescendantNodeInterface $constraint
  566.      *
  567.      * @return string
  568.      */
  569.     public function walkDescendantNodeConstraint(QOM\DescendantNodeInterface $constraint)
  570.     {
  571.         $ancestorPath = $constraint->getAncestorPath();
  572.         if ('/' === $ancestorPath) {
  573.             $ancestorPath = '';
  574.         } elseif (substr($ancestorPath, -1) === '/') {
  575.             throw new InvalidQueryException("Trailing slash in $ancestorPath");
  576.         }
  578.         return sprintf(
  579.             "%s.path LIKE '%s/%%'",
  580.             $this->getTableAlias($constraint->getSelectorName()),
  581.             addcslashes($ancestorPath, "'")
  582.         );
  583.     }
  585.     /**
  586.      * @param QOM\ChildNodeInterface $constraint
  587.      *
  588.      * @return string
  589.      */
  590.     public function walkChildNodeConstraint(QOM\ChildNodeInterface $constraint)
  591.     {
  592.         return sprintf(
  593.             "%s.parent = '%s'",
  594.             $this->getTableAlias($constraint->getSelectorName()),
  595.             addcslashes($constraint->getParentPath(), "'")
  596.         );
  597.     }
  599.     /**
  600.      * @param QOM\AndInterface $constraint
  601.      *
  602.      * @return string
  603.      */
  604.     public function walkAndConstraint(QOM\AndInterface $constraint)
  605.     {
  606.         return sprintf(
  607.             "(%s AND %s)",
  608.             $this->walkConstraint($constraint->getConstraint1()),
  609.             $this->walkConstraint($constraint->getConstraint2())
  610.         );
  611.     }
  613.     /**
  614.      * @param QOM\OrInterface $constraint
  615.      *
  616.      * @return string
  617.      */
  618.     public function walkOrConstraint(QOM\OrInterface $constraint)
  619.     {
  620.         return sprintf(
  621.             "(%s OR %s)",
  622.             $this->walkConstraint($constraint->getConstraint1()),
  623.             $this->walkConstraint($constraint->getConstraint2())
  624.         );
  625.     }
  627.     /**
  628.      * @param QOM\NotInterface $constraint
  629.      *
  630.      * @return string
  631.      */
  632.     public function walkNotConstraint(QOM\NotInterface $constraint)
  633.     {
  634.         return sprintf(
  635.             "NOT (%s)",
  636.             $this->walkConstraint($constraint->getConstraint())
  637.         );
  638.     }
  640.     /**
  641.      * This method figures out the best way to do a comparison
  642.      * When we need to compare a property with a literal value,
  643.      * we need to be aware of the multivalued properties, we then require
  644.      * a different xpath statement then with other comparisons
  645.      *
  646.      * @param QOM\ComparisonInterface $constraint
  647.      *
  648.      * @return string
  649.      */
  650.     public function walkComparisonConstraint(QOM\ComparisonInterface $constraint)
  651.     {
  652.         $operator = $this->walkOperator($constraint->getOperator());
  654.         $operator1 = $constraint->getOperand1();
  655.         $operator2 = $constraint->getOperand2();
  657.         // Check if we have a property and a literal value (in random order)
  658.         if (
  659.             ($operator1 instanceof QOM\PropertyValueInterface
  660.                 && $operator2 instanceof QOM\LiteralInterface)
  661.             || ($operator1 instanceof QOM\LiteralInterface
  662.                 && $operator2 instanceof QOM\PropertyValueInterface)
  663.             || ($operator1 instanceof QOM\NodeNameInterface
  664.                 && $operator2 instanceof QOM\LiteralInterface)
  665.             || ($operator1 instanceof QOM\LiteralInterface
  666.                 && $operator2 instanceof QOM\NodeNameInterface)
  667.         ) {
  668.             // Check whether the left is the literal, at this point the other always is the literal/nodename operand
  669.             if ($operator1 instanceof QOM\LiteralInterface) {
  670.                 $operand = $operator2;
  671.                 $literalOperand = $operator1;
  672.             } else {
  673.                 $literalOperand = $operator2;
  674.                 $operand = $operator1;
  675.             }
  677.             if (is_string($literalOperand->getLiteralValue()) && '=' !== $operator && '!=' !== $operator) {
  678.                 return
  679.                     $this->walkOperand($operator1) . ' ' .
  680.                     $operator . ' ' .
  681.                     $this->walkOperand($operator2);
  682.             }
  684.             if ($operand instanceof QOM\NodeNameInterface) {
  685.                 $selectorName = $operand->getSelectorName();
  686.                 $alias = $this->getTableAlias($selectorName);
  688.                 $literal = $literalOperand->getLiteralValue();
  689.                 if (false !== strpos($literal, ':')) {
  690.                     $parts = explode(':', $literal);
  691.                     if (!isset($this->namespaces[$parts[0]])) {
  692.                         throw new NamespaceException('The namespace ' . $parts[0] . ' was not registered.');
  693.                     }
  695.                     $parts[0] = $this->namespaces[$parts[0]];
  696.                     $literal = implode(':', $parts);
  697.                 }
  699.                 return sprintf(
  700.                     '%s %s %s',
  701.                     $this->platform->getConcatExpression(
  702.                         sprintf("%s.namespace", $alias),
  703.                         sprintf("(CASE %s.namespace WHEN '' THEN '' ELSE ':' END)", $alias),
  704.                         sprintf("%s.local_name", $alias)
  705.                     ),
  706.                     $operator,
  707.                     $this->conn->quote($literal)
  708.                 ) ;
  709.             }
  711.             if ('jcr:path' !== $operand->getPropertyName() && 'jcr:uuid' !== $operand->getPropertyName()) {
  712.                 if (is_int($literalOperand->getLiteralValue()) || is_float($literalOperand->getLiteralValue())) {
  713.                     return $this->walkNumComparisonConstraint($operand, $literalOperand, $operator);
  714.                 }
  715.                 if (is_bool($literalOperand->getLiteralValue())) {
  716.                     return $this->walkBoolComparisonConstraint($operand, $literalOperand, $operator);
  717.                 }
  719.                 return $this->walkTextComparisonConstraint($operand, $literalOperand, $operator);
  720.             }
  721.         }
  723.         return sprintf(
  724.             '%s %s %s',
  725.             $this->walkOperand($operator1),
  726.             $operator,
  727.             $this->walkOperand($operator2)
  728.         );
  729.     }
  731.     /**
  732.      * @param QOM\PropertyValueInterface $propertyOperand
  733.      * @param QOM\LiteralInterface $literalOperand
  734.      * @param string $operator
  735.      *
  736.      * @return string
  737.      */
  738.     public function walkTextComparisonConstraint(QOM\PropertyValueInterface $propertyOperand, QOM\LiteralInterface $literalOperand, $operator)
  739.     {
  740.         $alias = $this->getTableAlias($propertyOperand->getSelectorName() . '.' . $propertyOperand->getPropertyName());
  741.         $property = $propertyOperand->getPropertyName();
  743.         return $this->sqlXpathComparePropertyValue($alias, $property, $this->getLiteralValue($literalOperand), $operator);
  744.     }
  746.     public function walkBoolComparisonConstraint(QOM\PropertyValueInterface $propertyOperand, QOM\LiteralInterface $literalOperand, $operator)
  747.     {
  748.         $value = true === $literalOperand->getLiteralValue() ? '1' : '0';
  750.         return $this->walkOperand($propertyOperand) . ' ' . $operator . ' ' . $this->conn->quote($value);
  751.     }
  753.     public function walkNumComparisonConstraint(QOM\PropertyValueInterface $propertyOperand, QOM\LiteralInterface $literalOperand, $operator)
  754.     {
  755.         $alias = $this->getTableAlias($propertyOperand->getSelectorName() . '.' . $propertyOperand->getPropertyName());
  756.         $property = $propertyOperand->getPropertyName();
  759.         if ($this->platform instanceof MySQLPlatform && '=' === $operator) {
  760.             return sprintf(
  761.                 '0 != FIND_IN_SET("%s", REPLACE(EXTRACTVALUE(%s.props, \'//sv:property[@sv:name=%s]/sv:value\'), " ", ","))',
  762.                 $literalOperand->getLiteralValue(),
  763.                 $alias,
  764.                 Xpath::escape($property)
  765.             );
  766.         }
  768.         if ('=' === $operator) {
  769.             return $this->sqlXpathComparePropertyValue($alias, $property, $literalOperand->getLiteralValue(), $operator);
  770.         }
  772.         return sprintf(
  773.             '%s %s %s',
  774.             $this->sqlXpathExtractNumValue($alias, $property),
  775.             $operator,
  776.             $literalOperand->getLiteralValue()
  777.         );
  778.     }
  780.     /**
  781.      * @param string $operator
  782.      *
  783.      * @return string
  784.      */
  785.     public function walkOperator($operator)
  786.     {
  787.         if ($operator === QOM\QueryObjectModelConstantsInterface::JCR_OPERATOR_EQUAL_TO) {
  788.             return '=';
  789.         }
  790.         if ($operator === QOM\QueryObjectModelConstantsInterface::JCR_OPERATOR_GREATER_THAN) {
  791.             return '>';
  792.         }
  793.         if ($operator === QOM\QueryObjectModelConstantsInterface::JCR_OPERATOR_GREATER_THAN_OR_EQUAL_TO) {
  794.             return '>=';
  795.         }
  796.         if ($operator === QOM\QueryObjectModelConstantsInterface::JCR_OPERATOR_LESS_THAN) {
  797.             return '<';
  798.         }
  799.         if ($operator === QOM\QueryObjectModelConstantsInterface::JCR_OPERATOR_LESS_THAN_OR_EQUAL_TO) {
  800.             return '<=';
  801.         }
  802.         if ($operator === QOM\QueryObjectModelConstantsInterface::JCR_OPERATOR_NOT_EQUAL_TO) {
  803.             return '!=';
  804.         }
  805.         if ($operator === QOM\QueryObjectModelConstantsInterface::JCR_OPERATOR_LIKE) {
  806.             return 'LIKE';
  807.         }
  809.         return $operator; // no-op for simplicity, not standard conform (but using the constants is a pain)
  810.     }
  812.     /**
  813.      * @param QOM\OperandInterface $operand
  814.      *
  815.      * @return string
  816.      *
  817.      * @throws InvalidQueryException
  818.      */
  819.     public function walkOperand(QOM\OperandInterface $operand)
  820.     {
  821.         if ($operand instanceof QOM\NodeNameInterface) {
  822.             $selectorName = $operand->getSelectorName();
  823.             $alias = $this->getTableAlias($selectorName);
  825.             return $this->platform->getConcatExpression(
  826.                 sprintf("%s.namespace", $alias),
  827.                 sprintf("(CASE %s.namespace WHEN '' THEN '' ELSE ':' END)", $alias),
  828.                 sprintf("%s.local_name", $alias)
  829.             );
  830.         }
  832.         if ($operand instanceof QOM\NodeLocalNameInterface) {
  833.             $selectorName = $operand->getSelectorName();
  834.             $alias = $this->getTableAlias($selectorName);
  836.             return sprintf("%s.local_name", $alias);
  837.         }
  839.         if ($operand instanceof QOM\LowerCaseInterface) {
  840.             return $this->platform->getLowerExpression($this->walkOperand($operand->getOperand()));
  841.         }
  843.         if ($operand instanceof QOM\UpperCaseInterface) {
  844.             return $this->platform->getUpperExpression($this->walkOperand($operand->getOperand()));
  845.         }
  847.         if ($operand instanceof QOM\LiteralInterface) {
  848.             return $this->conn->quote($this->getLiteralValue($operand));
  849.         }
  851.         if ($operand instanceof QOM\PropertyValueInterface) {
  852.             $alias = $this->getTableAlias($operand->getSelectorName() . '.' . $operand->getPropertyName());
  853.             $property = $operand->getPropertyName();
  854.             if ($property === 'jcr:path') {
  855.                 return sprintf("%s.path", $alias);
  856.             }
  857.             if ($property === "jcr:uuid") {
  858.                 return sprintf("%s.identifier", $alias);
  859.             }
  861.             return $this->sqlXpathExtractValue($alias, $property);
  862.         }
  864.         if ($operand instanceof QOM\LengthInterface) {
  865.             $alias = $this->getTableAlias($operand->getPropertyValue()->getSelectorName());
  866.             $property = $operand->getPropertyValue()->getPropertyName();
  868.             return $this->sqlXpathExtractValueAttribute($alias, $property, 'length');
  869.         }
  871.         throw new InvalidQueryException(sprintf("Dynamic operand %s not yet supported.", get_class($operand)));
  872.     }
  874.     /**
  875.      * @param array $orderings
  876.      *
  877.      * @return string
  878.      */
  879.     public function walkOrderings(array $orderings)
  880.     {
  881.         $sql = '';
  882.         foreach ($orderings as $ordering) {
  883.             $sql .= empty($sql) ? 'ORDER BY ' : ', ';
  884.             $sql .= $this->walkOrdering($ordering);
  885.         }
  887.         return $sql;
  888.     }
  890.     /**
  891.      * @param QOM\OrderingInterface $ordering
  892.      *
  893.      * @return string
  894.      */
  895.     public function walkOrdering(QOM\OrderingInterface $ordering)
  896.     {
  897.         $direction = $ordering->getOrder();
  898.         if ($direction === QOM\QueryObjectModelConstantsInterface::JCR_ORDER_ASCENDING) {
  899.             $direction = 'ASC';
  900.         } elseif ($direction === QOM\QueryObjectModelConstantsInterface::JCR_ORDER_DESCENDING) {
  901.             $direction = 'DESC';
  902.         }
  904.         $sql = $this->walkOperand($ordering->getOperand());
  906.         if ($ordering->getOperand() instanceof QOM\PropertyValueInterface) {
  907.             $operand = $ordering->getOperand();
  908.             $property = $ordering->getOperand()->getPropertyName();
  909.             if ($property !== 'jcr:path' && $property !== 'jcr:uuid') {
  910.                 $alias = $this->getTableAlias($operand->getSelectorName() . '.' . $property);
  912.                 $numericalSelector = $this->sqlXpathExtractValue($alias, $property, 'numerical_props');
  914.                 $sql = sprintf(
  915.                     'CAST(%s AS DECIMAL) %s, %s',
  916.                     $numericalSelector,
  917.                     $direction,
  918.                     $sql
  919.                 );
  920.             }
  921.         }
  923.         $sql .= ' ' .$direction;
  925.         return $sql;
  926.     }
  928.     /**
  929.      * @param QOM\LiteralInterface $operand
  930.      *
  931.      * @return string
  932.      *
  933.      * @throws NamespaceException
  934.      */
  935.     private function getLiteralValue(QOM\LiteralInterface $operand)
  936.     {
  937.         $value = $operand->getLiteralValue();
  939.         /**
  940.          * Normalize Dates to UTC
  941.          */
  942.         if ($value instanceof DateTime) {
  943.             $valueUTC = clone($value);
  944.             $valueUTC->setTimezone(new DateTimeZone('UTC'));
  945.             return $valueUTC->format('c');
  946.         }
  948.         return $value;
  949.     }
  951.     /**
  952.      * SQL to execute an XPATH expression checking if the property exist on the node with the given alias.
  953.      *
  954.      * @param string $alias
  955.      * @param string $property
  956.      *
  957.      * @return string
  958.      */
  959.     private function sqlXpathValueExists($alias, $property)
  960.     {
  961.         if ($this->platform instanceof MySQLPlatform) {
  962.             return sprintf("EXTRACTVALUE(%s.props, 'count(//sv:property[@sv:name=%s]/sv:value[1])') = 1", $alias, Xpath::escape($property));
  963.         }
  965.         if ($this->platform instanceof PostgreSQL94Platform || $this->platform instanceof PostgreSqlPlatform) {
  966.             return sprintf("xpath_exists('//sv:property[@sv:name=%s]/sv:value[1]', CAST(%s.props AS xml), ".$this->sqlXpathPostgreSQLNamespaces().") = 't'", Xpath::escape($property), $alias);
  967.         }
  969.         if ($this->platform instanceof SqlitePlatform) {
  970.             return sprintf("EXTRACTVALUE(%s.props, 'count(//sv:property[@sv:name=%s]/sv:value[1])') = 1", $alias, Xpath::escape($property));
  971.         }
  973.         throw new NotImplementedException(sprintf("Xpath evaluations cannot be executed with '%s' yet.", $this->platform->getName()));
  974.     }
  976.     /**
  977.      * SQL to execute an XPATH expression extracting the property value on the node with the given alias.
  978.      *
  979.      * @param string $alias
  980.      * @param string $property
  981.      *
  982.      * @return string
  983.      */
  984.     private function sqlXpathExtractValue($alias, $property, $column = 'props')
  985.     {
  986.         if ($this->platform instanceof MySQLPlatform) {
  987.             return sprintf("EXTRACTVALUE(%s.%s, '//sv:property[@sv:name=%s]/sv:value[1]')", $alias, $column, Xpath::escape($property));
  988.         }
  990.         if ($this->platform instanceof PostgreSQL94Platform || $this->platform instanceof PostgreSqlPlatform) {
  991.             return sprintf("(xpath('//sv:property[@sv:name=%s]/sv:value[1]/text()', CAST(%s.%s AS xml), %s))[1]::text", Xpath::escape($property), $alias, $column, $this->sqlXpathPostgreSQLNamespaces());
  992.         }
  994.         if ($this->platform instanceof SqlitePlatform) {
  995.             return sprintf("EXTRACTVALUE(%s.%s, '//sv:property[@sv:name=%s]/sv:value[1]')", $alias, $column, Xpath::escape($property));
  996.         }
  998.         throw new NotImplementedException(sprintf("Xpath evaluations cannot be executed with '%s' yet.", $this->platform->getName()));
  999.     }
  1001.     private function sqlXpathExtractNumValue($alias, $property)
  1002.     {
  1003.         if ($this->platform instanceof PostgreSQL94Platform || $this->platform instanceof PostgreSqlPlatform) {
  1004.             return sprintf("(xpath('//sv:property[@sv:name=%s]/sv:value[1]/text()', CAST(%s.props AS xml), %s))[1]::text::int", Xpath::escape($property), $alias, $this->sqlXpathPostgreSQLNamespaces());
  1005.         }
  1007.         return sprintf('CAST(%s AS DECIMAL)', $this->sqlXpathExtractValue($alias, $property));
  1008.     }
  1010.     private function sqlXpathExtractValueAttribute($alias, $property, $attribute, $valueIndex = 1)
  1011.     {
  1012.         if ($this->platform instanceof MySQLPlatform) {
  1013.             return sprintf("EXTRACTVALUE(%s.props, '//sv:property[@sv:name=%s]/sv:value[%d]/@%s')", $alias, Xpath::escape($property), $valueIndex, $attribute);
  1014.         }
  1016.         if ($this->platform instanceof PostgreSQL94Platform || $this->platform instanceof PostgreSqlPlatform) {
  1017.             return sprintf("CAST((xpath('//sv:property[@sv:name=%s]/sv:value[%d]/@%s', CAST(%s.props AS xml), %s))[1]::text AS bigint)", Xpath::escape($property), $valueIndex, $attribute, $alias, $this->sqlXpathPostgreSQLNamespaces());
  1018.         }
  1020.         if ($this->platform instanceof SqlitePlatform) {
  1021.             return sprintf("EXTRACTVALUE(%s.props, '//sv:property[@sv:name=%s]/sv:value[%d]/@%s')", $alias, Xpath::escape($property), $valueIndex, $attribute);
  1022.         }
  1024.         throw new NotImplementedException(sprintf("Xpath evaluations cannot be executed with '%s' yet.", $this->platform->getName()));
  1025.     }
  1027.     /**
  1028.      * @param $alias
  1029.      * @param $property
  1030.      * @param $value
  1031.      * @param string $operator
  1032.      *
  1033.      * @return string
  1034.      *
  1035.      * @throws NotImplementedException if the storage backend is neither mysql
  1036.      *      nor postgres nor sqlite
  1037.      */
  1038.     private function sqlXpathComparePropertyValue($alias, $property, $value, $operator)
  1039.     {
  1040.         $expression = null;
  1042.         if ($this->platform instanceof MySQLPlatform) {
  1043.             $expression = sprintf("EXTRACTVALUE(%s.props, 'count(//sv:property[@sv:name=%s]/sv:value[text()%%s%%s]) > 0')", $alias, Xpath::escape($property));
  1044.             // mysql does not escape the backslashes for us, while postgres and sqlite do
  1045.             $value = Xpath::escapeBackslashes($value);
  1046.         } elseif ($this->platform instanceof PostgreSQL94Platform || $this->platform instanceof PostgreSqlPlatform) {
  1047.             $expression = sprintf("xpath_exists('//sv:property[@sv:name=%s]/sv:value[text()%%s%%s]', CAST(%s.props AS xml), %s) = 't'", Xpath::escape($property), $alias, $this->sqlXpathPostgreSQLNamespaces());
  1048.         } elseif ($this->platform instanceof SqlitePlatform) {
  1049.             $expression = sprintf("EXTRACTVALUE(%s.props, 'count(//sv:property[@sv:name=%s]/sv:value[text()%%s%%s]) > 0')", $alias, Xpath::escape($property));
  1050.         } else {
  1051.             throw new NotImplementedException(sprintf("Xpath evaluations cannot be executed with '%s' yet.", $this->platform->getName()));
  1052.         }
  1054.         return sprintf($expression, $this->walkOperator($operator), Xpath::escape($value));
  1055.     }
  1057.     /**
  1058.      * @return string
  1059.      */
  1060.     private function sqlXpathPostgreSQLNamespaces()
  1061.     {
  1062.         return "ARRAY[ARRAY['sv', 'http://www.jcp.org/jcr/sv/1.0']]";
  1063.     }
  1065.     /**
  1066.      * @param QOM\SelectorInterface $source
  1067.      * @param string                $alias
  1068.      *
  1069.      * @return string
  1070.      */
  1071.     private function sqlNodeTypeClause($alias, QOM\SelectorInterface $source)
  1072.     {
  1073.         $sql = sprintf("%s.type IN ('%s'", $alias, $source->getNodeTypeName());
  1075.         $subTypes = $this->nodeTypeManager->getSubtypes($source->getNodeTypeName());
  1076.         foreach ($subTypes as $subType) {
  1077.             /* @var $subType NodeTypeInterface */
  1078.             $sql .= sprintf(", '%s'", $subType->getName());
  1079.         }
  1080.         $sql .= ')';
  1082.         return $sql;
  1083.     }
  1084. }