MYSQL的（WITH RECURSIVE）递归使用

已于 2024-06-27 13:34:15 修改
阅读量1k 收藏 17
点赞数 22
分类专栏： 数据库 文章标签： mysql 数据库
于 2024-06-12 10:22:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gkqstd/article/details/139614098
版权

文章目录

1.定义

WITH RECURSIVE 是 SQL 中的一种高级查询结构，用于执行递归查询。递归查询是一种特殊的查询方式，它能够通过反复应用一个规则或算法，逐步构建出一个结果集，常用于解决层次化或树状数据结构的遍历问题。

WITH RECURSIVE 结构通常包含以下几个关键部分：

1. CTE（Common Table Expression，公用表表达式）：

语法：

WITH RECURSIVE cte_name (column_list) AS (
SELECT
	initial_query_result
UNION [ALL]
SELECT
	recursive_query
FROM
	cte_name
WHERE
	condition
)SELECT
	*
FROM
	cte_name;
  • WITH 关键字引入一个或多个 CTE。
  • RECURSIVE 关键字表明至少有一个CTE是递归的。
  • CTE 名称（cte_name）用于标识递归查询的临时结果集。
  • 列名列表（column_list）定义了 CTE 结果集中包含的列及其名称。
  • 初始查询（initial_query_result）提供递归过程的起点，即第一次迭代时使用的数据。
  • 递归部分（递归子查询）定义了如何将前一次迭代的结果作为输入，计算出下一次迭代的数据。
  • recursive_query:表示递归查询语句，应当与column_list中的列名对应。
  • condition:表示递归查询的终止条件，需要使用cte_name中的列进行判断。
  • SELECT * FROM cte_name：表示最终返回的查询结果集，可以通过cte_name查询表中的列名进行指定。

2.递归查询的结构

递归查询通常由两部分构成：初始化查询（非递归部分）和递归子查询（递归部分）。

  • 初始化查询：定义递归开始时的基础数据集，通常是与递归逻辑相关的最顶层数据或边界条件。
  • 递归子查询：定义如何根据前一次迭代的结果生成下一次迭代的数据。递归子查询通常包含对自身 CTE 名称的引用，以递归地应用相同的操作。

3.连接操作符：

递归查询的初始化查询和递归子查询通常通过 UNION 或 UNION ALL 连接起来，形成一个完整的递归查询表达式。
UNION 会去除结果集中的重复行，而 UNION ALL 不会去除重复，根据实际需求选择合适的连接操作符。

4.终止条件

递归查询必须有一个明确的终止条件，否则会无限循环下去。终止条件通常隐含在递归子查询的 WHERE 子句或其他逻辑中，当满足特定条件时，不再产生新的结果。

2.示例1

假设有一个员工表 employees，其中包含 id（员工ID）、name（员工姓名）、manager_id（上级经理ID），结构如下：

CREATE TABLE employees (
    id INT PRIMARY KEY,
    name VARCHAR(50),
    manager_id INT,
    FOREIGN KEY (manager_id) REFERENCES employees(id)
);

现在我们想查询出一个员工及其所有下属的完整层级关系。可以使用 WITH RECURSIVE 构建如下查询：

WITH RECURSIVE employee_hierarchy AS (
    -- 初始化查询：选取根节点（顶级经理，没有上级经理）
    SELECT id, name, manager_id, 1 AS level
    FROM employees
    WHERE manager_id IS NULL

    UNION ALL

    -- 递归子查询：根据上一层级结果，查找下一级员工
    SELECT e.id, e.name, e.manager_id, eh.level + 1
    FROM employees e
    JOIN employee_hierarchy eh ON e.manager_id = eh.id
)
SELECT * FROM employee_hierarchy;

