Manipulate COBOL data structure

Question

I would like informations to manipulate tables. I encounter few problem with a piece of cobol code like below: ``` 01 TABLE-1. 05 STRUCT-1 OCCURS 25 TIMES. 10 VALUE-1 PIC AAA. 10 VALUE-2 PIC 9(5)V999. 05 NUMBER-OF-OCCURS PIC 99. ``` How do you update values? (update a VALUE-2 when you know a VALUE-1) How look up a value and add new one? Thanks a lot!

Accepted Answer

How to look up a value/How to update a value

First you have to look up the record (row) that you want to update. This is typically done by searching the table for a given key value. COBOL provides a couple of ways to do this. I recommend that you start by reviewing the COBOL SEARCH statement. If `STRUCT-1` records are sorted, you could use `SEARCH ALL`, otherwise you must use `SEARCH` or just code your own search loop. In order to use any of these techniques you will need to declare another variable somewhere in your program to use as an index (offset) into the `STRUCT-1` table. COBOL provides the `INDEXED BY` phrase on the `OCCURS` clause to declare an index specific to the given table (see OCCURS)

Once you have set the index into `STRUCT-1` to point to the row to be updated you just `MOVE` the value to the appropriate variables within that row, for example

MOVE 123.456 TO VALUE-2 (IDX-1)

where IDX-1 is the index referred to above. Note that you can use either an integer or index variable to specify the row number to be updated, you are not limited to using an INDEX type variable. However, it is generally more efficient to use INDEX variables over other types of variables, particularily when working with multi-dimensional tables where the program makes lots of references to the table.

How to add a new row

First recognize that `STRUCT-1` contains exactly 25 rows. COBOL does not have a mechanism to dynamically increase or decrease this number (I've heard this will possible in the next ISO COBOL standard - but don't hold your breath waiting for it). Technically all 25 rows are available at any time. However a common convention is to 'grow' a table from being empty to full sequentially, one row at a time. To use this convention you need to assign a variable to keep track of the last used row number (don't forget to initialize this variable to zero at program startup). In your example it looks like the variable `NUMBER-OF-OCCURS` does this job (I didn't mention it but, you need this variable to bound the SEARCH discussed above).

To 'add' a row, just increment `NUMBER-OF-OCCURS` by 1. Be careful not to exceed the table size. Example code might be:

```
IF NUMBER-OF-OCCURS < (LENGTH OF TABLE-1 / LENGTH OF STRUCT-1 (1))
   ADD +1 TO NUMBER-OF-OCCURS
ELSE
   table is full, preform some error/recovery routine
END-IF
```

The above code avoids the explicit use of the number of occurs in `TABLE-1` which in turn can save a number of maintenance problems when/if the number of OCCURS is ever changed.

See the NOTE at the bottom: There is a really big Woops here - did you catch it!

Now back to the search problem. The following code example illustrates how you might proceed:

WORKING-STORAGE Declaration:

```
 01 FOUND-IND  PIC X(1).
    88 FOUND-YES  VALUE 'Y'.
    88 FOUND-NO   VALUE 'N'.
 77 MAX-IDX   USAGE IS INDEX.

01 TABLE-1.
    05 STRUCT-1 OCCURS 25 TIMES INDEXED BY IDX-1.
       10 VALUE-1 PIC AAA.
       10 VALUE-2 PIC 9(5)V999.
    05 NUMBER-OF-OCCURS PIC 99.
```

What was added:

- `FOUND-IND` is used to indicate whether the row you are looking for has been found. The 88 levels give specific values to set/test

- `MAX-IDX` is used to set an upper bound limit on the search. You could use `NUMBER-OF-OCCURS` in the upper bounds test but this would force a data type converson on every test which isn't very efficient

- `IDX-1` is used as the index (offset) into the `STRUCT-1` table.

Personally, I would declare `NUMBER-OF-OCCURS` as `PIC S9(4) BINARY` but what you have will work.

Assuming that `STRUCT-1` is not sorted and `NUMBER-OF-OCCURS` represents the current number of active rows in `STRUCT-1` this is an example of how you might code the `SEARCH` when looking for the value 'ABC':

```
SET FOUND-NO TO TRUE
IF NUMBER-OF-OCCURS > ZERO

SET IDX-1 TO 1
   SET MAX-IDX TO NUMBER-OF-OCCURS

SEARCH STRUCT-1
     WHEN IDX-1 > MAX-IDX
       CONTINUE
     WHEN VALUE-1 (IDX-1) = 'ABC'
       SET FOUND-YES TO TRUE
   END-SEARCH
END-IF

IF FOUND-YES
   row found, use IDX-1 to reference the row containing 'ABC'
ELSE
   row not found, IDX-1 does not contain a valid index
END-IF
```

How it works:

- Start by assuming the row is not in the table by setting `FOUND-NO` to true.

- The first `IF` ensures that there is at least 1 active row in `STRUCT-1` before beginning the search (it is an error to set an INDEX to zero - so you need to guard against that).

- The `SEARCH` terminates when the first `SEARCH WHEN` clause is satisified. That is why the 'do nothing' verb `CONTINUE` can be used when we run out of rows to search. The other terminating condition (finding the value you are looking for) is the only place where `FOUND-YES` can be set.

- When the `SEARCH` completes, test for success or failure then act accordingly.

Some exercises for you to research:

- Why did I not have to code an `AT END` clause in the `SEARCH` statement?

- Why did I not have to code a `VARYING` clause in the `SEARCH` statement?

- W…

Manipulate COBOL data structure

Solution

Problem