1

我在使用 MySQL 时遇到了嵌套集模型的问题。我可以插入、删除、移动子树到另一个父级，一切正常。

但我不知道如何订购兄弟姐妹。例如，我有这些兄弟姐妹：

甲、乙、丙、丁、乙

我想在 D 之后移动 B，得到这个：

A、C、D、B、E

我发现了大量用于插入、删除等的存储过程，但没有一个可以订购兄弟姐妹。我发现的唯一一个是交换兄弟姐妹的程序，但这不是我想要实现的。

我尝试编写自己的，但它似乎很复杂，并且并非在所有情况下都有效。

如果您知道如何在他的兄弟姐妹之一之前或之后移动节点，我们将不胜感激。

4

2 回答 2

5

所以...我重写了所有内容，这是一个存储过程，可以很好地在他的兄弟姐妹之一之后移动一个节点。如果我们想将节点移动到第一个位置，只需传递父 id 代替兄弟 id。

DELIMITER |
-- sibling parameter is either :
-- - the sibling id after which we want to put the page
-- - the parent id if we want to put the page on the first position
CREATE PROCEDURE move_after_sibling (IN to_move_id INT(10), IN parent_id INT(10), IN sibling_id INT(10))
LANGUAGE SQL
DETERMINISTIC
BEGIN
    DECLARE to_move_lft INT(10);
    DECLARE to_move_rgt INT(10);
    DECLARE parent_lft INT(10);
    DECLARE parent_rgt INT(10);
    DECLARE sibling_lft INT(10);
    DECLARE sibling_rgt INT(10);

    SET to_move_lft = (SELECT lft FROM pages WHERE id = to_move_id);
    SET to_move_rgt = (SELECT rgt FROM pages WHERE id = to_move_id);
    SET parent_lft = (SELECT lft FROM pages WHERE id = parent_id);
    SET parent_rgt = (SELECT rgt FROM pages WHERE id = parent_id);
    SET sibling_lft = (SELECT lft FROM pages WHERE id = sibling_id);
    SET sibling_rgt = (SELECT rgt FROM pages WHERE id = sibling_id);

    UPDATE pages 
        SET
            lft = 
                CASE 
                    WHEN sibling_id = parent_id THEN
                        CASE
                            WHEN lft BETWEEN parent_lft+1 AND to_move_lft-1 THEN
                                lft + (to_move_rgt - to_move_lft) + 1
                            WHEN lft BETWEEN to_move_lft AND to_move_rgt THEN 
                                lft - (to_move_lft - (parent_lft + 1))
                            ELSE
                                lft
                        END
                    ELSE
                        CASE 
                            WHEN to_move_lft > sibling_lft THEN
                                CASE
                                    WHEN lft BETWEEN sibling_rgt AND to_move_lft-1 THEN
                                        lft + (to_move_rgt - to_move_lft) + 1
                                    WHEN lft BETWEEN to_move_lft AND to_move_rgt THEN 
                                        lft - (to_move_lft - (sibling_rgt + 1))
                                    ELSE
                                        lft
                                END
                            ELSE
                                CASE
                                    WHEN lft BETWEEN to_move_rgt+1 AND sibling_rgt THEN
                                        lft - ((to_move_rgt - to_move_lft) + 1)
                                    WHEN lft BETWEEN to_move_lft AND to_move_rgt THEN 
                                        lft + (sibling_rgt - to_move_rgt)
                                    ELSE
                                        lft
                                END
                        END
                END,
            rgt = 
                CASE 
                    WHEN sibling_id = parent_id THEN
                        CASE
                            WHEN rgt BETWEEN parent_lft+1 AND to_move_lft-1 THEN
                                rgt + (to_move_rgt - to_move_lft) + 1
                            WHEN rgt BETWEEN to_move_lft AND to_move_rgt THEN 
                                rgt - (to_move_lft - (parent_lft + 1))
                            ELSE
                                rgt
                        END
                    ELSE
                        CASE 
                            WHEN to_move_rgt > sibling_lft THEN
                                CASE
                                    WHEN rgt BETWEEN sibling_rgt+1 AND to_move_lft-1 THEN
                                        rgt + (to_move_rgt - to_move_lft) + 1
                                    WHEN rgt BETWEEN to_move_lft AND to_move_rgt THEN 
                                        rgt - (to_move_lft - (sibling_rgt + 1))
                                    ELSE
                                        rgt
                                END
                            ELSE
                                CASE
                                    WHEN rgt BETWEEN to_move_rgt+1 AND sibling_rgt+1 THEN
                                        rgt - ((to_move_rgt - to_move_lft) + 1)
                                    WHEN rgt BETWEEN to_move_lft AND to_move_rgt THEN 
                                        rgt + (sibling_rgt - to_move_rgt)
                                    ELSE
                                        rgt
                                END
                        END
                END
        WHERE lft BETWEEN parent_lft+1 AND parent_rgt;
END
|
DELIMITER ;

也许这不是我们见过的最漂亮的代码，但它运行良好，并且可能比任何类型的排序算法都高效得多，例如。

于 2011-05-14T10:29:23.680 回答
0

我发现，在使用触发器处理嵌套集时，最好：

  1. 使用 before 触发器根据需要锁定行以避免并发问题。
  2. 使用 after 触发器重新索引，以解决与批量插入/批量更新相关的问题。
  3. 在重新索引任何内容之前，等待最后一个触发器触发。
  4. 如果此时，您检测到一个语句插入/移动了多个节点，则完全重新索引适用范围 - 这样做比多次重新索引树的整个块要快得多。

特别是对于您的问题，如果我做对了，您将使用存储过程一个一个地移动节点。这与更改节点的父节点没有太大区别：找到它的新 lft/rgt 索引并将其（及其子节点）相应地向左或向右移动。如果 lft/rgt 值向右移动，请不要忘记偏移它。

顺便说一句，我怀疑您才刚刚开始确定需要解决的潜在问题。根据我的经验，使用单个更新的节点排列是最棘手的，例如：

A - B - C

D - E - F

到：

B - E - C

A - D - F
于 2011-05-14T09:47:46.610 回答