MainframeMaster

COBOL Collating Sequence

A collating sequence in COBOL defines the order of characters for sorting and comparison operations. It determines how characters are compared, which character comes before another, and how strings are arranged in sorted output. Understanding collating sequences is crucial for implementing correct sorting and comparison logic in COBOL programs.

Understanding Collating Sequences

Think of a collating sequence as the "alphabetical order" for characters. Just as we know that 'A' comes before 'B' in the English alphabet, a collating sequence defines the complete ordering of all characters used in the system. This ordering affects how COBOL compares strings, sorts data, and determines the results of relational operations.

Default Collating Sequences

1. System Default Sequences

Different systems use different default collating sequences. Mainframe systems typically use EBCDIC (Extended Binary Coded Decimal Interchange Code), while distributed systems often use ASCII (American Standard Code for Information Interchange). Understanding these differences is important for cross-platform compatibility.

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
       IDENTIFICATION DIVISION.
       PROGRAM-ID. DEFAULT-COLLATING-EXAMPLE.
       *> This program demonstrates the default collating sequence behavior
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       *> Test data for collating sequence demonstration
       01 CHARACTER-COMPARISON-DATA.
           05 FIRST-CHARACTER      PIC X(1) VALUE 'A'.
           05 SECOND-CHARACTER     PIC X(1) VALUE 'B'.
           05 THIRD-CHARACTER      PIC X(1) VALUE 'a'.
           05 FOURTH-CHARACTER     PIC X(1) VALUE 'b'.
       
       01 STRING-COMPARISON-DATA.
           05 FIRST-STRING        PIC X(10) VALUE 'APPLE'.
           05 SECOND-STRING       PIC X(10) VALUE 'BANANA'.
           05 THIRD-STRING        PIC X(10) VALUE 'apple'.
           05 FOURTH-STRING       PIC X(10) VALUE 'banana'.
       
       01 COMPARISON-RESULTS.
           05 COMPARISON-STATUS   PIC X(1).
               88 FIRST-LESS-THAN-SECOND VALUE 'L'.
               88 FIRST-EQUAL-TO-SECOND  VALUE 'E'.
               88 FIRST-GREATER-THAN-SECOND VALUE 'G'.
       
       PROCEDURE DIVISION.
       DEMONSTRATE-DEFAULT-COLLATING.
           DISPLAY 'Demonstrating Default Collating Sequence'
           DISPLAY '========================================'
           
       *> Compare single characters
           PERFORM COMPARE-SINGLE-CHARACTERS
           
       *> Compare strings
           PERFORM COMPARE-STRING-VALUES
           
       *> Demonstrate sorting order
           PERFORM DEMONSTRATE-SORTING-ORDER
           
           STOP RUN.
       
       COMPARE-SINGLE-CHARACTERS.
           DISPLAY 'Single Character Comparisons:'
           
       *> Compare 'A' and 'B'
           IF FIRST-CHARACTER < SECOND-CHARACTER
               DISPLAY 'A < B (A comes before B)'
           ELSE
               IF FIRST-CHARACTER > SECOND-CHARACTER
                   DISPLAY 'A > B (A comes after B)'
               ELSE
                   DISPLAY 'A = B (A equals B)'
               END-IF
           END-IF
           
       *> Compare 'A' and 'a' (case sensitivity)
           IF FIRST-CHARACTER < THIRD-CHARACTER
               DISPLAY 'A < a (uppercase A comes before lowercase a)'
           ELSE
               IF FIRST-CHARACTER > THIRD-CHARACTER
                   DISPLAY 'A > a (uppercase A comes after lowercase a)'
               ELSE
                   DISPLAY 'A = a (A equals a)'
               END-IF
           END-IF
           
       *> Compare 'a' and 'b'
           IF THIRD-CHARACTER < FOURTH-CHARACTER
               DISPLAY 'a < b (lowercase a comes before lowercase b)'
           ELSE
               IF THIRD-CHARACTER > FOURTH-CHARACTER
                   DISPLAY 'a > b (lowercase a comes after lowercase b)'
               ELSE
                   DISPLAY 'a = b (a equals b)'
               END-IF
           END-IF.
       
       COMPARE-STRING-VALUES.
           DISPLAY 'String Comparisons:'
           
       *> Compare 'APPLE' and 'BANANA'
           IF FIRST-STRING < SECOND-STRING
               DISPLAY 'APPLE < BANANA (APPLE comes before BANANA)'
           ELSE
               IF FIRST-STRING > SECOND-STRING
                   DISPLAY 'APPLE > BANANA (APPLE comes after BANANA)'
               ELSE
                   DISPLAY 'APPLE = BANANA (strings are equal)'
               END-IF
           END-IF
           
       *> Compare 'APPLE' and 'apple' (case sensitivity)
           IF FIRST-STRING < THIRD-STRING
               DISPLAY 'APPLE < apple (uppercase comes before lowercase)'
           ELSE
               IF FIRST-STRING > THIRD-STRING
                   DISPLAY 'APPLE > apple (uppercase comes after lowercase)'
               ELSE
                   DISPLAY 'APPLE = apple (strings are equal)'
               END-IF
           END-IF.
       
       DEMONSTRATE-SORTING-ORDER.
           DISPLAY 'Expected Sorting Order:'
           DISPLAY '1. APPLE (uppercase A)'
           DISPLAY '2. BANANA (uppercase B)'
           DISPLAY '3. apple (lowercase a)'
           DISPLAY '4. banana (lowercase b)'
           DISPLAY 'Note: Order depends on system collating sequence'.

