You pick your frame of reference and you pays your money, as they say!
Which way should we all be going these days? The good old precompiler, since the beginning of time, or the modern sleek coprocessor? This month, I will show you what they both do, what they do the same, what they do differently, and the pros and cons of both!
COBOL For All!
Yep, this newsletter is *just* about COBOL. Sorry if you use JAVA, Ruby, Python, or CosyPinkTeabags I stick with a language that works on computers so big you cannot lift ‘em!
In the Beginning…
Many, many moons ago, the great precompiler was launched. The problem was that Structured Query Language (SQL) is not COBOL in any way shape or form, but companies needed a way to integrate SQL code into COBOL code. The mainframe world had had this problem before with CICS, where the elegant solution was a CICS translator that ran through the code, removed all the special CICS calls, and replaced them with correctly formed COBOL calls. All done under the covers so that the application programmer did not have to know, or do, anything. CICS also now supports the integrated CICS translator by the way.
SQL was More Complicated
Naturally, the abilities in SQL caused some headaches… The syntax checking required the use of TABLE DECLARES (Still optional to this day, which I find astonishing!) To generate executable code the system had to do two things:
- Replace the EXEC SQL with comments and then calls to Assembler routines with parameters that listed out the SQL statement to be executed and all of the host variables involved. It also created a CONTOKEN or Consistency token that Db2 uses to check that any given load module “fits” to the given Package (DBRM) at run time.
- Output a DBRM, also with the CONTOKEN within it, so that then the PACKAGE/PLAN could be bound into an executable object. Every statement in the package matched the COBOL assembler calls one to one. At execution time, if the CONTOKEN in the package did not match the CONTOKEN in the load module, you would get a nasty error, typically an SQLCODE -805 with one of five sub-types, as something is wrong somewhere!
The Problem?
At the point where the precompiler was run, *no* COBOL had been compiled so any use of COPY books caused syntax errors – here the EXEC SQL INCLUDE jumped in to help *but* for, some unknown reason, they did not implement a REPLACING syntax like COPY has… This meant that the INCLUDEd code was not 100% the same as your “normal” COPY book – Very annoying!
Coprocess This!
This situation caused problems, and after a few years IBM launched the coprocessor which is basically the IBM COBOL compiler with the precompiler bolted within. This gave two immediate benefits:
- Simpler JCL (No precompiler step anymore!)
- Simpler COBOL copy book management as the COPY syntax worked fine!
So Why are We Not *All* Using the Coprocessor Today?
Well, as always, the devil is in the detail. The one major stopper I have seen is Db2 columns defined as “FOR BIT DATA”. Now, in the normal COBOL world, this just means “no code page conversion please.” The data is quite probably hexadecimal and will be completely mangled if it gets a code page conversion! What you actually get depends on what you are doing but it is quite easy to get an SQLCODE -333.
Unicode – EBCDIC – ASCII
The triumvirate of pain! If I had a dollar for every file transfer I have received that was originally EBCDIC and got ASCII transferred… but I digress!
There is a Fix!
There are two solutions here:
- Use a DECLARE VARIABLE in the code to “inform” the Compiler *not* to do a code page conversion when this COBOL host variable is being processed. This is naturally more work for the programmer and “dangerous” too, as it is another “point of failure” that never existed before! This scares people – we all hate change after all.
- Use NOSQLCCSID in the COBOL coprocessor parameters. This is recommended as the easiest way to stay plug compatible with the precompiler. Naturally, at some point, it will be time to bite the bullet and do the code change required!
The DECLARE you might need looks like this:
exec sql declare :PACKAGE-CONTOKEN variable for bit data end-exec
The problem is normally caused by INSERT and UPDATE processing. Just SELECT appears to always work fine in my tests, (I created an EBCDIC table and a UNICODE table and then did multiple Inserts and Selects with hex data). However, your data constellation might well be different from mine – Always test first!
Bottom Line
If you are not using FOR BIT DATA you have no problem!
Here’s a little SQL to show you where you have any columns with FOR BIT DATA in your system:
SELECT SUBSTR(STRIP(TBCREATOR) CONCAT '.' CONCAT STRIP(TBNAME) , 1 , 32) AS TABLE_NAME , NAME AS COL_NAME FROM SYSIBM.SYSCOLUMNS WHERE FOREIGNKEY = 'B' ORDER BY 1 , 2 FOR FETCH ONLY WITH UR ;
JCL Changes Required
To get the Coprocessor up and running I just added these two lines into my SYSOPTF for COBOL 6.3:
,CODEPAGE(1141),NOSQLCCSID
,SQL("APOSTSQL ATTACH(CAF) COMMA DATE(ISO) TIME(ISO)")Notice the NOSQLCCSID so I do not have to do any code changes!
Naturally, the STEPLIB must be enhanced:
//STEPLIB DD DISP=SHR,DSN=IGY630.SIGYCOMP // DD DISP=SHR,DSN=DSND1A.SDSNEXIT.DD10 // DD DISP=SHR,DSN=DSND1A.SDSNLOAD
And there are two new DD cards:
//DBRMLIB DD DISP=SHR,DSN=SE.MDB2VNEX.TDBRM(COCOMP) //SYSTERM DD SYSOUT=*
That’s It!
All in all, I think if you are still using the precompiler you should take some time to migrate over to the coprocessor as it makes the modules much smaller and, by default, faster!
Faster? I Hear you Shout
Well, what the coprocessor also does, is completely remove all SQL based working storage and, most importantly, the PERFORM on the 1st call of the SQL-INITIAL section. Now the precompiler is clever but it is not Einstein! When the very first SQL gets called, this section is performed which defines in memory *all* the SQL in the program. So, let’s say you have a program with 1,000 SQLs. You are only using one of them, but for that one call all 1,000 working storage areas will be initialized through DSNHADDR and DSNHADD2 calls using the PLIST blocks. It is fast I know, but it is also just overhead!
Another Bonus!
Plus, if your COBOL is passing host variables through linkage section usage and the address changes between calls then you *must* currently reset the SQL-INIT-FLAG to zero *every* time… With the coprocessor you do not have to do that anymore – Another win!
Just the Facts Ma’am
In one of my test programs the precompiler generated:
1674 lines of working storage
232 lines of SQL-INITIAL code
For every EXEC SQL (31 in total) that was commented out a
PERFORM SQL-INITIAL UNTIL SQL-INIT-DONE CALL 'DSNHLI2' USING SQL-PLIST11 END-CALL
Block was written.
The coprocessor generated nothing! and the executable load module was 8% smaller!
Pros and Cons
Pros of precompiler are: No need to DECLARE for bit data columns and no JCL change.
Cons of precompiler are: No real COPY book support, larger code and bigger module size.
Pros of coprocessor are: No reset of SQL-INIT-FLAG, Perfect COPY book support, no generated code, smaller module size, faster run time execution and load.
Cons of coprocessor are: JCL change required and possible DECLARE VARIABLEs needed depending on usage.
What are your experiences with the precompiler and/or the coprocessor?
I would love to hear from you!
TTFN,
Roy Boxwell