XmlDb.php

Go to the documentation of this file.

<?php

 
namespace Depage\XmlDb;
 
use Depage\XmlDb\Exceptions\XmlDbException;
 
class XmlDb implements Interfaces\XmlGetter
{
    public $pdo;
    protected $cache;
    protected $dbNs;
 
    protected $tablePrefix = 'dp_';
    protected $tableDocs;
    protected $tableXml;
 
    protected $docIds = [];
 
    protected $transactions = 0;
    protected $alteringTransaction;
 
    public $options;
    public function __construct($tablePrefix, $pdo, $cache, $options = [])
    {
        $this->pdo = $pdo;
        $this->pdo->setAttribute(\PDO::ATTR_ORACLE_NULLS, \PDO::NULL_NATURAL);
 
        $this->cache = $cache;
 
        $this->options = $options;
 
        $this->dbNs = new XmlNs('db', 'http://cms.depagecms.net/ns/database');
 
        $this->tablePrefix = $tablePrefix;
        $this->tableDocs = $tablePrefix . '_xmldocs';
        $this->tableXml = $tablePrefix . '_xmltree';
    }

    public function __get($property)
    {
        if (property_exists($this, $property)) {
            return $this->$property;
        }
    }

    public function docExists($docIdOrName)
    {
        if (!isset($this->docIds[$docIdOrName])) {
            if ((int) $docIdOrName > 0) {
                $id = (int) $docIdOrName;
 
                // is already a doc-id
                $query = $this->pdo->prepare(
                    "SELECT docs.name AS docname
                    FROM {$this->tableDocs} AS docs
                    WHERE docs.id = :doc_id"
                );
                $query->execute([
                    'doc_id' => $id,
                ]);
 
                $result = $query->fetchObject();
                if ($result === false) {
                    // document does not exist
                    return false;
                }
 
                $name = $result->docname;
            } else {
                $name = $docIdOrName;
                $docList = $this->getDocuments($name);
 
                if (!isset($docList[$name])) {
                    // document does not exist
                    return false;
                }
 
                $id = $docList[$name]->getDocId();
            }
 
            $this->docIds[$id] = $id;
            $this->docIds[$name] = $id;
        }
 
        return $this->docIds[$docIdOrName];
    }

    public function getDocuments($name = "", $type = "")
    {
        $docs = [];
 
        $namequery = '';
        $where = [];
        $queryParam = [];
 
        if ($name) {
            $where[] = 'name = :name';
            $queryParam['name'] = $name;
        }
        if ($type) {
            $where[] = 'type = :type';
            $queryParam['type'] = $type;
        }
        if (count($where) > 0) {
            $namequery = "WHERE " . implode(" AND ", $where);
        }
 
 
        $query = $this->pdo->prepare(
            "SELECT
                docs.name AS name,
                docs.id AS id,
                docs.rootid AS rootid,
                docs.type AS type
            FROM {$this->tableDocs} AS docs
                $namequery
            ORDER BY docs.name ASC"
        );
 
        $query->execute($queryParam);
 
        while ($doc = $query->fetchObject()) {
            $docs[$doc->name] = new Document($this, $doc->id);
        }
 
        return $docs;
    }

    public function getDoc($docIdOrName)
    {
        $doc = false;
 
        if ($docId = $this->docExists($docIdOrName)) {
            $doc = new Document($this, $docId);
        }
 
        return $doc;
    }

    public function getDocByNodeId($nodeId)
    {
        $doc = false;
 
        $query = $this->pdo->prepare(
            "SELECT xml.id_doc AS id_doc
            FROM {$this->tableXml} AS xml
            WHERE xml.id = :nodeId"
        );
 
        $query->execute([
            'nodeId' => $nodeId,
        ]);
        $result = $query->fetchObject();
 
        if ($result && $docId = $this->docExists($result->id_doc)) {
            $doc = new Document($this, $docId);
        }
 
        return $doc;
    }

    public function getDocInfo($docIdOrName)
    {
        if ($doc = $this->getDoc($docIdOrName)) {
            return $doc->getDocInfo();
        }
 
        return false;
    }

