The document appears to be about Common Table Expressions (CTE) in SQL. It includes examples of using CTE to recursively query hierarchical or tree-like data with multiple levels. It also discusses using CTE to break complex queries into multiple simple steps.

1. bf
SQL
bleis-tift
February 26, 2011

2. id:bleis-tift / @bleis

3. id:bleis-tift / @bleis

4. id:bleis-tift / @bleis
SQL CTE

5. id:bleis-tift / @bleis
SQL CTE

6. id:bleis-tift / @bleis
SQL CTE

8. SQL

9. SQL

11. SQL bf

12. SQL bf
PL/SQL T-SQL

13. SQL bf
PL/SQL T-SQL
SELECT bf

16. CTE

18. CTE

19. CTE

20. CTE

21. CTE
Common Table Expression

22. CTE
Common Table Expression
SQL99

23. CTE
Common Table Expression
SQL99

24. CTE
Common Table Expression
SQL99

25. CTE
Common Table Expression
SQL99
SELECT

26. SELECT *
FROM
(SELECT 1 AS n UNION ALL
SELECT 3) T;

27. SELECT *
FROM
(SELECT 1 AS n UNION ALL
SELECT 3) T;
1
3

28. SELECT *
FROM
(SELECT 1 AS n UNION ALL
SELECT 3) T;
CTE
WITH T(n) AS (
SELECT 1 UNION ALL
SELECT 3
)
SELECT * FROM T;

29. CTE

30. CTE
CTE CTE

31. CTE
CTE CTE
SQL SELECT

32. CTE
WITH Hoge(n) AS (
SELECT 1 UNION ALL
SELECT n + 1 FROM Hoge
WHERE n < 3
)
SELECT * FROM Hoge;

33. CTE
WITH Hoge(n) AS (
SELECT 1 UNION ALL
SELECT n + 1 FROM Hoge
WHERE n < 3
)
SELECT * FROM Hoge;
1
2
3

34. bf

35. bf
Brainfuck

36. bf
Brainfuck

37. bf
Brainfuck

38. bf
Brainfuck

43. bf CTE

45. Ruby

46. Ruby
CTE

47. Ruby
CTE
CTE

48. Ruby
CTE
CTE
CTE

49. Ruby
CTE
CTE
CTE

50. Ruby
CTE
CTE
CTE
NE

51. Ruby
CTE
CTE
CTE
NE

55. WITH , Eval(id, array, ptr, input_pgm, crnt, stdout, stdin) AS (
Input(id, bf_program, stdin) AS ( SELECT
SELECT 0, ' id
>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.[-]>++++++++[<++ , CAST(REPLICATE(CHAR(0), 5000) AS char(5000))
++>-]<.>+++++++++++[<+++++>-]<.>++++++++[<+++>-]<.+++.------.--------.[-]> , 1
++++++++[<++++>-]<+.[-]++++++++++.', '' , bf_program
) , 1
, BracketTableSrc(id, open_bracket_pos, close_bracket_pos, stack, src, crnt) AS ( , CAST('' AS nvarchar(max))
SELECT , stdin
id FROM
, 0 Input
, 0 UNION ALL
, CAST('' AS varchar(max)) SELECT
, bf_program id
, 1 , CAST(
FROM CASE SUBSTRING(input_pgm, crnt, 1)
Input WHEN '+' THEN STUFF(array, ptr, 1, CHAR(ASCII(SUBSTRING(array, ptr, 1)) + 1))
UNION ALL WHEN '-' THEN STUFF(array, ptr, 1, CHAR(ASCII(SUBSTRING(array, ptr, 1)) - 1))
SELECT WHEN ',' THEN STUFF(array, ptr, 1, LEFT(stdin, 1))
id ELSE array
, CASE LEFT(src, 1) END
WHEN ']' THEN CAST(LEFT(stack, CHARINDEX(' ', stack, 1)) AS int) AS char(5000))
ELSE 0 , CASE SUBSTRING(input_pgm, crnt, 1)
END WHEN '>' THEN ptr + 1
, CASE LEFT(src, 1) WHEN '<' THEN ptr - 1
WHEN ']' THEN crnt ELSE ptr
ELSE 0 END
END , input_pgm
, CASE LEFT(src, 1) , CASE SUBSTRING(input_pgm, crnt, 1)
WHEN '[' THEN CAST(crnt AS varchar(4)) + ' ' + stack WHEN '[' THEN CASE ASCII(SUBSTRING(array, ptr, 1))
WHEN ']' THEN SUBSTRING(stack, CHARINDEX(' ', stack, 1) + 1, LEN(stack)) WHEN 0 THEN (SELECT close_bracket_pos FROM BracketTable
ELSE stack WHERE Eval.id = BracketTable.id AND open_bracket_pos = crnt) + 1
END ELSE crnt + 1
, SUBSTRING(src, 2, LEN(src)) END
, crnt + 1 WHEN ']' THEN (SELECT open_bracket_pos FROM BracketTable
FROM WHERE Eval.id = BracketTable.id AND close_bracket_pos = crnt)
BracketTableSrc ELSE crnt + 1
WHERE END
src <> '' , CASE SUBSTRING(input_pgm, crnt, 1)
) WHEN '.' THEN stdout + SUBSTRING(array, ptr, 1)
, BracketTable(id, open_bracket_pos, close_bracket_pos) AS ( ELSE stdout
SELECT END
id , CASE SUBSTRING(input_pgm, crnt, 1)
, open_bracket_pos WHEN ',' THEN SUBSTRING(stdin, 2, LEN(stdin))
, close_bracket_pos ELSE stdin
FROM END
BracketTableSrc FROM
WHERE Eval
open_bracket_pos <> 0 WHERE
AND close_bracket_pos <> 0 crnt <= LEN(input_pgm)
) )
, Result(id, stdout) AS (
SELECT
id
, stdout
FROM
Eval P
WHERE
crnt = (SELECT MAX(crnt) FROM Eval C WHERE P.id = C.id)
)
SELECT * FROM Result ORDER BY id
OPTION (MAXRECURSION 0)

57. Q.

58. Q.
A.

59. Q.
A.

60. Q.
A.

61. Q.
A.

62. SQL