使用 SQL 从贷方进行有条件借记

Question

我在下面存储交易的结构中有一个表加密交易。

ID	TRANSACTION_TYPEID	TRANSACTION_NAME	AMOUNT
1	101	bitcoin-received	5
2	102	bitcoin-mined	20
3	103	bitcoin-transferred	-5
4	104	bitcoin-lost	-10
5	101	bitcoin-received	55
6	102	bitcoin-mined	8
7	104	bitcoin-lost	-16
8	103	bitcoin-transferred	-5

我希望比特币转移只能从比特币开采中扣除，而比特币丢失可以从比特币接收或比特币开采中扣除，以先到者为准。

以下是预期结果

ID	TRANSACTION_TYPEID	TRANSACTION_NAME	AMOUNT
1	101	bitcoin-received	0
2	102	bitcoin-mined	0
5	101	bitcoin-received	49
6	102	bitcoin-mined	3

Answer 1

假设：

1. 我们不能挖掘或接收小于 0。
2. 我们不能转移或损失我们没有的金额。

不清楚 FIFO 行为涉及什么。一个更好的测试用例可能会有所帮助。

这是一个更新的测试用例，包含上述数据，然后是一个稍大的数据集，以及一个尝试引入 FIFO 逻辑的解决方案：

The updated test case with more data and FIFO logic

以下解决方案使用一些计算来完成这项工作。

在cte1 中我们得出：

1. run_mined - type = 102（挖掘量）的运行总和（按 id 顺序）
2. tot_xfer - 类型总数 = 103（已转移金额）
3. tot_lost - 类型总数 = 104（丢失数量）

那么由于转移的金额只能从挖出的金额中扣除，我们接下来在cte2 中执行此操作，调整挖出的行数。

如果总转移总和大于挖掘行的当前运行总和，则该金额减少到 0。我们已经转移了所有这些金额。

如果总转帐总和不大于当前挖掘数据的运行总和，我们扣除转帐金额，不大于该行当前已挖掘的金额。

任何后续开采的行都不会被触及，因为没有进一步的转移。

在cte1b 中，我们计算run2_in，这是mined 和received 金额的更新运行总和。请注意，mined 的金额已在 cte2 中进行了调整。

cte3 现在执行类似于cte2 的计算，但这次根据剩余的lost 总量按FIFO 顺序调整received 和mined 两种类型（101 和102）。

最后，我们只选择完全调整后的received 和mined 行来显示，以及相应的id 来指示执行FIFO 操作的顺序。

SQL：

WITH cte1 AS (
         SELECT a.*
              , SUM(CASE WHEN (transaction_typeid = 102) THEN 1 ELSE 0 END * amount) OVER (ORDER BY id) AS run_mined   
              , SUM(CASE WHEN (transaction_typeid = 103) THEN 1 ELSE 0 END * amount) OVER ()            AS tot_xfer    
              , SUM(CASE WHEN (transaction_typeid = 104) THEN 1 ELSE 0 END * amount) OVER ()            AS tot_lost    
           FROM cryptotransactionledger a
          ORDER BY id
     )
   , cte2 AS (
         SELECT a.id, a.transaction_typeid,  a.transaction_name
              , CASE WHEN transaction_typeid <> 102        THEN amount
                     WHEN run_mined  <= ABS(tot_xfer )     THEN 0
                     WHEN run_mined  + tot_xfer  >= amount THEN amount
                                                           ELSE run_mined  + tot_xfer 
                 END AS amount
              , run_mined 
              , tot_xfer 
              , tot_lost 
              , amount AS amount1
           FROM cte1 a
     )
   , cte1b AS (
         SELECT a.*
              , SUM(CASE WHEN (transaction_typeid IN (101, 102)) THEN 1 ELSE 0 END * amount) OVER (ORDER BY id) AS run2_in     
           FROM cte2 a
     )
   , cte3 AS (
         SELECT a.id, a.transaction_typeid,  a.transaction_name
              , CASE WHEN transaction_typeid NOT IN (101, 102) THEN amount
                     WHEN run2_in    <= ABS(tot_lost )         THEN 0
                     WHEN run2_in    + tot_lost  >= amount     THEN amount
                                                               ELSE run2_in    + tot_lost 
                 END AS amount
              , run_mined 
              , tot_xfer 
              , tot_lost 
              , run2_in
              , amount1
              , amount AS amount2
           FROM cte1b a
     )
SELECT id, transaction_name, amount
  FROM cte3
 WHERE transaction_typeid IN (101, 102)
 ORDER BY id
;

使用来自原始问题的数据的结果（平凡的案例）：

