Aufruf einer SQL Stored Procedure in SQLRPGLE

**Witaseck** · 13-12-16, 14:38

Hallo zusammen,

beim Aufruf einer SQL Stored Procedure per
"exec SQL CALL WITAAXE0.SP$MUBHBST (:InpMit8)"
in einem RPG-Programm erhalte ich den Fehler "SQLCOD = -000000443".
Die Procedure liefert also aufgrund eines internen Fehlers kein Ergebnis.
Im SQL des iNavigator läuft (dies mit"
CALL WITAAXE0.Cusa_MuB_Hauptbetriebsstaette_TEST ('01040553') ;"
fehlerfrei.

Woran kann dies liegen und wie wird dies verhindert?

SQL Stored Procedure

Code:

create or replace procedure WITAAXE0.Cusa_MuB_Hauptbetriebsstaette_TEST (in AKZ# char(8))
 LANGUAGE SQL
 READS SQL DATA
 SPECIFIC SP$MUBHBST -- EINDEUTIGER 10stelliger Systemname

BEGIN declare #Hauptbetriebsstaette char(4) ;
 declare HBST# char(4) ;
 select right(AKZ_BST, 4) into #Hauptbetriebsstaette
  from enteview.VW_BETRIEBSSTAETTEN
  where AKZ_UNTERNEHMEN = AKZ# and BSTART_KNZ = 'HU' ;
 set HBST# = #Hauptbetriebsstaette ;
 
 if HBST# <> '0000' then
  return 1 ;
 else
  if HBST# is NULL then
   return -1 ;
  end if ;
  return 0 ;
 end if ;
END;

RPGLE

Code:

h DatFmt(*EUR)        
h TimFmt(*HMS:)       
h CvtOpt(*VARCHAR)    
h option(*NOdebugIO)

d InpMit          s             12
d HBST#           s              4a   inz('@@@@')             
d HBST#_NI        s              4b 0                
d InpMit8         s              8a   inz('12345678')
d InpMit8_NI      s              4b 0                
                                       
/free

InpMit8 = %subst(InpMit: 1: 8) ;                              
exec SQL CALL WITAAXE0.SP$MUBHBST (:InpMit8) ;            
                                                          
if SQLCOD = 0 ;                                           
   %subst(InpMit:9:4) = HBST# ;                           
else ;                                                    
   exsr srSQLerror ;                                      
endIF ;                                                  
         
/end-free

**Fuerchau** · 13-12-16, 14:51

1. Frage: Arbeitest du mit NAMING=*SQL? Ich sehe da keine SQL-Optionen.
2. Frage: Bist du sicher, dass der "Select ... into ..." auch genau nur 1 Satz liefert?

Außerdem musst du in SQL-Body-Prozeduren eine SQL-Fehlerbehandlung einbauen:
whenever blabla ....
Ansonsten wird eben eine Außnahme ausgelöst, die besagt, dass ein SQL-Fehler nicht überwacht wird.

Näheres steht bestimmt im Joblog, was denn die eigentliche Ursache in deiner Prozedur ist.

**Witaseck** · 13-12-16, 15:49

Vielen Dank für deine Hinweise.
Wir haben OS400 V7 R3 auf der Maschine.

1. das PGM wird mit dem Parameter SQLCURRULE *DB2 erstellt und der "iNavigator" arbeitet im Modus "SQL-Naming"
2. Es gibt nur einen Satz und die Procedure läuft im "iNavigator" ohne Probleme.

und hier noch der JOBLOG:

Zeiger für angegebene Position nicht gesetzt.
Anwendungsfehler. MCH3601 nicht überwacht durch SP$MUBHBST bei Anweisung
0000000009, Instruktion X'0000'.
Fehler von Auslöserprogramm oder externer Routine erkannt.

Zeile 9 entspricht: select right(AKZ_BST, 4) into #Hauptbetriebsstaette

**Fuerchau** · 13-12-16, 16:23

Ob die Anweisung 9 tatsächlich deiner SQL-Anweisung entspricht steht in den Sternen.
Zu beachten ist, dass eine SQL-Body-Prozedur in ein C-Programm umgesetzt wird und dieses erst kompiliert wird.
Was da nun als Zeile 9 tatsächlich generiert wurde kannst du nur einem Spool der C-Auflösung entnehmen. Wie man an diese kommt entzieht sich mir.
Irgendwann hatte ich mal die erstellte Quelle in der QTEMP versucht zu analysieren. Es ist einfach schrecklich, was der Compiler da so generiert.
Ich habe mich darauf beschränkt, ausschließlich externe SQL-Prozeduren/-Funktionen zu erstellen. Da hat man alles im Griff (incl. Debugger) und langsamer ist das auch nicht.
Zugegeben, man benötigt 2 Quellen, den SQL-CREATE als auch die externe Prozedur.

Der MCH3601 deutet da eher auf einen Übergabefehler beim Prozeduraufruf hin.
Mit deinem Select hat das nichts zu tun.

**Witaseck** · 14-12-16, 08:01

Also sieht alles nach einem DEBUG aus.

**andreaspr@aon.at** · 14-12-16, 08:09

Du kannst auch die SQL Prozedur ganz einfach Debuggen.
Ich würde dann empfehlen zwischen der *SOURCE und der *LISTING Ansicht zu wechseln um dann die entsprechenden Details zu erfahren.

lg Andreas

**Witaseck** · 14-12-16, 13:01

Der DBG der Procedure ergab den Grund für den Abbruch in "Zeile 9":

7 sqlcontrol = 0x00;
8 SQLP_IND = (short int *)argv[2];
9 CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST.SQLP_I1 = *(SQLP_IND+0);

in Zeile 8 wird SQLP_IND = SPP:*NULL gesetzt.

Stellt sich die Frage, warum ist argv[2] = *NULL?

Leider habe ich von C keine Ahnung, aber hier der C-Source des Precompilers:

Code:

       #define SQL_BLOB_INIT(s) {sizeof(s)-1, s }
       #define SQL_CLOB_INIT(s) {sizeof(s)-1, s }
       #define SQL_DBCLOB_INIT(s) {(sizeof(s)/2)-1,s}
       #define SQL_VARBINARY_INIT(s) {sizeof(s)-1, s}
       #define SQL_FILE_READ  2
       #define SQL_FILE_CREATE 8
       #define SQL_FILE_OVERWRITE 16
       #define SQL_FILE_APPEND 32
       #pragma linkage (QSQROUTE,OS)
       #pragma map (QSQROUTE,"QSYS/QSQROUTE")
       #pragma linkage (QSQLOPEN,OS)
       #pragma map (QSQLOPEN,"QSYS/QSQLOPEN")
       #pragma linkage (QSQLCLSE,OS)
       #pragma map (QSQLCLSE,"QSYS/QSQLCLSE")
       #pragma linkage (QSQLCMIT,OS)
       #pragma map (QSQLCMIT,"QSYS/QSQLCMIT")
       typedef _Packed struct QSQROUTE_COMM_AREA {
          unsigned char sql_eye_catcher[8];
                   short sql_stmt_num;
          unsigned char sql_sqlstate[5];
                   char sql_control;
                   long sql_sqlcode;
                   long sql_rows;
                   long sql_rel_pos1;
                   long sql_rel_pos2;
                   char sql_reserved[40];
          } QSQROUTE_COMM_AREA;
       #pragma datamodel(P128)
       void extern QSQROUTE(QSQROUTE_COMM_AREA *, ... );
       void extern QSQLOPEN(QSQROUTE_COMM_AREA *, ... );
       void extern QSQLCLSE(QSQROUTE_COMM_AREA *, ... );
       void extern QSQLCMIT(QSQROUTE_COMM_AREA *, ... );
       void extern SQL_Route3(QSQROUTE_COMM_AREA *, ... );
       #pragma datamodel(pop)
       #include "qsys/qasqh/stdlib"
       #include "qsys/qasqh/stdio"
       #include "qsys/qasqh/string"
       #include "qsys/qasqh/decimal"
       #include "qsys/qasqh/wcstr"
       #include "qsys/qasqh/wchar"
       #include "qsys/qasqh/stddef"
       #include "qsys/qasqh/trgbuf"
       #include "qsys/qasqh/pointer"
       #include "qsys/qasqh/micommon"
       #include "qsys/qasqh/cpyblap"
       #include "qsys/qasqh/sqlproc"
       #include "qsys/qasqh/cpybytes"
       #define cpybytes _CPYBYTES
       /***$$$
       EXEC SQL SET OPTION SQLMODE = *SQLPROC
       $$$***/
       /***$$$
       EXEC SQL BEGIN DECLARE SECTION
       $$$***/
       static long sqlcode_sav;
       static char sqlstate_sav[5];
       static struct SQLDLINK * SQLDLPTR;
       typedef _Packed struct SQLDLINK {
           short SQL_DL_LEN;
           char SQL_DL_VERS[5];
           char SQL_DL_TYPE[4];
           char SQL_DL_URLLEN[5];
           char pad8[8];
           char SQL_DL_URLCMMT[32718]; };
       static long SQLP_INT_VAR;
       static short SQLP_INT_VAR_IND;
       static void* NULLPTR = 0;
       static char sqlcontrol;
       #define SQLnlvl_1 0x80
       #define SQLnlvl_0 0x7F
       static unsigned short SQL_JobCCSID;
       static long long SQL_ROW_COUNT;
       static long SQL_RETURN_STATUS;
       static long SQL_RETURN_CODE;
       static long long SQL_ARRAY_INDEX;
       static long SQL_ARRAY_SOURCE;
       static short sqlp_len;
       typedef _Packed struct {
       long totalL;
       short itemIdent;
       /***$$$
       VARCHAR tokens[1025];
       $$$***/
        _Packed struct { short len;
                char data[1025];}
       tokens;
        } SQLMsgT;
       static SQLMsgT SQLMsg;
       static short SQLmsgL;
       static char SQLmsgTxt[1025];
       void SQLSetDiagError(long,char*,SQLMsgT*);
       void SQLGetDiagValue(long, void*);
       typedef struct {
       char SQLP_AKZ_PD[8];
       short SQLP_I1;
       } CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST_T;
       typedef struct {
       long SQLP_OUTPUT;
       short SQLP_I2;
       } SQL_RETURN_T;
       /***$$$
       EXEC SQL END DECLARE SECTION
       $$$***/
       /*----------------------------------*/
       static int SQLPROCH(char *);
       /***$$$
       EXEC SQL BEGIN DECLARE SECTION
       $$$***/
       typedef struct {
       char SQLP_PD_HAUPTBETRIEBSSTAETTE[4];
       short SQLP_I3;
       char SQLP_PD_HAUPTBETRIEBSSTAETTE30[30];
       short SQLP_I4;
       decimal(31,0) SQLP_PD_ZEILENZAEHLER;
       short SQLP_I5;
       char HBST[4];
       short SQLP_I6;
         } SP_T;
       static int SQLPROC1(long *, char *, CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST_T *, SQL_RETURN_T *, SP_T Ö
       *);
       int main(int argc, char * argv[]) {
       short * SQLP_IND;
     1 short SQLP_IND0 = 0;
       long SQLCODE;
       char SQLSTATE[5];
       CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST_T CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST;
       CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST_T * CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST_x;
       SQL_RETURN_T SQL_RETURN;
       SQL_RETURN_T * SQL_RETURN_x;
       SP_T SP;
       SP_T * SP_x;
     2 long SQLP_RC1 = 0;
     3 long SQLP_RC2 = 0;
       /***$$$
       EXEC SQL END DECLARE SECTION
       $$$***/
     4 SQLCODE = 0;
     5 memset(SQLSTATE, '0', 5);
     6 SQL_JobCCSID = SQLRetrieveJobCCSID();
     7 sqlcontrol = 0x00;
     8 SQLP_IND = (short int *)argv[2];
     9 CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST.SQLP_I1 = *(SQLP_IND+0);
    10 if (CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST.SQLP_I1 >= 0)
    11 cpybytes(CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST.SQLP_AKZ_PD, argv[1], 8);
    12 SQL_RETURN.SQLP_I2 = SQLP_NULLIND;
       SP:
    13 SP.SQLP_I3 = SQLP_NULLIND;
    14 SP.SQLP_I4 = SQLP_NULLIND;
    15 SP.SQLP_I5 = SQLP_NULLIND;
    16 SP.SQLP_PD_ZEILENZAEHLER = 0;
    17 SP.SQLP_I6 = SQLP_NULLIND;
       /***$$$
       EXEC SQL SELECT AKZ_BST INTO  :SP.SQLP_PD_HAUPTBETRIEBSSTAETTE30 :SP.SQLP_I4 FROM ENTEVIEW . VW_BÖ
       ETRIEBSSTAETTEN WHERE AKZ_UNTERNEHMEN = '01040553'
       AND BSTART_KNZ = 'HU'
       $$$***/
       {
       #pragma datamodel(P128)
       struct QSQROUTE_COMM_AREA
    18 qsqroute_comm_area = {"QSQNOTCA", -9, "00000", '\0'};
       static _Packed struct {
                short SQL_HEADER_LENGTH;
                short SQL_STMT_NUM;
                long SQL_INVOKE;
                char SQL_RESERVED[120];
       } SQL_STRUCT = {128,    7,0};
         _Packed struct {
                char SQL_DATA_RETURNED;
                char SQL_RESERVED[15];
              char SQL_VAR_1[30];
              short SQL_VAR_3[1];
       } SQL_STRUCT_HV;
    22 qsqroute_comm_area.sql_control=sqlcontrol;
         SQL_Route3 ((QSQROUTE_COMM_AREA * )&qsqroute_comm_area,
    23             &SQL_STRUCT,&SQL_STRUCT_HV);
    24   if (SQL_STRUCT_HV.SQL_DATA_RETURNED == '1')
           {
    25        cpybytes(SP.SQLP_PD_HAUPTBETRIEBSSTAETTE30,SQL_STRUCT_HV.SQL_VAR_1,30);
    26        SP.SQLP_I4 = SQL_STRUCT_HV.SQL_VAR_3[0];
           }
    27   SQLCODE=qsqroute_comm_area.sql_sqlcode;
    28   cpybytes(SQLSTATE,qsqroute_comm_area.sql_sqlstate,5);
       #pragma datamodel(pop)
       }
    29 if (memcmp(SQLSTATE,"00000",5) != 0)
       {
    30 if (SQLPROCH(SQLSTATE) == 1) {
    31   goto SQL_END_CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST;
       }
       }
    32 SQLP_RC1 = 9999;
       if (SQLP_RC1 == 9999 && ((SQLP_RC1 = SQLPROC1(&SQLCODE, SQLSTATE, &CUSA_MUB_HAUPTBETRIEBSSTAETTE_Ö
       TEST, &SQL_RETURN, &SP)) == 0)
    33 ) {
    34 SQLDiagInit();
    35 memset(SQLSTATE, '0', 5);
    36 SQLCODE = 0;
    37 SQL_RETURN.SQLP_OUTPUT = 1;
    38 SQL_RETURN.SQLP_I2 = 0;
    39 SQLDiagInit();
    40 goto SQL_END_CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST;
         }
    41  else if (SQLP_RC1 == 9999)  {
    42 SQLDiagInit();
    43 memset(SQLSTATE, '0', 5);
    44 SQLCODE = 0;
    45 SQLP_RC2 = 9999;
    46 if (SQLP_RC2 == 9999 && (SP.SQLP_I6 < 0) ) {
    47 SQLDiagInit();
    48 memset(SQLSTATE, '0', 5);
    49 SQLCODE = 0;
    50 SQL_RETURN.SQLP_OUTPUT = -1;
    51 SQL_RETURN.SQLP_I2 = 0;
    52 SQLDiagInit();
    53 goto SQL_END_CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST;
         }
    54 SQL_RETURN.SQLP_OUTPUT = 0;
    55 SQL_RETURN.SQLP_I2 = 0;
    56 SQLDiagInit();
    57 goto SQL_END_CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST;
         }
    58 if (SQLPROCH(SQLSTATE) == 1) {
    59   goto SQL_END_CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST;
       }
    60 SQL_END_SP: ;
       SQL_END_CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST:
    61   ;
    62 if (SQL_RETURN.SQLP_I2 < 0)
           {
    63     if (SQLCODE >= 0)
    64         SQL_RETURN.SQLP_OUTPUT = 0;
           else
    65         SQL_RETURN.SQLP_OUTPUT = -1;
           }
    66 return SQL_RETURN.SQLP_OUTPUT; }
       /*----------------------------------*/
       static int SQLPROCH(char SQLSTATE[5]) {
           if (memcmp(SQLSTATE, "00", 2) != 0 &&
               memcmp(SQLSTATE, "01", 2) != 0 &&
     1         memcmp(SQLSTATE, "02", 2) != 0)
     2         return 1;
     3     return 0;  }
       /*----------------------------------*/
       /*-----------------*/
       static int SQLPROC1(long *SQLCODEp, char SQLSTATE[5], CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST_T * CUSAÖ
       _MUB_HAUPTBETRIEBSSTAETTE_TEST_TEMP, SQL_RETURN_T
       * SQL_RETURN_TEMP, SP_T * SP_TEMP) {
       long SQLCODE;
     1 long SQLP_RC1 = 0;
       CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST_T * CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST_x;
       SQL_RETURN_T * SQL_RETURN_x;
       SP_T * SP_x;
     2 CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST_x = CUSA_MUB_HAUPTBETRIEBSSTAETTE_TEST_TEMP;
     3 SQL_RETURN_x = SQL_RETURN_TEMP;
     4 SP_x = SP_TEMP;
     5 SQLCODE = *SQLCODEp;
       if (SQL_JobCCSID == 273 ||
     6     SQL_JobCCSID == 65535 ) {
     7  if ((*SP_x).SQLP_I6 < 0 )
     8     SQLP_INT_VAR = 9999;
     9  else if (memcmp((*SP_x).HBST,"0000",4) != 0)
    10     SQLP_INT_VAR = 0;
    11  else SQLP_INT_VAR = 9999;
    12 SQLDiagInit();
    13 memset(SQLSTATE, '0', 5);
    14 *SQLCODEp = 0;
    15 return SQLP_INT_VAR; }
       /***$$$
       EXEC SQL VALUES ( CASE WHEN  :*SP_x.HBST :*SP_x.SQLP_I6 <> '0000'  THEN 0 ELSE 9999 END ) INTO :SÖ
       QLP_INT_VAR :SQLP_INT_VAR_IND
       $$$***/
       {
       #pragma datamodel(P128)
       struct QSQROUTE_COMM_AREA
    16 qsqroute_comm_area = {"QSQNOTCA", -9, "00000", '\0'};
       static _Packed struct {
                short SQL_HEADER_LENGTH;
                short SQL_STMT_NUM;
                long SQL_INVOKE;
                char SQL_RESERVED[120];
       } SQL_STRUCT = {128,    8,0};
         _Packed struct {
                char SQL_DATA_RETURNED;
                char SQL_RESERVED[15];
              char SQL_VAR_1[4];
              long SQL_VAR_3;
              short SQL_VAR_5[2];
       } SQL_STRUCT_HV;
    20 qsqroute_comm_area.sql_control=sqlcontrol;
    21   cpybytes(SQL_STRUCT_HV.SQL_VAR_1,(*SP_x).HBST,4);
    22   SQL_STRUCT_HV.SQL_VAR_5[0]=(*SP_x).SQLP_I6;
         SQL_Route3 ((QSQROUTE_COMM_AREA * )&qsqroute_comm_area,
    23             &SQL_STRUCT,&SQL_STRUCT_HV);
    24   if (SQL_STRUCT_HV.SQL_DATA_RETURNED == '1')
           {
    25        SQLP_INT_VAR = SQL_STRUCT_HV.SQL_VAR_3;
    26        SQLP_INT_VAR_IND = SQL_STRUCT_HV.SQL_VAR_5[1];
           }
    27   SQLCODE=qsqroute_comm_area.sql_sqlcode;
    28   cpybytes(SQLSTATE,qsqroute_comm_area.sql_sqlstate,5);
       #pragma datamodel(pop)
       }
    29 sqlcode_sav = SQLCODE;
    30 if (memcmp(SQLSTATE,"00000",5) != 0)
       {
    31 if (SQLPROCH(SQLSTATE) == 1) {
    32 *SQLCODEp = SQLCODE;
    33   return -1;
       }
       }
    34 if (sqlcode_sav >= 0) {
    35   SQLDiagInit();
    36 *SQLCODEp = 0;
    37 return SQLP_INT_VAR; }
    38  else return -2;
       }

**Fuerchau** · 14-12-16, 13:18

Ich kann nur vermuten, dass du beim CREATE PROCEDURE die Aufrufart (Parameter Style) nicht einfach weglassen kannst. Per Default wird nämlich nur der Eingangsparameter übergeben.
Bei PARAMETER STYLE SQL gibt es zusätzliche NULL-Indicators und der Init deutet darauf hin, dass der erst mal auf NOT NULL initialisiert wird.
Erstelle die Prozedur noch mal mit PARAMETER STYLE SQL.
Warum der iSeries-Navigator da nicht auf die Nase fällt weiß ich nicht.
Ggf. macht aber der ODBC-Job hier eine Überwachung und ignoriert diesen Fehler einfach.

**Witaseck** · 14-12-16, 14:13

parameter style SQL gilt leider nicht für "SQL Proceduren = LANGUAGE SQL".

Vielleicht hat IBM in V7R3 hier ein Problem beim Compilieren für den CALL von SQL-Proceduren?

**Fuerchau** · 14-12-16, 14:20

Eher beim Registrieren, denn die Art des Aufrufes wird entweder im Objekt selber (SQLPKG) oder in den SYSPROC/PARMS/XXX abgelegt.
Dann musst du wohl mal einen Fehler bei IBM aufmachen.
Du kannst auch mal den OpsNav-QZDASOINIT-Job prüfen, ob der Fehler da nicht doch auch passiert nur abgefangen wird.

Aber wie gesagt, ich lasse die Finger von den SQL-Body-Prozeduren und mach hier lieber alles selber.
Auch D*B hat da schon so seine schlechten Erfahrungen.

**BenderD** · 14-12-16, 14:48

... ich verstehe zwar warum argv[2] NULL ist (wo nur ein Parameter ist, kann nur einer nicht Null sein), ich verstehe aber nicht, warum das RPG compilierbar sein soll - ich finde nämlich keine Deklaration von InpMit?!

=> InpMit8 = %subst(InpMit: 1: 8) ;

D*B

**Witaseck** · 14-12-16, 15:07

InpMit8 ist der Übergabeparameter aus dem SQLRPGLE an die SQL-Procedure.

Der obige C-Code ist der "Precompilercode" der SQL-Procedure, welche beim Debugen der Procedure (nach Aufruf im ebenfalls gedebuggten SQLRPGLE-Programme) angezeigt wird.

Zuletzt erzeugt per "Green Screen" mit:
RUNSQLSTM SRCFILE(WITAAXE0/QSQLSRC) SRCMBR(SP_DEMO) COMMIT(*NONE) NAMING(*
SQL) MARGINS(100) DBGVIEW(*SOURCE)

Thema: Aufruf einer SQL Stored Procedure in SQLRPGLE

Thread Tools

Bewerten Sie diesen Thema

Display