Question

我有这种情况使用Mysql上的递归查询在一个表上找到lv 2和lv3子... 数据库结构我使用：

id name parent
1    A    0
2    B    0
3    C    0
4    D    1
5    E    1
6    F    2
7    G    2
8    H    3
9    I    3
10   J    4
11   K    4

我期望的结果，当过滤数据时，id = 1，它将产生我期待的结果。

id name parent
4   D     1
5   E     1
10  J     4
11  K     4

或者这是插图。

我一直在寻找各处，并阅读http://mikehillyer.com/articles/managing-hierarchical-data-in-mysql/，但我没有找到我正在寻找的结果..任何帮助将不胜感激，谢谢

Answer 1

如果你想获得特定父母的所有等级孩子，那么你应该尝试这个

select  id,
        name,
        parent
from    (select * from tablename
         order by parent, id) tablename,
        (select @pv := '1') initialisation
where   find_in_set(parent, @pv) > 0
and     @pv := concat(@pv, ',', id)

Answer 2

试试这个，快得多

<div style="border-bottom: 1px solid; padding-bottom:10px; display: flex; flex-wrap: wrap; align-items: flex-end;">

    <h1 style="margin: 0;">
      This is my title
    </h1>
    
    <div style="
            margin-left: auto;
            font-size: small;
            padding: 0 0 4px 20px;
            font-style: italic;">
    	Published on Friday 11th August 2017 at 12:46 	
    </div>
		
</div>

<br>
<div style="border-bottom: 1px solid; padding-bottom:10px; display: flex; flex-wrap: wrap; align-items: flex-end;">

    <h1 style="margin: 0;">
      This is my big title - Bla bla bla   
    </h1>
    
    <div style="
            margin-left: auto;
            font-size: small;
            padding: 0 0 4px 20px;
            font-style: italic;">
    	Published on Friday 11th August 2017 at 12:46 	
    </div>
		
</div>

<br>
<div style="border-bottom: 1px solid; padding-bottom:10px; display: flex; flex-wrap: wrap; align-items: flex-end;">

    <h1 style="margin: 0;">
      This is my big title - Bla bla bla bla bla bla bla bla bla
    </h1>
    
    <div style="
            margin-left: auto;
            font-size: small;
            padding: 0 0 4px 20px;
            font-style: italic;">
    	Published on Friday 11th August 2017 at 12:46 	
    </div>
		
</div>

Answer 3

感谢@Manoj Rana your solution确实对我有很大帮助。但是我想在Hibernate的 createNativeQuery（）; 函数中使用此解决方案。由于：= 运算符，我无法使用。因此，我使用您的解决方案准备了新的存储过程，并在我的代码中使用了它。

您可以找到我在this link

中创建的存储过程

Answer 4

尝试一下，非常简单易懂。

（但仅支持一个层次结构级别）

SET @pv = 1;
select * from tablename 
where FIND_IN_SET(parentrecordID,@pv) and !isnull(@pv:= concat(@pv, ',', id));

Answer 5

我尝试过这个

select  id from  (select * from roles order by parent_role, id) roles,(select @pv := '1') initialisation
where   find_in_set(parent_role, @pv) > 0
and     @pv := concat(@pv, ',', id)

但是它仅适用于深度2，因为我有8个等级，我需要使其深度更深

Answer 6

您正在寻找的答案可能是这样； https://github.com/ersengultepe/mysql_hierarchy_recursive_procedure/

    DROP PROCEDURE IF EXISTS store_procedure_name;
CREATE PROCEDURE `store_procedure_name`(IN cat_id INT)
BEGIN
    declare loopId Int;
    SET max_sp_recursion_depth = 255;
    -- If the value of the category that comes as a parameter is not in the table as parent_id, no further action is required
    IF(select count(id) from category_table where parent_id=cat_id) > 0 THEN

    -- create temporary table
    CREATE TEMPORARY TABLE IF NOT EXISTS temp_category_table (
      `id` smallint(5) unsigned,
      `status` tinyint(3)
      ) ENGINE=InnoDB ;
    -- First, save the corresponding value in the temporary table.
    INSERT INTO temp_category_table
    (id, status) 
    VALUES (cat_id, 0);

    -- continue loop as long as the appropriate record exists in the temporary table
    WHILE (select count(id) from temp_category_table where status=0) > 0 DO 
      -- in this section, a record with a status of 0 will be extracted from the temporary table and assigned to the variable loopId
      set loopId = (select id from temp_category_table where status=0 limit 1);

      INSERT INTO temp_category_table
      (id, status)                                       
      (select id, 0 from category_table where parent_id=loopId);

      update temp_category_table set status=1 where id=loopId;

      CALL store_procedure_name((select id from temp_category_table where status=0 limit 1));     

    END WHILE;

    (select DISTINCT(id) from temp_category_table order by id ); 

    END IF;
END;

Answer 7

在我看来，在分层表结构中查找所有子节点的关键是首先找到父节点的路径，然后使用FIND_IN_SET查看请求的节点是否在路径中。向上搜索比向下搜索更容易也更有效，因为表中已经存在指向父项的链接。

所以让我们从这样的层次结构开始：

1 Pets
├─ 2 Dogs
│  ├─ 3 Katie
├─ 4 Cats
│  ├─ 5 George
│  ├─ 6 Pete
│  ├─ 7 Alice
├─ 8 Other
│  ├─ 9 Rabbits
│  │  ├─ 10 Noah
│  │  ├─ 11 Teddy
│  │  ├─ 12 Bella
│  ├─ 13 Rats
│  │  ├─ 14 Henry

