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 16@8cea358b128 vs 17@8cea358b128 Lines: 98.6 % 146 144 2 144
Current Date: 2024-04-14 14:21:10 Functions: 100.0 % 2 2 2
Baseline: 16@8cea358b128 Branches: 57.7 % 71 41 30 41
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed (240..) days: 98.6 % 146 144 2 144
Function coverage date bins:
(240..) days: 100.0 % 2 2 2
Branch coverage date bins:
(240..) days: 57.7 % 71 41 30 41

 Age         Owner                    Branch data    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
 5213 meskes@postgresql.or       16                 :CBC           8 : dump_sqlda(sqlda_t *sqlda)
                                 17                 :                : {
                                 18                 :                :     int i;
                                 19                 :                : 
                                 20         [ -  + ]:              8 :     if (sqlda == NULL)
                                 21                 :                :     {
 5213 meskes@postgresql.or       22                 :UBC           0 :         printf("dump_sqlda called with NULL sqlda\n");
                                 23                 :              0 :         return;
                                 24                 :                :     }
                                 25                 :                : 
 5213 meskes@postgresql.or       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:
 2156 tgl@sss.pgh.pa.us          40                 :              6 :             printf("name sqlda descriptor: '%s' value %f\n", sqlda->sqlvar[i].sqlname, *(double *)sqlda->sqlvar[i].sqldata);
 5213 meskes@postgresql.or       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");
 4891 peter_e@gmx.net           109                 :              4 :         exec sql fetch 1 from mycur1 into descriptor outp_sqlda;
 5213 meskes@postgresql.or      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 : 
 2432 peter_e@gmx.net           249                 :              1 :     return 0;
                                250                 :                : }
        

Generated by: LCOV version 2.1-beta2-3-g6141622