This example demonstrates how the default collating sequence affects character and string comparisons. The program compares single characters and strings to show the ordering relationships. The results depend on the system's default collating sequence - on EBCDIC systems, uppercase letters typically come before lowercase letters, while on ASCII systems, the opposite is usually true.

2. EBCDIC vs ASCII Collating

EBCDIC and ASCII have different character ordering, which can cause issues when moving code between systems. Understanding these differences helps in writing portable code and handling cross-platform data correctly.

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
       IDENTIFICATION DIVISION.
       PROGRAM-ID. EBCDIC-ASCII-COMPARISON.
       *> This program demonstrates differences between EBCDIC and ASCII collating
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       *> Character sets for comparison
       01 EBCDIC-CHARACTER-ORDER.
           05 EBCDIC-CHARS       PIC X(26) VALUE 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.
           05 EBCDIC-LOWER       PIC X(26) VALUE 'abcdefghijklmnopqrstuvwxyz'.
       
       01 ASCII-CHARACTER-ORDER.
           05 ASCII-CHARS        PIC X(26) VALUE 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.
           05 ASCII-LOWER        PIC X(26) VALUE 'abcdefghijklmnopqrstuvwxyz'.
       
       01 COMPARISON-TEST-DATA.
           05 UPPERCASE-A        PIC X(1) VALUE 'A'.
           05 LOWERCASE-A        PIC X(1) VALUE 'a'.
           05 UPPERCASE-Z        PIC X(1) VALUE 'Z'.
           05 LOWERCASE-Z        PIC X(1) VALUE 'z'.
       
       PROCEDURE DIVISION.
       DEMONSTRATE-COLLATING-DIFFERENCES.
           DISPLAY 'EBCDIC vs ASCII Collating Sequence Differences'
           DISPLAY '=============================================='
           
       *> Show character ordering differences
           PERFORM SHOW-CHARACTER-ORDERING
           
       *> Demonstrate sorting implications
           PERFORM DEMONSTRATE-SORTING-IMPLICATIONS
           
           STOP RUN.
       
       SHOW-CHARACTER-ORDERING.
           DISPLAY 'Character Ordering Comparison:'
           DISPLAY 'EBCDIC System: A < B < ... < Z < a < b < ... < z'
           DISPLAY 'ASCII System:  A < B < ... < Z < a < b < ... < z'
           DISPLAY 'Note: Actual order depends on system implementation'
           
       *> Test specific character comparisons
           IF UPPERCASE-A < LOWERCASE-A
               DISPLAY 'On this system: A < a (EBCDIC-like behavior)'
           ELSE
               DISPLAY 'On this system: A > a (ASCII-like behavior)'
           END-IF.
       
       DEMONSTRATE-SORTING-IMPLICATIONS.
           DISPLAY 'Sorting Implications:'
           DISPLAY 'EBCDIC: APPLE, BANANA, apple, banana'
           DISPLAY 'ASCII:  APPLE, BANANA, apple, banana'
           DISPLAY 'Note: Results may vary based on actual system collating sequence'.

