LCOV - differential code coverage report
Current view: top level - contrib/dict_int - dict_int.c (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage HEAD vs 15 Lines: 97.4 % 39 38 1 38
Current Date: 2023-04-08 17:13:01 Functions: 100.0 % 5 5 5
Baseline: 15 Line coverage date bins:
Baseline Date: 2023-04-08 15:09:40 (240..) days: 97.4 % 39 38 1 38
Legend: Lines: hit not hit Function coverage date bins:
(240..) days: 100.0 % 5 5 5

 Age         Owner                  TLA  Line data    Source code
                                  1                 : /*-------------------------------------------------------------------------
                                  2                 :  *
                                  3                 :  * dict_int.c
                                  4                 :  *    Text search dictionary for integers
                                  5                 :  *
                                  6                 :  * Copyright (c) 2007-2023, PostgreSQL Global Development Group
                                  7                 :  *
                                  8                 :  * IDENTIFICATION
                                  9                 :  *    contrib/dict_int/dict_int.c
                                 10                 :  *
                                 11                 :  *-------------------------------------------------------------------------
                                 12                 :  */
                                 13                 : #include "postgres.h"
                                 14                 : 
                                 15                 : #include "commands/defrem.h"
                                 16                 : #include "tsearch/ts_public.h"
                                 17                 : 
 5655 tgl                        18 CBC           1 : PG_MODULE_MAGIC;
                                 19                 : 
                                 20                 : typedef struct
                                 21                 : {
                                 22                 :     int         maxlen;
                                 23                 :     bool        rejectlong;
                                 24                 :     bool        absval;
                                 25                 : } DictInt;
                                 26                 : 
                                 27                 : 
                                 28               2 : PG_FUNCTION_INFO_V1(dintdict_init);
                                 29               2 : PG_FUNCTION_INFO_V1(dintdict_lexize);
                                 30                 : 
                                 31                 : Datum
                                 32               9 : dintdict_init(PG_FUNCTION_ARGS)
                                 33                 : {
 5624 bruce                      34               9 :     List       *dictoptions = (List *) PG_GETARG_POINTER(0);
                                 35                 :     DictInt    *d;
                                 36                 :     ListCell   *l;
                                 37                 : 
 5655 tgl                        38               9 :     d = (DictInt *) palloc0(sizeof(DictInt));
                                 39               9 :     d->maxlen = 6;
                                 40               9 :     d->rejectlong = false;
 1127                            41               9 :     d->absval = false;
                                 42                 : 
 5655                            43              21 :     foreach(l, dictoptions)
                                 44                 :     {
 5624 bruce                      45              13 :         DefElem    *defel = (DefElem *) lfirst(l);
                                 46                 : 
 1899 tgl                        47              13 :         if (strcmp(defel->defname, "maxlen") == 0)
                                 48                 :         {
 5655                            49               7 :             d->maxlen = atoi(defGetString(defel));
                                 50                 : 
 1223 tomas.vondra               51               7 :             if (d->maxlen < 1)
                                 52               1 :                 ereport(ERROR,
                                 53                 :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                 54                 :                          errmsg("maxlen value has to be >= 1")));
                                 55                 :         }
 1899 tgl                        56               6 :         else if (strcmp(defel->defname, "rejectlong") == 0)
                                 57                 :         {
 5655                            58               2 :             d->rejectlong = defGetBoolean(defel);
                                 59                 :         }
 1127                            60               4 :         else if (strcmp(defel->defname, "absval") == 0)
                                 61                 :         {
                                 62               4 :             d->absval = defGetBoolean(defel);
                                 63                 :         }
                                 64                 :         else
                                 65                 :         {
 5655 tgl                        66 UBC           0 :             ereport(ERROR,
                                 67                 :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                 68                 :                      errmsg("unrecognized intdict parameter: \"%s\"",
                                 69                 :                             defel->defname)));
                                 70                 :         }
                                 71                 :     }
                                 72                 : 
 5655 tgl                        73 CBC           8 :     PG_RETURN_POINTER(d);
                                 74                 : }
                                 75                 : 
                                 76                 : Datum
                                 77              57 : dintdict_lexize(PG_FUNCTION_ARGS)
                                 78                 : {
 5624 bruce                      79              57 :     DictInt    *d = (DictInt *) PG_GETARG_POINTER(0);
                                 80              57 :     char       *in = (char *) PG_GETARG_POINTER(1);
 1127 tgl                        81              57 :     int         len = PG_GETARG_INT32(2);
                                 82                 :     char       *txt;
 4175                            83              57 :     TSLexeme   *res = palloc0(sizeof(TSLexeme) * 2);
                                 84                 : 
 5655                            85              57 :     res[1].lexeme = NULL;
                                 86                 : 
 1127                            87              57 :     if (d->absval && (in[0] == '+' || in[0] == '-'))
                                 88                 :     {
                                 89               5 :         len--;
                                 90               5 :         txt = pnstrdup(in + 1, len);
                                 91                 :     }
                                 92                 :     else
                                 93              52 :         txt = pnstrdup(in, len);
                                 94                 : 
                                 95              57 :     if (len > d->maxlen)
                                 96                 :     {
 5624 bruce                      97              38 :         if (d->rejectlong)
                                 98                 :         {
                                 99                 :             /* reject by returning void array */
 5655 tgl                       100               2 :             pfree(txt);
                                101               2 :             res[0].lexeme = NULL;
                                102                 :         }
                                103                 :         else
                                104                 :         {
                                105                 :             /* trim integer */
                                106              36 :             txt[d->maxlen] = '\0';
                                107              36 :             res[0].lexeme = txt;
                                108                 :         }
                                109                 :     }
                                110                 :     else
                                111                 :     {
                                112              19 :         res[0].lexeme = txt;
                                113                 :     }
                                114                 : 
                                115              57 :     PG_RETURN_POINTER(res);
                                116                 : }
        

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