MainframeMaster

COBOL Tutorial

COBOL READ and END-READ

COBOL READ and END-READ represent comprehensive record retrieval mechanisms and sophisticated file input operations within advanced data processing environments, providing intelligent record access capabilities for optimal data retrieval, enhanced file navigation features for complex input workflows, and systematic record reading patterns that enable precise data acquisition, efficient file processing operations, and strategic input control while maintaining data integrity, ensuring predictable read behavior, and enabling flexible input architectures across enterprise applications requiring exact record retrieval, comprehensive file access capabilities, and reliable data input throughout sophisticated business processing scenarios and high-performance file management environments.

Basic READ Operations

Fundamental READ Statement Syntax
Essential READ patterns for sequential and random file access
cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
*> Basic READ operations and syntax patterns IDENTIFICATION DIVISION. PROGRAM-ID. READ-DEMONSTRATION. ENVIRONMENT DIVISION. INPUT-OUTPUT SECTION. FILE-CONTROL. *> Sequential file for basic read operations SELECT CUSTOMER-FILE ASSIGN TO "customers.seq" ORGANIZATION IS SEQUENTIAL ACCESS MODE IS SEQUENTIAL FILE STATUS IS WS-CUST-STATUS. *> Indexed file for key-based reads SELECT PRODUCT-FILE ASSIGN TO "products.idx" ORGANIZATION IS INDEXED ACCESS MODE IS RANDOM RECORD KEY IS PROD-KEY ALTERNATE RECORD KEY IS PROD-NAME WITH DUPLICATES FILE STATUS IS WS-PROD-STATUS. *> Relative file for record number access SELECT INVENTORY-FILE ASSIGN TO "inventory.rel" ORGANIZATION IS RELATIVE ACCESS MODE IS DYNAMIC RELATIVE KEY IS WS-REL-KEY FILE STATUS IS WS-INV-STATUS. DATA DIVISION. FILE SECTION. FD CUSTOMER-FILE. 01 CUSTOMER-RECORD. 05 CUST-ID PIC X(8). 05 CUST-NAME PIC X(30). 05 CUST-ADDRESS PIC X(50). 05 CUST-PHONE PIC X(15). 05 CUST-BALANCE PIC S9(7)V99 COMP-3. FD PRODUCT-FILE. 01 PRODUCT-RECORD. 05 PROD-KEY PIC X(10). 05 PROD-NAME PIC X(25). 05 PROD-CATEGORY PIC X(15). 05 PROD-PRICE PIC S9(5)V99 COMP-3. 05 PROD-QUANTITY PIC S9(5) COMP-3. FD INVENTORY-FILE. 01 INVENTORY-RECORD. 05 INV-ITEM-CODE PIC X(12). 05 INV-DESCRIPTION PIC X(40). 05 INV-QTY-ON-HAND PIC S9(7) COMP-3. 05 INV-REORDER-POINT PIC S9(5) COMP-3. 05 INV-UNIT-COST PIC S9(5)V99 COMP-3. WORKING-STORAGE SECTION. 01 WS-FILE-STATUS. 05 WS-CUST-STATUS PIC XX. 05 WS-PROD-STATUS PIC XX. 05 WS-INV-STATUS PIC XX. 01 WS-CONTROL-VARIABLES. 05 WS-REL-KEY PIC 9(6) COMP. 05 WS-EOF-FLAG PIC X VALUE 'N'. 05 WS-RECORD-FOUND PIC X VALUE 'N'. 05 WS-RECORD-COUNT PIC 9(6) VALUE 0. 01 WS-READ-TARGETS. 05 WS-CUSTOMER-COPY PIC X(110). 05 WS-PRODUCT-COPY PIC X(60). 05 WS-INVENTORY-COPY PIC X(100). PROCEDURE DIVISION. MAIN-READ-DEMONSTRATION. DISPLAY "=== COBOL READ AND END-READ DEMONSTRATION ===" PERFORM OPEN-FILES PERFORM DEMONSTRATE-SEQUENTIAL-READ PERFORM DEMONSTRATE-RANDOM-READ PERFORM DEMONSTRATE-DYNAMIC-READ PERFORM DEMONSTRATE-READ-INTO PERFORM DEMONSTRATE-READ-NEXT PERFORM CLOSE-FILES DISPLAY "=== READ DEMONSTRATION COMPLETE ===" STOP RUN. OPEN-FILES. DISPLAY " " DISPLAY "πŸ“‚ OPENING FILES FOR READ OPERATIONS" DISPLAY "====================================" OPEN INPUT CUSTOMER-FILE IF WS-CUST-STATUS NOT = "00" DISPLAY "❌ Error opening customer file: " WS-CUST-STATUS STOP RUN ELSE DISPLAY "βœ… Customer file opened for input" END-IF OPEN I-O PRODUCT-FILE IF WS-PROD-STATUS NOT = "00" DISPLAY "❌ Error opening product file: " WS-PROD-STATUS STOP RUN ELSE DISPLAY "βœ… Product file opened for I-O" END-IF OPEN I-O INVENTORY-FILE IF WS-INV-STATUS NOT = "00" DISPLAY "❌ Error opening inventory file: " WS-INV-STATUS STOP RUN ELSE DISPLAY "βœ… Inventory file opened for I-O" END-IF. DEMONSTRATE-SEQUENTIAL-READ. DISPLAY " " DISPLAY "πŸ“– SEQUENTIAL READ OPERATIONS" DISPLAY "=============================" *> Basic sequential read with AT END MOVE 'N' TO WS-EOF-FLAG MOVE 0 TO WS-RECORD-COUNT PERFORM UNTIL WS-EOF-FLAG = 'Y' READ CUSTOMER-FILE AT END MOVE 'Y' TO WS-EOF-FLAG DISPLAY "βœ… End of customer file reached" NOT AT END ADD 1 TO WS-RECORD-COUNT DISPLAY "Customer " WS-RECORD-COUNT ": " CUST-NAME *> Demonstrate processing logic IF CUST-BALANCE > 1000 DISPLAY " πŸ’° High-value customer: $" CUST-BALANCE END-IF END-READ *> Limit display for demonstration IF WS-RECORD-COUNT >= 5 MOVE 'Y' TO WS-EOF-FLAG END-IF END-PERFORM DISPLAY "Total customers read: " WS-RECORD-COUNT. DEMONSTRATE-RANDOM-READ. DISPLAY " " DISPLAY "🎯 RANDOM READ OPERATIONS" DISPLAY "=========================" *> Direct read by primary key MOVE "PROD001" TO PROD-KEY PERFORM READ-PRODUCT-BY-KEY IF WS-RECORD-FOUND = 'Y' DISPLAY "Product found: " PROD-NAME DISPLAY "Category: " PROD-CATEGORY DISPLAY "Price: $" PROD-PRICE ELSE DISPLAY "Product PROD001 not found" END-IF *> Read by alternate key MOVE "Digital Camera" TO PROD-NAME PERFORM READ-PRODUCT-BY-NAME IF WS-RECORD-FOUND = 'Y' DISPLAY "Found by name: " PROD-KEY DISPLAY "Quantity: " PROD-QUANTITY ELSE DISPLAY "Product 'Digital Camera' not found" END-IF *> Attempt to read non-existent record MOVE "PROD999" TO PROD-KEY PERFORM READ-PRODUCT-BY-KEY IF WS-RECORD-FOUND = 'N' DISPLAY "Product PROD999 not found (expected)" END-IF. READ-PRODUCT-BY-KEY. MOVE 'N' TO WS-RECORD-FOUND READ PRODUCT-FILE INVALID KEY DISPLAY "Invalid key: " PROD-KEY NOT INVALID KEY MOVE 'Y' TO WS-RECORD-FOUND DISPLAY "βœ… Product record read successfully" END-READ. READ-PRODUCT-BY-NAME. MOVE 'N' TO WS-RECORD-FOUND READ PRODUCT-FILE KEY IS PROD-NAME INVALID KEY DISPLAY "Product name not found: " PROD-NAME NOT INVALID KEY MOVE 'Y' TO WS-RECORD-FOUND DISPLAY "βœ… Product found by name" END-READ. DEMONSTRATE-DYNAMIC-READ. DISPLAY " " DISPLAY "πŸ”„ DYNAMIC READ OPERATIONS" DISPLAY "==========================" *> Sequential read in dynamic mode DISPLAY "Reading inventory sequentially..." MOVE 0 TO WS-RECORD-COUNT READ INVENTORY-FILE NEXT RECORD AT END DISPLAY "No inventory records available" NOT AT END ADD 1 TO WS-RECORD-COUNT DISPLAY "First inventory item: " INV-DESCRIPTION DISPLAY "Quantity on hand: " INV-QTY-ON-HAND END-READ *> Random read by relative key MOVE 25 TO WS-REL-KEY PERFORM READ-INVENTORY-BY-RELATIVE-KEY IF WS-RECORD-FOUND = 'Y' DISPLAY "Inventory item 25: " INV-DESCRIPTION DISPLAY "Unit cost: $" INV-UNIT-COST END-IF *> Read next record after random access READ INVENTORY-FILE NEXT RECORD AT END DISPLAY "End of inventory file" NOT AT END DISPLAY "Next inventory item: " INV-DESCRIPTION END-READ. READ-INVENTORY-BY-RELATIVE-KEY. MOVE 'N' TO WS-RECORD-FOUND READ INVENTORY-FILE INVALID KEY DISPLAY "Invalid relative key: " WS-REL-KEY NOT INVALID KEY MOVE 'Y' TO WS-RECORD-FOUND DISPLAY "βœ… Inventory record " WS-REL-KEY " read" END-READ. DEMONSTRATE-READ-INTO. DISPLAY " " DISPLAY "πŸ“₯ READ INTO OPERATIONS" DISPLAY "======================" *> Read directly into working storage MOVE "PROD002" TO PROD-KEY READ PRODUCT-FILE INTO WS-PRODUCT-COPY INVALID KEY DISPLAY "Product not found for READ INTO" NOT INVALID KEY DISPLAY "βœ… Product read into working storage" DISPLAY "Copied data length: " FUNCTION LENGTH(WS-PRODUCT-COPY) *> Original record buffer unchanged DISPLAY "Original record key: " PROD-KEY *> Working storage copy can be manipulated MOVE SPACES TO WS-PRODUCT-COPY DISPLAY "Working storage cleared" END-READ *> Sequential read into working storage READ CUSTOMER-FILE INTO WS-CUSTOMER-COPY AT END DISPLAY "No more customers for READ INTO" NOT AT END DISPLAY "βœ… Customer read into working storage" DISPLAY "Customer copy contains: " WS-CUSTOMER-COPY(1:30) END-READ. DEMONSTRATE-READ-NEXT. DISPLAY " " DISPLAY "⏭️ READ NEXT OPERATIONS" DISPLAY "=======================" *> Position at specific key then read next MOVE "PROD001" TO PROD-KEY READ PRODUCT-FILE KEY IS PROD-KEY INVALID KEY DISPLAY "Starting position not found" NOT INVALID KEY DISPLAY "βœ… Positioned at: " PROD-NAME *> Read next records sequentially PERFORM 3 TIMES READ PRODUCT-FILE NEXT RECORD AT END DISPLAY "End of products reached" EXIT PERFORM NOT AT END DISPLAY "Next product: " PROD-NAME DISPLAY " Key: " PROD-KEY DISPLAY " Price: $" PROD-PRICE END-READ END-PERFORM END-READ *> Start from beginning and read next MOVE LOW-VALUES TO PROD-KEY READ PRODUCT-FILE KEY IS GREATER THAN PROD-KEY INVALID KEY DISPLAY "No products in file" NOT INVALID KEY DISPLAY "βœ… First product: " PROD-NAME END-READ. CLOSE-FILES. DISPLAY " " DISPLAY "πŸ”’ CLOSING FILES" DISPLAY "===============" CLOSE CUSTOMER-FILE IF WS-CUST-STATUS NOT = "00" DISPLAY "❌ Error closing customer file" ELSE DISPLAY "βœ… Customer file closed" END-IF CLOSE PRODUCT-FILE IF WS-PROD-STATUS NOT = "00" DISPLAY "❌ Error closing product file" ELSE DISPLAY "βœ… Product file closed" END-IF CLOSE INVENTORY-FILE IF WS-INV-STATUS NOT = "00" DISPLAY "❌ Error closing inventory file" ELSE DISPLAY "βœ… Inventory file closed" END-IF.
File Input
Record Reading
Data Retrieval