This example highlights the differences between EBCDIC and ASCII collating sequences. While both systems typically have uppercase letters before lowercase letters, the exact ordering can vary. This is important to understand when writing code that needs to work across different platforms or when processing data that originated on different systems.

Custom Collating Sequences

1. Defining Custom Sequences

COBOL allows you to define custom collating sequences using the SPECIAL-NAMES paragraph. This is useful when you need specific character ordering for business requirements, such as putting numbers before letters or creating case-insensitive sorting.

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
       IDENTIFICATION DIVISION.
       PROGRAM-ID. CUSTOM-COLLATING-EXAMPLE.
       *> This program demonstrates custom collating sequence definition
       
       ENVIRONMENT DIVISION.
       CONFIGURATION SECTION.
       SPECIAL-NAMES.
       *> Define a custom collating sequence
           COLLATING-SEQUENCE IS CUSTOM-ORDER
           ALPHABET CUSTOM-ORDER IS
               '0' THROUGH '9'    *> Numbers first
               'A' THROUGH 'Z'    *> Then uppercase letters
               'a' THROUGH 'z'    *> Then lowercase letters
               SPACE              *> Then space character
               '.' ',' ';' ':'    *> Then punctuation
               '(' ')' '[' ']'    *> Then brackets
               '{' '}' '<' '>'    *> Then braces and angle brackets
               '!' '?' '-' '_'    *> Then other symbols
               '@' '#' '$' '%'    *> Then special characters
               '&' '*' '+' '='    *> Then operators
               '/' '' '|' '~'    *> Then other symbols
               ' '                *> Then other spaces
               X'00' THROUGH X'FF' *> Then all other characters
       .
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       *> Test data for custom collating sequence
       01 CUSTOM-SORTING-DATA.
           05 SORT-ITEM-1        PIC X(10) VALUE 'apple'.
           05 SORT-ITEM-2        PIC X(10) VALUE 'BANANA'.
           05 SORT-ITEM-3        PIC X(10) VALUE '123ABC'.
           05 SORT-ITEM-4        PIC X(10) VALUE '456DEF'.
           05 SORT-ITEM-5        PIC X(10) VALUE 'Cherry'.
       
       01 COMPARISON-RESULTS.
           05 COMPARE-STATUS     PIC X(1).
               88 ITEM1-LESS     VALUE 'L'.
               88 ITEM1-EQUAL    VALUE 'E'.
               88 ITEM1-GREATER  VALUE 'G'.
       
       PROCEDURE DIVISION.
       DEMONSTRATE-CUSTOM-COLLATING.
           DISPLAY 'Custom Collating Sequence Demonstration'
           DISPLAY '======================================'
           
       *> Show custom ordering
           PERFORM SHOW-CUSTOM-ORDERING
           
       *> Demonstrate sorting with custom sequence
           PERFORM DEMONSTRATE-CUSTOM-SORTING
           
           STOP RUN.
       
       SHOW-CUSTOM-ORDERING.
           DISPLAY 'Custom Collating Sequence Order:'
           DISPLAY '1. Numbers (0-9)'
           DISPLAY '2. Uppercase letters (A-Z)'
           DISPLAY '3. Lowercase letters (a-z)'
           DISPLAY '4. Space and punctuation'
           DISPLAY '5. Other symbols and characters'
           
       *> Test the custom ordering
           IF SORT-ITEM-3 < SORT-ITEM-1
               DISPLAY '123ABC < apple (numbers before letters)'
           END-IF
           
           IF SORT-ITEM-2 < SORT-ITEM-1
               DISPLAY 'BANANA < apple (uppercase before lowercase)'
           END-IF.
       
       DEMONSTRATE-CUSTOM-SORTING.
           DISPLAY 'Expected Custom Sort Order:'
           DISPLAY '1. 123ABC (starts with number)'
           DISPLAY '2. 456DEF (starts with number)'
           DISPLAY '3. BANANA (uppercase letter)'
           DISPLAY '4. Cherry (uppercase letter)'
           DISPLAY '5. apple (lowercase letter)'
           
       *> Perform actual comparisons to verify order
           PERFORM COMPARE-SORT-ITEMS
           
           DISPLAY 'Custom collating sequence applied successfully'.
       
       COMPARE-SORT-ITEMS.
       *> Compare items to verify custom ordering
           IF SORT-ITEM-3 < SORT-ITEM-4
               DISPLAY '123ABC < 456DEF (correct numeric order)'
           END-IF
           
           IF SORT-ITEM-4 < SORT-ITEM-2
               DISPLAY '456DEF < BANANA (numbers before letters)'
           END-IF
           
           IF SORT-ITEM-2 < SORT-ITEM-5
               DISPLAY 'BANANA < Cherry (alphabetical order)'
           END-IF
           
           IF SORT-ITEM-5 < SORT-ITEM-1
               DISPLAY 'Cherry < apple (uppercase before lowercase)'
           END-IF.