    public function getDocXml($docIdOrName, $addIdAttribute = true)
    {
        $xml = false;
 
        if ($docId = $this->docExists($docIdOrName)) {
            $doc = new Document($this, $docId);
            $xml = $doc->getXml($addIdAttribute);
        }
 
        return $xml;
    }

    public function getDocXmlXpath($docIdOrName, $xpath, $addIdAttribute = true)
    {
        $xml = false;
 
        if ($docId = $this->docExists($docIdOrName)) {
            $doc = new Document($this, $docId);
            $xml = $doc->getSubdocByXpath($xpath, $addIdAttribute);
        }
 
        return $xml;
    }

    public function getSubdocByXpath($xpath, $addIdAttribute = true)
    {
        $subdoc = false;
        $ids = $this->getNodeIdsByXpath($xpath);
 
        if (isset($ids[0])) {
            $subdoc = $this->getDocByNodeId($ids[0])->getSubdocByNodeId($ids[0], $addIdAttribute);
        }
 
        return $subdoc;
    }

    public function getNodeIdsByXpath($xpath, $docId = null)
    {
        $fallback = false;
        $tableSql = [];
        $params = [];
        $condSql = [];
        $parser = new XpathParser();
        $xpathElements = $parser->parseXpathElements($xpath);
        $levels = count($xpathElements) - 1;
 
        foreach ($xpathElements as $level => $element) {
            if ($level == 0) {
                $tableSql[] = "SELECT l$levels.id FROM";
                if ($element->divider == '/') {
                    $condSql[] = "l0.id_parent IS NULL";
                }
            } else {
                $tableSql[] = 'INNER JOIN';
                if ($element->divider == '/' && !$fallback) {
                    $parentLevel = $level - 1;
                    $condSql[] = "l$level.id_parent = l$parentLevel.id";
                } else {
                    $fallback = true;
                }
            }
 
            $tableSql[] = "{$this->tableXml} AS l$level";
            $op = $parser->getConditionOperator($element->namespace, $element->name);
            $condSql[] = "l$level.name $op :name$level";
            $params["name$level"] = $parser->translateName($element->namespace, $element->name);
 
            $hasPosition = $parser->parsePosition($element->condition);
 
            if ($hasPosition) {
                $fallback = true;
            } elseif ($element->condition != '') {
                if ($attributes = $parser->parseAttributes($element->condition)) {
                    // fetch by simple attributes: "ns:name[@attr1] ..."
                    $attributeCond = '';
                    foreach ($attributes as $i => $attribute) {
                        [$name, $operator, $value, $bool] = $attribute;
 
                        if ($bool) {
                            $attributeCond .= $parser->cleanOperator($bool);
                        }
 
                        if ($name == 'db:id') {
                            $attributeOperator = $parser->cleanOperator($operator);
                            $attributeCond .= " l$level.id {$parser->cleanOperator($operator)} :attr{$level}n{$i} ";
                            $params["attr{$level}n{$i}"] = $value;
                        } elseif ($operator == '=' || $operator == '') {
                            $attributeCond .= " l$level.value REGEXP :attr{$level}n{$i} ";
                            $regExValue = (is_null($value)) ? '.*' : $value;
                            $params["attr{$level}n{$i}"] = "(^| )$name=\"$regExValue\"( |$)";
                        } else {
                            $fallback = true;
                        }
                    }
 
                    if (!empty($attributeCond)) {
                        $condSql[] = $attributeCond;
                    }
                } else {
                    $fallback = true;
                }
            }
 
            if ($level == 0 && !is_null($docId)) {
                $condSql[] = "l$level.id_doc = :docid$level";
                $params["docid$level"] = $docId;
            }
        }
 
        $ids = [];
 
        if ($xpathElements) {
            if ($fallback) {
                $tableSql[0] = "SELECT DISTINCT l$level.id_doc FROM";
            }
            $where = '';
            if (!empty($condSql)) {
                $where = ' WHERE (' . implode(') AND (', $condSql) . ')';
            }
 
            $sql = implode(' ', $tableSql) . "$where ORDER BY l$level.id_parent, l$level.pos";
 
            $query = $this->pdo->prepare($sql);
            $query->execute($params);
 
 
            foreach ($query->fetchAll() as $result) {
                $ids[] = $result[0];
            }
        } else {
            $fallback = true;
 
            foreach ($this->getDocuments() as $doc) {
                $ids[] = $doc->getDocId();
            }
        }
 
        if ($fallback) {
            if (is_null($docId)) {
                $docIds = $ids;
            } else {
                $docIds = [$docId];
            }
            $nodeIds = $this->getNodeIdsByXpathDom($xpath, $docIds);
        } else {
            $nodeIds = $ids;
        }
 
        return $nodeIds;
    }
    protected function getNodeIdsByXpathDom($xpath, $docs = [])
    {
        $ids = [];
 
        foreach ($docs as $doc) {
            $domXpath = new \DomXpath($this->getDoc($doc)->getXml());
            $list = $domXpath->query($xpath);
            foreach ($list as $item) {
                $ids[] = $item->attributes->getNamedItem('id')->nodeValue;
            }
        }
 
        return $ids;
    }

