mutli-row fetch (oracle) [generating bad COBOL]

[GitMensch]

this issue is similar to #104 but procob targeted sources commonly work (DB2 not "in some places"), so I'd suggest this issue be tackled first and the other one later (but possibly keep its options in mind).

The following code does pass the preparser, but the resulting code isn't valid COBOL.

Given the table

       01 T02-FETCHTAB.
           05 T02-ID           PIC  X(018)              OCCURS 10.
           05 T02-STAMP        PIC  X(026)              OCCURS 10.

and the code

           EXEC SQL AT :CON
              DECLARE CSKEYTAB CURSOR FOR
                 SELECT TABID, STAMP FROM TAB
                 ORDER BY
                       USERID
                 ASC
           END-EXEC.

           EXEC SQL AT :CON
              OPEN CSKEYTAB 
           END-EXEC.
      *
           IF SQLCODE NOT = 0
              MOVE 'BAD SQLOPEN' TO ERROR-SQL
              PERFORM ERROR-SQL
           END-IF
      *
       DO-FETCH. 
      *
           INITIALIZE T02-FETCHTAB
           EXEC SQL AT :CON
               FETCH CSKEYTAB 
               INTO
                 :T02-ID,
                 :T02-STAMP
           END-EXEC.

      * SQLERRD(3) stores number of retrieved rows - with each fetch
      * it will be therefore incremented (if more data is there)
           IF SQLCODE NOT = 0
              MOVE 0 TO CUR-MAX
           ELSE
              MOVE FUNCTION MOD (SQLERRD(3), 10) INTO CUR-MAX
              IF CUR-MAX = 0    MOVE 10 TO CUR-MAX.

           PERFORM VARYING TAB-IDX FROM 1 BY 1 UNTIL TAB-IDX > CUR-MAX
              ....
           END-PERFORM
           IF CUR-MAX  = 10  GO TO DO-FETCH.
      
           EXEC SQL AT :CON
              CLOSE CSKEYTAB
           END-EXEC.

What currently happens is that the preprarser generates the reference "as it got", so the subscript is missing:

GIXSQL*    EXEC SQL AT :CON
GIXSQL*        FETCH CSKEYTAB
GIXSQL*        INTO
GIXSQL*          :T02-ID,
GIXSQL*          :T02-STAMP
GIXSQL*    END-EXEC.
GIXSQL     CALL "GIXSQLStartSQL"
GIXSQL     END-CALL
GIXSQL     CALL "GIXSQLSetResultParams" USING
GIXSQL         BY VALUE 16
GIXSQL         BY VALUE 18
GIXSQL         BY VALUE 0
GIXSQL         BY VALUE 0
GIXSQL         BY REFERENCE T02-ID
GIXSQL     END-CALL
GIXSQL     CALL "GIXSQLSetResultParams" USING
GIXSQL         BY VALUE 16
GIXSQL         BY VALUE 26
GIXSQL         BY VALUE 0
GIXSQL         BY VALUE 0
GIXSQL         BY REFERENCE T02-STAMP
GIXSQL     END-CALL
GIXSQL     CALL "GIXSQLCursorFetchOne" USING
GIXSQL         BY REFERENCE SQLCA
GIXSQL         BY REFERENCE "PROG_CSKEYTAB" & x"00"
GIXSQL     END-CALL
GIXSQL     CALL "GIXSQLEndSQL"
GIXSQL     END-CALL.

which, of course raises a compiler error on both BY REFERENCE

just for reference - this is what procob does:

      *    EXEC SQL AT :CON
      *        FETCH CSKEY13NG
      *        INTO
      *          :T02-ID,
      *          :T02-STAMP
      *    END-EXEC.
           MOVE 10 TO SQL-ITERS
           MOVE 2429 TO SQL-OFFSET
           MOVE 0 TO SQL-OCCURS
           MOVE 1 TO SQL-SELERR
           MOVE 0 TO SQL-SQPMEM
           CALL "SQLADR" USING
               SQLCUD
               SQL-CUD
           CALL "SQLADR" USING
               SQLCA
               SQL-SQLEST
           MOVE 4352 TO SQL-SQLETY
           MOVE 0 TO SQL-SQFOFF
           MOVE 2 TO SQL-SQFMOD
           CALL "SQLADR" USING
               T02-ID IN
               T02-FETCHTAB(1)
               SQL-SQHSTV(1)
           MOVE 18 TO SQL-SQHSTL(1)
           MOVE 18 TO SQL-SQHSTS(1)
           MOVE 0 TO SQL-SQINDV(1)
           MOVE 0 TO SQL-SQINDS(1)
           MOVE 0 TO SQL-SQHARM(1)
           CALL "SQLADR" USING
               T02-STAMP IN
               T02-FETCHTAB(1)
               SQL-SQHSTV(2)
           MOVE 26 TO SQL-SQHSTL(2)
           MOVE 26 TO SQL-SQHSTS(2)
           MOVE 0 TO SQL-SQINDV(2)
           MOVE 0 TO SQL-SQINDS(2)
           MOVE 0 TO SQL-SQHARM(2)
           CALL "SQLADR" USING
               CON
               SQL-SQHSTV(3)
           MOVE 10 TO SQL-SQHSTL(3)
           MOVE 10 TO SQL-SQHSTS(3)
           MOVE 0 TO SQL-SQINDV(3)
           MOVE 0 TO SQL-SQINDS(3)
           MOVE 0 TO SQL-SQHARM(3)
           CALL "SQLADR" USING
               SQL-SQHSTV(1)
               SQL-SQPHSV
           CALL "SQLADR" USING
               SQL-SQHSTL(1)
               SQL-SQPHSL
           CALL "SQLADR" USING
               SQL-SQHSTS(1)
               SQL-SQPHSS
           CALL "SQLADR" USING
               SQL-SQINDV(1)
               SQL-SQPIND
           CALL "SQLADR" USING
               SQL-SQINDS(1)
               SQL-SQPINS
           CALL "SQLADR" USING
               SQL-SQHARM(1)
               SQL-SQPARM
           CALL "SQLADR" USING
               SQL-SQHARC(1)
               SQL-SQPARC

           CALL "SQLBEX" USING
               SQLCTX
               SQLEXD
               SQLFPN
               .

some checking in the gixsql code showed that the preparser knows about the OCCURS attribute, but I have no clue if there's something in the runtime that could handle that.

[GitMensch]

Friendly ping as I plan to implement that (on the Oracle-side) "soon" and it would be nice to be able to use this with postgresql via GixSQL, too.