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

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\DoctrineDBAL\XmlPropsRemover\XmlPropsRemover;
  35. use Jackalope\Transport\MoveNodeOperation;
  36. use Jackalope\Transport\NodeTypeManagementInterface;
  37. use Jackalope\Transport\QueryInterface as QueryTransport;
  38. use Jackalope\Transport\StandardNodeTypes;
  39. use Jackalope\Transport\TransactionInterface;
  40. use Jackalope\Transport\WorkspaceManagementInterface;
  41. use Jackalope\Transport\WritingInterface;
  42. use PDO;
  43. use PHPCR\AccessDeniedException;
  44. use PHPCR\CredentialsInterface;
  45. use PHPCR\ItemExistsException;
  46. use PHPCR\ItemNotFoundException;
  47. use PHPCR\LoginException;
  48. use PHPCR\NamespaceException;
  49. use PHPCR\NamespaceRegistryInterface as NS;
  50. use PHPCR\NodeType\ConstraintViolationException;
  51. use PHPCR\NodeType\NodeDefinitionInterface;
  52. use PHPCR\NodeType\NodeTypeExistsException;
  53. use PHPCR\NodeType\NoSuchNodeTypeException;
  54. use PHPCR\NodeType\PropertyDefinitionInterface;
  55. use PHPCR\NoSuchWorkspaceException;
  56. use PHPCR\PathNotFoundException;
  57. use PHPCR\PropertyType;
  58. use PHPCR\Query\InvalidQueryException;
  59. use PHPCR\Query\QOM\QueryObjectModelConstantsInterface as QOM;
  60. use PHPCR\Query\QOM\QueryObjectModelInterface;
  61. use PHPCR\Query\QOM\SelectorInterface;
  62. use PHPCR\Query\QueryInterface;
  63. use PHPCR\ReferentialIntegrityException;
  64. use PHPCR\RepositoryException;
  65. use PHPCR\RepositoryInterface;
  66. use PHPCR\SimpleCredentials;
  67. use PHPCR\UnsupportedRepositoryOperationException;
  68. use PHPCR\Util\PathHelper;
  69. use PHPCR\Util\QOM\Sql2ToQomQueryConverter;
  70. use PHPCR\Util\UUIDHelper;
  71. use PHPCR\Util\ValueConverter;
  72. use stdClass;
  74. /**
  75.  * Class to handle the communication between Jackalope and RDBMS via Doctrine DBAL.
  76.  *
  77.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  78.  * @license http://opensource.org/licenses/MIT MIT License
  79.  *
  80.  * @author Benjamin Eberlei <kontakt@beberlei.de>
  81.  * @author Lukas Kahwe Smith <smith@pooteeweet.org>
  82.  */
  83. class Client extends BaseTransport implements QueryTransport, WritingInterface, WorkspaceManagementInterface, NodeTypeManagementInterface, TransactionInterface
  84. {
  85.     /**
  86.      * SQlite can only handle a maximum of 999 parameters inside an IN statement
  87.      * see https://github.com/jackalope/jackalope-doctrine-dbal/pull/149/files#diff-a3a0165ed79ca1ba3513ec5ecd59ec56R707
  88.      */
  89.     const SQLITE_MAXIMUM_IN_PARAM_COUNT = 999;
  91.     /**
  92.      * The factory to instantiate objects
  93.      *
  94.      * @var FactoryInterface
  95.      */
  96.     protected $factory;
  98.     /**
  99.      * @var ValueConverter
  100.      */
  101.     protected $valueConverter;
  103.     /**
  104.      * @var Connection
  105.      */
  106.     private $conn;
  108.     /**
  109.      * @var Closure
  110.      */
  111.     private $uuidGenerator;
  113.     /**
  114.      * @var bool
  115.      */
  116.     private $loggedIn = false;
  118.     /**
  119.      * @var SimpleCredentials
  120.      */
  121.     private $credentials;
  123.     /**
  124.      * @var string
  125.      */
  126.     protected $workspaceName;
  128.     /**
  129.      * @var array
  130.      */
  131.     private $nodeIdentifiers = [];
  133.     /**
  134.      * @var NodeTypeManager
  135.      */
  136.     private $nodeTypeManager;
  138.     /**
  139.      * @var bool
  140.      */
  141.     protected $inTransaction = false;
  143.     /**
  144.      * Check if an initial request on login should be send to check if repository exists
  145.      * This is according to the JCR specifications and set to true by default
  146.      *
  147.      * @see setCheckLoginOnServer
  148.      *
  149.      * @var bool
  150.      */
  151.     private $checkLoginOnServer = true;
  153.     /**
  154.      * Using an ArrayObject here so that we can pass this into the NodeProcessor by reference more elegantly
  155.      *
  156.      * @var null|ArrayObject
  157.      */
  158.     protected $namespaces;
  160.     /**
  161.      * @var null|array The namespaces at initial state when making changes to the namespaces, in case of rollback.
  162.      */
  163.     private $originalNamespaces;
  165.     /**
  166.      * The core namespaces defined in JCR
  167.      *
  168.      * @var array
  169.      */
  170.     private $coreNamespaces = [
  171.         NS::PREFIX_EMPTY => NS::NAMESPACE_EMPTY,
  172.         NS::PREFIX_JCR => NS::NAMESPACE_JCR,
  173.         NS::PREFIX_NT => NS::NAMESPACE_NT,
  174.         NS::PREFIX_MIX => NS::NAMESPACE_MIX,
  175.         NS::PREFIX_XML => NS::NAMESPACE_XML,
  176.         NS::PREFIX_SV => NS::NAMESPACE_SV,
  177.     ];
  179.     /**
  180.      * @var string|null
  181.      */
  182.     private $sequenceNodeName;
  184.     /**
  185.      * @var string|null
  186.      */
  187.     private $sequenceTypeName;
  189.     /**
  190.      * @var array
  191.      */
  192.     private $referencesToUpdate = [];
  194.     /**
  195.      * @var array
  196.      */
  197.     private $referenceTables = [
  198.         PropertyType::REFERENCE => 'phpcr_nodes_references',
  199.         PropertyType::WEAKREFERENCE => 'phpcr_nodes_weakreferences',
  200.     ];
  202.     /**
  203.      * @var array
  204.      */
  205.     private $referencesToDelete = [];
  207.     /**
  208.      * @var boolean
  209.      */
  210.     private $connectionInitialized = false;
  212.     /**
  213.      * @var NodeProcessor
  214.      */
  215.     private $nodeProcessor;
  217.     /**
  218.      * @var string
  219.      */
  220.     private $caseSensitiveEncoding = null;
  222.     /**
  223.      * @param FactoryInterface $factory
  224.      * @param Connection $conn
  225.      */
  226.     public function __construct(FactoryInterface $factory, Connection $conn)
  227.     {
  228.         $this->factory = $factory;
  229.         $this->valueConverter = $this->factory->get(ValueConverter::class);
  230.         $this->conn = $conn;
  231.     }
  233.     /**
  234.      * @TODO: move to "SqlitePlatform" and rename to "registerExtraFunctions"?
  235.      */
  236.     private function registerSqliteFunctions(PDO $sqliteConnection): void
  237.     {
  238.         $sqliteConnection->sqliteCreateFunction(
  239.             'EXTRACTVALUE',
  240.             function ($string, $expression) {
  241.                 if (null === $string) {
  242.                     return null;
  243.                 }
  245.                 $dom = new DOMDocument('1.0', 'UTF-8');
  246.                 $dom->loadXML($string);
  247.                 $xpath = new DOMXPath($dom);
  248.                 $list = $xpath->evaluate($expression);
  250.                 if (!is_object($list)) {
  251.                     return $list;
  252.                 }
  254.                 // @TODO: don't know if there are expressions returning more then one row
  255.                 if ($list->length > 0) {
  256.                     // @TODO: why it can happen that we do not have a type? https://github.com/phpcr/phpcr-api-tests/pull/132
  257.                     $type = is_object($list->item(0)->parentNode->attributes->getNamedItem('type')) ? $list->item(
  258.                         0
  259.                     )->parentNode->attributes->getNamedItem('type')->value : null;
  260.                     $content = $list->item(0)->textContent;
  262.                     switch ($type) {
  263.                         case 'long':
  264.                             return (int)$content;
  266.                         case 'double':
  267.                             return (double)$content;
  269.                         default:
  270.                             return $content;
  271.                     }
  272.                 }
  274.                 // @TODO: don't know if return value is right
  275.                 return null;
  276.             },
  277.             2
  278.         );
  280.         $sqliteConnection->sqliteCreateFunction(
  281.             'CONCAT',
  282.             function () {
  283.                 return implode('', func_get_args());
  284.             }
  285.         );
  286.     }
  288.     /**
  289.      * @return Connection
  290.      */
  291.     public function getConnection()
  292.     {
  293.         $this->initConnection();
  295.         return $this->conn;
  296.     }
  298.     /**
  299.      * Set the UUID generator to use. If not set, the phpcr-utils UUIDHelper
  300.      * will be used.
  301.      *
  302.      * @param Closure $generator
  303.      */
  304.     public function setUuidGenerator(Closure $generator)
  305.     {
  306.         $this->uuidGenerator = $generator;
  307.     }
  309.     /**
  310.      * @return callable a uuid generator function.
  311.      */
  312.     protected function getUuidGenerator()
  313.     {
  314.         if (!$this->uuidGenerator) {
  315.             $this->uuidGenerator = function () {
  316.                 return UUIDHelper::generateUUID();
  317.             };
  318.         }
  320.         return $this->uuidGenerator;
  321.     }
  323.     /**
  324.      * @return string a universally unique id.
  325.      */
  326.     protected function generateUuid()
  327.     {
  328.         // php 5.3 compatibility, no direct execution of this function.
  329.         $g = $this->getUuidGenerator();
  331.         return $g();
  332.     }
  334.     /**
  335.      * {@inheritDoc}
  336.      *
  337.      * @throws NotImplementedException
  338.      */
  339.     public function createWorkspace($name, $srcWorkspace = null)
  340.     {
  341.         if (null !== $srcWorkspace) {
  342.             throw new NotImplementedException('Creating workspace as clone of existing workspace not supported');
  343.         }
  345.         if ($this->workspaceExists($name)) {
  346.             throw new RepositoryException("Workspace '$name' already exists");
  347.         }
  349.         try {
  350.             $this->getConnection()->insert('phpcr_workspaces', ['name' => $name]);
  351.         } catch (Exception $e) {
  352.             throw new RepositoryException("Couldn't create Workspace '$name': " . $e->getMessage(), 0, $e);
  353.         }
  355.         $this->getConnection()->insert(
  356.             'phpcr_nodes',
  357.             [
  358.                 'path' => '/',
  359.                 'parent' => '',
  360.                 'workspace_name' => $name,
  361.                 'identifier' => $this->generateUuid(),
  362.                 'type' => 'nt:unstructured',
  363.                 'local_name' => '',
  364.                 'namespace' => '',
  365.                 'props' => '<?xml version="1.0" encoding="UTF-8"?>
  366. <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" />',
  367.                 // TODO compute proper value
  368.                 'depth' => 0,
  369.             ]
  370.         );
  371.     }
  373.     /**
  374.      * {@inheritDoc}
  375.      */
  376.     public function deleteWorkspace($name)
  377.     {
  378.         if (!$this->workspaceExists($name)) {
  379.             throw new RepositoryException("Workspace '$name' cannot be deleted as it does not exist");
  380.         }
  382.         try {
  383.             $this->getConnection()->delete('phpcr_workspaces', ['name' => $name]);
  384.         } catch (Exception $e) {
  385.             throw new RepositoryException("Couldn't delete workspace '$name': " . $e->getMessage(), 0, $e);
  386.         }
  388.         try {
  389.             $this->getConnection()->delete('phpcr_nodes', ['workspace_name' => $name]);
  390.         } catch (Exception $e) {
  391.             throw new RepositoryException("Couldn't delete nodes in workspace '$name': " . $e->getMessage(), 0, $e);
  392.         }
  394.         try {
  395.             $this->getConnection()->delete('phpcr_binarydata', ['workspace_name' => $name]);
  396.         } catch (Exception $e) {
  397.             throw new RepositoryException(
  398.                 "Couldn't delete binary data in workspace '$name': " . $e->getMessage(),
  399.                 0,
  400.                 $e
  401.             );
  402.         }
  403.     }
  405.     /**
  406.      * {@inheritDoc}
  407.      *
  408.      * @throws NotImplementedException
  409.      * @throws AccessDeniedException
  410.      * @throws UnsupportedRepositoryOperationException
  411.      */
  412.     public function login(CredentialsInterface $credentials = null, $workspaceName = null)
  413.     {
  414.         $this->credentials = $credentials;
  416.         $this->workspaceName = $workspaceName ?: 'default';
  418.         if (!$this->checkLoginOnServer) {
  419.             return $this->workspaceName;
  420.         }
  422.         if (!$this->workspaceExists($this->workspaceName)) {
  423.             if ('default' !== $this->workspaceName) {
  424.                 throw new NoSuchWorkspaceException("Requested workspace: '{$this->workspaceName}'");
  425.             }
  427.             // Create default workspace if it not exists
  428.             $this->createWorkspace($this->workspaceName);
  429.         }
  431.         $this->loggedIn = true;
  433.         return $this->workspaceName;
  434.     }
  436.     /**
  437.      * {@inheritDoc}
  438.      */
  439.     public function logout()
  440.     {
  441.         if ($this->loggedIn) {
  442.             $this->loggedIn = false;
  443.             $this->conn->close();
  444.             $this->conn = null;
  445.         }
  446.     }
  448.     /**
  449.      * Configure whether to check if we are logged in before doing a request.
  450.      *
  451.      * Will improve error reporting at the cost of some round trips.
  452.      */
  453.     public function setCheckLoginOnServer($bool)
  454.     {
  455.         $this->checkLoginOnServer = $bool;
  456.     }
  458.     /**
  459.      * This will control the collate which is being used on MySQL when querying nodes. It will be autodetected by just
  460.      * appending _bin to the current charset, which is good enough in most cases.
  461.      *
  462.      * @param string $encoding
  463.      */
  464.     public function setCaseSensitiveEncoding($encoding)
  465.     {
  466.         $this->caseSensitiveEncoding = $encoding;
  467.     }
  469.     /**
  470.      * Returns the collate which is being used on MySQL when querying nodes.
  471.      *
  472.      * @return string
  473.      */
  474.     private function getCaseSensitiveEncoding()
  475.     {
  476.         if (null !== $this->caseSensitiveEncoding) {
  477.             return $this->caseSensitiveEncoding;
  478.         }
  480.         $params = $this->conn->getParams();
  481.         $charset = $params['charset'] ?? 'utf8';
  482.         if (isset($params['defaultTableOptions']['collate'])) {
  483.             return $this->caseSensitiveEncoding = $params['defaultTableOptions']['collate'];
  484.         }
  486.         return $this->caseSensitiveEncoding = $charset === 'binary' ? $charset : $charset . '_bin';
  487.     }
  489.     protected function workspaceExists($workspaceName)
  490.     {
  491.         try {
  492.             $query = 'SELECT 1 FROM phpcr_workspaces WHERE name = ?';
  493.             $result = $this->getConnection()->fetchFirstColumn($query, [$workspaceName]);
  494.         } catch (Exception $e) {
  495.             if ($e instanceof DBALException) {
  496.                 if (1045 === $e->getCode()) {
  497.                     throw new LoginException('Access denied with your credentials: ' . $e->getMessage());
  498.                 }
  499.                 if ('42S02' === $e->getCode()) {
  500.                     throw new RepositoryException(
  501.                         'You did not properly set up the database for the repository. See README.md for more information. Message from backend: ' . $e->getMessage(
  502.                         )
  503.                     );
  504.                 }
  506.                 throw new RepositoryException('Unexpected error talking to the backend: ' . $e->getMessage(), 0, $e);
  507.             }
  509.             throw $e;
  510.         }
  512.         return $result;
  513.     }
  515.     /**
  516.      * Ensure that we are currently logged in, executing the login in case we
  517.      * did lazy login.
  518.      *
  519.      * @throws NotImplementedException
  520.      * @throws AccessDeniedException
  521.      * @throws LoginException
  522.      * @throws NoSuchWorkspaceException
  523.      * @throws UnsupportedRepositoryOperationException
  524.      * @throws RepositoryException if this transport is not logged in.
  525.      */
  526.     protected function assertLoggedIn()
  527.     {
  528.         if (!$this->loggedIn) {
  529.             if (!$this->checkLoginOnServer && $this->workspaceName) {
  530.                 $this->checkLoginOnServer = true;
  531.                 if ($this->login($this->credentials, $this->workspaceName)) {
  532.                     return;
  533.                 }
  534.             }
  536.             throw new RepositoryException('You need to be logged in for this operation');
  537.         }
  538.     }
  540.     /**
  541.      * {@inheritDoc}
  542.      */
  543.     public function getRepositoryDescriptors()
  544.     {
  545.         return [
  546.             RepositoryInterface::IDENTIFIER_STABILITY => RepositoryInterface::IDENTIFIER_STABILITY_INDEFINITE_DURATION,
  547.             RepositoryInterface::REP_NAME_DESC => 'jackalope_doctrine_dbal',
  548.             RepositoryInterface::REP_VENDOR_DESC => 'Jackalope Community',
  549.             RepositoryInterface::REP_VENDOR_URL_DESC => 'http://github.com/jackalope',
  550.             RepositoryInterface::REP_VERSION_DESC => '1.1.0-DEV',
  551.             RepositoryInterface::SPEC_NAME_DESC => 'Content Repository for PHP',
  552.             RepositoryInterface::SPEC_VERSION_DESC => '2.1',
  553.             RepositoryInterface::NODE_TYPE_MANAGEMENT_AUTOCREATED_DEFINITIONS_SUPPORTED => true,
  554.             RepositoryInterface::NODE_TYPE_MANAGEMENT_INHERITANCE => RepositoryInterface::NODE_TYPE_MANAGEMENT_INHERITANCE_SINGLE,
  555.             RepositoryInterface::NODE_TYPE_MANAGEMENT_MULTIPLE_BINARY_PROPERTIES_SUPPORTED => true,
  556.             RepositoryInterface::NODE_TYPE_MANAGEMENT_MULTIVALUED_PROPERTIES_SUPPORTED => true,
  557.             RepositoryInterface::NODE_TYPE_MANAGEMENT_ORDERABLE_CHILD_NODES_SUPPORTED => true,
  558.             RepositoryInterface::NODE_TYPE_MANAGEMENT_OVERRIDES_SUPPORTED => false,
  559.             RepositoryInterface::NODE_TYPE_MANAGEMENT_PRIMARY_ITEM_NAME_SUPPORTED => true,
  560.             RepositoryInterface::NODE_TYPE_MANAGEMENT_PROPERTY_TYPES => true,
  561.             RepositoryInterface::NODE_TYPE_MANAGEMENT_RESIDUAL_DEFINITIONS_SUPPORTED => false,
  562.             RepositoryInterface::NODE_TYPE_MANAGEMENT_SAME_NAME_SIBLINGS_SUPPORTED => false,
  563.             RepositoryInterface::NODE_TYPE_MANAGEMENT_UPDATE_IN_USE_SUPPORTED => false,
  564.             RepositoryInterface::NODE_TYPE_MANAGEMENT_VALUE_CONSTRAINTS_SUPPORTED => false,
  565.             RepositoryInterface::OPTION_ACCESS_CONTROL_SUPPORTED => false,
  566.             RepositoryInterface::OPTION_ACTIVITIES_SUPPORTED => false,
  567.             RepositoryInterface::OPTION_BASELINES_SUPPORTED => false,
  568.             RepositoryInterface::OPTION_JOURNALED_OBSERVATION_SUPPORTED => false,
  569.             RepositoryInterface::OPTION_LIFECYCLE_SUPPORTED => false,
  570.             RepositoryInterface::OPTION_LOCKING_SUPPORTED => false,
  571.             RepositoryInterface::OPTION_NODE_AND_PROPERTY_WITH_SAME_NAME_SUPPORTED => true,
  572.             RepositoryInterface::OPTION_NODE_TYPE_MANAGEMENT_SUPPORTED => true,
  573.             RepositoryInterface::OPTION_OBSERVATION_SUPPORTED => false,
  574.             RepositoryInterface::OPTION_RETENTION_SUPPORTED => false,
  575.             RepositoryInterface::OPTION_SHAREABLE_NODES_SUPPORTED => false,
  576.             RepositoryInterface::OPTION_SIMPLE_VERSIONING_SUPPORTED => false,
  577.             RepositoryInterface::OPTION_TRANSACTIONS_SUPPORTED => true,
  578.             RepositoryInterface::OPTION_UNFILED_CONTENT_SUPPORTED => true,
  579.             RepositoryInterface::OPTION_UPDATE_MIXIN_NODETYPES_SUPPORTED => true,
  580.             RepositoryInterface::OPTION_UPDATE_PRIMARY_NODETYPE_SUPPORTED => true,
  581.             RepositoryInterface::OPTION_VERSIONING_SUPPORTED => false,
  582.             RepositoryInterface::OPTION_WORKSPACE_MANAGEMENT_SUPPORTED => true,
  583.             RepositoryInterface::OPTION_XML_EXPORT_SUPPORTED => true,
  584.             RepositoryInterface::OPTION_XML_IMPORT_SUPPORTED => true,
  585.             RepositoryInterface::QUERY_FULL_TEXT_SEARCH_SUPPORTED => true,
  586.             RepositoryInterface::QUERY_CANCEL_SUPPORTED => false,
  587.             RepositoryInterface::QUERY_JOINS => RepositoryInterface::QUERY_JOINS_NONE,
  588.             RepositoryInterface::QUERY_LANGUAGES => [QueryInterface::JCR_SQL2, QueryInterface::JCR_JQOM],
  589.             RepositoryInterface::QUERY_STORED_QUERIES_SUPPORTED => false,
  590.             RepositoryInterface::WRITE_SUPPORTED => true,
  591.         ];
  592.     }
  594.     /**
  595.      * Get the registered namespace prefixes
  596.      *
  597.      * @return array
  598.      */
  599.     private function getNamespacePrefixes()
  600.     {
  601.         return array_keys($this->getNamespaces());
  602.     }
  604.     /**
  605.      * {@inheritDoc}
  606.      */
  607.     public function getNamespaces()
  608.     {
  609.         return (array)$this->getNamespacesObject();
  610.     }
  612.     /**
  613.      * Return the namespaces of the current session as a referenceable ArrayObject.
  614.      *
  615.      * @return ArrayObject
  616.      */
  617.     protected function getNamespacesObject()
  618.     {
  619.         if (null === $this->namespaces) {
  620.             $query = 'SELECT prefix, uri FROM phpcr_namespaces';
  621.             $result = $this->getConnection()->executeQuery($query);
  622.             $columns = $result->fetchAllNumeric();
  624.             $namespaces = array_column($columns, 1, 0);
  625.             $namespaces += $this->coreNamespaces;
  627.             $this->setNamespaces($namespaces);
  628.         }
  630.         return $this->namespaces;
  631.     }
  633.     /**
  634.      * Set the namespaces property to an \ArrayObject instance
  635.      *
  636.      * @param array|ArrayObject $namespaces
  637.      */
  638.     protected function setNamespaces($namespaces)
  639.     {
  640.         if ($this->namespaces instanceof ArrayObject) {
  641.             $this->namespaces->exchangeArray($namespaces);
  642.         } else {
  643.             $this->namespaces = new ArrayObject($namespaces);
  644.         }
  645.     }
  647.     /**
  648.      * Executes an UPDATE on DBAL while ensuring that we never try to send more than 999 parameters to SQLite
  649.      *
  650.      * @param $query
  651.      * @param array $params
  652.      *
  653.      * @throws DBALException
  654.      */
  655.     private function executeChunkedUpdate($query, array $params)
  656.     {
  657.         $types = [Connection::PARAM_INT_ARRAY];
  659.         if ($this->getConnection()->getDatabasePlatform() instanceof SqlitePlatform) {
  660.             foreach (array_chunk($params, self::SQLITE_MAXIMUM_IN_PARAM_COUNT) as $chunk) {
  661.                 $this->getConnection()->executeUpdate($query, [$chunk], $types);
  662.             }
  663.         } else {
  664.             $this->getConnection()->executeUpdate($query, [$params], $types);
  665.         }
  666.     }
  668.     /**
  669.      * {@inheritDoc}
  670.      *
  671.      * @throws NoSuchWorkspaceException
  672.      * @throws RepositoryException
  673.      * @throws PathNotFoundException
  674.      * @throws ItemExistsException
  675.      * @throws DBALException
  676.      * @throws InvalidArgumentException
  677.      */
  678.     public function copyNode($srcAbsPath, $dstAbsPath, $srcWorkspace = null)
  679.     {
  680.         $this->assertLoggedIn();
  682.         if (null !== $srcWorkspace && !$this->workspaceExists($srcWorkspace)) {
  683.             throw new NoSuchWorkspaceException("Source workspace '$srcWorkspace' does not exist.");
  684.         }
  685.         $srcWorkspace = $srcWorkspace ?: $this->workspaceName;
  687.         PathHelper::assertValidAbsolutePath($dstAbsPath, true, true, $this->getNamespacePrefixes());
  689.         $srcNodeId = $this->getSystemIdForNode($srcAbsPath, $srcWorkspace);
  690.         if (!$srcNodeId) {
  691.             throw new PathNotFoundException("Source path '$srcAbsPath' not found");
  692.         }
  694.         if ($this->getSystemIdForNode($dstAbsPath)) {
  695.             throw new ItemExistsException("Cannot copy to destination path '$dstAbsPath' that already exists.");
  696.         }
  698.         if (!$this->getSystemIdForNode(PathHelper::getParentPath($dstAbsPath))) {
  699.             throw new PathNotFoundException("Parent of the destination path '" . $dstAbsPath . "' has to exist.");
  700.         }
  702.         // Algorithm:
  703.         // 1. Select all nodes with path $srcAbsPath."%" and iterate them
  704.         // 2. create a new node with path $dstAbsPath + leftovers, with a new uuid. Save old => new uuid
  705.         // 3. copy all properties from old node to new node
  706.         // 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.
  707.         // 5. "May drop mixin types"
  709.         $query = 'SELECT * FROM phpcr_nodes WHERE (path = ? OR path LIKE ?) AND workspace_name = ? ORDER BY depth, sort_order';
  710.         $stmt = $this->getConnection()->executeQuery($query, [$srcAbsPath, $srcAbsPath . '/%', $srcWorkspace]);
  711.         $rows = $stmt->fetchAllAssociative();
  713.         $uuidMap = [];
  714.         $resultSetUuids = [];
  716.         // first iterate and build up an array of all the UUIDs in the result set
  717.         foreach ($rows as $row) {
  718.             $resultSetUuids[$row['identifier']] = $row['path'];
  719.         }
  721.         // array of references to remap within the copied tree
  722.         $referenceElsToRemap = [];
  724.         // array references that will need updating in the database
  725.         $referencesToUpdate = [];
  727.         foreach ($rows as $row) {
  728.             $newPath = str_replace($srcAbsPath, $dstAbsPath, $row['path']);
  730.             $stringDom = new DOMDocument('1.0', 'UTF-8');
  731.             $stringDom->loadXML($row['props']);
  732.             $numericalDom = null;
  733.             if ($row['numerical_props']) {
  734.                 $numericalDom = new DOMDocument('1.0', 'UTF-8');
  735.                 $numericalDom->loadXML($row['numerical_props']);
  736.             }
  738.             $propsData = [
  739.                 'stringDom' => $stringDom,
  740.                 'numericalDom' => $numericalDom,
  741.                 'references' => [],
  742.             ];
  744.             $xpath = new DOMXpath($stringDom);
  745.             $referenceEls = $xpath->query(
  746.                 './/sv:property[@sv:type="reference" or @sv:type="Reference" or @sv:type="weakreference" or @sv:type="WeakReference"]'
  747.             );
  749.             $references = [];
  750.             foreach ($referenceEls as $referenceEl) {
  751.                 $propName = $referenceEl->getAttribute('sv:name');
  752.                 $values = [];
  753.                 foreach ($xpath->query('./sv:value', $referenceEl) as $valueEl) {
  754.                     $values[] = $valueEl->nodeValue;
  755.                 }
  757.                 $references[$propName] = [
  758.                     'type' => PropertyType::valueFromName($referenceEl->getAttribute('sv:type')),
  759.                     'values' => $values,
  760.                 ];
  762.                 if (array_key_exists($referenceEl->nodeValue, $resultSetUuids)) {
  763.                     $referenceElsToRemap[] = [$referenceEl, $newPath, $row['type'], $propsData];
  764.                 }
  765.             }
  767.             $originalUuid = $row['identifier'];
  769.             // when copying a node, the copy is always a new node. set $isNewNode to true
  770.             $newNodeId = $this->syncNode(null, $newPath, $row['type'], true, [], $propsData);
  772.             if ($references) {
  773.                 $referencesToUpdate[$newNodeId] = [
  774.                     'path' => $row['path'],
  775.                     'properties' => $references,
  776.                 ];
  777.             }
  779.             $newUuid = $this->nodeIdentifiers[$newPath];
  780.             $uuidMap[$originalUuid] = $newUuid;
  782.             $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 = ?';
  784.             try {
  785.                 $this->getConnection()->executeUpdate($query, [$newNodeId, $this->workspaceName, $row['id']]);
  786.             } catch (DBALException $e) {
  787.                 throw new RepositoryException(
  788.                     "Unexpected exception while copying node from $srcAbsPath to $dstAbsPath",
  789.                     $e->getCode(),
  790.                     $e
  791.                 );
  792.             }
  793.         }
  795.         foreach ($referenceElsToRemap as $data) {
  796.             [$referenceEl, $newPath, $type, $propsData] = $data;
  797.             $referenceEl->nodeValue = $uuidMap[$referenceEl->nodeValue];
  799.             $this->syncNode($this->nodeIdentifiers[$newPath], $newPath, $type, false, [], $propsData);
  800.         }
  802.         $this->syncReferences($referencesToUpdate);
  803.     }
  805.     /**
  806.      * @param string $path
  807.      *
  808.      * @return array
  809.      *
  810.      * @throws NamespaceException
  811.      */
  812.     private function getJcrName($path)
  813.     {
  814.         $name = implode('', array_slice(explode('/', $path), -1, 1));
  815.         $alias = '';
  817.         if (($aliasLength = strpos($name, ':')) !== false) {
  818.             $alias = substr($name, 0, $aliasLength);
  819.             $name = substr($name, $aliasLength + 1);
  820.         }
  822.         $namespaces = $this->getNamespaces();
  824.         if (!array_key_exists($alias, $namespaces)) {
  825.             throw new NamespaceException("the namespace $alias was not registered.");
  826.         }
  828.         return [$namespaces[$alias], $name];
  829.     }
  831.     /**
  832.      * Actually write the node into the database
  833.      *
  834.      * @param string $uuid node uuid
  835.      * @param string $path absolute path of the node
  836.      * @param string $type node type name
  837.      * @param boolean $isNewNode new nodes to insert (true) or existing node to update (false)
  838.      * @param Property[] $props
  839.      * @param array $propsData
  840.      *
  841.      * @return boolean|string
  842.      *
  843.      * @throws ItemExistsException
  844.      * @throws RepositoryException
  845.      * @throws NamespaceException
  846.      * @throws Exception
  847.      */
  848.     private function syncNode($uuid, $path, $type, $isNewNode, $props = [], $propsData = [])
  849.     {
  850.         // TODO: Not sure if there are always ALL props in $props, should we grab the online data here?
  851.         // TODO: PERFORMANCE Binary data is handled very inefficiently here, UPSERT will really be necessary here as well as lazy handling
  853.         if (!$propsData) {
  854.             $propsData = $this->propsToXML($props);
  855.         }
  857.         if (null === $uuid) {
  858.             $uuid = $this->generateUuid();
  859.         }
  861.         if ($isNewNode) {
  862.             [$namespace, $localName] = $this->getJcrName($path);
  864.             $qb = $this->getConnection()->createQueryBuilder();
  866.             $qb->select(
  867.                 ':identifier, :type, :path, :local_name, :namespace, :parent, :workspace_name, :props, :numerical_props, :depth, COALESCE(MAX(n.sort_order), 0) + 1'
  868.             )->from('phpcr_nodes', 'n')->where('n.parent = :parent_a');
  870.             $sql = $qb->getSQL();
  872.             try {
  873.                 $insert = "INSERT INTO phpcr_nodes (identifier, type, path, local_name, namespace, parent, workspace_name, props, numerical_props, depth, sort_order) " . $sql;
  875.                 $this->getConnection()->executeUpdate(
  876.                     $insert,
  877.                     $data = [
  878.                         'identifier' => $uuid,
  879.                         'type' => $type,
  880.                         'path' => $path,
  881.                         'local_name' => $localName,
  882.                         'namespace' => $namespace,
  883.                         'parent' => PathHelper::getParentPath($path),
  884.                         'workspace_name' => $this->workspaceName,
  885.                         'props' => $propsData['stringDom']->saveXML(),
  886.                         'numerical_props' => $propsData['numericalDom'] ? $propsData['numericalDom']->saveXML() : null,
  887.                         'depth' => PathHelper::getPathDepth($path),
  888.                         'parent_a' => PathHelper::getParentPath($path),
  889.                     ]
  890.                 );
  891.             } catch (Exception $e) {
  892.                 if ($e instanceof DBALException) {
  893.                     if (strpos($e->getMessage(), 'SQLSTATE[23') !== false) {
  894.                         throw new ItemExistsException('Item ' . $path . ' already exists in the database');
  895.                     }
  896.                     throw new RepositoryException(
  897.                         'Unknown database error while inserting item ' . $path . ': ' . $e->getMessage(),
  898.                         0,
  899.                         $e
  900.                     );
  901.                 }
  902.                 throw $e;
  903.             }
  905.             $nodeId = $this->getConnection()->lastInsertId($this->sequenceNodeName);
  906.         } else {
  907.             $nodeId = $this->getSystemIdForNode($path);
  908.             if (!$nodeId) {
  909.                 throw new RepositoryException("nodeId for $path not found");
  910.             }
  912.             $this->getConnection()->update(
  913.                 'phpcr_nodes',
  914.                 [
  915.                     'props' => $propsData['stringDom']->saveXML(),
  916.                     'numerical_props' => $propsData['numericalDom'] ? $propsData['numericalDom']->saveXML() : null,
  917.                 ],
  918.                 ['id' => $nodeId]
  919.             );
  920.         }
  922.         $this->nodeIdentifiers[$path] = $uuid;
  924.         if (array_key_exists('binaryData', $propsData) && count($propsData['binaryData'])) {
  925.             $this->syncBinaryData($nodeId, $propsData['binaryData']);
  926.         }
  928.         $this->referencesToUpdate[$nodeId] = ['path' => $path, 'properties' => $propsData['references']];
  930.         return $nodeId;
  931.     }
  933.     private function syncBinaryData(string $nodeId, array $binaryData): void
  934.     {
  935.         $connection = $this->getConnection();
  936.         foreach ($binaryData as $propertyName => $binaryValues) {
  937.             foreach ($binaryValues as $idx => $data) {
  938.                 // TODO verify in which cases we can just update
  939.                 $params = [
  940.                     'node_id' => $nodeId,
  941.                     'property_name' => $propertyName,
  942.                     'workspace_name' => $this->workspaceName,
  943.                 ];
  945.                 $connection->delete('phpcr_binarydata', $params);
  947.                 $params['idx'] = $idx;
  948.                 $params['data'] = $data;
  949.                 $types = [
  950.                     ParameterType::INTEGER,
  951.                     ParameterType::STRING,
  952.                     ParameterType::STRING,
  953.                     ParameterType::INTEGER,
  954.                     ParameterType::LARGE_OBJECT,
  955.                 ];
  957.                 $connection->insert('phpcr_binarydata', $params, $types);
  958.             }
  959.         }
  960.     }
  962.     /**
  963.      * @param array $referencesToUpdate
  964.      *
  965.      * @throws RepositoryException
  966.      * @throws ReferentialIntegrityException
  967.      */
  968.     private function syncReferences(array $referencesToUpdate)
  969.     {
  970.         if ($referencesToUpdate) {
  971.             // do not update references that are going to be deleted anyways
  972.             $toUpdate = array_diff(array_keys($referencesToUpdate), array_keys($this->referencesToDelete));
  974.             try {
  975.                 foreach ($this->referenceTables as $table) {
  976.                     $query = "DELETE FROM $table WHERE source_id IN (?)";
  977.                     $this->executeChunkedUpdate($query, $toUpdate);
  978.                 }
  979.             } catch (DBALException $e) {
  980.                 throw new RepositoryException('Unexpected exception while cleaning up after saving', $e->getCode(), $e);
  981.             }
  983.             $updates = [];
  984.             foreach ($toUpdate as $nodeId) {
  985.                 $references = $referencesToUpdate[$nodeId];
  986.                 foreach ($references['properties'] as $name => $data) {
  987.                     foreach ($data['values'] as $value) {
  988.                         $targetId = $this->getSystemIdForNode($value);
  989.                         if (false === $targetId) {
  990.                             if (PropertyType::REFERENCE === $data['type']) {
  991.                                 throw new ReferentialIntegrityException(
  992.                                     sprintf(
  993.                                         'Trying to store reference to non-existant node with path "%s" in node "%s" "%s"',
  994.                                         $value,
  995.                                         $references['path'],
  996.                                         $name
  997.                                     )
  998.                                 );
  999.                             }
  1001.                             continue;
  1002.                         }
  1004.                         $key = $targetId . '-' . $nodeId . '-' . $name;
  1005.                         // it is valid to have multiple references to the same node in a multivalue
  1006.                         // but it is not desired to store duplicates in the database
  1007.                         $updates[$key] = [
  1008.                             'type' => $data['type'],
  1009.                             'data' => [
  1010.                                 'source_id' => $nodeId,
  1011.                                 'source_property_name' => $name,
  1012.                                 'target_id' => $targetId,
  1013.                             ],
  1014.                         ];
  1015.                     }
  1016.                 }
  1017.             }
  1019.             foreach ($updates as $update) {
  1020.                 $this->getConnection()->insert($this->referenceTables[$update['type']], $update['data']);
  1021.             }
  1022.         }
  1024.         // TODO on RDBMS that support deferred FKs we could skip this step
  1025.         if ($this->referencesToDelete) {
  1026.             $params = array_keys($this->referencesToDelete);
  1028.             // remove all PropertyType::REFERENCE with a source_id on a deleted node
  1029.             try {
  1030.                 $query = "DELETE FROM phpcr_nodes_references WHERE source_id IN (?)";
  1031.                 $this->executeChunkedUpdate($query, $params);
  1032.             } catch (DBALException $e) {
  1033.                 throw new RepositoryException(
  1034.                     'Unexpected exception while cleaning up deleted nodes',
  1035.                     $e->getCode(),
  1036.                     $e
  1037.                 );
  1038.             }
  1040.             // ensure that there are no PropertyType::REFERENCE pointing to nodes that will be deleted
  1041.             // Note: due to the outer join we cannot filter on workspace_name, but this is ok
  1042.             // since within a transaction there can never be missing referenced nodes within the current workspace
  1043.             // make sure the target node is not in the list of nodes being deleted, to allow deletion in same request
  1044.             $query = 'SELECT DISTINCT r.target_id
  1045.             FROM phpcr_nodes_references r
  1046.                 LEFT OUTER JOIN phpcr_nodes n ON r.target_id = n.id
  1047.             WHERE r.target_id IN (?)';
  1049.             if ($this->getConnection()->getDatabasePlatform() instanceof SqlitePlatform) {
  1050.                 $missingTargets = [];
  1051.                 foreach (array_chunk($params, self::SQLITE_MAXIMUM_IN_PARAM_COUNT) as $chunk) {
  1052.                     $stmt = $this->getConnection()->executeQuery($query, [$chunk], [Connection::PARAM_INT_ARRAY]);
  1053.                     $missingTargets = array_merge($missingTargets, array_column($stmt->fetchAllNumeric(), 0));
  1054.                 }
  1055.             } else {
  1056.                 $stmt = $this->getConnection()->executeQuery($query, [$params], [Connection::PARAM_INT_ARRAY]);
  1057.                 $missingTargets = array_column($stmt->fetchAllNumeric(), 0);
  1058.             }
  1059.             if ($missingTargets) {
  1060.                 $paths = [];
  1061.                 foreach ($missingTargets as $id) {
  1062.                     if (array_key_exists($id, $this->referencesToDelete)) {
  1063.                         $paths[] = $this->referencesToDelete[$id];
  1064.                     }
  1065.                 }
  1067.                 throw new ReferentialIntegrityException(
  1068.                     "Cannot delete '" . implode("', '", $paths) . "': A reference points to this node or a subnode"
  1069.                 );
  1070.             }
  1072.             // clean up all references
  1073.             try {
  1074.                 foreach ($this->referenceTables as $table) {
  1075.                     $query = "DELETE FROM $table WHERE target_id IN (?)";
  1076.                     $this->executeChunkedUpdate($query, $params);
  1077.                 }
  1078.             } catch (DBALException $e) {
  1079.                 throw new RepositoryException(
  1080.                     'Unexpected exception while cleaning up deleted nodes',
  1081.                     $e->getCode(),
  1082.                     $e
  1083.                 );
  1084.             }
  1085.         }
  1086.     }
  1088.     /**
  1089.      * Convert the node XML to stdClass node representation containing all properties
  1090.      *
  1091.      * @param string $xml
  1092.      *
  1093.      * @return stdClass
  1094.      *
  1095.      * @throws InvalidArgumentException
  1096.      */
  1097.     protected function xmlToProps($xml)
  1098.     {
  1099.         $xmlParser = new XmlToPropsParser(
  1100.             $xml,
  1101.             $this->valueConverter
  1102.         );
  1104.         return $xmlParser->parse();
  1105.     }
  1107.     /**
  1108.      * Convert the node XML to stdClass node representation containing only the given properties
  1109.      *
  1110.      * @param string $xml
  1111.      * @param array $propertyNames
  1112.      *
  1113.      * @return stdClass
  1114.      *
  1115.      * @throws InvalidArgumentException
  1116.      */
  1117.     protected function xmlToColumns($xml, $propertyNames)
  1118.     {
  1119.         $xmlParser = new XmlToPropsParser(
  1120.             $xml,
  1121.             $this->valueConverter,
  1122.             $propertyNames
  1123.         );
  1125.         return $xmlParser->parse();
  1126.     }
  1128.     /**
  1129.      * Map a property from the given property XML node to the given \stdClass node representation
  1130.      *
  1131.      * @param DOMElement $propertyNode
  1132.      * @param stdClass $data
  1133.      *
  1134.      * @throws InvalidArgumentException
  1135.      *
  1136.      * @deprecated This method was replaced with the `XmlToPropsParser` for performance reasons.
  1137.      */
  1138.     protected function mapPropertyFromElement(DOMElement $propertyNode, stdClass $data)
  1139.     {
  1140.         @trigger_error(
  1141.             sprintf('The "%s" method is deprecated since jackalope/jackalope-doctrine-dbal 1.7.', __METHOD__),
  1142.             \E_USER_DEPRECATED
  1143.         );
  1145.         $name = $propertyNode->getAttribute('sv:name');
  1147.         $values = [];
  1149.         $type = PropertyType::valueFromName($propertyNode->getAttribute('sv:type'));
  1150.         foreach ($propertyNode->childNodes as $valueNode) {
  1151.             switch ($type) {
  1152.                 case PropertyType::NAME:
  1153.                 case PropertyType::URI:
  1154.                 case PropertyType::WEAKREFERENCE:
  1155.                 case PropertyType::REFERENCE:
  1156.                 case PropertyType::PATH:
  1157.                 case PropertyType::DECIMAL:
  1158.                 case PropertyType::STRING:
  1159.                     $values[] = $valueNode->nodeValue;
  1160.                     break;
  1161.                 case PropertyType::BOOLEAN:
  1162.                     $values[] = (bool)$valueNode->nodeValue;
  1163.                     break;
  1164.                 case PropertyType::LONG:
  1165.                     $values[] = (int)$valueNode->nodeValue;
  1166.                     break;
  1167.                 case PropertyType::BINARY:
  1168.                     $values[] = (int)$valueNode->nodeValue;
  1169.                     break;
  1170.                 case PropertyType::DATE:
  1171.                     $date = $valueNode->nodeValue;
  1172.                     if ($date) {
  1173.                         $date = new DateTime($date);
  1174.                         $date->setTimezone(new DateTimeZone(date_default_timezone_get()));
  1175.                         // Jackalope expects a string, might make sense to refactor to allow DateTime instances too
  1176.                         $date = $this->valueConverter->convertType($date, PropertyType::STRING);
  1177.                     }
  1178.                     $values[] = $date;
  1179.                     break;
  1180.                 case PropertyType::DOUBLE:
  1181.                     $values[] = (double)$valueNode->nodeValue;
  1182.                     break;
  1183.                 default:
  1184.                     throw new InvalidArgumentException("Type with constant $type not found.");
  1185.             }
  1186.         }
  1188.         switch ($type) {
  1189.             case PropertyType::BINARY:
  1190.                 $data->{':' . $name} = $propertyNode->getAttribute('sv:multi-valued') ? $values : $values[0];
  1191.                 break;
  1192.             default:
  1193.                 $data->{$name} = $propertyNode->getAttribute('sv:multi-valued') ? $values : $values[0];
  1194.                 $data->{':' . $name} = $type;
  1195.                 break;
  1196.         }
  1197.     }
  1199.     /**
  1200.      * Seperate properties array into an xml and binary data.
  1201.      *
  1202.      * @param array $properties
  1203.      *
  1204.      * @return array (
  1205.      *     'stringDom' => $stringDom,
  1206.      *     'numericalDom' => $numericalDom',
  1207.      *     'binaryData' => streams,
  1208.      *     'references' => ['type' => INT, 'values' => [UUIDs])
  1209.      * )
  1210.      *
  1211.      * @throws RepositoryException
  1212.      */
  1213.     private function propsToXML($properties)
  1214.     {
  1215.         $namespaces = [
  1216.             NS::PREFIX_MIX => NS::NAMESPACE_MIX,
  1217.             NS::PREFIX_NT => NS::NAMESPACE_NT,
  1218.             'xs' => 'http://www.w3.org/2001/XMLSchema',
  1219.             NS::PREFIX_JCR => NS::NAMESPACE_JCR,
  1220.             NS::PREFIX_SV => NS::NAMESPACE_SV,
  1221.             'rep' => 'internal',
  1222.         ];
  1224.         $doms = [
  1225.             'stringDom' => [],
  1226.             'numericalDom' => [],
  1227.         ];
  1229.         $binaryData = $references = [];
  1231.         foreach ($properties as $property) {
  1232.             $targetDoms = ['stringDom'];
  1234.             switch ($property->getType()) {
  1235.                 case PropertyType::WEAKREFERENCE:
  1236.                 case PropertyType::REFERENCE:
  1237.                     $references[$property->getName()] = [
  1238.                         'type' => $property->getType(),
  1239.                         'values' => $property->isMultiple() ? $property->getString() : [$property->getString()],
  1240.                     ];
  1241.                     // no break
  1242.                 case PropertyType::NAME:
  1243.                 case PropertyType::URI:
  1244.                 case PropertyType::PATH:
  1245.                 case PropertyType::STRING:
  1246.                     $values = $property->getString();
  1247.                     break;
  1248.                 case PropertyType::DECIMAL:
  1249.                     $values = $property->getDecimal();
  1250.                     $targetDoms[] = 'numericalDom';
  1251.                     break;
  1252.                 case PropertyType::BOOLEAN:
  1253.                     $values = array_map('intval', (array)$property->getBoolean());
  1254.                     break;
  1255.                 case PropertyType::LONG:
  1256.                     $values = $property->getLong();
  1257.                     $targetDoms[] = 'numericalDom';
  1258.                     break;
  1259.                 case PropertyType::BINARY:
  1260.                     if ($property->isNew() || $property->isModified()) {
  1261.                         $values = [];
  1262.                         foreach ((array)$property->getValueForStorage() as $stream) {
  1263.                             if (null === $stream) {
  1264.                                 $binary = '';
  1265.                             } else {
  1266.                                 $binary = stream_get_contents($stream);
  1267.                                 fclose($stream);
  1268.                             }
  1269.                             $binaryData[$property->getName()][] = $binary;
  1270.                             $length = strlen($binary);
  1271.                             $values[] = $length;
  1272.                         }
  1273.                     } else {
  1274.                         $values = $property->getLength();
  1275.                         if (!$property->isMultiple() && empty($values)) {
  1276.                             $values = [0];
  1277.                         }
  1278.                     }
  1279.                     break;
  1280.                 case PropertyType::DATE:
  1281.                     $values = $property->getDate();
  1282.                     if ($values instanceof DateTime) {
  1283.                         $values = [$values];
  1284.                     }
  1285.                     foreach ((array)$values as $key => $date) {
  1286.                         if ($date instanceof DateTime) {
  1287.                             // do not modify the instance which is associated with the node.
  1288.                             $date = clone $date;
  1290.                             // normalize to UTC for storage.
  1291.                             $date->setTimezone(new DateTimeZone('UTC'));
  1292.                         }
  1293.                         $values[$key] = $date;
  1294.                     }
  1295.                     $values = $this->valueConverter->convertType($values, PropertyType::STRING);
  1296.                     break;
  1297.                 case PropertyType::DOUBLE:
  1298.                     $values = $property->getDouble();
  1299.                     $targetDoms[] = 'numericalDom';
  1300.                     break;
  1301.                 default:
  1302.                     throw new RepositoryException('unknown type ' . $property->getType());
  1303.             }
  1305.             foreach ($targetDoms as $targetDom) {
  1306.                 $doms[$targetDom][] = [
  1307.                     'name' => $property->getName(),
  1308.                     'type' => PropertyType::nameFromValue($property->getType()),
  1309.                     'multiple' => $property->isMultiple(),
  1310.                     'lengths' => (array)$property->getLength(),
  1311.                     'values' => $values,
  1312.                 ];
  1313.             }
  1314.         }
  1316.         $ret = [
  1317.             'stringDom' => null,
  1318.             'numericalDom' => null,
  1319.             'binaryData' => $binaryData,
  1320.             'references' => $references
  1321.         ];
  1323.         foreach ($doms as $targetDom => $properties) {
  1324.             $dom = new DOMDocument('1.0', 'UTF-8');
  1325.             $rootNode = $dom->createElement('sv:node');
  1326.             foreach ($namespaces as $namespace => $uri) {
  1327.                 $rootNode->setAttribute('xmlns:' . $namespace, $uri);
  1328.             }
  1329.             $dom->appendChild($rootNode);
  1331.             foreach ($properties as $property) {
  1333.                 /* @var $property Property */
  1334.                 $propertyNode = $dom->createElement('sv:property');
  1335.                 $propertyNode->setAttribute('sv:name', $property['name']);
  1336.                 $propertyNode->setAttribute('sv:type', $property['type']);
  1337.                 $propertyNode->setAttribute('sv:multi-valued', $property['multiple'] ? '1' : '0');
  1338.                 $lengths = (array)$property['lengths'];
  1339.                 foreach ((array)$property['values'] as $key => $value) {
  1340.                     $element = $propertyNode->appendChild($dom->createElement('sv:value'));
  1341.                     $element->appendChild($dom->createTextNode($value));
  1342.                     if (array_key_exists($key, $lengths)) {
  1343.                         $lengthAttribute = $dom->createAttribute('length');
  1344.                         $lengthAttribute->value = $lengths[$key];
  1345.                         $element->appendChild($lengthAttribute);
  1346.                     }
  1347.                 }
  1349.                 $rootNode->appendChild($propertyNode);
  1350.             }
  1352.             if (count($properties)) {
  1353.                 $ret[$targetDom] = $dom;
  1354.             }
  1355.         }
  1357.         return $ret;
  1358.     }
  1360.     /**
  1361.      * {@inheritDoc}
  1362.      *
  1363.      * @throws DBALException
  1364.      */
  1365.     public function getAccessibleWorkspaceNames()
  1366.     {
  1367.         $query = "SELECT DISTINCT name FROM phpcr_workspaces";
  1368.         $stmt = $this->getConnection()->executeQuery($query);
  1370.         return array_column($stmt->fetchAllNumeric(), 0);
  1371.     }
  1373.     /**
  1374.      * {@inheritDoc}
  1375.      *
  1376.      * @throws RepositoryException
  1377.      * @throws DBALException
  1378.      */
  1379.     public function getNode($path)
  1380.     {
  1381.         $this->assertLoggedIn();
  1382.         PathHelper::assertValidAbsolutePath($path, false, true, $this->getNamespacePrefixes());
  1384.         $values['path'] = $path;
  1385.         $values['pathd'] = rtrim($path, '/') . '/%';
  1386.         $values['workspace'] = $this->workspaceName;
  1388.         if ($this->fetchDepth > 0) {
  1389.             $values['fetchDepth'] = $this->fetchDepth;
  1390.             $query = '
  1391.               SELECT * FROM phpcr_nodes
  1392.               WHERE (path LIKE :pathd OR path = :path)
  1393.                 AND workspace_name = :workspace
  1394.                 AND depth <= ((SELECT depth FROM phpcr_nodes WHERE path = :path AND workspace_name = :workspace) + :fetchDepth)
  1395.               ORDER BY depth, sort_order ASC';
  1396.         } else {
  1397.             $query = '
  1398.               SELECT * FROM phpcr_nodes
  1399.               WHERE path = :path
  1400.                 AND workspace_name = :workspace
  1401.               ORDER BY depth, sort_order ASC';
  1402.         }
  1404.         $stmt = $this->getConnection()->executeQuery($query, $values);
  1405.         $rows = $stmt->fetchAllAssociative();
  1406.         if (empty($rows)) {
  1407.             throw new ItemNotFoundException("Item $path not found in workspace " . $this->workspaceName);
  1408.         }
  1410.         $nestedNodes = $this->getNodesData($rows);
  1411.         $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 (0 === count($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 (array_key_exists($identifier, $pathByUuid)) {
  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.         $nodesByPath = [];
  1804.         foreach ($operations as $op) {
  1805.             $nodePath = PathHelper::getParentPath($op->srcPath);
  1806.             $propertyName = PathHelper::getNodeName($op->srcPath);
  1807.             if (!array_key_exists($nodePath, $nodesByPath)) {
  1808.                 $nodesByPath[$nodePath] = [];
  1809.             }
  1810.             $nodesByPath[$nodePath][$propertyName] = $propertyName;
  1811.         }
  1813.         // Doing the actual removal
  1814.         $this->assertLoggedIn();
  1815.         foreach ($nodesByPath as $nodePath => $propertiesToDelete) {
  1816.             $this->removePropertiesFromNode($nodePath, $propertiesToDelete);
  1817.         }
  1819.         return true;
  1820.     }
  1822.     /**
  1823.      * {@inheritDoc}
  1824.      */
  1825.     public function deletePropertyImmediately($path)
  1826.     {
  1827.         $this->prepareSave();
  1828.         $this->deleteProperty($path);
  1829.         $this->finishSave();
  1831.         return true;
  1832.     }
  1834.     /**
  1835.      * {@inheritDoc}
  1836.      *
  1837.      * @throws ItemNotFoundException
  1838.      * @throws RepositoryException
  1839.      */
  1840.     protected function deleteProperty($path)
  1841.     {
  1842.         $this->assertLoggedIn();
  1843.         $nodePath = PathHelper::getParentPath($path);
  1844.         $propertyName = PathHelper::getNodeName($path);
  1845.         $this->removePropertiesFromNode($nodePath, [$propertyName]);
  1846.     }
  1848.     /**
  1849.      * Removes a list of properties from a given node.
  1850.      *
  1851.      * @param string $nodePath
  1852.      * @param array<string> $propertiesToDelete Path belonging to that node that should be deleted
  1853.      */
  1854.     private function removePropertiesFromNode($nodePath, array $propertiesToDelete): void
  1855.     {
  1856.         $nodeId = $this->getSystemIdForNode($nodePath);
  1857.         if (!$nodeId) {
  1858.             // no we really don't know that path
  1859.             throw new ItemNotFoundException('No item found at ' . $nodePath);
  1860.         }
  1862.         $query = 'SELECT props FROM phpcr_nodes WHERE id = ?';
  1863.         $xml = $this->getConnection()->fetchOne($query, [$nodeId]);
  1865.         $xmlPropsRemover = new XmlPropsRemover($xml, $propertiesToDelete);
  1866.         [$xml, $references] = $xmlPropsRemover->removeProps();
  1868.         foreach ($references as $type => $propertyNames) {
  1869.             $table = $this->referenceTables['reference' === $type ? PropertyType::REFERENCE : PropertyType::WEAKREFERENCE];
  1870.             foreach ($propertyNames as $propertyName) {
  1871.                 try {
  1872.                     $query = "DELETE FROM $table WHERE source_id = ? AND source_property_name = ?";
  1873.                     $this->getConnection()->executeUpdate($query, [$nodeId, $propertyName]);
  1874.                 } catch (DBALException $e) {
  1875.                     throw new RepositoryException(
  1876.                         'Unexpected exception while cleaning up deleted nodes',
  1877.                         $e->getCode(),
  1878.                         $e
  1879.                     );
  1880.                 }
  1881.             }
  1882.         }
  1884.         $query = 'UPDATE phpcr_nodes SET props = ? WHERE id = ?';
  1885.         $params = [$xml, $nodeId];
  1887.         try {
  1888.             $this->getConnection()->executeUpdate($query, $params);
  1889.         } catch (DBALException $e) {
  1890.             throw new RepositoryException("Unexpected exception while updating properties of $nodePath", $e->getCode(), $e);
  1891.         }
  1892.     }
  1894.     /**
  1895.      * {@inheritDoc}
  1896.      */
  1897.     public function moveNodes(array $operations)
  1898.     {
  1899.         /** @var $op MoveNodeOperation */
  1900.         foreach ($operations as $op) {
  1901.             $this->moveNode($op->srcPath, $op->dstPath);
  1902.         }
  1904.         return true;
  1905.     }
  1907.     /**
  1908.      * {@inheritDoc}
  1909.      */
  1910.     public function moveNodeImmediately($srcAbsPath, $dstAbspath)
  1911.     {
  1912.         $this->prepareSave();
  1913.         $this->moveNode($srcAbsPath, $dstAbspath);
  1914.         $this->finishSave();
  1916.         return true;
  1917.     }
  1919.     /**
  1920.      * Execute moving a single node
  1921.      *
  1922.      * @throws PathNotFoundException
  1923.      * @throws ItemExistsException
  1924.      * @throws RepositoryException
  1925.      */
  1926.     protected function moveNode($srcAbsPath, $dstAbsPath)
  1927.     {
  1928.         $this->assertLoggedIn();
  1929.         PathHelper::assertValidAbsolutePath($srcAbsPath, false, true, $this->getNamespacePrefixes());
  1930.         PathHelper::assertValidAbsolutePath($dstAbsPath, true, true, $this->getNamespacePrefixes());
  1932.         if (!$this->pathExists($srcAbsPath)) {
  1933.             throw new PathNotFoundException("Source path '$srcAbsPath' not found");
  1934.         }
  1936.         if ($this->getSystemIdForNode($dstAbsPath)) {
  1937.             throw new ItemExistsException(
  1938.                 "Cannot move '$srcAbsPath' to '$dstAbsPath' because destination node already exists."
  1939.             );
  1940.         }
  1942.         if (!$this->getSystemIdForNode(PathHelper::getParentPath($dstAbsPath))) {
  1943.             throw new PathNotFoundException("Parent of the destination path '" . $dstAbsPath . "' has to exist.");
  1944.         }
  1946.         $query = 'SELECT path, id FROM phpcr_nodes WHERE path LIKE ? OR path = ? AND workspace_name = ? ' . $this->getConnection(
  1947.             )->getDatabasePlatform()->getForUpdateSQL();
  1948.         $stmt = $this->getConnection()->executeQuery($query, [$srcAbsPath . '/%', $srcAbsPath, $this->workspaceName]);
  1950.         /*
  1951.          * TODO: https://github.com/jackalope/jackalope-doctrine-dbal/pull/26/files#L0R1057
  1952.          * the other thing i wonder: can't you do the replacement inside sql instead of loading and then storing
  1953.          * the node? this will be extremely slow for a large set of nodes. i think you should use query builder here
  1954.          * rather than raw sql, to make it work on a maximum of platforms.
  1955.          *
  1956.          * can you try to do this please? if we don't figure out how to do it, at least fix the where criteria, and
  1957.          * we can ask the doctrine community how to do the substring operation.
  1958.          * http://stackoverflow.com/questions/8619421/correct-syntax-for-doctrine2s-query-builder-substring-helper-method
  1959.          */
  1961.         $query = "UPDATE phpcr_nodes SET ";
  1962.         $updatePathCase = "path = CASE ";
  1963.         $updateParentCase = "parent = CASE ";
  1964.         $updateLocalNameCase = "local_name = CASE ";
  1965.         $updateSortOrderCase = "sort_order = CASE ";
  1966.         $updateDepthCase = "depth = CASE ";
  1968.         // TODO: Find a better way to do this
  1969.         // Calculate CAST type for CASE statement
  1970.         switch ($this->getConnection()->getDatabasePlatform()->getName()) {
  1971.             case 'pgsql':
  1972.                 $intType = 'integer';
  1973.                 break;
  1974.             case 'mysql':
  1975.                 $intType = 'unsigned';
  1976.                 break;
  1977.             default:
  1978.                 $intType = 'integer';
  1979.         }
  1981.         $i = 0;
  1982.         $values = $ids = [];
  1983.         $srcAbsPathPattern = '/^' . preg_quote($srcAbsPath, '/') . '/';
  1984.         while ($row = $stmt->fetchAssociative()) {
  1985.             $values['id' . $i] = $row['id'];
  1986.             $values['path' . $i] = preg_replace($srcAbsPathPattern, $dstAbsPath, $row['path'], 1);
  1987.             $values['parent' . $i] = PathHelper::getParentPath($values['path' . $i]);
  1988.             $values['depth' . $i] = PathHelper::getPathDepth($values['path' . $i]);
  1990.             $updatePathCase .= "WHEN id = :id$i THEN :path$i ";
  1991.             $updateParentCase .= "WHEN id = :id$i THEN :parent$i ";
  1992.             $updateDepthCase .= "WHEN id = :id$i THEN CAST(:depth$i AS $intType) ";
  1994.             if ($srcAbsPath === $row['path']) {
  1995.                 [, $localName] = $this->getJcrName($values['path' . $i]);
  1996.                 $values['localname' . $i] = $localName;
  1998.                 $updateLocalNameCase .= "WHEN id = :id$i THEN :localname$i ";
  1999.                 $updateSortOrderCase .= "WHEN id = :id$i THEN (SELECT * FROM ( SELECT MAX(x.sort_order) + 1 FROM phpcr_nodes x WHERE x.parent = :parent$i) y) ";
  2000.             }
  2002.             $ids[] = $row['id'];
  2004.             $i++;
  2005.         }
  2007.         if (!$i) {
  2008.             return;
  2009.         }
  2011.         $ids = implode(',', $ids);
  2013.         $updateLocalNameCase .= 'ELSE local_name END, ';
  2014.         $updateSortOrderCase .= 'ELSE sort_order END ';
  2016.         $query .= $updatePathCase . 'END, ' . $updateParentCase . 'END, ' . $updateDepthCase . 'END, ' . $updateLocalNameCase . $updateSortOrderCase;
  2017.         $query .= "WHERE id IN ($ids)";
  2019.         try {
  2020.             $this->getConnection()->executeStatement($query, $values);
  2021.         } catch (DBALException $e) {
  2022.             throw new RepositoryException(
  2023.                 "Unexpected exception while moving node from $srcAbsPath to $dstAbsPath",
  2024.                 $e->getCode(),
  2025.                 $e
  2026.             );
  2027.         }
  2029.         $this->cleanIdentifierCache($srcAbsPath);
  2030.     }
  2032.     /**
  2033.      * {@inheritDoc}
  2034.      *
  2035.      * @throws RepositoryException
  2036.      */
  2037.     public function reorderChildren(Node $node)
  2038.     {
  2039.         $this->assertLoggedIn();
  2041.         $values['absPath'] = $node->getPath();
  2042.         $sql = "UPDATE phpcr_nodes SET sort_order = CASE CONCAT(
  2043.           namespace,
  2044.           (CASE namespace WHEN '' THEN '' ELSE ':' END),
  2045.           local_name
  2046.         )";
  2048.         $i = 0;
  2050.         foreach ($node->getNodeNames() as $name) {
  2051.             $values['name' . $i] = implode(':', array_filter($this->getJcrName($name)));
  2052.             $values['order' . $i] = $i; // use our counter to avoid gaps
  2053.             $sql .= " WHEN :name$i THEN :order$i";
  2054.             $i++;
  2055.         }
  2057.         $sql .= ' ELSE sort_order END WHERE parent = :absPath';
  2059.         try {
  2060.             $this->getConnection()->executeStatement($sql, $values);
  2061.         } catch (DBALException $e) {
  2062.             throw new RepositoryException('Unexpected exception while reordering nodes', $e->getCode(), $e);
  2063.         }
  2065.         return true;
  2066.     }
  2068.     /**
  2069.      * Return the node processor for processing nodes
  2070.      * according to their node types.
  2071.      *
  2072.      * @return NodeProcessor
  2073.      */
  2074.     private function getNodeProcessor()
  2075.     {
  2076.         if ($this->nodeProcessor) {
  2077.             return $this->nodeProcessor;
  2078.         }
  2080.         $this->nodeProcessor = new NodeProcessor(
  2081.             $this->credentials->getUserID(),
  2082.             $this->getNamespacesObject(),
  2083.             $this->getAutoLastModified()
  2084.         );
  2086.         return $this->nodeProcessor;
  2087.     }
  2089.     /**
  2090.      * {@inheritDoc}
  2091.      */
  2092.     public function storeNodes(array $operations)
  2093.     {
  2094.         $this->assertLoggedIn();
  2096.         $additionalAddOperations = [];
  2098.         foreach ($operations as $operation) {
  2099.             if ($operation->node->isDeleted()) {
  2100.                 $properties = $operation->node->getPropertiesForStoreDeletedNode();
  2101.             } else {
  2102.                 $additionalAddOperations = array_merge(
  2103.                     $additionalAddOperations,
  2104.                     $this->getNodeProcessor()->process($operation->node)
  2105.                 );
  2106.                 $properties = $operation->node->getProperties();
  2107.             }
  2108.             $this->storeNode($operation->srcPath, $properties);
  2109.         }
  2111.         if (count($additionalAddOperations)) {
  2112.             $this->storeNodes($additionalAddOperations);
  2113.         }
  2114.     }
  2116.     /**
  2117.      * Make sure we have a uuid and a primaryType, then sync data into the database
  2118.      *
  2119.      * @param string $path the path to store the node at
  2120.      * @param Property[] $properties the properties of this node
  2121.      *
  2122.      * @return boolean true on success
  2123.      *
  2124.      * @throws RepositoryException if not logged in
  2125.      */
  2126.     protected function storeNode($path, $properties)
  2127.     {
  2128.         $nodeIdentifier = $this->getIdentifier($path, $properties);
  2129.         $type = isset($properties['jcr:primaryType']) ? $properties['jcr:primaryType']->getValue() : 'nt:unstructured';
  2131.         $this->syncNode($nodeIdentifier, $path, $type, true, $properties);
  2133.         return true;
  2134.     }
  2136.     /**
  2137.      * Determine a UUID for the node at this path with these properties
  2138.      *
  2139.      * @param string $path
  2140.      * @param Property[] $properties
  2141.      *
  2142.      * @return string a unique id
  2143.      */
  2144.     protected function getIdentifier($path, $properties)
  2145.     {
  2146.         if (array_key_exists($path, $this->nodeIdentifiers)) {
  2147.             return $this->nodeIdentifiers[$path];
  2148.         }
  2150.         if (isset($properties['jcr:uuid'])) {
  2151.             return $properties['jcr:uuid']->getValue();
  2152.         }
  2154.         // we always generate a uuid, even for non-referenceable nodes that have no automatic uuid
  2155.         return $this->generateUuid();
  2156.     }
  2158.     /**
  2159.      * {@inheritDoc}
  2160.      */
  2161.     public function getNodeTypes($nodeTypes = [])
  2162.     {
  2163.         $standardTypes = StandardNodeTypes::getNodeTypeData();
  2165.         $userTypes = $this->fetchUserNodeTypes();
  2167.         if ($nodeTypes) {
  2168.             $nodeTypes = array_flip($nodeTypes);
  2169.             return array_values(
  2170.                 array_intersect_key($standardTypes, $nodeTypes) + array_intersect_key($userTypes, $nodeTypes)
  2171.             );
  2172.         }
  2174.         return array_values($standardTypes + $userTypes);
  2175.     }
  2177.     /**
  2178.      * Fetch a user-defined node-type definition.
  2179.      *
  2180.      * @return array
  2181.      */
  2182.     protected function fetchUserNodeTypes()
  2183.     {
  2184.         $result = [];
  2186.         $query = '
  2187. SELECT
  2188. phpcr_type_nodes.name AS node_name, phpcr_type_nodes.is_abstract AS node_abstract,
  2189. phpcr_type_nodes.is_mixin AS node_mixin, phpcr_type_nodes.queryable AS node_queryable,
  2190. phpcr_type_nodes.orderable_child_nodes AS node_has_orderable_child_nodes,
  2191. phpcr_type_nodes.primary_item AS node_primary_item_name, phpcr_type_nodes.supertypes AS declared_super_type_names,
  2192. phpcr_type_props.name AS property_name, phpcr_type_props.auto_created AS property_auto_created,
  2193. phpcr_type_props.mandatory AS property_mandatory, phpcr_type_props.protected AS property_protected,
  2194. phpcr_type_props.on_parent_version AS property_on_parent_version,
  2195. phpcr_type_props.required_type AS property_required_type, phpcr_type_props.multiple AS property_multiple,
  2196. phpcr_type_props.fulltext_searchable AS property_fulltext_searchable,
  2197. phpcr_type_props.query_orderable AS property_query_orderable, phpcr_type_props.default_value as property_default_value,
  2198. phpcr_type_childs.name AS child_name, phpcr_type_childs.auto_created AS child_auto_created,
  2199. phpcr_type_childs.mandatory AS child_mandatory, phpcr_type_childs.protected AS child_protected,
  2200. phpcr_type_childs.on_parent_version AS child_on_parent_version, phpcr_type_childs.default_type AS child_default_type,
  2201. phpcr_type_childs.primary_types AS child_primary_types
  2202. FROM
  2203. phpcr_type_nodes
  2204. LEFT JOIN
  2205. phpcr_type_props ON phpcr_type_nodes.node_type_id = phpcr_type_props.node_type_id
  2206. LEFT JOIN
  2207. phpcr_type_childs ON phpcr_type_nodes.node_type_id = phpcr_type_childs.node_type_id
  2208. ';
  2210.         $statement = $this->getConnection()->prepare($query);
  2212.         $stmtResult = $statement->execute();
  2213.         $stmtResult = is_bool($stmtResult) ? $statement : $stmtResult;
  2215.         while ($row = $stmtResult->fetchAssociative()) {
  2216.             $nodeName = $row['node_name'];
  2218.             if (!array_key_exists($nodeName, $result)) {
  2219.                 $result[$nodeName] = [
  2220.                     'name' => $nodeName,
  2221.                     'isAbstract' => (bool)$row['node_abstract'],
  2222.                     'isMixin' => (bool)$row['node_mixin'],
  2223.                     'isQueryable' => (bool)$row['node_queryable'],
  2224.                     'hasOrderableChildNodes' => (bool)$row['node_has_orderable_child_nodes'],
  2225.                     'primaryItemName' => $row['node_primary_item_name'],
  2226.                     'declaredSuperTypeNames' => array_filter(explode(' ', $row['declared_super_type_names'])),
  2227.                     'declaredPropertyDefinitions' => [],
  2228.                     'declaredNodeDefinitions' => [],
  2229.                 ];
  2230.             }
  2232.             if (($propertyName = $row['property_name']) !== null) {
  2233.                 $result[$nodeName]['declaredPropertyDefinitions'][] = [
  2234.                     'declaringNodeType' => $nodeName,
  2235.                     'name' => $propertyName,
  2236.                     'isAutoCreated' => (bool)$row['property_auto_created'],
  2237.                     'isMandatory' => (bool)$row['property_mandatory'],
  2238.                     'isProtected' => (bool)$row['property_protected'],
  2239.                     'onParentVersion' => (bool)$row['property_on_parent_version'],
  2240.                     'requiredType' => (int)$row['property_required_type'],
  2241.                     'multiple' => (bool)$row['property_multiple'],
  2242.                     'isFulltextSearchable' => (bool)$row['property_fulltext_searchable'],
  2243.                     'isQueryOrderable' => (bool)$row['property_query_orderable'],
  2244.                     'queryOperators' => [
  2245.                         QOM::JCR_OPERATOR_EQUAL_TO,
  2246.                         QOM::JCR_OPERATOR_NOT_EQUAL_TO,
  2247.                         QOM::JCR_OPERATOR_GREATER_THAN,
  2248.                         QOM::JCR_OPERATOR_GREATER_THAN_OR_EQUAL_TO,
  2249.                         QOM::JCR_OPERATOR_LESS_THAN,
  2250.                         QOM::JCR_OPERATOR_LESS_THAN_OR_EQUAL_TO,
  2251.                         QOM::JCR_OPERATOR_LIKE,
  2252.                     ],
  2253.                     'defaultValues' => [$row['property_default_value']]
  2254.                 ];
  2255.             }
  2257.             if (($childName = $row['child_name']) !== null) {
  2258.                 $result[$nodeName]['declaredNodeDefinitions'][] = [
  2259.                     'declaringNodeType' => $nodeName,
  2260.                     'name' => $childName,
  2261.                     'isAutoCreated' => (bool)$row['child_auto_created'],
  2262.                     'isMandatory' => (bool)$row['child_mandatory'],
  2263.                     'isProtected' => (bool)$row['child_protected'],
  2264.                     'onParentVersion' => (bool)$row['child_on_parent_version'],
  2265.                     'allowsSameNameSiblings' => false,
  2266.                     'defaultPrimaryTypeName' => $row['child_default_type'],
  2267.                     'requiredPrimaryTypeNames' => array_filter(explode(' ', $row['child_primary_types']))
  2268.                 ];
  2269.             }
  2270.         }
  2272.         return $result;
  2273.     }
  2275.     /**
  2276.      * {@inheritDoc}
  2277.      */
  2278.     public function registerNodeTypes($types, $allowUpdate)
  2279.     {
  2280.         $builtinTypes = StandardNodeTypes::getNodeTypeData();
  2282.         /* @var $type NodeTypeDefinition */
  2283.         foreach ($types as $type) {
  2284.             if (array_key_exists($type->getName(), $builtinTypes)) {
  2285.                 throw new RepositoryException(sprintf('%s: can\'t reregister built-in node type.', $type->getName()));
  2286.             }
  2288.             $nodeTypeName = $type->getName();
  2290.             $query = "SELECT * FROM phpcr_type_nodes WHERE name = ?";
  2291.             $result = $this->getConnection()->fetchOne($query, [$nodeTypeName]);
  2293.             $data = [
  2294.                 'name' => $nodeTypeName,
  2295.                 'supertypes' => implode(' ', $type->getDeclaredSuperTypeNames()),
  2296.                 'is_abstract' => $type->isAbstract() ? 1 : 0,
  2297.                 'is_mixin' => $type->isMixin() ? 1 : 0,
  2298.                 'queryable' => $type->isQueryable() ? 1 : 0,
  2299.                 'orderable_child_nodes' => $type->hasOrderableChildNodes() ? 1 : 0,
  2300.                 'primary_item' => $type->getPrimaryItemName(),
  2301.             ];
  2303.             if ($result) {
  2304.                 if (!$allowUpdate) {
  2305.                     throw new NodeTypeExistsException("Could not register node type with the name '$nodeTypeName'.");
  2306.                 }
  2308.                 $this->getConnection()->update('phpcr_type_nodes', $data, ['node_type_id' => $result]);
  2309.                 $this->getConnection()->delete('phpcr_type_props', ['node_type_id' => $result]);
  2310.                 $this->getConnection()->delete('phpcr_type_childs', ['node_type_id' => $result]);
  2312.                 $nodeTypeId = $result;
  2313.             } else {
  2314.                 $this->getConnection()->insert('phpcr_type_nodes', $data);
  2316.                 $nodeTypeId = $this->getConnection()->lastInsertId($this->sequenceTypeName);
  2317.             }
  2319.             if ($propDefs = $type->getDeclaredPropertyDefinitions()) {
  2320.                 foreach ($propDefs as $propertyDef) {
  2321.                     /* @var $propertyDef PropertyDefinitionInterface */
  2322.                     $this->getConnection()->insert(
  2323.                         'phpcr_type_props',
  2324.                         [
  2325.                             'node_type_id' => $nodeTypeId,
  2326.                             'name' => $propertyDef->getName(),
  2327.                             'protected' => $propertyDef->isProtected() ? 1 : 0,
  2328.                             'mandatory' => $propertyDef->isMandatory() ? 1 : 0,
  2329.                             'auto_created' => $propertyDef->isAutoCreated() ? 1 : 0,
  2330.                             'on_parent_version' => $propertyDef->getOnParentVersion(),
  2331.                             'multiple' => $propertyDef->isMultiple() ? 1 : 0,
  2332.                             'fulltext_searchable' => $propertyDef->isFullTextSearchable() ? 1 : 0,
  2333.                             'query_orderable' => $propertyDef->isQueryOrderable() ? 1 : 0,
  2334.                             'required_type' => $propertyDef->getRequiredType(),
  2335.                             'query_operators' => 0, // transform to bitmask
  2336.                             'default_value' => $propertyDef->getDefaultValues() ? current(
  2337.                                 $propertyDef->getDefaultValues()
  2338.                             ) : null,
  2339.                         ]
  2340.                     );
  2341.                 }
  2342.             }
  2344.             if ($childDefs = $type->getDeclaredChildNodeDefinitions()) {
  2345.                 foreach ($childDefs as $childDef) {
  2346.                     /* @var $childDef NodeDefinitionInterface */
  2347.                     $this->getConnection()->insert(
  2348.                         'phpcr_type_childs',
  2349.                         [
  2350.                             'node_type_id' => $nodeTypeId,
  2351.                             'name' => $childDef->getName(),
  2352.                             'protected' => $childDef->isProtected() ? 1 : 0,
  2353.                             'mandatory' => $childDef->isMandatory() ? 1 : 0,
  2354.                             'auto_created' => $childDef->isAutoCreated() ? 1 : 0,
  2355.                             'on_parent_version' => $childDef->getOnParentVersion(),
  2356.                             'primary_types' => implode(' ', $childDef->getRequiredPrimaryTypeNames() ?: []),
  2357.                             'default_type' => $childDef->getDefaultPrimaryTypeName(),
  2358.                         ]
  2359.                     );
  2360.                 }
  2361.             }
  2362.         }
  2363.     }
  2365.     /**
  2366.      * {@inheritDoc}
  2367.      */
  2368.     public function setNodeTypeManager($nodeTypeManager)
  2369.     {
  2370.         $this->nodeTypeManager = $nodeTypeManager;
  2371.     }
  2373.     /**
  2374.      * {@inheritDoc}
  2375.      */
  2376.     public function cloneFrom($srcWorkspace, $srcAbsPath, $destAbsPath, $removeExisting)
  2377.     {
  2378.         throw new NotImplementedException('Cloning nodes is not implemented yet');
  2379.     }
  2381.     /**
  2382.      * {@inheritDoc}
  2383.      */
  2384.     public function updateNode(Node $node, $srcWorkspace)
  2385.     {
  2386.         throw new NotImplementedException('Updating nodes is not implemented yet');
  2387.     }
  2389.     /**
  2390.      * {@inheritDoc}
  2391.      * @throws RepositoryException when no binary data found
  2392.      */
  2393.     public function getBinaryStream($path)
  2394.     {
  2395.         $this->assertLoggedIn();
  2397.         $nodePath = PathHelper::getParentPath($path);
  2398.         $nodeId = $this->getSystemIdForNode($nodePath);
  2399.         $propertyName = PathHelper::getNodeName($path);
  2401.         $data = $this->getConnection()->fetchAllAssociative(
  2402.             'SELECT data, idx FROM phpcr_binarydata WHERE node_id = ? AND property_name = ? AND workspace_name = ?',
  2403.             [$nodeId, $propertyName, $this->workspaceName]
  2404.         );
  2406.         if (count($data) === 0) {
  2407.             throw new RepositoryException('No binary data found in stream');
  2408.         }
  2410.         $streams = [];
  2411.         foreach ($data as $row) {
  2412.             if (is_resource($row['data'])) {
  2413.                 $stream = $row['data'];
  2414.             } else {
  2415.                 $stream = fopen('php://memory', 'rwb+');
  2416.                 fwrite($stream, $row['data']);
  2417.                 rewind($stream);
  2418.             }
  2420.             $streams[] = $stream;
  2421.         }
  2423.         if (count($data) === 1) {
  2424.             // we don't know if this is a multivalue property or not.
  2425.             // TODO we should have something more efficient to know this. a flag in the database?
  2427.             // TODO use self::getProperty()->isMultiple() once implemented
  2428.             $node = $this->getNode($nodePath);
  2429.             if (!is_array($node->{':' . $propertyName})) {
  2430.                 return reset($streams);
  2431.             }
  2432.         }
  2434.         return $streams;
  2435.     }
  2437.     /**
  2438.      * {@inheritDoc}
  2439.      */
  2440.     public function getProperty($path)
  2441.     {
  2442.         throw new NotImplementedException('Getting properties by path is not implemented yet');
  2443.     }
  2445.     /**
  2446.      * {@inheritDoc}
  2447.      *
  2448.      * @throws InvalidQueryException
  2449.      */
  2450.     public function query(Query $query)
  2451.     {
  2452.         $this->assertLoggedIn();
  2454.         if (!$query instanceof QueryObjectModelInterface) {
  2455.             $parser = new Sql2ToQomQueryConverter($this->factory->get(QueryObjectModelFactory::class));
  2456.             try {
  2457.                 $qom = $parser->parse($query->getStatement());
  2458.                 $qom->setLimit($query->getLimit());
  2459.                 $qom->setOffset($query->getOffset());
  2460.             } catch (Exception $e) {
  2461.                 throw new InvalidQueryException('Invalid query: ' . $query->getStatement(), 0, $e);
  2462.             }
  2463.         } else {
  2464.             $qom = $query;
  2465.         }
  2467.         $qomWalker = new QOMWalker($this->nodeTypeManager, $this->getConnection(), $this->getNamespaces());
  2468.         [$selectors, $selectorAliases, $sql] = $qomWalker->walkQOMQuery($qom);
  2470.         $primarySource = reset($selectors);
  2471.         $primaryType = $primarySource->getSelectorName() ?: $primarySource->getNodeTypeName();
  2472.         $statement = $this->getConnection()->executeQuery($sql, [$this->workspaceName]);
  2474.         $results = $properties = $standardColumns = [];
  2475.         while ($row = $statement->fetchAssociative()) {
  2476.             $result = [];
  2478.             /** @var SelectorInterface $selector */
  2479.             foreach ($selectors as $selector) {
  2480.                 $selectorName = $selector->getSelectorName() ?: $selector->getNodeTypeName();
  2481.                 $columnPrefix = array_key_exists($selectorName, $selectorAliases) ? $selectorAliases[$selectorName] . '_' : $selectorAliases[''] . '_';
  2483.                 if ($primaryType === $selector->getNodeTypeName()) {
  2484.                     $result[] = [
  2485.                         'dcr:name' => 'jcr:path',
  2486.                         'dcr:value' => $row[$columnPrefix . 'path'],
  2487.                         'dcr:selectorName' => $selectorName
  2488.                     ];
  2489.                 }
  2491.                 $result[] = [
  2492.                     'dcr:name' => 'jcr:path',
  2493.                     'dcr:value' => $row[$columnPrefix . 'path'],
  2494.                     'dcr:selectorName' => $selectorName
  2495.                 ];
  2496.                 $result[] = ['dcr:name' => 'jcr:score', 'dcr:value' => 0, 'dcr:selectorName' => $selectorName];
  2497.                 if (0 === count($qom->getColumns())) {
  2498.                     $selectorPrefix = null !== $selector->getSelectorName() ? $selectorName . '.' : '';
  2499.                     $result[] = [
  2500.                         'dcr:name' => $selectorPrefix . 'jcr:primaryType',
  2501.                         'dcr:value' => $primaryType,
  2502.                         'dcr:selectorName' => $selectorName
  2503.                     ];
  2504.                 }
  2506.                 if (array_key_exists($columnPrefix.'props', $row) && is_string($row[$columnPrefix.'props'])) {
  2507.                     $propertyNames = [];
  2508.                     $columns = $qom->getColumns();
  2510.                     // Always populate jcr:created and jcr:createdBy if a wildcard selector is used.
  2511.                     // This emulates the behavior of Jackrabbit
  2512.                     if (0 === count($columns)) {
  2513.                         $propertyNames = ['jcr:created', 'jcr:createdBy'];
  2514.                     }
  2516.                     foreach ($columns as $column) {
  2517.                         if (!$column->getSelectorName() || $column->getSelectorName() == $selectorName) {
  2518.                             $propertyNames[] = $column->getPropertyName();
  2519.                         }
  2520.                     }
  2522.                     $properties[$selectorName] = (array)$this->xmlToColumns(
  2523.                         $row[$columnPrefix.'props'],
  2524.                         $propertyNames
  2525.                     );
  2526.                 } else {
  2527.                     $properties[$selectorName] = [];
  2528.                 }
  2530.                 // TODO: add other default columns that Jackrabbit provides to provide a more consistent behavior
  2531.                 if (isset($properties[$selectorName]['jcr:createdBy'])) {
  2532.                     $standardColumns[$selectorName]['jcr:createdBy'] = $properties[$selectorName]['jcr:createdBy'];
  2533.                 }
  2535.                 if (isset($properties[$selectorName]['jcr:created'])) {
  2536.                     $standardColumns[$selectorName]['jcr:created'] = $properties[$selectorName]['jcr:created'];
  2537.                 }
  2538.             }
  2540.             $reservedNames = ['jcr:path', 'jcr:score'];
  2542.             foreach ($qom->getColumns() as $column) {
  2543.                 $selectorName = $column->getSelectorName();
  2544.                 $columnName = $column->getPropertyName();
  2545.                 $columnPrefix = array_key_exists($selectorName, $selectorAliases) ? $selectorAliases[$selectorName] . '_' : $selectorAliases[''] . '_';
  2548.                 if (in_array($column->getColumnName(), $reservedNames)) {
  2549.                     throw new InvalidQueryException(
  2550.                         sprintf(
  2551.                             'Cannot reserved name "%s". Reserved names are "%s"',
  2552.                             $column->getColumnName(),
  2553.                             implode('", "', $reservedNames)
  2554.                         )
  2555.                     );
  2556.                 }
  2558.                 $dcrValue = 'jcr:uuid' === $columnName ? $row[$columnPrefix . 'identifier'] : ($properties[$selectorName][$columnName] ?? '');
  2560.                 unset($standardColumns[$selectorName][$columnName]);
  2562.                 $dcrName = $column->getColumnName() === $columnName
  2563.                     && isset($properties[$selectorName][$columnName])
  2564.                     ? $selectorName.'.'.$columnName
  2565.                     : $column->getColumnName()
  2566.                 ;
  2567.                 $result[] = [
  2568.                     'dcr:name' => $dcrName,
  2569.                     'dcr:value' => $dcrValue,
  2570.                     'dcr:selectorName' => $selectorName ?: $primaryType,
  2571.                 ];
  2572.             }
  2574.             foreach ($standardColumns as $selectorName => $columns) {
  2575.                 foreach ($columns as $columnName => $value) {
  2576.                     $result[] = [
  2577.                         'dcr:name' => $primaryType . '.' . $columnName,
  2578.                         'dcr:value' => $value,
  2579.                         'dcr:selectorName' => $selectorName,
  2580.                     ];
  2581.                 }
  2582.             }
  2584.             $results[] = $result;
  2585.         }
  2587.         return $results;
  2588.     }
  2590.     /**
  2591.      * {@inheritDoc}
  2592.      */
  2593.     public function getSupportedQueryLanguages()
  2594.     {
  2595.         return [
  2596.             QueryInterface::JCR_SQL2,
  2597.             QueryInterface::JCR_JQOM,
  2598.             QueryInterface::SQL,
  2599.         ];
  2600.     }
  2602.     /**
  2603.      * We need to create an in memory backup when we are inside a transaction
  2604.      * so that we can efficiently restore the original state in the namespaces
  2605.      * property in case of a rollback.
  2606.      *
  2607.      * This method also ensures that namespaces are loaded to begin with.
  2608.      */
  2609.     private function ensureNamespacesBackup()
  2610.     {
  2611.         if (!$this->namespaces instanceof \ArrayObject) {
  2612.             $this->getNamespacesObject();
  2613.         }
  2615.         if (!$this->inTransaction) {
  2616.             return;
  2617.         }
  2619.         if (null === $this->originalNamespaces) {
  2620.             $this->originalNamespaces = $this->namespaces->getArrayCopy();
  2621.         }
  2622.     }
  2624.     /**
  2625.      * {@inheritDoc}
  2626.      *
  2627.      * @throws NamespaceException
  2628.      */
  2629.     public function registerNamespace($prefix, $uri)
  2630.     {
  2631.         if ($this->namespaces && $this->namespaces->offsetExists($prefix)) {
  2632.             if ($this->namespaces[$prefix] === $uri) {
  2633.                 return;
  2634.             }
  2636.             if (array_key_exists($prefix, $this->coreNamespaces)) {
  2637.                 throw new NamespaceException(
  2638.                     "Cannot overwrite JCR core namespace prefix '$prefix' to a new uri '$uri'."
  2639.                 );
  2640.             }
  2641.         }
  2643.         $this->ensureNamespacesBackup();
  2645.         $this->getConnection()->delete('phpcr_namespaces', ['prefix' => $prefix]);
  2646.         $this->getConnection()->delete('phpcr_namespaces', ['uri' => $uri]);
  2648.         $this->getConnection()->insert(
  2649.             'phpcr_namespaces',
  2650.             [
  2651.                 'prefix' => $prefix,
  2652.                 'uri' => $uri,
  2653.             ]
  2654.         );
  2656.         if (null !== $this->namespaces) {
  2657.             $this->namespaces[$prefix] = $uri;
  2658.         }
  2659.     }
  2661.     /**
  2662.      * {@inheritDoc}
  2663.      */
  2664.     public function unregisterNamespace($prefix)
  2665.     {
  2666.         if (array_key_exists($prefix, $this->coreNamespaces)) {
  2667.             throw new NamespaceException("Cannot unregister JCR core namespace prefix '$prefix'.");
  2668.         }
  2670.         $this->ensureNamespacesBackup();
  2672.         $this->getConnection()->delete('phpcr_namespaces', ['prefix' => $prefix]);
  2674.         if (null !== $this->namespaces) {
  2675.             unset($this->namespaces[$prefix]);
  2676.         }
  2677.     }
  2679.     /**
  2680.      * {@inheritDoc}
  2681.      */
  2682.     public function getReferences($path, $name = null)
  2683.     {
  2684.         return $this->getNodeReferences($path, $name, false);
  2685.     }
  2687.     /**
  2688.      * {@inheritDoc}
  2689.      */
  2690.     public function getWeakReferences($path, $name = null)
  2691.     {
  2692.         return $this->getNodeReferences($path, $name, true);
  2693.     }
  2695.     /**
  2696.      * @param string $path the path for which we need the references
  2697.      * @param string $name the name of the referencing properties or null for all
  2698.      * @param boolean $weakReference whether to get weak or strong references
  2699.      *
  2700.      * @return array list of paths to nodes that reference $path
  2701.      */
  2702.     private function getNodeReferences($path, $name = null, $weakReference = false)
  2703.     {
  2704.         $targetId = $this->getSystemIdForNode($path);
  2706.         if (false === $targetId) {
  2707.             return [];
  2708.         }
  2710.         $params = [$targetId];
  2712.         $table = $weakReference ? $this->referenceTables[PropertyType::WEAKREFERENCE] : $this->referenceTables[PropertyType::REFERENCE];
  2713.         $query = "SELECT CONCAT(n.path, '/', r.source_property_name) FROM phpcr_nodes n
  2714.                INNER JOIN $table r ON n.id = r.source_id
  2715.                WHERE r.target_id = ?";
  2716.         if (null !== $name) {
  2717.             $query .= " AND source_property_name = ?";
  2718.             $params[] = $name;
  2719.         }
  2721.         $stmt = $this->getConnection()->executeQuery($query, $params);
  2723.         return array_column($stmt->fetchAllNumeric(), 0);
  2724.     }
  2726.     /**
  2727.      * {@inheritDoc}
  2728.      */
  2729.     public function beginTransaction()
  2730.     {
  2731.         if ($this->inTransaction) {
  2732.             throw new RepositoryException('Begin transaction failed: transaction already open');
  2733.         }
  2735.         $this->assertLoggedIn();
  2737.         try {
  2738.             $this->getConnection()->beginTransaction();
  2739.             $this->inTransaction = true;
  2740.         } catch (Exception $e) {
  2741.             throw new RepositoryException('Begin transaction failed: ' . $e->getMessage());
  2742.         }
  2743.     }
  2745.     /**
  2746.      * {@inheritDoc}
  2747.      *
  2748.      * @throws RepositoryException
  2749.      */
  2750.     public function commitTransaction()
  2751.     {
  2752.         if (!$this->inTransaction) {
  2753.             throw new RepositoryException('Commit transaction failed: no transaction open');
  2754.         }
  2756.         $this->assertLoggedIn();
  2758.         try {
  2759.             $this->inTransaction = false;
  2761.             $this->getConnection()->commit();
  2763.             if ($this->originalNamespaces) {
  2764.                 // now that the transaction is committed, reset the cache of the stored namespaces.
  2765.                 $this->originalNamespaces = null;
  2766.             }
  2767.         } catch (Exception $e) {
  2768.             throw new RepositoryException('Commit transaction failed: ' . $e->getMessage());
  2769.         }
  2770.     }
  2772.     /**
  2773.      * {@inheritDoc}
  2774.      *
  2775.      * @throws RepositoryException
  2776.      */
  2777.     public function rollbackTransaction()
  2778.     {
  2779.         if (!$this->inTransaction) {
  2780.             throw new RepositoryException('Rollback transaction failed: no transaction open');
  2781.         }
  2783.         $this->assertLoggedIn();
  2785.         try {
  2786.             $this->inTransaction = false;
  2788.             $this->getConnection()->rollBack();
  2790.             if ($this->originalNamespaces) {
  2791.                 // reset namespaces
  2792.                 $this->setNamespaces($this->originalNamespaces);
  2793.                 $this->originalNamespaces = null;
  2794.             }
  2795.         } catch (Exception $e) {
  2796.             throw new RepositoryException('Rollback transaction failed: ' . $e->getMessage(), 0, $e);
  2797.         }
  2798.     }
  2800.     /**
  2801.      * Sets the default transaction timeout
  2802.      *
  2803.      * @param int $seconds The value of the timeout in seconds
  2804.      */
  2805.     public function setTransactionTimeout($seconds)
  2806.     {
  2807.         $this->assertLoggedIn();
  2809.         throw new NotImplementedException("Setting a transaction timeout is not yet implemented");
  2810.     }
  2812.     /**
  2813.      * {@inheritDoc}
  2814.      */
  2815.     public function prepareSave()
  2816.     {
  2817.         $this->getConnection()->beginTransaction();
  2818.     }
  2820.     /**
  2821.      * {@inheritDoc}
  2822.      */
  2823.     public function finishSave()
  2824.     {
  2825.         $this->syncReferences($this->referencesToUpdate);
  2826.         $this->referencesToUpdate = $this->referencesToDelete = [];
  2827.         $this->getConnection()->commit();
  2828.     }
  2830.     /**
  2831.      * {@inheritDoc}
  2832.      */
  2833.     public function rollbackSave()
  2834.     {
  2835.         $this->referencesToUpdate = $this->referencesToDelete = [];
  2836.         $this->getConnection()->rollBack();
  2837.     }
  2839.     /**
  2840.      *
  2841.      * @param Node $node the node to update
  2842.      */
  2843.     public function updateProperties(Node $node)
  2844.     {
  2845.         $this->assertLoggedIn();
  2846.         // we can ignore the operations returned, there will be no additions because of property updates
  2847.         $this->getNodeProcessor()->process($node);
  2849.         $this->syncNode(
  2850.             $node->getIdentifier(),
  2851.             $node->getPath(),
  2852.             $node->getPrimaryNodeType(),
  2853.             false,
  2854.             $node->getProperties()
  2855.         );
  2857.         return true;
  2858.     }
  2860.     /**
  2861.      * Initialize the dbal connection lazily
  2862.      */
  2863.     private function initConnection()
  2864.     {
  2865.         if (true === $this->conn->isConnected() && true === $this->connectionInitialized) {
  2866.             return;
  2867.         }
  2869.         $platform = $this->conn->getDatabasePlatform();
  2870.         if ($platform instanceof PostgreSQL94Platform || $platform instanceof PostgreSqlPlatform) {
  2871.             $this->sequenceNodeName = 'phpcr_nodes_id_seq';
  2872.             $this->sequenceTypeName = 'phpcr_type_nodes_node_type_id_seq';
  2873.         }
  2875.         // @TODO: move to "SqlitePlatform" and rename to "registerExtraFunctions"?
  2876.         if ($this->conn->getDatabasePlatform() instanceof SqlitePlatform) {
  2877.             if (method_exists($this->conn, 'getNativeConnection')) {
  2878.                 $connection = $this->conn->getNativeConnection();
  2879.             } else {
  2880.                 $connection = $this->conn->getWrappedConnection();
  2881.                 if ($connection instanceof PDOConnection && !$connection instanceof PDO) {
  2882.                     $connection = $connection->getWrappedConnection();
  2883.                 }
  2884.             }
  2886.             $this->registerSqliteFunctions($connection);
  2887.         }
  2889.         $this->connectionInitialized = true;
  2890.     }
  2891. }