    public function getIndexNodeData($nodeIds)
    {
        $nodeIds = array_values(array_unique(array_map('intval', $nodeIds)));
 
        $nodeData = [];
        if (empty($nodeIds)) {
            return $nodeData;
        }
 
        $query = $this->pdo->prepare(
            "SELECT xml.id, xml.id_doc, xml.type, xml.value
            FROM {$this->tableXml} AS xml
            WHERE xml.id IN (" . implode(", ", $nodeIds) . ")",
        );
        $query->execute();
 
        foreach ($query->fetchAll(\PDO::FETCH_OBJ) as $row) {
            $nodeData[(int) $row->id] = [
                'doc_id' => (int) $row->id_doc,
                'attributes' => ($row->type == 'ELEMENT_NODE')
                    ? Document::parseAttributeString($row->value)
                    : [],
            ];
        }
 
        return $nodeData;
    }

    public function getIndexTextContent($nodeIds)
    {
        $nodeIds = array_values(array_unique(array_map('intval', $nodeIds)));
 
        $texts = [];
        if (empty($nodeIds)) {
            return $texts;
        }
 
        $pad = Document::SORTKEY_PAD;
        $query = $this->pdo->prepare(
            Helpers\TreeSql::descendants($this->tableXml, "id IN (" . implode(", ", $nodeIds) . ")", $pad) . "
            SELECT tree.root_id, xml.value
            FROM tree INNER JOIN {$this->tableXml} AS xml ON xml.id = tree.id
            WHERE xml.type = 'TEXT_NODE'
            ORDER BY tree.root_id ASC, tree.sortkey ASC",
        );
        $query->execute();
 
        foreach ($query->fetchAll(\PDO::FETCH_OBJ) as $row) {
            $rootId = (int) $row->root_id;
 
            $texts[$rootId] = ($texts[$rootId] ?? '') . $row->value;
        }
 
        return $texts;
    }

    public function createDoc($doctype = 'Depage\XmlDb\XmlDoctypes\Base', $docName = null)
    {
        if (is_null($docName)) {
            // generate generic docname based on doctype
            $docName = '_' . substr($doctype, strrpos($doctype, "\\") + 1) . '_' . sha1(uniqid(dechex(mt_rand(256, 4095))));
        }
        if (!is_string($docName) || $this->docExists($docName)) {
            throw new XmlDbException("Invalid or duplicate document name \"$docName\"");
        }
 
        $query = $this->pdo->prepare(
            "INSERT {$this->tableDocs} SET name = :name, type = :type, ns = '', entities = ''"
        );
        $query->execute([
            'name' => $docName,
            'type' => $doctype,
        ]);
 
        $docId = $this->pdo->lastInsertId();
        $document = new Document($this, $docId);
 
        return $document;
    }

    public function duplicateDoc($docNameOrId, $newName = null)
    {
        $copy = false;
        $original = $this->getDoc($docNameOrId);
 
        if ($original !== false) {
            $info = $original->getDocInfo();
            $xml = $original->getXml(false);
 
            $copy = $this->createDoc($info->type, $newName);
            $copy->save($xml);
        }
 
        return $copy;
    }