现在您想找到类别 Other 下的所有子项（包括类别），那么预期结果将是：

8,9,10,11,12,13,14

现在我们来看看Henry的层次路径。 Henry (14) 的父对象是 Rats (13)，它有父对象 Other (8)，最后是 Pets (1).如果我们使用 ID 为 Henry 创建路径，它将如下所示：

1,8,13,14

这就是 MySQL 函数 FIND_IN_SET 发挥作用的地方。使用 FIND_IN_SET，您可以过滤结果，其中变量可以在逗号分隔的列表中找到。在此示例中，我们正在查找类别 Other (8) 中的所有子项，我们可以简单地使用 FIND_IN_SET(8, path)。

要获取分层表的路径，我想参考我在此处MySql: ORDER BY parent and child 的帖子中的回答。我们只需将破折号更改为逗号，以便我们可以使用 FIND_IN_SET 函数。

上面的例子在分层表中看起来像这样：

+----+--------+---------+
| id | parent | name    |
+----+--------+---------+
|  1 |   NULL | Pets    |
|  2 |      1 | Dogs    |
|  3 |      2 | Katie   |
|  4 |      1 | Cats    |
|  5 |      4 | George  |
|  6 |      4 | Pete    |
|  7 |      4 | Alice   |
|  8 |      1 | Other   |
|  9 |      8 | Rabbits |
| 10 |      9 | Noah    |
| 11 |      9 | Teddy   |
| 12 |      9 | Bella   |
| 13 |      8 | Rats    |
| 14 |     13 | Henry   |
+----+--------+---------+

在我的方法中，我将使用一个过程，该过程将递归调用自身，并继续在路径前面加上请求的 id 的父级，直到它到达 NULL 父级。

DELIMITER $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `PATH`(IN `input` INT, OUT `output` VARCHAR(128))
BEGIN

  DECLARE _id INT;
  DECLARE _parent INT;
  DECLARE _path VARCHAR(128);

  SET `max_sp_recursion_depth` = 50;

  SELECT `id`, `parent`
  INTO _id, _parent
  FROM `database`.`table`
  WHERE `table`.`id` = `input`;

  IF _parent IS NULL THEN
    SET _path = _id;
  ELSE
    CALL `PATH`(_parent, _path);
    SELECT CONCAT(_path, ',', _id) INTO _path;
  END IF;

  SELECT _path INTO `output`;

END $$
DELIMITER ;

我们需要在 SELECT 查询中使用这些结果，因此我们也需要一个 FUNCTION 来包装 PROCEDURE 的结果。

DELIMITER $$
CREATE DEFINER=`root`@`localhost` FUNCTION `GETPATH`(`input` INT) RETURNS VARCHAR(128)
BEGIN

  CALL `PATH`(`input`, @path);
  RETURN @path;

END $$
DELIMITER ;

现在我们可以在查询中使用路径。在一个有 10000 行的表上，在我的工作站上只需要一秒钟多。

SELECT `id`, `parent`, `name`, GETPATH(`id`) `path` FROM `database`.`table`;

示例输出：

+----+--------+---------+-----------+
| id | parent | name    | path      |
+----+--------+---------+-----------+
|  1 |   NULL | Pets    | 1         |
|  2 |      1 | Dogs    | 1,2       |
|  3 |      2 | Katie   | 1,2,3     |
|  4 |      1 | Cats    | 1,4       |
|  5 |      4 | George  | 1,4,5     |
|  6 |      4 | Pete    | 1,4,6     |
|  7 |      4 | Alice   | 1,4,7     |
|  8 |      1 | Other   | 1,8       |
|  9 |      8 | Rabbits | 1,8,9     |
| 10 |      9 | Noah    | 1,8,9,10  |
| 11 |      9 | Teddy   | 1,8,9,11  |
| 12 |      9 | Bella   | 1,8,9,12  |
| 13 |      8 | Rats    | 1,8,13    |
| 14 |     13 | Henry   | 1,8,13,14 |
+----+--------+---------+-----------+

为了找到 Other (8) 的所有子代，并且还包括 Other 本身，我们可以使用与 FIND_IN_SET 相同的查询和过滤器：

SELECT `id`, `parent`, `name`, GETPATH(`id`) `path` FROM `database`.`table` WHERE FIND_IN_SET(8, GETPATH(`id`));

最后是结果。我们在程序中设置了 50 级递归限制，但除此之外我们没有深度限制。

+----+--------+---------+-----------+
| id | parent | name    | path      |
+----+--------+---------+-----------+
|  8 |      1 | Other   | 1,8       |
|  9 |      8 | Rabbits | 1,8,9     |
| 10 |      9 | Noah    | 1,8,9,10  |
| 11 |      9 | Teddy   | 1,8,9,11  |
| 12 |      9 | Bella   | 1,8,9,12  |
| 13 |      8 | Rats    | 1,8,13    |
| 14 |     13 | Henry   | 1,8,13,14 |
+----+--------+---------+-----------+
7 rows in set (0,01 sec)

如果您想使用单个值而不是行，那么您可能需要像这样使用 GROUP_CONCAT：

SELECT GROUP_CONCAT(`id`) `children` FROM `database`.`table` WHERE FIND_IN_SET(8, GETPATH(`id`));

给你以下结果：

+--------------------+
| children           |
+--------------------+
| 8,9,10,11,12,13,14 |
+--------------------+
1 row in set (0,00 sec)

MySQL Recursive从父级获取所有子级

7 个答案: