Parent/child table with include/exclude items - postgresql

Question

I have a table with parent-child relations. The relations can go n-level deep.
There is also a table with elements that belong to a group.
CREATE TABLE group_children(
id serial PRIMARY KEY,
parent_id integer,
children_id integer,
contains boolean
);
CREATE TABLE group_item(
id serial PRIMARY KEY,
group_id integer,
name text
);
INSERT INTO group_children(parent_id, children_id, contains) VALUES
(1, 2, true),
(1, 3, false),
(2, 4, true),
(2, 5, false),
(3, 6, true),
(3, 7, false);
INSERT INTO group_item(group_id, name) VALUES
(4, 'aaa'),
(4, 'bbb'),
(5, 'bbb'),
(5, 'ccc'),
(6, 'aaa'),
(6, 'bbb'),
(7, 'aaa'),
(7, 'ccc');
So, we can represent this data as
It is not necessary to be in the form of a binary tree, just a simple case. Group can contains m child.
Need to read right to left. Group 4 contains ['aaa', 'bbb'], group 5 - ['bbb', 'ccc']. Group 2 includes all items from group 4 and excludes from group 5. So group 2 contains ['aaa']. And so on. After all computation group 1 will contain ['aaa'].
Question is: how to build a sql query to get all items that belong to the group 1?
All i could do:
WITH RECURSIVE r AS (
SELECT group_children.parent_id, group_children.children_id, group_children.contains, group_item.name
FROM group_children
LEFT JOIN group_item ON group_children.children_id = group_item.group_id
WHERE parent_id = 1
UNION ALL
SELECT group_children.parent_id, group_children.children_id, group_children.contains, group_item.name
FROM group_children
LEFT JOIN group_item ON group_children.children_id = group_item.group_id
JOIN r ON group_children.parent_id = r.children_id
)
SELECT * FROM r;
SQL Fiddle

Answer 1

demo:db<>fiddle
WITH RECURSIVE items AS (
SELECT -- 1
group_id,
array_agg(name)
FROM
group_Item
GROUP BY group_id
UNION
SELECT DISTINCT
parent_id,
array_agg(unnest) FILTER (WHERE bool_and) OVER (PARTITION BY parent_id) -- 5
FROM (
SELECT
parent_id,
unnest,
bool_and(contains) OVER (PARTITION BY parent_id, unnest) -- 4
FROM items i
JOIN group_children gc -- 2
ON i.group_id = gc.children_id,
unnest(array_agg) -- 3
) s
)
SELECT * FROM items
The non-recursive part aggregates all names per group_id
Recursive part: Joining the chilren against their parents
Expanding the name arrays into one element per row.
This results in:
| group_id | array_agg | id | parent_id | children_id | contains | unnest |
|----------|-----------|----|-----------|-------------|----------|--------|
| 4 | {aaa,bbb} | 3 | 2 | 4 | true | aaa |
| 4 | {aaa,bbb} | 3 | 2 | 4 | true | bbb |
| 5 | {bbb,ccc} | 4 | 2 | 5 | false | bbb |
| 5 | {bbb,ccc} | 4 | 2 | 5 | false | ccc |
| 6 | {aaa,bbb} | 5 | 3 | 6 | true | aaa |
| 6 | {aaa,bbb} | 5 | 3 | 6 | true | bbb |
| 7 | {aaa,ccc} | 6 | 3 | 7 | false | aaa |
| 7 | {aaa,ccc} | 6 | 3 | 7 | false | ccc |
Now you have the unnested names. Now you want to find the ones that have to be excluded. Taking the bbb element for the parent_id = 2: There is one row with contains = true and one with contains = false. This should be excluded. Therefore all the names per parent_id have to be grouped. The contains values can be aggregated with boolean operators. The aggregate function bool_and gives only true if all elements are true. So bbb would get a false (The aggregation needs to be done as a window function because GROUP BY is not allowed within the recursive part for some reasons):
Result:
| parent_id | unnest | bool_and |
|-----------|--------|----------|
| 2 | aaa | true |
| 2 | bbb | false |
| 2 | bbb | false |
| 2 | ccc | false |
| 3 | aaa | false |
| 3 | aaa | false |
| 3 | bbb | true |
| 3 | ccc | false |
After that the unnested names can be grouped per parent_id. The FILTER clause only aggregates the elements where the bool_and is true. Of course you need to do this in a window function again. This creates duplicate records which can be removed by the DISTINCT clause
Final result (which of course could be filtered by the element 1):
| group_id | array_agg |
|----------|-----------|
| 5 | {bbb,ccc} |
| 4 | {aaa,bbb} |
| 6 | {aaa,bbb} |
| 7 | {aaa,ccc} |
| 2 | {aaa} |
| 3 | {bbb} |
| 1 | {aaa} |