如何递归地求和 SQL 中的所有子树？

Question

Good day, I've been pulling my hair on this problem for a while ><"

I have 4 categories in a tree structure.

tenant_category_transaction_view:

I would like to have the sum of all children "sumSubtotal" on every category

Something like that:

I've managed to come very close... But there's something I don't get ><"

with recursive cte (sumSubtotal, sumQuantity, id, idParentCategory, treeSum, depth) as (

        select  root.sumSubtotal, -- STEP 1
                root.sumQuantity, 
                root.id, 
                root.idParentCategory, 
                root.sumSubtotal as treeSum,
                0 as depth
        from    tenant_category_transaction_view as root

        union all -- LOOP THROUGH ALL ROOT ROWS AND ADD ROWS TO THE CTE WITH THE INNER JOIN

        select  child.sumSubtotal, -- STEP 3
                child.sumQuantity, 
                child.id, 
                child.idParentCategory, 
                (cte.treeSum + child.sumSubtotal) AS treeSum,
                (cte.depth + 1) AS depth
        from    tenant_category_transaction_view AS child

        inner join cte on child.idParentCategory = cte.id -- STEP 2
)
select sumSubtotal, sumQuantity, id, idParentCategory, treeSum, depth -- STEP 4
from cte

Result of the above query:

It seems I'm generating the correct treeSum but upside down in only one branch

Would you be so kind to give me a hand?

Thank you for your time:)

Answer 1

Try this one. First, we find all the branch lists recursively. Each branch is identified by a corresponding root. Then, we aggregate the node quantities for each root/branch.

Note: The top of the tree shouldn't have a null id. That would violate the primary key constraint. The parent of the top node can be null, however. I corrected that in my test case.

Also, I could have carried the root row values (for each branch) through the recursion, avoiding the final join.

The fiddle

WITH RECURSIVE cte AS (
        SELECT t.*, t.id AS root
          FROM tenant_category_transaction_view AS t
         UNION ALL
        SELECT t.*, t0.root
          FROM cte AS t0
          JOIN tenant_category_transaction_view AS t
            ON t.idParentCategory = t0.id
     )
SELECT root
     , MIN(t2.idParentCategory) AS idParentCategory
     , MIN(t2.sumSubtotal)      AS sumSubtotal
     , MIN(t2.sumQuantity)      AS sumQuantity
     , SUM(t1.sumSubtotal)      AS total
  FROM cte AS t1
  JOIN tenant_category_transaction_view AS t2
    ON t1.root = t2.id
 GROUP BY root
 ORDER BY root
;

root	idParentCategory	sumSubtotal	sumQuantity	total
1	null	0	98	9890
2	1	9800	1	9800
4	1	20	1	90
5	4	30	1	70
6	5	40	1	40

Additionally, this can be written to aggregate based on t2.id, which is the primary key, allowing slight simplification, due to functional dependence.

WITH RECURSIVE cte AS (
        SELECT t.*, t.id AS root
          FROM tenant_category_transaction_view AS t
         UNION ALL
        SELECT t.*, t0.root
          FROM cte AS t0
          JOIN tenant_category_transaction_view AS t
            ON t.idParentCategory = t0.id
     )
SELECT t2.id
     , t2.idParentCategory
     , t2.sumSubtotal
     , t2.sumQuantity
     , SUM(t1.sumSubtotal)      AS total
  FROM cte AS t1
  JOIN tenant_category_transaction_view AS t2
    ON t1.root = t2.id
 GROUP BY t2.id
 ORDER BY t2.id
;

Finally, we can remove the last JOIN by carrying other root values within the recursive logic:

WITH RECURSIVE cte AS (
        SELECT t.*, t.id AS root
             , idParentCategory AS idParentCategory0
             , sumSubtotal      AS sumSubtotal0
             , sumQuantity      AS sumQuantity0
          FROM tenant_category_transaction_view AS t
         UNION ALL
        SELECT t.* , t0.root
             , t0.idParentCategory0
             , t0.sumSubtotal0
             , t0.sumQuantity0
          FROM cte AS t0
          JOIN tenant_category_transaction_view AS t
            ON t.idParentCategory = t0.id
     )
SELECT root
     , MIN(idParentCategory0)   AS idParentCategory
     , MIN(sumSubtotal0)        AS sumSubtotal
     , MIN(sumQuantity0)        AS sumQuantity
     , SUM(t1.sumSubtotal)      AS total
  FROM cte AS t1
 GROUP BY root
 ORDER BY root
;

The setup:

CREATE TABLE tenant_category_transaction_view (
    id               int primary key
  , idParentCategory int
  , sumSubtotal      int
  , sumQuantity      int
);

INSERT INTO tenant_category_transaction_view VALUES
    (1, null,    0,  0)
  , (2,    1, 9800, 98)
  , (4,    1,   20,  1)
  , (5,    4,   30,  1)
  , (6,    5,   40,  1)
;

Answer 2

The solution is actually quite simple:-)

1. Inside the CTE add an hard-coded row that represents the root node (where id is NULL). Please not that we can use multiple anchore queries within a CTE (queries that does not refer to the name of the CTE).
2. Create all paths from all node to all of their descendants (including themselves). Each path is represented by a row that holds the start node id, the descendant node id and the amount of the descendant node. Please note the use of the null-safe equal operator ( <=> )
3. Aggregate by the starting nodes ids and for each node summarize the amount of all of its descendants

PS
There is nothing recursive about "recursive" queries. It is a misleading name. Those are actually iterative queries, not recursive.

---

with recursive cte (root_id, id, sumSubtotal)  as 
(
  select     null
            ,null
            ,0
  
  union all
  
  select     id
            ,id
            ,sumSubtotal

  from      tenant_category_transaction_view as tctv
  
  union all
  
  select     cte.root_id
            ,tctv.id
            ,tctv.sumSubtotal

  from      cte 
            join    tenant_category_transaction_view as tctv 
            on      tctv.idParentCategory <=> cte.id
)
select   root_id
        ,sum(sumSubtotal)
from     cte
group by root_id

---

+---------+-------------+
| root_id | sumSubtotal |
+---------+-------------+
| null    |        9890 |
| 1       |        9800 |
| 4       |          90 |
| 5       |          70 |
| 6       |          40 |
+---------+-------------+

fiddle