MainframeMaster

COBOL Tutorial

COBOL DESCENDING

The DESCENDING clause in COBOL specifies that data should be arranged in descending order, from highest to lowest values, enabling efficient data organization and search operations.

DESCENDING Syntax

DESCENDING is used with OCCURS clauses to define table key ordering and with SORT statements to specify sort order.

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
*> DESCENDING with OCCURS clause
level-number table-name OCCURS number TIMES
    [ASCENDING/DESCENDING KEY key-field-name]
    [INDEXED BY index-name]
 
*> DESCENDING with SORT statement
SORT sort-file-name
    ON DESCENDING KEY key-field-name
    [ON ASCENDING/DESCENDING KEY additional-key]
    USING input-file-name
    GIVING output-file-name
 
*> Multiple keys with mixed ordering
05 EMPLOYEE-TABLE OCCURS 100 TIMES
    ASCENDING KEY EMP-DEPT
    DESCENDING KEY EMP-SALARY
    INDEXED BY EMP-INDEX

DESCENDING with Table Keys

Single DESCENDING Key

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-SALES-DATA.
   05 WS-SALES-COUNT        PIC 9(3) VALUE 0.
   05 WS-SALES-RECORD       OCCURS 50 TIMES
                            DESCENDING KEY WS-SALES-AMOUNT
                            INDEXED BY SALES-INDEX.
      10 WS-SALES-ID        PIC X(6).
      10 WS-SALESPERSON     PIC X(25).
      10 WS-SALES-AMOUNT    PIC 9(8)V99.
      10 WS-SALES-DATE      PIC X(8).
 
01 WS-PROCESSING-VARIABLES.
   05 WS-SEARCH-AMOUNT      PIC 9(8)V99.
   05 WS-TEMP-RECORD.
      10 WS-TEMP-ID         PIC X(6).
      10 WS-TEMP-PERSON     PIC X(25).
      10 WS-TEMP-AMOUNT     PIC 9(8)V99.
      10 WS-TEMP-DATE       PIC X(8).
 
PROCEDURE DIVISION.
DESCENDING-KEY-DEMO.
    DISPLAY "=== DESCENDING Key Table Demo ==="
    
    PERFORM LOAD-SALES-DATA
    PERFORM DISPLAY-SALES-TABLE
    PERFORM DEMONSTRATE-SEARCH.
 
LOAD-SALES-DATA.
    *> Load sample sales data (will be automatically sorted by amount descending)
    PERFORM ADD-SALES-RECORD("SAL001", "John Smith", 15000.00, "20240115")
    PERFORM ADD-SALES-RECORD("SAL002", "Jane Doe", 22000.00, "20240116")
    PERFORM ADD-SALES-RECORD("SAL003", "Bob Johnson", 18000.00, "20240117")
    PERFORM ADD-SALES-RECORD("SAL004", "Alice Brown", 25000.00, "20240118")
    PERFORM ADD-SALES-RECORD("SAL005", "Charlie Wilson", 12000.00, "20240119")
    
    DISPLAY "Loaded " WS-SALES-COUNT " sales records"
    DISPLAY "Table automatically sorted by sales amount (descending)".
 
ADD-SALES-RECORD.
    *> This represents adding a record and maintaining descending order
    ADD 1 TO WS-SALES-COUNT
    
    *> In a real implementation, you would insert in the correct position
    *> For demo, we'll add and then sort
    CONTINUE.
 
DISPLAY-SALES-TABLE.
    DISPLAY " "
    DISPLAY "Sales Records (Sorted by Amount - Descending):"
    DISPLAY "ID     Salesperson               Amount      Date"
    DISPLAY "------ ------------------------ ----------- --------"
    
    PERFORM VARYING SALES-INDEX FROM 1 BY 1
            UNTIL SALES-INDEX > WS-SALES-COUNT
        DISPLAY WS-SALES-ID(SALES-INDEX) " "
                WS-SALESPERSON(SALES-INDEX) " "
                WS-SALES-AMOUNT(SALES-INDEX) " "
                WS-SALES-DATE(SALES-INDEX)
    END-PERFORM.
 