在这个例子中：

  • employee_hierarchy 是 CTE 的名称。
  • 列名列表为 id, name, manager_id, level。
  • 初始化查询选择了所有没有上级经理（manager_id IS NULL）的员工作为递归的起点。
  • 递归子查询通过 JOIN 语句将 employee_hierarchy 与 employees 表连接起来，根据 manager_id 匹配关系找到下一层级的员工。同时，level 列每次递归时增加 1，表示员工在层级结构中的深度。
  • 最后，通过 SELECT * FROM employee_hierarchy 查询出最终的递归结果集。

总结起来，WITH RECURSIVE 的用法主要包括以下几个步骤：

  • 定义 CTE，指定 RECURSIVE 关键字。
  • 编写初始化查询和递归子查询，通过 UNION 或 UNION ALL 连接。
  • 确保递归子查询中包含终止条件，以避免无限递归。
  • 在主查询中引用 CTE 名称，获取递归查询的结果。

这种结构适用于解决各种层次化数据的遍历问题，如组织架构、目录结构、路径搜索、数列生成等。通过递归查询，可以简化复杂查询逻辑，提高代码可读性，并且在某些情况下比使用循环或其他编程语言结构更高效。

EXPLAIN

1.执行 EXPLAIN 命令：

将 WITH RECURSIVE 查询语句包裹在 EXPLAIN 关键字之后，运行该命令以获取查询执行计划。由于 WITH RECURSIVE 查询包含两个部分（初始化查询和递归子查询），您需要分别分析这两个部分。

EXPLAIN WITH RECURSIVE employee_hierarchy AS (
    SELECT id, name, manager_id, 1 AS level
    FROM employees
    WHERE manager_id IS NULL

    UNION ALL

    SELECT e.id, e.name, e.manager_id, eh.level + 1
    FROM employees e
    JOIN employee_hierarchy eh ON e.manager_id = eh.id
)
SELECT * FROM employee_hierarchy;

然而，MySQL 直接对包含 WITH 子句的查询使用EXPLAIN会有语法错误。为了分析递归查询，可以将递归查询转换为临时表（或者视图），然后对临时表进行 EXPLAIN 分析：

CREATE TEMPORARY TABLE temp_employee_hierarchy AS
WITH RECURSIVE employee_hierarchy AS (
    SELECT id, name, manager_id, 1 AS level
    FROM employees
    WHERE manager_id IS NULL

    UNION ALL

    SELECT e.id, e.name, e.manager_id, eh.level + 1
    FROM employees e
    JOIN employee_hierarchy eh ON e.manager_id = eh.id
)
SELECT * FROM employee_hierarchy;

EXPLAIN SELECT * FROM temp_employee_hierarchy;

请注意，这种方法仅能分析递归查询的最终结果集，无法直接分析递归过程中的各个步骤。若要详细了解递归过程中的索引使用情况，可能需要手动分解递归查询并分别进行 EXPLAIN 分析。

2.解读 EXPLAIN 输出：

EXPLAIN 命令的输出会显示查询的执行计划，重点关注以下几个关键列：

  • type：表示访问类型，从最好到最差的类型为 system > const >eq_ref> ref > fulltext > ref_or_null > index_merge > unique_subquery > index_subquery > range > index > ALL。理想情况下，应至少达到 range 级别，最好达到 ref 级别。如果为 ALL，表示全表扫描，没有使用索引。
  • key：显示实际使用的键或索引。如果为 NULL，表示未使用任何索引，需要优化。
  • extra：包含额外的信息，如 Using index 表示覆盖索引（无需回表），Using where 表示在索引检索后还需要过滤，Using filesort 和 Using temporary 表示需要额外排序或创建临时表，这些都是不太友好的值

对于上述示例，主要关注 employees 表的查询是否使用了索引，特别是 manager_id 字段上的索引。如果表上有适当的索引（如 manager_id 上的单列索引或复合索引），期望在 EXPLAIN 输出中看到 type 列显示为 ref 或更好的访问类型，并且 key 列显示实际使用的索引名。

3.优化建议：

