What are data access patterns in COBOL?

Strategies for reading and writing data files: sequential, random, indexed, and VSAM access methods for different business requirements.

When should I use sequential vs random access?

Use sequential for processing all records in order, random for accessing specific records by key, and indexed for both sequential and random access.

How do I optimize data access performance?

Choose appropriate access methods, use proper indexing, implement efficient search algorithms, and minimize I/O operations.

MainframeMaster

COBOL Data Access Patterns

Data access patterns determine how programs retrieve and process data from files. Learn sequential, random, indexed, and VSAM access methods for efficient data handling in business applications.

Sequential Access Pattern

cobol

1
2
3
4
5
6
7
8
9
10
       *> Sequential processing of all records
       OPEN INPUT CUSTOMER-FILE
       PERFORM UNTIL EOF
           READ CUSTOMER-FILE AT END SET EOF TO TRUE
           NOT AT END
               DISPLAY 'Customer: ' CUSTOMER-NAME
               PERFORM PROCESS-CUSTOMER-RECORD
           END-READ
       END-PERFORM
       CLOSE CUSTOMER-FILE.

Sequential access reads records in the order they appear in the file. Use this pattern for batch processing, reports, and when you need to process all records. Most efficient for large-scale data processing.

Random Access Pattern

cobol

1
2
3
4
5
6
7
8
9
10
11
12
       *> Random access by key
       OPEN I-O CUSTOMER-FILE
       MOVE SEARCH-CUSTOMER-ID TO CUSTOMER-ID
       READ CUSTOMER-FILE KEY IS CUSTOMER-ID
           INVALID KEY
               DISPLAY 'Customer not found: ' CUSTOMER-ID
           NOT INVALID KEY
               DISPLAY 'Found customer: ' CUSTOMER-NAME
               PERFORM UPDATE-CUSTOMER-RECORD
               REWRITE CUSTOMER-RECORD
       END-READ
       CLOSE CUSTOMER-FILE.

Random access retrieves specific records by key value. Use this pattern for online applications, lookups, and updates. Requires indexed or VSAM files for efficient key-based access.

Indexed Access Pattern

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
       *> Indexed file with multiple keys
       OPEN I-O INDEXED-CUSTOMER-FILE
       
       *> Access by primary key
       MOVE PRIMARY-KEY TO CUSTOMER-ID
       READ INDEXED-CUSTOMER-FILE KEY IS CUSTOMER-ID
           INVALID KEY
               DISPLAY 'Primary key not found'
           NOT INVALID KEY
               PERFORM PROCESS-BY-PRIMARY-KEY
       END-READ
       
       *> Access by alternate key
       MOVE ALTERNATE-KEY TO CUSTOMER-NAME
       READ INDEXED-CUSTOMER-FILE KEY IS CUSTOMER-NAME
           INVALID KEY
               DISPLAY 'Alternate key not found'
           NOT INVALID KEY
               PERFORM PROCESS-BY-ALTERNATE-KEY
       END-READ.

Indexed access supports multiple keys (primary and alternate) for flexible data retrieval. Use this pattern when you need to access data by different criteria. Provides both sequential and random access capabilities.

VSAM Access Patterns

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
       *> VSAM KSDS (Key Sequenced Data Set)
       OPEN I-O VSAM-CUSTOMER-FILE
       
       *> Sequential access
       START VSAM-CUSTOMER-FILE KEY IS GREATER THAN START-KEY
       PERFORM UNTIL EOF
           READ VSAM-CUSTOMER-FILE NEXT RECORD AT END SET EOF TO TRUE
           NOT AT END
               PERFORM PROCESS-VSAM-RECORD
           END-READ
       END-PERFORM
       
       *> Random access
       MOVE SEARCH-KEY TO CUSTOMER-KEY
       READ VSAM-CUSTOMER-FILE KEY IS CUSTOMER-KEY
           INVALID KEY
               DISPLAY 'VSAM record not found'
           NOT INVALID KEY
               PERFORM PROCESS-VSAM-RECORD
       END-READ.

