如何用COBOL实现百万级销售记录的客户分组聚合？

这是COBOL处理这类批量文件汇总的经典场景，完全不需要复杂的数据结构或数据库，用排序+顺序累加的范式就能高效解决，这就是最地道的“COBOL式方法”：

核心思路 #

COBOL的强项就是批量文件处理，尤其是针对大文件的排序和合并操作。具体步骤分两步：

1. 先对源销售文件按客户ID排序：利用COBOL内置的SORT语句，它会自动处理大文件的外部排序（不需要全加载到内存），效率极高，完全能应对百万级记录。
2. 遍历排序后的文件，逐客户累加汇总：排序后同一客户的所有销售记录会连续排列，只需要维护一组临时变量（当前客户ID、累计销售数量、累计销售总额），每读到一条记录就判断是否和当前客户一致：
   • 一致就累加数量和金额
   • 不一致就把当前客户的汇总结果写入输出文件，然后重置临时变量为新客户的信息
   • 最后别忘了处理文件末尾的最后一个客户

代码示例片段 #

1. 文件定义（FILE SECTION） #

FILE SECTION.
FD  SALES-INPUT-FILE
    RECORDING MODE F
    LABEL RECORDS STANDARD.
01  SALES-RECORD.
    05  CUST-ID-IN        PIC X(10).
    05  SALES-QTY-IN      PIC 9(5).
    05  SALES-AMT-IN      PIC 9(8)V99.

SD  SORTED-SALES-FILE.
01  SORTED-SALES-RECORD.
    05  CUST-ID-SORT      PIC X(10).
    05  SALES-QTY-SORT    PIC 9(5).
    05  SALES-AMT-SORT    PIC 9(8)V99.

FD  CUST-SUMMARY-FILE
    RECORDING MODE F
    LABEL RECORDS STANDARD.
01  CUST-SUMMARY-RECORD.
    05  CUST-ID-OUT       PIC X(10).
    05  TOTAL-QTY-OUT     PIC 9(6).
    05  TOTAL-AMT-OUT     PIC 9(9)V99.

2. 排序与汇总处理（PROCEDURE DIVISION） #

PROCEDURE DIVISION.
000-MAIN.
    SORT SORTED-SALES-FILE
        ON ASCENDING KEY CUST-ID-SORT
        INPUT PROCEDURE IS 100-READ-SALES
        OUTPUT PROCEDURE IS 200-GENERATE-SUMMARY.
    STOP RUN.

100-READ-SALES.
    OPEN INPUT SALES-INPUT-FILE.
    PERFORM UNTIL END-OF-SALES = 'Y'
        READ SALES-INPUT-FILE
            AT END SET END-OF-SALES TO 'Y'
            NOT AT END RELEASE SORTED-SALES-RECORD FROM SALES-RECORD
        END-READ
    END-PERFORM.
    CLOSE SALES-INPUT-FILE.

200-GENERATE-SUMMARY.
    OPEN OUTPUT CUST-SUMMARY-FILE.
    INITIALIZE WS-CURRENT-CUST, WS-TOTAL-QTY, WS-TOTAL-AMT.
    PERFORM UNTIL END-OF-SORTED = 'Y'
        READ SORTED-SALES-FILE
            AT END SET END-OF-SORTED TO 'Y'
            NOT AT END
                IF CUST-ID-SORT NOT = WS-CURRENT-CUST
                    IF WS-CURRENT-CUST NOT = SPACES
                        MOVE WS-CURRENT-CUST TO WS-CUST-ID-OUT
                        MOVE WS-TOTAL-QTY TO WS-TOTAL-QTY-OUT
                        MOVE WS-TOTAL-AMT TO WS-TOTAL-AMT-OUT
                        WRITE CUST-SUMMARY-RECORD FROM WS-SUMMARY-RECORD
                    END-IF
                    MOVE CUST-ID-SORT TO WS-CURRENT-CUST
                    MOVE SALES-QTY-SORT TO WS-TOTAL-QTY
                    MOVE SALES-AMT-SORT TO WS-TOTAL-AMT
                ELSE
                    ADD SALES-QTY-SORT TO WS-TOTAL-QTY
                    ADD SALES-AMT-SORT TO WS-TOTAL-AMT
                END-IF
        END-READ
    END-PERFORM.
    * 处理最后一个客户的汇总数据
    IF WS-CURRENT-CUST NOT = SPACES
        MOVE WS-CURRENT-CUST TO WS-CUST-ID-OUT
        MOVE WS-TOTAL-QTY TO WS-TOTAL-QTY-OUT
        MOVE WS-TOTAL-AMT TO WS-TOTAL-AMT-OUT
        WRITE CUST-SUMMARY-RECORD FROM WS-SUMMARY-RECORD
    END-IF.
    CLOSE CUST-SUMMARY-FILE.

* 工作存储节定义临时变量
WORKING-STORAGE SECTION.
01  WS-CURRENT-CUST       PIC X(10) VALUE SPACES.
01  WS-TOTAL-QTY          PIC 9(6) VALUE ZEROS.
01  WS-TOTAL-AMT          PIC 9(9)V99 VALUE ZEROS.
01  WS-SUMMARY-RECORD.
    05  WS-CUST-ID-OUT     PIC X(10).
    05  WS-TOTAL-QTY-OUT   PIC 9(6).
    05  WS-TOTAL-AMT-OUT   PIC 9(9)V99.
01  END-OF-SALES          PIC X VALUE 'N'.
01  END-OF-SORTED         PIC X VALUE 'N'.

为什么这是最优解？ #

• 完全适配COBOL的设计初衷：批量处理海量文件，SORT语句是经过工业级优化的，处理百万级记录毫无压力，不需要自己实现复杂的排序逻辑。
• 内存占用极低：排序过程由COBOL runtime自动处理磁盘缓存和分块排序，不需要把所有数据加载到内存，彻底规避数组的性能问题。
• 逻辑简单直观：排序后同客户记录连续，只需要一次顺序遍历就能完成汇总，代码维护性强，是COBOL开发的标准做法。

内容的提问来源于stack exchange，提问作者karbi79