J'ai ce SQL:
CREATE TABLE test(id SERIAL PRIMARY KEY, data JSONB);
INSERT INTO test(data) VALUES
('{"parent":null,"children":[2,3]}'),
('{"parent":1, "children":[4,5]}'),
('{"parent":1, "children":[]}'),
('{"parent":2, "children":[]}'),
('{"parent":2, "children":[]}');
Cela donnerait:
id | data
----+--------------------------------------
1 | {"parent": null, "children": [2, 3]}
2 | {"parent": 1, "children": [4, 5]}
3 | {"parent": 1, "children": []}
4 | {"parent": 2, "children": []}
5 | {"parent": 2, "children": []}
En faisant un à plusieurs normal, cela montrerait quelque chose comme ceci:
SELECT *
FROM test x1
LEFT JOIN test x2
ON x1.id = (x2.data->>'parent')::INT;
id | data | id | data
----+--------------------------------------+----+-----------------------------------
1 | {"parent": null, "children": [2, 3]} | 2 | {"parent": 1, "children": [4, 5]}
1 | {"parent": null, "children": [2, 3]} | 3 | {"parent": 1, "children": []}
2 | {"parent": 1, "children": [4, 5]} | 4 | {"parent": 2, "children": []}
2 | {"parent": 1, "children": [4, 5]} | 5 | {"parent": 2, "children": []}
5 | {"parent": 2, "children": []} | |
4 | {"parent": 2, "children": []} | |
3 | {"parent": 1, "children": []} | |
Comment rejoindre en fonction des enfants (en utilisant LEFT JOIN
ou WHERE IN
)? J'ai essayé:
SELECT data->>'children' FROM test;
?column?
----------
[2, 3]
[4, 5]
[]
[]
[]
SELECT json_array_elements((data->>'children')::TEXT) FROM t...
^
HINT: No function matches the given name and argument types. You might need to add explicit type casts.
SELECT json_array_elements((data->>'children')::JSONB) FROM ...
^
HINT: No function matches the given name and argument types. You might need to add explicit type casts.
SELECT json_to_record((data->>'children')::JSON) FROM test;
ERROR: function returning record called in context that cannot accept type record
HINT: Try calling the function in the FROM clause using a column definition list.
SELECT * FROM json_to_record((test.data->>'children')::JSON);
ERROR: missing FROM-clause entry for table "test"
LINE 1: SELECT * FROM json_to_record((test.data->>'children')::JSON)...
Ce serait plus efficace:
json
et json_array_elements()
en pg 9.3SELECT p.id AS p_id, p.data AS p_data
, c.id AS c_id, c.data AS c_data
FROM test p
LEFT JOIN LATERAL json_array_elements(p.data->'children') pc(child) ON TRUE
LEFT JOIN test c ON c.id = pc.child::text::int;
Utilisez l'opérateur ->
Au lieu de ->>
Dans la référence à children
. De la manière dont vous l'avez, vous devez d'abord convertir json
/jsonb
en text
puis revenir à json
.
La meilleure façon d'appeler une fonction renvoyant un ensemble est LEFT [OUTER] JOIN LATERAL
. Ceci inclut lignes sans enfants. Pour exclure ceux-ci, passez à [INNER] JOIN LATERAL
Ou CROSS JOIN
- ou à la syntaxe abrégée avec une virgule:
, json_array_elements(p.data->'children') pc(child)
Éviter les noms de colonne en double dans le résultat.
jsonb
et jsonb_array_elements()
en pg 9.4EXPLAIN
SELECT p.id AS p_id, p.data AS p_data
, c.id AS c_id, c.data AS c_data
FROM test p
LEFT JOIN LATERAL jsonb_array_elements(p.data->'children') pc(child) ON TRUE
LEFT JOIN test c ON c.id = pc.child::text::int;
-------------------------------------------------------------------------------------------
Hash Left Join (cost=37.69..4826.24 rows=123000 width=72)
Hash Cond: (((pc.child)::text)::integer = c.id)
-> Nested Loop Left Join (cost=0.01..2482.31 rows=123000 width=68)
-> Seq Scan on test p (cost=0.00..22.30 rows=1230 width=36)
-> Function Scan on jsonb_array_elements pc (cost=0.01..1.01 rows=100 width=32)
-> Hash (cost=22.30..22.30 rows=1230 width=36)
-> Seq Scan on test c (cost=0.00..22.30 rows=1230 width=36)
En plus: Une conception de base de données normalisée avec des types de données de base serait façon plus efficace pour cela.
Peu importe, j'ai trouvé le chemin
SELECT *
FROM ( SELECT *, json_array_elements((data->>'children')::JSON) child FROM test) x1
LEFT JOIN test x2
ON x1.child::TEXT::INT = x2.id
;
id | data | child | id | data
----+--------------------------------------+-------+----+-----------------------------------
1 | {"parent": null, "children": [2, 3]} | 2 | 2 | {"parent": 1, "children": [4, 5]}
1 | {"parent": null, "children": [2, 3]} | 3 | 3 | {"parent": 1, "children": []}
2 | {"parent": 1, "children": [4, 5]} | 4 | 4 | {"parent": 2, "children": []}
2 | {"parent": 1, "children": [4, 5]} | 5 | 5 | {"parent": 2, "children": []}
QUERY PLAN
-----------------------------------------------------------------------------------------------------------
Hash Left Join (cost=37.67..4217.38 rows=123000 width=104)
Hash Cond: ((((json_array_elements(((test.data ->> 'children'::text))::json)))::text)::integer = x2.id)
-> Seq Scan on test (cost=0.00..643.45 rows=123000 width=36)
-> Hash (cost=22.30..22.30 rows=1230 width=36)
-> Seq Scan on test x2 (cost=0.00..22.30 rows=1230 width=36)
ou
SELECT *
FROM test x1
LEFT JOIN ( SELECT *, json_array_elements((data->>'children')::JSON) child FROM test) x2
ON x1.id = x2.child::TEXT::INT
;
id | data | id | data | child
----+--------------------------------------+----+--------------------------------------+-------
2 | {"parent": 1, "children": [4, 5]} | 1 | {"parent": null, "children": [2, 3]} | 2
3 | {"parent": 1, "children": []} | 1 | {"parent": null, "children": [2, 3]} | 3
4 | {"parent": 2, "children": []} | 2 | {"parent": 1, "children": [4, 5]} | 4
5 | {"parent": 2, "children": []} | 2 | {"parent": 1, "children": [4, 5]} | 5
1 | {"parent": null, "children": [2, 3]} | | |
QUERY PLAN
-----------------------------------------------------------------------------------------------------------
Hash Right Join (cost=37.67..4217.38 rows=123000 width=104)
Hash Cond: ((((json_array_elements(((test.data ->> 'children'::text))::json)))::text)::integer = x1.id)
-> Seq Scan on test (cost=0.00..643.45 rows=123000 width=36)
-> Hash (cost=22.30..22.30 rows=1230 width=36)
-> Seq Scan on test x1 (cost=0.00..22.30 rows=1230 width=36)