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

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\Driver\PDO\Connection as PDOConnection;
  11. use Doctrine\DBAL\Exception as DBALException;
  12. use Doctrine\DBAL\ParameterType;
  13. use Doctrine\DBAL\Platforms\MySQLPlatform;
  14. use Doctrine\DBAL\Platforms\PostgreSqlPlatform;
  15. use Doctrine\DBAL\Platforms\PostgreSQL94Platform;
  16. use Doctrine\DBAL\Platforms\SqlitePlatform;
  17. use DOMDocument;
  18. use DOMElement;
  19. use DOMXPath;
  20. use Exception;
  21. use InvalidArgumentException;
  22. use Jackalope\FactoryInterface;
  23. use Jackalope\Node;
  24. use Jackalope\NodeType\NodeProcessor;
  25. use Jackalope\NodeType\NodeTypeDefinition;
  26. use Jackalope\NodeType\NodeTypeManager;
  27. use Jackalope\NotImplementedException;
  28. use Jackalope\Property;
  29. use Jackalope\Query\QOM\QueryObjectModelFactory;
  30. use Jackalope\Query\Query;
  31. use Jackalope\Transport\BaseTransport;
  32. use Jackalope\Transport\DoctrineDBAL\Query\QOMWalker;
  33. use Jackalope\Transport\DoctrineDBAL\XmlParser\XmlToPropsParser;
  34. use Jackalope\Transport\MoveNodeOperation;
  35. use Jackalope\Transport\NodeTypeManagementInterface;
  36. use Jackalope\Transport\QueryInterface as QueryTransport;
  37. use Jackalope\Transport\StandardNodeTypes;
  38. use Jackalope\Transport\TransactionInterface;
  39. use Jackalope\Transport\WorkspaceManagementInterface;
  40. use Jackalope\Transport\WritingInterface;
  41. use PDO;
  42. use PHPCR\AccessDeniedException;
  43. use PHPCR\CredentialsInterface;
  44. use PHPCR\ItemExistsException;
  45. use PHPCR\ItemNotFoundException;
  46. use PHPCR\LoginException;
  47. use PHPCR\NamespaceException;
  48. use PHPCR\NamespaceRegistryInterface as NS;
  49. use PHPCR\NodeType\ConstraintViolationException;
  50. use PHPCR\NodeType\NodeDefinitionInterface;
  51. use PHPCR\NodeType\NodeTypeExistsException;
  52. use PHPCR\NodeType\NoSuchNodeTypeException;
  53. use PHPCR\NodeType\PropertyDefinitionInterface;
  54. use PHPCR\NoSuchWorkspaceException;
  55. use PHPCR\PathNotFoundException;
  56. use PHPCR\PropertyType;
  57. use PHPCR\Query\InvalidQueryException;
  58. use PHPCR\Query\QOM\QueryObjectModelConstantsInterface as QOM;
  59. use PHPCR\Query\QOM\QueryObjectModelInterface;
  60. use PHPCR\Query\QOM\SelectorInterface;
  61. use PHPCR\Query\QueryInterface;
  62. use PHPCR\ReferentialIntegrityException;
  63. use PHPCR\RepositoryException;
  64. use PHPCR\RepositoryInterface;
  65. use PHPCR\SimpleCredentials;
  66. use PHPCR\UnsupportedRepositoryOperationException;
  67. use PHPCR\Util\PathHelper;
  68. use PHPCR\Util\QOM\Sql2ToQomQueryConverter;
  69. use PHPCR\Util\UUIDHelper;
  70. use PHPCR\Util\ValueConverter;
  71. use stdClass;
  73. /**
  74.  * Class to handle the communication between Jackalope and RDBMS via Doctrine DBAL.
  75.  *
  76.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  77.  * @license http://opensource.org/licenses/MIT MIT License
  78.  *
  79.  * @author Benjamin Eberlei <kontakt@beberlei.de>
  80.  * @author Lukas Kahwe Smith <smith@pooteeweet.org>
  81.  */
  82. class Client extends BaseTransport implements QueryTransport, WritingInterface, WorkspaceManagementInterface, NodeTypeManagementInterface, TransactionInterface
  83. {
  84.     /**
  85.      * SQlite can only handle a maximum of 999 parameters inside an IN statement
  86.      * see https://github.com/jackalope/jackalope-doctrine-dbal/pull/149/files#diff-a3a0165ed79ca1ba3513ec5ecd59ec56R707
  87.      */
  88.     const SQLITE_MAXIMUM_IN_PARAM_COUNT = 999;
  90.     /**
  91.      * The factory to instantiate objects
  92.      *
  93.      * @var FactoryInterface
  94.      */
  95.     protected $factory;
  97.     /**
  98.      * @var ValueConverter
  99.      */
  100.     protected $valueConverter;
  102.     /**
  103.      * @var Connection
  104.      */
  105.     private $conn;
  107.     /**
  108.      * @var Closure
  109.      */
  110.     private $uuidGenerator;
  112.     /**
  113.      * @var bool
  114.      */
  115.     private $loggedIn = false;
  117.     /**
  118.      * @var SimpleCredentials
  119.      */
  120.     private $credentials;
  122.     /**
  123.      * @var string
  124.      */
  125.     protected $workspaceName;
  127.     /**
  128.      * @var array
  129.      */
  130.     private $nodeIdentifiers = [];
  132.     /**
  133.      * @var NodeTypeManager
  134.      */
  135.     private $nodeTypeManager;
  137.     /**
  138.      * @var bool
  139.      */
  140.     protected $inTransaction = false;
  142.     /**
  143.      * Check if an initial request on login should be send to check if repository exists
  144.      * This is according to the JCR specifications and set to true by default
  145.      *
  146.      * @see setCheckLoginOnServer
  147.      *
  148.      * @var bool
  149.      */
  150.     private $checkLoginOnServer = true;
  152.     /**
  153.      * Using an ArrayObject here so that we can pass this into the NodeProcessor by reference more elegantly
  154.      *
  155.      * @var null|ArrayObject
  156.      */
  157.     protected $namespaces;
  159.     /**
  160.      * @var null|array The namespaces at initial state when making changes to the namespaces, in case of rollback.
  161.      */
  162.     private $originalNamespaces;
  164.     /**
  165.      * The core namespaces defined in JCR
  166.      *
  167.      * @var array
  168.      */
  169.     private $coreNamespaces = [
  170.         NS::PREFIX_EMPTY => NS::NAMESPACE_EMPTY,
  171.         NS::PREFIX_JCR => NS::NAMESPACE_JCR,
  172.         NS::PREFIX_NT => NS::NAMESPACE_NT,
  173.         NS::PREFIX_MIX => NS::NAMESPACE_MIX,
  174.         NS::PREFIX_XML => NS::NAMESPACE_XML,
  175.         NS::PREFIX_SV => NS::NAMESPACE_SV,
  176.     ];
  178.     /**
  179.      * @var string|null
  180.      */
  181.     private $sequenceNodeName;
  183.     /**
  184.      * @var string|null
  185.      */
  186.     private $sequenceTypeName;
  188.     /**
  189.      * @var array
  190.      */
  191.     private $referencesToUpdate = [];
  193.     /**
  194.      * @var array
  195.      */
  196.     private $referenceTables = [
  197.         PropertyType::REFERENCE => 'phpcr_nodes_references',
  198.         PropertyType::WEAKREFERENCE => 'phpcr_nodes_weakreferences',
  199.     ];
  201.     /**
  202.      * @var array
  203.      */
  204.     private $referencesToDelete = [];
  206.     /**
  207.      * @var boolean
  208.      */
  209.     private $connectionInitialized = false;
  211.     /**
  212.      * @var NodeProcessor
  213.      */
  214.     private $nodeProcessor;
  216.     /**
  217.      * @var string
  218.      */
  219.     private $caseSensitiveEncoding = null;
  221.     /**
  222.      * @param FactoryInterface $factory
  223.      * @param Connection $conn
  224.      */
  225.     public function __construct(FactoryInterface $factory, Connection $conn)
  226.     {
  227.         $this->factory = $factory;
  228.         $this->valueConverter = $this->factory->get(ValueConverter::class);
  229.         $this->conn = $conn;
  230.     }
  232.     /**
  233.      * @TODO: move to "SqlitePlatform" and rename to "registerExtraFunctions"?
  234.      */
  235.     private function registerSqliteFunctions(PDO $sqliteConnection): void
  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;
  265.                         case 'double':
  266.                             return (double)$content;
  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.         );
  285.     }
  287.     /**
  288.      * @return Connection
  289.      */
  290.     public function getConnection()
  291.     {
  292.         $this->initConnection();
  294.         return $this->conn;
  295.     }
  297.     /**
  298.      * Set the UUID generator to use. If not set, the phpcr-utils UUIDHelper
  299.      * will be used.
  300.      *
  301.      * @param Closure $generator
  302.      */
  303.     public function setUuidGenerator(Closure $generator)
  304.     {
  305.         $this->uuidGenerator = $generator;
  306.     }
  308.     /**
  309.      * @return callable a uuid generator function.
  310.      */
  311.     protected function getUuidGenerator()
  312.     {
  313.         if (!$this->uuidGenerator) {
  314.             $this->uuidGenerator = function () {
  315.                 return UUIDHelper::generateUUID();
  316.             };
  317.         }
  319.         return $this->uuidGenerator;
  320.     }
  322.     /**
  323.      * @return string a universally unique id.
  324.      */
  325.     protected function generateUuid()
  326.     {
  327.         // php 5.3 compatibility, no direct execution of this function.
  328.         $g = $this->getUuidGenerator();
  330.         return $g();
  331.     }
  333.     /**
  334.      * {@inheritDoc}
  335.      *
  336.      * @throws NotImplementedException
  337.      */
  338.     public function createWorkspace($name, $srcWorkspace = null)
  339.     {
  340.         if (null !== $srcWorkspace) {
  341.             throw new NotImplementedException('Creating workspace as clone of existing workspace not supported');
  342.         }
  344.         if ($this->workspaceExists($name)) {
  345.             throw new RepositoryException("Workspace '$name' already exists");
  346.         }
  348.         try {
  349.             $this->getConnection()->insert('phpcr_workspaces', ['name' => $name]);
  350.         } catch (Exception $e) {
  351.             throw new RepositoryException("Couldn't create Workspace '$name': " . $e->getMessage(), 0, $e);
  352.         }
  354.         $this->getConnection()->insert(
  355.             'phpcr_nodes',
  356.             [
  357.                 'path' => '/',
  358.                 'parent' => '',
  359.                 'workspace_name' => $name,
  360.                 'identifier' => $this->generateUuid(),
  361.                 'type' => 'nt:unstructured',
  362.                 'local_name' => '',
  363.                 'namespace' => '',
  364.                 'props' => '<?xml version="1.0" encoding="UTF-8"?>
  365. <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" />',
  366.                 // TODO compute proper value
  367.                 'depth' => 0,
  368.             ]
  369.         );
  370.     }
  372.     /**
  373.      * {@inheritDoc}
  374.      */
  375.     public function deleteWorkspace($name)
  376.     {
  377.         if (!$this->workspaceExists($name)) {
  378.             throw new RepositoryException("Workspace '$name' cannot be deleted as it does not exist");
  379.         }
  381.         try {
  382.             $this->getConnection()->delete('phpcr_workspaces', ['name' => $name]);
  383.         } catch (Exception $e) {
  384.             throw new RepositoryException("Couldn't delete workspace '$name': " . $e->getMessage(), 0, $e);
  385.         }
  387.         try {
  388.             $this->getConnection()->delete('phpcr_nodes', ['workspace_name' => $name]);
  389.         } catch (Exception $e) {
  390.             throw new RepositoryException("Couldn't delete nodes in workspace '$name': " . $e->getMessage(), 0, $e);
  391.         }
  393.         try {
  394.             $this->getConnection()->delete('phpcr_binarydata', ['workspace_name' => $name]);
  395.         } catch (Exception $e) {
  396.             throw new RepositoryException(
  397.                 "Couldn't delete binary data in workspace '$name': " . $e->getMessage(),
  398.                 0,
  399.                 $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()->fetchFirstColumn($query, [$workspaceName]);
  493.         } catch (Exception $e) {
  494.             if ($e instanceof DBALException) {
  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()->executeQuery($query);
  621.             $columns = $result->fetchAllNumeric();
  623.             $namespaces = array_column($columns, 1, 0);
  624.             $namespaces += $this->coreNamespaces;
  626.             $this->setNamespaces($namespaces);
  627.         }
  629.         return $this->namespaces;
  630.     }
  632.     /**
  633.      * Set the namespaces property to an \ArrayObject instance
  634.      *
  635.      * @param array|ArrayObject $namespaces
  636.      */
  637.     protected function setNamespaces($namespaces)
  638.     {
  639.         if ($this->namespaces instanceof ArrayObject) {
  640.             $this->namespaces->exchangeArray($namespaces);
  641.         } else {
  642.             $this->namespaces = new ArrayObject($namespaces);
  643.         }
  644.     }
  646.     /**
  647.      * Executes an UPDATE on DBAL while ensuring that we never try to send more than 999 parameters to SQLite
  648.      *
  649.      * @param $query
  650.      * @param array $params
  651.      *
  652.      * @throws DBALException
  653.      */
  654.     private function executeChunkedUpdate($query, array $params)
  655.     {
  656.         $types = [Connection::PARAM_INT_ARRAY];
  658.         if ($this->getConnection()->getDatabasePlatform() instanceof SqlitePlatform) {
  659.             foreach (array_chunk($params, self::SQLITE_MAXIMUM_IN_PARAM_COUNT) as $chunk) {
  660.                 $this->getConnection()->executeUpdate($query, [$chunk], $types);
  661.             }
  662.         } else {
  663.             $this->getConnection()->executeUpdate($query, [$params], $types);
  664.         }
  665.     }
  667.     /**
  668.      * {@inheritDoc}
  669.      *
  670.      * @throws NoSuchWorkspaceException
  671.      * @throws RepositoryException
  672.      * @throws PathNotFoundException
  673.      * @throws ItemExistsException
  674.      * @throws DBALException
  675.      * @throws InvalidArgumentException
  676.      */
  677.     public function copyNode($srcAbsPath, $dstAbsPath, $srcWorkspace = null)
  678.     {
  679.         $this->assertLoggedIn();
  681.         if (null !== $srcWorkspace && !$this->workspaceExists($srcWorkspace)) {
  682.             throw new NoSuchWorkspaceException("Source workspace '$srcWorkspace' does not exist.");
  683.         }
  684.         $srcWorkspace = $srcWorkspace ?: $this->workspaceName;
  686.         PathHelper::assertValidAbsolutePath($dstAbsPath, true, true, $this->getNamespacePrefixes());
  688.         $srcNodeId = $this->getSystemIdForNode($srcAbsPath, $srcWorkspace);
  689.         if (!$srcNodeId) {
  690.             throw new PathNotFoundException("Source path '$srcAbsPath' not found");
  691.         }
  693.         if ($this->getSystemIdForNode($dstAbsPath)) {
  694.             throw new ItemExistsException("Cannot copy to destination path '$dstAbsPath' that already exists.");
  695.         }
  697.         if (!$this->getSystemIdForNode(PathHelper::getParentPath($dstAbsPath))) {
  698.             throw new PathNotFoundException("Parent of the destination path '" . $dstAbsPath . "' has to exist.");
  699.         }
  701.         // Algorithm:
  702.         // 1. Select all nodes with path $srcAbsPath."%" and iterate them
  703.         // 2. create a new node with path $dstAbsPath + leftovers, with a new uuid. Save old => new uuid
  704.         // 3. copy all properties from old node to new node
  705.         // 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.
  706.         // 5. "May drop mixin types"
  708.         $query = 'SELECT * FROM phpcr_nodes WHERE (path = ? OR path LIKE ?) AND workspace_name = ? ORDER BY depth, sort_order';
  709.         $stmt = $this->getConnection()->executeQuery($query, [$srcAbsPath, $srcAbsPath . '/%', $srcWorkspace]);
  710.         $rows = $stmt->fetchAllAssociative();
  712.         $uuidMap = [];
  713.         $resultSetUuids = [];
  715.         // first iterate and build up an array of all the UUIDs in the result set
  716.         foreach ($rows as $row) {
  717.             $resultSetUuids[$row['identifier']] = $row['path'];
  718.         }
  720.         // array of references to remap within the copied tree
  721.         $referenceElsToRemap = [];
  723.         // array references that will need updating in the database
  724.         $referencesToUpdate = [];
  726.         foreach ($rows as $row) {
  727.             $newPath = str_replace($srcAbsPath, $dstAbsPath, $row['path']);
  729.             $stringDom = new DOMDocument('1.0', 'UTF-8');
  730.             $stringDom->loadXML($row['props']);
  731.             $numericalDom = null;
  732.             if ($row['numerical_props']) {
  733.                 $numericalDom = new DOMDocument('1.0', 'UTF-8');
  734.                 $numericalDom->loadXML($row['numerical_props']);
  735.             }
  737.             $propsData = [
  738.                 'stringDom' => $stringDom,
  739.                 'numericalDom' => $numericalDom,
  740.                 'references' => [],
  741.             ];
  743.             $xpath = new DOMXpath($stringDom);
  744.             $referenceEls = $xpath->query(
  745.                 './/sv:property[@sv:type="reference" or @sv:type="Reference" or @sv:type="weakreference" or @sv:type="WeakReference"]'
  746.             );
  748.             $references = [];
  749.             foreach ($referenceEls as $referenceEl) {
  750.                 $propName = $referenceEl->getAttribute('sv:name');
  751.                 $values = [];
  752.                 foreach ($xpath->query('./sv:value', $referenceEl) as $valueEl) {
  753.                     $values[] = $valueEl->nodeValue;
  754.                 }
  756.                 $references[$propName] = [
  757.                     'type' => PropertyType::valueFromName($referenceEl->getAttribute('sv:type')),
  758.                     'values' => $values,
  759.                 ];
  761.                 if (isset($resultSetUuids[$referenceEl->nodeValue])) {
  762.                     $referenceElsToRemap[] = [$referenceEl, $newPath, $row['type'], $propsData];
  763.                 }
  764.             }
  766.             $originalUuid = $row['identifier'];
  768.             // when copying a node, the copy is always a new node. set $isNewNode to true
  769.             $newNodeId = $this->syncNode(null, $newPath, $row['type'], true, [], $propsData);
  771.             if ($references) {
  772.                 $referencesToUpdate[$newNodeId] = [
  773.                     'path' => $row['path'],
  774.                     'properties' => $references,
  775.                 ];
  776.             }
  778.             $newUuid = $this->nodeIdentifiers[$newPath];
  779.             $uuidMap[$originalUuid] = $newUuid;
  781.             $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 = ?';
  783.             try {
  784.                 $this->getConnection()->executeUpdate($query, [$newNodeId, $this->workspaceName, $row['id']]);
  785.             } catch (DBALException $e) {
  786.                 throw new RepositoryException(
  787.                     "Unexpected exception while copying node from $srcAbsPath to $dstAbsPath",
  788.                     $e->getCode(),
  789.                     $e
  790.                 );
  791.             }
  792.         }
  794.         foreach ($referenceElsToRemap as $data) {
  795.             [$referenceEl, $newPath, $type, $propsData] = $data;
  796.             $referenceEl->nodeValue = $uuidMap[$referenceEl->nodeValue];
  798.             $this->syncNode($this->nodeIdentifiers[$newPath], $newPath, $type, false, [], $propsData);
  799.         }
  801.         $this->syncReferences($referencesToUpdate);
  802.     }
  804.     /**
  805.      * @param string $path
  806.      *
  807.      * @return array
  808.      *
  809.      * @throws NamespaceException
  810.      */
  811.     private function getJcrName($path)
  812.     {
  813.         $name = implode('', array_slice(explode('/', $path), -1, 1));
  814.         $alias = '';
  816.         if (($aliasLength = strpos($name, ':')) !== false) {
  817.             $alias = substr($name, 0, $aliasLength);
  818.             $name = substr($name, $aliasLength + 1);
  819.         }
  821.         $namespaces = $this->getNamespaces();
  823.         if (!isset($namespaces[$alias])) {
  824.             throw new NamespaceException("the namespace $alias was not registered.");
  825.         }
  827.         return [$namespaces[$alias], $name];
  828.     }
  830.     /**
  831.      * Actually write the node into the database
  832.      *
  833.      * @param string $uuid node uuid
  834.      * @param string $path absolute path of the node
  835.      * @param string $type node type name
  836.      * @param boolean $isNewNode new nodes to insert (true) or existing node to update (false)
  837.      * @param Property[] $props
  838.      * @param array $propsData
  839.      *
  840.      * @return boolean|string
  841.      *
  842.      * @throws ItemExistsException
  843.      * @throws RepositoryException
  844.      * @throws NamespaceException
  845.      * @throws Exception
  846.      */
  847.     private function syncNode($uuid, $path, $type, $isNewNode, $props = [], $propsData = [])
  848.     {
  849.         // TODO: Not sure if there are always ALL props in $props, should we grab the online data here?
  850.         // TODO: PERFORMANCE Binary data is handled very inefficiently here, UPSERT will really be necessary here as well as lazy handling
  852.         if (!$propsData) {
  853.             $propsData = $this->propsToXML($props);
  854.         }
  856.         if (null === $uuid) {
  857.             $uuid = $this->generateUuid();
  858.         }
  860.         if ($isNewNode) {
  861.             [$namespace, $localName] = $this->getJcrName($path);
  863.             $qb = $this->getConnection()->createQueryBuilder();
  865.             $qb->select(
  866.                 ':identifier, :type, :path, :local_name, :namespace, :parent, :workspace_name, :props, :numerical_props, :depth, COALESCE(MAX(n.sort_order), 0) + 1'
  867.             )->from('phpcr_nodes', 'n')->where('n.parent = :parent_a');
  869.             $sql = $qb->getSQL();
  871.             try {
  872.                 $insert = "INSERT INTO phpcr_nodes (identifier, type, path, local_name, namespace, parent, workspace_name, props, numerical_props, depth, sort_order) " . $sql;
  874.                 $this->getConnection()->executeUpdate(
  875.                     $insert,
  876.                     $data = [
  877.                         'identifier' => $uuid,
  878.                         'type' => $type,
  879.                         'path' => $path,
  880.                         'local_name' => $localName,
  881.                         'namespace' => $namespace,
  882.                         'parent' => PathHelper::getParentPath($path),
  883.                         'workspace_name' => $this->workspaceName,
  884.                         'props' => $propsData['stringDom']->saveXML(),
  885.                         'numerical_props' => $propsData['numericalDom'] ? $propsData['numericalDom']->saveXML() : null,
  886.                         'depth' => PathHelper::getPathDepth($path),
  887.                         'parent_a' => PathHelper::getParentPath($path),
  888.                     ]
  889.                 );
  890.             } catch (Exception $e) {
  891.                 if ($e instanceof DBALException) {
  892.                     if (strpos($e->getMessage(), 'SQLSTATE[23') !== false) {
  893.                         throw new ItemExistsException('Item ' . $path . ' already exists in the database');
  894.                     } else {
  895.                         throw new RepositoryException(
  896.                             'Unknown database error while inserting item ' . $path . ': ' . $e->getMessage(),
  897.                             0,
  898.                             $e
  899.                         );
  900.                     }
  901.                 } else {
  902.                     throw $e;
  903.                 }
  904.             }
  906.             $nodeId = $this->getConnection()->lastInsertId($this->sequenceNodeName);
  907.         } else {
  908.             $nodeId = $this->getSystemIdForNode($path);
  909.             if (!$nodeId) {
  910.                 throw new RepositoryException("nodeId for $path not found");
  911.             }
  913.             $this->getConnection()->update(
  914.                 'phpcr_nodes',
  915.                 [
  916.                     'props' => $propsData['stringDom']->saveXML(),
  917.                     'numerical_props' => $propsData['numericalDom'] ? $propsData['numericalDom']->saveXML() : null,
  918.                 ],
  919.                 ['id' => $nodeId]
  920.             );
  921.         }
  923.         $this->nodeIdentifiers[$path] = $uuid;
  925.         if (!empty($propsData['binaryData'])) {
  926.             $this->syncBinaryData($nodeId, $propsData['binaryData']);
  927.         }
  929.         $this->referencesToUpdate[$nodeId] = ['path' => $path, 'properties' => $propsData['references']];
  931.         return $nodeId;
  932.     }
  934.     private function syncBinaryData(string $nodeId, array $binaryData): void
  935.     {
  936.         $connection = $this->getConnection();
  937.         foreach ($binaryData as $propertyName => $binaryValues) {
  938.             foreach ($binaryValues as $idx => $data) {
  939.                 // TODO verify in which cases we can just update
  940.                 $params = [
  941.                     'node_id' => $nodeId,
  942.                     'property_name' => $propertyName,
  943.                     'workspace_name' => $this->workspaceName,
  944.                 ];
  946.                 $connection->delete('phpcr_binarydata', $params);
  948.                 $params['idx'] = $idx;
  949.                 $params['data'] = $data;
  950.                 $types = [
  951.                     ParameterType::INTEGER,
  952.                     ParameterType::STRING,
  953.                     ParameterType::STRING,
  954.                     ParameterType::INTEGER,
  955.                     ParameterType::LARGE_OBJECT,
  956.                 ];
  958.                 $connection->insert('phpcr_binarydata', $params, $types);
  959.             }
  960.         }
  961.     }
  963.     /**
  964.      * @param array $referencesToUpdate
  965.      *
  966.      * @throws RepositoryException
  967.      * @throws ReferentialIntegrityException
  968.      */
  969.     private function syncReferences(array $referencesToUpdate)
  970.     {
  971.         if ($referencesToUpdate) {
  972.             // do not update references that are going to be deleted anyways
  973.             $toUpdate = array_diff(array_keys($referencesToUpdate), array_keys($this->referencesToDelete));
  975.             try {
  976.                 foreach ($this->referenceTables as $table) {
  977.                     $query = "DELETE FROM $table WHERE source_id IN (?)";
  978.                     $this->executeChunkedUpdate($query, $toUpdate);
  979.                 }
  980.             } catch (DBALException $e) {
  981.                 throw new RepositoryException('Unexpected exception while cleaning up after saving', $e->getCode(), $e);
  982.             }
  984.             $updates = [];
  985.             foreach ($toUpdate as $nodeId) {
  986.                 $references = $referencesToUpdate[$nodeId];
  987.                 foreach ($references['properties'] as $name => $data) {
  988.                     foreach ($data['values'] as $value) {
  989.                         $targetId = $this->getSystemIdForNode($value);
  990.                         if (false === $targetId) {
  991.                             if (PropertyType::REFERENCE === $data['type']) {
  992.                                 throw new ReferentialIntegrityException(
  993.                                     sprintf(
  994.                                         'Trying to store reference to non-existant node with path "%s" in node "%s" "%s"',
  995.                                         $value,
  996.                                         $references['path'],
  997.                                         $name
  998.                                     )
  999.                                 );
  1000.                             }
  1002.                             continue;
  1003.                         }
  1005.                         $key = $targetId . '-' . $nodeId . '-' . $name;
  1006.                         // it is valid to have multiple references to the same node in a multivalue
  1007.                         // but it is not desired to store duplicates in the database
  1008.                         $updates[$key] = [
  1009.                             'type' => $data['type'],
  1010.                             'data' => [
  1011.                                 'source_id' => $nodeId,
  1012.                                 'source_property_name' => $name,
  1013.                                 'target_id' => $targetId,
  1014.                             ],
  1015.                         ];
  1016.                     }
  1017.                 }
  1018.             }
  1020.             foreach ($updates as $update) {
  1021.                 $this->getConnection()->insert($this->referenceTables[$update['type']], $update['data']);
  1022.             }
  1023.         }
  1025.         // TODO on RDBMS that support deferred FKs we could skip this step
  1026.         if ($this->referencesToDelete) {
  1027.             $params = array_keys($this->referencesToDelete);
  1029.             // remove all PropertyType::REFERENCE with a source_id on a deleted node
  1030.             try {
  1031.                 $query = "DELETE FROM phpcr_nodes_references WHERE source_id IN (?)";
  1032.                 $this->executeChunkedUpdate($query, $params);
  1033.             } catch (DBALException $e) {
  1034.                 throw new RepositoryException(
  1035.                     'Unexpected exception while cleaning up deleted nodes',
  1036.                     $e->getCode(),
  1037.                     $e
  1038.                 );
  1039.             }
  1041.             // ensure that there are no PropertyType::REFERENCE pointing to nodes that will be deleted
  1042.             // Note: due to the outer join we cannot filter on workspace_name, but this is ok
  1043.             // since within a transaction there can never be missing referenced nodes within the current workspace
  1044.             // make sure the target node is not in the list of nodes being deleted, to allow deletion in same request
  1045.             $query = 'SELECT DISTINCT r.target_id
  1046.             FROM phpcr_nodes_references r
  1047.                 LEFT OUTER JOIN phpcr_nodes n ON r.target_id = n.id
  1048.             WHERE r.target_id IN (?)';
  1050.             if ($this->getConnection()->getDatabasePlatform() instanceof SqlitePlatform) {
  1051.                 $missingTargets = [];
  1052.                 foreach (array_chunk($params, self::SQLITE_MAXIMUM_IN_PARAM_COUNT) as $chunk) {
  1053.                     $stmt = $this->getConnection()->executeQuery($query, [$chunk], [Connection::PARAM_INT_ARRAY]);
  1054.                     $missingTargets = array_merge($missingTargets, array_column($stmt->fetchAllNumeric(), 0));
  1055.                 }
  1056.             } else {
  1057.                 $stmt = $this->getConnection()->executeQuery($query, [$params], [Connection::PARAM_INT_ARRAY]);
  1058.                 $missingTargets = array_column($stmt->fetchAllNumeric(), 0);
  1059.             }
  1060.             if ($missingTargets) {
  1061.                 $paths = [];
  1062.                 foreach ($missingTargets as $id) {
  1063.                     if (isset($this->referencesToDelete[$id])) {
  1064.                         $paths[] = $this->referencesToDelete[$id];
  1065.                     }
  1066.                 }
  1068.                 throw new ReferentialIntegrityException(
  1069.                     "Cannot delete '" . implode("', '", $paths) . "': A reference points to this node or a subnode"
  1070.                 );
  1071.             }
  1073.             // clean up all references
  1074.             try {
  1075.                 foreach ($this->referenceTables as $table) {
  1076.                     $query = "DELETE FROM $table WHERE target_id IN (?)";
  1077.                     $this->executeChunkedUpdate($query, $params);
  1078.                 }
  1079.             } catch (DBALException $e) {
  1080.                 throw new RepositoryException(
  1081.                     'Unexpected exception while cleaning up deleted nodes',
  1082.                     $e->getCode(),
  1083.                     $e
  1084.                 );
  1085.             }
  1086.         }
  1087.     }
  1089.     /**
  1090.      * Convert the node XML to stdClass node representation containing all properties
  1091.      *
  1092.      * @param string $xml
  1093.      *
  1094.      * @return stdClass
  1095.      *
  1096.      * @throws InvalidArgumentException
  1097.      */
  1098.     protected function xmlToProps($xml)
  1099.     {
  1100.         $xmlParser = new XmlToPropsParser(
  1101.             $xml,
  1102.             $this->valueConverter
  1103.         );
  1105.         return $xmlParser->parse();
  1106.     }
  1108.     /**
  1109.      * Convert the node XML to stdClass node representation containing only the given properties
  1110.      *
  1111.      * @param string $xml
  1112.      * @param array $propertyNames
  1113.      *
  1114.      * @return stdClass
  1115.      *
  1116.      * @throws InvalidArgumentException
  1117.      */
  1118.     protected function xmlToColumns($xml, $propertyNames)
  1119.     {
  1120.         $xmlParser = new XmlToPropsParser(
  1121.             $xml,
  1122.             $this->valueConverter,
  1123.             $propertyNames
  1124.         );
  1126.         return $xmlParser->parse();
  1127.     }
  1129.     /**
  1130.      * Map a property from the given property XML node to the given \stdClass node representation
  1131.      *
  1132.      * @param DOMElement $propertyNode
  1133.      * @param stdClass $data
  1134.      *
  1135.      * @throws InvalidArgumentException
  1136.      *
  1137.      * @deprecated This method was replaced with the `XmlToPropsParser` for performance reasons.
  1138.      */
  1139.     protected function mapPropertyFromElement(DOMElement $propertyNode, stdClass $data)
  1140.     {
  1141.         @trigger_error(
  1142.             sprintf('The "%s" method is deprecated since jackalope/jackalope-doctrine-dbal 1.7.', __METHOD__),
  1143.             \E_USER_DEPRECATED
  1144.         );
  1146.         $name = $propertyNode->getAttribute('sv:name');
  1148.         $values = [];
  1150.         $type = PropertyType::valueFromName($propertyNode->getAttribute('sv:type'));
  1151.         foreach ($propertyNode->childNodes as $valueNode) {
  1152.             switch ($type) {
  1153.                 case PropertyType::NAME:
  1154.                 case PropertyType::URI:
  1155.                 case PropertyType::WEAKREFERENCE:
  1156.                 case PropertyType::REFERENCE:
  1157.                 case PropertyType::PATH:
  1158.                 case PropertyType::DECIMAL:
  1159.                 case PropertyType::STRING:
  1160.                     $values[] = $valueNode->nodeValue;
  1161.                     break;
  1162.                 case PropertyType::BOOLEAN:
  1163.                     $values[] = (bool)$valueNode->nodeValue;
  1164.                     break;
  1165.                 case PropertyType::LONG:
  1166.                     $values[] = (int)$valueNode->nodeValue;
  1167.                     break;
  1168.                 case PropertyType::BINARY:
  1169.                     $values[] = (int)$valueNode->nodeValue;
  1170.                     break;
  1171.                 case PropertyType::DATE:
  1172.                     $date = $valueNode->nodeValue;
  1173.                     if ($date) {
  1174.                         $date = new DateTime($date);
  1175.                         $date->setTimezone(new DateTimeZone(date_default_timezone_get()));
  1176.                         // Jackalope expects a string, might make sense to refactor to allow DateTime instances too
  1177.                         $date = $this->valueConverter->convertType($date, PropertyType::STRING);
  1178.                     }
  1179.                     $values[] = $date;
  1180.                     break;
  1181.                 case PropertyType::DOUBLE:
  1182.                     $values[] = (double)$valueNode->nodeValue;
  1183.                     break;
  1184.                 default:
  1185.                     throw new InvalidArgumentException("Type with constant $type not found.");
  1186.             }
  1187.         }
  1189.         switch ($type) {
  1190.             case PropertyType::BINARY:
  1191.                 $data->{':' . $name} = $propertyNode->getAttribute('sv:multi-valued') ? $values : $values[0];
  1192.                 break;
  1193.             default:
  1194.                 $data->{$name} = $propertyNode->getAttribute('sv:multi-valued') ? $values : $values[0];
  1195.                 $data->{':' . $name} = $type;
  1196.                 break;
  1197.         }
  1198.     }
  1200.     /**
  1201.      * Seperate properties array into an xml and binary data.
  1202.      *
  1203.      * @param array $properties
  1204.      *
  1205.      * @return array (
  1206.      *     'stringDom' => $stringDom,
  1207.      *     'numericalDom' => $numericalDom',
  1208.      *     'binaryData' => streams,
  1209.      *     'references' => ['type' => INT, 'values' => [UUIDs])
  1210.      * )
  1211.      *
  1212.      * @throws RepositoryException
  1213.      */
  1214.     private function propsToXML($properties)
  1215.     {
  1216.         $namespaces = [
  1217.             NS::PREFIX_MIX => NS::NAMESPACE_MIX,
  1218.             NS::PREFIX_NT => NS::NAMESPACE_NT,
  1219.             'xs' => 'http://www.w3.org/2001/XMLSchema',
  1220.             NS::PREFIX_JCR => NS::NAMESPACE_JCR,
  1221.             NS::PREFIX_SV => NS::NAMESPACE_SV,
  1222.             'rep' => 'internal',
  1223.         ];
  1225.         $doms = [
  1226.             'stringDom' => [],
  1227.             'numericalDom' => [],
  1228.         ];
  1230.         $binaryData = $references = [];
  1232.         foreach ($properties as $property) {
  1233.             $targetDoms = ['stringDom'];
  1235.             switch ($property->getType()) {
  1236.                 case PropertyType::WEAKREFERENCE:
  1237.                 case PropertyType::REFERENCE:
  1238.                     $references[$property->getName()] = [
  1239.                         'type' => $property->getType(),
  1240.                         'values' => $property->isMultiple() ? $property->getString() : [$property->getString()],
  1241.                     ];
  1242.                     // no break
  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 array_column($stmt->fetchAllNumeric(), 0);
  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->fetchAllAssociative();
  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()->fetchAllAssociative(
  1482.                     $query,
  1483.                     [$chunk, $this->workspaceName],
  1484.                     [Connection::PARAM_STR_ARRAY, null]
  1485.                 );
  1486.             }
  1487.         } else {
  1488.             $childrenRows = $this->getConnection()->fetchAllAssociative(
  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);
  1571.         // emulate old $stmt->fetchAll(PDO::FETCH_UNIQUE | PDO::FETCH_GROUP)
  1572.         $all = [];
  1573.         while ($row = $stmt->fetchAssociative()) {
  1574.             $index = array_shift($row);
  1575.             $all[$index] = $row;
  1576.         }
  1578.         $nodes = [];
  1579.         if ($all) {
  1580.             $nodes = $this->getNodesData($all);
  1581.         }
  1583.         return $nodes;
  1584.     }
  1587.     /**
  1588.      * Determine if a path exists already.
  1589.      *
  1590.      * @param string $path Path of the node
  1591.      * @param string $workspaceName To overwrite the current workspace
  1592.      *
  1593.      * @return bool
  1594.      */
  1595.     private function pathExists($path, $workspaceName = null)
  1596.     {
  1597.         return (boolean)$this->getSystemIdForNode($path, $workspaceName);
  1598.     }
  1600.     /**
  1601.      * Get the database primary key for node.
  1602.      *
  1603.      * @param string $identifier Path of the identifier
  1604.      * @param string $workspaceName To overwrite the current workspace
  1605.      *
  1606.      * @return bool|string The database id
  1607.      */
  1608.     private function getSystemIdForNode($identifier, $workspaceName = null)
  1609.     {
  1610.         if (null === $workspaceName) {
  1611.             $workspaceName = $this->workspaceName;
  1612.         }
  1614.         if (UUIDHelper::isUUID($identifier)) {
  1615.             $query = 'SELECT id FROM phpcr_nodes WHERE identifier = ? AND workspace_name = ?';
  1616.         } else {
  1617.             $platform = $this->getConnection()->getDatabasePlatform();
  1618.             if ($platform instanceof MySQLPlatform) {
  1619.                 $query = 'SELECT id FROM phpcr_nodes WHERE path COLLATE ' . $this->getCaseSensitiveEncoding() . ' = ? AND workspace_name = ?';
  1620.             } else {
  1621.                 $query = 'SELECT id FROM phpcr_nodes WHERE path = ? AND workspace_name = ?';
  1622.             }
  1623.         }
  1625.         $nodeId = $this->getConnection()->fetchOne($query, [$identifier, $workspaceName]);
  1627.         return $nodeId ?: false;
  1628.     }
  1630.     /**
  1631.      * {@inheritDoc}
  1632.      */
  1633.     public function getNodeByIdentifier($uuid)
  1634.     {
  1635.         $this->assertLoggedIn();
  1637.         $query = 'SELECT * FROM phpcr_nodes WHERE identifier = ? AND workspace_name = ?';
  1638.         $row = $this->getConnection()->fetchAssociative($query, [$uuid, $this->workspaceName]);
  1639.         if (!$row) {
  1640.             throw new ItemNotFoundException("Item $uuid not found in workspace " . $this->workspaceName);
  1641.         }
  1643.         $path = $row['path'];
  1644.         $data = $this->getNodeData($row);
  1645.         $data->{':jcr:path'} = $path;
  1647.         return $data;
  1648.     }
  1650.     /**
  1651.      * {@inheritDoc}
  1652.      */
  1653.     public function getNodesByIdentifier($identifiers)
  1654.     {
  1655.         $this->assertLoggedIn();
  1657.         if (empty($identifiers)) {
  1658.             return [];
  1659.         }
  1661.         $query = 'SELECT id, path, parent, local_name, namespace, workspace_name, identifier, type, props, depth, sort_order
  1662.             FROM phpcr_nodes WHERE workspace_name = ? AND identifier IN (?)';
  1663.         if ($this->getConnection()->getDatabasePlatform() instanceof SqlitePlatform) {
  1664.             $all = [];
  1665.             foreach (array_chunk($identifiers, self::SQLITE_MAXIMUM_IN_PARAM_COUNT) as $chunk) {
  1666.                 $all += $this->getConnection()->fetchAllAssociative(
  1667.                     $query,
  1668.                     [$this->workspaceName, $chunk],
  1669.                     [ParameterType::STRING, Connection::PARAM_STR_ARRAY]
  1670.                 );
  1671.             }
  1672.         } else {
  1673.             $all = $this->getConnection()->fetchAllAssociative(
  1674.                 $query,
  1675.                 [$this->workspaceName, $identifiers],
  1676.                 [ParameterType::STRING, Connection::PARAM_STR_ARRAY]
  1677.             );
  1678.         }
  1680.         $nodes = [];
  1681.         if ($all) {
  1682.             $nodesData = $this->getNodesData($all);
  1683.             // ensure that the nodes are returned in the order if how the identifiers were passed in
  1684.             $pathByUuid = [];
  1685.             foreach ($nodesData as $path => $node) {
  1686.                 $pathByUuid[$node->{'jcr:uuid'}] = $path;
  1687.             }
  1688.             foreach ($identifiers as $identifier) {
  1689.                 if (isset($pathByUuid[$identifier])) {
  1690.                     $nodes[$pathByUuid[$identifier]] = $nodesData[$pathByUuid[$identifier]];
  1691.                 }
  1692.             }
  1693.         }
  1695.         return $nodes;
  1696.     }
  1698.     /**
  1699.      * {@inheritDoc}
  1700.      *
  1701.      * @throws NotImplementedException
  1702.      * @throws ItemNotFoundException
  1703.      */
  1704.     public function getNodePathForIdentifier($uuid, $workspace = null)
  1705.     {
  1706.         if (null !== $workspace) {
  1707.             throw new NotImplementedException('Specifying the workspace is not yet supported.');
  1708.         }
  1710.         $this->assertLoggedIn();
  1712.         $query = "SELECT path FROM phpcr_nodes WHERE identifier = ? AND workspace_name = ?";
  1713.         $path = $this->getConnection()->fetchOne($query, [$uuid, $this->workspaceName]);
  1714.         if (!$path) {
  1715.             throw new ItemNotFoundException("no item found with uuid " . $uuid);
  1716.         }
  1718.         return $path;
  1719.     }
  1721.     /**
  1722.      * {@inheritDoc}
  1723.      */
  1724.     public function deleteNodes(array $operations)
  1725.     {
  1726.         $this->assertLoggedIn();
  1728.         foreach ($operations as $op) {
  1729.             $this->deleteNode($op->srcPath);
  1730.         }
  1732.         return true;
  1733.     }
  1735.     /**
  1736.      * {@inheritDoc}
  1737.      */
  1738.     public function deleteNodeImmediately($path)
  1739.     {
  1740.         $this->prepareSave();
  1741.         $this->deleteNode($path);
  1742.         $this->finishSave();
  1744.         return true;
  1745.     }
  1747.     /**
  1748.      * TODO instead of calling the deletes separately, we should batch the delete query
  1749.      * but careful with the caching!
  1750.      *
  1751.      * @param string $path node path to delete
  1752.      *
  1753.      * @throws ConstraintViolationException
  1754.      * @throws ItemNotFoundException
  1755.      * @throws RepositoryException
  1756.      */
  1757.     protected function deleteNode($path)
  1758.     {
  1759.         if ('/' === $path) {
  1760.             throw new ConstraintViolationException('You can not delete the root node of a repository');
  1761.         }
  1763.         if (!$this->pathExists($path)) {
  1764.             throw new ItemNotFoundException("No node found at " . $path);
  1765.         }
  1767.         $params = [$path, $path . "/%", $this->workspaceName];
  1769.         // TODO on RDBMS that support deferred FKs we could skip this step
  1770.         $query = 'SELECT id, path FROM phpcr_nodes WHERE (path = ? OR path LIKE ?) AND workspace_name = ?';
  1771.         $stmt = $this->getConnection()->executeQuery($query, $params);
  1772.         $this->referencesToDelete += array_column($stmt->fetchAllNumeric(), 1, 0);
  1774.         try {
  1775.             $query = 'DELETE FROM phpcr_nodes WHERE (path = ? OR path LIKE ?) AND workspace_name = ?';
  1776.             $this->getConnection()->executeUpdate($query, $params);
  1777.             $this->cleanIdentifierCache($path);
  1778.         } catch (DBALException $e) {
  1779.             throw new RepositoryException('Unexpected exception while deleting node ' . $path, $e->getCode(), $e);
  1780.         }
  1781.     }
  1783.     /**
  1784.      * Clean all identifiers under path $root.
  1785.      *
  1786.      * @param string $root Path to the root node to be cleared
  1787.      */
  1788.     private function cleanIdentifierCache($root)
  1789.     {
  1790.         unset($this->nodeIdentifiers[$root]);
  1791.         foreach (array_keys($this->nodeIdentifiers) as $path) {
  1792.             if (strpos($path, "$root/") === 0) {
  1793.                 unset($this->nodeIdentifiers[$path]);
  1794.             }
  1795.         }
  1796.     }
  1798.     /**
  1799.      * {@inheritDoc}
  1800.      */
  1801.     public function deleteProperties(array $operations)
  1802.     {
  1803.         $this->assertLoggedIn();
  1805.         foreach ($operations as $op) {
  1806.             $this->deleteProperty($op->srcPath);
  1807.         }
  1809.         return true;
  1810.     }
  1812.     /**
  1813.      * {@inheritDoc}
  1814.      */
  1815.     public function deletePropertyImmediately($path)
  1816.     {
  1817.         $this->prepareSave();
  1818.         $this->deleteProperty($path);
  1819.         $this->finishSave();
  1821.         return true;
  1822.     }
  1824.     /**
  1825.      * {@inheritDoc}
  1826.      *
  1827.      * @throws ItemNotFoundException
  1828.      * @throws RepositoryException
  1829.      */
  1830.     protected function deleteProperty($path)
  1831.     {
  1832.         $this->assertLoggedIn();
  1834.         $nodePath = PathHelper::getParentPath($path);
  1835.         $nodeId = $this->getSystemIdForNode($nodePath);
  1836.         if (!$nodeId) {
  1837.             // no we really don't know that path
  1838.             throw new ItemNotFoundException("No item found at " . $path);
  1839.         }
  1841.         $query = 'SELECT props FROM phpcr_nodes WHERE id = ?';
  1842.         $xml = $this->getConnection()->fetchOne($query, [$nodeId]);
  1844.         $dom = new DOMDocument('1.0', 'UTF-8');
  1845.         $dom->loadXML($xml);
  1846.         $xpath = new DomXpath($dom);
  1848.         $found = false;
  1849.         $propertyName = PathHelper::getNodeName($path);
  1850.         foreach ($xpath->query(sprintf('//*[@sv:name="%s"]', $propertyName)) as $propertyNode) {
  1851.             $found = true;
  1852.             // would be nice to have the property object to ask for type
  1853.             // but its in state deleted, would mean lots of refactoring
  1854.             if ($propertyNode->hasAttribute('sv:type')) {
  1855.                 $type = strtolower($propertyNode->getAttribute('sv:type'));
  1856.                 if (in_array($type, ['reference', 'weakreference'])) {
  1857.                     $table = $this->referenceTables['reference' === $type ? PropertyType::REFERENCE : PropertyType::WEAKREFERENCE];
  1858.                     try {
  1859.                         $query = "DELETE FROM $table WHERE source_id = ? AND source_property_name = ?";
  1860.                         $this->getConnection()->executeUpdate($query, [$nodeId, $propertyName]);
  1861.                     } catch (DBALException $e) {
  1862.                         throw new RepositoryException(
  1863.                             'Unexpected exception while cleaning up deleted nodes',
  1864.                             $e->getCode(),
  1865.                             $e
  1866.                         );
  1867.                     }
  1868.                 }
  1869.             }
  1871.             $propertyNode->parentNode->removeChild($propertyNode);
  1872.         }
  1874.         if (!$found) {
  1875.             throw new ItemNotFoundException("Node $nodePath has no property $propertyName");
  1876.         }
  1878.         $xml = $dom->saveXML();
  1880.         $query = 'UPDATE phpcr_nodes SET props = ? WHERE id = ?';
  1881.         $params = [$xml, $nodeId];
  1883.         try {
  1884.             $this->getConnection()->executeUpdate($query, $params);
  1885.         } catch (DBALException $e) {
  1886.             throw new RepositoryException("Unexpected exception while updating properties of $path", $e->getCode(), $e);
  1887.         }
  1888.     }
  1890.     /**
  1891.      * {@inheritDoc}
  1892.      */
  1893.     public function moveNodes(array $operations)
  1894.     {
  1895.         /** @var $op MoveNodeOperation */
  1896.         foreach ($operations as $op) {
  1897.             $this->moveNode($op->srcPath, $op->dstPath);
  1898.         }
  1900.         return true;
  1901.     }
  1903.     /**
  1904.      * {@inheritDoc}
  1905.      */
  1906.     public function moveNodeImmediately($srcAbsPath, $dstAbspath)
  1907.     {
  1908.         $this->prepareSave();
  1909.         $this->moveNode($srcAbsPath, $dstAbspath);
  1910.         $this->finishSave();
  1912.         return true;
  1913.     }
  1915.     /**
  1916.      * Execute moving a single node
  1917.      *
  1918.      * @throws PathNotFoundException
  1919.      * @throws ItemExistsException
  1920.      * @throws RepositoryException
  1921.      */
  1922.     protected function moveNode($srcAbsPath, $dstAbsPath)
  1923.     {
  1924.         $this->assertLoggedIn();
  1925.         PathHelper::assertValidAbsolutePath($srcAbsPath, false, true, $this->getNamespacePrefixes());
  1926.         PathHelper::assertValidAbsolutePath($dstAbsPath, true, true, $this->getNamespacePrefixes());
  1928.         if (!$this->pathExists($srcAbsPath)) {
  1929.             throw new PathNotFoundException("Source path '$srcAbsPath' not found");
  1930.         }
  1932.         if ($this->getSystemIdForNode($dstAbsPath)) {
  1933.             throw new ItemExistsException(
  1934.                 "Cannot move '$srcAbsPath' to '$dstAbsPath' because destination node already exists."
  1935.             );
  1936.         }
  1938.         if (!$this->getSystemIdForNode(PathHelper::getParentPath($dstAbsPath))) {
  1939.             throw new PathNotFoundException("Parent of the destination path '" . $dstAbsPath . "' has to exist.");
  1940.         }
  1942.         $query = 'SELECT path, id FROM phpcr_nodes WHERE path LIKE ? OR path = ? AND workspace_name = ? ' . $this->getConnection(
  1943.             )->getDatabasePlatform()->getForUpdateSQL();
  1944.         $stmt = $this->getConnection()->executeQuery($query, [$srcAbsPath . '/%', $srcAbsPath, $this->workspaceName]);
  1946.         /*
  1947.          * TODO: https://github.com/jackalope/jackalope-doctrine-dbal/pull/26/files#L0R1057
  1948.          * the other thing i wonder: can't you do the replacement inside sql instead of loading and then storing
  1949.          * the node? this will be extremely slow for a large set of nodes. i think you should use query builder here
  1950.          * rather than raw sql, to make it work on a maximum of platforms.
  1951.          *
  1952.          * can you try to do this please? if we don't figure out how to do it, at least fix the where criteria, and
  1953.          * we can ask the doctrine community how to do the substring operation.
  1954.          * http://stackoverflow.com/questions/8619421/correct-syntax-for-doctrine2s-query-builder-substring-helper-method
  1955.          */
  1957.         $query = "UPDATE phpcr_nodes SET ";
  1958.         $updatePathCase = "path = CASE ";
  1959.         $updateParentCase = "parent = CASE ";
  1960.         $updateLocalNameCase = "local_name = CASE ";
  1961.         $updateSortOrderCase = "sort_order = CASE ";
  1962.         $updateDepthCase = "depth = CASE ";
  1964.         // TODO: Find a better way to do this
  1965.         // Calculate CAST type for CASE statement
  1966.         switch ($this->getConnection()->getDatabasePlatform()->getName()) {
  1967.             case 'pgsql':
  1968.                 $intType = 'integer';
  1969.                 break;
  1970.             case 'mysql':
  1971.                 $intType = 'unsigned';
  1972.                 break;
  1973.             default:
  1974.                 $intType = 'integer';
  1975.         }
  1977.         $i = 0;
  1978.         $values = $ids = [];
  1979.         $srcAbsPathPattern = '/^' . preg_quote($srcAbsPath, '/') . '/';
  1980.         while ($row = $stmt->fetchAssociative()) {
  1981.             $values['id' . $i] = $row['id'];
  1982.             $values['path' . $i] = preg_replace($srcAbsPathPattern, $dstAbsPath, $row['path'], 1);
  1983.             $values['parent' . $i] = PathHelper::getParentPath($values['path' . $i]);
  1984.             $values['depth' . $i] = PathHelper::getPathDepth($values['path' . $i]);
  1986.             $updatePathCase .= "WHEN id = :id$i THEN :path$i ";
  1987.             $updateParentCase .= "WHEN id = :id$i THEN :parent$i ";
  1988.             $updateDepthCase .= "WHEN id = :id$i THEN CAST(:depth$i AS $intType) ";
  1990.             if ($srcAbsPath === $row['path']) {
  1991.                 [, $localName] = $this->getJcrName($values['path' . $i]);
  1992.                 $values['localname' . $i] = $localName;
  1994.                 $updateLocalNameCase .= "WHEN id = :id$i THEN :localname$i ";
  1995.                 $updateSortOrderCase .= "WHEN id = :id$i THEN (SELECT * FROM ( SELECT MAX(x.sort_order) + 1 FROM phpcr_nodes x WHERE x.parent = :parent$i) y) ";
  1996.             }
  1998.             $ids[] = $row['id'];
  2000.             $i++;
  2001.         }
  2003.         if (!$i) {
  2004.             return;
  2005.         }
  2007.         $ids = implode(',', $ids);
  2009.         $updateLocalNameCase .= 'ELSE local_name END, ';
  2010.         $updateSortOrderCase .= 'ELSE sort_order END ';
  2012.         $query .= $updatePathCase . 'END, ' . $updateParentCase . 'END, ' . $updateDepthCase . 'END, ' . $updateLocalNameCase . $updateSortOrderCase;
  2013.         $query .= "WHERE id IN ($ids)";
  2015.         try {
  2016.             $this->getConnection()->executeStatement($query, $values);
  2017.         } catch (DBALException $e) {
  2018.             throw new RepositoryException(
  2019.                 "Unexpected exception while moving node from $srcAbsPath to $dstAbsPath",
  2020.                 $e->getCode(),
  2021.                 $e
  2022.             );
  2023.         }
  2025.         $this->cleanIdentifierCache($srcAbsPath);
  2026.     }
  2028.     /**
  2029.      * {@inheritDoc}
  2030.      *
  2031.      * @throws RepositoryException
  2032.      */
  2033.     public function reorderChildren(Node $node)
  2034.     {
  2035.         $this->assertLoggedIn();
  2037.         $values['absPath'] = $node->getPath();
  2038.         $sql = "UPDATE phpcr_nodes SET sort_order = CASE CONCAT(
  2039.           namespace,
  2040.           (CASE namespace WHEN '' THEN '' ELSE ':' END),
  2041.           local_name
  2042.         )";
  2044.         $i = 0;
  2046.         foreach ($node->getNodeNames() as $name) {
  2047.             $values['name' . $i] = implode(':', array_filter($this->getJcrName($name)));
  2048.             $values['order' . $i] = $i; // use our counter to avoid gaps
  2049.             $sql .= " WHEN :name$i THEN :order$i";
  2050.             $i++;
  2051.         }
  2053.         $sql .= ' ELSE sort_order END WHERE parent = :absPath';
  2055.         try {
  2056.             $this->getConnection()->executeStatement($sql, $values);
  2057.         } catch (DBALException $e) {
  2058.             throw new RepositoryException('Unexpected exception while reordering nodes', $e->getCode(), $e);
  2059.         }
  2061.         return true;
  2062.     }
  2064.     /**
  2065.      * Return the node processor for processing nodes
  2066.      * according to their node types.
  2067.      *
  2068.      * @return NodeProcessor
  2069.      */
  2070.     private function getNodeProcessor()
  2071.     {
  2072.         if ($this->nodeProcessor) {
  2073.             return $this->nodeProcessor;
  2074.         }
  2076.         $this->nodeProcessor = new NodeProcessor(
  2077.             $this->credentials->getUserID(),
  2078.             $this->getNamespacesObject(),
  2079.             $this->getAutoLastModified()
  2080.         );
  2082.         return $this->nodeProcessor;
  2083.     }
  2085.     /**
  2086.      * {@inheritDoc}
  2087.      */
  2088.     public function storeNodes(array $operations)
  2089.     {
  2090.         $this->assertLoggedIn();
  2092.         $additionalAddOperations = [];
  2094.         foreach ($operations as $operation) {
  2095.             if ($operation->node->isDeleted()) {
  2096.                 $properties = $operation->node->getPropertiesForStoreDeletedNode();
  2097.             } else {
  2098.                 $additionalAddOperations = array_merge(
  2099.                     $additionalAddOperations,
  2100.                     $this->getNodeProcessor()->process($operation->node)
  2101.                 );
  2102.                 $properties = $operation->node->getProperties();
  2103.             }
  2104.             $this->storeNode($operation->srcPath, $properties);
  2105.         }
  2107.         if (!empty($additionalAddOperations)) {
  2108.             $this->storeNodes($additionalAddOperations);
  2109.         }
  2110.     }
  2112.     /**
  2113.      * Make sure we have a uuid and a primaryType, then sync data into the database
  2114.      *
  2115.      * @param string $path the path to store the node at
  2116.      * @param Property[] $properties the properties of this node
  2117.      *
  2118.      * @return boolean true on success
  2119.      *
  2120.      * @throws RepositoryException if not logged in
  2121.      */
  2122.     protected function storeNode($path, $properties)
  2123.     {
  2124.         $nodeIdentifier = $this->getIdentifier($path, $properties);
  2125.         $type = isset($properties['jcr:primaryType']) ? $properties['jcr:primaryType']->getValue() : 'nt:unstructured';
  2127.         $this->syncNode($nodeIdentifier, $path, $type, true, $properties);
  2129.         return true;
  2130.     }
  2132.     /**
  2133.      * Determine a UUID for the node at this path with these properties
  2134.      *
  2135.      * @param string $path
  2136.      * @param Property[] $properties
  2137.      *
  2138.      * @return string a unique id
  2139.      */
  2140.     protected function getIdentifier($path, $properties)
  2141.     {
  2142.         if (isset($this->nodeIdentifiers[$path])) {
  2143.             return $this->nodeIdentifiers[$path];
  2144.         }
  2146.         if (isset($properties['jcr:uuid'])) {
  2147.             return $properties['jcr:uuid']->getValue();
  2148.         }
  2150.         // we always generate a uuid, even for non-referenceable nodes that have no automatic uuid
  2151.         return $this->generateUuid();
  2152.     }
  2154.     /**
  2155.      * {@inheritDoc}
  2156.      */
  2157.     public function getNodeTypes($nodeTypes = [])
  2158.     {
  2159.         $standardTypes = StandardNodeTypes::getNodeTypeData();
  2161.         $userTypes = $this->fetchUserNodeTypes();
  2163.         if ($nodeTypes) {
  2164.             $nodeTypes = array_flip($nodeTypes);
  2165.             return array_values(
  2166.                 array_intersect_key($standardTypes, $nodeTypes) + array_intersect_key($userTypes, $nodeTypes)
  2167.             );
  2168.         }
  2170.         return array_values($standardTypes + $userTypes);
  2171.     }
  2173.     /**
  2174.      * Fetch a user-defined node-type definition.
  2175.      *
  2176.      * @return array
  2177.      */
  2178.     protected function fetchUserNodeTypes()
  2179.     {
  2180.         $result = [];
  2182.         $query = '
  2183. SELECT
  2184. phpcr_type_nodes.name AS node_name, phpcr_type_nodes.is_abstract AS node_abstract,
  2185. phpcr_type_nodes.is_mixin AS node_mixin, phpcr_type_nodes.queryable AS node_queryable,
  2186. phpcr_type_nodes.orderable_child_nodes AS node_has_orderable_child_nodes,
  2187. phpcr_type_nodes.primary_item AS node_primary_item_name, phpcr_type_nodes.supertypes AS declared_super_type_names,
  2188. phpcr_type_props.name AS property_name, phpcr_type_props.auto_created AS property_auto_created,
  2189. phpcr_type_props.mandatory AS property_mandatory, phpcr_type_props.protected AS property_protected,
  2190. phpcr_type_props.on_parent_version AS property_on_parent_version,
  2191. phpcr_type_props.required_type AS property_required_type, phpcr_type_props.multiple AS property_multiple,
  2192. phpcr_type_props.fulltext_searchable AS property_fulltext_searchable,
  2193. phpcr_type_props.query_orderable AS property_query_orderable, phpcr_type_props.default_value as property_default_value,
  2194. phpcr_type_childs.name AS child_name, phpcr_type_childs.auto_created AS child_auto_created,
  2195. phpcr_type_childs.mandatory AS child_mandatory, phpcr_type_childs.protected AS child_protected,
  2196. phpcr_type_childs.on_parent_version AS child_on_parent_version, phpcr_type_childs.default_type AS child_default_type,
  2197. phpcr_type_childs.primary_types AS child_primary_types
  2198. FROM
  2199. phpcr_type_nodes
  2200. LEFT JOIN
  2201. phpcr_type_props ON phpcr_type_nodes.node_type_id = phpcr_type_props.node_type_id
  2202. LEFT JOIN
  2203. phpcr_type_childs ON phpcr_type_nodes.node_type_id = phpcr_type_childs.node_type_id
  2204. ';
  2206.         $statement = $this->getConnection()->prepare($query);
  2208.         $stmtResult = $statement->execute();
  2209.         $stmtResult = is_bool($stmtResult) ? $statement : $stmtResult;
  2211.         while ($row = $stmtResult->fetchAssociative()) {
  2212.             $nodeName = $row['node_name'];
  2214.             if (!isset($result[$nodeName])) {
  2215.                 $result[$nodeName] = [
  2216.                     'name' => $nodeName,
  2217.                     'isAbstract' => (bool)$row['node_abstract'],
  2218.                     'isMixin' => (bool)$row['node_mixin'],
  2219.                     'isQueryable' => (bool)$row['node_queryable'],
  2220.                     'hasOrderableChildNodes' => (bool)$row['node_has_orderable_child_nodes'],
  2221.                     'primaryItemName' => $row['node_primary_item_name'],
  2222.                     'declaredSuperTypeNames' => array_filter(explode(' ', $row['declared_super_type_names'])),
  2223.                     'declaredPropertyDefinitions' => [],
  2224.                     'declaredNodeDefinitions' => [],
  2225.                 ];
  2226.             }
  2228.             if (($propertyName = $row['property_name']) !== null) {
  2229.                 $result[$nodeName]['declaredPropertyDefinitions'][] = [
  2230.                     'declaringNodeType' => $nodeName,
  2231.                     'name' => $propertyName,
  2232.                     'isAutoCreated' => (bool)$row['property_auto_created'],
  2233.                     'isMandatory' => (bool)$row['property_mandatory'],
  2234.                     'isProtected' => (bool)$row['property_protected'],
  2235.                     'onParentVersion' => (bool)$row['property_on_parent_version'],
  2236.                     'requiredType' => (int)$row['property_required_type'],
  2237.                     'multiple' => (bool)$row['property_multiple'],
  2238.                     'isFulltextSearchable' => (bool)$row['property_fulltext_searchable'],
  2239.                     'isQueryOrderable' => (bool)$row['property_query_orderable'],
  2240.                     'queryOperators' => [
  2241.                         QOM::JCR_OPERATOR_EQUAL_TO,
  2242.                         QOM::JCR_OPERATOR_NOT_EQUAL_TO,
  2243.                         QOM::JCR_OPERATOR_GREATER_THAN,
  2244.                         QOM::JCR_OPERATOR_GREATER_THAN_OR_EQUAL_TO,
  2245.                         QOM::JCR_OPERATOR_LESS_THAN,
  2246.                         QOM::JCR_OPERATOR_LESS_THAN_OR_EQUAL_TO,
  2247.                         QOM::JCR_OPERATOR_LIKE,
  2248.                     ],
  2249.                     'defaultValues' => [$row['property_default_value']]
  2250.                 ];
  2251.             }
  2253.             if (($childName = $row['child_name']) !== null) {
  2254.                 $result[$nodeName]['declaredNodeDefinitions'][] = [
  2255.                     'declaringNodeType' => $nodeName,
  2256.                     'name' => $childName,
  2257.                     'isAutoCreated' => (bool)$row['child_auto_created'],
  2258.                     'isMandatory' => (bool)$row['child_mandatory'],
  2259.                     'isProtected' => (bool)$row['child_protected'],
  2260.                     'onParentVersion' => (bool)$row['child_on_parent_version'],
  2261.                     'allowsSameNameSiblings' => false,
  2262.                     'defaultPrimaryTypeName' => $row['child_default_type'],
  2263.                     'requiredPrimaryTypeNames' => array_filter(explode(' ', $row['child_primary_types']))
  2264.                 ];
  2265.             }
  2266.         }
  2268.         return $result;
  2269.     }
  2271.     /**
  2272.      * {@inheritDoc}
  2273.      */
  2274.     public function registerNodeTypes($types, $allowUpdate)
  2275.     {
  2276.         $builtinTypes = StandardNodeTypes::getNodeTypeData();
  2278.         /* @var $type NodeTypeDefinition */
  2279.         foreach ($types as $type) {
  2280.             if (isset($builtinTypes[$type->getName()])) {
  2281.                 throw new RepositoryException(sprintf('%s: can\'t reregister built-in node type.', $type->getName()));
  2282.             }
  2284.             $nodeTypeName = $type->getName();
  2286.             $query = "SELECT * FROM phpcr_type_nodes WHERE name = ?";
  2287.             $result = $this->getConnection()->fetchOne($query, [$nodeTypeName]);
  2289.             $data = [
  2290.                 'name' => $nodeTypeName,
  2291.                 'supertypes' => implode(' ', $type->getDeclaredSuperTypeNames()),
  2292.                 'is_abstract' => $type->isAbstract() ? 1 : 0,
  2293.                 'is_mixin' => $type->isMixin() ? 1 : 0,
  2294.                 'queryable' => $type->isQueryable() ? 1 : 0,
  2295.                 'orderable_child_nodes' => $type->hasOrderableChildNodes() ? 1 : 0,
  2296.                 'primary_item' => $type->getPrimaryItemName(),
  2297.             ];
  2299.             if ($result) {
  2300.                 if (!$allowUpdate) {
  2301.                     throw new NodeTypeExistsException("Could not register node type with the name '$nodeTypeName'.");
  2302.                 }
  2304.                 $this->getConnection()->update('phpcr_type_nodes', $data, ['node_type_id' => $result]);
  2305.                 $this->getConnection()->delete('phpcr_type_props', ['node_type_id' => $result]);
  2306.                 $this->getConnection()->delete('phpcr_type_childs', ['node_type_id' => $result]);
  2308.                 $nodeTypeId = $result;
  2309.             } else {
  2310.                 $this->getConnection()->insert('phpcr_type_nodes', $data);
  2312.                 $nodeTypeId = $this->getConnection()->lastInsertId($this->sequenceTypeName);
  2313.             }
  2315.             if ($propDefs = $type->getDeclaredPropertyDefinitions()) {
  2316.                 foreach ($propDefs as $propertyDef) {
  2317.                     /* @var $propertyDef PropertyDefinitionInterface */
  2318.                     $this->getConnection()->insert(
  2319.                         'phpcr_type_props',
  2320.                         [
  2321.                             'node_type_id' => $nodeTypeId,
  2322.                             'name' => $propertyDef->getName(),
  2323.                             'protected' => $propertyDef->isProtected() ? 1 : 0,
  2324.                             'mandatory' => $propertyDef->isMandatory() ? 1 : 0,
  2325.                             'auto_created' => $propertyDef->isAutoCreated() ? 1 : 0,
  2326.                             'on_parent_version' => $propertyDef->getOnParentVersion(),
  2327.                             'multiple' => $propertyDef->isMultiple() ? 1 : 0,
  2328.                             'fulltext_searchable' => $propertyDef->isFullTextSearchable() ? 1 : 0,
  2329.                             'query_orderable' => $propertyDef->isQueryOrderable() ? 1 : 0,
  2330.                             'required_type' => $propertyDef->getRequiredType(),
  2331.                             'query_operators' => 0, // transform to bitmask
  2332.                             'default_value' => $propertyDef->getDefaultValues() ? current(
  2333.                                 $propertyDef->getDefaultValues()
  2334.                             ) : null,
  2335.                         ]
  2336.                     );
  2337.                 }
  2338.             }
  2340.             if ($childDefs = $type->getDeclaredChildNodeDefinitions()) {
  2341.                 foreach ($childDefs as $childDef) {
  2342.                     /* @var $childDef NodeDefinitionInterface */
  2343.                     $this->getConnection()->insert(
  2344.                         'phpcr_type_childs',
  2345.                         [
  2346.                             'node_type_id' => $nodeTypeId,
  2347.                             'name' => $childDef->getName(),
  2348.                             'protected' => $childDef->isProtected() ? 1 : 0,
  2349.                             'mandatory' => $childDef->isMandatory() ? 1 : 0,
  2350.                             'auto_created' => $childDef->isAutoCreated() ? 1 : 0,
  2351.                             'on_parent_version' => $childDef->getOnParentVersion(),
  2352.                             'primary_types' => implode(' ', $childDef->getRequiredPrimaryTypeNames() ?: []),
  2353.                             'default_type' => $childDef->getDefaultPrimaryTypeName(),
  2354.                         ]
  2355.                     );
  2356.                 }
  2357.             }
  2358.         }
  2359.     }
  2361.     /**
  2362.      * {@inheritDoc}
  2363.      */
  2364.     public function setNodeTypeManager($nodeTypeManager)
  2365.     {
  2366.         $this->nodeTypeManager = $nodeTypeManager;
  2367.     }
  2369.     /**
  2370.      * {@inheritDoc}
  2371.      */
  2372.     public function cloneFrom($srcWorkspace, $srcAbsPath, $destAbsPath, $removeExisting)
  2373.     {
  2374.         throw new NotImplementedException('Cloning nodes is not implemented yet');
  2375.     }
  2377.     /**
  2378.      * {@inheritDoc}
  2379.      */
  2380.     public function updateNode(Node $node, $srcWorkspace)
  2381.     {
  2382.         throw new NotImplementedException('Updating nodes is not implemented yet');
  2383.     }
  2385.     /**
  2386.      * {@inheritDoc}
  2387.      * @throws RepositoryException when no binary data found
  2388.      */
  2389.     public function getBinaryStream($path)
  2390.     {
  2391.         $this->assertLoggedIn();
  2393.         $nodePath = PathHelper::getParentPath($path);
  2394.         $nodeId = $this->getSystemIdForNode($nodePath);
  2395.         $propertyName = PathHelper::getNodeName($path);
  2397.         $data = $this->getConnection()->fetchAllAssociative(
  2398.             'SELECT data, idx FROM phpcr_binarydata WHERE node_id = ? AND property_name = ? AND workspace_name = ?',
  2399.             [$nodeId, $propertyName, $this->workspaceName]
  2400.         );
  2402.         if (count($data) === 0) {
  2403.             throw new RepositoryException('No binary data found in stream');
  2404.         }
  2406.         $streams = [];
  2407.         foreach ($data as $row) {
  2408.             if (is_resource($row['data'])) {
  2409.                 $stream = $row['data'];
  2410.             } else {
  2411.                 $stream = fopen('php://memory', 'rwb+');
  2412.                 fwrite($stream, $row['data']);
  2413.                 rewind($stream);
  2414.             }
  2416.             $streams[] = $stream;
  2417.         }
  2419.         if (count($data) === 1) {
  2420.             // we don't know if this is a multivalue property or not.
  2421.             // TODO we should have something more efficient to know this. a flag in the database?
  2423.             // TODO use self::getProperty()->isMultiple() once implemented
  2424.             $node = $this->getNode($nodePath);
  2425.             if (!is_array($node->{':' . $propertyName})) {
  2426.                 return reset($streams);
  2427.             }
  2428.         }
  2430.         return $streams;
  2431.     }
  2433.     /**
  2434.      * {@inheritDoc}
  2435.      */
  2436.     public function getProperty($path)
  2437.     {
  2438.         throw new NotImplementedException('Getting properties by path is not implemented yet');
  2439.     }
  2441.     /**
  2442.      * {@inheritDoc}
  2443.      *
  2444.      * @throws InvalidQueryException
  2445.      */
  2446.     public function query(Query $query)
  2447.     {
  2448.         $this->assertLoggedIn();
  2450.         if (!$query instanceof QueryObjectModelInterface) {
  2451.             $parser = new Sql2ToQomQueryConverter($this->factory->get(QueryObjectModelFactory::class));
  2452.             try {
  2453.                 $qom = $parser->parse($query->getStatement());
  2454.                 $qom->setLimit($query->getLimit());
  2455.                 $qom->setOffset($query->getOffset());
  2456.             } catch (Exception $e) {
  2457.                 throw new InvalidQueryException('Invalid query: ' . $query->getStatement(), 0, $e);
  2458.             }
  2459.         } else {
  2460.             $qom = $query;
  2461.         }
  2463.         $qomWalker = new QOMWalker($this->nodeTypeManager, $this->getConnection(), $this->getNamespaces());
  2464.         [$selectors, $selectorAliases, $sql] = $qomWalker->walkQOMQuery($qom);
  2466.         $primarySource = reset($selectors);
  2467.         $primaryType = $primarySource->getSelectorName() ?: $primarySource->getNodeTypeName();
  2468.         $statement = $this->getConnection()->executeQuery($sql, [$this->workspaceName]);
  2470.         $results = $properties = $standardColumns = [];
  2471.         while ($row = $statement->fetchAssociative()) {
  2472.             $result = [];
  2474.             /** @var SelectorInterface $selector */
  2475.             foreach ($selectors as $selector) {
  2476.                 $selectorName = $selector->getSelectorName() ?: $selector->getNodeTypeName();
  2477.                 $columnPrefix = isset($selectorAliases[$selectorName]) ? $selectorAliases[$selectorName] . '_' : $selectorAliases[''] . '_';
  2479.                 if ($primaryType === $selector->getNodeTypeName()) {
  2480.                     $result[] = [
  2481.                         'dcr:name' => 'jcr:path',
  2482.                         'dcr:value' => $row[$columnPrefix . 'path'],
  2483.                         'dcr:selectorName' => $selectorName
  2484.                     ];
  2485.                 }
  2487.                 $result[] = [
  2488.                     'dcr:name' => 'jcr:path',
  2489.                     'dcr:value' => $row[$columnPrefix . 'path'],
  2490.                     'dcr:selectorName' => $selectorName
  2491.                 ];
  2492.                 $result[] = ['dcr:name' => 'jcr:score', 'dcr:value' => 0, 'dcr:selectorName' => $selectorName];
  2493.                 if (0 === count($qom->getColumns())) {
  2494.                     $selectorPrefix = null !== $selector->getSelectorName() ? $selectorName . '.' : '';
  2495.                     $result[] = [
  2496.                         'dcr:name' => $selectorPrefix . 'jcr:primaryType',
  2497.                         'dcr:value' => $primaryType,
  2498.                         'dcr:selectorName' => $selectorName
  2499.                     ];
  2500.                 }
  2502.                 if (isset($row[$columnPrefix . 'props'])) {
  2503.                     $propertyNames = [];
  2504.                     $columns = $qom->getColumns();
  2506.                     // Always populate jcr:created and jcr:createdBy if a wildcard selector is used.
  2507.                     // This emulates the behavior of Jackrabbit
  2508.                     if (0 === count($columns)) {
  2509.                         $propertyNames = ['jcr:created', 'jcr:createdBy'];
  2510.                     }
  2512.                     foreach ($columns as $column) {
  2513.                         if (!$column->getSelectorName() || $column->getSelectorName() == $selectorName) {
  2514.                             $propertyNames[] = $column->getPropertyName();
  2515.                         }
  2516.                     }
  2518.                     $properties[$selectorName] = (array)$this->xmlToColumns(
  2519.                         $row[$columnPrefix . 'props'],
  2520.                         $propertyNames
  2521.                     );
  2522.                 } else {
  2523.                     $properties[$selectorName] = [];
  2524.                 }
  2526.                 // TODO: add other default columns that Jackrabbit provides to provide a more consistent behavior
  2527.                 if (isset($properties[$selectorName]['jcr:createdBy'])) {
  2528.                     $standardColumns[$selectorName]['jcr:createdBy'] = $properties[$selectorName]['jcr:createdBy'];
  2529.                 }
  2531.                 if (isset($properties[$selectorName]['jcr:created'])) {
  2532.                     $standardColumns[$selectorName]['jcr:created'] = $properties[$selectorName]['jcr:created'];
  2533.                 }
  2534.             }
  2536.             $reservedNames = ['jcr:path', 'jcr:score'];
  2538.             foreach ($qom->getColumns() as $column) {
  2539.                 $selectorName = $column->getSelectorName();
  2540.                 $columnName = $column->getPropertyName();
  2541.                 $columnPrefix = isset($selectorAliases[$selectorName]) ? $selectorAliases[$selectorName] . '_' : $selectorAliases[''] . '_';
  2544.                 if (in_array($column->getColumnName(), $reservedNames)) {
  2545.                     throw new InvalidQueryException(
  2546.                         sprintf(
  2547.                             'Cannot reserved name "%s". Reserved names are "%s"',
  2548.                             $column->getColumnName(),
  2549.                             implode('", "', $reservedNames)
  2550.                         )
  2551.                     );
  2552.                 }
  2554.                 $dcrValue = 'jcr:uuid' === $columnName ? $row[$columnPrefix . 'identifier'] : (isset($properties[$selectorName][$columnName]) ? $properties[$selectorName][$columnName] : '');
  2556.                 if (isset($standardColumns[$selectorName][$columnName])) {
  2557.                     unset($standardColumns[$selectorName][$columnName]);
  2558.                 }
  2560.                 $result[] = [
  2561.                     'dcr:name' => $column->getColumnName(
  2562.                     ) === $columnName && isset($properties[$selectorName][$columnName]) ? $selectorName . '.' . $columnName : $column->getColumnName(
  2563.                     ),
  2564.                     'dcr:value' => $dcrValue,
  2565.                     'dcr:selectorName' => $selectorName ?: $primaryType,
  2566.                 ];
  2567.             }
  2569.             foreach ($standardColumns as $selectorName => $columns) {
  2570.                 foreach ($columns as $columnName => $value) {
  2571.                     $result[] = [
  2572.                         'dcr:name' => $primaryType . '.' . $columnName,
  2573.                         'dcr:value' => $value,
  2574.                         'dcr:selectorName' => $selectorName,
  2575.                     ];
  2576.                 }
  2577.             }
  2579.             $results[] = $result;
  2580.         }
  2582.         return $results;
  2583.     }
  2585.     /**
  2586.      * {@inheritDoc}
  2587.      */
  2588.     public function getSupportedQueryLanguages()
  2589.     {
  2590.         return [
  2591.             QueryInterface::JCR_SQL2,
  2592.             QueryInterface::JCR_JQOM,
  2593.             QueryInterface::SQL,
  2594.         ];
  2595.     }
  2597.     /**
  2598.      * We need to create an in memory backup when we are inside a transaction
  2599.      * so that we can efficiently restore the original state in the namespaces
  2600.      * property in case of a rollback.
  2601.      *
  2602.      * This method also ensures that namespaces are loaded to begin with.
  2603.      */
  2604.     private function ensureNamespacesBackup()
  2605.     {
  2606.         if (!$this->namespaces instanceof \ArrayObject) {
  2607.             $this->getNamespacesObject();
  2608.         }
  2610.         if (!$this->inTransaction) {
  2611.             return;
  2612.         }
  2614.         if (null === $this->originalNamespaces) {
  2615.             $this->originalNamespaces = $this->namespaces->getArrayCopy();
  2616.         }
  2617.     }
  2619.     /**
  2620.      * {@inheritDoc}
  2621.      *
  2622.      * @throws NamespaceException
  2623.      */
  2624.     public function registerNamespace($prefix, $uri)
  2625.     {
  2626.         if (isset($this->namespaces[$prefix])) {
  2627.             if ($this->namespaces[$prefix] === $uri) {
  2628.                 return;
  2629.             }
  2631.             if (isset($this->coreNamespaces[$prefix])) {
  2632.                 throw new NamespaceException(
  2633.                     "Cannot overwrite JCR core namespace prefix '$prefix' to a new uri '$uri'."
  2634.                 );
  2635.             }
  2636.         }
  2638.         $this->ensureNamespacesBackup();
  2640.         $this->getConnection()->delete('phpcr_namespaces', ['prefix' => $prefix]);
  2641.         $this->getConnection()->delete('phpcr_namespaces', ['uri' => $uri]);
  2643.         $this->getConnection()->insert(
  2644.             'phpcr_namespaces',
  2645.             [
  2646.                 'prefix' => $prefix,
  2647.                 'uri' => $uri,
  2648.             ]
  2649.         );
  2651.         if (!empty($this->namespaces)) {
  2652.             $this->namespaces[$prefix] = $uri;
  2653.         }
  2654.     }
  2656.     /**
  2657.      * {@inheritDoc}
  2658.      */
  2659.     public function unregisterNamespace($prefix)
  2660.     {
  2661.         if (isset($this->coreNamespaces[$prefix])) {
  2662.             throw new NamespaceException("Cannot unregister JCR core namespace prefix '$prefix'.");
  2663.         }
  2665.         $this->ensureNamespacesBackup();
  2667.         $this->getConnection()->delete('phpcr_namespaces', ['prefix' => $prefix]);
  2669.         if (!empty($this->namespaces)) {
  2670.             unset($this->namespaces[$prefix]);
  2671.         }
  2672.     }
  2674.     /**
  2675.      * {@inheritDoc}
  2676.      */
  2677.     public function getReferences($path, $name = null)
  2678.     {
  2679.         return $this->getNodeReferences($path, $name, false);
  2680.     }
  2682.     /**
  2683.      * {@inheritDoc}
  2684.      */
  2685.     public function getWeakReferences($path, $name = null)
  2686.     {
  2687.         return $this->getNodeReferences($path, $name, true);
  2688.     }
  2690.     /**
  2691.      * @param string $path the path for which we need the references
  2692.      * @param string $name the name of the referencing properties or null for all
  2693.      * @param boolean $weakReference whether to get weak or strong references
  2694.      *
  2695.      * @return array list of paths to nodes that reference $path
  2696.      */
  2697.     private function getNodeReferences($path, $name = null, $weakReference = false)
  2698.     {
  2699.         $targetId = $this->getSystemIdForNode($path);
  2701.         if (false === $targetId) {
  2702.             return [];
  2703.         }
  2705.         $params = [$targetId];
  2707.         $table = $weakReference ? $this->referenceTables[PropertyType::WEAKREFERENCE] : $this->referenceTables[PropertyType::REFERENCE];
  2708.         $query = "SELECT CONCAT(n.path, '/', r.source_property_name) FROM phpcr_nodes n
  2709.                INNER JOIN $table r ON n.id = r.source_id
  2710.                WHERE r.target_id = ?";
  2711.         if (null !== $name) {
  2712.             $query .= " AND source_property_name = ?";
  2713.             $params[] = $name;
  2714.         }
  2716.         $stmt = $this->getConnection()->executeQuery($query, $params);
  2718.         return array_column($stmt->fetchAllNumeric(), 0);
  2719.     }
  2721.     /**
  2722.      * {@inheritDoc}
  2723.      */
  2724.     public function beginTransaction()
  2725.     {
  2726.         if ($this->inTransaction) {
  2727.             throw new RepositoryException('Begin transaction failed: transaction already open');
  2728.         }
  2730.         $this->assertLoggedIn();
  2732.         try {
  2733.             $this->getConnection()->beginTransaction();
  2734.             $this->inTransaction = true;
  2735.         } catch (Exception $e) {
  2736.             throw new RepositoryException('Begin transaction failed: ' . $e->getMessage());
  2737.         }
  2738.     }
  2740.     /**
  2741.      * {@inheritDoc}
  2742.      *
  2743.      * @throws RepositoryException
  2744.      */
  2745.     public function commitTransaction()
  2746.     {
  2747.         if (!$this->inTransaction) {
  2748.             throw new RepositoryException('Commit transaction failed: no transaction open');
  2749.         }
  2751.         $this->assertLoggedIn();
  2753.         try {
  2754.             $this->inTransaction = false;
  2756.             $this->getConnection()->commit();
  2758.             if ($this->originalNamespaces) {
  2759.                 // now that the transaction is committed, reset the cache of the stored namespaces.
  2760.                 $this->originalNamespaces = null;
  2761.             }
  2762.         } catch (Exception $e) {
  2763.             throw new RepositoryException('Commit transaction failed: ' . $e->getMessage());
  2764.         }
  2765.     }
  2767.     /**
  2768.      * {@inheritDoc}
  2769.      *
  2770.      * @throws RepositoryException
  2771.      */
  2772.     public function rollbackTransaction()
  2773.     {
  2774.         if (!$this->inTransaction) {
  2775.             throw new RepositoryException('Rollback transaction failed: no transaction open');
  2776.         }
  2778.         $this->assertLoggedIn();
  2780.         try {
  2781.             $this->inTransaction = false;
  2783.             $this->getConnection()->rollBack();
  2785.             if ($this->originalNamespaces) {
  2786.                 // reset namespaces
  2787.                 $this->setNamespaces($this->originalNamespaces);
  2788.                 $this->originalNamespaces = null;
  2789.             }
  2790.         } catch (Exception $e) {
  2791.             throw new RepositoryException('Rollback transaction failed: ' . $e->getMessage(), 0, $e);
  2792.         }
  2793.     }
  2795.     /**
  2796.      * Sets the default transaction timeout
  2797.      *
  2798.      * @param int $seconds The value of the timeout in seconds
  2799.      */
  2800.     public function setTransactionTimeout($seconds)
  2801.     {
  2802.         $this->assertLoggedIn();
  2804.         throw new NotImplementedException("Setting a transaction timeout is not yet implemented");
  2805.     }
  2807.     /**
  2808.      * {@inheritDoc}
  2809.      */
  2810.     public function prepareSave()
  2811.     {
  2812.         $this->getConnection()->beginTransaction();
  2813.     }
  2815.     /**
  2816.      * {@inheritDoc}
  2817.      */
  2818.     public function finishSave()
  2819.     {
  2820.         $this->syncReferences($this->referencesToUpdate);
  2821.         $this->referencesToUpdate = $this->referencesToDelete = [];
  2822.         $this->getConnection()->commit();
  2823.     }
  2825.     /**
  2826.      * {@inheritDoc}
  2827.      */
  2828.     public function rollbackSave()
  2829.     {
  2830.         $this->referencesToUpdate = $this->referencesToDelete = [];
  2831.         $this->getConnection()->rollBack();
  2832.     }
  2834.     /**
  2835.      *
  2836.      * @param Node $node the node to update
  2837.      */
  2838.     public function updateProperties(Node $node)
  2839.     {
  2840.         $this->assertLoggedIn();
  2841.         // we can ignore the operations returned, there will be no additions because of property updates
  2842.         $this->getNodeProcessor()->process($node);
  2844.         $this->syncNode(
  2845.             $node->getIdentifier(),
  2846.             $node->getPath(),
  2847.             $node->getPrimaryNodeType(),
  2848.             false,
  2849.             $node->getProperties()
  2850.         );
  2852.         return true;
  2853.     }
  2855.     /**
  2856.      * Initialize the dbal connection lazily
  2857.      */
  2858.     private function initConnection()
  2859.     {
  2860.         if (true === $this->conn->isConnected() && true === $this->connectionInitialized) {
  2861.             return;
  2862.         }
  2864.         $platform = $this->conn->getDatabasePlatform();
  2865.         if ($platform instanceof PostgreSQL94Platform || $platform instanceof PostgreSqlPlatform) {
  2866.             $this->sequenceNodeName = 'phpcr_nodes_id_seq';
  2867.             $this->sequenceTypeName = 'phpcr_type_nodes_node_type_id_seq';
  2868.         }
  2870.         // @TODO: move to "SqlitePlatform" and rename to "registerExtraFunctions"?
  2871.         if ($this->conn->getDatabasePlatform() instanceof SqlitePlatform) {
  2872.             if (method_exists($this->conn, 'getNativeConnection')) {
  2873.                 $connection = $this->conn->getNativeConnection();
  2874.             } else {
  2875.                 $connection = $this->conn->getWrappedConnection();
  2876.                 if ($connection instanceof PDOConnection && !$connection instanceof PDO) {
  2877.                     $connection = $connection->getWrappedConnection();
  2878.                 }
  2879.             }
  2881.             $this->registerSqliteFunctions($connection);
  2882.         }
  2884.         $this->connectionInitialized = true;
  2885.     }
  2886. }