排序sql树层次结构

Question

像这样对表格进行排序的最佳方法是什么：

CREATE TABLE category(
    id INT(10),
    parent_id INT(10),
    name VARCHAR(50)
);

INSERT INTO category (id, parent_id, name) VALUES
(1, 0, 'pizza'),        --node 1
(2, 0, 'burger'),       --node 2
(3, 0, 'coffee'),       --node 3
(4, 1, 'piperoni'),     --node 1.1
(5, 1, 'cheese'),       --node 1.2
(6, 1, 'vegetariana'),  --node 1.3
(7, 5, 'extra cheese'); --node 1.2.1

按id或name分层排序：
'pizza' //节点 1
'piperoni' //节点 1.1
'奶酪' //节点 1.2
'额外的奶酪' //节点 1.2.1
'vegetariana' //节点 1.3
'burger' //节点 2
'coffee' //节点 3

编辑：名称末尾的数字是为了更好地可视化结构，而不是用于排序。

编辑 2： 多次提到...name "cheese 1.2" 末尾的数字仅用于可视化目的，不用于排序.我把它们作为cmets移动了，太多人混淆了，对不起。

Answer 1

通过添加路径列和触发器，这可以相当容易地完成。

首先添加一个 varchar 列，该列将包含从根到节点的路径：

ALTER TABLE category ADD path VARCHAR(50) NULL;

然后添加一个触发器，计算插入时的路径：

（简单地将新的 id 与父路径连接起来）

CREATE TRIGGER set_path BEFORE INSERT ON category
  FOR EACH ROW SET NEW.path = 
  CONCAT(IFNULL((select path from category where id = NEW.parent_id), '0'), '.', New.id);

然后只需按路径选择顺序：

SELECT name, path FROM category ORDER BY path;

结果：

pizza         0.1
piperoni      0.1.4
cheese        0.1.5
extra cheese  0.1.5.7
vegetariana   0.1.6
burger        0.2
coffee        0.3

见fiddle。

这种方式维护成本也最低。路径字段在插入时隐藏，通过触发器计算。删除一个节点没有开销，因为该节点的所有子节点也都被删除了。唯一的问题是更新节点的 parent_id 时；好吧，不要那样做！ :)

Answer 2

嵌套树集与level 列相结合是一种非常好的技术，用于读取和排序基于树的结构。很容易选择一棵子树，将结果限制在某个级别，并在一个查询中进行排序。但是插入和删除整体的成本相对较高，因此如果您更频繁地查询数据然后写入它们并且读取性能很重要，则应该使用它。 （对于 50-100，移除、插入或移动元素的时间应该没有问题，即使是 1000 也应该没有问题）。

您存储的每个条目是 level 和 left 和 right 的值，在下面的示例中它是：(left,right,level) 如果您只想选择1.2 和它的后代你会做的：

 SELECT * FROM table WHERE left >=7 AND right <=16

如果您只想选择孩子，那么

 SELECT * FROM table WHERE left >=7 AND right <=16 AND level=2

如果你想排序，你可以这样做

 SELECT * FROM table WHERE left >=7 AND right <=16 ORDER BY left

在保持层次结构分组的同时按其他字段排序可能会出现问题，具体取决于您希望如何排序。

                               1 (0,17,0)
                                   |
                                   |
                   +---------------+---------------------------------------+
                   |                                                       |
              1.1 (1,6,1)                                            1.2 (7,16,1)
                   |                                                       |
      +------------+-------+                  +-------------------+--------+----------------+
      |                    |                  |                   |                         |
  1.1.1 (2,3,2)      1.1.2 (4,5,2)      1.2.1 (8,9,2)       1.2.2 (10,13,2)         1.2.2 (14,15,2)
                                                                  |
                                                                  |
                                                                  |
                                                            1.2.2.1 (11,12,3)

闭包表（用于完成，但我不建议您的用例使用）。它将所有路径存储在树中，因此如果您有许多级别，层次结构所需的存储空间将增长得非常快。

路径枚举在那里你存储每个元素的路径与条目/0/，/0/1/ 在那里查询路径很容易，但是对于排序它不是那么灵活。

对于少量的整体，我会使用 嵌套树集。 遗憾的是，我没有一个很好的参考页面来描述这些技术并进行比较。

Answer 3

如果只有 3 层嵌套，你可以这样做

