Recursive query to calculate new value in a table.

Question

Hello folks,
I have following data.
drop table transactions;
create table transactions
( ac varchar2(10), rec_seq int, tr_ref int, action varchar2(100), qty int );
select * from transactions;
insert into transactions values ('A1', 1, null, 'BUY', 1);
insert into transactions values ('A1', 2, null, 'BUY', 4);
insert into transactions values ('A1', 3, 1, 'TR to A2', -2);
insert into transactions values ('A1', 4, null, 'SELL', -1);
insert into transactions values ('A1', 5, 2, 'TR from A2', 2);
insert into transactions values ('A1', 6, null, 'BUY', 5);
insert into transactions values ('A1', 3, 3, 'TR to A3', -1);
insert into transactions values ('A2', 1, null, 'BUY', 5);
insert into transactions values ('A2', 2, null, 'BUY', 5);
insert into transactions values ('A2', 3, null, 'BUY', 5);
insert into transactions values ('A2', 4, 1, 'TR from A1', 2);
insert into transactions values ('A2', 5, null, 'SELL', 2);
insert into transactions values ('A2', 6, null, 'BUY', 1);
insert into transactions values ('A2', 7, null, 'BUY', 1);
insert into transactions values ('A2', 8, 2, 'TR to A1', -2);
insert into transactions values ('A2', 9, null, 'sell', 3);
insert into transactions values ('A2', 10, 4, 'TR from A3', 3);
insert into transactions values ('A3', 1, null, 'BUY', 5);
insert into transactions values ('A3', 2, 3, 'TR from A1', 1);
insert into transactions values ('A3', 3, null, 'SELL', 2);
insert into transactions values ('A3', 4, 4, 'TR to A2', -3);I the transactions table that holds the activity took place in a time. Below is some description of the table.
1. rec_seq is the unique for each row within each AC value
2. action column holds the nature of the activity
3. tr_ref holds to link between the transfers. That is, source and destination of the transfers can be matched using this column.
Now I want to write a query such that It returns the whole table with value of rec_seq changed in a recursive fashion that is
1. Compare transfer records using tr_ref.
2. Assign the greatest rec_seq to both the records.
3. Recalculate the rec_seq of the following records from the new value. This recalculation to happen in a recursive fashion.
Any hint/partial or full assistance in this will immensely help.
Thank you.
Girish

Answer 1

Hi,
Transfers are the key events in this problem. Every time there is a transfer, the new rec_seq number has to be adjusted. The new rec_seq value will be the greater of two numbers:
(1) the req_seq of the last transfer in this ac, plus the number of other transactions in this ac since then, and
(2) the req_seq of the last transfer in the other ac, plus the number of other transactions in that ac since then.
(I assume a transfer always involves two different ac's. If not, the query below can be changed.)
One way to approach this problem is to think of a directed graph, where every node is a transfer row, and it may have up to two parents:
(1) the previous transfer in the same ac
(2) the previous transfer in the other ac
The query below constructs such a graph, then finds all the paths through that graph (in the sub-query named graph). It finds the longest path to each node (weighted by the number of rows between transactions). The main query references that number, and assigns consectuive new_rec_seqs starting with it.
WITH     got_trs  AS
     SELECT     ac, rec_seq, tr_ref, action, qTy
     ,     LAST_VALUE (tr_ref IGNORE NULLS)  OVER ( PARTITION BY  ac
                                                       ORDER BY      rec_seq
                                        ROWS BETWEEN  UNBOUNDED PRECEDING
                                         AND  1            PRECEDING
                                       )        AS prev_tr
     ,       LAST_VALUE (tr_ref IGNORE NULLS)  OVER ( PARTITION BY  ac
                                                       ORDER BY      rec_seq     DESC
                                             )        AS next_tr
     FROM    transactions
--     WHERE     ...     -- if you need any filtering, put it here
,     got_tr_cnt     AS
     SELECT     got_trs.*
     ,     COUNT (*) OVER ( PARTITION BY  ac
                              ,            next_tr
                      )    AS tr_cnt
     FROM    got_trs
,     nodes     AS
     SELECT     ac
     ,     tr_ref
     ,     tr_cnt
     ,     ac          AS parent_ac
     ,     prev_tr          AS parent_tr
     FROM     got_tr_cnt
     WHERE     tr_ref     IS NOT NULL
    UNION
     SELECT     s.ac
     ,     s.tr_ref
     ,     o.tr_cnt
     ,     o.ac          AS parent_ac
     ,     o.prev_tr     AS parent_tr
     FROM     got_tr_cnt     s
     JOIN     got_tr_cnt      o  ON     s.tr_ref     = o.tr_ref
                       AND     s.ac          != o.ac
     WHERE     o.prev_tr        IS NOT NULL
,     graph     AS
     SELECT     tr_ref
     ,     MAX ( LENGTH ( REPLACE ( SYS_CONNECT_BY_PATH ( LPAD ('.', tr_cnt, '.')
                )     AS start_pt
     FROM     nodes
     START WITH     parent_tr     IS NULL
     CONNECT BY     parent_tr     = PRIOR tr_ref
          AND     parent_ac     = PRIOR ac
     GROUP BY     tr_ref
SELECT       t.ac
,       t.rec_seq
,       t.tr_ref
,       t.action
,       t.qty
,       NVL ( g.start_pt
           , 1
           ) + ROW_NUMBER () OVER ( PARTITION BY  ac
                                        ,          NVL ( t.tr_ref
                                                , t.prev_tr
                                        ORDER BY          rec_seq
          - 1     AS new_rec_seq
FROM           got_trs  t
LEFT OUTER JOIN      graph       g  ON  g.tr_ref     = NVL ( t.tr_ref
                                                   , t.prev_tr
ORDER BY  t.ac
,            t.rec_seq
;Output:
AC    REC_SEQ TR_REF ACTION     QTY NEW_REC_SEQ
A1          1        BUY          1           1
A1          2        BUY          4           2
A1          3      1 TR to A2    -2           4
A1          4        SELL        -1           5
A1          5      2 TR from A2   2           8
A1          6        BUY          5           9
A1          7      3 TR to A3    -1          10
A2          1        BUY          5           1
A2          2        BUY          5           2
A2          3        BUY          5           3
A2          4      1 TR from A1   2           4
A2          5        SELL         2           5
A2          6        BUY          1           6
A2          7        BUY          1           7
A2          8      2 TR to A1    -2           8
A2          9        sell         3           9
A2         10      4 TR from A3   3          12
A3          1        BUY          5           1
A3          2      3 TR from A1   1          10
A3          3        SELL         2          11
A3          4      4 TR to A2    -3          12I don't recommend trying to store this number in the table; it will be a nightmare trying to keep it up to date. However, if you do want to store it in the table, you can use something like the query above in a MERGE statement.
When trying to understnad any quiery that uses sub-queries, it can be helpful to run the individual sub-queries by themselves, and study the output.