LCOV - differential code coverage report
Current view: top level - src/interfaces/ecpg/test/sql - sqlda.pgc (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 96.1 % 152 146 6 146
Current Date: 2024-04-14 14:21:10 Functions: 100.0 % 2 2 2
Baseline: 16@8cea358b128 Branches: 57.5 % 73 42 31 42
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: 96.1 % 152 146 6 146
Function coverage date bins:
(240..) days: 100.0 % 2 2 2
Branch coverage date bins:
(240..) days: 57.5 % 73 42 31 42

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : #include <stdlib.h>
                                  2                 :                : #include <string.h>
                                  3                 :                : #include <limits.h>
                                  4                 :                : #include "ecpg_config.h"
                                  5                 :                : 
                                  6                 :                : exec sql include ../regression;
                                  7                 :                : exec sql include sqlda.h;
                                  8                 :                : exec sql include pgtypes_numeric.h;
                                  9                 :                : 
                                 10                 :                : exec sql whenever sqlerror stop;
                                 11                 :                : 
                                 12                 :                : /* These shouldn't be under DECLARE SECTION */
                                 13                 :                : sqlda_t *inp_sqlda, *outp_sqlda, *outp_sqlda1;
                                 14                 :                : 
                                 15                 :                : static void
 5213 meskes@postgresql.or       16                 :CBC          12 : dump_sqlda(sqlda_t *sqlda)
                                 17                 :                : {
                                 18                 :                :     int i;
                                 19                 :                : 
                                 20         [ -  + ]:             12 :     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          84 :     for (i = 0; i < sqlda->sqld; i++)
                                 27                 :                :     {
                                 28   [ +  -  +  + ]:             72 :         if (sqlda->sqlvar[i].sqlind && *(sqlda->sqlvar[i].sqlind) == -1)
                                 29                 :             10 :             printf("name sqlda descriptor: '%s' value NULL'\n", sqlda->sqlvar[i].sqlname.data);
                                 30                 :                :         else
                                 31   [ +  +  +  -  :             62 :         switch (sqlda->sqlvar[i].sqltype)
                                           +  +  - ]
                                 32                 :                :         {
                                 33                 :             20 :         case ECPGt_char:
                                 34                 :             20 :             printf("name sqlda descriptor: '%s' value '%s'\n", sqlda->sqlvar[i].sqlname.data, sqlda->sqlvar[i].sqldata);
                                 35                 :             20 :             break;
                                 36                 :             12 :         case ECPGt_int:
                                 37                 :             12 :             printf("name sqlda descriptor: '%s' value %d\n", sqlda->sqlvar[i].sqlname.data, *(int *)sqlda->sqlvar[i].sqldata);
                                 38                 :             12 :             break;
 2158 tgl@sss.pgh.pa.us          39                 :             10 :         case ECPGt_long:
                                 40                 :             10 :             printf("name sqlda descriptor: '%s' value %ld\n", sqlda->sqlvar[i].sqlname.data, *(long int *)sqlda->sqlvar[i].sqldata);
                                 41                 :             10 :             break;
 2158 tgl@sss.pgh.pa.us          42                 :UBC           0 :         case ECPGt_long_long:
 1629 peter@eisentraut.org       43                 :              0 :             printf(
                                 44                 :                : #ifdef _WIN32
                                 45                 :                :                 "name sqlda descriptor: '%s' value %I64d\n",
                                 46                 :                : #else
                                 47                 :                :                 "name sqlda descriptor: '%s' value %lld\n",
                                 48                 :                : #endif
                                 49                 :              0 :                 sqlda->sqlvar[i].sqlname.data, *(long long int *)sqlda->sqlvar[i].sqldata);
 2158 tgl@sss.pgh.pa.us          50                 :              0 :             break;
 5213 meskes@postgresql.or       51                 :CBC          10 :         case ECPGt_double:
 2156 tgl@sss.pgh.pa.us          52                 :             10 :             printf("name sqlda descriptor: '%s' value %f\n", sqlda->sqlvar[i].sqlname.data, *(double *)sqlda->sqlvar[i].sqldata);
 5213 meskes@postgresql.or       53                 :             10 :             break;
                                 54                 :             10 :         case ECPGt_numeric:
                                 55                 :                :             {
                                 56                 :                :                 char    *val;
                                 57                 :                : 
                                 58                 :             10 :                 val = PGTYPESnumeric_to_asc((numeric*)sqlda->sqlvar[i].sqldata, -1);
                                 59                 :             10 :                 printf("name sqlda descriptor: '%s' value NUMERIC '%s'\n", sqlda->sqlvar[i].sqlname.data, val);
 2127 tmunro@postgresql.or       60                 :             10 :                 PGTYPESchar_free(val);
 5213 meskes@postgresql.or       61                 :             10 :                 break;
                                 62                 :                :             }
                                 63                 :                :         }
                                 64                 :                :     }
                                 65                 :                : }
                                 66                 :                : 
                                 67                 :                : int
                                 68                 :              1 : main (void)
                                 69                 :                : {
                                 70                 :                : exec sql begin declare section;
                                 71                 :              1 :     char    *stmt1 = "SELECT * FROM t1";
                                 72                 :              1 :     char    *stmt2 = "SELECT * FROM t1 WHERE id = ?";
                                 73                 :                :     int rec;
                                 74                 :                :     int id;
                                 75                 :                : exec sql end declare section;
                                 76                 :                : 
                                 77                 :                :     char msg[128];
                                 78                 :                : 
                                 79                 :              1 :     ECPGdebug(1, stderr);
                                 80                 :                : 
                                 81                 :              1 :     strcpy(msg, "connect");
                                 82                 :              1 :     exec sql connect to REGRESSDB1 as regress1;
                                 83         [ -  + ]:              1 : 
                                 84                 :              1 :     strcpy(msg, "set");
                                 85                 :              1 :     exec sql set datestyle to iso;
                                 86         [ -  + ]:              1 : 
                                 87                 :              1 :     strcpy(msg, "create");
                                 88                 :              1 :     exec sql create table t1(
                                 89                 :                :         id integer,
                                 90                 :                :         t text,
                                 91                 :                :         d1 numeric,
                                 92                 :                :         d2 float8,
                                 93                 :                :         c char(10),
                                 94                 :                :         big bigint
                                 95                 :                :         );
                                 96         [ -  + ]:              1 : 
                                 97                 :              1 :     strcpy(msg, "insert");
                                 98                 :              1 :     exec sql insert into t1 values
                                 99                 :                :         (1, 'a', 1.0, 1, 'a',1111111111111111111),
                                100                 :                :         (2, null, null, null, null,null),
                                101                 :                :         (3, 'c', 0.0, 3, 'c',3333333333333333333),
                                102                 :                :         (4, 'd', 'NaN', 4, 'd',4444444444444444444),
                                103                 :                :         (5, 'e', 0.001234, 5, 'e',5555555555555555555);
                                104         [ -  + ]:              1 : 
                                105                 :              1 :     strcpy(msg, "commit");
                                106                 :              1 :     exec sql commit;
                                107         [ -  + ]:              1 : 
                                108                 :                :     /* SQLDA test for getting all records from a table */
                                109                 :                : 
                                110                 :              1 :     outp_sqlda = NULL;
                                111                 :                : 
                                112                 :              1 :     strcpy(msg, "prepare");
                                113                 :              1 :     exec sql prepare st_id1 from :stmt1;
                                114         [ -  + ]:              1 : 
                                115                 :              1 :     strcpy(msg, "declare");
                                116                 :                :     exec sql declare mycur1 cursor for st_id1;
                                117                 :                : 
                                118                 :              1 :     strcpy(msg, "open");
                                119                 :              1 :     exec sql open mycur1;
                                120         [ -  + ]:              1 : 
                                121                 :                :     exec sql whenever not found do break;
                                122                 :                : 
                                123                 :              1 :     rec = 0;
                                124                 :                :     while (1)
                                125                 :                :     {
                                126                 :              6 :         strcpy(msg, "fetch");
 4891 peter_e@gmx.net           127                 :              6 :         exec sql fetch 1 from mycur1 into descriptor outp_sqlda;
 5213 meskes@postgresql.or      128   [ +  +  -  + ]:              6 : 
                                129                 :              5 :         printf("FETCH RECORD %d\n", ++rec);
                                130                 :              5 :         dump_sqlda(outp_sqlda);
                                131                 :                :     }
                                132                 :                : 
                                133                 :                :     exec sql whenever not found continue;
                                134                 :                : 
                                135                 :              1 :     strcpy(msg, "close");
                                136                 :              1 :     exec sql close mycur1;
                                137         [ -  + ]:              1 : 
                                138                 :              1 :     strcpy(msg, "deallocate");
                                139                 :              1 :     exec sql deallocate prepare st_id1;
                                140         [ -  + ]:              1 : 
                                141                 :              1 :     free(outp_sqlda);
                                142                 :                : 
                                143                 :                :     /* SQLDA test for getting ALL records into the sqlda list */
                                144                 :                : 
                                145                 :              1 :     outp_sqlda = NULL;
                                146                 :                : 
                                147                 :              1 :     strcpy(msg, "prepare");
                                148                 :              1 :     exec sql prepare st_id2 from :stmt1;
                                149         [ -  + ]:              1 : 
                                150                 :              1 :     strcpy(msg, "declare");
                                151                 :                :     exec sql declare mycur2 cursor for st_id2;
                                152                 :                : 
                                153                 :              1 :     strcpy(msg, "open");
                                154                 :              1 :     exec sql open mycur2;
                                155         [ -  + ]:              1 : 
                                156                 :              1 :     strcpy(msg, "fetch");
                                157                 :              1 :     exec sql fetch all from mycur2 into descriptor outp_sqlda;
                                158         [ -  + ]:              1 : 
                                159                 :              1 :     outp_sqlda1 = outp_sqlda;
                                160                 :              1 :     rec = 0;
                                161         [ +  + ]:              6 :     while (outp_sqlda1)
                                162                 :                :     {
                                163                 :                :         sqlda_t *ptr;
                                164                 :              5 :         printf("FETCH RECORD %d\n", ++rec);
                                165                 :              5 :         dump_sqlda(outp_sqlda1);
                                166                 :                : 
                                167                 :              5 :         ptr = outp_sqlda1;
                                168                 :              5 :         outp_sqlda1 = outp_sqlda1->desc_next;
                                169                 :              5 :         free(ptr);
                                170                 :                :     }
                                171                 :                : 
                                172                 :              1 :     strcpy(msg, "close");
                                173                 :              1 :     exec sql close mycur2;
                                174         [ -  + ]:              1 : 
                                175                 :              1 :     strcpy(msg, "deallocate");
                                176                 :              1 :     exec sql deallocate prepare st_id2;
                                177         [ -  + ]:              1 : 
                                178                 :                :     /* SQLDA test for getting one record using an input descriptor */
                                179                 :                : 
                                180                 :                :     /*
                                181                 :                :      * Input sqlda has to be built manually
                                182                 :                :      * sqlda_t contains 1 sqlvar_t structure already.
                                183                 :                :      */
                                184                 :              1 :     inp_sqlda = (sqlda_t *)malloc(sizeof(sqlda_t));
                                185                 :              1 :     memset(inp_sqlda, 0, sizeof(sqlda_t));
                                186                 :              1 :     inp_sqlda->sqln = 1;
                                187                 :                : 
                                188                 :              1 :     inp_sqlda->sqlvar[0].sqltype = ECPGt_int;
                                189                 :              1 :     inp_sqlda->sqlvar[0].sqldata = (char *)&id;
                                190                 :                : 
                                191                 :              1 :     printf("EXECUTE RECORD 4\n");
                                192                 :                : 
                                193                 :              1 :     id = 4;
                                194                 :                : 
                                195                 :              1 :     outp_sqlda = NULL;
                                196                 :                : 
                                197                 :              1 :     strcpy(msg, "prepare");
                                198                 :              1 :     exec sql prepare st_id3 FROM :stmt2;
                                199         [ -  + ]:              1 : 
                                200                 :              1 :     strcpy(msg, "execute");
                                201                 :              1 :     exec sql execute st_id3 using descriptor inp_sqlda into descriptor outp_sqlda;
                                202         [ -  + ]:              1 : 
                                203                 :              1 :     dump_sqlda(outp_sqlda);
                                204                 :                : 
                                205                 :              1 :     strcpy(msg, "deallocate");
                                206                 :              1 :     exec sql deallocate prepare st_id3;
                                207         [ -  + ]:              1 : 
                                208                 :              1 :     free(inp_sqlda);
                                209                 :              1 :     free(outp_sqlda);
                                210                 :                : 
                                211                 :                :     /* SQLDA test for getting one record using an input descriptor
                                212                 :                :      * on a named connection
                                213                 :                :      */
                                214                 :                : 
                                215                 :              1 :     exec sql connect to REGRESSDB1 as con2;
                                216         [ -  + ]:              1 : 
                                217                 :                :     /*
                                218                 :                :      * Input sqlda has to be built manually
                                219                 :                :      * sqlda_t contains 1 sqlvar_t structure already.
                                220                 :                :      */
                                221                 :              1 :     inp_sqlda = (sqlda_t *)malloc(sizeof(sqlda_t));
                                222                 :              1 :     memset(inp_sqlda, 0, sizeof(sqlda_t));
                                223                 :              1 :     inp_sqlda->sqln = 1;
                                224                 :                : 
                                225                 :              1 :     inp_sqlda->sqlvar[0].sqltype = ECPGt_int;
                                226                 :              1 :     inp_sqlda->sqlvar[0].sqldata = (char *)&id;
                                227                 :                : 
                                228                 :              1 :     printf("EXECUTE RECORD 4\n");
                                229                 :                : 
                                230                 :              1 :     id = 4;
                                231                 :                : 
                                232                 :              1 :     outp_sqlda = NULL;
                                233                 :                : 
                                234                 :              1 :     strcpy(msg, "prepare");
                                235                 :              1 :     exec sql at con2 prepare st_id4 FROM :stmt2;
                                236         [ -  + ]:              1 : 
                                237                 :              1 :     strcpy(msg, "execute");
                                238                 :              1 :     exec sql at con2 execute st_id4 using descriptor inp_sqlda into descriptor outp_sqlda;
                                239         [ -  + ]:              1 : 
                                240                 :              1 :     dump_sqlda(outp_sqlda);
                                241                 :                : 
                                242                 :              1 :     strcpy(msg, "commit");
                                243                 :              1 :     exec sql at con2 commit;
                                244         [ -  + ]:              1 : 
                                245                 :              1 :     strcpy(msg, "deallocate");
                                246                 :              1 :     exec sql deallocate prepare st_id4;
                                247         [ -  + ]:              1 : 
                                248                 :              1 :     free(inp_sqlda);
                                249                 :              1 :     free(outp_sqlda);
                                250                 :                : 
                                251                 :              1 :     strcpy(msg, "disconnect");
                                252                 :              1 :     exec sql disconnect con2;
                                253         [ -  + ]:              1 : 
                                254                 :                :     /* End test */
                                255                 :                : 
                                256                 :              1 :     strcpy(msg, "drop");
                                257                 :              1 :     exec sql drop table t1;
                                258         [ -  + ]:              1 : 
                                259                 :              1 :     strcpy(msg, "commit");
                                260                 :              1 :     exec sql commit;
                                261         [ -  + ]:              1 : 
                                262                 :              1 :     strcpy(msg, "disconnect");
                                263                 :              1 :     exec sql disconnect;
                                264         [ -  + ]:              1 : 
 2432 peter_e@gmx.net           265                 :              1 :     return 0;
                                266                 :                : }
        

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