Usando
WITH RECURSIVE (https://www.postgresql.org/docs/current/static/queries-with.html) e funções JSON (https://www.postgresql.org/docs/current/static/functions-json.html) I construa esta solução:db<>violino
A funcionalidade principal:
WITH RECURSIVE tree(node_id, ancestor, child, path, json) AS (
SELECT
t1.node_id,
NULL::int,
t2.node_id,
'{children}'::text[] ||
(row_number() OVER (PARTITION BY t1.node_id ORDER BY t2.node_id) - 1)::text,-- C
jsonb_build_object('name', t2.name, 'children', array_to_json(ARRAY[]::int[])) -- B
FROM test t1
LEFT JOIN test t2 ON t1.node_id = t2.parent_node -- A
WHERE t1.parent_node IS NULL
UNION
SELECT
t1.node_id,
t1.parent_node,
t2.node_id,
tree.path || '{children}' || (row_number() OVER (PARTITION BY t1.node_id ORDER BY t2.node_id) - 1)::text,
jsonb_build_object('name', t2.name, 'children', array_to_json(ARRAY[]::int[]))
FROM test t1
LEFT JOIN test t2 ON t1.node_id = t2.parent_node
INNER JOIN tree ON (t1.node_id = tree.child)
WHERE t1.parent_node = tree.node_id -- D
)
SELECT -- E
child as node_id, path, json
FROM tree
WHERE child IS NOT NULL ORDER BY path
Cada
WITH RECURSIVE contém um SELECT inicial e uma parte de recursão (a segunda SELECT ) combinado por um UNION . R:Unindo a tabela novamente para encontrar os filhos de um
node_id . B:Construindo o objeto json para o filho que pode ser inserido em seu pai
C:Construindo o caminho onde o objeto filho deve ser inserido (da raiz). A função de janela
row_number() (https://www.postgresql.org/docs/current/static/tutorial-window.html) gera o índice do filho dentro do array filhos do pai. D:A parte de recursão funciona como a parte inicial com uma diferença:não está procurando pelo elemento raiz, mas pelo elemento que tem o nó pai da última recursão.
E:Executando a recursão e filtrando todos os elementos sem nenhum filho dá este resultado:
node_id path json
2 children,0 {"name": "node2", "children": []}
4 children,0,children,0 {"name": "node4", "children": []}
5 children,0,children,1 {"name": "node5", "children": []}
6 children,0,children,2 {"name": "node6", "children": []}
3 children,1 {"name": "node3", "children": []}
7 children,1,children,0 {"name": "node7", "children": []}
8 children,1,children,1 {"name": "node8", "children": []}
Embora eu não tenha encontrado nenhuma maneira de adicionar todos os elementos filhos na recursão (o json de origem não é uma variável global; portanto, ele sempre conhece as alterações dos ancestrais diretos, não de seus irmãos), tive que iterar as linhas em uma etapa de segundos.
É por isso que eu construo a função. Lá eu posso fazer a iteração para uma variável global. Com a função
jsonb_insert Estou inserindo todos os elementos calculados em um objeto json raiz - usando o caminho calculado. CREATE OR REPLACE FUNCTION json_tree() RETURNS jsonb AS $$
DECLARE
_json_output jsonb;
_temprow record;
BEGIN
SELECT
jsonb_build_object('name', name, 'children', array_to_json(ARRAY[]::int[]))
INTO _json_output
FROM test
WHERE parent_node IS NULL;
FOR _temprow IN
/* Query above */
LOOP
SELECT jsonb_insert(_json_output, _temprow.path, _temprow.json) INTO _json_output;
END LOOP;
RETURN _json_output;
END;
$$ LANGUAGE plpgsql;
A última etapa é chamar a função e tornar o JSON mais legível (
jsonb_pretty() ) {
"name": "node1",
"children": [{
"name": "node2",
"children": [{
"name": "node4",
"children": []
},
{
"name": "node5",
"children": []
},
{
"name": "node6",
"children": []
}]
},
{
"name": "node3",
"children": [{
"name": "node7",
"children": []
},
{
"name": "node8",
"children": []
}]
}]
}
Tenho certeza de que é possível otimizar a consulta, mas para um esboço funciona.
