Get up to topmost parent - sql

Question

Explain my problem with sample.
I have three tables ledger, balance, group.
Columns are
ledger ---> no, name, groupno
balance --> ledgerno, balance
group --> groupno, groupname, undergroupno
I want to show the ledger with top most parent which has balance > 0.
ledger
no name groupno
1 A 5
2 B 4
balance
ledgerno balance
1 100
2 200
group
groupno groupname undergroupno
1 AA 0
2 BB 0
3 CC 1
4 DD 1
5 EE 1
6 FF 1
7 GG 2
8 HH 2
9 II 2
10 JJ 2
So I want the result like this:
name balance
AA
CC
DD
B 100
EE
A 100
FF
I tried the below with query but it does not show the right results
WITH rel AS (
SELECT groupname, amount
FROM (
WITH RECURSIVE rel_tree AS (
SELECT groupno, groupname, undergroupno
FROM "group"
WHERE undergroupno = 0
UNION ALL
SELECT groupno, groupname, undergroupno
FROM balance b
INNER JOIN ledger l ON l.no = b.ledgerno
INNER JOIN "group" g ON g.groupno = l.groupno AS tt
INNER JOIN rel_tree r ON r.groupno = tt.undergroupno
)
SELECT *, 0 AS amount
FROM rel_tree
GROUP BY groupno, groupname, undergroupno
)
SELECT *
FROM rel
UNION ALL
SELECT groupname, amount
FROM (
SELECT name AS groupname, balance AS amount, groupname AS ord
FROM balance b
INNER JOIN ledger l ON l.no = b.ledgerno
INNER JOIN "group" g ON g.groupno = l.groupno) AS ta
INNER JOIN rel ON rel.groupname = ta.ord
Using postgresql 9.3

Answer 1

First of all, NEVER EVER use a SQL reserved word as a name for a table or a column. NEVER. EVER. Below I use grp instead of group.
Second, use column names that are immediately clear. Below I use parent instead of undergroupno.
Third, this is a really nice problem that I happily spent some time on. I am using recursive data structures myself and getting the query right is always something of a puzzle.
Fourth, what you state that you want is rather impossible. You have output on multiple lines from one table (grp), which is interspersed with data from other tables. I have a solution that comes quite close to what you specified. Here it is:
WITH tree AS (
WITH RECURSIVE rel_tree(parent, groupno, refs, path) AS (
SELECT groupno, groupno, 0, lpad(groupno::text, 4, '0') FROM grp WHERE parent > 0
UNION
SELECT g.parent, t.groupno, t.refs+1, lpad(g.parent::text, 4, '0') || '.' || t.path FROM grp g
JOIN rel_tree t ON t.parent = g.groupno)
SELECT * FROM rel_tree WHERE parent > 0
UNION
SELECT groupno, groupno, 0 AS refs, lpad(groupno::text, 4, '0') FROM grp WHERE parent = 0)
SELECT repeat(' ', t.refs) || grp.groupname AS name, l.name AS ledger, b.balance
FROM grp
JOIN (
SELECT DISTINCT ON (groupno) groupno, parent, max(refs) AS refs, path
FROM tree
GROUP BY parent, groupno, path
ORDER BY groupno, path) t USING (groupno)
LEFT JOIN ledger l USING (groupno)
LEFT JOIN balance b ON b.ledgerno = l.no
ORDER BY t.path
This gives the output:
name, ledger, balance
AA
CC
DD, B, 200
EE, A, 100
FF
BB
GG
HH
II
JJ
A few words on the recursive-with query:
This query yields a self-inclusive complete hierarchy. What this means is that it lists for every node of the hierarchy all of its parents, including itself. If you run the tree CTE as a separate query, you will find that it returns more rows than the 10 in the grp table.This is because it lists all grp records with their groupno as groupno but also as parent and additionally all parent nodes higher up in the hierarchy. Such a self-inclusive complete hierarchy is very handy when analyzing other properties of recursive data structures, such as containment and parentage.
Note that the hierarchy is built from the bottom up, starting with every node having itself as a parent, a refs value of 0 (i.e. 0 referrals between parent and self and a path which is just the groupno as a text value (padded with 0's). The recursion works its way up the hierarchy with increasing ref values and longer paths. The sub-select in the main query trims the complete list down to a single record for each grp record, which can be ordered by path. (Note that the use of refs can be omitted and replaced by length(path), but refs does have uses in other contexts of using a similar query.)
This query works to greater depths of the hierarchy as well. If you add:
11 KK 8
12 LL 8
13 MM 11
to table grp, the query will output:
name, ledger, balance
AA
CC
DD, B, 200
EE, A, 100
FF
BB
GG
HH
KK
MM
LL
II
JJ
Note that the path works with groupno values up to 9999. For larger groupno values increase the leading 0's in the recursive CTE, or consider using the ltree extension for more flexibility.