如果发现查询未有效使用索引，可以尝试以下优化措施：

  • 检查索引：确认 employees 表上是否存在针对manager_id字段的索引。如果没有，应创建相应的索引。

  • 调整查询：确保查询条件和连接条件能够充分利用现有索引。例如，确保 WHERE 子句和 JOIN 条件中涉及的列都已建立索引。

  • 分析数据分布：如果表数据分布不均匀，即使存在索引，也可能导致查询优化器选择全表扫描。在这种情况下，可能需要重新评估索引设计或调整查询语句。

  • 调整查询：确保查询条件和连接条件能够充分利用现有索引。例如，确保 WHERE 子句和 JOIN 条件中涉及的列都已建立索引。

  • 分析数据分布：如果表数据分布不均匀，即使存在索引，也可能导致查询优化器选择全表扫描。在这种情况下，可能需要重新评估索引设计或调整查询语句。

综上所述，分析 WITH RECURSIVE 查询是否走索引，需通过 EXPLAIN 命令获取查询执行计划，并关注 type、key 和 extra 列。根据输出结果判断索引使用情况，并据此进行相应的优化。由于直接对递归查询使用 EXPLAIN 有局限性，可能需要采用变通方法（如创建临时表）或手动分解查询进行分析。

3.示例2

1.准备工作

① 首先准备一张递归表：这里使用用户邀请记录表，A可以邀请B，B可以邀请C，C可以…依次随意邀请。

在这里插入图片描述

--推广记录表
CREATE TABLE `sz_promotion_tree` ( `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
`user_id` bigint DEFAULT NULL COMMENT '用户id',
`parent_id` bigint DEFAULT NULL COMMENT '推荐者id',
`create_time` datetime DEFAULT NULL COMMENT '推广时间',
PRIMARY KEY (`id`),
KEY `user_id` (`user_id`)
	USING BTREE,
KEY `parent_id` (`parent_id`)
	USING BTREE) ENGINE = InnoDB AUTO_INCREMENT = 2 DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '推广记录表';

② 随便准备一张用户表 比如

--用户表
CREATE TABLE `sz_user` ( `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
`nickname` varchar(100) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '昵称',
PRIMARY KEY (`id`)) ENGINE = InnoDB AUTO_INCREMENT = 111 DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '用户表';

③ 造数据

INSERT
	INTO
	sz_user(id,
	nickname)
VALUES (99,
'S');

INSERT
	INTO
	sz_user(id,
	nickname)
VALUES (100,
'A');

INSERT
	INTO
	sz_user(id,
	nickname)
VALUES (101,
'B');

INSERT
	INTO
	sz_user(id,
	nickname)
VALUES (102,
'C');

INSERT
	INTO
	sz_user(id,
	nickname)
VALUES (103,
'D');

INSERT
	INTO
	sz_user(id,
	nickname)
VALUES (104,
'E');

INSERT
	INTO
	sz_user(id,
	nickname)
VALUES (105,
'F');

INSERT
	INTO
	sz_user(id,
	nickname)
VALUES (106,
'G');

INSERT
	INTO
	sz_user(id,
	nickname)
VALUES (107,
'H');

INSERT
	INTO
	sz_user(id,
	nickname)
VALUES (108,
'I');

INSERT
	INTO
	sz_user(id,
	nickname)
VALUES (109,
'J');
--------------------------------
INSERT
	INTO
	sz_promotion_tree(id,
	user_id,
	parent_id,
	create_time)
VALUES (1,
100,
99,
NULL);

INSERT
	INTO
	sz_promotion_tree(id,
	user_id,
	parent_id,
	create_time)
VALUES (2,
101,
100,
NULL);

INSERT
	INTO
	sz_promotion_tree(id,
	user_id,
	parent_id,
	create_time)
VALUES (3,
102,
100,
NULL);

INSERT
	INTO
	sz_promotion_tree(id,
	user_id,
	parent_id,
	create_time)