This example demonstrates how to define a custom collating sequence that puts numbers first, then uppercase letters, then lowercase letters, followed by punctuation and other characters. This custom ordering can be useful for business applications where you want numbers to sort before letters, or where you need case-sensitive sorting with uppercase letters taking precedence.

2. Case-Insensitive Collating

Sometimes you need case-insensitive sorting where 'A' and 'a' are treated as equivalent. This can be achieved by defining a custom collating sequence that groups uppercase and lowercase letters together.

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
       IDENTIFICATION DIVISION.
       PROGRAM-ID. CASE-INSENSITIVE-COLLATING.
       *> This program demonstrates case-insensitive collating sequence
       
       ENVIRONMENT DIVISION.
       CONFIGURATION SECTION.
       SPECIAL-NAMES.
       *> Define case-insensitive collating sequence
           COLLATING-SEQUENCE IS CASE-INSENSITIVE-ORDER
           ALPHABET CASE-INSENSITIVE-ORDER IS
               '0' THROUGH '9'                    *> Numbers first
               'A' 'a' 'B' 'b' 'C' 'c' 'D' 'd'   *> Mixed case letters
               'E' 'e' 'F' 'f' 'G' 'g' 'H' 'h'   *> Continuing mixed case
               'I' 'i' 'J' 'j' 'K' 'k' 'L' 'l'   *> More mixed case
               'M' 'm' 'N' 'n' 'O' 'o' 'P' 'p'   *> More mixed case
               'Q' 'q' 'R' 'r' 'S' 's' 'T' 't'   *> More mixed case
               'U' 'u' 'V' 'v' 'W' 'w' 'X' 'x'   *> More mixed case
               'Y' 'y' 'Z' 'z'                   *> Final mixed case
               SPACE                              *> Then space
               '.' ',' ';' ':' '!' '?'           *> Then punctuation
               '(' ')' '[' ']' '{' '}'           *> Then brackets
               '<' '>' '"' "'" '-' '_'           *> Then other symbols
               '@' '#' '$' '%' '&' '*'           *> Then special chars
               '+' '=' '/' '' '|' '~'           *> Then operators
               ' '                               *> Then other spaces
               X'00' THROUGH X'FF'               *> Then all other chars
       .
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       *> Test data for case-insensitive sorting
       01 CASE-INSENSITIVE-DATA.
           05 SORT-ITEM-1        PIC X(10) VALUE 'Apple'.
           05 SORT-ITEM-2        PIC X(10) VALUE 'banana'.
           05 SORT-ITEM-3        PIC X(10) VALUE 'CHERRY'.
           05 SORT-ITEM-4        PIC X(10) VALUE 'date'.
           05 SORT-ITEM-5        PIC X(10) VALUE 'ELDERBERRY'.
       
       PROCEDURE DIVISION.
       DEMONSTRATE-CASE-INSENSITIVE.
           DISPLAY 'Case-Insensitive Collating Sequence'
           DISPLAY '==================================='
           
       *> Show case-insensitive ordering
           PERFORM SHOW-CASE-INSENSITIVE-ORDERING
           
       *> Demonstrate case-insensitive comparisons
           PERFORM DEMONSTRATE-CASE-INSENSITIVE-COMPARISONS
           
           STOP RUN.
       
       SHOW-CASE-INSENSITIVE-ORDERING.
           DISPLAY 'Case-Insensitive Collating Sequence:'
           DISPLAY 'Numbers: 0-9'
           DISPLAY 'Letters: Aa, Bb, Cc, Dd, Ee, Ff, Gg, Hh, Ii, Jj, Kk, Ll'
           DISPLAY '         Mm, Nn, Oo, Pp, Qq, Rr, Ss, Tt, Uu, Vv, Ww, Xx, Yy, Zz'
           DISPLAY 'Then: Space, punctuation, symbols, other characters'
           
           DISPLAY 'Expected Sort Order:'
           DISPLAY '1. Apple (A comes first)'
           DISPLAY '2. banana (b comes after A)'
           DISPLAY '3. CHERRY (C comes after b)'
           DISPLAY '4. date (d comes after C)'
           DISPLAY '5. ELDERBERRY (E comes after d)'.
       
       DEMONSTRATE-CASE-INSENSITIVE-COMPARISONS.
           DISPLAY 'Case-Insensitive Comparisons:'
           
       *> Test case-insensitive behavior
           IF SORT-ITEM-1 < SORT-ITEM-2
               DISPLAY 'Apple < banana (A < b in case-insensitive order)'
           END-IF
           
           IF SORT-ITEM-2 < SORT-ITEM-3
               DISPLAY 'banana < CHERRY (b < C in case-insensitive order)'
           END-IF
           
           IF SORT-ITEM-3 < SORT-ITEM-4
               DISPLAY 'CHERRY < date (C < d in case-insensitive order)'
           END-IF
           
           IF SORT-ITEM-4 < SORT-ITEM-5
               DISPLAY 'date < ELDERBERRY (d < E in case-insensitive order)'
           END-IF
           
           DISPLAY 'Case-insensitive collating sequence applied successfully'.

