Use self joins to collapse linked rows in POSTGRESQL - postgresql

Question

Suppose I have a table in the format:
+======+=========+=======+============+
| code | type | Price | parentCode |
+======+=========+=======+============+
| TR1 | initial | 100 | -1 |
+------+---------+-------+------------+
| TR2 | losing | 70 | TR1 |
+------+---------+-------+------------+
| TR3 | winning | 150 | TR1 |
+------+---------+-------+------------+
Which for example, represented a trade placed by a user at a price of 100 (TR1), and the following trades (TR2, TR3) are automatic trades that will be placed if the price hits the value specified.
Using the fact that TR2 and TR3 are linked to the initial trade using the parentCode, how would I use this relationship to generate the following table by collapsing the entries into a single row:
+=============+============+=============+==============+=============+==============+
| initialCode | losingCode | winningCode | initialPrice | losingPrice | winningPrice |
+=============+============+=============+==============+=============+==============+
| TR1 | TR2 | TR3 | 100 | 70 | 150 |
+-------------+------------+-------------+--------------+-------------+--------------+

Answer 1

Assuming these are always in groups of one each of initial, losing, and winning.
select i.code as initialCode,
l.code as losingCode,
w.code as winningCode,
i.price as initialPrice,
l.price as losingPrice,
w.price as winningPrice
from trades i
join trades l on l.parentCode = i.code and l.type = 'losing'
join trades w on w.parentCode = i.code and w.type = 'winning'
where i.type = 'initial';
This can also be done without joining. Ask in the comments if you want to see that.
If you have more than just the three types, then you can follow the above pattern, but the self-joins will start adding up.
To do this without all the joins, follow this pattern:
with by_parent as (
select case
when parentCode = '-1' then code
else parentCode
end as parentCode,
type, price, code
from trades
)
select parentCode as initialCode,
max(code) filter (where type='losing') as losingCode,
max(code) filter (where type='winning') as winningCode,
max(code) filter (where type='trailLosing') as trailLosingCode,
max(code) filter (where type='guaranteedLosing') as guaranteedLosingCode,
max(price) filter (where type='initial') as initialPrice,
max(price) filter (where type='losing') as losingPrice,
max(price) filter (where type='winning') as winningPrice,
max(price) filter (where type='trailLosing') as trailLosingPrice,
max(price) filter (where type='guaranteedLosing') as guaranteedLosingPrice
from by_parent
group by parentCode
;
initialcode | losingcode | winningcode | traillosingcode | guaranteedlosingcode | initialprice | losingprice | winningprice | traillosingprice | guaranteedlosingprice
-------------+------------+-------------+-----------------+----------------------+--------------+-------------+--------------+------------------+-----------------------
TR1 | TR2 | TR3 | | | 100 | 70 | 150 | |
(1 row)
If you have control over your source data, then you can get rid of the by_parent CTE if you can have the parentCode set to the code for the initial rows.