+----+------------------+--------+
| id | transaction_name | amount |
+----+------------------+--------+
|  1 | bitcoin-received |      0 |
|  2 | bitcoin-mined    |     10 |
+----+------------------+--------+

在更新的小提琴中，提供了一个包含更多数据的示例：

新数据：

create table cryptotransactionledger as
    select  1 as id, 101 as transaction_typeid, 'bitcoin-received'    as transaction_name,   5 as amount from dual union all
    select  2 as id, 102 as transaction_typeid, 'bitcoin-mined'       as transaction_name,  20 as amount from dual union all
    select  3 as id, 103 as transaction_typeid, 'bitcoin-transferred' as transaction_name,  -5 as amount from dual union all
    select  4 as id, 104 as transaction_typeid, 'bitcoin-lost'        as transaction_name, -10 as amount from dual union all
    select  5 as id, 101 as transaction_typeid, 'bitcoin-received'    as transaction_name,  55 as amount from dual union all
    select 15 as id, 102 as transaction_typeid, 'bitcoin-mined'       as transaction_name,   8 as amount from dual union all
    select 16 as id, 102 as transaction_typeid, 'bitcoin-mined'       as transaction_name,  20 as amount from dual union all
    select 17 as id, 102 as transaction_typeid, 'bitcoin-mined'       as transaction_name,  30 as amount from dual union all
    select 18 as id, 103 as transaction_typeid, 'bitcoin-transferred' as transaction_name,  -5 as amount from dual union all
    select 19 as id, 103 as transaction_typeid, 'bitcoin-transferred' as transaction_name,  -5 as amount from dual union all
    select 20 as id, 103 as transaction_typeid, 'bitcoin-transferred' as transaction_name,  -5 as amount from dual union all
    select 30 as id, 103 as transaction_typeid, 'bitcoin-transferred' as transaction_name,  -5 as amount from dual union all
    select 31 as id, 103 as transaction_typeid, 'bitcoin-transferred' as transaction_name,  -4 as amount from dual union all
    select 40 as id, 104 as transaction_typeid, 'bitcoin-lost'        as transaction_name, -16 as amount from dual union all
    select 99 as id, 103 as transaction_typeid, 'bitcoin-transferred' as transaction_name,  -5 as amount from dual WHERE 1 = 0
;

结果：

+----+------------------+--------+
| id | transaction_name | amount |
+----+------------------+--------+
|  1 | bitcoin-received |      0 |
|  2 | bitcoin-mined    |      0 |
|  5 | bitcoin-received |     34 |
| 15 | bitcoin-mined    |      0 |
| 16 | bitcoin-mined    |     19 |
| 17 | bitcoin-mined    |     30 |
+----+------------------+--------+

Answer 2

以下答案滥用递归来实现循环。

• 写一个实际的循环可能会更好...

这是因为 FIFO 规则意味着无法提前知道哪些 mined/received 记录将被 lost 记录减少。因此，它们每个 lost/transferred 记录必须被完全处理，然后才能开始分配下一个 lost/transferred 记录。

然后，我使用了以下逻辑……

• income 记录是当transaction_typeid 是101 或102。
• outgoing 记录是transaction_typeid 是103 或104。
• 如果outgoing 是104/lost 类型，它可以应用于任何 income 类型。否则outgoing必须是103/transferred类型，并且只能应用于income类型102/mined。

那么……

• 创建一个包含所有 income 记录的记录集
• 将outgoing 记录加入到该集合中，一次一个（最低id 第一）
• 最多可以分配给第一条income记录是LEAST(in.amount, out.amount)
• 对于第二条记录，变为LEAST(in.amount, out.amount - <amount allocated to row1>)

使用窗口函数，变成（伪代码）...

LEAST(
  in.amount,
  GREATEST(
    0,
    out.amount - SUM(in.amount) OVER (<all-preceding-rows>)
  )
)
WHERE out.transcation_type_id = 104
   OR  in.transaction_type_id = 102

所以，最后的（相当长） 查询是......

WITH
  income
AS
(
  SELECT
    c.id,
    c.transaction_typeid,
    c.amount
  FROM
    cryptotransactionledger  c
  WHERE
    c.transaction_typeid IN (101, 102)
),
  outgoing
AS
(
  SELECT
    o.*,
    ROW_NUMBER() OVER (ORDER BY o.id)  AS seq_num
  FROM
    cryptotransactionledger  o
  WHERE
    o.transaction_typeid IN (103, 104)
),
  fifo(
    depth, id, transaction_typeid, amount
  )