VALUES (4,
103,
101,
NULL);

INSERT
	INTO
	sz_promotion_tree(id,
	user_id,
	parent_id,
	create_time)
VALUES (5,
104,
101,
NULL);

INSERT
	INTO
	sz_promotion_tree(id,
	user_id,
	parent_id,
	create_time)
VALUES (6,
105,
102,
NULL);

INSERT
	INTO
	sz_promotion_tree(id,
	user_id,
	parent_id,
	create_time)
VALUES (7,
106,
102,
NULL);

INSERT
	INTO
	sz_promotion_tree(id,
	user_id,
	parent_id,
	create_time)
VALUES (8,
107,
103,
NULL);

INSERT
	INTO
	sz_promotion_tree(id,
	user_id,
	parent_id,
	create_time)
VALUES (9,
108,
103,
NULL);

INSERT
	INTO
	sz_promotion_tree(id,
	user_id,
	parent_id,
	create_time)
VALUES (10,
109,
104,
NULL);

造出来一份这样结构的关系：

  • S邀请了A，
    • A邀请了B、C，
      • B邀请了D、E，
        • D邀请了H、I，
        • E邀请了J

在这里插入图片描述

2. 向上递归

比如现在查询 J 109 的所有上级，并且还要查出，这些上级和 J 109 的关系是几级

WITH RECURSIVE promotion_tree AS (
SELECT
	id,
	user_id,
	parent_id,
	1 AS level
FROM
	sz_promotion_tree
WHERE
	user_id = 109
UNION ALL
SELECT
	pt.id,
	pt.user_id,
	pt.parent_id,
	pt2.level + 1
FROM
	sz_promotion_tree pt
JOIN promotion_tree pt2 ON
	pt.user_id = pt2.parent_id
WHERE
	pt.parent_id IS NOT NULL
)SELECT
	*
	FROM promotion_tree;

查询结果：
在这里插入图片描述

解析：

  • ① 首先，使用 WITH RECURSIVE 关键字声明了一个递归查询公共表表达式（CTE），命名为 promotion_tree。
  • ②在初始查询中，从 sz_promotion_tree 表中选择符合条件user_id = 109的记录，并为它们分配一个初始级别 1。这些记录作为递归查询的起始点。
  • ③ 使用 UNION ALL 运算符，将初始查询的结果与递归查询的结果连接起来。
  • ④ 在递归查询中，选择 sz_promotion_tree 表中的记录，连接到前一级的递归结果（promotion_tree），并通过条件 pt.user_id = pt2.parent_id 进行连接。这样可以构建一个向上层级递归的结构。
  • ⑤ 在递归查询的每一次迭代中，将前一级的层级 pt2.level 加上 1，并将结果作为当前级别 level。
  • ⑥ 递归查询继续迭代，直到不再满足条件 pt.parent_id IS NOT NULL，即没有上级用户时停止递归。
  • ⑦ 最后，从递归查询公共表表达式promotion_tree中选择所有列，并返回结果。

3.向下递归

如果再加一张消费记录表，每个人在平台的消费都会给记录到消费记录表中，比如A，A下面有B、C，A邀请的第一级有几个人，就算几个分支，现在需要查询出A下面有多少个分支，并且，每个分支的消费额（比如B分支，包含B和B的所有子节点）有多少。
准备数据：给刚才的A-I，每人插入一条1w的购物记录

