LCOV - code coverage report
Current view: top level - src/interfaces/ecpg/test/compat_informix - sqlda.pgc (source / functions) Coverage Total Hit
Test: Code coverage Lines: 0.0 % 152 0
Test Date: 2026-01-26 10:56:24 Functions: 0.0 % 2 0
Legend: Lines:     hit not hit

            Line data    Source code
       1              : #include <stdlib.h>
       2              : #include <string.h>
       3              : #include <limits.h>
       4              : 
       5              : exec sql include ../regression;
       6              : 
       7              : exec sql include sqlda.h;
       8              : exec sql include sqltypes.h;
       9              : 
      10              : exec sql whenever sqlerror stop;
      11              : 
      12              : /* These shouldn't be under DECLARE SECTION */
      13              : sqlda_t *inp_sqlda, *outp_sqlda;
      14              : 
      15              : static void
      16            0 : dump_sqlda(sqlda_t *sqlda)
      17              : {
      18            0 :         int     i;
      19              : 
      20            0 :         if (sqlda == NULL)
      21              :         {
      22            0 :                 printf("dump_sqlda called with NULL sqlda\n");
      23            0 :                 return;
      24              :         }
      25              : 
      26            0 :         for (i = 0; i < sqlda->sqld; i++)
      27              :         {
      28            0 :                 if (sqlda->sqlvar[i].sqlind && *(sqlda->sqlvar[i].sqlind) == -1)
      29            0 :                         printf("name sqlda descriptor: '%s' value NULL'\n", sqlda->sqlvar[i].sqlname);
      30              :                 else
      31            0 :                 switch (sqlda->sqlvar[i].sqltype)
      32              :                 {
      33              :                 case SQLCHAR:
      34            0 :                         printf("name sqlda descriptor: '%s' value '%s'\n", sqlda->sqlvar[i].sqlname, sqlda->sqlvar[i].sqldata);
      35            0 :                         break;
      36              :                 case SQLINT:
      37            0 :                         printf("name sqlda descriptor: '%s' value %d\n", sqlda->sqlvar[i].sqlname, *(int *)sqlda->sqlvar[i].sqldata);
      38            0 :                         break;
      39              :                 case SQLFLOAT:
      40            0 :                         printf("name sqlda descriptor: '%s' value %f\n", sqlda->sqlvar[i].sqlname, *(double *)sqlda->sqlvar[i].sqldata);
      41            0 :                         break;
      42              :                 case SQLDECIMAL:
      43              :                         {
      44            0 :                                 char    val[64];
      45            0 :                                 dectoasc((dec_t *)sqlda->sqlvar[i].sqldata, val, 64, -1);
      46            0 :                                 printf("name sqlda descriptor: '%s' value DECIMAL '%s'\n", sqlda->sqlvar[i].sqlname, val);
      47              :                                 break;
      48            0 :                         }
      49              :                 }
      50            0 :         }
      51            0 : }
      52              : 
      53              : int
      54            0 : main (void)
      55              : {
      56              : exec sql begin declare section;
      57            0 :         char    *stmt1 = "SELECT * FROM t1";
      58            0 :         char    *stmt2 = "SELECT * FROM t1 WHERE id = ?";
      59            0 :         int     rec;
      60            0 :         int     id;
      61              : exec sql end declare section;
      62              : 
      63            0 :         char msg[128];
      64              : 
      65            0 :         ECPGdebug(1, stderr);
      66              : 
      67            0 :         strcpy(msg, "connect");
      68            0 :         exec sql connect to REGRESSDB1 as regress1;
      69            0 : 
      70            0 :         strcpy(msg, "set");
      71            0 :         exec sql set datestyle to iso;
      72            0 : 
      73            0 :         strcpy(msg, "create");
      74            0 :         exec sql create table t1(
      75              :                 id integer,
      76              :                 t text,
      77              :                 d1 numeric,
      78              :                 d2 float8,
      79              :                 c char(10));
      80            0 : 
      81            0 :         strcpy(msg, "insert");
      82            0 :         exec sql insert into t1 values
      83              :                 (1, 'a', 1.0, 1, 'a'),
      84              :                 (2, null, null, null, null),
      85              :                 (4, 'd', 4.0, 4, 'd');
      86            0 : 
      87            0 :         strcpy(msg, "commit");
      88            0 :         exec sql commit;
      89            0 : 
      90              :         /* SQLDA test for getting all records from a table */
      91              : 
      92            0 :         outp_sqlda = NULL;
      93              : 
      94            0 :         strcpy(msg, "prepare");
      95            0 :         exec sql prepare st_id1 from :stmt1;
      96            0 : 
      97            0 :         strcpy(msg, "declare");
      98              :         exec sql declare mycur1 cursor for st_id1;
      99              : 
     100            0 :         strcpy(msg, "open");
     101            0 :         exec sql open mycur1;
     102            0 : 
     103              :         exec sql whenever not found do break;
     104              : 
     105            0 :         rec = 0;
     106            0 :         while (1)
     107              :         {
     108            0 :                 strcpy(msg, "fetch");
     109            0 :                 exec sql fetch 1 from mycur1 into descriptor outp_sqlda;
     110            0 : 
     111            0 :                 printf("FETCH RECORD %d\n", ++rec);
     112            0 :                 dump_sqlda(outp_sqlda);
     113              :         }
     114              : 
     115              :         exec sql whenever not found continue;
     116              : 
     117            0 :         strcpy(msg, "close");
     118            0 :         exec sql close mycur1;
     119            0 : 
     120            0 :         strcpy(msg, "deallocate");
     121            0 :         exec sql deallocate prepare st_id1;
     122            0 : 
     123            0 :         free(outp_sqlda);
     124              : 
     125              :         /* SQLDA test for getting all records from a table
     126              :            using the Informix-specific FETCH ... USING DESCRIPTOR
     127              :          */
     128              : 
     129            0 :         outp_sqlda = NULL;
     130              : 
     131            0 :         strcpy(msg, "prepare");
     132            0 :         exec sql prepare st_id2 from :stmt1;
     133            0 : 
     134            0 :         strcpy(msg, "declare");
     135              :         exec sql declare mycur2 cursor for st_id2;
     136              : 
     137            0 :         strcpy(msg, "open");
     138            0 :         exec sql open mycur2;
     139            0 : 
     140              :         exec sql whenever not found do break;
     141              : 
     142            0 :         rec = 0;
     143            0 :         while (1)
     144              :         {
     145            0 :                 strcpy(msg, "fetch");
     146            0 :                 exec sql fetch from mycur2 using descriptor outp_sqlda;
     147            0 : 
     148            0 :                 printf("FETCH RECORD %d\n", ++rec);
     149            0 :                 dump_sqlda(outp_sqlda);
     150              :         }
     151              : 
     152              :         exec sql whenever not found continue;
     153              : 
     154            0 :         strcpy(msg, "close");
     155            0 :         exec sql close mycur2;
     156            0 : 
     157            0 :         strcpy(msg, "deallocate");
     158            0 :         exec sql deallocate prepare st_id2;
     159            0 : 
     160            0 :         free(outp_sqlda);
     161              : 
     162              :         /* SQLDA test for getting one record using an input descriptor */
     163              : 
     164              :         /* Input sqlda has to be built manually */
     165            0 :         inp_sqlda = (sqlda_t *)malloc(sizeof(sqlda_t));
     166            0 :         memset(inp_sqlda, 0, sizeof(sqlda_t));
     167            0 :         inp_sqlda->sqld = 1;
     168            0 :         inp_sqlda->sqlvar = malloc(sizeof(sqlvar_t));
     169            0 :         memset(inp_sqlda->sqlvar, 0, sizeof(sqlvar_t));
     170              : 
     171            0 :         inp_sqlda->sqlvar[0].sqltype = SQLINT;
     172            0 :         inp_sqlda->sqlvar[0].sqldata = (char *)&id;
     173              : 
     174            0 :         printf("EXECUTE RECORD 4\n");
     175              : 
     176            0 :         id = 4;
     177              : 
     178            0 :         outp_sqlda = NULL;
     179              : 
     180            0 :         strcpy(msg, "prepare");
     181            0 :         exec sql prepare st_id3 FROM :stmt2;
     182            0 : 
     183            0 :         strcpy(msg, "execute");
     184            0 :         exec sql execute st_id3 using descriptor inp_sqlda into descriptor outp_sqlda;
     185            0 : 
     186            0 :         dump_sqlda(outp_sqlda);
     187              : 
     188            0 :         strcpy(msg, "deallocate");
     189            0 :         exec sql deallocate prepare st_id3;
     190            0 : 
     191            0 :         free(inp_sqlda->sqlvar);
     192            0 :         free(inp_sqlda);
     193            0 :         free(outp_sqlda);
     194              : 
     195              :         /* SQLDA test for getting one record using an input descriptor
     196              :          * on a named connection
     197              :          */
     198              : 
     199            0 :         exec sql connect to REGRESSDB1 as con2;
     200            0 : 
     201              :         /* Input sqlda has to be built manually */
     202            0 :         inp_sqlda = (sqlda_t *)malloc(sizeof(sqlda_t));
     203            0 :         memset(inp_sqlda, 0, sizeof(sqlda_t));
     204            0 :         inp_sqlda->sqld = 1;
     205            0 :         inp_sqlda->sqlvar = malloc(sizeof(sqlvar_t));
     206            0 :         memset(inp_sqlda->sqlvar, 0, sizeof(sqlvar_t));
     207              : 
     208            0 :         inp_sqlda->sqlvar[0].sqltype = SQLINT;
     209            0 :         inp_sqlda->sqlvar[0].sqldata = (char *)&id;
     210              : 
     211            0 :         printf("EXECUTE RECORD 4\n");
     212              : 
     213            0 :         id = 4;
     214              : 
     215            0 :         outp_sqlda = NULL;
     216              : 
     217            0 :         strcpy(msg, "prepare");
     218            0 :         exec sql at con2 prepare st_id4 FROM :stmt2;
     219            0 : 
     220            0 :         strcpy(msg, "execute");
     221            0 :         exec sql at con2 execute st_id4 using descriptor inp_sqlda into descriptor outp_sqlda;
     222            0 : 
     223            0 :         dump_sqlda(outp_sqlda);
     224              : 
     225            0 :         strcpy(msg, "commit");
     226            0 :         exec sql at con2 commit;
     227            0 : 
     228            0 :         strcpy(msg, "deallocate");
     229            0 :         exec sql deallocate prepare st_id4;
     230            0 : 
     231            0 :         free(inp_sqlda->sqlvar);
     232            0 :         free(inp_sqlda);
     233            0 :         free(outp_sqlda);
     234              : 
     235            0 :         strcpy(msg, "disconnect");
     236            0 :         exec sql disconnect con2;
     237            0 : 
     238              :         /* End test */
     239              : 
     240            0 :         strcpy(msg, "drop");
     241            0 :         exec sql drop table t1;
     242            0 : 
     243            0 :         strcpy(msg, "commit");
     244            0 :         exec sql commit;
     245            0 : 
     246            0 :         strcpy(msg, "disconnect");
     247            0 :         exec sql disconnect;
     248            0 : 
     249            0 :         return 0;
     250            0 : }
        

Generated by: LCOV version 2.3.2-1