AS
(
  SELECT 0, i.* FROM income i
  ---------
  UNION ALL
  ---------
  SELECT
    f.depth + 1,
    f.id,
    f.transaction_typeid,
    f.amount
    -
    LEAST(
      -- everything remaining
      f.amount,
      -- the remaining available deductions
      GREATEST(
        0,
        CASE WHEN o.transaction_typeid = 104 THEN -o.amount
             WHEN f.transaction_typeid = 102 THEN -o.amount
                                             ELSE 0         END
        -
        -- the total amount from all preceding income rows
        COALESCE(
          SUM(CASE WHEN o.transaction_typeid = 104 THEN f.amount
                   WHEN f.transaction_typeid = 102 THEN f.amount
                                                   ELSE 0         END
          )
          OVER (ORDER BY f.id
                    ROWS BETWEEN UNBOUNDED PRECEDING
                             AND         1 PRECEDING
          ),
          0
        )
      )
    )
  FROM
    fifo     f
  INNER JOIN
    outgoing o
      ON o.seq_num = f.depth + 1
)
SELECT
  f.*
FROM
  fifo  f
WHERE
  f.depth = (SELECT MAX(depth) FROM fifo)
ORDER BY
  f.id
;

这是一个演示，基于您提出的问题。

• https://dbfiddle.uk/?rdbms=oracle_11.2&fiddle=4f5e6510fdea80e547252513f6397b43

Answer 3

这里的逻辑与我的递归 CTE 相同，但写成纯循环。

• 递归 CTE 将在 2000 条 outgoing 记录之后失败。

创建一个临时表来保存正在处理的值...

CREATE GLOBAL TEMPORARY TABLE temp_cryptotransactionledger (
  id                  INT,
  transaction_typeid  INT,
  transaction_name    VARCHAR2(32),
  amount              INT
);

循环遍历每条outgoing 记录，并应用 FIFO 逻辑...

DECLARE
  CURSOR cur_outgoing IS
    SELECT id, transaction_typeid, amount
      FROM cryptotransactionledger
     WHERE transaction_typeid IN (103, 104)
  ORDER BY id;
BEGIN
  INSERT INTO temp_cryptotransactionledger
    SELECT c.*
      FROM cryptotransactionledger c
     WHERE c.transaction_typeid IN (101, 102);

  FOR o
  IN cur_outgoing
  LOOP
    MERGE INTO
      temp_cryptotransactionledger  t
    USING
    (
      SELECT
        i.id,
        LEAST(
          i.amount,
          GREATEST(
            0,
            i.amount - o.amount - SUM(i.amount) OVER (ORDER BY i.id)
          )
        )
          AS amount
      FROM
        temp_cryptotransactionledger  i
      WHERE
            i.id     < o.id
        AND i.amount > 0
        AND (
             o.transaction_typeid = 104
          OR i.transaction_typeid = 102
        )
    )
      f
        ON  (t.id = f.id)
    WHEN MATCHED THEN UPDATE SET
      t.amount = t.amount - f.amount
    ;
  END LOOP;
END;
/

选出结果...

SELECT * FROM temp_cryptotransactionledger;

演示...

• https://dbfiddle.uk/?rdbms=oracle_11.2&fiddle=7426efe17e9ee3cf3de61486cbdb865d

Answer 4

您可以使用PIPELINED 函数并且只读取表一次：

CREATE FUNCTION process_cryptotransledger
  RETURN cryptotransactionledger_ttype PIPELINED
IS
  transactions cryptotransactionledger_ttype;
  loss_amount INT;
BEGIN
  SELECT cryptotransactionledger_type(
           id,
           transaction_typeid,
           transaction_name,
           amount
         )
  BULK COLLECT INTO transactions
  FROM   cryptotransactionledger
  ORDER BY id;
  
  
  FOR loss IN 1 .. transactions.COUNT
  LOOP
    IF transactions(loss).transaction_name
         IN ('bitcoin-received', 'bitcoin-mined')
    THEN
      CONTINUE;
    END IF;

    loss_amount := transactions(loss).amount;

    FOR gain IN 1 .. transactions.COUNT
    LOOP
      EXIT WHEN loss_amount >= 0;
      
      IF transactions(gain).amount <= 0
      OR (
         transactions(gain).transaction_name <> 'bitcoin-mined'
         AND transactions(loss).transaction_name = 'bitcoin-transferred'
      )
      THEN
        CONTINUE;
      END IF;
      
      IF -loss_amount >= transactions(gain).amount THEN
        loss_amount := loss_amount + transactions(gain).amount;
        transactions(gain).amount := 0;
      ELSE
        transactions(gain).amount := transactions(gain).amount + loss_amount;
        loss_amount := 0;
      END IF;
    END LOOP;
  END LOOP;

  FOR i IN 1 .. transactions.COUNT
  LOOP
    IF transactions(i).transaction_name
         IN ('bitcoin-received', 'bitcoin-mined')
    THEN
      PIPE ROW (transactions(i));
    END IF;
  END LOOP;