CREATE TABLE `sz_order` ( `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
`user_id` bigint DEFAULT NULL COMMENT '用户id',
`recharge_amount` decimal(10,
2) DEFAULT NULL COMMENT '花费金额',
PRIMARY KEY (`id`)) ENGINE = InnoDB AUTO_INCREMENT = 1 DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '购买记录';

INSERT
	INTO
	sz_order(id,
	user_id,
	recharge_amount)
VALUES (8,
99,
10000);

INSERT
	INTO
	sz_order(id,
	user_id,
	recharge_amount)
VALUES (9,
100,
10000);

INSERT
	INTO
	sz_order(id,
	user_id,
	recharge_amount)
VALUES (10,
101,
10000);

INSERT
	INTO
	sz_order(id,
	user_id,
	recharge_amount)
VALUES (11,
102,
10000);

INSERT
	INTO
	sz_order(id,
	user_id,
	recharge_amount)
VALUES (12,
103,
10000);

INSERT
	INTO
	sz_order(id,
	user_id,
	recharge_amount)
VALUES (13,
104,
10000);

INSERT
	INTO
	sz_order(id,
	user_id,
	recharge_amount)
VALUES (14,
105,
10000);

INSERT
	INTO
	sz_order(id,
	user_id,
	recharge_amount)
VALUES (15,
106,
10000);

INSERT
	INTO
	sz_order(id,
	user_id,
	recharge_amount)
VALUES (16,
107,
10000);

INSERT
	INTO
	sz_order(id,
	user_id,
	recharge_amount)
VALUES (17,
108,
10000);

INSERT
	INTO
	sz_order(id,
	user_id,
	recharge_amount)
VALUES (18,
109,
10000);

解决：拿A100举例，他下面俩链路，B和C，分别对应6w和3w

WITH RECURSIVE promotion_tree AS (
SELECT
	id,
	user_id,
	parent_id,
	CAST(user_id AS CHAR(200)) AS chain
FROM
	sz_promotion_tree
WHERE
	parent_id = (
	SELECT
		user_id
	FROM
		sz_promotion_tree
	WHERE
		user_id = 100)
UNION ALL
SELECT
	pt.id,
	pt.user_id,
	pt.parent_id,
	CONCAT(pt2.chain, '->', pt.user_id)
FROM
	sz_promotion_tree pt
JOIN promotion_tree pt2 ON
	pt.parent_id = pt2.user_id),
chain_summary AS (
SELECT
	pt.chain,
	SUM(so.recharge_amount) AS total_amount
FROM
	promotion_tree pt
LEFT JOIN sz_order so ON
	pt.user_id = so.user_id
GROUP BY
	pt.chain
)SELECT
	pt.user_id,
	sum(cs.total_amount) as total_amountFROM promotion_tree ptleft
JOIN chain_summary cs ON
	cs.chain LIKE CONCAT(pt.chain, '%')
	WHERE pt.parent_id = (
	SELECT
		user_id
	FROM
		sz_promotion_tree
	WHERE
		user_id = 100)
	group by pt.user_id;

结果：

在这里插入图片描述
分析：

第一个递归的临时表promotion_tree结果：

在这里插入图片描述
第二个临时表chain_summary结果：

在这里插入图片描述
这两将两个表 使用关联查询，用chain 进行左模糊匹配来确定下级有哪些，最后再通过 user_id限定和分组，即可查询每个链路的金额。

4.注意事项

  • 1、递归的层数应该尽可能的少，过多的递归层数可能导致查询效率低下或者程序崩溃。

  • 2、MySQL with Recursive功能在MySQL 8.0版本中才被正式引入，使用该功能建议使用该版本或者以上版本。

  • 3、使用时需要考虑数据量的大小，如果数据量过大可能会影响递归查询的效率。

5.总结

MySQL with Recursive是一种基于递归思想的MySQL查询方式，可以实现对数据的递归查询和处理，应用广泛。在使用时需要注意递归的层数和数据量大小等因素。通过学习本文，相信大家已经对MySQL with Recursive有了深入的理解，并能够熟练运用该功能。

被拯救的威尼斯
关注
  • 22
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mysql with recursive 递归用法
诺浅的专栏
01-28 3183
with recursive 是一个递归的查询子句，他会把查询出来的结果再次代入到查询子句中继续查询。
MySQL实现递归查询的三种方式.rar
07-29
从MySQL 8.0开始，引入了`WITH RECURSIVE`子句，这是一种标准的SQL语法，专门用于执行递归查询。它允许在单个查询中定义一个临时的、可递归的表，这极大地简化了处理层次结构数据的过程。 ```sql WITH RECURSIVE ...
MySQL通过自定义函数实现递归查询父级ID或者子级ID
12-16
背 景: 在MySQL中如果是有限的层次，比如我们事先如果可以确定这个树的最大深度, 那么所有节点为根的树的深度均不会超过树的最大深度，则我们可以直接通过left join来实现。 但很多时候我们是无法控制或者是知道树的深度的。这时就需要在MySQL中用存储过程(函数)来实现或者在程序中使用递归来实现。本文讨论在MySQL中使用函数来实现的方法： 一、环境准备 1、建表 CREATE TABLE `table_name` ( `id` int(11) NOT NULL AUTO_INCREMENT, `status` int(255) NULL DEFAULT NULL, `pid`
一篇文章成为递归大神：MySQL递归查询（with recursive）
w13966597931的博客
09-24 2万+
文章包含了MySQL with Recursive 语法的概念，结合两个常用的查询案例，分析具体使用。 其中包括 向上递归案例，向下递归案例。 最后是 注意事项 和 总结
递归查询（WITH RECURSIVE）应用
weixin_44111939的博客
06-26 626
递归查询（WITH RECURSIVE）应用
SQL中WITH RECURSIVE的用法
LuckFairyLuckBaby的博客
04-18 1385
WITH RECURSIVE 是 SQL 中的一种高级查询结构，用于执行递归查询。递归查询是一种特殊的查询方式，它能够通过反复应用一个规则或算法，逐步构建出一个结果集，常用于解决层次化或树状数据结构的遍历问题。WITH RECURSIVE 结构通常包含以下几个关键部分：WITH 关键字引入一个或多个 CTE。ECURSIVE 关键字表明至少有一个 CTE 是递归的。CTE 名称（cte_name）用于标识递归查询的临时结果集。
with recursive用法
Apikaqiu的博客
07-27 1万+
with recursive--递归查询
mysql 递归函数with recursive的用法
热门推荐
mjfppxx的博客
05-25 2万+
with用法: 简单递归用法: 首先我们引出一个问题: 什么叫做递归? 递归:给定函数初始条件,然后反复调用自身直到终止条件. 例子1:递归得到依次递增的序列: WITH RECURSIVE cte (n) AS ( SELECT 1 UNION ALL SELECT n + 1 FROM cte WHERE n < 5 ) SELECT * FROM cte; 运行结果: +------+ | n | +------+ | 1 | | 2 | | 3 | |
with recursive 递归函数的用法
sgs6911的博客
09-13 3920
首先了解with用法，with相当于对sql的执行结果临时起一个别名，以便于之后的select使用。 with recursive tablename([col1]) as （SQL ） 这里目的是对SQL的执行结果赋给tablename，执行结果的字段类型和数量要和tablename声明的字段[col1]类型和数量一致 SQL的格式： 初始值 unionall 递归sql 初始值：可以是一个selectSQL也可以是具体值，同样这个值的字段数量、类型要与tabl...
【MYSQL WITH recursive使用】
sin_dapeng的博客
12-02 9120
MYSQL WITH recursive使用MYSQL WITH recursive使用语法用法1：输出1~n或者求 1~n的和用法2 父求子创建table：user求张三后代 MYSQL WITH recursive使用 由于在项目中有使用到recursive，因此在此做记录 语法 WITH recursive 表名 AS ( 初始语句（非递归部分） UNION ALL 递归部分语句 ) [ SELECT| INSERT | UPDATE | DELETE] 用法1：输出1~n或者求
教你如何使用MySQL8递归的方法
09-08
MySQL8的递归查询是通过Common Table Expressions (CTE)实现的，CTE是一种临时结果集，可以被后续的查询引用。递归查询在处理层次结构数据时特别有用，如树形结构。在MySQL 8.0版本以后，引入了递归查询的语法，使得...
SQL如何实现MYSQL的递归查询
01-19
众所周知，目前的mysql版本中并不支持直接的递归查询，但是通过递归到迭代转化的思路，还是可以在一句SQL内实现树的递归查询的。这个得益于Mysql允许在SQL语句内使用@变量。以下是示例代码。 创建表格 CREATE TABLE...
两种mysql递归tree查询效率-mysql递归tree
10-24
1. **使用自连接和递归联合（RECURSIVE UNION）**：这种方法通过将表与自身连接，并通过递归地应用联合查询来构建层级结构。 2. **利用变量和循环**：这种方法通过在SQL查询中使用变量和循环结构来实现递归查询，...
WITH RECURSIVE语句是一种在关系型数据库中用于执行递归查询的SQL语法
慢慢来，谁还没有一个努力的过程。
04-18 401
在这个示例中，我们首先定义了一个递归的公共表表达式（CTE）EmployeeHierarchy，它包含了初始条件（CEO）以及递归部分。需要注意的是，使用递归查询时需要谨慎，确保递归部分能够正常终止，以避免无限循环。此外，不是所有的数据库管理系统都支持WITH RECURSIVE语法，因此在使用时需要查阅相应的数据库文档以确保兼容性。假设我们有一个名为employee的表，其中存储了员工的ID和直接上级的ID，我们希望使用递归查询来获取每个员工及其所有下属的信息。
mysql -- WITH RECURSIVE 语法
dazhong2012的专栏
05-10 1032
在 SQL 中，WITH RECURSIVE 是一个用于创建递归查询的语句。它允许你定义一个 Common Table Expression (CTE)，该 CTE 可以引用自身的输出。递归 CTE 非常适合于查询具有层次结构或树状结构的数据，例如组织结构、文件系统或任何其他具有自引用关系的数据。
with as 和with recursive 用法
Moko_7_的博客
02-13 1938
with as用法 with recursive递归用法 递归查询 构建临时表表查询
SQL中with recursive用法案例详解
leehoward
12-14 2043
SQL提供了递归查询，可将当前查询结果作为下一次的查询集合进行再次查询，最后得到我们想要的结果。关键字：with recursive。
MySQL with recursive 用法浅析
最新发布
Kingfar Ou
07-23 1065
通俗易懂地讲解MySQL “with recursive” 的用法
mysql with recursive 递归调用
08-05
MySQL的WITH RECURSIVE语法可以实现递归查询。具体用法如下所示： ```sqlWITH RECURSIVE cte_name (col_name [, col_name ...) AS ( subquery [, cte_name (col_name [, col_name ...) AS (subquery)] ... ) SELECT * FROM cte_name [ORDER BY ...]; ``` 其中，cte_name是递归查询的名称，col_name是要查询的列名，subquery是子查询的语句。 如果需要向上递归查询，可以参考以下示例： ```sqlWITH RECURSIVE t1 AS ( SELECT * FROM course_category p WHERE id = '1-1-1' UNION ALL SELECT t.* FROM course_category t INNER JOIN t1 ON t1.parentid = t.id) SELECT * FROM t1 ORDER BY t1.id, t1.orderby; ``` 这个例子中，通过递归查询父级课程分类，从'id'为'1-1-1'开始，一直向上查询，直到顶级分类。 如果需要实现课程分类的查询，可以参考以下示例： ```sqlWITH RECURSIVE t1 AS ( SELECT * FROM course_category p WHERE id = '1' UNION ALL SELECT t.* FROM course_category t INNER JOIN t1 ON t1.id = t.parentid) SELECT * FROM t1 ORDER BY t1.id, t1.orderby; ``` 这个例子中，通过递归查询子级课程分类，从'id'为'1'开始，一直向下查询，直到最底层分类。 请根据实际需求，适当修改语句中的表名、列名和条件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值