    public function removeDoc($docId)
    {
        $result = false;
        $docId = $this->docExists($docId);
 
        if ($docId !== false) {
            $query = $this->pdo->prepare(
                "DELETE
                FROM {$this->tableDocs}
                WHERE id = :doc_id"
            );
            $query->execute([
                'doc_id' => $docId,
            ]);
 
            $this->cache->delete(Helpers\CacheKey::forDocument($this->tableDocs, $docId));
 
            $this->docIds = array_filter(
                $this->docIds,
                function ($id) use ($docId) {
                    return $id != $docId;
                }
            );
 
            $result = true;
        }
 
        return $result;
    }

    public function updateSchema()
    {
        $schema = new \Depage\Db\Schema($this->pdo);
 
        $pdoPrefix = $this->pdo->prefix;
        $tablePrefix = $this->tablePrefix;
 
        $schema->setReplace(
            function ($tableName) use ($pdoPrefix, $tablePrefix) {
                if ($tableName == '_auth_user') {
                    return $pdoPrefix . $tableName;
                } else {
                    return $tablePrefix . $tableName;
                }
            }
        );
 
        $this->pdo->exec('SET FOREIGN_KEY_CHECKS=0;');
 
        // schema for xmlDb
        $schema->loadGlob(__DIR__ . '/Sql/*.sql');
        $schema->update();
 
        $this->pdo->exec('SET FOREIGN_KEY_CHECKS=1;');
    }

    public function clearTables()
    {
        $this->pdo->query("DELETE FROM `{$this->tableDocs}`;");
        //$this->pdo->query("ALTER TABLE `{$this->tableDocs}` AUTO_INCREMENT = 1;");
 
        $this->docIds = [];
    }

    public function beginTransactionAltering()
    {
        $this->alteringTransaction = true;
 
        return $this->beginTransactionNonAltering();
    }

    public function beginTransactionNonAltering()
    {
        if ($this->transactions == 0) {
            $this->beginPdoTransaction();
        } else {
            $this->createSavepoint($this->transactions);
        }
        $this->transactions++;
 
        return $this->transactions;
    }

    public function endTransaction()
    {
        $altered = false;
        $this->transactions--;
 
        if ($this->transactions == 0) {
            $this->commitPdoTransaction();
 
            $altered = $this->alteringTransaction;
            $this->alteringTransaction = false;
        } else {
            $this->releaseSavepoint($this->transactions);
        }
 
        return $altered;
    }

    public function rollBackTransaction()
    {
        if ($this->transactions == 0) {
            return false;
        }
 
        $this->transactions--;
 
        if ($this->transactions == 0) {
            $this->rollBackPdoTransaction();
            $this->alteringTransaction = false;
        } else {
            $this->rollbackToSavepoint($this->transactions);
            $this->releaseSavepoint($this->transactions);
        }
 
        return true;
    }

    public function rollBack()
    {
        $this->transactions = 0;
        $this->alteringTransaction = false;
 
        return $this->rollBackPdoTransaction();
    }
 
    protected function beginPdoTransaction()
    {
        $this->pdo->beginTransaction();
    }
    protected function commitPdoTransaction()
    {
        $this->pdo->commit();
    }
    protected function rollBackPdoTransaction()
    {
        $rolledBack = false;
 
        if ($this->pdo->inTransaction()) {
            $this->pdo->rollBack();
            $rolledBack = true;
        }
 
        return $rolledBack;
    }
    protected function createSavepoint($level)
    {
        if ($this->pdo->inTransaction()) {
            $this->pdo->exec('SAVEPOINT xmldb_sp_' . (int) $level);
        }
    }
    protected function releaseSavepoint($level)
    {
        if ($this->pdo->inTransaction()) {
            $this->pdo->exec('RELEASE SAVEPOINT xmldb_sp_' . (int) $level);
        }
    }
    protected function rollbackToSavepoint($level)
    {
        if ($this->pdo->inTransaction()) {
            $this->pdo->exec('ROLLBACK TO SAVEPOINT xmldb_sp_' . (int) $level);
        }
    }
}
 
/* vim:set ft=php sw=4 sts=4 fdm=marker et : */