DEMONSTRATE-SEARCH.
    DISPLAY " "
    DISPLAY "=== Binary Search on DESCENDING Table ==="
    
    *> Search for specific amount
    MOVE 18000.00 TO WS-SEARCH-AMOUNT
    
    SEARCH ALL WS-SALES-RECORD
        AT END
            DISPLAY "Sales amount " WS-SEARCH-AMOUNT " not found"
        WHEN WS-SALES-AMOUNT(SALES-INDEX) = WS-SEARCH-AMOUNT
            DISPLAY "Found sales record:"
            DISPLAY "  ID: " WS-SALES-ID(SALES-INDEX)
            DISPLAY "  Salesperson: " WS-SALESPERSON(SALES-INDEX)
            DISPLAY "  Amount: " WS-SALES-AMOUNT(SALES-INDEX)
            DISPLAY "  Date: " WS-SALES-DATE(SALES-INDEX)
    END-SEARCH.

Multiple Keys with Mixed Ordering

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-EMPLOYEE-DATA.
   05 WS-EMP-COUNT          PIC 9(3) VALUE 0.
   05 WS-EMPLOYEE-RECORD    OCCURS 100 TIMES
                            ASCENDING KEY WS-EMP-DEPT
                            DESCENDING KEY WS-EMP-SALARY
                            INDEXED BY EMP-INDEX.
      10 WS-EMP-ID          PIC X(6).
      10 WS-EMP-NAME        PIC X(25).
      10 WS-EMP-DEPT        PIC X(3).
      10 WS-EMP-SALARY      PIC 9(6)V99.
      10 WS-EMP-HIRE-DATE   PIC X(8).
 
01 WS-SEARCH-CRITERIA.
   05 WS-SEARCH-DEPT        PIC X(3).
   05 WS-SEARCH-SALARY      PIC 9(6)V99.
 
PROCEDURE DIVISION.
MIXED-ORDERING-DEMO.
    DISPLAY "=== Mixed Ordering Keys Demo ==="
    
    PERFORM LOAD-EMPLOYEE-DATA
    PERFORM DISPLAY-BY-DEPARTMENT
    PERFORM DEMONSTRATE-MULTI-KEY-SEARCH.
 
LOAD-EMPLOYEE-DATA.
    *> Load employees from different departments with various salaries
    PERFORM ADD-EMPLOYEE("EMP001", "John Smith", "IT", 75000.00, "20220115")
    PERFORM ADD-EMPLOYEE("EMP002", "Jane Doe", "HR", 65000.00, "20220201")
    PERFORM ADD-EMPLOYEE("EMP003", "Bob Johnson", "IT", 85000.00, "20220110")
    PERFORM ADD-EMPLOYEE("EMP004", "Alice Brown", "FIN", 90000.00, "20220305")
    PERFORM ADD-EMPLOYEE("EMP005", "Charlie Wilson", "IT", 70000.00, "20220120")
    PERFORM ADD-EMPLOYEE("EMP006", "Diana Davis", "HR", 70000.00, "20220215")
    PERFORM ADD-EMPLOYEE("EMP007", "Eve Miller", "FIN", 95000.00, "20220301")
    PERFORM ADD-EMPLOYEE("EMP008", "Frank Garcia", "HR", 60000.00, "20220220")
    
    DISPLAY "Loaded " WS-EMP-COUNT " employee records"
    DISPLAY "Sorted by: Department (Ascending), then Salary (Descending)".
 
ADD-EMPLOYEE.
    *> Simplified add - in real code would maintain sort order
    ADD 1 TO WS-EMP-COUNT
    CONTINUE.
 
DISPLAY-BY-DEPARTMENT.
    DISPLAY " "
    DISPLAY "Employee Records (Dept ASC, Salary DESC):"
    DISPLAY "ID     Name                     Dept Salary    Hire Date"
    DISPLAY "------ ------------------------ ---- --------- --------"
    
    PERFORM VARYING EMP-INDEX FROM 1 BY 1
            UNTIL EMP-INDEX > WS-EMP-COUNT
        DISPLAY WS-EMP-ID(EMP-INDEX) " "
                WS-EMP-NAME(EMP-INDEX) " "
                WS-EMP-DEPT(EMP-INDEX) "  "
                WS-EMP-SALARY(EMP-INDEX) " "
                WS-EMP-HIRE-DATE(EMP-INDEX)
    END-PERFORM
    
    PERFORM ANALYZE-DEPARTMENT-GROUPING.
 
