LCOV - differential code coverage report
Current view: top level - contrib/hstore_plperl - hstore_plperl.c (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 100.0 % 58 58 58
Current Date: 2024-04-14 14:21:10 Functions: 100.0 % 6 6 6
Baseline: 16@8cea358b128 Branches: 80.8 % 26 21 5 21
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: 100.0 % 58 58 58
Function coverage date bins:
(240..) days: 100.0 % 6 6 6
Branch coverage date bins:
(240..) days: 80.8 % 26 21 5 21

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : #include "postgres.h"
                                  2                 :                : 
                                  3                 :                : #include "fmgr.h"
                                  4                 :                : #include "hstore/hstore.h"
                                  5                 :                : #include "plperl.h"
                                  6                 :                : 
 3276 peter_e@gmx.net             7                 :CBC           3 : PG_MODULE_MAGIC;
                                  8                 :                : 
                                  9                 :                : /* Linkage to functions in hstore module */
                                 10                 :                : typedef HStore *(*hstoreUpgrade_t) (Datum orig);
                                 11                 :                : static hstoreUpgrade_t hstoreUpgrade_p;
                                 12                 :                : typedef int (*hstoreUniquePairs_t) (Pairs *a, int32 l, int32 *buflen);
                                 13                 :                : static hstoreUniquePairs_t hstoreUniquePairs_p;
                                 14                 :                : typedef HStore *(*hstorePairs_t) (Pairs *pairs, int32 pcount, int32 buflen);
                                 15                 :                : static hstorePairs_t hstorePairs_p;
                                 16                 :                : typedef size_t (*hstoreCheckKeyLen_t) (size_t len);
                                 17                 :                : static hstoreCheckKeyLen_t hstoreCheckKeyLen_p;
                                 18                 :                : typedef size_t (*hstoreCheckValLen_t) (size_t len);
                                 19                 :                : static hstoreCheckValLen_t hstoreCheckValLen_p;
                                 20                 :                : 
                                 21                 :                : 
                                 22                 :                : /*
                                 23                 :                :  * Module initialize function: fetch function pointers for cross-module calls.
                                 24                 :                :  */
                                 25                 :                : void
 2749 tgl@sss.pgh.pa.us          26                 :              3 : _PG_init(void)
                                 27                 :                : {
                                 28                 :                :     /* Asserts verify that typedefs above match original declarations */
                                 29                 :                :     AssertVariableIsOfType(&hstoreUpgrade, hstoreUpgrade_t);
                                 30                 :              3 :     hstoreUpgrade_p = (hstoreUpgrade_t)
                                 31                 :              3 :         load_external_function("$libdir/hstore", "hstoreUpgrade",
                                 32                 :                :                                true, NULL);
                                 33                 :                :     AssertVariableIsOfType(&hstoreUniquePairs, hstoreUniquePairs_t);
                                 34                 :              3 :     hstoreUniquePairs_p = (hstoreUniquePairs_t)
                                 35                 :              3 :         load_external_function("$libdir/hstore", "hstoreUniquePairs",
                                 36                 :                :                                true, NULL);
                                 37                 :                :     AssertVariableIsOfType(&hstorePairs, hstorePairs_t);
                                 38                 :              3 :     hstorePairs_p = (hstorePairs_t)
                                 39                 :              3 :         load_external_function("$libdir/hstore", "hstorePairs",
                                 40                 :                :                                true, NULL);
                                 41                 :                :     AssertVariableIsOfType(&hstoreCheckKeyLen, hstoreCheckKeyLen_t);
                                 42                 :              3 :     hstoreCheckKeyLen_p = (hstoreCheckKeyLen_t)
                                 43                 :              3 :         load_external_function("$libdir/hstore", "hstoreCheckKeyLen",
                                 44                 :                :                                true, NULL);
                                 45                 :                :     AssertVariableIsOfType(&hstoreCheckValLen, hstoreCheckValLen_t);
                                 46                 :              3 :     hstoreCheckValLen_p = (hstoreCheckValLen_t)
                                 47                 :              3 :         load_external_function("$libdir/hstore", "hstoreCheckValLen",
                                 48                 :                :                                true, NULL);
                                 49                 :              3 : }
                                 50                 :                : 
                                 51                 :                : 
                                 52                 :                : /* These defines must be after the module init function */
                                 53                 :                : #define hstoreUpgrade hstoreUpgrade_p
                                 54                 :                : #define hstoreUniquePairs hstoreUniquePairs_p
                                 55                 :                : #define hstorePairs hstorePairs_p
                                 56                 :                : #define hstoreCheckKeyLen hstoreCheckKeyLen_p
                                 57                 :                : #define hstoreCheckValLen hstoreCheckValLen_p
                                 58                 :                : 
                                 59                 :                : 
 3276 peter_e@gmx.net            60                 :              5 : PG_FUNCTION_INFO_V1(hstore_to_plperl);
                                 61                 :                : 
                                 62                 :                : Datum
                                 63                 :              7 : hstore_to_plperl(PG_FUNCTION_ARGS)
                                 64                 :                : {
 2452 tgl@sss.pgh.pa.us          65                 :              7 :     dTHX;
 2400                            66                 :              7 :     HStore     *in = PG_GETARG_HSTORE_P(0);
                                 67                 :                :     int         i;
 3276 peter_e@gmx.net            68                 :              7 :     int         count = HS_COUNT(in);
                                 69                 :              7 :     char       *base = STRPTR(in);
                                 70                 :              7 :     HEntry     *entries = ARRPTR(in);
                                 71                 :                :     HV         *hv;
                                 72                 :                : 
                                 73                 :              7 :     hv = newHV();
                                 74                 :                : 
                                 75         [ +  + ]:             20 :     for (i = 0; i < count; i++)
                                 76                 :                :     {
                                 77                 :                :         const char *key;
                                 78                 :                :         SV         *value;
                                 79                 :                : 
 3069 tgl@sss.pgh.pa.us          80         [ +  + ]:             13 :         key = pnstrdup(HSTORE_KEY(entries, base, i),
                                 81         [ +  + ]:             13 :                        HSTORE_KEYLEN(entries, i));
                                 82         [ +  + ]:             13 :         value = HSTORE_VALISNULL(entries, i) ? newSV(0) :
                                 83         [ +  - ]:              7 :             cstr2sv(pnstrdup(HSTORE_VAL(entries, base, i),
                                 84         [ -  + ]:              7 :                              HSTORE_VALLEN(entries, i)));
                                 85                 :                : 
 3276 peter_e@gmx.net            86                 :             13 :         (void) hv_store(hv, key, strlen(key), value, 0);
                                 87                 :                :     }
                                 88                 :                : 
                                 89                 :              7 :     return PointerGetDatum(newRV((SV *) hv));
                                 90                 :                : }
                                 91                 :                : 
                                 92                 :                : 
                                 93                 :              6 : PG_FUNCTION_INFO_V1(plperl_to_hstore);
                                 94                 :                : 
                                 95                 :                : Datum
                                 96                 :              7 : plperl_to_hstore(PG_FUNCTION_ARGS)
                                 97                 :                : {
 2452 tgl@sss.pgh.pa.us          98                 :              7 :     dTHX;
 2127                            99                 :              7 :     SV         *in = (SV *) PG_GETARG_POINTER(0);
                                100                 :                :     HV         *hv;
                                101                 :                :     HE         *he;
                                102                 :                :     int32       buflen;
                                103                 :                :     int32       i;
                                104                 :                :     int32       pcount;
                                105                 :                :     HStore     *out;
                                106                 :                :     Pairs      *pairs;
                                107                 :                : 
                                108                 :                :     /* Dereference references recursively. */
                                109         [ +  + ]:             13 :     while (SvROK(in))
                                110                 :              6 :         in = SvRV(in);
                                111                 :                : 
                                112                 :                :     /* Now we must have a hash. */
                                113         [ +  + ]:              7 :     if (SvTYPE(in) != SVt_PVHV)
                                114         [ +  - ]:              2 :         ereport(ERROR,
                                115                 :                :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                116                 :                :                  errmsg("cannot transform non-hash Perl value to hstore")));
                                117                 :              5 :     hv = (HV *) in;
                                118                 :                : 
 3276 peter_e@gmx.net           119                 :              5 :     pcount = hv_iterinit(hv);
                                120                 :                : 
                                121                 :              5 :     pairs = palloc(pcount * sizeof(Pairs));
                                122                 :                : 
                                123                 :              5 :     i = 0;
                                124         [ +  + ]:             18 :     while ((he = hv_iternext(hv)))
                                125                 :                :     {
 3249 bruce@momjian.us          126   [ +  -  -  + ]:             13 :         char       *key = sv2cstr(HeSVKEY_force(he));
                                127                 :             13 :         SV         *value = HeVAL(he);
                                128                 :                : 
 3276 peter_e@gmx.net           129                 :             13 :         pairs[i].key = pstrdup(key);
                                130                 :             13 :         pairs[i].keylen = hstoreCheckKeyLen(strlen(pairs[i].key));
                                131                 :             13 :         pairs[i].needfree = true;
                                132                 :                : 
                                133         [ +  + ]:             13 :         if (!SvOK(value))
                                134                 :                :         {
                                135                 :              4 :             pairs[i].val = NULL;
                                136                 :              4 :             pairs[i].vallen = 0;
                                137                 :              4 :             pairs[i].isnull = true;
                                138                 :                :         }
                                139                 :                :         else
                                140                 :                :         {
                                141                 :              9 :             pairs[i].val = pstrdup(sv2cstr(value));
                                142                 :              9 :             pairs[i].vallen = hstoreCheckValLen(strlen(pairs[i].val));
                                143                 :              9 :             pairs[i].isnull = false;
                                144                 :                :         }
                                145                 :                : 
                                146                 :             13 :         i++;
                                147                 :                :     }
                                148                 :                : 
                                149                 :              5 :     pcount = hstoreUniquePairs(pairs, pcount, &buflen);
                                150                 :              5 :     out = hstorePairs(pairs, pcount, buflen);
                                151                 :              5 :     PG_RETURN_POINTER(out);
                                152                 :                : }
        

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