This example demonstrates a case-insensitive collating sequence where uppercase and lowercase letters are interleaved (A, a, B, b, C, c, etc.). This means that 'A' and 'a' are treated as equivalent for sorting purposes, but if they were different, 'A' would come before 'a'. This type of collating sequence is useful when you want case-insensitive sorting but still need predictable ordering.

Collating Sequence in Sorting

1. SORT Statement with Collating

The SORT statement in COBOL can use custom collating sequences to control how data is sorted. This is particularly useful when you need specialized sorting behavior that differs from the system default.

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
       IDENTIFICATION DIVISION.
       PROGRAM-ID. SORT-WITH-COLLATING.
       *> This program demonstrates sorting with custom collating sequence
       
       ENVIRONMENT DIVISION.
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.
           SELECT SORT-FILE ASSIGN TO 'SORTWK'
               ORGANIZATION IS SEQUENTIAL.
           SELECT INPUT-FILE ASSIGN TO 'INPUT.DAT'
               ORGANIZATION IS SEQUENTIAL
               ACCESS MODE IS SEQUENTIAL.
           SELECT OUTPUT-FILE ASSIGN TO 'OUTPUT.DAT'
               ORGANIZATION IS SEQUENTIAL
               ACCESS MODE IS SEQUENTIAL.
       
       DATA DIVISION.
       FILE SECTION.
       FD INPUT-FILE.
       01 INPUT-RECORD.
           05 INPUT-KEY-FIELD     PIC X(10).
           05 INPUT-DATA-FIELD    PIC X(50).
       
       FD OUTPUT-FILE.
       01 OUTPUT-RECORD.
           05 OUTPUT-KEY-FIELD    PIC X(10).
           05 OUTPUT-DATA-FIELD   PIC X(50).
       
       SD SORT-FILE.
       01 SORT-RECORD.
           05 SORT-KEY-FIELD      PIC X(10).
           05 SORT-DATA-FIELD     PIC X(50).
       
       WORKING-STORAGE SECTION.
       *> Sort control variables
       01 SORT-CONTROL.
           05 SORT-STATUS        PIC X(1).
               88 SORT-SUCCESS   VALUE 'S'.
               88 SORT-FAILURE   VALUE 'F'.
       
       PROCEDURE DIVISION.
       MAIN-SORT-PROCESSING.
           DISPLAY 'Starting Sort with Custom Collating Sequence'
           
       *> Perform the sort with custom collating sequence
           PERFORM EXECUTE-CUSTOM-SORT
           
       *> Display results
           PERFORM DISPLAY-SORT-RESULTS
           
           STOP RUN.
       
       EXECUTE-CUSTOM-SORT.
       *> Sort using custom collating sequence
           SORT SORT-FILE
               ON ASCENDING KEY SORT-KEY-FIELD
               USING INPUT-FILE
               GIVING OUTPUT-FILE
           
       *> Check sort results
           IF SORT-STATUS = 'S'
               DISPLAY 'Sort completed successfully'
           ELSE
               DISPLAY 'Sort failed'
           END-IF.
       
       DISPLAY-SORT-RESULTS.
           DISPLAY 'Sort Results:'
           DISPLAY 'Data sorted using custom collating sequence'
           DISPLAY 'Key field used for sorting: SORT-KEY-FIELD'
           DISPLAY 'Sort order: ASCENDING'
           DISPLAY 'Output written to: OUTPUT.DAT'.