Advanced READ Techniques

Complex READ Operations and Error Handling
Advanced patterns for robust file processing and error management
cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
*> Advanced READ techniques with comprehensive error handling IDENTIFICATION DIVISION. PROGRAM-ID. ADVANCED-READ-OPERATIONS. ENVIRONMENT DIVISION. INPUT-OUTPUT SECTION. FILE-CONTROL. SELECT TRANSACTION-FILE ASSIGN TO "transactions.dat" ORGANIZATION IS INDEXED ACCESS MODE IS DYNAMIC RECORD KEY IS TRANS-PRIMARY-KEY ALTERNATE RECORD KEY IS TRANS-DATE-KEY WITH DUPLICATES ALTERNATE RECORD KEY IS TRANS-CUSTOMER-KEY WITH DUPLICATES FILE STATUS IS WS-TRANS-STATUS. SELECT LOG-FILE ASSIGN TO "process.log" ORGANIZATION IS SEQUENTIAL ACCESS MODE IS SEQUENTIAL FILE STATUS IS WS-LOG-STATUS. DATA DIVISION. FILE SECTION. FD TRANSACTION-FILE. 01 TRANSACTION-RECORD. 05 TRANS-PRIMARY-KEY PIC X(15). 05 TRANS-DATE-KEY PIC 9(8). 05 TRANS-CUSTOMER-KEY PIC X(8). 05 TRANS-TYPE PIC X(3). 05 TRANS-AMOUNT PIC S9(9)V99 COMP-3. 05 TRANS-DESCRIPTION PIC X(50). 05 TRANS-STATUS PIC X. 05 TRANS-PROCESSED-BY PIC X(8). 05 TRANS-TIMESTAMP PIC X(14). FD LOG-FILE. 01 LOG-RECORD PIC X(200). WORKING-STORAGE SECTION. 01 WS-FILE-STATUS. 05 WS-TRANS-STATUS PIC XX. 05 WS-LOG-STATUS PIC XX. 01 WS-READ-CONTROL. 05 WS-READ-SUCCESSFUL PIC X VALUE 'N'. 05 WS-RETRY-COUNT PIC 9(2) VALUE 0. 05 WS-MAX-RETRIES PIC 9(2) VALUE 3. 05 WS-TIMEOUT-SECONDS PIC 9(3) VALUE 30. 01 WS-BATCH-PROCESSING. 05 WS-BATCH-KEYS OCCURS 50 TIMES. 10 WS-BATCH-KEY PIC X(15). 10 WS-BATCH-RESULT PIC X. 05 WS-BATCH-SIZE PIC 9(2) VALUE 0. 05 WS-CURRENT-BATCH PIC 9(2) VALUE 0. 01 WS-PERFORMANCE-METRICS. 05 WS-TOTAL-READS PIC 9(7) VALUE 0. 05 WS-SUCCESSFUL-READS PIC 9(7) VALUE 0. 05 WS-FAILED-READS PIC 9(7) VALUE 0. 05 WS-RETRY-ATTEMPTS PIC 9(7) VALUE 0. 05 WS-START-TIME PIC 9(8). 05 WS-END-TIME PIC 9(8). 01 WS-SEARCH-CRITERIA. 05 WS-DATE-FROM PIC 9(8). 05 WS-DATE-TO PIC 9(8). 05 WS-CUSTOMER-LIST OCCURS 10 TIMES. 10 WS-CUSTOMER-ID PIC X(8). 05 WS-AMOUNT-THRESHOLD PIC S9(9)V99 COMP-3. 01 WS-BUFFER-MANAGEMENT. 05 WS-READ-BUFFER PIC X(200). 05 WS-BACKUP-RECORD PIC X(200). 05 WS-BUFFER-VALID PIC X VALUE 'N'. PROCEDURE DIVISION. MAIN-ADVANCED-READ-PROCESSING. DISPLAY "=== ADVANCED READ OPERATIONS ===" PERFORM INITIALIZE-ADVANCED-PROCESSING PERFORM DEMONSTRATE-ERROR-HANDLING-READS PERFORM DEMONSTRATE-BATCH-READING PERFORM DEMONSTRATE-CONDITIONAL-READING PERFORM DEMONSTRATE-BUFFERED-READING PERFORM DEMONSTRATE-PERFORMANCE-READING PERFORM DISPLAY-READ-METRICS PERFORM CLEANUP-ADVANCED-PROCESSING DISPLAY "=== ADVANCED READ PROCESSING COMPLETE ===" STOP RUN. INITIALIZE-ADVANCED-PROCESSING. DISPLAY " " DISPLAY "πŸš€ INITIALIZING ADVANCED READ PROCESSING" DISPLAY "========================================" OPEN I-O TRANSACTION-FILE IF WS-TRANS-STATUS NOT = "00" DISPLAY "❌ Error opening transaction file: " WS-TRANS-STATUS STOP RUN ELSE DISPLAY "βœ… Transaction file opened successfully" END-IF OPEN OUTPUT LOG-FILE IF WS-LOG-STATUS NOT = "00" DISPLAY "❌ Error opening log file: " WS-LOG-STATUS ELSE DISPLAY "βœ… Log file opened successfully" END-IF MOVE FUNCTION CURRENT-DATE(9:6) TO WS-START-TIME MOVE 0 TO WS-TOTAL-READS MOVE 0 TO WS-SUCCESSFUL-READS MOVE 0 TO WS-FAILED-READS MOVE 0 TO WS-RETRY-ATTEMPTS. DEMONSTRATE-ERROR-HANDLING-READS. DISPLAY " " DISPLAY "πŸ›‘οΈ ERROR HANDLING READ OPERATIONS" DISPLAY "==================================" *> Read with comprehensive error handling MOVE "TRANS123456789A" TO TRANS-PRIMARY-KEY PERFORM READ-WITH-ERROR-HANDLING *> Read non-existent record with retry MOVE "NONEXISTENT001" TO TRANS-PRIMARY-KEY PERFORM READ-WITH-RETRY-LOGIC *> Read with timeout simulation MOVE "TRANS999999999Z" TO TRANS-PRIMARY-KEY PERFORM READ-WITH-TIMEOUT-HANDLING. READ-WITH-ERROR-HANDLING. MOVE 'N' TO WS-READ-SUCCESSFUL ADD 1 TO WS-TOTAL-READS READ TRANSACTION-FILE INVALID KEY ADD 1 TO WS-FAILED-READS PERFORM LOG-READ-ERROR DISPLAY "❌ Transaction not found: " TRANS-PRIMARY-KEY NOT INVALID KEY ADD 1 TO WS-SUCCESSFUL-READS MOVE 'Y' TO WS-READ-SUCCESSFUL DISPLAY "βœ… Transaction read: " TRANS-DESCRIPTION PERFORM LOG-READ-SUCCESS END-READ *> Additional file status checking EVALUATE WS-TRANS-STATUS WHEN "00" CONTINUE WHEN "23" DISPLAY "⚠️ Record not found" WHEN "10" DISPLAY "⚠️ End of file" WHEN "30" DISPLAY "❌ Permanent error" WHEN OTHER DISPLAY "❌ Unexpected file status: " WS-TRANS-STATUS END-EVALUATE. READ-WITH-RETRY-LOGIC. MOVE 0 TO WS-RETRY-COUNT MOVE 'N' TO WS-READ-SUCCESSFUL PERFORM UNTIL WS-READ-SUCCESSFUL = 'Y' OR WS-RETRY-COUNT >= WS-MAX-RETRIES ADD 1 TO WS-RETRY-COUNT ADD 1 TO WS-RETRY-ATTEMPTS READ TRANSACTION-FILE INVALID KEY DISPLAY "❌ Retry " WS-RETRY-COUNT " failed for: " TRANS-PRIMARY-KEY IF WS-RETRY-COUNT < WS-MAX-RETRIES DISPLAY "⏳ Waiting before retry..." *> Simulate wait (would use CALL "CBL_OC_NANOSLEEP" in real code) END-IF NOT INVALID KEY MOVE 'Y' TO WS-READ-SUCCESSFUL DISPLAY "βœ… Retry " WS-RETRY-COUNT " successful" END-READ END-PERFORM IF WS-READ-SUCCESSFUL = 'N' DISPLAY "❌ All retry attempts failed" PERFORM LOG-READ-FAILURE END-IF. READ-WITH-TIMEOUT-HANDLING. DISPLAY "πŸ• Simulating read with timeout handling..." *> In real application, this would involve actual timeout logic MOVE 'N' TO WS-READ-SUCCESSFUL READ TRANSACTION-FILE INVALID KEY DISPLAY "❌ Read timeout for: " TRANS-PRIMARY-KEY PERFORM LOG-READ-TIMEOUT NOT INVALID KEY MOVE 'Y' TO WS-READ-SUCCESSFUL DISPLAY "βœ… Read completed within timeout" END-READ. DEMONSTRATE-BATCH-READING. DISPLAY " " DISPLAY "πŸ“¦ BATCH READ OPERATIONS" DISPLAY "=======================" *> Setup batch of keys to read PERFORM SETUP-BATCH-KEYS *> Process batch with performance tracking PERFORM PROCESS-BATCH-READS *> Display batch results PERFORM DISPLAY-BATCH-RESULTS. SETUP-BATCH-KEYS. MOVE 5 TO WS-BATCH-SIZE MOVE "TRANS000000001A" TO WS-BATCH-KEY(1) MOVE "TRANS000000002B" TO WS-BATCH-KEY(2) MOVE "TRANS000000003C" TO WS-BATCH-KEY(3) MOVE "TRANS000000004D" TO WS-BATCH-KEY(4) MOVE "TRANS000000005E" TO WS-BATCH-KEY(5) DISPLAY "βœ… Batch of " WS-BATCH-SIZE " keys prepared". PROCESS-BATCH-READS. MOVE 0 TO WS-CURRENT-BATCH PERFORM VARYING WS-CURRENT-BATCH FROM 1 BY 1 UNTIL WS-CURRENT-BATCH > WS-BATCH-SIZE MOVE WS-BATCH-KEY(WS-CURRENT-BATCH) TO TRANS-PRIMARY-KEY READ TRANSACTION-FILE INVALID KEY MOVE 'N' TO WS-BATCH-RESULT(WS-CURRENT-BATCH) DISPLAY "❌ Batch item " WS-CURRENT-BATCH " failed" NOT INVALID KEY MOVE 'Y' TO WS-BATCH-RESULT(WS-CURRENT-BATCH) DISPLAY "βœ… Batch item " WS-CURRENT-BATCH " success" *> Process the record PERFORM PROCESS-BATCH-RECORD END-READ END-PERFORM. PROCESS-BATCH-RECORD. *> Example batch processing IF TRANS-AMOUNT > 1000 DISPLAY " πŸ’° High-value transaction: $" TRANS-AMOUNT END-IF IF TRANS-STATUS = 'P' DISPLAY " ⏳ Pending transaction" END-IF. DISPLAY-BATCH-RESULTS. MOVE 0 TO WS-CURRENT-BATCH DISPLAY "πŸ“Š Batch Processing Summary:" PERFORM VARYING WS-CURRENT-BATCH FROM 1 BY 1 UNTIL WS-CURRENT-BATCH > WS-BATCH-SIZE IF WS-BATCH-RESULT(WS-CURRENT-BATCH) = 'Y' ADD 1 TO WS-SUCCESSFUL-READS ELSE ADD 1 TO WS-FAILED-READS END-IF END-PERFORM. DEMONSTRATE-CONDITIONAL-READING. DISPLAY " " DISPLAY "πŸ” CONDITIONAL READ OPERATIONS" DISPLAY "==============================" *> Read by date range MOVE 20231001 TO WS-DATE-FROM MOVE 20231031 TO WS-DATE-TO PERFORM READ-BY-DATE-RANGE *> Read by customer criteria MOVE "CUST0001" TO WS-CUSTOMER-ID(1) MOVE "CUST0002" TO WS-CUSTOMER-ID(2) PERFORM READ-BY-CUSTOMER-LIST *> Read by amount threshold MOVE 5000.00 TO WS-AMOUNT-THRESHOLD PERFORM READ-BY-AMOUNT-THRESHOLD. READ-BY-DATE-RANGE. DISPLAY "πŸ“… Reading transactions by date range..." MOVE WS-DATE-FROM TO TRANS-DATE-KEY READ TRANSACTION-FILE KEY IS GREATER THAN OR EQUAL TO TRANS-DATE-KEY INVALID KEY DISPLAY "❌ No transactions in date range" NOT INVALID KEY DISPLAY "βœ… First transaction in range: " TRANS-DATE-KEY DISPLAY " Description: " TRANS-DESCRIPTION *> Continue reading in range PERFORM READ-NEXT-IN-DATE-RANGE END-READ. READ-NEXT-IN-DATE-RANGE. PERFORM 3 TIMES READ TRANSACTION-FILE NEXT RECORD AT END DISPLAY "End of file reached" EXIT PERFORM NOT AT END IF TRANS-DATE-KEY <= WS-DATE-TO DISPLAY " Transaction: " TRANS-DATE-KEY " Amount: $" TRANS-AMOUNT ELSE DISPLAY " Beyond date range, stopping" EXIT PERFORM END-IF END-READ END-PERFORM. READ-BY-CUSTOMER-LIST. DISPLAY "πŸ‘₯ Reading transactions by customer list..." PERFORM VARYING WS-CURRENT-BATCH FROM 1 BY 1 UNTIL WS-CURRENT-BATCH > 2 MOVE WS-CUSTOMER-ID(WS-CURRENT-BATCH) TO TRANS-CUSTOMER-KEY READ TRANSACTION-FILE KEY IS TRANS-CUSTOMER-KEY INVALID KEY DISPLAY "❌ No transactions for customer: " TRANS-CUSTOMER-KEY NOT INVALID KEY DISPLAY "βœ… Found transaction for: " TRANS-CUSTOMER-KEY DISPLAY " Amount: $" TRANS-AMOUNT DISPLAY " Type: " TRANS-TYPE END-READ END-PERFORM. READ-BY-AMOUNT-THRESHOLD. DISPLAY "πŸ’° Reading high-value transactions..." *> Start from beginning and scan for high-value transactions MOVE LOW-VALUES TO TRANS-PRIMARY-KEY READ TRANSACTION-FILE KEY IS GREATER THAN TRANS-PRIMARY-KEY INVALID KEY DISPLAY "❌ No transactions in file" NOT INVALID KEY PERFORM CHECK-AMOUNT-THRESHOLD *> Read additional records PERFORM 5 TIMES READ TRANSACTION-FILE NEXT RECORD AT END EXIT PERFORM NOT AT END PERFORM CHECK-AMOUNT-THRESHOLD END-READ END-PERFORM END-READ. CHECK-AMOUNT-THRESHOLD. IF TRANS-AMOUNT >= WS-AMOUNT-THRESHOLD DISPLAY "βœ… High-value transaction: " TRANS-PRIMARY-KEY DISPLAY " Amount: $" TRANS-AMOUNT DISPLAY " Customer: " TRANS-CUSTOMER-KEY END-IF. DEMONSTRATE-BUFFERED-READING. DISPLAY " " DISPLAY "πŸ’Ύ BUFFERED READ OPERATIONS" DISPLAY "==========================" *> Read with buffer management MOVE "TRANS111111111A" TO TRANS-PRIMARY-KEY PERFORM READ-WITH-BUFFER *> Access buffered data PERFORM ACCESS-BUFFERED-DATA *> Refresh buffer if needed PERFORM REFRESH-BUFFER. READ-WITH-BUFFER. MOVE 'N' TO WS-BUFFER-VALID READ TRANSACTION-FILE INTO WS-READ-BUFFER INVALID KEY DISPLAY "❌ Buffer read failed" NOT INVALID KEY MOVE WS-READ-BUFFER TO WS-BACKUP-RECORD MOVE 'Y' TO WS-BUFFER-VALID DISPLAY "βœ… Record buffered successfully" END-READ. ACCESS-BUFFERED-DATA. IF WS-BUFFER-VALID = 'Y' DISPLAY "πŸ“– Accessing buffered data..." DISPLAY " Buffer contains: " WS-READ-BUFFER(1:50) DISPLAY " Backup available: " WS-BACKUP-RECORD(1:50) ELSE DISPLAY "❌ No valid buffer data" END-IF. REFRESH-BUFFER. IF WS-BUFFER-VALID = 'Y' DISPLAY "πŸ”„ Refreshing buffer..." MOVE WS-BACKUP-RECORD TO WS-READ-BUFFER DISPLAY "βœ… Buffer refreshed from backup" END-IF. DEMONSTRATE-PERFORMANCE-READING. DISPLAY " " DISPLAY "⚑ PERFORMANCE READ OPERATIONS" DISPLAY "=============================" *> Time-based performance measurement MOVE FUNCTION CURRENT-DATE(9:6) TO WS-START-TIME *> Perform bulk read operations PERFORM BULK-READ-OPERATIONS MOVE FUNCTION CURRENT-DATE(9:6) TO WS-END-TIME PERFORM CALCULATE-READ-PERFORMANCE. BULK-READ-OPERATIONS. DISPLAY "πŸš€ Performing bulk read operations..." *> Read multiple records for performance testing PERFORM VARYING WS-CURRENT-BATCH FROM 1 BY 1 UNTIL WS-CURRENT-BATCH > 10 MOVE WS-CURRENT-BATCH TO TRANS-PRIMARY-KEY(11:5) READ TRANSACTION-FILE INVALID KEY CONTINUE NOT INVALID KEY ADD 1 TO WS-SUCCESSFUL-READS END-READ ADD 1 TO WS-TOTAL-READS END-PERFORM. CALCULATE-READ-PERFORMANCE. COMPUTE WS-CURRENT-BATCH = WS-END-TIME - WS-START-TIME DISPLAY "πŸ“ˆ Performance Results:" DISPLAY " Elapsed time: " WS-CURRENT-BATCH " seconds" DISPLAY " Total reads: " WS-TOTAL-READS DISPLAY " Reads per second: " WS-TOTAL-READS / WS-CURRENT-BATCH. LOG-READ-SUCCESS. STRING "SUCCESS: Read " TRANS-PRIMARY-KEY " at " FUNCTION CURRENT-DATE(9:14) DELIMITED BY SIZE INTO LOG-RECORD WRITE LOG-RECORD. LOG-READ-ERROR. STRING "ERROR: Failed to read " TRANS-PRIMARY-KEY " at " FUNCTION CURRENT-DATE(9:14) " Status: " WS-TRANS-STATUS DELIMITED BY SIZE INTO LOG-RECORD WRITE LOG-RECORD. LOG-READ-FAILURE. STRING "FAILURE: All retries exhausted for " TRANS-PRIMARY-KEY " at " FUNCTION CURRENT-DATE(9:14) DELIMITED BY SIZE INTO LOG-RECORD WRITE LOG-RECORD. LOG-READ-TIMEOUT. STRING "TIMEOUT: Read timeout for " TRANS-PRIMARY-KEY " at " FUNCTION CURRENT-DATE(9:14) DELIMITED BY SIZE INTO LOG-RECORD WRITE LOG-RECORD. DISPLAY-READ-METRICS. DISPLAY " " DISPLAY "πŸ“Š READ OPERATION METRICS" DISPLAY "========================" DISPLAY "Total read attempts: " WS-TOTAL-READS DISPLAY "Successful reads: " WS-SUCCESSFUL-READS DISPLAY "Failed reads: " WS-FAILED-READS DISPLAY "Retry attempts: " WS-RETRY-ATTEMPTS IF WS-TOTAL-READS > 0 COMPUTE WS-CURRENT-BATCH = (WS-SUCCESSFUL-READS / WS-TOTAL-READS) * 100 DISPLAY "Success rate: " WS-CURRENT-BATCH "%" END-IF. CLEANUP-ADVANCED-PROCESSING. DISPLAY " " DISPLAY "🧹 CLEANUP PROCESSING" DISPLAY "====================" CLOSE TRANSACTION-FILE CLOSE LOG-FILE DISPLAY "βœ… All files closed successfully".

READ Features and Capabilities

Access Methods
  • β€’ Sequential record reading
  • β€’ Random key-based access
  • β€’ Dynamic access switching
  • β€’ Relative record positioning
Error Handling
  • β€’ AT END condition detection
  • β€’ INVALID KEY handling
  • β€’ File status monitoring
  • β€’ Exception processing
Data Transfer
  • β€’ READ INTO working storage
  • β€’ Buffer management
  • β€’ Record copying
  • β€’ Data validation
Business Applications
  • β€’ Customer data retrieval
  • β€’ Transaction processing
  • β€’ Report data gathering
  • β€’ Batch file processing

Best Practices

Related Pages