使用递归语句重新编号表行

Question

为了了解递归的行为（在 SQLite 中），我尝试了以下语句来使用递归语句对表的行重新编号：

让我们创建一个示例表，

CREATE TABLE tb
    (x TEXT(1) PRIMARY KEY);

INSERT INTO tb
    VALUES ('a'), ('b'), ('c');

并重新编号从 2 开始的行

SELECT tb.x as x, tb.rowid + 1 as idx from tb; 
/* yields expected:
a|2
b|3
c|4
*/

尝试对递归 WITH（忽略 ROWID）执行相同操作，会导致分歧 — 在这里，我添加了 LIMIT 6 以防止分歧：

WITH RECURSIVE
newtb AS (
   SELECT tb.x, 2 AS idx FROM tb
   UNION ALL
   SELECT tb.x, newtb.idx + 1
      FROM tb, newtb
      LIMIT 6 -- only to prevent divergence!
)
SELECT * FROM newtb;
/* yields indefinitely:
a|2
b|2
c|2
a|3
b|3
c|3
...
*/

为什么递归在到达表tb的末尾时没有停止？可以预防吗？

请注意，该问题可以重新表述为如何在 SQLite 中生成以下过程伪代码的结果（不用多说）：

tb := {'a', 'b', 'c'};
num := {1, 2, 3};
result := {};  # initialize an empty table

for i in {1, ..., length(tb)}  # assume index starts from 1
    append tuple(num[i], tb[i]) to result;
end for

# result will be {(1, 'a'), (2, 'b'), (3, 'c')}

这相当于 Python 等语言中的zip 操作。

根据@CPerkins 的提示，可以通过window functions（对于SQLite >= 3.25）非常优雅地实现这一目标；例如，

SELECT (row_number() OVER (ORDER BY x)) + 2 AS newId, x FROM tb;

Answer 1

为什么递归在到达表 tb 的末尾时没有停止？

因为它就是这样设计的，而且非常有用。它与大多数具有某种递归形式的语言几乎没有什么不同，并且通常是解决某些编程问题（例如遍历目录树）的高效且有效的方法。

• 大多数计算机编程语言通过允许一个 函数从自己的代码中调用自己。一些功能性 编程语言不定义任何循环结构，而是依赖 仅在递归上重复调用代码。可计算性理论 证明这些仅递归的语言是图灵完备的；他们 与图灵完全命令式一样具有计算能力 语言，这意味着它们可以解决与 命令式语言，即使没有迭代控制结构，例如 while 和 for.Recursion (computer science)

如果您使用 LIMIT (SELECT count() FROM tb) 而不是 LIMIT 6，则递归将根据表中的行数停止。

但是，如果您要重新编号（通过在 rowid 上加 1），那么您会看到更像：-

WITH RECURSIVE 
    cte(idx,newidx) AS (
        SELECT (SELECT max(rowid) FROM tb),(SELECT max(rowid) FROM tb) +1
        UNION ALL
        SELECT 
        idx-1, newidx-1 FROM cte
        WHERE idx > 0
    )
SELECT (SELECT x FROM tb WHERE tb.rowid = cte.idx) AS x, newidx, idx AS original FROM cte WHERE x IS NOT NULL;

这将（假设 tb 有带有 a、b 和 c 的行 .... X、Y 和 Z 并且行 d-w 已被删除）导致：-

SQlite 的推理是：-

递归公用表表达式提供了执行以下操作的能力 树和图的分层或递归查询，一种能力 这在 SQL 语言中是不可用的。 SQL As Understood By SQLite - WITH clause

这可以避免吗？

是的，你不能使用递归，因为可能有替代方案，但与其他语言中的递归一样，如果你确实使用递归，那么你必须有一些方法来检测递归何时应该完成。使用 WHERE 或 LIMIT 子句有助于实现这一点。