Renumber table rows with a recursive statement - sqlite

Question

To understand the behaviour of recursion (in SQLite), I tried the following statements to re-number the rows of a table with a recursive statement:
Let's create a sample table,
CREATE TABLE tb
(x TEXT(1) PRIMARY KEY);
INSERT INTO tb
VALUES ('a'), ('b'), ('c');
and re-number the rows starting from, say, 2 via
SELECT tb.x as x, tb.rowid + 1 as idx from tb;
/* yields expected:
a|2
b|3
c|4
*/
Attempting to do the same with a recursive WITH (neglecting ROWID), results in divergence — here, I have added LIMIT 6 to prevent the divergence:
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
...
*/
Why does the recursion does not stop when it reaches the end of table tb? Could this be prevented?
Note that the problem can be reformulated as how to produce the result of the following procedural pseudo-code in SQLite (without too much ado):
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')}
This is equivalent to the zip operation in a language like Python.
According to a hint by #CPerkins, one can achieve this goal via window functions (for SQLite >= 3.25) very elegantly; eg.,
SELECT (row_number() OVER (ORDER BY x)) + 2 AS newId, x FROM tb;

Answer 1

Why does the recursion does not stop when it reaches the end of table tb?
Because that's the way it is designed to be and it is extremely useful. It is little different from most languages that have some form of recursion and is often and efficient and effective the way to resolve some programming issues such as traversing a directory tree.
Most computer programming languages support recursion by allowing a
function to call itself from within its own code. Some functional
programming languages do not define any looping constructs but rely
solely on recursion to repeatedly call code. Computability theory
proves that these recursive-only languages are Turing complete; they
are as computationally powerful as Turing complete imperative
languages, meaning they can solve the same kinds of problems as
imperative languages even without iterative control structures such as
while and for.Recursion (computer science)
If you used LIMIT (SELECT count() FROM tb) instead of LIMIT 6 then the recursion would stop based upon the number of rows in the table.
However, if you are looking to renumber (by adding 1 to the rowid) then you would be looking at something more like :-
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;
This would (assuming that tb had rows with a, b and c .... X, Y and Z and that rows d-w had been deleted) result in :-
SQlite's reasoning is :-
Recursive common table expressions provide the ability to do
hierarchical or recursive queries of trees and graphs, a capability
that is not otherwise available in the SQL language.
SQL As Understood By SQLite - WITH clause
Could this be prevented?
Yes, you can not use recursion as there may be alternatives but as with recursion throughout other languages if you do use recursion then you have to have some means of detecting when the recursion should finish. The use of a WHERE or LIMIT clause facilitates this.