ANALYZE-DEPARTMENT-GROUPING.
    DISPLAY " "
    DISPLAY "Department Analysis:"
    
    MOVE SPACES TO WS-SEARCH-DEPT
    PERFORM VARYING EMP-INDEX FROM 1 BY 1
            UNTIL EMP-INDEX > WS-EMP-COUNT
        
        IF WS-EMP-DEPT(EMP-INDEX) NOT = WS-SEARCH-DEPT
            MOVE WS-EMP-DEPT(EMP-INDEX) TO WS-SEARCH-DEPT
            DISPLAY "Department: " WS-SEARCH-DEPT
            PERFORM COUNT-DEPT-EMPLOYEES
        END-IF
    END-PERFORM.
 
COUNT-DEPT-EMPLOYEES.
    MOVE 0 TO WS-DEPT-COUNT
    MOVE 0 TO WS-TOTAL-SALARY
    MOVE 0 TO WS-MAX-SALARY
    
    PERFORM VARYING WS-INDEX FROM 1 BY 1
            UNTIL WS-INDEX > WS-EMP-COUNT
        IF WS-EMP-DEPT(WS-INDEX) = WS-SEARCH-DEPT
            ADD 1 TO WS-DEPT-COUNT
            ADD WS-EMP-SALARY(WS-INDEX) TO WS-TOTAL-SALARY
            IF WS-EMP-SALARY(WS-INDEX) > WS-MAX-SALARY
                MOVE WS-EMP-SALARY(WS-INDEX) TO WS-MAX-SALARY
            END-IF
        END-IF
    END-PERFORM
    
    COMPUTE WS-AVG-SALARY = WS-TOTAL-SALARY / WS-DEPT-COUNT
    
    DISPLAY "  Employees: " WS-DEPT-COUNT
    DISPLAY "  Highest Salary: " WS-MAX-SALARY
    DISPLAY "  Average Salary: " WS-AVG-SALARY.
 
DEMONSTRATE-MULTI-KEY-SEARCH.
    DISPLAY " "
    DISPLAY "=== Multi-Key Search Demo ==="
    
    *> Search for employee in IT department with specific salary
    MOVE "IT" TO WS-SEARCH-DEPT
    MOVE 75000.00 TO WS-SEARCH-SALARY
    
    SEARCH ALL WS-EMPLOYEE-RECORD
        AT END
            DISPLAY "No employee found in " WS-SEARCH-DEPT 
                    " with salary " WS-SEARCH-SALARY
        WHEN WS-EMP-DEPT(EMP-INDEX) = WS-SEARCH-DEPT
         AND WS-EMP-SALARY(EMP-INDEX) = WS-SEARCH-SALARY
            DISPLAY "Found employee:"
            DISPLAY "  ID: " WS-EMP-ID(EMP-INDEX)
            DISPLAY "  Name: " WS-EMP-NAME(EMP-INDEX)
            DISPLAY "  Department: " WS-EMP-DEPT(EMP-INDEX)
            DISPLAY "  Salary: " WS-EMP-SALARY(EMP-INDEX)
            DISPLAY "  Hire Date: " WS-EMP-HIRE-DATE(EMP-INDEX)
    END-SEARCH.

DESCENDING with SORT Statement

Basic SORT with DESCENDING Key

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
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT INPUT-FILE ASSIGN TO "UNSORTED.DAT"
        ORGANIZATION IS SEQUENTIAL
        FILE STATUS IS INPUT-STATUS.
    
    SELECT OUTPUT-FILE ASSIGN TO "SORTED.DAT"
        ORGANIZATION IS SEQUENTIAL
        FILE STATUS IS OUTPUT-STATUS.
    
    SELECT SORT-FILE ASSIGN TO "SORTWORK"
        ORGANIZATION IS SEQUENTIAL.
 
