MainframeMaster

COBOL Data Parsing

Data parsing breaks down structured data into individual components for processing and manipulation. Learn string parsing techniques, data extraction methods, and text processing for effective data manipulation.

UNSTRING Statement for Delimited Data

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
       WORKING-STORAGE SECTION.
       01 PARSING-DATA.
           05 INPUT-STRING PIC X(100).
           05 PARSED-FIELDS.
               10 FIELD-1 PIC X(20).
               10 FIELD-2 PIC X(20).
               10 FIELD-3 PIC X(20).
               10 FIELD-4 PIC X(20).
           05 DELIMITER-COUNT PIC 9(2).
       
       PROCEDURE DIVISION.
       PERFORM PARSE-DELIMITED-DATA
       
       PARSE-DELIMITED-DATA.
           MOVE 'JOHN,SMITH,12345,ACCOUNTANT' TO INPUT-STRING
           
           *> Parse comma-delimited data
           UNSTRING INPUT-STRING
               DELIMITED BY ','
               INTO FIELD-1 FIELD-2 FIELD-3 FIELD-4
               TALLYING DELIMITER-COUNT
           END-UNSTRING
           
           DISPLAY 'Parsed fields:'
           DISPLAY 'Field 1: ' FIELD-1
           DISPLAY 'Field 2: ' FIELD-2
           DISPLAY 'Field 3: ' FIELD-3
           DISPLAY 'Field 4: ' FIELD-4
           DISPLAY 'Delimiter count: ' DELIMITER-COUNT.

Use UNSTRING statement to parse delimited data by specifying delimiters and target fields. The TALLYING clause counts delimiters found, and UNSTRING extracts data into individual fields.

Multiple Delimiter Parsing

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
       WORKING-STORAGE SECTION.
       01 MULTIPLE-DELIMITER-PARSING.
           05 COMPLEX-STRING PIC X(200).
           05 PARSED-COMPONENTS.
               10 COMPONENT-1 PIC X(30).
               10 COMPONENT-2 PIC X(30).
               10 COMPONENT-3 PIC X(30).
               10 COMPONENT-4 PIC X(30).
           05 DELIMITER-TYPE PIC X(10).
       
       PROCEDURE DIVISION.
       PERFORM PARSE-MULTIPLE-DELIMITERS
       
       PARSE-MULTIPLE-DELIMITERS.
           MOVE 'NAME:JOHN SMITH|ID:12345|DEPT:IT|STATUS:ACTIVE' TO COMPLEX-STRING
           
           *> Parse with multiple delimiters
           UNSTRING COMPLEX-STRING
               DELIMITED BY ':' OR '|'
               INTO COMPONENT-1 COMPONENT-2 COMPONENT-3 COMPONENT-4
               WITH POINTER POINTER-VALUE
               ON OVERFLOW
                   DISPLAY 'Parsing overflow occurred'
           END-UNSTRING
           
           DISPLAY 'Parsed components:'
           DISPLAY 'Component 1: ' COMPONENT-1
           DISPLAY 'Component 2: ' COMPONENT-2
           DISPLAY 'Component 3: ' COMPONENT-3
           DISPLAY 'Component 4: ' COMPONENT-4.

Parse data with multiple delimiters using OR clause in UNSTRING statement. Use WITH POINTER for position tracking and ON OVERFLOW for error handling when parsing complex data.

