在嵌套集树中移动节点

Question

我正在使用 mySQL 处理邻接列表，但无法（至少我自己）进行足够合理的查询所需的思考，以便能够移动一组节点（以及最终的子节点）。

该表包含以下列：

 id     name     left     right

非常感谢！

Answer 1

这是一个解决方案，让您只需使用一个输入参数即可将节点移动到树中的任何位置 - 节点的新左侧位置 (newpos)。

基本上分为三组：

• 为子树创建新空间。
• 将子树移动到该空间中。
• 删除子树腾出的旧空间。

在 psuedo-sql 中，它看起来像这样：

//
 *  -- create new space for subtree
 *  UPDATE tags SET lpos = lpos + :width WHERE lpos >= :newpos
 *  UPDATE tags SET rpos = rpos + :width WHERE rpos >= :newpos
 * 
 *  -- move subtree into new space
 *  UPDATE tags SET lpos = lpos + :distance, rpos = rpos + :distance
 *           WHERE lpos >= :tmppos AND rpos < :tmppos + :width
 * 
 *  -- remove old space vacated by subtree
 *  UPDATE tags SET lpos = lpos - :width WHERE lpos > :oldrpos
 *  UPDATE tags SET rpos = rpos - :width WHERE rpos > :oldrpos
 */

:distance 变量是新旧位置之间的距离，:width 是子树的大小，:tmppos 用于跟踪更新期间移动的子树。这些变量定义为：

// calculate position adjustment variables
int width = node.getRpos() - node.getLpos() + 1;
int distance = newpos - node.getLpos();
int tmppos = node.getLpos();
        
// backwards movement must account for new space
if (distance < 0) {
    distance -= width;
    tmppos += width;
}

有关完整的代码示例，请参阅我的博客

https://rogerkeays.com/how-to-move-a-node-in-nested-sets-with-sql

如果您喜欢这个解决方案，请投票。

Answer 2

我很确定该表使用嵌套集设计，而不是邻接列表。如果使用邻接列表，它将具有类似 parent_id 的列，而不是 left 和 right。

移动节点是嵌套集中的皇家 PITA。您必须为移动的每个节点重新编号所有 left 和 right 值。

如果移动子树，最简单的方法是一次删除一个节点，在每个节点删除后对 left 和 right 字段重新编号。然后，一旦您删除了整个子树（并以某种方式在应用程序中保留了子树的结构），请将子树重新插入到树中的目标位置，再次重新编号 left 和 <每次插入的 code>right 字段。

---

更新：我最近写了一篇关于如何在不同的分层数据设计中移动子树的博客，我比嵌套集更喜欢它。我将这种设计称为闭合表。
请参阅http://www.mysqlperformanceblog.com/ 2011/02/14/移动闭包表中的子树/

Answer 3

使用嵌套集模型（具有左列和右列）在类别树中移动子树的步骤是：
1. 将 lft 和 rgt 列转换为您想要移动的类别及其子类别的负对应项（这将暂时从树中“删除”子树）
2.如果要将子树向上移动（或在嵌套集合表示中“向左”移动），请将子树的新父级与其旧的左（或右，在第二种情况下）限制之间的所有类别向右移动，否则（向下移动子树时）向右。这涉及将这些类别的左列和右列设置为其值加上（或减去，在第二种情况下）子树（或要移动的类别）左列和右列之间的距离
3. 之后，您所要做的就是将左列和右列恢复为正值，同时减去（或在第二种情况下添加）其左极限与新父左列之间的差值（或者在第二种情况下在父级左极限和右极限之间）

这一切看起来都很复杂，用一种情况表达，所以我将其分解为两种情况：

$step = 1+ $this->_categoriesTable->rgt
                - $this->_categoriesTable->lft;
$lft = $this->_categoriesTable->lft;
$rgt = $this->_categoriesTable->rgt;
$id = $this->_categoriesTable->id;
$distance = $lft - $parentLeft - 1;
                $query = '
                    UPDATE %s SET lft=-lft, rgt=-rgt
                        WHERE lft>=%d AND lft<=%d;
                    UPDATE %s SET lft=lft+%d WHERE lft>%d AND lft<%d;
                    UPDATE %s SET rgt=rgt+%d WHERE rgt>%d AND rgt<%d;
                    UPDATE %s SET lft=-lft-%d, rgt=-rgt-%d WHERE lft<=-%d
                        AND lft>=-%d;
                    UPDATE %s SET parent_id=%d, title=%s, description=%s,
                        metadescription=%s WHERE id=%s';

                $query = sprintf($query,
                    $this->_db->nameQuote('#__categories'),
                        $lft, $rgt,
                    $this->_db->nameQuote('#__categories'), $step,
                        $parentLeft, $lft,
                    $this->_db->nameQuote('#__categories'), $step,
                        $parentLeft, $lft,
                    $this->_db->nameQuote('#__categories'), $distance,
                        $distance, $lft, $rgt,
                    $this->_db->nameQuote('#__categories'),
                        $data['parent_id'], 
                        $this->_db->Quote($this->_categoriesTable->title),
                        $this->_db->Quote($this->_categoriesTable->description),
                        $this->_db->Quote(
                            $this->_categoriesTable->metadescription),
                        $this->_db->Quote($id));

