100% Free Forever
AI-Powered Learning
Industry Expert Content
Certificates & Badges
Learn At Your Own Pace
Programming

COBOL and DB2

Learn how COBOL programs embed SQL to interact with a DB2 relational database, using host variables, cursors, and SQLCA/SQLCODE for error checking.

Structured ProgrammingAdvanced11 min readJul 10, 2026
Analogies

Embedded SQL in COBOL Programs

A COBOL program accesses a DB2 relational database by writing embedded SQL statements directly in the PROCEDURE DIVISION, delimited by EXEC SQL and END-EXEC, which a preprocessor called the DB2 precompiler scans and replaces with calls to the DB2 runtime before the modified source is handed to the standard COBOL compiler. Host variables, ordinary COBOL WORKING-STORAGE fields prefixed with a colon inside SQL statements like WHERE CUST_ID = :WS-CUST-ID, let SQL statements read values from and write results into normal COBOL data items, bridging the relational, set-based world of SQL with COBOL's record-oriented procedural style. The DATA DIVISION also typically includes an EXEC SQL INCLUDE member-name END-EXEC statement pulling in the DCLGEN-generated host variable structure that mirrors a table's column definitions, ensuring the COBOL field lengths and types stay synchronized with the actual DB2 table schema.

🏏

Cricket analogy: Embedded SQL inside COBOL is like a commentator switching from live play-by-play English into reading out an official Hawk-Eye trajectory report mid-broadcast; the surrounding language stays the same broadcast, but a distinct, precisely delimited segment queries a different data source.

SQLCA and SQLCODE for Error Checking

Every embedded SQL statement implicitly populates the SQL Communication Area, SQLCA, a structure the precompiler automatically declares, and the program must check the SQLCODE field within it after each SQL statement to determine success or failure. An SQLCODE of zero means the statement succeeded, +100 means no rows were found to satisfy a SELECT or FETCH, and negative values indicate genuine errors such as -803 for a duplicate key violation or -305 for an unexpected null value fetched into a non-nullable host variable, and disciplined programs code a shared paragraph like 9999-CHECK-SQLCODE, performed after every EXEC SQL block, to branch on these values consistently. Because SQL operates on sets and can implicitly return null, host variables that might receive a null column value require a paired indicator variable, declared as a COBOL PIC S9(4) COMP field referenced with a colon like :WS-CUST-NAME:WS-CUST-NAME-IND, which DB2 sets to -1 when the actual column value was null.

🏏

Cricket analogy: SQLCODE is like the on-field umpire's raised finger versus a shake of the head after every single delivery, an explicit signal the batting side must check each ball to know whether that delivery counted as a wicket, a dot, or a run.

Cursors for Multi-Row Result Sets

Because COBOL processes data one record at a time while SQL SELECT statements naturally return sets of many rows, a program that needs to iterate over multiple result rows must declare a cursor with EXEC SQL DECLARE CURSOR-NAME CURSOR FOR SELECT ... END-EXEC, then explicitly OPEN the cursor, repeatedly FETCH one row at a time into host variables inside a PERFORM UNTIL loop checking SQLCODE for +100 as the end-of-data signal, and finally CLOSE the cursor once processing completes. This pattern, structurally similar to the AT END loop used for sequential file reads, lets a COBOL batch program page through thousands of DB2 rows, such as every overdue account in a billing cycle, one record at a time while applying normal procedural logic like conditional updates or accumulation between fetches. Cursors can also be declared FOR UPDATE OF column-list, which allows a subsequent WHERE CURRENT OF CURSOR-NAME clause on an UPDATE or DELETE statement to modify exactly the row most recently fetched, without needing to re-specify its full key.

🏏

Cricket analogy: A DB2 cursor is like a scorer working through the ball-by-ball log of an entire innings one delivery at a time, FETCHing the next ball's details into the scoresheet row by row rather than seeing the whole innings at once.

cobol
       WORKING-STORAGE SECTION.
           EXEC SQL INCLUDE SQLCA END-EXEC.
       01  WS-CUST-ID          PIC X(6).
       01  WS-CUST-BALANCE     PIC S9(7)V99 COMP-3.

           EXEC SQL
               DECLARE OVERDUE-CUR CURSOR FOR
                   SELECT CUST_ID, BALANCE
                   FROM CUSTOMER_ACCOUNTS
                   WHERE BALANCE > 0 AND DUE_DATE < CURRENT DATE
           END-EXEC.

       PROCEDURE DIVISION.
           EXEC SQL OPEN OVERDUE-CUR END-EXEC
           PERFORM UNTIL SQLCODE = 100
               EXEC SQL
                   FETCH OVERDUE-CUR INTO :WS-CUST-ID, :WS-CUST-BALANCE
               END-EXEC
               IF SQLCODE = 0
                   PERFORM 3000-APPLY-LATE-FEE
               END-IF
           END-PERFORM
           EXEC SQL CLOSE OVERDUE-CUR END-EXEC.

DCLGEN (Declarations Generator) is a DB2 utility that reads a table's actual catalog definition and generates a matching COBOL copybook of host variable declarations, so the COBOL field lengths and data types are guaranteed to match the DB2 table schema exactly; regenerating and re-including this copybook after any DDL change is a standard maintenance practice.

Fetching a nullable DB2 column into a host variable without a paired indicator variable will typically result in SQLCODE -305 at runtime when the column actually contains NULL, since a COBOL PICTURE field has no native way to represent NULL. Every host variable mapped to a nullable column must have its own indicator variable checked after each FETCH.

  • Embedded SQL statements are delimited by EXEC SQL and END-EXEC and are translated by a DB2 precompiler before COBOL compilation.
  • Host variables, prefixed with a colon, let SQL statements read and write ordinary COBOL WORKING-STORAGE fields.
  • SQLCODE must be checked after every SQL statement: 0 means success, +100 means no rows found, negative values indicate errors.
  • Indicator variables are required to detect and represent NULL values in host variables, since COBOL fields cannot natively hold NULL.
  • Cursors bridge SQL's set-based results with COBOL's record-at-a-time processing via DECLARE, OPEN, FETCH, and CLOSE.
  • WHERE CURRENT OF CURSOR-NAME lets an UPDATE or DELETE modify exactly the most recently fetched row.
  • DCLGEN-generated copybooks keep COBOL host variable definitions synchronized with the actual DB2 table schema.

Practice what you learned

Was this page helpful?

Topics covered

#Programming#COBOLStudyNotes#COBOLAndDB2#COBOL#DB2#Embedded#SQL#StudyNotes#SkillVeris#ExamPrep