Fixed-Position Parsing

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
       WORKING-STORAGE SECTION.
       01 FIXED-POSITION-PARSING.
           05 FIXED-RECORD PIC X(80).
           05 PARSED-FIELDS.
               10 RECORD-TYPE PIC X(1).
               10 CUSTOMER-ID PIC X(6).
               10 CUSTOMER-NAME PIC X(30).
               10 ACCOUNT-BALANCE PIC X(10).
               10 TRANSACTION-DATE PIC X(8).
               10 FILLER PIC X(25).
       
       PROCEDURE DIVISION.
       PERFORM PARSE-FIXED-POSITIONS
       
       PARSE-FIXED-POSITIONS.
           MOVE 'C123456JOHN SMITH                   1500.50   20231225     ' TO FIXED-RECORD
           
           *> Parse fixed-position data using reference modification
           MOVE FIXED-RECORD(1:1) TO RECORD-TYPE
           MOVE FIXED-RECORD(2:6) TO CUSTOMER-ID
           MOVE FIXED-RECORD(8:30) TO CUSTOMER-NAME
           MOVE FIXED-RECORD(38:10) TO ACCOUNT-BALANCE
           MOVE FIXED-RECORD(48:8) TO TRANSACTION-DATE
           
           DISPLAY 'Fixed position parsing:'
           DISPLAY 'Record Type: ' RECORD-TYPE
           DISPLAY 'Customer ID: ' CUSTOMER-ID
           DISPLAY 'Customer Name: ' CUSTOMER-NAME
           DISPLAY 'Account Balance: ' ACCOUNT-BALANCE
           DISPLAY 'Transaction Date: ' TRANSACTION-DATE.

Parse fixed-position data using reference modification to extract specific portions of a record. Use position and length specifications to extract data from known locations.

Date and Time Parsing

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
       WORKING-STORAGE SECTION.
       01 DATE-TIME-PARSING.
           05 INPUT-DATE-TIME PIC X(20).
           05 PARSED-DATE-TIME.
               10 YEAR PIC X(4).
               10 MONTH PIC X(2).
               10 DAY PIC X(2).
               10 HOUR PIC X(2).
               10 MINUTE PIC X(2).
               10 SECOND PIC X(2).
           05 FORMATTED-DATE PIC X(10).
           05 FORMATTED-TIME PIC X(8).
       
       PROCEDURE DIVISION.
       PERFORM PARSE-DATE-TIME
       
       PARSE-DATE-TIME.
           MOVE '20231225143052' TO INPUT-DATE-TIME
           
           *> Parse date-time string
           MOVE INPUT-DATE-TIME(1:4) TO YEAR
           MOVE INPUT-DATE-TIME(5:2) TO MONTH
           MOVE INPUT-DATE-TIME(7:2) TO DAY
           MOVE INPUT-DATE-TIME(9:2) TO HOUR
           MOVE INPUT-DATE-TIME(11:2) TO MINUTE
           MOVE INPUT-DATE-TIME(13:2) TO SECOND
           
           *> Format parsed components
           STRING MONTH '/' DAY '/' YEAR INTO FORMATTED-DATE
           STRING HOUR ':' MINUTE ':' SECOND INTO FORMATTED-TIME
           
           DISPLAY 'Parsed date-time:'
           DISPLAY 'Year: ' YEAR
           DISPLAY 'Month: ' MONTH
           DISPLAY 'Day: ' DAY
           DISPLAY 'Formatted Date: ' FORMATTED-DATE
           DISPLAY 'Formatted Time: ' FORMATTED-TIME.

Parse date and time data from various formats using reference modification. Extract year, month, day, hour, minute, and second components, then format them for display.

CSV Data Parsing

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
       WORKING-STORAGE SECTION.
       01 CSV-PARSING.
           05 CSV-RECORD PIC X(200).
           05 CSV-FIELDS.
               10 CSV-FIELD-1 PIC X(30).
               10 CSV-FIELD-2 PIC X(30).
               10 CSV-FIELD-3 PIC X(30).
               10 CSV-FIELD-4 PIC X(30).
               10 CSV-FIELD-5 PIC X(30).
           05 FIELD-COUNT PIC 9(2).
           05 CURRENT-POSITION PIC 9(3).
       
       PROCEDURE DIVISION.
       PERFORM PARSE-CSV-DATA
       
       PARSE-CSV-DATA.
           MOVE 'CUSTOMER_ID,CUSTOMER_NAME,ACCOUNT_BALANCE,STATUS,DATE' TO CSV-RECORD
           
           MOVE 1 TO CURRENT-POSITION
           MOVE 0 TO FIELD-COUNT
           
           *> Parse CSV header
           UNSTRING CSV-RECORD
               DELIMITED BY ','
               INTO CSV-FIELD-1 CSV-FIELD-2 CSV-FIELD-3 CSV-FIELD-4 CSV-FIELD-5
               WITH POINTER CURRENT-POSITION
               TALLYING FIELD-COUNT
           END-UNSTRING
           
           DISPLAY 'CSV Header Fields:'
           DISPLAY 'Field 1: ' CSV-FIELD-1
           DISPLAY 'Field 2: ' CSV-FIELD-2
           DISPLAY 'Field 3: ' CSV-FIELD-3
           DISPLAY 'Field 4: ' CSV-FIELD-4
           DISPLAY 'Field 5: ' CSV-FIELD-5
           DISPLAY 'Total fields: ' FIELD-COUNT.

