PHPCR Guide

    <?php
    require("/path/to/jackalope-jackrabbit/vendor/autoload.php");

    $factoryclass = '\Jackalope\RepositoryFactoryJackrabbit';
    $parameters = array('jackalope.jackrabbit_uri' => 'http://localhost:8080/server');
    // end of implementation specific configuration

    $factory = new $factoryclass();
    $repository = $factory->getRepository($parameters);
    $credentials = new \PHPCR\SimpleCredentials('admin','admin');
    $session = $repository->login($credentials, 'default');
    $root = $session->getRootNode();
    $node = $root->addNode('test', 'nt:unstructured');
    $node->setProperty('prop', 'value');
    $session->save();

    // data is stored now. in a follow-up request you can do
    $node = $session->getNode('/test');
    echo $node->getPropertyValue('prop'); // outputs "value"

    <?php
    require("vendor/autoload.php");

    // factory (the *only* implementation specific part)
    $factoryclass = '\Jackalope\RepositoryFactoryJackrabbit';
    // the parameters would typically live in a configuration file
    // see your implementation for required and optional parameters
    $parameters = array('jackalope.jackrabbit_uri' => 'http://localhost:8080/server');

    // end of implementation specific configuration
    // from here on, the whole code does not need to be changed when using different implementations

    $factory = new $factoryclass();
    $repository = $factory->getRepository($parameters);
    if (null === $repository) {
        var_dump($parameters);
        die('There where missing parameters, the factory could not create a repository');
    }

    // the login parameters would typically live in a configuration file

    $workspacename = 'default';
    $user = 'admin';
    $pass = 'admin';

    // create credentials and log in to get a session
    $credentials = new \PHPCR\SimpleCredentials($user, $pass);
    try {
        $session = $repository->login($credentials, $workspacename);
    } catch(\PHPCR\LoginException $e) {
        die('Invalid credentials: '.$e->getMessage());
    } catch(\PHPCR\NoSuchWorkspaceException $e) {
        die("No workspace $workspacename: ".$e->getMessage());
    }

    // if we get here, we have a session object that can be used to read and write the repository

    <data xmlns:jcr="http://www.jcp.org/jcr/1.0" xmlns:nt="http://www.jcp.org/jcr/nt/1.0">
        <node title="Test" content="This is some test content" />
        <sibling title="Test" content="This is another test content">
            <child1 title="Child1 title" />
            <child2 title="Child2 title" />
            <otherchild title="Otherchild title"/>
            <yetanother title="Yetanother title">
                <child title="Child title" />
            </yetanother>
        </sibling>
    </data>

    <?php
    $session->importXML('/', 'test.xml', \PHPCR\ImportUUIDBehaviorInterface::IMPORT_UUID_CREATE_NEW);
    $session->save();

    <?php
    $node = $session->getNode('/data/node');
    echo $node->getName(); // will be 'node'
    echo $node->getPath(); // will be '/data/node'

    <?php
    //get the node from the session
    $node = $session->getNode('/data/node');

    // get the php value of a property (type automatically determined from stored information)
    echo $node->getPropertyValue('title');

    // get the Property object to operate on
    $property = $node->getProperty('content');
    echo 'Size of '.$property->getPath().' is '.$property->getLength();

    // read a property that could be very long
    $property = $node->getProperty('content');

    // if it is binary convert into string
    $data = $property->getString();
    echo $data;

    // get binary stream. could be more performant with binary property
    $stream = $property->getBinary();
    fpassthru($stream);
    fclose($stream);

    // the above in short if you just want to dump a file that is in a binary propery:
    // fpassthru($node->getPropertyValue('binary-prop'));

    <?php
    // get all properties of this node
    foreach ($node->getPropertiesValues() as $name => $value) {
        echo "$name: $value\n";
    }
    // get the properties of this node with a name starting with 't'
    foreach ($node->getPropertiesValues("t*") as $name => $value) {
        echo "$name: $value\n";
    }

    <?php
    //get the node from the session
    $node = $session->getNode('/data/node');

    // getting a node by path relative to the node
    $othernode = $node->getNode('../sibling'); // /sibling

    // get all child nodes. the $node is Iterable, the iterator being all children
    $node = $session->getNode('/data/sibling');
    foreach ($node as $name => $child) {
        if ($child->hasProperties()) {
            echo "$name has properties\n";
        } else {
            echo "$name does not have properties\n";
        }
    }

    // get child nodes with the name starting with 'c'
    foreach ($node->getNodes('c*') as $name => $child) {
        echo "$name\n";
    }

    // get child nodes with the name starting with 'o' or ending with '2' or named 'yetanother'
    foreach ($node->getNodes(array('o*', '*2', 'yetanother')) as $name => $child) {
        echo "$name\n";
    }

    // get the parent node
    $parent = $node->getParent(); // /

    // build a breadcrumb of the node ancestry
    $node = $session->getNode('/data/sibling/yetanother');
    $i = 0;
    $breadcrumb = array();
    do {
        $i++;
        $parent = $node->getAncestor($i);
        $breadcrumb[$parent->getPath()] = $parent->getName();
    } while ($parent != $node);
    var_dump($breadcrumb);

    <sv:node
         xmlns:mix="http://www.jcp.org/jcr/mix/1.0"
         xmlns:nt="http://www.jcp.org/jcr/nt/1.0"
         xmlns:xs="http://www.w3.org/2001/XMLSchema"
         xmlns:jcr="http://www.jcp.org/jcr/1.0"
         xmlns:sv="http://www.jcp.org/jcr/sv/1.0"
         xmlns:rep="internal"

        sv:name="idExample"
    >
        <sv:property sv:name="jcr:primaryType" sv:type="Name">
            <sv:value>nt:unstructured</sv:value>
        </sv:property>

        <sv:node sv:name="target">
            <sv:property sv:name="jcr:primaryType" sv:type="Name">
                <sv:value>nt:unstructured</sv:value>
            </sv:property>
            <sv:property sv:name="jcr:mixinTypes" sv:type="Name">
                <sv:value>mix:referenceable</sv:value>
            </sv:property>
            <sv:property sv:name="jcr:uuid" sv:type="String">
                <sv:value>13543fc6-1abf-4708-bfcc-e49511754b40</sv:value>
            </sv:property>
            <sv:property sv:name="someproperty" sv:type="String">
                <sv:value>Some value</sv:value>
            </sv:property>
        </sv:node>

        <sv:node sv:name="source">
            <sv:property sv:name="jcr:primaryType" sv:type="Name">
                <sv:value>nt:unstructured</sv:value>
            </sv:property>
            <sv:property sv:name="reference" sv:type="WeakReference">
                <sv:value>13543fc6-1abf-4708-bfcc-e49511754b40</sv:value>
            </sv:property>
            <sv:property sv:name="path" sv:type="Path">
                <sv:value>../target/someproperty</sv:value>
            </sv:property>
        </sv:node>

    </sv:node>

    <?php
    $node = $session->getNode('/idExample/source');
    // will return you a node if the property is of type REFERENCE or WEAKREFERENCE
    $othernode = $node->getPropertyValue('reference');

    // force a node
    $property = $node->getProperty('reference');
    // will additionally try to resolve a PATH or NAME property and even work
    // if the property is a STRING that happens to be a valid UUID or to
    // denote an existing path
    $othernode = $property->getNode();

    // get a referenced property
    $property = $node->getProperty('path');
    $otherproperty = $property->getProperty();
    echo $otherproperty->getName(); // someproperty
    echo $otherproperty->getValue(); // Some value

    <?php
    // get the query interface from the workspace
    $workspace = $session->getWorkspace();
    $queryManager = $workspace->getQueryManager();

    $sql = "SELECT * FROM [nt:unstructured]
        WHERE [nt:unstructured].[title] = 'Test'
        ORDER BY [nt:unstructured].content";
    $query = $queryManager->createQuery($sql, 'JCR-SQL2');
    $query->setLimit(10); // limit number of results to be returned
    $query->setOffset(1); // set an offset to skip first n results
    $queryResult = $query->execute();

    foreach ($queryResult->getNodes() as $path => $node) {
        echo $node->getName();
    }

    <?php
    foreach ($queryResult as $path => $row) {
        echo $path . ' scored ' . $row->getScore();

        $row->getValue('a-value-you-know-exists');
    }

    <?php
    $qomFactory = $mySession->getWorkspace()->getQueryManager()->getQOMFactory();

    <?php
    $source = $qomFactory->selector('a', '[nt:unstructured]');
    $query = $qomFactory->createQuery($source, null, array(), array());
    $queryResult = $query->execute();

    <?php
    use PHPCR\Query\QOM\QueryObjectModelConstantsInterface;
    use PHPCR\Util\QOM\QueryBuilder;

    $qf = $qomFactory;
    $qb = new QueryBuilder($qomFactory);
    //add the source
    $qb->from($qomFactory->selector('a', 'nt:unstructured'))
        //some composed constraint
        ->andWhere($qf->comparison($qf->propertyValue('a', 'title'),
        QueryObjectModelConstantsInterface::JCR_OPERATOR_EQUAL_TO,
        $qf->literal('Test')))
        //orderings (descending by default)
        ->orderBy($qf->propertyValue('a', 'content'))
        //set an offset
        ->setFirstResult(0)
        //and the maximum number of node-tuples to retrieve
        ->setMaxResults(25);
    $result = $qb->execute();

    foreach ($result->getNodes() as $node) {
        echo $node->getName() . " has content: " . $node->getPropertyValue('content') . "\n";
    }
    //node has content: This is some test content
    //sibling has content: This is another test content

    //get the node from the session
    $node = $session->getNode('/data/node');

    // add a new node as child of $node
    $newnode = $node->addNode('new node', 'nt:unstructured'); // until we have shown node types, just use nt:unstructured as type

    // set a property on the new node
    $newproperty = $newnode->setProperty('my property', 'my value');

    // persist the changes permanently. now they also become visible in other sessions
    $session->save();


    // have a reference
    $targetnode = $session->getNode('/data/sibling/yetanother');

    // make sure the target node is referenceable.
    $targetnode->addMixin('mix:referenceable');
    // depending on the implementation, you might need to save the session at
    // this point to have the identifier generated

    // add a reference property to the node. because the property value is a
    // Node, PHPCR will automatically detect that you want a reference
    $node->setProperty('my reference', $targetnode);

    $session->save();

    <?php
    // move the node yetanother and all its children from its parent /sibling to
    // the new parent /sibling/child1
    // the target parent must already exist, it is not automatically created
    // as the move includes the target name, it can also be used to rename nodes
    $session->move('/data/sibling/yetanother', '/data/sibling/child1/yetanother');

    // for this session, everything that was at /sibling/yetanother is now under /sibling/child1/yetanother
    // i.e. /sibling/child1/yetanother/child
    // once the session is saved, the move is persisted and visible in other sessions
    // alternatively, you can immediatly move the node in the persistent storage

    // rename node child2 to child2_new
    $workspace = $session->getWorkspace();
    $workspace->move('/data/sibling/child2', '/data/sibling/child2_new');

    // copy a node and its children (only available on workspace, not inside session)
    $workspace->copy('/data/sibling/yetanother', '/data/sibling/child1/yetanother');

    // delete a node
    $session->removeItem('/data/sibling/child1/yetanother');

    <?php
    //get the node from the session
    $node = $session->getNode('/data/node');

    $node->addNode('first');
    $node->addNode('second'); // new nodes are added to the end of the list
    // order is: first, second

    // ordering is done on the parent node. the first argument is the name of
    // the child node to be reordered, the second the name of the node to moved
    // node is placed before
    $node->orderBefore('second', 'first');
    // now the order is: second, first

    <?php
    //get the node from the session
    $node = $session->getNode('/data/node');

    $node->setProperty('foo', 'fafa');
    // mark the node as versionable
    $node->addMixin('mix:versionable');
    $session->save();

    // version operations are done through the VersionManager
    $versionManager = $session->getWorkspace()->getVersionManager();

    // put the versionable node into edit mode
    $versionManager->checkout($node->getPath());
    $node->setProperty('foo', 'bar'); // need a change to see something
    $session->save(); // you can only create versions of saved nodes
    // create a new version of the node with our changes
    $version = $versionManager->checkin($node->getPath());
    // Version extends the Node interface. The version is the node with additional functionality

    // walk back the versions
    $oldversion = $version->getLinearPredecessor();
    // the version objects are just the meta data. call getFrozenNode on them
    // to get a snapshot of the data when the version was created
    echo $version->getName() . ': ' . $version->getFrozenNode()->getPropertyValue('foo') . "\n"; // 1.1: bar
    echo $oldversion->getName() . ': ' . $oldversion->getFrozenNode()->getPropertyValue('foo'); // 1.0: fafa

    // get the full version history
    $history = $versionManager->getVersionHistory($node->getPath());
    foreach ($history->getAllFrozenNodes() as $node) {
        if ($node->hasProperty('foo')) {
            // the root version does not have the property
            echo $node->getPropertyValue('foo') . "\n";
        }
    }

    // restore an old version
    $node->setProperty('foo', 'different');
    $versionManager->checkout($node->getPath());
    $session->save(); // restoring is only possible if the session is clean
    $current = $versionManager->getBaseVersion($node->getPath());
    $versionManager->restore(true, $current);
    echo $node->getPropertyValue('foo'); // fafa

    <?php
    //get the node from the session
    $node = $session->getNode('/data/sibling');
    //the node has to be lockable
    $node->addMixin('mix:lockable');
    $session->save(); //node needs to be clean before locking

    // get the lock manager
    $workspace = $session->getWorkspace();
    $lockManager = $workspace->getLockManager();
    var_dump($lockManager->isLocked('/data/sibling')); // should be false
    $lockManager->lock('/data/sibling', true, true); // lock child nodes as well, release when session closed
    // now only this session may change the node //sibling and its descendants
    var_dump($lockManager->isLocked('/data/sibling')); // should be true
    var_dump($lockManager->isLocked('/data/sibling/child1')); // should be true because we locked deep

    // getting the lock from LockManager is not yet implemented with jackalope-jackrabbit
    $lock = $lockManager->getLock('/data/sibling');
    var_dump($lock->isLockOwningSession()); // true, this is our lock, not somebody else's
    var_dump($lock->getSecondsRemaining()); // PHP_INT_MAX because this lock has no timeout
    var_dump($lock->isLive()); // true

    $node = $lock->getNode(); // this gets us the node for /sibling
    $node === $lockManager->getLock('/data/sibling')->getNode(); // getnode always returns the lock owning node

    // now unlock the node again
    $lockManager->unlock('/data/sibling'); // we could also let $session->logout() unlock when using session based lock
    var_dump($lockManager->isLocked('/data/sibling')); // false
    var_dump($lock->isLive()); // false

    <?php
    // get the transaction manager.
    $workspace = $session->getWorkspace();
    $transactionManager = $workspace->getTransactionManager();
    // start a transaction
    $transactionManager->begin();
    $session->removeNode('/data/sibling');
    $session->getRootNode()->addNode('insideTransaction');
    $session->save(); // wrote to the backend but not yet visible to other sessions
    $workspace->move('/data/node', '/new'); // will only move the new node if session has been saved. still not visible to other sessions
    $transactionManager->commit(); // now everything become persistent and visible to others

    // you can abort a transaction
    try {
        ...
    } catch(\Exception $e) {
        if ($transactionManager->inTransaction()) {
            $transactionManager->rollback();
        }
        ...
    }

    <?php
    $file = fopen('/tmp/document.xml', 'w+');

    // dump the tree at /foo/bar into a document view file
    $session->exportDocumentView(
        '/data/sibling',
        $file,
        true, // skip binary properties to not have large files in the dump
        false // recursivly output the child nodes as well
    );

    fclose($file);

    $file = fopen('/tmp/system.xml', 'w+');
    // export the tree at /foo/bar into a system view xml file
    $session->exportSystemView(
        '/data/sibling',
        $file,
        false, // do not skip binary properties
        false
    );

    fclose($file);

    <?php
    $filename = 'dump.xml';
    $session->getRootNode()->addNode('imported_data', 'nt:unstructured');
    $session->importXML(
        '/imported_data', // attach the imported data at this node
        $filename,
        ImportUUIDBehaviorInterface::IMPORT_UUID_CREATE_NEW
    );

    <?php
    use PHPCR\Observation\EventInterface; // Contains the constants for event types

    // Get the observation manager
    $workspace = $session->getWorkspace();
    $observationManager = $workspace->getObservationManager();

    // Get the unfiltered event journal and go through its content
    $journal = $observationManager->getEventJournal();
    $journal->skipTo(strtotime('-1 day')); // Skip all the events prior to yesterday
    foreach ($journal as $event) {
        // Do something with $event (it's a Jackalope\Observation\Event instance)
        echo $event->getType() . ' - ' . $event->getPath();
    }

    // Filtering and using the journal as an iterator
    // You can filter the event journal on several criteria, here we keep events for node and properties added
    $journal = $observationManager->getEventJournal(EventInterface::NODE_ADDED | EventInterface::PROPERTY_ADDED);

    while ($journal->valid()) {
        $event = $journal->current();
        // Do something with $event
        $journal->next();
    }