DATA DIVISION.
FILE SECTION.
FD INPUT-FILE.
01 INPUT-RECORD.
   05 INPUT-ID              PIC X(6).
   05 INPUT-NAME            PIC X(25).
   05 INPUT-SCORE           PIC 9(3).
   05 INPUT-DATE            PIC X(8).
 
FD OUTPUT-FILE.
01 OUTPUT-RECORD.
   05 OUTPUT-ID             PIC X(6).
   05 OUTPUT-NAME           PIC X(25).
   05 OUTPUT-SCORE          PIC 9(3).
   05 OUTPUT-DATE           PIC X(8).
 
SD SORT-FILE.
01 SORT-RECORD.
   05 SORT-ID               PIC X(6).
   05 SORT-NAME             PIC X(25).
   05 SORT-SCORE            PIC 9(3).
   05 SORT-DATE             PIC X(8).
 
WORKING-STORAGE SECTION.
01 INPUT-STATUS             PIC X(2).
01 OUTPUT-STATUS            PIC X(2).
01 WS-RECORD-COUNT          PIC 9(5) VALUE 0.
 
PROCEDURE DIVISION.
SORT-DESCENDING-DEMO.
    DISPLAY "=== SORT with DESCENDING Key Demo ==="
    
    *> Sort by score in descending order (highest scores first)
    SORT SORT-FILE
        ON DESCENDING KEY SORT-SCORE
        USING INPUT-FILE
        GIVING OUTPUT-FILE
    
    DISPLAY "Sort completed - records sorted by score (descending)"
    
    PERFORM DISPLAY-SORTED-RESULTS.
 
DISPLAY-SORTED-RESULTS.
    OPEN INPUT OUTPUT-FILE
    
    DISPLAY " "
    DISPLAY "Sorted Results (Score Descending):"
    DISPLAY "ID     Name                     Score Date"
    DISPLAY "------ ------------------------ ----- --------"
    
    PERFORM READ-AND-DISPLAY UNTIL INPUT-STATUS = "10"
    
    CLOSE OUTPUT-FILE
    
    DISPLAY "Total records processed: " WS-RECORD-COUNT.
 
READ-AND-DISPLAY.
    READ OUTPUT-FILE
        AT END
            MOVE "10" TO INPUT-STATUS
        NOT AT END
            ADD 1 TO WS-RECORD-COUNT
            DISPLAY OUTPUT-ID " "
                    OUTPUT-NAME " "
                    OUTPUT-SCORE " "
                    OUTPUT-DATE
    END-READ.

Multi-Key SORT with Mixed Ordering

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
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT SALES-INPUT ASSIGN TO "SALESIN.DAT"
        ORGANIZATION IS SEQUENTIAL.
    
    SELECT SALES-OUTPUT ASSIGN TO "SALESOUT.DAT"
        ORGANIZATION IS SEQUENTIAL.
    
    SELECT SALES-SORT ASSIGN TO "SORTWORK".
 
DATA DIVISION.
FILE SECTION.
SD SALES-SORT.
01 SORT-SALES-RECORD.
   05 SORT-REGION           PIC X(2).
   05 SORT-SALESPERSON      PIC X(25).
   05 SORT-SALES-AMOUNT     PIC 9(8)V99.
   05 SORT-COMMISSION       PIC 9(6)V99.
   05 SORT-QUARTER          PIC 9(1).
 
FD SALES-INPUT.
01 INPUT-SALES-RECORD.
   05 INPUT-REGION          PIC X(2).
   05 INPUT-SALESPERSON     PIC X(25).
   05 INPUT-SALES-AMOUNT    PIC 9(8)V99.
   05 INPUT-COMMISSION      PIC 9(6)V99.
   05 INPUT-QUARTER         PIC 9(1).
 
FD SALES-OUTPUT.
01 OUTPUT-SALES-RECORD.
   05 OUTPUT-REGION         PIC X(2).
   05 OUTPUT-SALESPERSON    PIC X(25).
   05 OUTPUT-SALES-AMOUNT   PIC 9(8)V99.
   05 OUTPUT-COMMISSION     PIC 9(6)V99.
   05 OUTPUT-QUARTER        PIC 9(1).
 