Parse CSV (Comma-Separated Values) data using UNSTRING with comma delimiters. Use WITH POINTER for position tracking and TALLYING to count fields for dynamic CSV processing.

JSON-like Data Parsing

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
       WORKING-STORAGE SECTION.
       01 JSON-PARSING.
           05 JSON-STRING PIC X(300).
           05 PARSED-JSON.
               10 JSON-KEY-1 PIC X(20).
               10 JSON-VALUE-1 PIC X(30).
               10 JSON-KEY-2 PIC X(20).
               10 JSON-VALUE-2 PIC X(30).
               10 JSON-KEY-3 PIC X(20).
               10 JSON-VALUE-3 PIC X(30).
       
       PROCEDURE DIVISION.
       PERFORM PARSE-JSON-DATA
       
       PARSE-JSON-DATA.
           MOVE '{"customer_id":"123456","name":"John Smith","balance":"1500.50"}' TO JSON-STRING
           
           *> Parse JSON-like data
           UNSTRING JSON-STRING
               DELIMITED BY '"' OR ':' OR ',' OR '{' OR '}'
               INTO JSON-KEY-1 JSON-VALUE-1 JSON-KEY-2 JSON-VALUE-2 JSON-KEY-3 JSON-VALUE-3
           END-UNSTRING
           
           DISPLAY 'Parsed JSON data:'
           DISPLAY 'Key 1: ' JSON-KEY-1 ' Value 1: ' JSON-VALUE-1
           DISPLAY 'Key 2: ' JSON-KEY-2 ' Value 2: ' JSON-VALUE-2
           DISPLAY 'Key 3: ' JSON-KEY-3 ' Value 3: ' JSON-VALUE-3.

Parse JSON-like data using multiple delimiters including quotes, colons, commas, and braces. Extract key-value pairs from structured data formats.

Error Handling in Parsing

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
       WORKING-STORAGE SECTION.
       01 PARSING-ERROR-HANDLING.
           05 INPUT-DATA PIC X(100).
           05 PARSED-RESULT PIC X(50).
           05 PARSING-STATUS PIC X.
               88 PARSING-SUCCESS VALUE 'S'.
               88 PARSING-FAILED VALUE 'F'.
           05 ERROR-MESSAGE PIC X(100).
       
       PROCEDURE DIVISION.
       PERFORM PARSE-WITH-ERROR-HANDLING
       
       PARSE-WITH-ERROR-HANDLING.
           MOVE 'INVALID,DATA,FORMAT' TO INPUT-DATA
           MOVE 'S' TO PARSING-STATUS
           
           *> Attempt parsing with error handling
           UNSTRING INPUT-DATA
               DELIMITED BY ','
               INTO PARSED-RESULT
               ON OVERFLOW
                   MOVE 'F' TO PARSING-STATUS
                   MOVE 'Parsing overflow - data too long' TO ERROR-MESSAGE
               NOT ON OVERFLOW
                   MOVE 'Parsing completed successfully' TO ERROR-MESSAGE
           END-UNSTRING
           
           IF PARSING-FAILED
               DISPLAY 'Parsing failed: ' ERROR-MESSAGE
               PERFORM HANDLE-PARSING-ERROR
           ELSE
               DISPLAY 'Parsing successful: ' ERROR-MESSAGE
               DISPLAY 'Parsed result: ' PARSED-RESULT
           END-IF.

