Built DWH From Father-Child table efficiently with T-SQL - sql

Question

For the last two days, I've been trying to find an efficient solution as most dynamic as possible but I can't make it. Do you have a hint for the following example? I tried a recursive call to get the "level" or the native join so far with the results below.
I have "initTable":
parent | child
-------+------
A | H
A | B
A | C
B | D
B | G
C | F
D | E
I want to have "finalTable": (in the bescase with dynamically create columns "levelX"
level1 | level2 | level 3 | level 4
-------+--------+---------+---------
A | A | A | H
A | A | C | F
A | A | B | G
A | B | D | E
Attempt #1: recursive way to get the level
Question: Is there a possibility to create the for each level a column during the recursion?
WITH recTable (father, child, lev) AS
(
SELECT
p1.father,
p1.child,
0 as lev
FROM
initTable AS p1
WHERE
p1.father = 'A'
UNION ALL
SELECT
p1.father,
p1.child,
lev+1
FROM
initTable AS p1
INNER JOIN
recTable as p2 ON p1.father = p2.child
)
SELECT * FROM ASD
Attempt #2: but with "wrong" order
Here I would need to fill up the columns "backwards" somehow...
SELECT
p1.child AS Level 1,
p2.child AS Level 2,
p3.child AS Level 3,
p4.child AS Level 4
FROM
initTable p1
LEFT JOIN
initTable p2 ON p1.child = p2.father
LEFT JOIN
initTable p3 ON p2.child = p3.father
LEFT JOIN
initTable p4 ON p3.child = p4.father
WHERE
p1.father= 'A'
Does someone know a nice and efficient way to solve this problem? I feel like I m pretty close but I just can't solve it so far.

Answer 1

The following is dynamic and will work for your example, as well as for any with more/less parent/child relationships:
-- Get the number of required fields
SELECT
parent
, child
, 1 [level]
INTO #checking
FROM initTable
WHERE parent NOT IN (SELECT child FROM initTable)
;
WHILE EXISTS (SELECT * FROM #checking c JOIN initTable t ON c.child = t.parent)
BEGIN
INSERT INTO #checking
SELECT
t.parent
, t.child
, (SELECT MAX([level]) + 1 FROM #checking)
FROM
#checking c
JOIN initTable t ON c.child = t.parent
;
DELETE
FROM #checking
WHERE [level] <> (SELECT MAX([level]) FROM #checking)
;
END
;
DECLARE #requiredLevels int = (SELECT TOP 1 [level] + 1 FROM #checking)
;
DROP TABLE #checking
;
-- Build a dynamic statement for the SELECT fields
DECLARE
#fieldSQL varchar(1000) = ''
, #fieldsN int = #requiredLevels
;
WHILE #fieldsN > 0
BEGIN
IF #fieldsN > 2
BEGIN
DECLARE
#coalesceFields varchar(1000) = ''
, #coalesceN int = #fieldsN
WHILE #coalesceN > 1
BEGIN
IF #coalesceFields = ''
SET #coalesceFields = 'L' + CAST(#coalesceN AS varchar) + '.parent'
ELSE
SET #coalesceFields = #coalesceFields + ', L' + CAST(#coalesceN AS varchar) + '.parent'
;
SET #coalesceN = #coalesceN - 1
END
SET #fieldSQL = #fieldSQL + ', COALESCE(' + #coalesceFields + ') [level ' + CAST(#requiredLevels - #fieldsN + 1 AS varchar) + ']'
END
ELSE
SET #fieldSQL = #fieldSQL + ', L' + CAST(#fieldsN AS varchar) + '.' + CASE WHEN #fieldsN = 1 THEN 'child' ELSE 'parent' END + ' [level ' + CAST(#requiredLevels - #fieldsN + 1 AS varchar) + ']'
;
SET #fieldsN = #fieldsN - 1
END
SET #fieldSQL = SUBSTRING(#fieldSQL, 3, LEN(#fieldSQL) - 2)
-- Build a dynamic statement for the LEFT JOINs
DECLARE
#joinSQL varchar(1000) = ''
, #joinsN int = 2
WHILE #joinsN <= #requiredLevels
BEGIN
SET #joinSQL = #joinSQL + ' LEFT JOIN initTable L' + CAST(#joinsN AS varchar) + ' ON L' + CAST(#joinsN - 1 AS varchar) + '.' + CASE WHEN #joinsN = 2 THEN 'child' ELSE 'parent' END + ' = L' + CAST(#joinsN AS varchar) + '.child'
SET #joinsN = #joinsN + 1
END
-- Build the final SQL statement and execute
DECLARE #SQL varchar(8000) =
'
SELECT ' + #fieldSQL + '
FROM
(
SELECT child
FROM initTable
WHERE child NOT IN (SELECT parent FROM initTable)
) L1' + #joinSQL
EXEC (#SQL)