WORKING-STORAGE SECTION.
01 WS-SORT-STATISTICS.
   05 WS-RECORDS-SORTED     PIC 9(5) VALUE 0.
   05 WS-CURRENT-REGION     PIC X(2) VALUE SPACES.
   05 WS-REGION-TOTAL       PIC 9(10)V99 VALUE 0.
   05 WS-GRAND-TOTAL        PIC 9(12)V99 VALUE 0.
 
PROCEDURE DIVISION.
MULTI-KEY-SORT-DEMO.
    DISPLAY "=== Multi-Key SORT with Mixed Ordering ==="
    
    *> Sort by:
    *> 1. Region (Ascending) - to group regions together
    *> 2. Sales Amount (Descending) - highest sales first within region
    *> 3. Quarter (Ascending) - chronological order for same amounts
    
    SORT SALES-SORT
        ON ASCENDING KEY SORT-REGION
        ON DESCENDING KEY SORT-SALES-AMOUNT
        ON ASCENDING KEY SORT-QUARTER
        INPUT PROCEDURE IS SORT-INPUT-PROC
        OUTPUT PROCEDURE IS SORT-OUTPUT-PROC
    
    PERFORM DISPLAY-SORT-SUMMARY.
 
SORT-INPUT-PROC.
    OPEN INPUT SALES-INPUT
    
    PERFORM READ-INPUT-RECORD UNTIL INPUT-SALES-RECORD = HIGH-VALUES
    
    CLOSE SALES-INPUT.
 
READ-INPUT-RECORD.
    READ SALES-INPUT
        AT END
            MOVE HIGH-VALUES TO INPUT-SALES-RECORD
        NOT AT END
            MOVE INPUT-SALES-RECORD TO SORT-SALES-RECORD
            RELEASE SORT-SALES-RECORD
            ADD 1 TO WS-RECORDS-SORTED
    END-READ.
 
SORT-OUTPUT-PROC.
    OPEN OUTPUT SALES-OUTPUT
    
    PERFORM RETURN-SORTED-RECORD UNTIL SORT-SALES-RECORD = HIGH-VALUES
    
    CLOSE SALES-OUTPUT.
 
RETURN-SORTED-RECORD.
    RETURN SALES-SORT
        AT END
            MOVE HIGH-VALUES TO SORT-SALES-RECORD
        NOT AT END
            MOVE SORT-SALES-RECORD TO OUTPUT-SALES-RECORD
            WRITE OUTPUT-SALES-RECORD
            PERFORM ACCUMULATE-TOTALS
            PERFORM DISPLAY-SORTED-RECORD
    END-RETURN.
 
ACCUMULATE-TOTALS.
    *> Check for region break
    IF SORT-REGION NOT = WS-CURRENT-REGION
        IF WS-CURRENT-REGION NOT = SPACES
            DISPLAY "  Region " WS-CURRENT-REGION " Total: $" WS-REGION-TOTAL
            DISPLAY " "
        END-IF
        MOVE SORT-REGION TO WS-CURRENT-REGION
        MOVE 0 TO WS-REGION-TOTAL
        DISPLAY "Region: " WS-CURRENT-REGION
    END-IF
    
    ADD SORT-SALES-AMOUNT TO WS-REGION-TOTAL
    ADD SORT-SALES-AMOUNT TO WS-GRAND-TOTAL.
 
DISPLAY-SORTED-RECORD.
    DISPLAY "  " SORT-SALESPERSON " Q" SORT-QUARTER 
            " $" SORT-SALES-AMOUNT " (Comm: $" SORT-COMMISSION ")".
 
DISPLAY-SORT-SUMMARY.
    DISPLAY " "
    DISPLAY "Final Region Total: $" WS-REGION-TOTAL
    DISPLAY " "
    DISPLAY "=== Sort Summary ==="
    DISPLAY "Records sorted: " WS-RECORDS-SORTED
    DISPLAY "Grand total sales: $" WS-GRAND-TOTAL
    DISPLAY "Sort order: Region ASC, Sales Amount DESC, Quarter ASC".

Advanced DESCENDING Techniques