SELECT c1.name FROM category as c1 LEFT JOIN category as c2
   ON c1.parent_id = c2.id OR (c1.parent_id = 0 AND c1.id = c2.id) 
   ORDER BY c2.parent_id, c2.id, c1.id; 

如果你有更多的嵌套级别，那就更棘手了

更多嵌套级别可以编写函数

delimiter ~
DROP FUNCTION getPriority~

CREATE FUNCTION getPriority (inID INT) RETURNS VARCHAR(255) DETERMINISTIC
begin
  DECLARE gParentID INT DEFAULT 0;
  DECLARE gPriority VARCHAR(255) DEFAULT '';
  SET gPriority = inID;
  SELECT parent_id INTO gParentID FROM category WHERE ID = inID;
  WHILE gParentID > 0 DO
    SET gPriority = CONCAT(gParentID, '.', gPriority);
    SELECT parent_id INTO gParentID FROM category WHERE ID = gParentID;
  END WHILE;
  RETURN gPriority;
end~

delimiter ;

所以我现在开始

SELECT * FROM category ORDER BY getPriority(ID);

我有

+------+-----------+--------------------+
| ID   | parent_id | name               |
+------+-----------+--------------------+
|    1 |         0 | pizza 1            |
|    4 |         1 | piperoni 1.1       |
|    5 |         1 | cheese 1.2         |
|    7 |         5 | extra cheese 1.2.1 |
|    6 |         1 | vegetariana 1.3    |
|    2 |         0 | burger 2           |
|    3 |         0 | coffee 3           |
+------+-----------+--------------------+

Answer 4

我认为每个人都在过度设计解决方案。如果您的目标确实由您的示例表示，例如在虚拟顶级 0 id 的 3 级中，这就足够了。

SELECT *
     , id AS SORT_KEY
  FROM category a
 WHERE parent_id = 0
UNION ALL
SELECT a.*
     , CONCAT(b.id, '.', a.id) AS SORT_KEY
  FROM category a
     , category b
 WHERE b.parent_id = 0
   and b.id = a.parent_id
UNION ALL
SELECT a.*
     , CONCAT(c.id,'.', b.id,'.', a.id) AS SORT_KEY
  FROM category a
     , category b
     , category c
 WHERE c.parent_id = 0
   and b.id = a.parent_id
   AND c.id = b.parent_id
ORDER BY sort_key

Answer 5

一种方法是使用单独的字符串字段来存储任何节点的完整路径。 您需要在每次插入/更新/删除操作时维护此字段。

你可以有如下的字段值

CREATE TABLE category(
    id INT(10),
    parent_id INT(10),
    name VARCHAR(50),
    path VARCHAR(255)
);

INSERT INTO category (id, parent_id, name, path) VALUES
(1, 0, 'pizza 1','|1|'),
(2, 0, 'burger 2','|2|'),
(3, 0, 'coffee 3','|3|'),
(4, 1, 'piperoni 1.1','|1||4|'),
(5, 1, 'cheese 1.2','|1||5|'),
(6, 1, 'vegetariana 1.3','|1||6|'),
(7, 5, 'extra cheese 1.2.1','|1||5||1|');

您需要按路径字段排序才能使树按正确的排序顺序。

SELECT * FROM `category` ORDER BY `path`;

见SqlFiddle Demo

这样您就不需要编程语言中的递归来以正确的排序顺序打印整个树。

Note:

此示例仅在您的最大 ID 为 9 时才有效，如 |1||11|将早于 |1||2|

要解决此问题，您需要根据您的应用程序预期的 ID 字段的最大值对构建字符串进行填充，如以下示例，预期最大值为 999（3 位）

|001||002|

---

根据我的经验，这个解决方案应该只适用于处理深度达到 7-8 级的树。

其他方式：Click Here

Answer 6

SQL

WITH CTE_Category
    AS
    (
      SELECT id, parent_id, name
      , RIGHT(name,CHARINDEX(' ',REVERSE(RTRIM(name)))-1) as ordername
      FROM Category 
    )

    SELECT id, parent_id, name FROM CTE_Category ORDER BY ordername

MySql

SELECT id, parent_id, name
FROM Category ORDER BY SUBSTRING_INDEX(name,' ',-1)

Answer 7

在 SQL 查询结束时尝试ORDER BY name , id。

这将按名称排序并使用 id 来解决任何关系。

Answer 8

SELECT * FROM category ORDER BY name, parent_id ASC