LCOV - differential code coverage report
Current view: top level - src/interfaces/ecpg/test/compat_informix - sqlda.pgc (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage HEAD vs 15 Lines: 98.6 % 146 144 2 144
Current Date: 2023-04-08 17:13:01 Functions: 100.0 % 2 2 2
Baseline: 15 Line coverage date bins:
Baseline Date: 2023-04-08 15:09:40 (240..) days: 98.6 % 146 144 2 144
Legend: Lines: hit not hit Function coverage date bins:
(240..) days: 100.0 % 2 2 2

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

Generated by: LCOV version v1.16-55-g56c0a2a