Dynamic Sort Order Selection

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
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-PRODUCT-TABLE.
   05 WS-PRODUCT-COUNT      PIC 9(3) VALUE 0.
   05 WS-PRODUCT-ITEM       OCCURS 100 TIMES
                            INDEXED BY PROD-INDEX.
      10 WS-PROD-ID         PIC X(8).
      10 WS-PROD-NAME       PIC X(30).
      10 WS-PROD-PRICE      PIC 9(6)V99.
      10 WS-PROD-STOCK      PIC 9(5).
      10 WS-PROD-CATEGORY   PIC X(15).
 
01 WS-SORT-CONTROLS.
   05 WS-SORT-CHOICE        PIC X(1).
   05 WS-SORT-DIRECTION     PIC X(1).
   05 WS-TEMP-PRODUCT.
      10 WS-TEMP-ID         PIC X(8).
      10 WS-TEMP-NAME       PIC X(30).
      10 WS-TEMP-PRICE      PIC 9(6)V99.
      10 WS-TEMP-STOCK      PIC 9(5).
      10 WS-TEMP-CATEGORY   PIC X(15).
 
PROCEDURE DIVISION.
DYNAMIC-SORT-DEMO.
    DISPLAY "=== Dynamic Sort Order Demo ==="
    
    PERFORM LOAD-SAMPLE-PRODUCTS
    PERFORM SORT-MENU.
 
LOAD-SAMPLE-PRODUCTS.
    *> Load sample products
    PERFORM ADD-PRODUCT("PROD001", "Laptop", 1299.99, 25, "Electronics")
    PERFORM ADD-PRODUCT("PROD002", "Mouse", 29.99, 150, "Electronics")
    PERFORM ADD-PRODUCT("PROD003", "Chair", 249.50, 30, "Furniture")
    PERFORM ADD-PRODUCT("PROD004", "Desk", 399.00, 15, "Furniture")
    PERFORM ADD-PRODUCT("PROD005", "Monitor", 299.99, 40, "Electronics")
    
    DISPLAY "Loaded " WS-PRODUCT-COUNT " products".
 
ADD-PRODUCT.
    *> Simplified add for demo
    ADD 1 TO WS-PRODUCT-COUNT
    CONTINUE.
 
SORT-MENU.
    PERFORM DISPLAY-CURRENT-TABLE
    
    DISPLAY " "
    DISPLAY "Sort Options:"
    DISPLAY "(1) Price, (2) Stock, (3) Name, (4) Category"
    DISPLAY "Choose sort field (1-4): "
    ACCEPT WS-SORT-CHOICE
    
    DISPLAY "Sort direction - (A)scending or (D)escending: "
    ACCEPT WS-SORT-DIRECTION
    
    PERFORM EXECUTE-SORT
    
    DISPLAY "Continue? (Y/N): "
    ACCEPT WS-CONTINUE-FLAG
    
    IF WS-CONTINUE-FLAG = 'Y' OR WS-CONTINUE-FLAG = 'y'
        PERFORM SORT-MENU
    END-IF.
 
DISPLAY-CURRENT-TABLE.
    DISPLAY " "
    DISPLAY "Current Product Table:"
    DISPLAY "ID       Name                           Price    Stock Category"
    DISPLAY "-------- ------------------------------ -------- ----- ---------------"
    
    PERFORM VARYING PROD-INDEX FROM 1 BY 1
            UNTIL PROD-INDEX > WS-PRODUCT-COUNT
        DISPLAY WS-PROD-ID(PROD-INDEX) " "
                WS-PROD-NAME(PROD-INDEX) " "
                WS-PROD-PRICE(PROD-INDEX) " "
                WS-PROD-STOCK(PROD-INDEX) " "
                WS-PROD-CATEGORY(PROD-INDEX)
    END-PERFORM.
 
EXECUTE-SORT.
    EVALUATE WS-SORT-CHOICE
        WHEN "1"
            PERFORM SORT-BY-PRICE
        WHEN "2"
            PERFORM SORT-BY-STOCK
        WHEN "3"
            PERFORM SORT-BY-NAME
        WHEN "4"
            PERFORM SORT-BY-CATEGORY
        WHEN OTHER
            DISPLAY "Invalid choice"
    END-EVALUATE.
 
