How do I load a table?

Read records from a file, increment a counter, and MOVE fields into the table until EOF or you reach capacity.

How do I validate a table?

Validate each row as it is loaded; maintain counts of valid/invalid to report issues.

When to use SEARCH ALL?

When the table is sorted by key; it performs a binary search.

COBOL Table Processing Concepts

Table processing is the end-to-end pattern: load data, validate, transform, sort as needed, and search for fast lookups. Keep operations bounded and predictable. This covers the complete lifecycle of working with in-memory tables.

1) Loading a Table

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
       01 MAX-ROWS        PIC 9(4) VALUE 500.
       01 ROW-COUNT       PIC 9(4) VALUE 0.
       01 TABLE.
           05 ROW OCCURS 500 TIMES INDEXED BY ROW-IX.
              10 KEY   PIC 9(6).
              10 NAME  PIC X(30).
              10 AMOUNT PIC 9(9)V99.
       ...
       OPEN INPUT SOURCE-FILE
       PERFORM UNTIL EOF OR ROW-COUNT = MAX-ROWS
           READ SOURCE-FILE AT END SET EOF TO TRUE NOT AT END
               ADD 1 TO ROW-COUNT
               MOVE SRC-KEY    TO KEY(ROW-COUNT)
               MOVE SRC-NAME   TO NAME(ROW-COUNT)
               MOVE SRC-AMOUNT TO AMOUNT(ROW-COUNT)
           END-READ
       END-PERFORM
       CLOSE SOURCE-FILE.

Stop when you reach EOF or capacity to avoid overrun. Always check both conditions to prevent buffer overflow. The ROW-COUNT tells you how many valid records were loaded.

2) Validating Rows

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
       01 VALID-COUNT PIC 9(4) VALUE 0.
       01 BAD-COUNT   PIC 9(4) VALUE 0.
       01 ERROR-MSG   PIC X(50).
       PERFORM VARYING I FROM 1 BY 1 UNTIL I > ROW-COUNT
           IF KEY(I) = 0 OR KEY(I) < 100000
               ADD 1 TO BAD-COUNT
               MOVE 'Invalid key' TO ERROR-MSG
           ELSE IF NAME(I) = SPACES OR NAME(I) = LOW-VALUES
               ADD 1 TO BAD-COUNT
               MOVE 'Missing name' TO ERROR-MSG
           ELSE IF AMOUNT(I) < 0
               ADD 1 TO BAD-COUNT
               MOVE 'Negative amount' TO ERROR-MSG
           ELSE
               ADD 1 TO VALID-COUNT
           END-IF
       END-PERFORM.

Validate early and track counts for reporting. Check for common data quality issues: missing values, invalid ranges, negative amounts. Maintain separate counters for valid and invalid records.

3) Transform / Normalize

cobol

1
2
3
       PERFORM VARYING I FROM 1 BY 1 UNTIL I > ROW-COUNT
           MOVE FUNCTION UPPER-CASE(NAME(I)) TO NAME(I)
       END-PERFORM.

4) Sort Before Binary Search

cobol

1
2
3
4
5
6
7
8
9
10
       *> Simple bubble pass (demo only)
       PERFORM VARYING I FROM 1 BY 1 UNTIL I > ROW-COUNT - 1
           PERFORM VARYING J FROM 1 BY 1 UNTIL J > ROW-COUNT - I
               IF KEY(J) > KEY(J + 1)
                   MOVE KEY(J) TO TEMP-KEY
                   MOVE KEY(J + 1) TO KEY(J)
                   MOVE TEMP-KEY TO KEY(J + 1)
               END-IF
           END-PERFORM
       END-PERFORM.

3) Transform / Normalize

cobol

1
2
3
4
5
6
       PERFORM VARYING I FROM 1 BY 1 UNTIL I > ROW-COUNT
           MOVE FUNCTION UPPER-CASE(NAME(I)) TO NAME(I)
           IF AMOUNT(I) > 1000000
               COMPUTE AMOUNT(I) = AMOUNT(I) / 1000
           END-IF
       END-PERFORM.

Normalize data for consistency: convert names to uppercase, scale large amounts, trim spaces. This reduces comparison errors and makes data more uniform for processing.

4) Sort Before Binary Search

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
       *> Simple bubble sort (for small tables)
       PERFORM VARYING I FROM 1 BY 1 UNTIL I > ROW-COUNT - 1
           PERFORM VARYING J FROM 1 BY 1 UNTIL J > ROW-COUNT - I
               IF KEY(J) > KEY(J + 1)
                   MOVE KEY(J) TO TEMP-KEY
                   MOVE KEY(J + 1) TO KEY(J)
                   MOVE TEMP-KEY TO KEY(J + 1)
                   MOVE NAME(J) TO TEMP-NAME
                   MOVE NAME(J + 1) TO NAME(J)
                   MOVE TEMP-NAME TO NAME(J + 1)
                   MOVE AMOUNT(J) TO TEMP-AMOUNT
                   MOVE AMOUNT(J + 1) TO AMOUNT(J)
                   MOVE TEMP-AMOUNT TO AMOUNT(J + 1)
               END-IF
           END-PERFORM
       END-PERFORM.

Sort all related fields together when swapping. For larger tables (1000+ records), consider external SORT utility or load from pre-sorted files for better performance.

5) Lookups

cobol

1
2
3
4
5
6
       SET ROW-IX TO 1
       SEARCH ALL ROW
           AT END DISPLAY 'Not found'
           WHEN KEY(ROW-IX) = SEARCH-KEY
                DISPLAY 'Found: ' NAME(ROW-IX) ' Amount: ' AMOUNT(ROW-IX)
       END-SEARCH.

6) Reporting Results

cobol

1
2
3
4
5
       DISPLAY 'Table Processing Complete'
       DISPLAY 'Total records loaded: ' ROW-COUNT
       DISPLAY 'Valid records: ' VALID-COUNT
       DISPLAY 'Invalid records: ' BAD-COUNT
       DISPLAY 'Processing time: ' PROCESSING-TIME ' seconds'.

Cap loads with MAX-ROWS to prevent buffer overflow.
Sort before SEARCH ALL for optimal performance.
Normalize to reduce comparison errors and improve data quality.
Validate early and maintain counts for reporting.
Report processing statistics for monitoring and debugging.

Table Handling

Basics of OCCURS and INDEXED BY

Search Techniques

Sequential vs binary search