END;
/

定义数据类型后：

CREATE TYPE cryptotransactionledger_type AS OBJECT(
  id                 INT,
  transaction_typeid INT,
  transaction_name   VARCHAR2(30),
  amount             INT
);

CREATE TYPE cryptotransactionledger_ttype
  AS TABLE OF cryptotransactionledger_type;

那么，对于样本数据：

CREATE TABLE cryptotransactionledger (
  id, transaction_typeid, transaction_name, amount
) AS
  SELECT 1, 101, 'bitcoin-received',      5 FROM DUAL UNION ALL
  SELECT 2, 102, 'bitcoin-mined',        20 FROM DUAL UNION ALL
  SELECT 3, 103, 'bitcoin-transferred',  -5 FROM DUAL UNION ALL
  SELECT 4, 104, 'bitcoin-lost',        -10 FROM DUAL UNION ALL
  SELECT 5, 101, 'bitcoin-received',     55 FROM DUAL UNION ALL
  SELECT 6, 102, 'bitcoin-mined',         8 FROM DUAL UNION ALL
  SELECT 7, 104, 'bitcoin-lost',        -16 FROM DUAL UNION ALL
  SELECT 8, 103, 'bitcoin-transferred',  -5 FROM DUAL;

查询：

SELECT *
FROM   TABLE(process_cryptotransledger());

输出：

ID	TRANSACTION_TYPEID	TRANSACTION_NAME	AMOUNT
1	101	bitcoin-received	0
2	102	bitcoin-mined	0
5	101	bitcoin-received	49
6	102	bitcoin-mined	3

---

更新

如果表很大，那么更有效的解决方案可能是分批处理它（同样，只从表中读取一次）并将收益保存在一个单独的集合中，并在它们完成后立即将它们作为输出管道已完全处理：

CREATE OR REPLACE FUNCTION process_cryptotransledger
  RETURN cryptotransactionledger_ttype PIPELINED
IS
  CURSOR transactions_cur IS
    SELECT cryptotransactionledger_type(
             id,
             transaction_typeid,
             transaction_name,
             amount
           )
    FROM   cryptotransactionledger
    ORDER BY id;

  transactions cryptotransactionledger_ttype;
  loss         cryptotransactionledger_type;
  gains        cryptotransactionledger_ttype := cryptotransactionledger_ttype();
  gain         PLS_INTEGER;
BEGIN
  OPEN transactions_cur;
  
  LOOP
    FETCH transactions_cur
    BULK COLLECT INTO transactions
    LIMIT 1000; -- Set the batch size to an appropriate level.
    
    EXIT WHEN transactions.COUNT = 0;
    
    FOR i IN 1 .. transactions.COUNT
    LOOP
      -- Process each item in the batch.

      IF transactions(i).transaction_name
           IN ('bitcoin-received', 'bitcoin-mined')
      THEN
        -- Store the gains.
        gains.EXTEND();
        gains(gains.LAST) :=  transactions(i);
        CONTINUE;
      END IF;

      -- Process each loss.
      loss := transactions(i);

      gain := gains.FIRST;
      WHILE gain IS NOT NULL AND gains(gain).amount = 0
      LOOP
        -- Pipe the fully processed gain rows
        PIPE ROW( gains(gain) );
        gains.DELETE(gain);
        gain := gains.FIRST;
      END LOOP;
      
      -- Update the first appropriate gain row(s) with the loss amount.
      WHILE gain IS NOT NULL AND loss.amount < 0
      LOOP
        IF gains(gain).amount > 0
        AND (
           gains(gain).transaction_name = 'bitcoin-mined'
           OR loss.transaction_name <> 'bitcoin-transferred'
        )
        THEN
          IF -loss.amount >= gains(gain).amount THEN
            loss.amount := loss.amount + gains(gain).amount;
            gains(gain).amount := 0;
          ELSE
            gains(gain).amount := gains(gain).amount + loss.amount;
            loss.amount := 0;
          END IF;
        END IF;
        gain := gains.NEXT(gain);
      END LOOP;
    END LOOP;
  END LOOP;
  
  CLOSE transactions_cur;

  -- Pipe the remaining gain rows.
  FOR i IN gains.FIRST .. gains.LAST
  LOOP
    PIPE ROW (gains(i));
  END LOOP;
END;
/

db小提琴here