This example shows how to use the SORT statement with a custom collating sequence. The SORT statement will use the collating sequence defined in the SPECIAL-NAMES paragraph to determine the order of the sorted output. This is particularly useful when you need specialized sorting behavior that differs from the system default.

2. Collating in String Comparisons

Collating sequences also affect string comparisons in IF statements, EVALUATE clauses, and other conditional logic. Understanding how collating sequences affect comparisons is important for writing correct conditional logic.

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
       IDENTIFICATION DIVISION.
       PROGRAM-ID. COLLATING-COMPARISONS.
       *> This program demonstrates how collating sequences affect comparisons
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       *> Test data for collating sequence comparisons
       01 COMPARISON-TEST-DATA.
           05 STRING-1           PIC X(10) VALUE 'Apple'.
           05 STRING-2           PIC X(10) VALUE 'banana'.
           05 STRING-3           PIC X(10) VALUE 'CHERRY'.
           05 STRING-4           PIC X(10) VALUE '123ABC'.
           05 STRING-5           PIC X(10) VALUE '456DEF'.
       
       01 COMPARISON-RESULTS.
           05 COMPARE-RESULT     PIC X(1).
               88 STRING1-LESS   VALUE 'L'.
               88 STRING1-EQUAL  VALUE 'E'.
               88 STRING1-GREATER VALUE 'G'.
       
       PROCEDURE DIVISION.
       DEMONSTRATE-COLLATING-COMPARISONS.
           DISPLAY 'Collating Sequence in String Comparisons'
           DISPLAY '========================================'
           
       *> Demonstrate various comparison scenarios
           PERFORM COMPARE-STRING-VALUES
           PERFORM DEMONSTRATE-EVALUATE-USAGE
           PERFORM SHOW-RELATIONAL-OPERATORS
           
           STOP RUN.
       
       COMPARE-STRING-VALUES.
           DISPLAY 'String Comparison Results:'
           
       *> Compare 'Apple' and 'banana'
           IF STRING-1 < STRING-2
               DISPLAY 'Apple < banana (A < b in collating sequence)'
           ELSE
               IF STRING-1 > STRING-2
                   DISPLAY 'Apple > banana (A > b in collating sequence)'
               ELSE
                   DISPLAY 'Apple = banana (strings are equal)'
               END-IF
           END-IF
           
       *> Compare 'banana' and 'CHERRY'
           IF STRING-2 < STRING-3
               DISPLAY 'banana < CHERRY (b < C in collating sequence)'
           ELSE
               IF STRING-2 > STRING-3
                   DISPLAY 'banana > CHERRY (b > C in collating sequence)'
               ELSE
                   DISPLAY 'banana = CHERRY (strings are equal)'
               END-IF
           END-IF
           
       *> Compare '123ABC' and '456DEF'
           IF STRING-4 < STRING-5
               DISPLAY '123ABC < 456DEF (123 < 456 in collating sequence)'
           ELSE
               IF STRING-4 > STRING-5
                   DISPLAY '123ABC > 456DEF (123 > 456 in collating sequence)'
               ELSE
                   DISPLAY '123ABC = 456DEF (strings are equal)'
               END-IF
           END-IF.
       
       DEMONSTRATE-EVALUATE-USAGE.
           DISPLAY 'EVALUATE Statement with Collating Sequence:'
           
       *> Use EVALUATE with collating sequence comparisons
           EVALUATE STRING-1
               WHEN 'Apple'
                   DISPLAY 'String-1 matches Apple exactly'
               WHEN 'APPLE'
                   DISPLAY 'String-1 matches APPLE exactly'
               WHEN 'apple'
                   DISPLAY 'String-1 matches apple exactly'
               WHEN OTHER
                   DISPLAY 'String-1 does not match any expected values'
           END-EVALUATE
           
       *> Demonstrate range comparisons
           EVALUATE STRING-2
               WHEN 'A' THROUGH 'M'
                   DISPLAY 'String-2 starts with A through M'
               WHEN 'N' THROUGH 'Z'
                   DISPLAY 'String-2 starts with N through Z'
               WHEN 'a' THROUGH 'm'
                   DISPLAY 'String-2 starts with a through m'
               WHEN 'n' THROUGH 'z'
                   DISPLAY 'String-2 starts with n through z'
               WHEN OTHER
                   DISPLAY 'String-2 does not start with a letter'
           END-EVALUATE.
       
       SHOW-RELATIONAL-OPERATORS.
           DISPLAY 'Relational Operators with Collating Sequence:'
           
       *> Demonstrate various relational operators
           IF STRING-1 = STRING-2
               DISPLAY 'Apple = banana (strings are equal)'
           ELSE
               DISPLAY 'Apple ≠ banana (strings are not equal)'
           END-IF
           
           IF STRING-1 NOT = STRING-2
               DISPLAY 'Apple ≠ banana (strings are not equal)'
           ELSE
               DISPLAY 'Apple = banana (strings are equal)'
           END-IF
           
           IF STRING-1 >= STRING-2
               DISPLAY 'Apple ≥ banana (Apple greater than or equal to banana)'
           ELSE
               DISPLAY 'Apple < banana (Apple less than banana)'
           END-IF
           
           IF STRING-1 <= STRING-2
               DISPLAY 'Apple ≤ banana (Apple less than or equal to banana)'
           ELSE
               DISPLAY 'Apple > banana (Apple greater than banana)'
           END-IF.

This example demonstrates how collating sequences affect various types of string comparisons in COBOL. The results of IF statements, EVALUATE clauses, and relational operators all depend on the collating sequence being used. Understanding these effects is crucial for writing correct conditional logic and ensuring that comparisons work as expected.

Best Practices for Collating Sequences

Common Collating Sequence Patterns

Character Sets

Learn character set definitions

Character Encoding

Master character encoding techniques

String Processing

Learn string handling techniques

Sorting Operations

Master sorting techniques

Comparison Operations

Learn comparison techniques

Data Validation

Understand validation methods