SORT-BY-PRICE.
    DISPLAY "Sorting by price..."
    PERFORM BUBBLE-SORT-PRICE
    
    IF WS-SORT-DIRECTION = 'D' OR WS-SORT-DIRECTION = 'd'
        DISPLAY "Applied descending order"
    ELSE
        DISPLAY "Applied ascending order"
    END-IF.
 
BUBBLE-SORT-PRICE.
    PERFORM VARYING WS-I FROM 1 BY 1
            UNTIL WS-I >= WS-PRODUCT-COUNT
        PERFORM VARYING WS-J FROM WS-I BY 1
                UNTIL WS-J > WS-PRODUCT-COUNT
            
            EVALUATE WS-SORT-DIRECTION
                WHEN 'A' OR 'a'
                    IF WS-PROD-PRICE(WS-I) > WS-PROD-PRICE(WS-J)
                        PERFORM SWAP-PRODUCTS
                    END-IF
                WHEN 'D' OR 'd'
                    IF WS-PROD-PRICE(WS-I) < WS-PROD-PRICE(WS-J)
                        PERFORM SWAP-PRODUCTS
                    END-IF
            END-EVALUATE
        END-PERFORM
    END-PERFORM.
 
SORT-BY-STOCK.
    DISPLAY "Sorting by stock quantity..."
    PERFORM BUBBLE-SORT-STOCK.
 
BUBBLE-SORT-STOCK.
    PERFORM VARYING WS-I FROM 1 BY 1
            UNTIL WS-I >= WS-PRODUCT-COUNT
        PERFORM VARYING WS-J FROM WS-I BY 1
                UNTIL WS-J > WS-PRODUCT-COUNT
            
            EVALUATE WS-SORT-DIRECTION
                WHEN 'A' OR 'a'
                    IF WS-PROD-STOCK(WS-I) > WS-PROD-STOCK(WS-J)
                        PERFORM SWAP-PRODUCTS
                    END-IF
                WHEN 'D' OR 'd'
                    IF WS-PROD-STOCK(WS-I) < WS-PROD-STOCK(WS-J)
                        PERFORM SWAP-PRODUCTS
                    END-IF
            END-EVALUATE
        END-PERFORM
    END-PERFORM.
 
SWAP-PRODUCTS.
    MOVE WS-PRODUCT-ITEM(WS-I) TO WS-TEMP-PRODUCT
    MOVE WS-PRODUCT-ITEM(WS-J) TO WS-PRODUCT-ITEM(WS-I)
    MOVE WS-TEMP-PRODUCT TO WS-PRODUCT-ITEM(WS-J).

Best Practices and Guidelines

DESCENDING Best Practices

  • Choose sort order based on most common access patterns
  • Use DESCENDING for data where you typically need highest values first
  • Consider using multiple keys to create meaningful data groupings
  • Document the business logic behind your sort order choices
  • Test binary search operations thoroughly with DESCENDING keys
  • Be consistent with sort orders across related tables and files
  • Consider performance implications of your chosen sort order

Common DESCENDING Patterns

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
*> Single descending key pattern
05 sales-table OCCURS 100 TIMES
    DESCENDING KEY sales-amount
    INDEXED BY sales-index
 
*> Mixed ordering pattern  
05 employee-table OCCURS 200 TIMES
    ASCENDING KEY emp-department
    DESCENDING KEY emp-salary
    INDEXED BY emp-index
 
*> Sort statement pattern
SORT sort-file
    ON DESCENDING KEY sort-amount
    ON ASCENDING KEY sort-date
    USING input-file
    GIVING output-file
 
*> Search on descending table
SEARCH ALL table-name
    AT END
        PERFORM not-found-routine
    WHEN key-field(index) = search-value
        PERFORM found-routine
END-SEARCH

Related Concepts

Sorting Algorithms

Understanding different sorting techniques and implementations

Table Processing

Complete guide to table operations and data organization

Data Ordering

Techniques for organizing and arranging data efficiently

Search Techniques

Binary search and other search algorithms for sorted data

Frequently Asked Questions