Implement comprehensive error handling for parsing operations using ON OVERFLOW and NOT ON OVERFLOW clauses. Check parsing status and provide meaningful error messages.

Dynamic Parsing

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
       WORKING-STORAGE SECTION.
       01 DYNAMIC-PARSING.
           05 DYNAMIC-STRING PIC X(200).
           05 PARSING-CONTROL.
               10 DELIMITER-CHAR PIC X.
               10 FIELD-COUNT PIC 9(2).
               10 CURRENT-FIELD PIC 9(2).
           05 DYNAMIC-FIELDS OCCURS 20 TIMES.
               10 DYNAMIC-FIELD PIC X(30).
       
       PROCEDURE DIVISION.
       PERFORM DYNAMIC-PARSING-OPERATION
       
       DYNAMIC-PARSING-OPERATION.
           MOVE 'FIELD1|FIELD2|FIELD3|FIELD4|FIELD5' TO DYNAMIC-STRING
           MOVE '|' TO DELIMITER-CHAR
           MOVE 0 TO FIELD-COUNT
           
           *> Count fields first
           PERFORM COUNT-DELIMITERS
           
           *> Parse fields dynamically
           PERFORM PARSE-DYNAMIC-FIELDS
           
           DISPLAY 'Dynamic parsing results:'
           PERFORM VARYING CURRENT-FIELD FROM 1 BY 1 UNTIL CURRENT-FIELD > FIELD-COUNT
               DISPLAY 'Field ' CURRENT-FIELD ': ' DYNAMIC-FIELD(CURRENT-FIELD)
           END-PERFORM.
       
       COUNT-DELIMITERS.
           PERFORM VARYING I FROM 1 BY 1 UNTIL I > FUNCTION LENGTH(DYNAMIC-STRING)
               IF DYNAMIC-STRING(I:1) = DELIMITER-CHAR
                   ADD 1 TO FIELD-COUNT
               END-IF
           END-PERFORM
           ADD 1 TO FIELD-COUNT  *> Add 1 for the last field.

Implement dynamic parsing that adapts to different data formats and field counts. Count delimiters first, then parse fields dynamically based on the actual data structure.

Parsing Performance Optimization

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
       WORKING-STORAGE SECTION.
       01 OPTIMIZED-PARSING.
           05 PARSING-BUFFER PIC X(1000).
           05 PARSED-DATA OCCURS 50 TIMES.
               10 PARSED-FIELD PIC X(50).
           05 PARSING-METRICS.
               10 PARSING-TIME PIC 9(6).
               10 RECORDS-PARSED PIC 9(8).
               10 PARSING-RATE PIC 9(6).
       
       PROCEDURE DIVISION.
       PERFORM OPTIMIZED-PARSING-OPERATION
       
       OPTIMIZED-PARSING-OPERATION.
           MOVE FUNCTION CURRENT-TIME TO START-TIME
           MOVE 0 TO RECORDS-PARSED
           
           *> Parse multiple records efficiently
           PERFORM UNTIL EOF
               READ INPUT-FILE AT END SET EOF TO TRUE
               NOT AT END
                   PERFORM PARSE-SINGLE-RECORD
                   ADD 1 TO RECORDS-PARSED
               END-READ
           END-PERFORM
           
           MOVE FUNCTION CURRENT-TIME TO END-TIME
           COMPUTE PARSING-TIME = END-TIME - START-TIME
           COMPUTE PARSING-RATE = RECORDS-PARSED / PARSING-TIME
           
           DISPLAY 'Parsing performance:'
           DISPLAY 'Records parsed: ' RECORDS-PARSED
           DISPLAY 'Parsing time: ' PARSING-TIME ' seconds'
           DISPLAY 'Parsing rate: ' PARSING-RATE ' records/second'.

Optimize parsing performance by using efficient parsing techniques, buffering data, and measuring parsing metrics. Monitor parsing rates and optimize for high-volume data processing.

Data Organization

Data structure and layout

Data Parsing Concepts

Data parsing concepts