vendor/jackalope/jackalope-doctrine-dbal/src/Jackalope/Transport/DoctrineDBAL/Client.php line 606

Open in your IDE?
  1. <?php
  3. namespace Jackalope\Transport\DoctrineDBAL;
  5. use ArrayObject;
  6. use Closure;
  7. use DateTime;
  8. use DateTimeZone;
  9. use Doctrine\DBAL\Connection;
  10. use Doctrine\DBAL\DBALException;
  11. use Doctrine\DBAL\Platforms\PostgreSqlPlatform;
  12. use Doctrine\DBAL\Platforms\SqlitePlatform;
  13. use DOMDocument;
  14. use DOMElement;
  15. use DOMXPath;
  16. use Exception;
  17. use InvalidArgumentException;
  18. use Jackalope\FactoryInterface;
  19. use Jackalope\Node;
  20. use Jackalope\NodeType\NodeProcessor;
  21. use Jackalope\NodeType\NodeTypeDefinition;
  22. use Jackalope\NodeType\NodeTypeManager;
  23. use Jackalope\NotImplementedException;
  24. use Jackalope\Property;
  25. use Jackalope\Query\QOM\QueryObjectModelFactory;
  26. use Jackalope\Query\Query;
  27. use Jackalope\Transport\BaseTransport;
  28. use Jackalope\Transport\DoctrineDBAL\Query\QOMWalker;
  29. use Jackalope\Transport\MoveNodeOperation;
  30. use Jackalope\Transport\NodeTypeManagementInterface;
  31. use Jackalope\Transport\QueryInterface as QueryTransport;
  32. use Jackalope\Transport\StandardNodeTypes;
  33. use Jackalope\Transport\TransactionInterface;
  34. use Jackalope\Transport\WorkspaceManagementInterface;
  35. use Jackalope\Transport\WritingInterface;
  36. use PDO;
  37. use PDOException;
  38. use PHPCR\AccessDeniedException;
  39. use PHPCR\CredentialsInterface;
  40. use PHPCR\ItemExistsException;
  41. use PHPCR\ItemNotFoundException;
  42. use PHPCR\LoginException;
  43. use PHPCR\NamespaceException;
  44. use PHPCR\NamespaceRegistryInterface as NS;
  45. use PHPCR\NodeType\ConstraintViolationException;
  46. use PHPCR\NodeType\NodeDefinitionInterface;
  47. use PHPCR\NodeType\NodeTypeExistsException;
  48. use PHPCR\NodeType\NoSuchNodeTypeException;
  49. use PHPCR\NodeType\PropertyDefinitionInterface;
  50. use PHPCR\NoSuchWorkspaceException;
  51. use PHPCR\PathNotFoundException;
  52. use PHPCR\PropertyType;
  53. use PHPCR\Query\InvalidQueryException;
  54. use PHPCR\Query\QOM\QueryObjectModelConstantsInterface as QOM;
  55. use PHPCR\Query\QOM\QueryObjectModelInterface;
  56. use PHPCR\Query\QOM\SelectorInterface;
  57. use PHPCR\Query\QueryInterface;
  58. use PHPCR\ReferentialIntegrityException;
  59. use PHPCR\RepositoryException;
  60. use PHPCR\RepositoryInterface;
  61. use PHPCR\SimpleCredentials;
  62. use PHPCR\UnsupportedRepositoryOperationException;
  63. use PHPCR\Util\PathHelper;
  64. use PHPCR\Util\QOM\Sql2ToQomQueryConverter;
  65. use PHPCR\Util\UUIDHelper;
  66. use PHPCR\Util\ValueConverter;
  67. use stdClass;
  69. /**
  70.  * Class to handle the communication between Jackalope and RDBMS via Doctrine DBAL.
  71.  *
  72.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  73.  * @license http://opensource.org/licenses/MIT MIT License
  74.  *
  75.  * @author Benjamin Eberlei <kontakt@beberlei.de>
  76.  * @author Lukas Kahwe Smith <smith@pooteeweet.org>
  77.  */
  78. class Client extends BaseTransport implements QueryTransport, WritingInterface, WorkspaceManagementInterface, NodeTypeManagementInterface, TransactionInterface
  79. {
  80.     /**
  81.      * SQlite can only handle a maximum of 999 parameters inside an IN statement
  82.      * see https://github.com/jackalope/jackalope-doctrine-dbal/pull/149/files#diff-a3a0165ed79ca1ba3513ec5ecd59ec56R707
  83.      */
  84.     const SQLITE_MAXIMUM_IN_PARAM_COUNT = 999;
  86.     /**
  87.      * The factory to instantiate objects
  88.      *
  89.      * @var FactoryInterface
  90.      */
  91.     protected $factory;
  93.     /**
  94.      * @var ValueConverter
  95.      */
  96.     protected $valueConverter;
  98.     /**
  99.      * @var Connection
  100.      */
  101.     private $conn;
  103.     /**
  104.      * @var Closure
  105.      */
  106.     private $uuidGenerator;
  108.     /**
  109.      * @var bool
  110.      */
  111.     private $loggedIn = false;
  113.     /**
  114.      * @var SimpleCredentials
  115.      */
  116.     private $credentials;
  118.     /**
  119.      * @var string
  120.      */
  121.     protected $workspaceName;
  123.     /**
  124.      * @var array
  125.      */
  126.     private $nodeIdentifiers = [];
  128.     /**
  129.      * @var NodeTypeManager
  130.      */
  131.     private $nodeTypeManager;
  133.     /**
  134.      * @var bool
  135.      */
  136.     protected $inTransaction = false;
  138.     /**
  139.      * Check if an initial request on login should be send to check if repository exists
  140.      * This is according to the JCR specifications and set to true by default
  141.      *
  142.      * @see setCheckLoginOnServer
  143.      *
  144.      * @var bool
  145.      */
  146.     private $checkLoginOnServer = true;
  148.     /**
  149.      * Using an ArrayObject here so that we can pass this into the NodeProcessor by reference more elegantly
  150.      *
  151.      * @var null|ArrayObject
  152.      */
  153.     protected $namespaces;
  155.     /**
  156.      * @var null|array The namespaces at initial state when making changes to the namespaces, in case of rollback.
  157.      */
  158.     private $originalNamespaces;
  160.     /**
  161.      * The core namespaces defined in JCR
  162.      *
  163.      * @var array
  164.      */
  165.     private $coreNamespaces = [
  166.         NS::PREFIX_EMPTY => NS::NAMESPACE_EMPTY,
  167.         NS::PREFIX_JCR => NS::NAMESPACE_JCR,
  168.         NS::PREFIX_NT => NS::NAMESPACE_NT,
  169.         NS::PREFIX_MIX => NS::NAMESPACE_MIX,
  170.         NS::PREFIX_XML => NS::NAMESPACE_XML,
  171.         NS::PREFIX_SV => NS::NAMESPACE_SV,
  172.     ];
  174.     /**
  175.      * @var string|null
  176.      */
  177.     private $sequenceNodeName;
  179.     /**
  180.      * @var string|null
  181.      */
  182.     private $sequenceTypeName;
  184.     /**
  185.      * @var array
  186.      */
  187.     private $referencesToUpdate = [];
  189.     /**
  190.      * @var array
  191.      */
  192.     private $referenceTables = [
  193.         PropertyType::REFERENCE => 'phpcr_nodes_references',
  194.         PropertyType::WEAKREFERENCE => 'phpcr_nodes_weakreferences',
  195.     ];
  197.     /**
  198.      * @var array
  199.      */
  200.     private $referencesToDelete = [];
  202.     /**
  203.      * @var boolean
  204.      */
  205.     private $connectionInitialized = false;
  207.     /**
  208.      * @var NodeProcessor
  209.      */
  210.     private $nodeProcessor;
  212.     /**
  213.      * @var string
  214.      */
  215.     private $caseSensitiveEncoding = null;
  217.     /**
  218.      * @param FactoryInterface $factory
  219.      * @param Connection $conn
  220.      */
  221.     public function __construct(FactoryInterface $factory, Connection $conn)
  222.     {
  223.         $this->factory = $factory;
  224.         $this->valueConverter = $this->factory->get(ValueConverter::class);
  225.         $this->conn = $conn;
  226.     }
  228.     /**
  229.      * @TODO: move to "SqlitePlatform" and rename to "registerExtraFunctions"?
  230.      *
  231.      * @param PDO $sqliteConnection
  232.      *
  233.      * @return Client
  234.      */
  235.     private function registerSqliteFunctions(PDO $sqliteConnection)
  236.     {
  237.         $sqliteConnection->sqliteCreateFunction(
  238.             'EXTRACTVALUE',
  239.             function ($string, $expression) {
  240.                 if (null === $string) {
  241.                     return null;
  242.                 }
  244.                 $dom = new DOMDocument('1.0', 'UTF-8');
  245.                 $dom->loadXML($string);
  246.                 $xpath = new DOMXPath($dom);
  247.                 $list = $xpath->evaluate($expression);
  249.                 if (!is_object($list)) {
  250.                     return $list;
  251.                 }
  253.                 // @TODO: don't know if there are expressions returning more then one row
  254.                 if ($list->length > 0) {
  255.                     // @TODO: why it can happen that we do not have a type? https://github.com/phpcr/phpcr-api-tests/pull/132
  256.                     $type = is_object($list->item(0)->parentNode->attributes->getNamedItem('type')) ? $list->item(
  257.                         0
  258.                     )->parentNode->attributes->getNamedItem('type')->value : null;
  259.                     $content = $list->item(0)->textContent;
  261.                     switch ($type) {
  262.                         case 'long':
  263.                             return (int)$content;
  264.                             break;
  265.                         case 'double':
  266.                             return (double)$content;
  267.                             break;
  268.                         default:
  269.                             return $content;
  270.                     }
  271.                 }
  273.                 // @TODO: don't know if return value is right
  274.                 return null;
  275.             },
  276.             2
  277.         );
  279.         $sqliteConnection->sqliteCreateFunction(
  280.             'CONCAT',
  281.             function () {
  282.                 return implode('', func_get_args());
  283.             }
  284.         );
  286.         return $this;
  287.     }
  289.     /**
  290.      * @return Connection
  291.      */
  292.     public function getConnection()
  293.     {
  294.         $this->initConnection();
  296.         return $this->conn;
  297.     }
  299.     /**
  300.      * Set the UUID generator to use. If not set, the phpcr-utils UUIDHelper
  301.      * will be used.
  302.      *
  303.      * @param Closure $generator
  304.      */
  305.     public function setUuidGenerator(Closure $generator)
  306.     {
  307.         $this->uuidGenerator = $generator;
  308.     }
  310.     /**
  311.      * @return callable a uuid generator function.
  312.      */
  313.     protected function getUuidGenerator()
  314.     {
  315.         if (!$this->uuidGenerator) {
  316.             $this->uuidGenerator = function () {
  317.                 return UUIDHelper::generateUUID();
  318.             };
  319.         }
  321.         return $this->uuidGenerator;
  322.     }
  324.     /**
  325.      * @return string a universally unique id.
  326.      */
  327.     protected function generateUuid()
  328.     {
  329.         // php 5.3 compatibility, no direct execution of this function.
  330.         $g = $this->getUuidGenerator();
  332.         return $g();
  333.     }
  335.     /**
  336.      * {@inheritDoc}
  337.      *
  338.      * @throws NotImplementedException
  339.      */
  340.     public function createWorkspace($name, $srcWorkspace = null)
  341.     {
  342.         if (null !== $srcWorkspace) {
  343.             throw new NotImplementedException('Creating workspace as clone of existing workspace not supported');
  344.         }
  346.         if ($this->workspaceExists($name)) {
  347.             throw new RepositoryException("Workspace '$name' already exists");
  348.         }
  350.         try {
  351.             $this->getConnection()->insert('phpcr_workspaces', ['name' => $name]);
  352.         } catch (Exception $e) {
  353.             throw new RepositoryException("Couldn't create Workspace '$name': " . $e->getMessage(), 0, $e);
  354.         }
  356.         $this->getConnection()->insert(
  357.             'phpcr_nodes',
  358.             [
  359.                 'path' => '/',
  360.                 'parent' => '',
  361.                 'workspace_name' => $name,
  362.                 'identifier' => $this->generateUuid(),
  363.                 'type' => 'nt:unstructured',
  364.                 'local_name' => '',
  365.                 'namespace' => '',
  366.                 'props' => '<?xml version="1.0" encoding="UTF-8"?>
  367. <sv:node xmlns:' . NS::PREFIX_MIX . '="' . NS::NAMESPACE_MIX . '" xmlns:' . NS::PREFIX_NT . '="' . NS::NAMESPACE_NT . '" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:' . NS::PREFIX_JCR . '="' . NS::NAMESPACE_JCR . '" xmlns:' . NS::PREFIX_SV . '="' . NS::NAMESPACE_SV . '" xmlns:rep="internal" />',
  368.                 // TODO compute proper value
  369.                 'depth' => 0,
  370.             ]
  371.         );
  372.     }
  374.     /**
  375.      * {@inheritDoc}
  376.      */
  377.     public function deleteWorkspace($name)
  378.     {
  379.         if (!$this->workspaceExists($name)) {
  380.             throw new RepositoryException("Workspace '$name' cannot be deleted as it does not exist");
  381.         }
  383.         try {
  384.             $this->getConnection()->delete('phpcr_workspaces', ['name' => $name]);
  385.         } catch (Exception $e) {
  386.             throw new RepositoryException("Couldn't delete workspace '$name': " . $e->getMessage(), 0, $e);
  387.         }
  389.         try {
  390.             $this->getConnection()->delete('phpcr_nodes', ['workspace_name' => $name]);
  391.         } catch (Exception $e) {
  392.             throw new RepositoryException("Couldn't delete nodes in workspace '$name': " . $e->getMessage(), 0, $e);
  393.         }
  395.         try {
  396.             $this->getConnection()->delete('phpcr_binarydata', ['workspace_name' => $name]);
  397.         } catch (Exception $e) {
  398.             throw new RepositoryException(
  399.                 "Couldn't delete binary data in workspace '$name': " . $e->getMessage(), 0, $e
  400.             );
  401.         }
  402.     }
  404.     /**
  405.      * {@inheritDoc}
  406.      *
  407.      * @throws NotImplementedException
  408.      * @throws AccessDeniedException
  409.      * @throws UnsupportedRepositoryOperationException
  410.      */
  411.     public function login(CredentialsInterface $credentials = null, $workspaceName = null)
  412.     {
  413.         $this->credentials = $credentials;
  415.         $this->workspaceName = $workspaceName ?: 'default';
  417.         if (!$this->checkLoginOnServer) {
  418.             return $this->workspaceName;
  419.         }
  421.         if (!$this->workspaceExists($this->workspaceName)) {
  422.             if ('default' !== $this->workspaceName) {
  423.                 throw new NoSuchWorkspaceException("Requested workspace: '{$this->workspaceName}'");
  424.             }
  426.             // Create default workspace if it not exists
  427.             $this->createWorkspace($this->workspaceName);
  428.         }
  430.         $this->loggedIn = true;
  432.         return $this->workspaceName;
  433.     }
  435.     /**
  436.      * {@inheritDoc}
  437.      */
  438.     public function logout()
  439.     {
  440.         if ($this->loggedIn) {
  441.             $this->loggedIn = false;
  442.             $this->conn->close();
  443.             $this->conn = null;
  444.         }
  445.     }
  447.     /**
  448.      * Configure whether to check if we are logged in before doing a request.
  449.      *
  450.      * Will improve error reporting at the cost of some round trips.
  451.      */
  452.     public function setCheckLoginOnServer($bool)
  453.     {
  454.         $this->checkLoginOnServer = $bool;
  455.     }
  457.     /**
  458.      * This will control the collate which is being used on MySQL when querying nodes. It will be autodetected by just
  459.      * appending _bin to the current charset, which is good enough in most cases.
  460.      *
  461.      * @param string $encoding
  462.      */
  463.     public function setCaseSensitiveEncoding($encoding)
  464.     {
  465.         $this->caseSensitiveEncoding = $encoding;
  466.     }
  468.     /**
  469.      * Returns the collate which is being used on MySQL when querying nodes.
  470.      *
  471.      * @return string
  472.      */
  473.     private function getCaseSensitiveEncoding()
  474.     {
  475.         if (null !== $this->caseSensitiveEncoding) {
  476.             return $this->caseSensitiveEncoding;
  477.         }
  479.         $params = $this->conn->getParams();
  480.         $charset = isset($params['charset']) ? $params['charset'] : 'utf8';
  481.         if (isset($params['defaultTableOptions']) && isset($params['defaultTableOptions']['collate'])) {
  482.             return $this->caseSensitiveEncoding = $params['defaultTableOptions']['collate'];
  483.         }
  485.         return $this->caseSensitiveEncoding = $charset === 'binary' ? $charset : $charset . '_bin';
  486.     }
  488.     protected function workspaceExists($workspaceName)
  489.     {
  490.         try {
  491.             $query = 'SELECT 1 FROM phpcr_workspaces WHERE name = ?';
  492.             $result = $this->getConnection()->fetchColumn($query, [$workspaceName]);
  493.         } catch (Exception $e) {
  494.             if ($e instanceof DBALException || $e instanceof PDOException) {
  495.                 if (1045 === $e->getCode()) {
  496.                     throw new LoginException('Access denied with your credentials: ' . $e->getMessage());
  497.                 }
  498.                 if ('42S02' === $e->getCode()) {
  499.                     throw new RepositoryException(
  500.                         'You did not properly set up the database for the repository. See README.md for more information. Message from backend: ' . $e->getMessage(
  501.                         )
  502.                     );
  503.                 }
  505.                 throw new RepositoryException('Unexpected error talking to the backend: ' . $e->getMessage(), 0, $e);
  506.             }
  508.             throw $e;
  509.         }
  511.         return $result;
  512.     }
  514.     /**
  515.      * Ensure that we are currently logged in, executing the login in case we
  516.      * did lazy login.
  517.      *
  518.      * @throws NotImplementedException
  519.      * @throws AccessDeniedException
  520.      * @throws LoginException
  521.      * @throws NoSuchWorkspaceException
  522.      * @throws UnsupportedRepositoryOperationException
  523.      * @throws RepositoryException if this transport is not logged in.
  524.      */
  525.     protected function assertLoggedIn()
  526.     {
  527.         if (!$this->loggedIn) {
  528.             if (!$this->checkLoginOnServer && $this->workspaceName) {
  529.                 $this->checkLoginOnServer = true;
  530.                 if ($this->login($this->credentials, $this->workspaceName)) {
  531.                     return;
  532.                 }
  533.             }
  535.             throw new RepositoryException('You need to be logged in for this operation');
  536.         }
  537.     }
  539.     /**
  540.      * {@inheritDoc}
  541.      */
  542.     public function getRepositoryDescriptors()
  543.     {
  544.         return [
  545.             RepositoryInterface::IDENTIFIER_STABILITY => RepositoryInterface::IDENTIFIER_STABILITY_INDEFINITE_DURATION,
  546.             RepositoryInterface::REP_NAME_DESC => 'jackalope_doctrine_dbal',
  547.             RepositoryInterface::REP_VENDOR_DESC => 'Jackalope Community',
  548.             RepositoryInterface::REP_VENDOR_URL_DESC => 'http://github.com/jackalope',
  549.             RepositoryInterface::REP_VERSION_DESC => '1.1.0-DEV',
  550.             RepositoryInterface::SPEC_NAME_DESC => 'Content Repository for PHP',
  551.             RepositoryInterface::SPEC_VERSION_DESC => '2.1',
  552.             RepositoryInterface::NODE_TYPE_MANAGEMENT_AUTOCREATED_DEFINITIONS_SUPPORTED => true,
  553.             RepositoryInterface::NODE_TYPE_MANAGEMENT_INHERITANCE => RepositoryInterface::NODE_TYPE_MANAGEMENT_INHERITANCE_SINGLE,
  554.             RepositoryInterface::NODE_TYPE_MANAGEMENT_MULTIPLE_BINARY_PROPERTIES_SUPPORTED => true,
  555.             RepositoryInterface::NODE_TYPE_MANAGEMENT_MULTIVALUED_PROPERTIES_SUPPORTED => true,
  556.             RepositoryInterface::NODE_TYPE_MANAGEMENT_ORDERABLE_CHILD_NODES_SUPPORTED => true,
  557.             RepositoryInterface::NODE_TYPE_MANAGEMENT_OVERRIDES_SUPPORTED => false,
  558.             RepositoryInterface::NODE_TYPE_MANAGEMENT_PRIMARY_ITEM_NAME_SUPPORTED => true,
  559.             RepositoryInterface::NODE_TYPE_MANAGEMENT_PROPERTY_TYPES => true,
  560.             RepositoryInterface::NODE_TYPE_MANAGEMENT_RESIDUAL_DEFINITIONS_SUPPORTED => false,
  561.             RepositoryInterface::NODE_TYPE_MANAGEMENT_SAME_NAME_SIBLINGS_SUPPORTED => false,
  562.             RepositoryInterface::NODE_TYPE_MANAGEMENT_UPDATE_IN_USE_SUPPORTED => false,
  563.             RepositoryInterface::NODE_TYPE_MANAGEMENT_VALUE_CONSTRAINTS_SUPPORTED => false,
  564.             RepositoryInterface::OPTION_ACCESS_CONTROL_SUPPORTED => false,
  565.             RepositoryInterface::OPTION_ACTIVITIES_SUPPORTED => false,
  566.             RepositoryInterface::OPTION_BASELINES_SUPPORTED => false,
  567.             RepositoryInterface::OPTION_JOURNALED_OBSERVATION_SUPPORTED => false,
  568.             RepositoryInterface::OPTION_LIFECYCLE_SUPPORTED => false,
  569.             RepositoryInterface::OPTION_LOCKING_SUPPORTED => false,
  570.             RepositoryInterface::OPTION_NODE_AND_PROPERTY_WITH_SAME_NAME_SUPPORTED => true,
  571.             RepositoryInterface::OPTION_NODE_TYPE_MANAGEMENT_SUPPORTED => true,
  572.             RepositoryInterface::OPTION_OBSERVATION_SUPPORTED => false,
  573.             RepositoryInterface::OPTION_RETENTION_SUPPORTED => false,
  574.             RepositoryInterface::OPTION_SHAREABLE_NODES_SUPPORTED => false,
  575.             RepositoryInterface::OPTION_SIMPLE_VERSIONING_SUPPORTED => false,
  576.             RepositoryInterface::OPTION_TRANSACTIONS_SUPPORTED => true,
  577.             RepositoryInterface::OPTION_UNFILED_CONTENT_SUPPORTED => true,
  578.             RepositoryInterface::OPTION_UPDATE_MIXIN_NODETYPES_SUPPORTED => true,
  579.             RepositoryInterface::OPTION_UPDATE_PRIMARY_NODETYPE_SUPPORTED => true,
  580.             RepositoryInterface::OPTION_VERSIONING_SUPPORTED => false,
  581.             RepositoryInterface::OPTION_WORKSPACE_MANAGEMENT_SUPPORTED => true,
  582.             RepositoryInterface::OPTION_XML_EXPORT_SUPPORTED => true,
  583.             RepositoryInterface::OPTION_XML_IMPORT_SUPPORTED => true,
  584.             RepositoryInterface::QUERY_FULL_TEXT_SEARCH_SUPPORTED => true,
  585.             RepositoryInterface::QUERY_CANCEL_SUPPORTED => false,
  586.             RepositoryInterface::QUERY_JOINS => RepositoryInterface::QUERY_JOINS_NONE,
  587.             RepositoryInterface::QUERY_LANGUAGES => [QueryInterface::JCR_SQL2, QueryInterface::JCR_JQOM],
  588.             RepositoryInterface::QUERY_STORED_QUERIES_SUPPORTED => false,
  589.             RepositoryInterface::WRITE_SUPPORTED => true,
  590.         ];
  591.     }
  593.     /**
  594.      * Get the registered namespace prefixes
  595.      *
  596.      * @return array
  597.      */
  598.     private function getNamespacePrefixes()
  599.     {
  600.         return array_keys($this->getNamespaces());
  601.     }
  603.     /**
  604.      * {@inheritDoc}
  605.      */
  606.     public function getNamespaces()
  607.     {
  608.         return (array)$this->getNamespacesObject();
  609.     }
  611.     /**
  612.      * Return the namespaces of the current session as a referenceable ArrayObject.
  613.      *
  614.      * @return ArrayObject
  615.      */
  616.     protected function getNamespacesObject()
  617.     {
  618.         if (null === $this->namespaces) {
  619.             $query = 'SELECT prefix, uri FROM phpcr_namespaces';
  620.             $result = $this->getConnection()->query($query);
  621.             $namespaces = (array)$result->fetchAll(\PDO::FETCH_KEY_PAIR);
  622.             $namespaces += $this->coreNamespaces;
  624.             $this->setNamespaces($namespaces);
  625.         }
  627.         return $this->namespaces;
  628.     }
  630.     /**
  631.      * Set the namespaces property to an \ArrayObject instance
  632.      *
  633.      * @param array|ArrayObject $namespaces
  634.      */
  635.     protected function setNamespaces($namespaces)
  636.     {
  637.         if ($this->namespaces instanceof ArrayObject) {
  638.             $this->namespaces->exchangeArray($namespaces);
  639.         } else {
  640.             $this->namespaces = new ArrayObject($namespaces);
  641.         }
  642.     }
  644.     /**
  645.      * Executes an UPDATE on DBAL while ensuring that we never try to send more than 999 parameters to SQLite
  646.      *
  647.      * @param $query
  648.      * @param array $params
  649.      *
  650.      * @throws DBALException
  651.      */
  652.     private function executeChunkedUpdate($query, array $params)
  653.     {
  654.         $types = [Connection::PARAM_INT_ARRAY];
  656.         if ($this->getConnection()->getDatabasePlatform() instanceof SqlitePlatform) {
  657.             foreach (array_chunk($params, self::SQLITE_MAXIMUM_IN_PARAM_COUNT) as $chunk) {
  658.                 $this->getConnection()->executeUpdate($query, [$chunk], $types);
  659.             }
  660.         } else {
  661.             $this->getConnection()->executeUpdate($query, [$params], $types);
  662.         }
  663.     }
  665.     /**
  666.      * {@inheritDoc}
  667.      *
  668.      * @throws NoSuchWorkspaceException
  669.      * @throws RepositoryException
  670.      * @throws PathNotFoundException
  671.      * @throws ItemExistsException
  672.      * @throws DBALException
  673.      * @throws InvalidArgumentException
  674.      */
  675.     public function copyNode($srcAbsPath, $dstAbsPath, $srcWorkspace = null)
  676.     {
  677.         $this->assertLoggedIn();
  679.         if (null !== $srcWorkspace && !$this->workspaceExists($srcWorkspace)) {
  680.             throw new NoSuchWorkspaceException("Source workspace '$srcWorkspace' does not exist.");
  681.         }
  682.         $srcWorkspace = $srcWorkspace ?: $this->workspaceName;
  684.         PathHelper::assertValidAbsolutePath($dstAbsPath, true, true, $this->getNamespacePrefixes());
  686.         $srcNodeId = $this->getSystemIdForNode($srcAbsPath, $srcWorkspace);
  687.         if (!$srcNodeId) {
  688.             throw new PathNotFoundException("Source path '$srcAbsPath' not found");
  689.         }
  691.         if ($this->getSystemIdForNode($dstAbsPath)) {
  692.             throw new ItemExistsException("Cannot copy to destination path '$dstAbsPath' that already exists.");
  693.         }
  695.         if (!$this->getSystemIdForNode(PathHelper::getParentPath($dstAbsPath))) {
  696.             throw new PathNotFoundException("Parent of the destination path '" . $dstAbsPath . "' has to exist.");
  697.         }
  699.         // Algorithm:
  700.         // 1. Select all nodes with path $srcAbsPath."%" and iterate them
  701.         // 2. create a new node with path $dstAbsPath + leftovers, with a new uuid. Save old => new uuid
  702.         // 3. copy all properties from old node to new node
  703.         // 4. if a reference is in the properties, either update the uuid based on the map if its inside the copied graph or keep it.
  704.         // 5. "May drop mixin types"
  706.         $query = 'SELECT * FROM phpcr_nodes WHERE (path = ? OR path LIKE ?) AND workspace_name = ? ORDER BY depth, sort_order';
  707.         $stmt = $this->getConnection()->executeQuery($query, [$srcAbsPath, $srcAbsPath . '/%', $srcWorkspace]);
  708.         $rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
  710.         $uuidMap = [];
  711.         $resultSetUuids = [];
  713.         // first iterate and build up an array of all the UUIDs in the result set
  714.         foreach ($rows as $row) {
  715.             $resultSetUuids[$row['identifier']] = $row['path'];
  716.         }
  718.         // array of references to remap within the copied tree
  719.         $referenceElsToRemap = [];
  721.         // array references that will need updating in the database
  722.         $referencesToUpdate = [];
  724.         foreach ($rows as $row) {
  725.             $newPath = str_replace($srcAbsPath, $dstAbsPath, $row['path']);
  727.             $stringDom = new DOMDocument('1.0', 'UTF-8');
  728.             $stringDom->loadXML($row['props']);
  729.             $numericalDom = null;
  730.             if ($row['numerical_props']) {
  731.                 $numericalDom = new DOMDocument('1.0', 'UTF-8');
  732.                 $numericalDom->loadXML($row['numerical_props']);
  733.             }
  735.             $propsData = [
  736.                 'stringDom' => $stringDom,
  737.                 'numericalDom' => $numericalDom,
  738.                 'references' => [],
  739.             ];
  741.             $xpath = new DOMXpath($stringDom);
  742.             $referenceEls = $xpath->query(
  743.                 './/sv:property[@sv:type="reference" or @sv:type="Reference" or @sv:type="weakreference" or @sv:type="WeakReference"]'
  744.             );
  746.             $references = [];
  747.             foreach ($referenceEls as $referenceEl) {
  748.                 $propName = $referenceEl->getAttribute('sv:name');
  749.                 $values = [];
  750.                 foreach ($xpath->query('./sv:value', $referenceEl) as $valueEl) {
  751.                     $values[] = $valueEl->nodeValue;
  752.                 }
  754.                 $references[$propName] = [
  755.                     'type' => PropertyType::valueFromName($referenceEl->getAttribute('sv:type')),
  756.                     'values' => $values,
  757.                 ];
  759.                 if (isset($resultSetUuids[$referenceEl->nodeValue])) {
  760.                     $referenceElsToRemap[] = [$referenceEl, $newPath, $row['type'], $propsData];
  761.                 }
  762.             }
  764.             $originalUuid = $row['identifier'];
  766.             // when copying a node, the copy is always a new node. set $isNewNode to true
  767.             $newNodeId = $this->syncNode(null, $newPath, $row['type'], true, [], $propsData);
  769.             if ($references) {
  770.                 $referencesToUpdate[$newNodeId] = [
  771.                     'path' => $row['path'],
  772.                     'properties' => $references,
  773.                 ];
  774.             }
  776.             $newUuid = $this->nodeIdentifiers[$newPath];
  777.             $uuidMap[$originalUuid] = $newUuid;
  779.             $query = 'INSERT INTO phpcr_binarydata (node_id, property_name, workspace_name, idx, data)' . '   SELECT ?, b.property_name, ?, b.idx, b.data FROM phpcr_binarydata b WHERE b.node_id = ?';
  781.             try {
  782.                 $this->getConnection()->executeUpdate($query, [$newNodeId, $this->workspaceName, $row['id']]);
  783.             } catch (DBALException $e) {
  784.                 throw new RepositoryException(
  785.                     "Unexpected exception while copying node from $srcAbsPath to $dstAbsPath",
  786.                     $e->getCode(),
  787.                     $e
  788.                 );
  789.             }
  790.         }
  792.         foreach ($referenceElsToRemap as $data) {
  793.             list($referenceEl, $newPath, $type, $propsData) = $data;
  794.             $referenceEl->nodeValue = $uuidMap[$referenceEl->nodeValue];
  796.             $this->syncNode($this->nodeIdentifiers[$newPath], $newPath, $type, false, [], $propsData);
  797.         }
  799.         $this->syncReferences($referencesToUpdate);
  800.     }
  802.     /**
  803.      * @param string $path
  804.      *
  805.      * @return array
  806.      *
  807.      * @throws NamespaceException
  808.      */
  809.     private function getJcrName($path)
  810.     {
  811.         $name = implode('', array_slice(explode('/', $path), -1, 1));
  812.         $alias = '';
  814.         if (($aliasLength = strpos($name, ':')) !== false) {
  815.             $alias = substr($name, 0, $aliasLength);
  816.             $name = substr($name, $aliasLength + 1);
  817.         }
  819.         $namespaces = $this->getNamespaces();
  821.         if (!isset($namespaces[$alias])) {
  822.             throw new NamespaceException("the namespace $alias was not registered.");
  823.         }
  825.         return [$namespaces[$alias], $name];
  826.     }
  828.     /**
  829.      * Actually write the node into the database
  830.      *
  831.      * @param string $uuid node uuid
  832.      * @param string $path absolute path of the node
  833.      * @param string $type node type name
  834.      * @param boolean $isNewNode new nodes to insert (true) or existing node to update (false)
  835.      * @param Property[] $props
  836.      * @param array $propsData
  837.      *
  838.      * @return boolean|string
  839.      *
  840.      * @throws ItemExistsException
  841.      * @throws RepositoryException
  842.      * @throws NamespaceException
  843.      * @throws Exception
  844.      */
  845.     private function syncNode($uuid, $path, $type, $isNewNode, $props = [], $propsData = [])
  846.     {
  847.         // TODO: Not sure if there are always ALL props in $props, should we grab the online data here?
  848.         // TODO: PERFORMANCE Binary data is handled very inefficiently here, UPSERT will really be necessary here as well as lazy handling
  850.         if (!$propsData) {
  851.             $propsData = $this->propsToXML($props);
  852.         }
  854.         if (null === $uuid) {
  855.             $uuid = $this->generateUuid();
  856.         }
  858.         if ($isNewNode) {
  859.             list($namespace, $localName) = $this->getJcrName($path);
  861.             $qb = $this->getConnection()->createQueryBuilder();
  863.             $qb->select(
  864.                 ':identifier, :type, :path, :local_name, :namespace, :parent, :workspace_name, :props, :numerical_props, :depth, COALESCE(MAX(n.sort_order), 0) + 1'
  865.             )->from('phpcr_nodes', 'n')->where('n.parent = :parent_a');
  867.             $sql = $qb->getSQL();
  869.             try {
  870.                 $insert = "INSERT INTO phpcr_nodes (identifier, type, path, local_name, namespace, parent, workspace_name, props, numerical_props, depth, sort_order) " . $sql;
  872.                 $this->getConnection()->executeUpdate(
  873.                     $insert,
  874.                     $data = [
  875.                         'identifier' => $uuid,
  876.                         'type' => $type,
  877.                         'path' => $path,
  878.                         'local_name' => $localName,
  879.                         'namespace' => $namespace,
  880.                         'parent' => PathHelper::getParentPath($path),
  881.                         'workspace_name' => $this->workspaceName,
  882.                         'props' => $propsData['stringDom']->saveXML(),
  883.                         'numerical_props' => $propsData['numericalDom'] ? $propsData['numericalDom']->saveXML() : null,
  884.                         'depth' => PathHelper::getPathDepth($path),
  885.                         'parent_a' => PathHelper::getParentPath($path),
  886.                     ]
  887.                 );
  888.             } catch (Exception $e) {
  889.                 if ($e instanceof PDOException || $e instanceof DBALException) {
  890.                     if (strpos($e->getMessage(), 'SQLSTATE[23') !== false) {
  891.                         throw new ItemExistsException('Item ' . $path . ' already exists in the database');
  892.                     } else {
  893.                         throw new RepositoryException(
  894.                             'Unknown database error while inserting item ' . $path . ': ' . $e->getMessage(), 0, $e
  895.                         );
  896.                     }
  897.                 } else {
  898.                     throw $e;
  899.                 }
  900.             }
  902.             $nodeId = $this->getConnection()->lastInsertId($this->sequenceNodeName);
  903.         } else {
  904.             $nodeId = $this->getSystemIdForNode($path);
  905.             if (!$nodeId) {
  906.                 throw new RepositoryException("nodeId for $path not found");
  907.             }
  909.             $this->getConnection()->update(
  910.                 'phpcr_nodes',
  911.                 [
  912.                     'props' => $propsData['stringDom']->saveXML(),
  913.                     'numerical_props' => $propsData['numericalDom'] ? $propsData['numericalDom']->saveXML() : null,
  914.                 ],
  915.                 ['id' => $nodeId]
  916.             );
  917.         }
  919.         $this->nodeIdentifiers[$path] = $uuid;
  921.         if (!empty($propsData['binaryData'])) {
  922.             $this->syncBinaryData($nodeId, $propsData['binaryData']);
  923.         }
  925.         $this->referencesToUpdate[$nodeId] = ['path' => $path, 'properties' => $propsData['references']];
  927.         return $nodeId;
  928.     }
  930.     /**
  931.      * @param $nodeId
  932.      * @param $binaryData
  933.      */
  934.     private function syncBinaryData($nodeId, $binaryData)
  935.     {
  936.         foreach ($binaryData as $propertyName => $binaryValues) {
  937.             foreach ($binaryValues as $idx => $data) {
  938.                 // TODO verify in which cases we can just update
  939.                 $params = [
  940.                     'node_id' => $nodeId,
  941.                     'property_name' => $propertyName,
  942.                     'workspace_name' => $this->workspaceName,
  943.                 ];
  945.                 $this->getConnection()->delete('phpcr_binarydata', $params);
  947.                 $params['idx'] = $idx;
  948.                 $params['data'] = $data;
  949.                 $types = [
  950.                     PDO::PARAM_INT,
  951.                     PDO::PARAM_STR,
  952.                     PDO::PARAM_STR,
  953.                     PDO::PARAM_INT,
  954.                     PDO::PARAM_LOB
  955.                 ];
  956.                 $this->getConnection()->insert('phpcr_binarydata', $params, $types);
  957.             }
  958.         }
  959.     }
  961.     /**
  962.      * @param array $referencesToUpdate
  963.      *
  964.      * @throws RepositoryException
  965.      * @throws ReferentialIntegrityException
  966.      */
  967.     private function syncReferences(array $referencesToUpdate)
  968.     {
  969.         if ($referencesToUpdate) {
  970.             // do not update references that are going to be deleted anyways
  971.             $toUpdate = array_diff(array_keys($referencesToUpdate), array_keys($this->referencesToDelete));
  973.             try {
  974.                 foreach ($this->referenceTables as $table) {
  975.                     $query = "DELETE FROM $table WHERE source_id IN (?)";
  976.                     $this->executeChunkedUpdate($query, $toUpdate);
  977.                 }
  978.             } catch (DBALException $e) {
  979.                 throw new RepositoryException('Unexpected exception while cleaning up after saving', $e->getCode(), $e);
  980.             }
  982.             $updates = [];
  983.             foreach ($toUpdate as $nodeId) {
  984.                 $references = $referencesToUpdate[$nodeId];
  985.                 foreach ($references['properties'] as $name => $data) {
  986.                     foreach ($data['values'] as $value) {
  987.                         $targetId = $this->getSystemIdForNode($value);
  988.                         if (false === $targetId) {
  989.                             if (PropertyType::REFERENCE === $data['type']) {
  990.                                 throw new ReferentialIntegrityException(
  991.                                     sprintf(
  992.                                         'Trying to store reference to non-existant node with path "%s" in node "%s" "%s"',
  993.                                         $value,
  994.                                         $references['path'],
  995.                                         $name
  996.                                     )
  997.                                 );
  998.                             }
  1000.                             continue;
  1001.                         }
  1003.                         $key = $targetId . '-' . $nodeId . '-' . $name;
  1004.                         // it is valid to have multiple references to the same node in a multivalue
  1005.                         // but it is not desired to store duplicates in the database
  1006.                         $updates[$key] = [
  1007.                             'type' => $data['type'],
  1008.                             'data' => [
  1009.                                 'source_id' => $nodeId,
  1010.                                 'source_property_name' => $name,
  1011.                                 'target_id' => $targetId,
  1012.                             ],
  1013.                         ];
  1014.                     }
  1015.                 }
  1016.             }
  1018.             foreach ($updates as $update) {
  1019.                 $this->getConnection()->insert($this->referenceTables[$update['type']], $update['data']);
  1020.             }
  1021.         }
  1023.         // TODO on RDBMS that support deferred FKs we could skip this step
  1024.         if ($this->referencesToDelete) {
  1025.             $params = array_keys($this->referencesToDelete);
  1027.             // remove all PropertyType::REFERENCE with a source_id on a deleted node
  1028.             try {
  1029.                 $query = "DELETE FROM phpcr_nodes_references WHERE source_id IN (?)";
  1030.                 $this->executeChunkedUpdate($query, $params);
  1031.             } catch (DBALException $e) {
  1032.                 throw new RepositoryException(
  1033.                     'Unexpected exception while cleaning up deleted nodes', $e->getCode(), $e
  1034.                 );
  1035.             }
  1037.             // ensure that there are no PropertyType::REFERENCE pointing to nodes that will be deleted
  1038.             // Note: due to the outer join we cannot filter on workspace_name, but this is ok
  1039.             // since within a transaction there can never be missing referenced nodes within the current workspace
  1040.             // make sure the target node is not in the list of nodes being deleted, to allow deletion in same request
  1041.             $query = 'SELECT DISTINCT r.target_id
  1042.             FROM phpcr_nodes_references r
  1043.                 LEFT OUTER JOIN phpcr_nodes n ON r.target_id = n.id
  1044.             WHERE r.target_id IN (?)';
  1046.             if ($this->getConnection()->getDatabasePlatform() instanceof SqlitePlatform) {
  1047.                 $missingTargets = [];
  1048.                 foreach (array_chunk($params, self::SQLITE_MAXIMUM_IN_PARAM_COUNT) as $chunk) {
  1049.                     $stmt = $this->getConnection()->executeQuery($query, [$chunk], [Connection::PARAM_INT_ARRAY]);
  1050.                     $missingTargets = array_merge($missingTargets, $stmt->fetchAll(\PDO::FETCH_COLUMN));
  1051.                 }
  1052.             } else {
  1053.                 $stmt = $this->getConnection()->executeQuery($query, [$params], [Connection::PARAM_INT_ARRAY]);
  1054.                 $missingTargets = $stmt->fetchAll(PDO::FETCH_COLUMN);
  1055.             }
  1056.             if ($missingTargets) {
  1057.                 $paths = [];
  1058.                 foreach ($missingTargets as $id) {
  1059.                     if (isset($this->referencesToDelete[$id])) {
  1060.                         $paths[] = $this->referencesToDelete[$id];
  1061.                     }
  1062.                 }
  1064.                 throw new ReferentialIntegrityException(
  1065.                     "Cannot delete '" . implode("', '", $paths) . "': A reference points to this node or a subnode"
  1066.                 );
  1067.             }
  1069.             // clean up all references
  1070.             try {
  1071.                 foreach ($this->referenceTables as $table) {
  1072.                     $query = "DELETE FROM $table WHERE target_id IN (?)";
  1073.                     $this->executeChunkedUpdate($query, $params);
  1074.                 }
  1075.             } catch (DBALException $e) {
  1076.                 throw new RepositoryException(
  1077.                     'Unexpected exception while cleaning up deleted nodes', $e->getCode(), $e
  1078.                 );
  1079.             }
  1080.         }
  1081.     }
  1083.     /**
  1084.      * Convert the node XML to stdClass node representation containing all properties
  1085.      *
  1086.      * @param string $xml
  1087.      *
  1088.      * @return stdClass
  1089.      *
  1090.      * @throws InvalidArgumentException
  1091.      */
  1092.     protected function xmlToProps($xml)
  1093.     {
  1094.         $data = new stdClass();
  1096.         $dom = new DOMDocument('1.0', 'UTF-8');
  1097.         $dom->loadXML($xml);
  1099.         foreach ($dom->getElementsByTagNameNS('http://www.jcp.org/jcr/sv/1.0', 'property') as $propertyNode) {
  1100.             $this->mapPropertyFromElement($propertyNode, $data);
  1101.         }
  1103.         return $data;
  1104.     }
  1106.     /**
  1107.      * Convert the node XML to stdClass node representation containing only the given properties
  1108.      *
  1109.      * @param string $xml
  1110.      * @param array $propertyNames
  1111.      *
  1112.      * @return stdClass
  1113.      *
  1114.      * @throws InvalidArgumentException
  1115.      */
  1116.     protected function xmlToColumns($xml, $propertyNames)
  1117.     {
  1118.         $data = new stdClass();
  1119.         $dom = new DOMDocument('1.0');
  1120.         $dom->loadXML($xml);
  1121.         $dom->formatOutput = true;
  1122.         $xpath = new DOMXPath($dom);
  1124.         foreach ($propertyNames as $propertyName) {
  1125.             $els = $xpath->query(sprintf('.//sv:property[@sv:name="%s"]', $propertyName));
  1126.             if ($els->length === 0) {
  1127.                 continue;
  1128.             }
  1130.             $propertyEl = $els->item(0);
  1131.             $this->mapPropertyFromElement($propertyEl, $data);
  1132.         }
  1134.         return $data;
  1135.     }
  1137.     /**
  1138.      * Map a property from the given property XML node to the given \stdClass node representation
  1139.      *
  1140.      * @param DOMElement $propertyNode
  1141.      * @param stdClass $data
  1142.      *
  1143.      * @throws InvalidArgumentException
  1144.      */
  1145.     protected function mapPropertyFromElement(DOMElement $propertyNode, stdClass $data)
  1146.     {
  1147.         $name = $propertyNode->getAttribute('sv:name');
  1149.         $values = [];
  1151.         $type = PropertyType::valueFromName($propertyNode->getAttribute('sv:type'));
  1152.         foreach ($propertyNode->childNodes as $valueNode) {
  1153.             switch ($type) {
  1154.                 case PropertyType::NAME:
  1155.                 case PropertyType::URI:
  1156.                 case PropertyType::WEAKREFERENCE:
  1157.                 case PropertyType::REFERENCE:
  1158.                 case PropertyType::PATH:
  1159.                 case PropertyType::DECIMAL:
  1160.                 case PropertyType::STRING:
  1161.                     $values[] = $valueNode->nodeValue;
  1162.                     break;
  1163.                 case PropertyType::BOOLEAN:
  1164.                     $values[] = (bool)$valueNode->nodeValue;
  1165.                     break;
  1166.                 case PropertyType::LONG:
  1167.                     $values[] = (int)$valueNode->nodeValue;
  1168.                     break;
  1169.                 case PropertyType::BINARY:
  1170.                     $values[] = (int)$valueNode->nodeValue;
  1171.                     break;
  1172.                 case PropertyType::DATE:
  1173.                     $date = $valueNode->nodeValue;
  1174.                     if ($date) {
  1175.                         $date = new DateTime($date);
  1176.                         $date->setTimezone(new DateTimeZone(date_default_timezone_get()));
  1177.                         // Jackalope expects a string, might make sense to refactor to allow DateTime instances too
  1178.                         $date = $this->valueConverter->convertType($date, PropertyType::STRING);
  1179.                     }
  1180.                     $values[] = $date;
  1181.                     break;
  1182.                 case PropertyType::DOUBLE:
  1183.                     $values[] = (double)$valueNode->nodeValue;
  1184.                     break;
  1185.                 default:
  1186.                     throw new InvalidArgumentException("Type with constant $type not found.");
  1187.             }
  1188.         }
  1190.         switch ($type) {
  1191.             case PropertyType::BINARY:
  1192.                 $data->{':' . $name} = $propertyNode->getAttribute('sv:multi-valued') ? $values : $values[0];
  1193.                 break;
  1194.             default:
  1195.                 $data->{$name} = $propertyNode->getAttribute('sv:multi-valued') ? $values : $values[0];
  1196.                 $data->{':' . $name} = $type;
  1197.                 break;
  1198.         }
  1199.     }
  1201.     /**
  1202.      * Seperate properties array into an xml and binary data.
  1203.      *
  1204.      * @param array $properties
  1205.      *
  1206.      * @return array (
  1207.      *     'stringDom' => $stringDom,
  1208.      *     'numericalDom' => $numericalDom',
  1209.      *     'binaryData' => streams,
  1210.      *     'references' => ['type' => INT, 'values' => [UUIDs])
  1211.      * )
  1212.      *
  1213.      * @throws RepositoryException
  1214.      */
  1215.     private function propsToXML($properties)
  1216.     {
  1217.         $namespaces = [
  1218.             NS::PREFIX_MIX => NS::NAMESPACE_MIX,
  1219.             NS::PREFIX_NT => NS::NAMESPACE_NT,
  1220.             'xs' => 'http://www.w3.org/2001/XMLSchema',
  1221.             NS::PREFIX_JCR => NS::NAMESPACE_JCR,
  1222.             NS::PREFIX_SV => NS::NAMESPACE_SV,
  1223.             'rep' => 'internal',
  1224.         ];
  1226.         $doms = [
  1227.             'stringDom' => [],
  1228.             'numericalDom' => [],
  1229.         ];
  1231.         $binaryData = $references = [];
  1233.         foreach ($properties as $property) {
  1234.             $targetDoms = ['stringDom'];
  1236.             switch ($property->getType()) {
  1237.                 case PropertyType::WEAKREFERENCE:
  1238.                 case PropertyType::REFERENCE:
  1239.                     $references[$property->getName()] = [
  1240.                         'type' => $property->getType(),
  1241.                         'values' => $property->isMultiple() ? $property->getString() : [$property->getString()],
  1242.                     ];
  1243.                 case PropertyType::NAME:
  1244.                 case PropertyType::URI:
  1245.                 case PropertyType::PATH:
  1246.                 case PropertyType::STRING:
  1247.                     $values = $property->getString();
  1248.                     break;
  1249.                 case PropertyType::DECIMAL:
  1250.                     $values = $property->getDecimal();
  1251.                     $targetDoms[] = 'numericalDom';
  1252.                     break;
  1253.                 case PropertyType::BOOLEAN:
  1254.                     $values = array_map('intval', (array)$property->getBoolean());
  1255.                     break;
  1256.                 case PropertyType::LONG:
  1257.                     $values = $property->getLong();
  1258.                     $targetDoms[] = 'numericalDom';
  1259.                     break;
  1260.                 case PropertyType::BINARY:
  1261.                     if ($property->isNew() || $property->isModified()) {
  1262.                         $values = [];
  1263.                         foreach ((array)$property->getValueForStorage() as $stream) {
  1264.                             if (null === $stream) {
  1265.                                 $binary = '';
  1266.                             } else {
  1267.                                 $binary = stream_get_contents($stream);
  1268.                                 fclose($stream);
  1269.                             }
  1270.                             $binaryData[$property->getName()][] = $binary;
  1271.                             $length = strlen($binary);
  1272.                             $values[] = $length;
  1273.                         }
  1274.                     } else {
  1275.                         $values = $property->getLength();
  1276.                         if (!$property->isMultiple() && empty($values)) {
  1277.                             $values = [0];
  1278.                         }
  1279.                     }
  1280.                     break;
  1281.                 case PropertyType::DATE:
  1282.                     $values = $property->getDate();
  1283.                     if ($values instanceof DateTime) {
  1284.                         $values = [$values];
  1285.                     }
  1286.                     foreach ((array)$values as $key => $date) {
  1287.                         if ($date instanceof DateTime) {
  1288.                             // do not modify the instance which is associated with the node.
  1289.                             $date = clone $date;
  1291.                             // normalize to UTC for storage.
  1292.                             $date->setTimezone(new DateTimeZone('UTC'));
  1293.                         }
  1294.                         $values[$key] = $date;
  1295.                     }
  1296.                     $values = $this->valueConverter->convertType($values, PropertyType::STRING);
  1297.                     break;
  1298.                 case PropertyType::DOUBLE:
  1299.                     $values = $property->getDouble();
  1300.                     $targetDoms[] = 'numericalDom';
  1301.                     break;
  1302.                 default:
  1303.                     throw new RepositoryException('unknown type ' . $property->getType());
  1304.             }
  1306.             foreach ($targetDoms as $targetDom) {
  1307.                 $doms[$targetDom][] = [
  1308.                     'name' => $property->getName(),
  1309.                     'type' => PropertyType::nameFromValue($property->getType()),
  1310.                     'multiple' => $property->isMultiple(),
  1311.                     'lengths' => (array)$property->getLength(),
  1312.                     'values' => $values,
  1313.                 ];
  1314.             }
  1315.         }
  1317.         $ret = [
  1318.             'stringDom' => null,
  1319.             'numericalDom' => null,
  1320.             'binaryData' => $binaryData,
  1321.             'references' => $references
  1322.         ];
  1324.         foreach ($doms as $targetDom => $properties) {
  1325.             $dom = new DOMDocument('1.0', 'UTF-8');
  1326.             $rootNode = $dom->createElement('sv:node');
  1327.             foreach ($namespaces as $namespace => $uri) {
  1328.                 $rootNode->setAttribute('xmlns:' . $namespace, $uri);
  1329.             }
  1330.             $dom->appendChild($rootNode);
  1332.             foreach ($properties as $property) {
  1334.                 /* @var $property Property */
  1335.                 $propertyNode = $dom->createElement('sv:property');
  1336.                 $propertyNode->setAttribute('sv:name', $property['name']);
  1337.                 $propertyNode->setAttribute('sv:type', $property['type']);
  1338.                 $propertyNode->setAttribute('sv:multi-valued', $property['multiple'] ? '1' : '0');
  1339.                 $lengths = (array)$property['lengths'];
  1340.                 foreach ((array)$property['values'] as $key => $value) {
  1341.                     $element = $propertyNode->appendChild($dom->createElement('sv:value'));
  1342.                     $element->appendChild($dom->createTextNode($value));
  1343.                     if (isset($lengths[$key])) {
  1344.                         $lengthAttribute = $dom->createAttribute('length');
  1345.                         $lengthAttribute->value = $lengths[$key];
  1346.                         $element->appendChild($lengthAttribute);
  1347.                     }
  1348.                 }
  1350.                 $rootNode->appendChild($propertyNode);
  1351.             }
  1353.             if (count($properties)) {
  1354.                 $ret[$targetDom] = $dom;
  1355.             }
  1356.         }
  1358.         return $ret;
  1359.     }
  1361.     /**
  1362.      * {@inheritDoc}
  1363.      *
  1364.      * @throws DBALException
  1365.      */
  1366.     public function getAccessibleWorkspaceNames()
  1367.     {
  1368.         $query = "SELECT DISTINCT name FROM phpcr_workspaces";
  1369.         $stmt = $this->getConnection()->executeQuery($query);
  1371.         return $stmt->fetchAll(PDO::FETCH_COLUMN);
  1372.     }
  1374.     /**
  1375.      * {@inheritDoc}
  1376.      *
  1377.      * @throws RepositoryException
  1378.      * @throws DBALException
  1379.      */
  1380.     public function getNode($path)
  1381.     {
  1382.         $this->assertLoggedIn();
  1383.         PathHelper::assertValidAbsolutePath($path, false, true, $this->getNamespacePrefixes());
  1385.         $values[':path'] = $path;
  1386.         $values[':pathd'] = rtrim($path, '/') . '/%';
  1387.         $values[':workspace'] = $this->workspaceName;
  1389.         if ($this->fetchDepth > 0) {
  1390.             $values[':fetchDepth'] = $this->fetchDepth;
  1391.             $query = '
  1392.               SELECT * FROM phpcr_nodes
  1393.               WHERE (path LIKE :pathd OR path = :path)
  1394.                 AND workspace_name = :workspace
  1395.                 AND depth <= ((SELECT depth FROM phpcr_nodes WHERE path = :path AND workspace_name = :workspace) + :fetchDepth)
  1396.               ORDER BY depth, sort_order ASC';
  1397.         } else {
  1398.             $query = '
  1399.               SELECT * FROM phpcr_nodes
  1400.               WHERE path = :path
  1401.                 AND workspace_name = :workspace
  1402.               ORDER BY depth, sort_order ASC';
  1403.         }
  1405.         $stmt = $this->getConnection()->executeQuery($query, $values);
  1406.         $rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
  1407.         if (empty($rows)) {
  1408.             throw new ItemNotFoundException("Item $path not found in workspace " . $this->workspaceName);
  1409.         }
  1411.         $nestedNodes = $this->getNodesData($rows);
  1412.         $node = array_shift($nestedNodes);
  1413.         foreach ($nestedNodes as $nestedPath => $nested) {
  1414.             $relativePath = PathHelper::relativizePath($nestedPath, $path);
  1415.             $this->nestNode($node, $nested, explode('/', $relativePath));
  1416.         }
  1418.         return $node;
  1419.     }
  1421.     /**
  1422.      * Attach a node at a subpath under the ancestor node.
  1423.      *
  1424.      * @param stdClass $ancestor The root node
  1425.      * @param stdClass $node The node to add
  1426.      * @param array $nodeNames Breadcrumb of child nodes from parentNode to the node itself
  1427.      */
  1428.     private function nestNode($ancestor, $node, array $nodeNames)
  1429.     {
  1430.         while ($name = array_shift($nodeNames)) {
  1431.             if (empty($nodeNames)) {
  1432.                 $ancestor->{$name} = $node;
  1434.                 return;
  1435.             }
  1436.             $ancestor = $ancestor->{$name};
  1437.         }
  1438.     }
  1440.     /**
  1441.      * Convert a node result row to the stdClass representing all raw data.
  1442.      *
  1443.      * @param array $row
  1444.      *
  1445.      * @return stdClass raw node data
  1446.      */
  1447.     private function getNodeData($row)
  1448.     {
  1449.         $data = $this->getNodesData([$row]);
  1451.         return array_shift($data);
  1452.     }
  1454.     /**
  1455.      * Build the raw data for a list of database result rows, fetching the
  1456.      * additional information in one single query.
  1457.      *
  1458.      * @param array $rows
  1459.      *
  1460.      * @return stdClass[]
  1461.      *
  1462.      * @throws NoSuchNodeTypeException
  1463.      * @throws RepositoryException
  1464.      */
  1465.     private function getNodesData($rows)
  1466.     {
  1467.         $data = [];
  1468.         $paths = [];
  1470.         foreach ($rows as $row) {
  1471.             $this->nodeIdentifiers[$row['path']] = $row['identifier'];
  1472.             $data[$row['path']] = $this->xmlToProps($row['props']);
  1473.             $data[$row['path']]->{'jcr:primaryType'} = $row['type'];
  1474.             $paths[] = $row['path'];
  1475.         }
  1477.         $query = 'SELECT path, parent FROM phpcr_nodes WHERE parent IN (?) AND workspace_name = ? ORDER BY sort_order ASC';
  1478.         if ($this->getConnection()->getDatabasePlatform() instanceof SqlitePlatform) {
  1479.             $childrenRows = [];
  1480.             foreach (array_chunk($paths, self::SQLITE_MAXIMUM_IN_PARAM_COUNT) as $chunk) {
  1481.                 $childrenRows += $this->getConnection()->fetchAll(
  1482.                     $query,
  1483.                     [$chunk, $this->workspaceName],
  1484.                     [Connection::PARAM_STR_ARRAY, null]
  1485.                 );
  1486.             }
  1487.         } else {
  1488.             $childrenRows = $this->getConnection()->fetchAll(
  1489.                 $query,
  1490.                 [$paths, $this->workspaceName],
  1491.                 [Connection::PARAM_STR_ARRAY, null]
  1492.             );
  1493.         }
  1495.         foreach ($childrenRows as $child) {
  1496.             $childName = explode('/', $child['path']);
  1497.             $childName = end($childName);
  1498.             if (!isset($data[$child['parent']]->{$childName})) {
  1499.                 $data[$child['parent']]->{$childName} = new stdClass();
  1500.             }
  1501.         }
  1503.         foreach (array_keys($data) as $path) {
  1504.             // If the node is referenceable, return jcr:uuid.
  1505.             if (isset($data[$path]->{'jcr:mixinTypes'})) {
  1506.                 foreach ((array)$data[$path]->{'jcr:mixinTypes'} as $mixin) {
  1507.                     if ($this->nodeTypeManager->getNodeType($mixin)->isNodeType('mix:referenceable')) {
  1508.                         $data[$path]->{'jcr:uuid'} = $this->nodeIdentifiers[$path];
  1509.                         break;
  1510.                     }
  1511.                 }
  1512.             }
  1513.         }
  1515.         return $data;
  1516.     }
  1518.     /**
  1519.      * {@inheritDoc}
  1520.      *
  1521.      * @throws RepositoryException
  1522.      */
  1523.     public function getNodes($paths)
  1524.     {
  1525.         $this->assertLoggedIn();
  1527.         if (empty($paths)) {
  1528.             return [];
  1529.         }
  1531.         foreach ($paths as $path) {
  1532.             PathHelper::assertValidAbsolutePath($path, false, true, $this->getNamespacePrefixes());
  1533.         }
  1535.         $params[':workspace'] = $this->workspaceName;
  1537.         if ($this->fetchDepth > 0) {
  1538.             $params[':fetchDepth'] = $this->fetchDepth;
  1540.             $query = '
  1541.               SELECT path AS arraykey, id, path, parent, local_name, namespace, workspace_name, identifier, type, props, depth, sort_order
  1542.               FROM phpcr_nodes
  1543.               WHERE workspace_name = :workspace
  1544.                 AND (';
  1546.             $i = 0;
  1547.             foreach ($paths as $path) {
  1548.                 $params[':path' . $i] = $path;
  1549.                 $params[':pathd' . $i] = rtrim($path, '/') . '/%';
  1550.                 $subquery = 'SELECT depth FROM phpcr_nodes WHERE path = :path' . $i . ' AND workspace_name = :workspace';
  1551.                 $query .= '(path LIKE :pathd' . $i . ' OR path = :path' . $i . ') AND depth <= ((' . $subquery . ') + :fetchDepth) OR ';
  1552.                 $i++;
  1553.             }
  1554.         } else {
  1555.             $query = 'SELECT path AS arraykey, id, path, parent, local_name, namespace, workspace_name, identifier, type, props, depth, sort_order
  1556.                 FROM phpcr_nodes WHERE workspace_name = :workspace AND (';
  1558.             $i = 0;
  1559.             foreach ($paths as $path) {
  1560.                 $params[':path' . $i] = $path;
  1561.                 $query .= 'path = :path' . $i . ' OR ';
  1562.                 $i++;
  1563.             }
  1564.         }
  1566.         $query = rtrim($query, 'OR ');
  1567.         $query .= ') ORDER BY sort_order ASC';
  1569.         $stmt = $this->getConnection()->executeQuery($query, $params);
  1570.         $all = $stmt->fetchAll(PDO::FETCH_UNIQUE | PDO::FETCH_GROUP);
  1572.         $nodes = [];
  1573.         if ($all) {
  1574.             $nodes = $this->getNodesData($all);
  1575.         }
  1577.         return $nodes;
  1578.     }
  1581.     /**
  1582.      * Determine if a path exists already.
  1583.      *
  1584.      * @param string $path Path of the node
  1585.      * @param string $workspaceName To overwrite the current workspace
  1586.      *
  1587.      * @return bool
  1588.      */
  1589.     private function pathExists($path, $workspaceName = null)
  1590.     {
  1591.         return (boolean)$this->getSystemIdForNode($path, $workspaceName);
  1592.     }
  1594.     /**
  1595.      * Get the database primary key for node.
  1596.      *
  1597.      * @param string $identifier Path of the identifier
  1598.      * @param string $workspaceName To overwrite the current workspace
  1599.      *
  1600.      * @return bool|string The database id
  1601.      */
  1602.     private function getSystemIdForNode($identifier, $workspaceName = null)
  1603.     {
  1604.         if (null === $workspaceName) {
  1605.             $workspaceName = $this->workspaceName;
  1606.         }
  1608.         if (UUIDHelper::isUUID($identifier)) {
  1609.             $query = 'SELECT id FROM phpcr_nodes WHERE identifier = ? AND workspace_name = ?';
  1610.         } else {
  1611.             if ($this->getConnection()->getDriver() instanceof \Doctrine\DBAL\Driver\PDOMySql\Driver) {
  1612.                 $query = 'SELECT id FROM phpcr_nodes WHERE path COLLATE ' . $this->getCaseSensitiveEncoding(
  1613.                     ) . ' = ? AND workspace_name = ?';
  1614.             } else {
  1615.                 $query = 'SELECT id FROM phpcr_nodes WHERE path = ? AND workspace_name = ?';
  1616.             }
  1617.         }
  1619.         $nodeId = $this->getConnection()->fetchColumn($query, [$identifier, $workspaceName]);
  1621.         return $nodeId ?: false;
  1622.     }
  1624.     /**
  1625.      * {@inheritDoc}
  1626.      */
  1627.     public function getNodeByIdentifier($uuid)
  1628.     {
  1629.         $this->assertLoggedIn();
  1631.         $query = 'SELECT * FROM phpcr_nodes WHERE identifier = ? AND workspace_name = ?';
  1632.         $row = $this->getConnection()->fetchAssoc($query, [$uuid, $this->workspaceName]);
  1633.         if (!$row) {
  1634.             throw new ItemNotFoundException("Item $uuid not found in workspace " . $this->workspaceName);
  1635.         }
  1637.         $path = $row['path'];
  1638.         $data = $this->getNodeData($row);
  1639.         $data->{':jcr:path'} = $path;
  1641.         return $data;
  1642.     }
  1644.     /**
  1645.      * {@inheritDoc}
  1646.      */
  1647.     public function getNodesByIdentifier($identifiers)
  1648.     {
  1649.         $this->assertLoggedIn();
  1651.         if (empty($identifiers)) {
  1652.             return [];
  1653.         }
  1655.         $query = 'SELECT id, path, parent, local_name, namespace, workspace_name, identifier, type, props, depth, sort_order
  1656.             FROM phpcr_nodes WHERE workspace_name = ? AND identifier IN (?)';
  1657.         if ($this->getConnection()->getDatabasePlatform() instanceof SqlitePlatform) {
  1658.             $all = [];
  1659.             foreach (array_chunk($identifiers, self::SQLITE_MAXIMUM_IN_PARAM_COUNT) as $chunk) {
  1660.                 $all += $this->getConnection()->fetchAll(
  1661.                     $query,
  1662.                     [$this->workspaceName, $chunk],
  1663.                     [PDO::PARAM_STR, Connection::PARAM_STR_ARRAY]
  1664.                 );
  1665.             }
  1666.         } else {
  1667.             $all = $this->getConnection()->fetchAll(
  1668.                 $query,
  1669.                 [$this->workspaceName, $identifiers],
  1670.                 [PDO::PARAM_STR, Connection::PARAM_STR_ARRAY]
  1671.             );
  1672.         }
  1674.         $nodes = [];
  1675.         if ($all) {
  1676.             $nodesData = $this->getNodesData($all);
  1677.             // ensure that the nodes are returned in the order if how the identifiers were passed in
  1678.             $pathByUuid = [];
  1679.             foreach ($nodesData as $path => $node) {
  1680.                 $pathByUuid[$node->{'jcr:uuid'}] = $path;
  1681.             }
  1682.             foreach ($identifiers as $identifier) {
  1683.                 if (isset($pathByUuid[$identifier])) {
  1684.                     $nodes[$pathByUuid[$identifier]] = $nodesData[$pathByUuid[$identifier]];
  1685.                 }
  1686.             }
  1687.         }
  1689.         return $nodes;
  1690.     }
  1692.     /**
  1693.      * {@inheritDoc}
  1694.      *
  1695.      * @throws NotImplementedException
  1696.      * @throws ItemNotFoundException
  1697.      */
  1698.     public function getNodePathForIdentifier($uuid, $workspace = null)
  1699.     {
  1700.         if (null !== $workspace) {
  1701.             throw new NotImplementedException('Specifying the workspace is not yet supported.');
  1702.         }
  1704.         $this->assertLoggedIn();
  1706.         $query = "SELECT path FROM phpcr_nodes WHERE identifier = ? AND workspace_name = ?";
  1707.         $path = $this->getConnection()->fetchColumn($query, [$uuid, $this->workspaceName]);
  1708.         if (!$path) {
  1709.             throw new ItemNotFoundException("no item found with uuid " . $uuid);
  1710.         }
  1712.         return $path;
  1713.     }
  1715.     /**
  1716.      * {@inheritDoc}
  1717.      */
  1718.     public function deleteNodes(array $operations)
  1719.     {
  1720.         $this->assertLoggedIn();
  1722.         foreach ($operations as $op) {
  1723.             $this->deleteNode($op->srcPath);
  1724.         }
  1726.         return true;
  1727.     }
  1729.     /**
  1730.      * {@inheritDoc}
  1731.      */
  1732.     public function deleteNodeImmediately($path)
  1733.     {
  1734.         $this->prepareSave();
  1735.         $this->deleteNode($path);
  1736.         $this->finishSave();
  1738.         return true;
  1739.     }
  1741.     /**
  1742.      * TODO instead of calling the deletes separately, we should batch the delete query
  1743.      * but careful with the caching!
  1744.      *
  1745.      * @param string $path node path to delete
  1746.      *
  1747.      * @throws ConstraintViolationException
  1748.      * @throws ItemNotFoundException
  1749.      * @throws RepositoryException
  1750.      */
  1751.     protected function deleteNode($path)
  1752.     {
  1753.         if ('/' === $path) {
  1754.             throw new ConstraintViolationException('You can not delete the root node of a repository');
  1755.         }
  1757.         if (!$this->pathExists($path)) {
  1758.             throw new ItemNotFoundException("No node found at " . $path);
  1759.         }
  1761.         $params = [$path, $path . "/%", $this->workspaceName];
  1763.         // TODO on RDBMS that support deferred FKs we could skip this step
  1764.         $query = 'SELECT id, path FROM phpcr_nodes WHERE (path = ? OR path LIKE ?) AND workspace_name = ?';
  1765.         $stmt = $this->getConnection()->executeQuery($query, $params);
  1766.         $this->referencesToDelete += $stmt->fetchAll(PDO::FETCH_UNIQUE | PDO::FETCH_COLUMN);
  1768.         try {
  1769.             $query = 'DELETE FROM phpcr_nodes WHERE (path = ? OR path LIKE ?) AND workspace_name = ?';
  1770.             $this->getConnection()->executeUpdate($query, $params);
  1771.             $this->cleanIdentifierCache($path);
  1772.         } catch (DBALException $e) {
  1773.             throw new RepositoryException('Unexpected exception while deleting node ' . $path, $e->getCode(), $e);
  1774.         }
  1775.     }
  1777.     /**
  1778.      * Clean all identifiers under path $root.
  1779.      *
  1780.      * @param string $root Path to the root node to be cleared
  1781.      */
  1782.     private function cleanIdentifierCache($root)
  1783.     {
  1784.         unset($this->nodeIdentifiers[$root]);
  1785.         foreach (array_keys($this->nodeIdentifiers) as $path) {
  1786.             if (strpos($path, "$root/") === 0) {
  1787.                 unset($this->nodeIdentifiers[$path]);
  1788.             }
  1789.         }
  1790.     }
  1792.     /**
  1793.      * {@inheritDoc}
  1794.      */
  1795.     public function deleteProperties(array $operations)
  1796.     {
  1797.         $this->assertLoggedIn();
  1799.         foreach ($operations as $op) {
  1800.             $this->deleteProperty($op->srcPath);
  1801.         }
  1803.         return true;
  1804.     }
  1806.     /**
  1807.      * {@inheritDoc}
  1808.      */
  1809.     public function deletePropertyImmediately($path)
  1810.     {
  1811.         $this->prepareSave();
  1812.         $this->deleteProperty($path);
  1813.         $this->finishSave();
  1815.         return true;
  1816.     }
  1818.     /**
  1819.      * {@inheritDoc}
  1820.      *
  1821.      * @throws ItemNotFoundException
  1822.      * @throws RepositoryException
  1823.      */
  1824.     protected function deleteProperty($path)
  1825.     {
  1826.         $this->assertLoggedIn();
  1828.         $nodePath = PathHelper::getParentPath($path);
  1829.         $nodeId = $this->getSystemIdForNode($nodePath);
  1830.         if (!$nodeId) {
  1831.             // no we really don't know that path
  1832.             throw new ItemNotFoundException("No item found at " . $path);
  1833.         }
  1835.         $query = 'SELECT props FROM phpcr_nodes WHERE id = ?';
  1836.         $xml = $this->getConnection()->fetchColumn($query, [$nodeId]);
  1838.         $dom = new DOMDocument('1.0', 'UTF-8');
  1839.         $dom->loadXML($xml);
  1841.         $found = false;
  1842.         $propertyName = PathHelper::getNodeName($path);
  1843.         foreach ($dom->getElementsByTagNameNS('http://www.jcp.org/jcr/sv/1.0', 'property') as $propertyNode) {
  1844.             if ($propertyName == $propertyNode->getAttribute('sv:name')) {
  1845.                 $found = true;
  1846.                 // would be nice to have the property object to ask for type
  1847.                 // but its in state deleted, would mean lots of refactoring
  1848.                 if ($propertyNode->hasAttribute('sv:type')) {
  1849.                     $type = strtolower($propertyNode->getAttribute('sv:type'));
  1850.                     if (in_array($type, ['reference', 'weakreference'])) {
  1851.                         $table = $this->referenceTables['reference' === $type ? PropertyType::REFERENCE : PropertyType::WEAKREFERENCE];
  1852.                         try {
  1853.                             $query = "DELETE FROM $table WHERE source_id = ? AND source_property_name = ?";
  1854.                             $this->getConnection()->executeUpdate($query, [$nodeId, $propertyName]);
  1855.                         } catch (DBALException $e) {
  1856.                             throw new RepositoryException(
  1857.                                 'Unexpected exception while cleaning up deleted nodes',
  1858.                                 $e->getCode(),
  1859.                                 $e
  1860.                             );
  1861.                         }
  1862.                     }
  1863.                 }
  1864.                 $propertyNode->parentNode->removeChild($propertyNode);
  1865.                 break;
  1866.             }
  1867.         }
  1869.         if (!$found) {
  1870.             throw new ItemNotFoundException("Node $nodePath has no property $propertyName");
  1871.         }
  1873.         $xml = $dom->saveXML();
  1875.         $query = 'UPDATE phpcr_nodes SET props = ? WHERE id = ?';
  1876.         $params = [$xml, $nodeId];
  1878.         try {
  1879.             $this->getConnection()->executeUpdate($query, $params);
  1880.         } catch (DBALException $e) {
  1881.             throw new RepositoryException("Unexpected exception while updating properties of $path", $e->getCode(), $e);
  1882.         }
  1883.     }
  1885.     /**
  1886.      * {@inheritDoc}
  1887.      */
  1888.     public function moveNodes(array $operations)
  1889.     {
  1890.         /** @var $op MoveNodeOperation */
  1891.         foreach ($operations as $op) {
  1892.             $this->moveNode($op->srcPath, $op->dstPath);
  1893.         }
  1895.         return true;
  1896.     }
  1898.     /**
  1899.      * {@inheritDoc}
  1900.      */
  1901.     public function moveNodeImmediately($srcAbsPath, $dstAbspath)
  1902.     {
  1903.         $this->prepareSave();
  1904.         $this->moveNode($srcAbsPath, $dstAbspath);
  1905.         $this->finishSave();
  1907.         return true;
  1908.     }
  1910.     /**
  1911.      * Execute moving a single node
  1912.      *
  1913.      * @throws PathNotFoundException
  1914.      * @throws ItemExistsException
  1915.      * @throws RepositoryException
  1916.      */
  1917.     protected function moveNode($srcAbsPath, $dstAbsPath)
  1918.     {
  1919.         $this->assertLoggedIn();
  1920.         PathHelper::assertValidAbsolutePath($srcAbsPath, false, true, $this->getNamespacePrefixes());
  1921.         PathHelper::assertValidAbsolutePath($dstAbsPath, true, true, $this->getNamespacePrefixes());
  1923.         if (!$this->pathExists($srcAbsPath)) {
  1924.             throw new PathNotFoundException("Source path '$srcAbsPath' not found");
  1925.         }
  1927.         if ($this->getSystemIdForNode($dstAbsPath)) {
  1928.             throw new ItemExistsException(
  1929.                 "Cannot move '$srcAbsPath' to '$dstAbsPath' because destination node already exists."
  1930.             );
  1931.         }
  1933.         if (!$this->getSystemIdForNode(PathHelper::getParentPath($dstAbsPath))) {
  1934.             throw new PathNotFoundException("Parent of the destination path '" . $dstAbsPath . "' has to exist.");
  1935.         }
  1937.         $query = 'SELECT path, id FROM phpcr_nodes WHERE path LIKE ? OR path = ? AND workspace_name = ? ' . $this->getConnection(
  1938.             )->getDatabasePlatform()->getForUpdateSQL();
  1939.         $stmt = $this->getConnection()->executeQuery($query, [$srcAbsPath . '/%', $srcAbsPath, $this->workspaceName]);
  1941.         /*
  1942.          * TODO: https://github.com/jackalope/jackalope-doctrine-dbal/pull/26/files#L0R1057
  1943.          * the other thing i wonder: can't you do the replacement inside sql instead of loading and then storing
  1944.          * the node? this will be extremely slow for a large set of nodes. i think you should use query builder here
  1945.          * rather than raw sql, to make it work on a maximum of platforms.
  1946.          *
  1947.          * can you try to do this please? if we don't figure out how to do it, at least fix the where criteria, and
  1948.          * we can ask the doctrine community how to do the substring operation.
  1949.          * http://stackoverflow.com/questions/8619421/correct-syntax-for-doctrine2s-query-builder-substring-helper-method
  1950.          */
  1952.         $query = "UPDATE phpcr_nodes SET ";
  1953.         $updatePathCase = "path = CASE ";
  1954.         $updateParentCase = "parent = CASE ";
  1955.         $updateLocalNameCase = "local_name = CASE ";
  1956.         $updateSortOrderCase = "sort_order = CASE ";
  1957.         $updateDepthCase = "depth = CASE ";
  1959.         // TODO: Find a better way to do this
  1960.         // Calculate CAST type for CASE statement
  1961.         switch ($this->getConnection()->getDatabasePlatform()->getName()) {
  1962.             case 'pgsql':
  1963.                 $intType = 'integer';
  1964.                 break;
  1965.             case 'mysql':
  1966.                 $intType = 'unsigned';
  1967.                 break;
  1968.             default:
  1969.                 $intType = 'integer';
  1970.         }
  1972.         $i = 0;
  1973.         $values = $ids = [];
  1974.         $srcAbsPathPattern = '/^' . preg_quote($srcAbsPath, '/') . '/';
  1975.         while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
  1976.             $values[':id' . $i] = $row['id'];
  1977.             $values[':path' . $i] = preg_replace($srcAbsPathPattern, $dstAbsPath, $row['path'], 1);
  1978.             $values[':parent' . $i] = PathHelper::getParentPath($values[':path' . $i]);
  1979.             $values[':depth' . $i] = PathHelper::getPathDepth($values[':path' . $i]);
  1981.             $updatePathCase .= "WHEN id = :id$i THEN :path$i ";
  1982.             $updateParentCase .= "WHEN id = :id$i THEN :parent$i ";
  1983.             $updateDepthCase .= "WHEN id = :id$i THEN CAST(:depth$i AS $intType) ";
  1985.             if ($srcAbsPath === $row['path']) {
  1986.                 list($namespace, $localName) = $this->getJcrName($values[':path' . $i]);
  1987.                 $values[':localname' . $i] = $localName;
  1989.                 $updateLocalNameCase .= "WHEN id = :id$i THEN :localname$i ";
  1990.                 $updateSortOrderCase .= "WHEN id = :id$i THEN (SELECT * FROM ( SELECT MAX(x.sort_order) + 1 FROM phpcr_nodes x WHERE x.parent = :parent$i) y) ";
  1991.             }
  1993.             $ids[] = $row['id'];
  1995.             $i++;
  1996.         }
  1998.         if (!$i) {
  1999.             return;
  2000.         }
  2002.         $ids = implode(',', $ids);
  2004.         $updateLocalNameCase .= 'ELSE local_name END, ';
  2005.         $updateSortOrderCase .= 'ELSE sort_order END ';
  2007.         $query .= $updatePathCase . 'END, ' . $updateParentCase . 'END, ' . $updateDepthCase . 'END, ' . $updateLocalNameCase . $updateSortOrderCase;
  2008.         $query .= "WHERE id IN ($ids)";
  2010.         try {
  2011.             $this->getConnection()->executeUpdate($query, $values);
  2012.         } catch (DBALException $e) {
  2013.             throw new RepositoryException(
  2014.                 "Unexpected exception while moving node from $srcAbsPath to $dstAbsPath",
  2015.                 $e->getCode(),
  2016.                 $e
  2017.             );
  2018.         }
  2020.         $this->cleanIdentifierCache($srcAbsPath);
  2021.     }
  2023.     /**
  2024.      * {@inheritDoc}
  2025.      *
  2026.      * @throws RepositoryException
  2027.      */
  2028.     public function reorderChildren(Node $node)
  2029.     {
  2030.         $this->assertLoggedIn();
  2032.         $values[':absPath'] = $node->getPath();
  2033.         $sql = "UPDATE phpcr_nodes SET sort_order = CASE CONCAT(
  2034.           namespace,
  2035.           (CASE namespace WHEN '' THEN '' ELSE ':' END),
  2036.           local_name
  2037.         )";
  2039.         $i = 0;
  2041.         foreach ($node->getNodeNames() as $name) {
  2042.             $values[':name' . $i] = implode(':', array_filter($this->getJcrName($name)));
  2043.             $values[':order' . $i] = $i; // use our counter to avoid gaps
  2044.             $sql .= " WHEN :name$i THEN :order$i";
  2045.             $i++;
  2046.         }
  2048.         $sql .= ' ELSE sort_order END WHERE parent = :absPath';
  2050.         try {
  2051.             $this->getConnection()->executeUpdate($sql, $values);
  2052.         } catch (DBALException $e) {
  2053.             throw new RepositoryException('Unexpected exception while reordering nodes', $e->getCode(), $e);
  2054.         }
  2056.         return true;
  2057.     }
  2059.     /**
  2060.      * Return the node processor for processing nodes
  2061.      * according to their node types.
  2062.      *
  2063.      * @return NodeProcessor
  2064.      */
  2065.     private function getNodeProcessor()
  2066.     {
  2067.         if ($this->nodeProcessor) {
  2068.             return $this->nodeProcessor;
  2069.         }
  2071.         $this->nodeProcessor = new NodeProcessor(
  2072.             $this->credentials->getUserID(), $this->getNamespacesObject(), $this->getAutoLastModified()
  2073.         );
  2075.         return $this->nodeProcessor;
  2076.     }
  2078.     /**
  2079.      * {@inheritDoc}
  2080.      */
  2081.     public function storeNodes(array $operations)
  2082.     {
  2083.         $this->assertLoggedIn();
  2085.         $additionalAddOperations = [];
  2087.         foreach ($operations as $operation) {
  2088.             if ($operation->node->isDeleted()) {
  2089.                 $properties = $operation->node->getPropertiesForStoreDeletedNode();
  2090.             } else {
  2091.                 $additionalAddOperations = array_merge(
  2092.                     $additionalAddOperations,
  2093.                     $this->getNodeProcessor()->process($operation->node)
  2094.                 );
  2095.                 $properties = $operation->node->getProperties();
  2096.             }
  2097.             $this->storeNode($operation->srcPath, $properties);
  2098.         }
  2100.         if (!empty($additionalAddOperations)) {
  2101.             $this->storeNodes($additionalAddOperations);
  2102.         }
  2103.     }
  2105.     /**
  2106.      * Make sure we have a uuid and a primaryType, then sync data into the database
  2107.      *
  2108.      * @param string $path the path to store the node at
  2109.      * @param Property[] $properties the properties of this node
  2110.      *
  2111.      * @return boolean true on success
  2112.      *
  2113.      * @throws RepositoryException if not logged in
  2114.      */
  2115.     protected function storeNode($path, $properties)
  2116.     {
  2117.         $nodeIdentifier = $this->getIdentifier($path, $properties);
  2118.         $type = isset($properties['jcr:primaryType']) ? $properties['jcr:primaryType']->getValue() : 'nt:unstructured';
  2120.         $this->syncNode($nodeIdentifier, $path, $type, true, $properties);
  2122.         return true;
  2123.     }
  2125.     /**
  2126.      * Determine a UUID for the node at this path with these properties
  2127.      *
  2128.      * @param string $path
  2129.      * @param Property[] $properties
  2130.      *
  2131.      * @return string a unique id
  2132.      */
  2133.     protected function getIdentifier($path, $properties)
  2134.     {
  2135.         if (isset($this->nodeIdentifiers[$path])) {
  2136.             return $this->nodeIdentifiers[$path];
  2137.         }
  2139.         if (isset($properties['jcr:uuid'])) {
  2140.             return $properties['jcr:uuid']->getValue();
  2141.         }
  2143.         // we always generate a uuid, even for non-referenceable nodes that have no automatic uuid
  2144.         return $this->generateUuid();
  2145.     }
  2147.     /**
  2148.      * {@inheritDoc}
  2149.      */
  2150.     public function getNodeTypes($nodeTypes = [])
  2151.     {
  2152.         $standardTypes = StandardNodeTypes::getNodeTypeData();
  2154.         $userTypes = $this->fetchUserNodeTypes();
  2156.         if ($nodeTypes) {
  2157.             $nodeTypes = array_flip($nodeTypes);
  2158.             return array_values(
  2159.                 array_intersect_key($standardTypes, $nodeTypes) + array_intersect_key($userTypes, $nodeTypes)
  2160.             );
  2161.         }
  2163.         return array_values($standardTypes + $userTypes);
  2164.     }
  2166.     /**
  2167.      * Fetch a user-defined node-type definition.
  2168.      *
  2169.      * @return array
  2170.      */
  2171.     protected function fetchUserNodeTypes()
  2172.     {
  2173.         $result = [];
  2175.         $query = '
  2176. SELECT 
  2177. phpcr_type_nodes.name AS node_name, phpcr_type_nodes.is_abstract AS node_abstract, 
  2178. phpcr_type_nodes.is_mixin AS node_mixin, phpcr_type_nodes.queryable AS node_queryable, 
  2179. phpcr_type_nodes.orderable_child_nodes AS node_has_orderable_child_nodes, 
  2180. phpcr_type_nodes.primary_item AS node_primary_item_name, phpcr_type_nodes.supertypes AS declared_super_type_names, 
  2181. phpcr_type_props.name AS property_name, phpcr_type_props.auto_created AS property_auto_created, 
  2182. phpcr_type_props.mandatory AS property_mandatory, phpcr_type_props.protected AS property_protected, 
  2183. phpcr_type_props.on_parent_version AS property_on_parent_version, 
  2184. phpcr_type_props.required_type AS property_required_type, phpcr_type_props.multiple AS property_multiple, 
  2185. phpcr_type_props.fulltext_searchable AS property_fulltext_searchable, 
  2186. phpcr_type_props.query_orderable AS property_query_orderable, phpcr_type_props.default_value as property_default_value,
  2187. phpcr_type_childs.name AS child_name, phpcr_type_childs.auto_created AS child_auto_created, 
  2188. phpcr_type_childs.mandatory AS child_mandatory, phpcr_type_childs.protected AS child_protected, 
  2189. phpcr_type_childs.on_parent_version AS child_on_parent_version, phpcr_type_childs.default_type AS child_default_type, 
  2190. phpcr_type_childs.primary_types AS child_primary_types 
  2191. FROM 
  2192. phpcr_type_nodes 
  2193. LEFT JOIN 
  2194. phpcr_type_props ON phpcr_type_nodes.node_type_id = phpcr_type_props.node_type_id 
  2195. LEFT JOIN 
  2196. phpcr_type_childs ON phpcr_type_nodes.node_type_id = phpcr_type_childs.node_type_id
  2197. ';
  2199.         $statement = $this->getConnection()->prepare($query);
  2201.         $statement->execute();
  2203.         while ($row = $statement->fetch()) {
  2204.             $nodeName = $row['node_name'];
  2206.             if (!isset($result[$nodeName])) {
  2207.                 $result[$nodeName] = [
  2208.                     'name' => $nodeName,
  2209.                     'isAbstract' => (bool)$row['node_abstract'],
  2210.                     'isMixin' => (bool)$row['node_mixin'],
  2211.                     'isQueryable' => (bool)$row['node_queryable'],
  2212.                     'hasOrderableChildNodes' => (bool)$row['node_has_orderable_child_nodes'],
  2213.                     'primaryItemName' => $row['node_primary_item_name'],
  2214.                     'declaredSuperTypeNames' => array_filter(explode(' ', $row['declared_super_type_names'])),
  2215.                     'declaredPropertyDefinitions' => [],
  2216.                     'declaredNodeDefinitions' => [],
  2217.                 ];
  2218.             }
  2220.             if (($propertyName = $row['property_name']) !== null) {
  2221.                 $result[$nodeName]['declaredPropertyDefinitions'][] = [
  2222.                     'declaringNodeType' => $nodeName,
  2223.                     'name' => $propertyName,
  2224.                     'isAutoCreated' => (bool)$row['property_auto_created'],
  2225.                     'isMandatory' => (bool)$row['property_mandatory'],
  2226.                     'isProtected' => (bool)$row['property_protected'],
  2227.                     'onParentVersion' => (bool)$row['property_on_parent_version'],
  2228.                     'requiredType' => (int)$row['property_required_type'],
  2229.                     'multiple' => (bool)$row['property_multiple'],
  2230.                     'isFulltextSearchable' => (bool)$row['property_fulltext_searchable'],
  2231.                     'isQueryOrderable' => (bool)$row['property_query_orderable'],
  2232.                     'queryOperators' => [
  2233.                         QOM::JCR_OPERATOR_EQUAL_TO,
  2234.                         QOM::JCR_OPERATOR_NOT_EQUAL_TO,
  2235.                         QOM::JCR_OPERATOR_GREATER_THAN,
  2236.                         QOM::JCR_OPERATOR_GREATER_THAN_OR_EQUAL_TO,
  2237.                         QOM::JCR_OPERATOR_LESS_THAN,
  2238.                         QOM::JCR_OPERATOR_LESS_THAN_OR_EQUAL_TO,
  2239.                         QOM::JCR_OPERATOR_LIKE,
  2240.                     ],
  2241.                     'defaultValues' => [$row['property_default_value']]
  2242.                 ];
  2243.             }
  2245.             if (($childName = $row['child_name']) !== null) {
  2246.                 $result[$nodeName]['declaredNodeDefinitions'][] = [
  2247.                     'declaringNodeType' => $nodeName,
  2248.                     'name' => $childName,
  2249.                     'isAutoCreated' => (bool)$row['child_auto_created'],
  2250.                     'isMandatory' => (bool)$row['child_mandatory'],
  2251.                     'isProtected' => (bool)$row['child_protected'],
  2252.                     'onParentVersion' => (bool)$row['child_on_parent_version'],
  2253.                     'allowsSameNameSiblings' => false,
  2254.                     'defaultPrimaryTypeName' => $row['child_default_type'],
  2255.                     'requiredPrimaryTypeNames' => array_filter(explode(' ', $row['child_primary_types']))
  2256.                 ];
  2257.             }
  2258.         }
  2260.         return $result;
  2261.     }
  2263.     /**
  2264.      * {@inheritDoc}
  2265.      */
  2266.     public function registerNodeTypes($types, $allowUpdate)
  2267.     {
  2268.         $builtinTypes = StandardNodeTypes::getNodeTypeData();
  2270.         /* @var $type NodeTypeDefinition */
  2271.         foreach ($types as $type) {
  2272.             if (isset($builtinTypes[$type->getName()])) {
  2273.                 throw new RepositoryException(sprintf('%s: can\'t reregister built-in node type.', $type->getName()));
  2274.             }
  2276.             $nodeTypeName = $type->getName();
  2278.             $query = "SELECT * FROM phpcr_type_nodes WHERE name = ?";
  2279.             $result = $this->getConnection()->fetchColumn($query, [$nodeTypeName]);
  2281.             $data = [
  2282.                 'name' => $nodeTypeName,
  2283.                 'supertypes' => implode(' ', $type->getDeclaredSuperTypeNames()),
  2284.                 'is_abstract' => $type->isAbstract() ? 1 : 0,
  2285.                 'is_mixin' => $type->isMixin() ? 1 : 0,
  2286.                 'queryable' => $type->isQueryable() ? 1 : 0,
  2287.                 'orderable_child_nodes' => $type->hasOrderableChildNodes() ? 1 : 0,
  2288.                 'primary_item' => $type->getPrimaryItemName(),
  2289.             ];
  2291.             if ($result) {
  2292.                 if (!$allowUpdate) {
  2293.                     throw new NodeTypeExistsException("Could not register node type with the name '$nodeTypeName'.");
  2294.                 }
  2296.                 $this->getConnection()->update('phpcr_type_nodes', $data, ['node_type_id' => $result]);
  2297.                 $this->getConnection()->delete('phpcr_type_props', ['node_type_id' => $result]);
  2298.                 $this->getConnection()->delete('phpcr_type_childs', ['node_type_id' => $result]);
  2300.                 $nodeTypeId = $result;
  2301.             } else {
  2302.                 $this->getConnection()->insert('phpcr_type_nodes', $data);
  2304.                 $nodeTypeId = $this->getConnection()->lastInsertId($this->sequenceTypeName);
  2305.             }
  2307.             if ($propDefs = $type->getDeclaredPropertyDefinitions()) {
  2308.                 foreach ($propDefs as $propertyDef) {
  2309.                     /* @var $propertyDef PropertyDefinitionInterface */
  2310.                     $this->getConnection()->insert(
  2311.                         'phpcr_type_props',
  2312.                         [
  2313.                             'node_type_id' => $nodeTypeId,
  2314.                             'name' => $propertyDef->getName(),
  2315.                             'protected' => $propertyDef->isProtected() ? 1 : 0,
  2316.                             'mandatory' => $propertyDef->isMandatory() ? 1 : 0,
  2317.                             'auto_created' => $propertyDef->isAutoCreated() ? 1 : 0,
  2318.                             'on_parent_version' => $propertyDef->getOnParentVersion(),
  2319.                             'multiple' => $propertyDef->isMultiple() ? 1 : 0,
  2320.                             'fulltext_searchable' => $propertyDef->isFullTextSearchable() ? 1 : 0,
  2321.                             'query_orderable' => $propertyDef->isQueryOrderable() ? 1 : 0,
  2322.                             'required_type' => $propertyDef->getRequiredType(),
  2323.                             'query_operators' => 0, // transform to bitmask
  2324.                             'default_value' => $propertyDef->getDefaultValues() ? current(
  2325.                                 $propertyDef->getDefaultValues()
  2326.                             ) : null,
  2327.                         ]
  2328.                     );
  2329.                 }
  2330.             }
  2332.             if ($childDefs = $type->getDeclaredChildNodeDefinitions()) {
  2333.                 foreach ($childDefs as $childDef) {
  2334.                     /* @var $childDef NodeDefinitionInterface */
  2335.                     $this->getConnection()->insert(
  2336.                         'phpcr_type_childs',
  2337.                         [
  2338.                             'node_type_id' => $nodeTypeId,
  2339.                             'name' => $childDef->getName(),
  2340.                             'protected' => $childDef->isProtected() ? 1 : 0,
  2341.                             'mandatory' => $childDef->isMandatory() ? 1 : 0,
  2342.                             'auto_created' => $childDef->isAutoCreated() ? 1 : 0,
  2343.                             'on_parent_version' => $childDef->getOnParentVersion(),
  2344.                             'primary_types' => implode(' ', $childDef->getRequiredPrimaryTypeNames() ?: []),
  2345.                             'default_type' => $childDef->getDefaultPrimaryTypeName(),
  2346.                         ]
  2347.                     );
  2348.                 }
  2349.             }
  2350.         }
  2351.     }
  2353.     /**
  2354.      * {@inheritDoc}
  2355.      */
  2356.     public function setNodeTypeManager($nodeTypeManager)
  2357.     {
  2358.         $this->nodeTypeManager = $nodeTypeManager;
  2359.     }
  2361.     /**
  2362.      * {@inheritDoc}
  2363.      */
  2364.     public function cloneFrom($srcWorkspace, $srcAbsPath, $destAbsPath, $removeExisting)
  2365.     {
  2366.         throw new NotImplementedException('Cloning nodes is not implemented yet');
  2367.     }
  2369.     /**
  2370.      * {@inheritDoc}
  2371.      */
  2372.     public function updateNode(Node $node, $srcWorkspace)
  2373.     {
  2374.         throw new NotImplementedException('Updating nodes is not implemented yet');
  2375.     }
  2377.     /**
  2378.      * {@inheritDoc}
  2379.      * @throws RepositoryException when no binary data found
  2380.      */
  2381.     public function getBinaryStream($path)
  2382.     {
  2383.         $this->assertLoggedIn();
  2385.         $nodePath = PathHelper::getParentPath($path);
  2386.         $nodeId = $this->getSystemIdForNode($nodePath);
  2387.         $propertyName = PathHelper::getNodeName($path);
  2389.         $data = $this->getConnection()->fetchAll(
  2390.             'SELECT data, idx FROM phpcr_binarydata WHERE node_id = ? AND property_name = ? AND workspace_name = ?',
  2391.             [$nodeId, $propertyName, $this->workspaceName]
  2392.         );
  2394.         if (count($data) === 0) {
  2395.             throw new RepositoryException('No binary data found in stream');
  2396.         }
  2398.         $streams = [];
  2399.         foreach ($data as $row) {
  2400.             if (is_resource($row['data'])) {
  2401.                 $stream = $row['data'];
  2402.             } else {
  2403.                 $stream = fopen('php://memory', 'rwb+');
  2404.                 fwrite($stream, $row['data']);
  2405.                 rewind($stream);
  2406.             }
  2408.             $streams[] = $stream;
  2409.         }
  2411.         if (count($data) === 1) {
  2412.             // we don't know if this is a multivalue property or not.
  2413.             // TODO we should have something more efficient to know this. a flag in the database?
  2415.             // TODO use self::getProperty()->isMultiple() once implemented
  2416.             $node = $this->getNode($nodePath);
  2417.             if (!is_array($node->{':' . $propertyName})) {
  2418.                 return reset($streams);
  2419.             }
  2420.         }
  2422.         return $streams;
  2423.     }
  2425.     /**
  2426.      * {@inheritDoc}
  2427.      */
  2428.     public function getProperty($path)
  2429.     {
  2430.         throw new NotImplementedException('Getting properties by path is not implemented yet');
  2431.     }
  2433.     /**
  2434.      * {@inheritDoc}
  2435.      *
  2436.      * @throws InvalidQueryException
  2437.      */
  2438.     public function query(Query $query)
  2439.     {
  2440.         $this->assertLoggedIn();
  2442.         if (!$query instanceof QueryObjectModelInterface) {
  2443.             $parser = new Sql2ToQomQueryConverter($this->factory->get(QueryObjectModelFactory::class));
  2444.             try {
  2445.                 $qom = $parser->parse($query->getStatement());
  2446.                 $qom->setLimit($query->getLimit());
  2447.                 $qom->setOffset($query->getOffset());
  2448.             } catch (Exception $e) {
  2449.                 throw new InvalidQueryException('Invalid query: ' . $query->getStatement(), null, $e);
  2450.             }
  2451.         } else {
  2452.             $qom = $query;
  2453.         }
  2455.         $qomWalker = new QOMWalker($this->nodeTypeManager, $this->getConnection(), $this->getNamespaces());
  2456.         list($selectors, $selectorAliases, $sql) = $qomWalker->walkQOMQuery($qom);
  2458.         $primarySource = reset($selectors);
  2459.         $primaryType = $primarySource->getSelectorName() ?: $primarySource->getNodeTypeName();
  2460.         $data = $this->getConnection()->fetchAll($sql, [$this->workspaceName]);
  2462.         $results = $properties = $standardColumns = [];
  2463.         foreach ($data as $row) {
  2464.             $result = [];
  2466.             /** @var SelectorInterface $selector */
  2467.             foreach ($selectors as $selector) {
  2468.                 $selectorName = $selector->getSelectorName() ?: $selector->getNodeTypeName();
  2469.                 $columnPrefix = isset($selectorAliases[$selectorName]) ? $selectorAliases[$selectorName] . '_' : $selectorAliases[''] . '_';
  2471.                 if ($primaryType === $selector->getNodeTypeName()) {
  2472.                     $result[] = [
  2473.                         'dcr:name' => 'jcr:path',
  2474.                         'dcr:value' => $row[$columnPrefix . 'path'],
  2475.                         'dcr:selectorName' => $selectorName
  2476.                     ];
  2477.                 }
  2479.                 $result[] = [
  2480.                     'dcr:name' => 'jcr:path',
  2481.                     'dcr:value' => $row[$columnPrefix . 'path'],
  2482.                     'dcr:selectorName' => $selectorName
  2483.                 ];
  2484.                 $result[] = ['dcr:name' => 'jcr:score', 'dcr:value' => 0, 'dcr:selectorName' => $selectorName];
  2485.                 if (0 === count($qom->getColumns())) {
  2486.                     $selectorPrefix = null !== $selector->getSelectorName() ? $selectorName . '.' : '';
  2487.                     $result[] = [
  2488.                         'dcr:name' => $selectorPrefix . 'jcr:primaryType',
  2489.                         'dcr:value' => $primaryType,
  2490.                         'dcr:selectorName' => $selectorName
  2491.                     ];
  2492.                 }
  2494.                 if (isset($row[$columnPrefix . 'props'])) {
  2495.                     $propertyNames = [];
  2496.                     $columns = $qom->getColumns();
  2498.                     // Always populate jcr:created and jcr:createdBy if a wildcard selector is used.
  2499.                     // This emulates the behavior of Jackrabbit
  2500.                     if (0 === count($columns)) {
  2501.                         $propertyNames = ['jcr:created', 'jcr:createdBy'];
  2502.                     }
  2504.                     foreach ($columns as $column) {
  2505.                         if (!$column->getSelectorName() || $column->getSelectorName() == $selectorName) {
  2506.                             $propertyNames[] = $column->getPropertyName();
  2507.                         }
  2508.                     }
  2510.                     $properties[$selectorName] = (array)$this->xmlToColumns(
  2511.                         $row[$columnPrefix . 'props'],
  2512.                         $propertyNames
  2513.                     );
  2514.                 } else {
  2515.                     $properties[$selectorName] = [];
  2516.                 }
  2518.                 // TODO: add other default columns that Jackrabbit provides to provide a more consistent behavior
  2519.                 if (isset($properties[$selectorName]['jcr:createdBy'])) {
  2520.                     $standardColumns[$selectorName]['jcr:createdBy'] = $properties[$selectorName]['jcr:createdBy'];
  2521.                 }
  2523.                 if (isset($properties[$selectorName]['jcr:created'])) {
  2524.                     $standardColumns[$selectorName]['jcr:created'] = $properties[$selectorName]['jcr:created'];
  2525.                 }
  2526.             }
  2528.             $reservedNames = ['jcr:path', 'jcr:score'];
  2530.             foreach ($qom->getColumns() as $column) {
  2531.                 $selectorName = $column->getSelectorName();
  2532.                 $columnName = $column->getPropertyName();
  2533.                 $columnPrefix = isset($selectorAliases[$selectorName]) ? $selectorAliases[$selectorName] . '_' : $selectorAliases[''] . '_';
  2536.                 if (in_array($column->getColumnName(), $reservedNames)) {
  2537.                     throw new InvalidQueryException(
  2538.                         sprintf(
  2539.                             'Cannot reserved name "%s". Reserved names are "%s"',
  2540.                             $column->getColumnName(),
  2541.                             implode('", "', $reservedNames)
  2542.                         )
  2543.                     );
  2544.                 }
  2546.                 $dcrValue = 'jcr:uuid' === $columnName ? $row[$columnPrefix . 'identifier'] : (isset($properties[$selectorName][$columnName]) ? $properties[$selectorName][$columnName] : '');
  2548.                 if (isset($standardColumns[$selectorName][$columnName])) {
  2549.                     unset($standardColumns[$selectorName][$columnName]);
  2550.                 }
  2552.                 $result[] = [
  2553.                     'dcr:name' => $column->getColumnName(
  2554.                     ) === $columnName && isset($properties[$selectorName][$columnName]) ? $selectorName . '.' . $columnName : $column->getColumnName(
  2555.                     ),
  2556.                     'dcr:value' => $dcrValue,
  2557.                     'dcr:selectorName' => $selectorName ?: $primaryType,
  2558.                 ];
  2559.             }
  2561.             foreach ($standardColumns as $selectorName => $columns) {
  2562.                 foreach ($columns as $columnName => $value) {
  2563.                     $result[] = [
  2564.                         'dcr:name' => $primaryType . '.' . $columnName,
  2565.                         'dcr:value' => $value,
  2566.                         'dcr:selectorName' => $selectorName,
  2567.                     ];
  2568.                 }
  2569.             }
  2571.             $results[] = $result;
  2572.         }
  2574.         return $results;
  2575.     }
  2577.     /**
  2578.      * {@inheritDoc}
  2579.      */
  2580.     public function getSupportedQueryLanguages()
  2581.     {
  2582.         return [
  2583.             QueryInterface::JCR_SQL2,
  2584.             QueryInterface::JCR_JQOM,
  2585.             QueryInterface::SQL,
  2586.         ];
  2587.     }
  2589.     /**
  2590.      * We need to create an in memory backup when we are inside a transaction
  2591.      * so that we can efficiently restore the original state in the namespaces
  2592.      * property in case of a rollback.
  2593.      *
  2594.      * This method also ensures that namespaces are loaded to begin with.
  2595.      */
  2596.     private function ensureNamespacesBackup()
  2597.     {
  2598.         if (!$this->namespaces instanceof \ArrayObject) {
  2599.             $this->getNamespacesObject();
  2600.         }
  2602.         if (!$this->inTransaction) {
  2603.             return;
  2604.         }
  2606.         if (null === $this->originalNamespaces) {
  2607.             $this->originalNamespaces = $this->namespaces->getArrayCopy();
  2608.         }
  2609.     }
  2611.     /**
  2612.      * {@inheritDoc}
  2613.      *
  2614.      * @throws NamespaceException
  2615.      */
  2616.     public function registerNamespace($prefix, $uri)
  2617.     {
  2618.         if (isset($this->namespaces[$prefix])) {
  2619.             if ($this->namespaces[$prefix] === $uri) {
  2620.                 return;
  2621.             }
  2623.             if (isset($this->coreNamespaces[$prefix])) {
  2624.                 throw new NamespaceException(
  2625.                     "Cannot overwrite JCR core namespace prefix '$prefix' to a new uri '$uri'."
  2626.                 );
  2627.             }
  2628.         }
  2630.         $this->ensureNamespacesBackup();
  2632.         $this->getConnection()->delete('phpcr_namespaces', ['prefix' => $prefix]);
  2633.         $this->getConnection()->delete('phpcr_namespaces', ['uri' => $uri]);
  2635.         $this->getConnection()->insert(
  2636.             'phpcr_namespaces',
  2637.             [
  2638.                 'prefix' => $prefix,
  2639.                 'uri' => $uri,
  2640.             ]
  2641.         );
  2643.         if (!empty($this->namespaces)) {
  2644.             $this->namespaces[$prefix] = $uri;
  2645.         }
  2646.     }
  2648.     /**
  2649.      * {@inheritDoc}
  2650.      */
  2651.     public function unregisterNamespace($prefix)
  2652.     {
  2653.         if (isset($this->coreNamespaces[$prefix])) {
  2654.             throw new NamespaceException("Cannot unregister JCR core namespace prefix '$prefix'.");
  2655.         }
  2657.         $this->ensureNamespacesBackup();
  2659.         $this->getConnection()->delete('phpcr_namespaces', ['prefix' => $prefix]);
  2661.         if (!empty($this->namespaces)) {
  2662.             unset($this->namespaces[$prefix]);
  2663.         }
  2664.     }
  2666.     /**
  2667.      * {@inheritDoc}
  2668.      */
  2669.     public function getReferences($path, $name = null)
  2670.     {
  2671.         return $this->getNodeReferences($path, $name, false);
  2672.     }
  2674.     /**
  2675.      * {@inheritDoc}
  2676.      */
  2677.     public function getWeakReferences($path, $name = null)
  2678.     {
  2679.         return $this->getNodeReferences($path, $name, true);
  2680.     }
  2682.     /**
  2683.      * @param string $path the path for which we need the references
  2684.      * @param string $name the name of the referencing properties or null for all
  2685.      * @param boolean $weakReference whether to get weak or strong references
  2686.      *
  2687.      * @return array list of paths to nodes that reference $path
  2688.      */
  2689.     private function getNodeReferences($path, $name = null, $weakReference = false)
  2690.     {
  2691.         $targetId = $this->getSystemIdForNode($path);
  2692.         $params = [$targetId];
  2694.         $table = $weakReference ? $this->referenceTables[PropertyType::WEAKREFERENCE] : $this->referenceTables[PropertyType::REFERENCE];
  2695.         $query = "SELECT CONCAT(n.path, '/', r.source_property_name) FROM phpcr_nodes n
  2696.                INNER JOIN $table r ON n.id = r.source_id
  2697.                WHERE r.target_id = ?";
  2698.         if (null !== $name) {
  2699.             $query .= " AND source_property_name = ?";
  2700.             $params[] = $name;
  2701.         }
  2703.         $stmt = $this->getConnection()->executeQuery($query, $params);
  2705.         return $stmt->fetchAll(PDO::FETCH_COLUMN);
  2706.     }
  2708.     /**
  2709.      * {@inheritDoc}
  2710.      */
  2711.     public function beginTransaction()
  2712.     {
  2713.         if ($this->inTransaction) {
  2714.             throw new RepositoryException('Begin transaction failed: transaction already open');
  2715.         }
  2717.         $this->assertLoggedIn();
  2719.         try {
  2720.             $this->getConnection()->beginTransaction();
  2721.             $this->inTransaction = true;
  2722.         } catch (Exception $e) {
  2723.             throw new RepositoryException('Begin transaction failed: ' . $e->getMessage());
  2724.         }
  2725.     }
  2727.     /**
  2728.      * {@inheritDoc}
  2729.      *
  2730.      * @throws RepositoryException
  2731.      */
  2732.     public function commitTransaction()
  2733.     {
  2734.         if (!$this->inTransaction) {
  2735.             throw new RepositoryException('Commit transaction failed: no transaction open');
  2736.         }
  2738.         $this->assertLoggedIn();
  2740.         try {
  2741.             $this->inTransaction = false;
  2743.             $this->getConnection()->commit();
  2745.             if ($this->originalNamespaces) {
  2746.                 // now that the transaction is committed, reset the cache of the stored namespaces.
  2747.                 $this->originalNamespaces = null;
  2748.             }
  2749.         } catch (Exception $e) {
  2750.             throw new RepositoryException('Commit transaction failed: ' . $e->getMessage());
  2751.         }
  2752.     }
  2754.     /**
  2755.      * {@inheritDoc}
  2756.      *
  2757.      * @throws RepositoryException
  2758.      */
  2759.     public function rollbackTransaction()
  2760.     {
  2761.         if (!$this->inTransaction) {
  2762.             throw new RepositoryException('Rollback transaction failed: no transaction open');
  2763.         }
  2765.         $this->assertLoggedIn();
  2767.         try {
  2768.             $this->inTransaction = false;
  2770.             $this->getConnection()->rollBack();
  2772.             if ($this->originalNamespaces) {
  2773.                 // reset namespaces
  2774.                 $this->setNamespaces($this->originalNamespaces);
  2775.                 $this->originalNamespaces = null;
  2776.             }
  2777.         } catch (Exception $e) {
  2778.             throw new RepositoryException('Rollback transaction failed: ' . $e->getMessage(), 0, $e);
  2779.         }
  2780.     }
  2782.     /**
  2783.      * Sets the default transaction timeout
  2784.      *
  2785.      * @param int $seconds The value of the timeout in seconds
  2786.      */
  2787.     public function setTransactionTimeout($seconds)
  2788.     {
  2789.         $this->assertLoggedIn();
  2791.         throw new NotImplementedException("Setting a transaction timeout is not yet implemented");
  2792.     }
  2794.     /**
  2795.      * {@inheritDoc}
  2796.      */
  2797.     public function prepareSave()
  2798.     {
  2799.         $this->getConnection()->beginTransaction();
  2800.     }
  2802.     /**
  2803.      * {@inheritDoc}
  2804.      */
  2805.     public function finishSave()
  2806.     {
  2807.         $this->syncReferences($this->referencesToUpdate);
  2808.         $this->referencesToUpdate = $this->referencesToDelete = [];
  2809.         $this->getConnection()->commit();
  2810.     }
  2812.     /**
  2813.      * {@inheritDoc}
  2814.      */
  2815.     public function rollbackSave()
  2816.     {
  2817.         $this->referencesToUpdate = $this->referencesToDelete = [];
  2818.         $this->getConnection()->rollBack();
  2819.     }
  2821.     /**
  2822.      *
  2823.      * @param Node $node the node to update
  2824.      */
  2825.     public function updateProperties(Node $node)
  2826.     {
  2827.         $this->assertLoggedIn();
  2828.         // we can ignore the operations returned, there will be no additions because of property updates
  2829.         $this->getNodeProcessor()->process($node);
  2831.         $this->syncNode(
  2832.             $node->getIdentifier(),
  2833.             $node->getPath(),
  2834.             $node->getPrimaryNodeType(),
  2835.             false,
  2836.             $node->getProperties()
  2837.         );
  2839.         return true;
  2840.     }
  2842.     /**
  2843.      * Initialize the dbal connection lazily
  2844.      */
  2845.     private function initConnection()
  2846.     {
  2847.         if (true === $this->conn->isConnected() && true === $this->connectionInitialized) {
  2848.             return;
  2849.         }
  2851.         if ($this->conn->getDatabasePlatform() instanceof PostgreSqlPlatform) {
  2852.             $this->sequenceNodeName = 'phpcr_nodes_id_seq';
  2853.             $this->sequenceTypeName = 'phpcr_type_nodes_node_type_id_seq';
  2854.         }
  2856.         // @TODO: move to "SqlitePlatform" and rename to "registerExtraFunctions"?
  2857.         if ($this->conn->getDatabasePlatform() instanceof SqlitePlatform) {
  2858.             $this->registerSqliteFunctions($this->conn->getWrappedConnection());
  2859.         }
  2861.         $this->connectionInitialized = true;
  2862.     }
  2863. }