VSAM provides advanced access patterns with KSDS (Key Sequenced Data Set) for both sequential and random access. Use START to position for sequential reading and READ for random access by key.

Batch Processing Pattern

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
       *> Process multiple files in batch
       OPEN INPUT TRANSACTION-FILE
       OPEN I-O CUSTOMER-FILE
       OPEN OUTPUT REPORT-FILE
       
       PERFORM UNTIL EOF
           READ TRANSACTION-FILE AT END SET EOF TO TRUE
           NOT AT END
               MOVE TRANS-CUSTOMER-ID TO CUSTOMER-ID
               READ CUSTOMER-FILE KEY IS CUSTOMER-ID
                   INVALID KEY
                       PERFORM PROCESS-INVALID-CUSTOMER
                   NOT INVALID KEY
                       PERFORM PROCESS-VALID-TRANSACTION
               END-READ
           END-READ
       END-PERFORM
       
       CLOSE TRANSACTION-FILE CUSTOMER-FILE REPORT-FILE.

Batch processing combines multiple files for comprehensive data processing. Read from input files, lookup reference data, and write to output files. Efficient for large-scale data processing operations.

Lookup Table Pattern

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
       *> Load lookup table into memory
       MOVE 0 TO LOOKUP-COUNT
       OPEN INPUT LOOKUP-FILE
       PERFORM UNTIL EOF OR LOOKUP-COUNT = MAX-LOOKUP-SIZE
           READ LOOKUP-FILE AT END SET EOF TO TRUE
           NOT AT END
               ADD 1 TO LOOKUP-COUNT
               MOVE LOOKUP-KEY TO TABLE-KEY(LOOKUP-COUNT)
               MOVE LOOKUP-VALUE TO TABLE-VALUE(LOOKUP-COUNT)
           END-READ
       END-PERFORM
       CLOSE LOOKUP-FILE.
       
       *> Use lookup table
       PERFORM VARYING I FROM 1 BY 1 UNTIL I > LOOKUP-COUNT
           IF TABLE-KEY(I) = SEARCH-KEY
               MOVE TABLE-VALUE(I) TO FOUND-VALUE
               EXIT PERFORM
           END-IF
       END-PERFORM.

Load small reference tables into memory for fast lookups. Use this pattern when you need frequent access to reference data. More efficient than repeated file reads for small datasets.

Stream Processing Pattern

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
       *> Process data in streams
       OPEN INPUT INPUT-STREAM
       OPEN OUTPUT OUTPUT-STREAM
       
       PERFORM UNTIL EOF
           READ INPUT-STREAM AT END SET EOF TO TRUE
           NOT AT END
               PERFORM TRANSFORM-RECORD
               WRITE OUTPUT-RECORD
           END-READ
       END-PERFORM
       
       CLOSE INPUT-STREAM OUTPUT-STREAM.

Stream processing reads input data, transforms it, and writes output data in a continuous flow. Use this pattern for data transformation, ETL operations, and real-time processing applications.

Error Handling in Access Patterns

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
       READ CUSTOMER-FILE KEY IS CUSTOMER-ID
           INVALID KEY
               DISPLAY 'Error: Customer not found - ' CUSTOMER-ID
               ADD 1 TO NOT-FOUND-COUNT
               PERFORM LOG-ERROR
           NOT INVALID KEY
               ADD 1 TO SUCCESS-COUNT
               PERFORM PROCESS-CUSTOMER
       END-READ.
       
       *> Check file status for additional error handling
       IF FILE-STATUS NOT = '00'
           DISPLAY 'File error: ' FILE-STATUS
           PERFORM ERROR-HANDLING
       END-IF.

Implement comprehensive error handling for all access patterns. Handle INVALID KEY conditions, check FILE-STATUS codes, and provide meaningful error messages. Log errors for troubleshooting and monitoring.

Choose access patterns based on data usage requirements.
Use sequential access for batch processing and reports.
Implement random access for online lookups and updates.
Consider indexed files for multiple access keys.
Handle errors comprehensively in all access patterns.

File Processing

File handling concepts

Indexed Files

Indexed file operations