Positions.php

Go to the documentation of this file.

<?php

 
namespace Depage\XmlDb\Helpers;
 
use Depage\XmlDb\Exceptions\XmlDbException;

class Positions
{
    public const POS_GAP = 65536;

    public const POS_MIN_GAP = 16;

    public const SCRATCH_OFFSET = 1125899906842624;
 
    protected $pdo;

    public function __construct(
        $pdo,
        protected string $table,
        protected $docId,
        protected int $batchSize = CaseUpdate::DEFAULT_SIZE
    ) {
        $this->pdo = $pdo;
    }

    public function siblings($parentId): array
    {
        $query = $this->pdo->prepare(
            "SELECT xml.id, xml.pos
            FROM {$this->table} AS xml
            WHERE xml.id_parent = :parent_id AND xml.id_doc = :doc_id
            ORDER BY xml.pos ASC, xml.id ASC",
        );
        $query->execute([
            'parent_id' => $parentId,
            'doc_id' => $this->docId,
        ]);
 
        return $query->fetchAll(\PDO::FETCH_OBJ);
    }

    private function siblingsWithout($parentId, $excludeId = null): array
    {
        $siblings = $this->siblings($parentId);
 
        if (!is_null($excludeId)) {
            foreach ($siblings as $i => $sibling) {
                if ($sibling->id == $excludeId) {
                    unset($siblings[$i]);
                    $siblings = array_values($siblings);
                    break;
                }
            }
        }
 
        return $siblings;
    }

    private function clampIndex($targetIndex, int $numSiblings): int
    {
        if (!is_numeric($targetIndex) || (int) $targetIndex < 0) {
            return $numSiblings;
        }
 
        return min((int) $targetIndex, $numSiblings);
    }

    public function normalizeIndex($parentId, $targetIndex, $excludeId = null)
    {
        return $this->clampIndex(
            $targetIndex,
            count($this->siblingsWithout($parentId, $excludeId))
        );
    }

    public function indexById($id)
    {
        $query = $this->pdo->prepare(
            "SELECT xml.id_parent, xml.pos
            FROM {$this->table} AS xml
            WHERE xml.id = :id AND xml.id_doc = :doc_id
            LIMIT 1",
        );
        $query->execute([
            'id' => $id,
            'doc_id' => $this->docId,
        ]);
 
        if (!($node = $query->fetchObject())) {
            return false;
        }
 
        $query = $this->pdo->prepare(
            "SELECT COUNT(*) AS sibling_index
            FROM {$this->table} AS xml
            WHERE xml.id_parent = :parent_id AND xml.id_doc = :doc_id AND xml.pos < :pos",
        );
        $query->execute([
            'parent_id' => $node->id_parent,
            'pos' => $node->pos,
            'doc_id' => $this->docId,
        ]);
        $result = $query->fetchObject();
 
        return (int) $result->sibling_index;
    }

    public function appendIndex($parentId)
    {
        $query = $this->pdo->prepare(
            "SELECT COUNT(*) AS pos
            FROM {$this->table} AS xml
            WHERE xml.id_parent = :target_id AND id_doc = :doc_id",
        );
        $query->execute([
            'target_id' => $parentId,
            'doc_id' => $this->docId,
        ]);
 
        if ($object = $query->fetchObject()) {
            $result = $object->pos;
        } else {
            $result = null;
        }
 
        return $result;
    }

    public function positionForIndex($parentId, $index, $excludeId = null)
    {
        $siblings = $this->siblingsWithout($parentId, $excludeId);
 
        $numSiblings = count($siblings);
        $index = $this->clampIndex($index, $numSiblings);
 
        if ($index >= $numSiblings) {
            // appending does not need room between two neighbours
            $lastPos = $numSiblings > 0 ? (int) $siblings[$numSiblings - 1]->pos : 0;
 
            return $lastPos + self::POS_GAP;
        }
 
        $prevPos = $index > 0 ? (int) $siblings[$index - 1]->pos : 0;
        $nextPos = (int) $siblings[$index]->pos;
 
        if ($nextPos - $prevPos - 1 < self::POS_MIN_GAP) {
            $this->rebalance($parentId);
 
            return $this->positionForIndex($parentId, $index, $excludeId);
        }
 
        return intdiv($prevPos + $nextPos, 2);
    }

    public function rebalance($parentId, $order = null): void
    {
        $siblings = $this->siblings($parentId);
 
        if (count($siblings) == 0) {
            return;
        }
 
        $current = [];
        foreach ($siblings as $sibling) {
            $current[] = (int) $sibling->id;
        }
 
        if (is_null($order)) {
            // keep the order that is stored in the database
            $ids = $current;
        } else {
            // reorder into the given child order (used by the patch
            // applier)
            $ids = array_map('intval', $order);
 
            if (count($ids) != count($current) || array_diff($ids, $current) || array_diff($current, $ids)) {
                throw new XmlDbException("Can not reorder the children of node {$parentId}, the node list does not match.");
            }
        }
 
        // the unique sibling index is checked row by row, so the positions
        // have to be moved out of the way first: adding a big offset in
        // descending order cannot collide with a sibling that has not
        // been updated yet, and the offset is big enough to keep the
        // scratch positions clear of the final positions that are
        // assigned in the update below
        $this->pdo->exec(
            "UPDATE {$this->table}
            SET pos = pos + " . self::SCRATCH_OFFSET . "
            WHERE id_doc = " . (int) $this->docId . " AND id_parent = " . (int) $parentId . "
            ORDER BY pos DESC"
        );
 
        // every sibling gets a position of its own, so writing the final
        // positions in batches cannot collide with the unique sibling
        // index either
        $positions = new CaseUpdate($this->pdo, $this->table, $this->batchSize);
        foreach ($ids as $index => $id) {
            $positions->add($id, ($index + 1) * self::POS_GAP);
        }
        $positions->write('pos', ['id_doc' => $this->docId]);
    }
}
 
/* vim:set ft=php sw=4 sts=4 fdm=marker et : */