// and for the moving to the "right" case
$step = 1+ $this->_categoriesTable->rgt
                - $this->_categoriesTable->lft;
$distance = $parentLeft - $this->_categoriesTable->rgt;

// Memorize this because we bind and we need the old values
$lft = $this->_categoriesTable->lft;
$rgt = $this->_categoriesTable->rgt;
$id = $this->_categoriesTable->id;

$query = sprintf($query,
                    $this->_db->nameQuote('#__categories'),
                        $lft, $rgt,
                    $this->_db->nameQuote('#__categories'), $step,
                        $rgt, $parentLeft,
                    $this->_db->nameQuote('#__categories'), $step,
                        $rgt, $parentLeft,
                    $this->_db->nameQuote('#__categories'), $distance,
                        $distance, $lft, $rgt,
                    $this->_db->nameQuote('#__categories'),
                        $data['parent_id'],
                        $this->_db->Quote($this->_categoriesTable->title),
                        $this->_db->Quote($this->_categoriesTable->description),
                        $this->_db->Quote(
                            $this->_categoriesTable->metadescription),
                        $this->_db->Quote($id));

Answer 4

我有一个更简单、更容易阅读的sql，它非常适合我。它形成了一个典型的嵌套集合结构，包含 id、rgt、lft、level（也可以在没有 level 的情况下工作）：

#Set IDs
SET @dirId := :dirId; #folder (subtree) you wanna move
SET @targetId := :folderId; #target

#get datas
SELECT rgt, lft, rgt-lft+1, level INTO @dir_rgt, @dir_lft, @dir_size, @dir_level FROM files WHERE id = @dirId;

#put the moving tree aside (lft and rgt columns must allow negative int)
UPDATE files SET lft = 0-lft, rgt = 0-rgt WHERE lft BETWEEN @dir_lft AND @dir_rgt;

#fill the empty space        
UPDATE files SET rgt = rgt-@dir_size WHERE rgt > @dir_rgt;
UPDATE files SET lft = lft-@dir_size WHERE lft > @dir_rgt;

#get datas of the target-folder      
SELECT lft, level INTO @target_lft, @target_level FROM files WHERE id = @targetId;

#create space in the target-folder        
UPDATE files SET rgt = rgt+@dir_size WHERE rgt >= @target_lft;
UPDATE files SET lft = lft+@dir_size WHERE lft > @target_lft;

#edit all nodes in the moving-tree
UPDATE files SET
   lft     = 0 - lft - (@dir_lft - @target_lft - 1), #this formula fits for all moving directions
   rgt     = 0 - rgt - (@dir_lft - @target_lft - 1), 
   level   = level - (@dir_level - @target_level) + 1

WHERE 
   lft < 0; #that could be more precise...

Answer 5

当您从数学角度思考时，您可以使用单个 UPDATE 语句来完成这一切。对于任何移动操作，当您知道节点的左侧和右侧以及希望其最终到达的插入位置时，您可以一次性重新计算树中的所有左侧和右侧。您只需要确保新位置不在移动节点本身内，这可以通过简单的 WHERE 子句来完成：

-- moves a subtree before the specified position
-- if the position is the rgt of a node, the subtree will be its last child
-- if the position is the lft of a node, the subtree will be inserted before
-- @param l the lft of the subtree to move
-- @param r the rgt of the subtree to move
-- @param p the position to move the subtree before
update tree
set
    lft = lft + if (:p > :r,
        if (:r < lft and lft < :p,
            :l - :r - 1,
            if (:l <= lft and lft < :r,
                :p - :r - 1,
                0
            )
        ),
        if (:p <= lft and lft < :l,
            :r - :l + 1,
            if (:l <= lft and lft < :r,
                :p - :l,
                0
            )
        )
    ),
    rgt = rgt + if (:p > :r,
        if (:r < rgt and rgt < :p,
            :l - :r - 1,
            if (:l < rgt and rgt <= :r,
                :p - :r - 1,
                0
            )
        ),
        if (:p <= rgt and rgt < :l,
            :r - :l + 1,
            if (:l < rgt and rgt <= :r,
                :p - :l,
                0
            )
        )
    )
where :r < :p or :p < :l;

请参阅 https://sedna-soft.de/articles/nested-sets-move-subtree/