Searching a Table
The tables that we have looked at have all involved extracting information from the table
using a pointer or subscript that was defined on the input. The subscript was a numeric
field with numbers starting at 1 that could be used to point to an item in the table. This
kind of subscript is called a DIRECT SUBSCRIPT meaning that the subscript as it is defined
can be used as a direct pointer to extract data from the table.
If the program is dealing with data that requires a table, but there is no field that can
be used as a DIRECT SUBSCRIPT, then it is necessary for the programmer to define a table
that can be SEARCHed using an INDIRECT SUBSCRIPT.
Indirect subscript and a search
The following example sets up a situation where a DIRECT SUBSCRIPT is inappropriate, so the
programmer must SEARCH the table using an INDIRECT SUBSCRIPT as the pointer. The search
that is needed can be done with the SEARCH VERB or with code developed by the programmer.
Some COBOL compilers do not support the SEARCH VERB and sometimes the search is too complex
to use the verb, therefore a programmer must be able to use their own code to develop a
search. Since understanding the COBOL search code is critical to understanding the concept,
the SEARCH VERB will be dealt with last.
This example will deal with a information that is to be set up in a table so that the
programmer can use the item number on the input to retrieve the item name from the table
and print it on the detail line. The programmer is provided with the following list
showing what item number goes with what item name:
|Item Number||Item Name|
|28||GREEN PEA SOUP|
In this example, the item numbers are spread out rather than clustered at the beginning of
the number sequence. The item number cannot be used as a DIRECT SUBSCRIPT. Instead, after
setting up the table in Working-Storage, the programmer must write code to search the table
using an INDIRECT SUBSCRIPT. Because the search will involve comparing the item number on
the input to the item number in the table, the item number must be included with the item
name in the table that is set up. Notice that this is a major difference from a table
where a DIRECT SUBSCRIPT can be used. In those tables the item number would not have been
included in the table.
The approach is to read the item number on the input and compare it to the first item
number entry in the table which in our example is 03, if it does not match, we move down
and compare the item number on the input to the second item number entry in the table which
in our example is 12. This pattern continues until either a match is found or there are no
more table entries to check. To do this, we need to set up a subscript or pointer in the
WORKING-STORAGE SECTION that we can use to point to the first entry in the table and then
the second etc. We also need to set up an indicator to tell us whether or not the search
05 ITEM-NUMBER-IN PIC 99.
05 ITEM-SUB PIC 99 VALUE 0.
05 MATCH-IND PIC XXX VALUE "NO ".
Next, lets look at the table or tables that the programmer will need to set up in the
WORKING-STORAGE SECTION. Remember, the item number must be kept in the table so that the
program can compare it to the item number on the input. Clearly, the item number is also
in the table since the purpose of the table is to access the item name and print it on the
line. The programmer can either establish one table containing both the item number and
the item name or two tables, one containing the item number and one containing the item
name. My very strong preference is to establish one table containing both, but I will
cover both approaches. Note that the search and processing in the PROCEDURE DIVISION are
the same no matter which setup method is chosen.
05 FILLER PIC X(17) VALUE "03SEAFOOD CHOWDER".
05 FILLER PIC X(17) VALUE "12CORN CHOWDER ".
05 FILLER PIC X(17) VALUE "15CLAM CHOWDER ".
05 FILLER PIC X(17) VALUE "17TOMATO SOUP ".
05 FILLER PIC X(17) VALUE "24CHICKEN SOUP ".
05 FILLER PIC X(17) VALUE "25VEGETABLE SOUP ".
05 FILLER PIC X(17) VALUE "27ONION SOUP ".
05 FILLER PIC X(17) VALUE "28GREEN PEA SOUP ".
05 FILLER PIC X(17) VALUE "45WONTON SOUP ".
01 RDF-TABLE-COMBINED REDEFINES TABLE-COMBINED.
05 ENTRIES OCCURS 9 TIMES.
10 ITEM-NUMBER-TBL PIC 99.
10 ITEM-NAME-TBL PIC X(15).
With this method, the item number is stored right next to the item name so it is easy to see
which number goes with which name.
Notice what happens when the table is redefined. The 05 level indicates that there are 9
entries and on the 10 level each entry is broken down so that the first two characters are
given the name ITEM-NUMBER-TBL and the last 15 characters are given the name ITEM-NAME-TBL.
This means that the item number and the item name can be accessed separately (ENTRIES
accesses the combined data).
The other approach to setting up this information uses two tables: one for item number and
one for item name.
05 FILLER PIC 99 VALUE 03.
05 FILLER PIC 99 VALUE 12.
05 FILLER PIC 99 VALUE 15.
05 FILLER PIC 99 VALUE 17.
05 FILLER PIC 99 VALUE 24.
05 FILLER PIC 99 VALUE 25.
05 FILLER PIC 99 VALUE 27.
05 FILLER PIC 99 VALUE 28.
05 FILLER PIC 99 VALUE 45.
01 RDF-TABLE-ITEM-NUMBERS REDEFINES TABLE-ITEM-NUMBERS.
05 ITEM-NUMBER-TBL PIC 99 OCCURS 9 TIMES.
05 FILLER PIC X(15) VALUE "SEAFOOD CHOWDER".
05 FILLER PIC X(15) VALUE "CORN CHOWDER ".
05 FILLER PIC X(15) VALUE "CLAM CHOWDER ".
05 FILLER PIC X(15) VALUE "TOMATO SOUP ".
05 FILLER PIC X(15) VALUE "CHICKEN SOUP ".
05 FILLER PIC X(15) VALUE "VEGETABLE SOUP ".
05 FILLER PIC X(15) VALUE "ONION SOUP ".
05 FILLER PIC X(15) VALUE "GREEN PEA SOUP ".
05 FILLER PIC X(15) VALUE "WONTON SOUP ".
01 RDF-TABLE-NAMES REDEFINES TABLE-NAMES.
05 ITEM-NAME-TBL PIC X(15) OCCURS 9 TIMES.
After the table or tables have been set up, the entries in the WORKING-STORAGE SECTION are
complete. The next step is to code the two PROCEDURE DIVISION routines: one routine that
will control the search and direct the processing steps after the search is complete
depending on whether or not the search was successful and one routine that will actually
do the search.
In the B-200-LOOP, when you are setting up the print line, you need the item name to move
to the print line. The item name is contained in the table, so you must search the table
to find a match to the item number on the input and then move the corresponding item name
to the print line. Before doing the search, some preliminary housekeeping must be done.
The subscript being used for the search must be set to 1 and the MATCH-IND used to tell
whether a match was found is set to NO. The search is performed until either the subscript
is greater than 9 which indicates that all 9 elements in the table have been checked
without finding a match or until the MATCH-IND is set to YES. When the search is over,
the program needs to know what condition triggered the end of the search (MATCH-IND = "YES"
or ITEM-SUB >9). If a match was found, the corresponding name will me moved from the table
to the print line. This will be done using ITEM-SUB. If the match was found when ITEM-SUB
= 4 then the statement MOVE ITEM-NAME-TBL (ITEM-SUB) will move the 4th name in the table.
If a match was not found then an error message defined in WORKING-STORAGE will be moved.
The search itself happens in B-300-SEARCH. The search compares the item number on the
input to the item number in the table that the ITEM-SUB subscript is pointing to. If the
two numbers match, then the MATCH-IND is set to YES. If the two numbers do not match, the
ITEM-SUB is increased by one so that the next time this paragraph is performed the subscript
will point down one item.
Notice that every time the perform is done, the UNTIL clause will check to see if the
subscript has passed the limit of 9. If the limit were passed, the subscript would be out
of bounds or out of the range of the table and the program would about. When working with
tables, the programmer needs to always keep control of the subscript so that it never goes
out of the range of the table.
The code for the search:
... processing not related to search ...
MOVE 1 TO ITEM-SUB.
MOVE "NO " TO MATCH-IND.
UNTIL ITEM-SUB > 9 OR MATCH-IND = "YES".
IF MATCH-IND = "YES"
MOVE ITEM-NAME-TBL (ITEM-SUB) TO ITEM-NAME-PR
MOVE ERROR-MSG-TBL TO ITEM-NAME-PR.
... processing not related to search...
IF ITEM-NUMBER-IN = ITEM-NUMBER-TBL (ITEM-SUB)
MOVE "YES" TO MATCH-IND
ADD 1 TO ITEM-SUB.
The B-200-LOOP includes the code to:
- set up the search - (1) set the search subscript in Working Storage that
will successively point to each element in the table to 1 and (2) initialize the match
indicator that will tell whether or not the search was successful to NO
- perform the search - perform the search routine which checks an item in
the table until either a match is found (set the match indicator to YES) or all of the
items in the table have been checked
- process according to the outcome of the search - the search is terminated
either by a match being found, in which case the match indicator will be set to YES or by
all of the elements in the table being checked - when the search is over, the indicator
will tell what caused it to end - if the indicator has been set to YES then the search was
successful and the processing that should be done if a match was found is executed - if the
indicator has stayed NO, the search was not successful and error processing should be
The B-300-SEARCH includes the code to:
Notice that the B-300-SEARCH is being performed until one of two conditions is met and
that both these conditions are changed in the B-300-SEARCH routine itself. In other words,
the MATCH-IND can be changed to YES if a match is found and the ITEM-SUB is increased by 1
each time that a match is not found. This is a very important point to understand.
The perform of the routine is done until one of two conditions is met and these conditions
both can change within the routine that is being performed so that the perform will
- Check for a match between the input and the items in the table - this
routine checks the item number on the input (ITEM-NUMBER-IN) against one of the item
numbers in the table (ITEM-NUMBER-TBL). Each time this routine is executed it will
compare to a different item number in the table. This is accomplished by using ITEM-SUB
which starts at 1 and is increased by one every time this routine is executed
- Processing if match is found - if a match is found, the match indicator
is set to YES - this accomplishes two things: (1) the routine will not be executed again
since one of the conditions that terminates the perform is MATCH-IND = "YES" and (2) it
will indicate that the search was successful and trigger appropriate processing
- Processing if match is not found - if a match is not found, ITEM-SUB is
increased by 1 so that the next time through the B-300-SEARCH the comparison will be with
the next item in the table