LCOV - differential code coverage report
Current view: top level - src/backend/tsearch - wparser.c (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 95.1 % 226 215 11 215
Current Date: 2024-04-14 14:21:10 Functions: 90.5 % 21 19 2 19
Baseline: 16@8cea358b128 Branches: 59.0 % 122 72 50 72
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: 95.1 % 226 215 11 215
Function coverage date bins:
(240..) days: 90.5 % 21 19 2 19
Branch coverage date bins:
(240..) days: 59.0 % 122 72 50 72

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : /*-------------------------------------------------------------------------
                                  2                 :                :  *
                                  3                 :                :  * wparser.c
                                  4                 :                :  *      Standard interface to word parser
                                  5                 :                :  *
                                  6                 :                :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
                                  7                 :                :  *
                                  8                 :                :  *
                                  9                 :                :  * IDENTIFICATION
                                 10                 :                :  *    src/backend/tsearch/wparser.c
                                 11                 :                :  *
                                 12                 :                :  *-------------------------------------------------------------------------
                                 13                 :                :  */
                                 14                 :                : #include "postgres.h"
                                 15                 :                : 
                                 16                 :                : #include "catalog/namespace.h"
                                 17                 :                : #include "commands/defrem.h"
                                 18                 :                : #include "funcapi.h"
                                 19                 :                : #include "tsearch/ts_cache.h"
                                 20                 :                : #include "tsearch/ts_utils.h"
                                 21                 :                : #include "utils/fmgrprotos.h"
                                 22                 :                : #include "utils/jsonfuncs.h"
                                 23                 :                : #include "utils/varlena.h"
                                 24                 :                : 
                                 25                 :                : /******sql-level interface******/
                                 26                 :                : 
                                 27                 :                : typedef struct
                                 28                 :                : {
                                 29                 :                :     int         cur;
                                 30                 :                :     LexDescr   *list;
                                 31                 :                : } TSTokenTypeStorage;
                                 32                 :                : 
                                 33                 :                : /* state for ts_headline_json_* */
                                 34                 :                : typedef struct HeadlineJsonState
                                 35                 :                : {
                                 36                 :                :     HeadlineParsedText *prs;
                                 37                 :                :     TSConfigCacheEntry *cfg;
                                 38                 :                :     TSParserCacheEntry *prsobj;
                                 39                 :                :     TSQuery     query;
                                 40                 :                :     List       *prsoptions;
                                 41                 :                :     bool        transformed;
                                 42                 :                : } HeadlineJsonState;
                                 43                 :                : 
                                 44                 :                : static text *headline_json_value(void *_state, char *elem_value, int elem_len);
                                 45                 :                : 
                                 46                 :                : static void
  480 michael@paquier.xyz        47                 :CBC         193 : tt_setup_firstcall(FuncCallContext *funcctx, FunctionCallInfo fcinfo,
                                 48                 :                :                    Oid prsid)
                                 49                 :                : {
                                 50                 :                :     TupleDesc   tupdesc;
                                 51                 :                :     MemoryContext oldcontext;
                                 52                 :                :     TSTokenTypeStorage *st;
 6081 tgl@sss.pgh.pa.us          53                 :            193 :     TSParserCacheEntry *prs = lookup_ts_parser_cache(prsid);
                                 54                 :                : 
                                 55         [ -  + ]:            193 :     if (!OidIsValid(prs->lextypeOid))
 6081 tgl@sss.pgh.pa.us          56         [ #  # ]:UBC           0 :         elog(ERROR, "method lextype isn't defined for text search parser %u",
                                 57                 :                :              prsid);
                                 58                 :                : 
 6081 tgl@sss.pgh.pa.us          59                 :CBC         193 :     oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
                                 60                 :                : 
                                 61                 :            193 :     st = (TSTokenTypeStorage *) palloc(sizeof(TSTokenTypeStorage));
                                 62                 :            193 :     st->cur = 0;
                                 63                 :                :     /* lextype takes one dummy argument */
                                 64                 :            193 :     st->list = (LexDescr *) DatumGetPointer(OidFunctionCall1(prs->lextypeOid,
                                 65                 :                :                                                              (Datum) 0));
                                 66                 :            193 :     funcctx->user_fctx = (void *) st;
                                 67                 :                : 
  480 michael@paquier.xyz        68         [ -  + ]:            193 :     if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
  480 michael@paquier.xyz        69         [ #  # ]:UBC           0 :         elog(ERROR, "return type must be a row type");
  480 michael@paquier.xyz        70                 :CBC         193 :     funcctx->tuple_desc = tupdesc;
 6081 tgl@sss.pgh.pa.us          71                 :            193 :     funcctx->attinmeta = TupleDescGetAttInMetadata(tupdesc);
                                 72                 :                : 
                                 73                 :            193 :     MemoryContextSwitchTo(oldcontext);
                                 74                 :            193 : }
                                 75                 :                : 
                                 76                 :                : static Datum
                                 77                 :           4632 : tt_process_call(FuncCallContext *funcctx)
                                 78                 :                : {
                                 79                 :                :     TSTokenTypeStorage *st;
                                 80                 :                : 
                                 81                 :           4632 :     st = (TSTokenTypeStorage *) funcctx->user_fctx;
                                 82   [ +  -  +  + ]:           4632 :     if (st->list && st->list[st->cur].lexid)
                                 83                 :                :     {
                                 84                 :                :         Datum       result;
                                 85                 :                :         char       *values[3];
                                 86                 :                :         char        txtid[16];
                                 87                 :                :         HeapTuple   tuple;
                                 88                 :                : 
                                 89                 :           4439 :         sprintf(txtid, "%d", st->list[st->cur].lexid);
                                 90                 :           4439 :         values[0] = txtid;
                                 91                 :           4439 :         values[1] = st->list[st->cur].alias;
                                 92                 :           4439 :         values[2] = st->list[st->cur].descr;
                                 93                 :                : 
                                 94                 :           4439 :         tuple = BuildTupleFromCStrings(funcctx->attinmeta, values);
                                 95                 :           4439 :         result = HeapTupleGetDatum(tuple);
                                 96                 :                : 
                                 97                 :           4439 :         pfree(values[1]);
                                 98                 :           4439 :         pfree(values[2]);
                                 99                 :           4439 :         st->cur++;
                                100                 :           4439 :         return result;
                                101                 :                :     }
                                102                 :            193 :     return (Datum) 0;
                                103                 :                : }
                                104                 :                : 
                                105                 :                : Datum
                                106                 :           4560 : ts_token_type_byid(PG_FUNCTION_ARGS)
                                107                 :                : {
                                108                 :                :     FuncCallContext *funcctx;
                                109                 :                :     Datum       result;
                                110                 :                : 
                                111         [ +  + ]:           4560 :     if (SRF_IS_FIRSTCALL())
                                112                 :                :     {
                                113                 :            190 :         funcctx = SRF_FIRSTCALL_INIT();
  480 michael@paquier.xyz       114                 :            190 :         tt_setup_firstcall(funcctx, fcinfo, PG_GETARG_OID(0));
                                115                 :                :     }
                                116                 :                : 
 6081 tgl@sss.pgh.pa.us         117                 :           4560 :     funcctx = SRF_PERCALL_SETUP();
                                118                 :                : 
                                119         [ +  + ]:           4560 :     if ((result = tt_process_call(funcctx)) != (Datum) 0)
                                120                 :           4370 :         SRF_RETURN_NEXT(funcctx, result);
                                121                 :            190 :     SRF_RETURN_DONE(funcctx);
                                122                 :                : }
                                123                 :                : 
                                124                 :                : Datum
                                125                 :             72 : ts_token_type_byname(PG_FUNCTION_ARGS)
                                126                 :                : {
                                127                 :                :     FuncCallContext *funcctx;
                                128                 :                :     Datum       result;
                                129                 :                : 
                                130         [ +  + ]:             72 :     if (SRF_IS_FIRSTCALL())
                                131                 :                :     {
 2590 noah@leadboat.com         132                 :              3 :         text       *prsname = PG_GETARG_TEXT_PP(0);
                                133                 :                :         Oid         prsId;
                                134                 :                : 
 6081 tgl@sss.pgh.pa.us         135                 :              3 :         funcctx = SRF_FIRSTCALL_INIT();
 5001 rhaas@postgresql.org      136                 :              3 :         prsId = get_ts_parser_oid(textToQualifiedNameList(prsname), false);
  480 michael@paquier.xyz       137                 :              3 :         tt_setup_firstcall(funcctx, fcinfo, prsId);
                                138                 :                :     }
                                139                 :                : 
 6081 tgl@sss.pgh.pa.us         140                 :             72 :     funcctx = SRF_PERCALL_SETUP();
                                141                 :                : 
                                142         [ +  + ]:             72 :     if ((result = tt_process_call(funcctx)) != (Datum) 0)
                                143                 :             69 :         SRF_RETURN_NEXT(funcctx, result);
                                144                 :              3 :     SRF_RETURN_DONE(funcctx);
                                145                 :                : }
                                146                 :                : 
                                147                 :                : typedef struct
                                148                 :                : {
                                149                 :                :     int         type;
                                150                 :                :     char       *lexeme;
                                151                 :                : } LexemeEntry;
                                152                 :                : 
                                153                 :                : typedef struct
                                154                 :                : {
                                155                 :                :     int         cur;
                                156                 :                :     int         len;
                                157                 :                :     LexemeEntry *list;
                                158                 :                : } PrsStorage;
                                159                 :                : 
                                160                 :                : 
                                161                 :                : static void
  480 michael@paquier.xyz       162                 :             22 : prs_setup_firstcall(FuncCallContext *funcctx, FunctionCallInfo fcinfo,
                                163                 :                :                     Oid prsid, text *txt)
                                164                 :                : {
                                165                 :                :     TupleDesc   tupdesc;
                                166                 :                :     MemoryContext oldcontext;
                                167                 :                :     PrsStorage *st;
 6081 tgl@sss.pgh.pa.us         168                 :             22 :     TSParserCacheEntry *prs = lookup_ts_parser_cache(prsid);
                                169                 :             22 :     char       *lex = NULL;
                                170                 :             22 :     int         llen = 0,
                                171                 :             22 :                 type = 0;
                                172                 :                :     void       *prsdata;
                                173                 :                : 
                                174                 :             22 :     oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
                                175                 :                : 
                                176                 :             22 :     st = (PrsStorage *) palloc(sizeof(PrsStorage));
                                177                 :             22 :     st->cur = 0;
                                178                 :             22 :     st->len = 16;
                                179                 :             22 :     st->list = (LexemeEntry *) palloc(sizeof(LexemeEntry) * st->len);
                                180                 :                : 
                                181   [ -  +  -  -  :             22 :     prsdata = (void *) DatumGetPointer(FunctionCall2(&prs->prsstart,
                                     -  -  -  -  -  
                                           +  -  + ]
                                182                 :                :                                                      PointerGetDatum(VARDATA_ANY(txt)),
                                183                 :                :                                                      Int32GetDatum(VARSIZE_ANY_EXHDR(txt))));
                                184                 :                : 
                                185                 :            541 :     while ((type = DatumGetInt32(FunctionCall3(&prs->prstoken,
                                186                 :                :                                                PointerGetDatum(prsdata),
                                187                 :                :                                                PointerGetDatum(&lex),
                                188         [ +  + ]:            541 :                                                PointerGetDatum(&llen)))) != 0)
                                189                 :                :     {
                                190         [ +  + ]:            519 :         if (st->cur >= st->len)
                                191                 :                :         {
                                192                 :             12 :             st->len = 2 * st->len;
                                193                 :             12 :             st->list = (LexemeEntry *) repalloc(st->list, sizeof(LexemeEntry) * st->len);
                                194                 :                :         }
                                195                 :            519 :         st->list[st->cur].lexeme = palloc(llen + 1);
                                196                 :            519 :         memcpy(st->list[st->cur].lexeme, lex, llen);
                                197                 :            519 :         st->list[st->cur].lexeme[llen] = '\0';
                                198                 :            519 :         st->list[st->cur].type = type;
                                199                 :            519 :         st->cur++;
                                200                 :                :     }
                                201                 :                : 
                                202                 :             22 :     FunctionCall1(&prs->prsend, PointerGetDatum(prsdata));
                                203                 :                : 
                                204                 :             22 :     st->len = st->cur;
                                205                 :             22 :     st->cur = 0;
                                206                 :                : 
                                207                 :             22 :     funcctx->user_fctx = (void *) st;
  480 michael@paquier.xyz       208         [ -  + ]:             22 :     if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
  480 michael@paquier.xyz       209         [ #  # ]:UBC           0 :         elog(ERROR, "return type must be a row type");
  480 michael@paquier.xyz       210                 :CBC          22 :     funcctx->tuple_desc = tupdesc;
 6081 tgl@sss.pgh.pa.us         211                 :             22 :     funcctx->attinmeta = TupleDescGetAttInMetadata(tupdesc);
                                212                 :             22 :     MemoryContextSwitchTo(oldcontext);
                                213                 :             22 : }
                                214                 :                : 
                                215                 :                : static Datum
                                216                 :            541 : prs_process_call(FuncCallContext *funcctx)
                                217                 :                : {
                                218                 :                :     PrsStorage *st;
                                219                 :                : 
                                220                 :            541 :     st = (PrsStorage *) funcctx->user_fctx;
                                221         [ +  + ]:            541 :     if (st->cur < st->len)
                                222                 :                :     {
                                223                 :                :         Datum       result;
                                224                 :                :         char       *values[2];
                                225                 :                :         char        tid[16];
                                226                 :                :         HeapTuple   tuple;
                                227                 :                : 
                                228                 :            519 :         values[0] = tid;
                                229                 :            519 :         sprintf(tid, "%d", st->list[st->cur].type);
                                230                 :            519 :         values[1] = st->list[st->cur].lexeme;
                                231                 :            519 :         tuple = BuildTupleFromCStrings(funcctx->attinmeta, values);
                                232                 :            519 :         result = HeapTupleGetDatum(tuple);
                                233                 :                : 
                                234                 :            519 :         pfree(values[1]);
                                235                 :            519 :         st->cur++;
                                236                 :            519 :         return result;
                                237                 :                :     }
                                238                 :             22 :     return (Datum) 0;
                                239                 :                : }
                                240                 :                : 
                                241                 :                : Datum
                                242                 :            105 : ts_parse_byid(PG_FUNCTION_ARGS)
                                243                 :                : {
                                244                 :                :     FuncCallContext *funcctx;
                                245                 :                :     Datum       result;
                                246                 :                : 
                                247         [ +  + ]:            105 :     if (SRF_IS_FIRSTCALL())
                                248                 :                :     {
 2590 noah@leadboat.com         249                 :             18 :         text       *txt = PG_GETARG_TEXT_PP(1);
                                250                 :                : 
 6081 tgl@sss.pgh.pa.us         251                 :             18 :         funcctx = SRF_FIRSTCALL_INIT();
  480 michael@paquier.xyz       252                 :             18 :         prs_setup_firstcall(funcctx, fcinfo, PG_GETARG_OID(0), txt);
 6081 tgl@sss.pgh.pa.us         253         [ -  + ]:             18 :         PG_FREE_IF_COPY(txt, 1);
                                254                 :                :     }
                                255                 :                : 
                                256                 :            105 :     funcctx = SRF_PERCALL_SETUP();
                                257                 :                : 
                                258         [ +  + ]:            105 :     if ((result = prs_process_call(funcctx)) != (Datum) 0)
                                259                 :             87 :         SRF_RETURN_NEXT(funcctx, result);
                                260                 :             18 :     SRF_RETURN_DONE(funcctx);
                                261                 :                : }
                                262                 :                : 
                                263                 :                : Datum
                                264                 :            436 : ts_parse_byname(PG_FUNCTION_ARGS)
                                265                 :                : {
                                266                 :                :     FuncCallContext *funcctx;
                                267                 :                :     Datum       result;
                                268                 :                : 
                                269         [ +  + ]:            436 :     if (SRF_IS_FIRSTCALL())
                                270                 :                :     {
 2590 noah@leadboat.com         271                 :              4 :         text       *prsname = PG_GETARG_TEXT_PP(0);
                                272                 :              4 :         text       *txt = PG_GETARG_TEXT_PP(1);
                                273                 :                :         Oid         prsId;
                                274                 :                : 
 6081 tgl@sss.pgh.pa.us         275                 :              4 :         funcctx = SRF_FIRSTCALL_INIT();
 5001 rhaas@postgresql.org      276                 :              4 :         prsId = get_ts_parser_oid(textToQualifiedNameList(prsname), false);
  480 michael@paquier.xyz       277                 :              4 :         prs_setup_firstcall(funcctx, fcinfo, prsId, txt);
                                278                 :                :     }
                                279                 :                : 
 6081 tgl@sss.pgh.pa.us         280                 :            436 :     funcctx = SRF_PERCALL_SETUP();
                                281                 :                : 
                                282         [ +  + ]:            436 :     if ((result = prs_process_call(funcctx)) != (Datum) 0)
                                283                 :            432 :         SRF_RETURN_NEXT(funcctx, result);
                                284                 :              4 :     SRF_RETURN_DONE(funcctx);
                                285                 :                : }
                                286                 :                : 
                                287                 :                : Datum
                                288                 :             73 : ts_headline_byid_opt(PG_FUNCTION_ARGS)
                                289                 :                : {
 2525                           290                 :             73 :     Oid         tsconfig = PG_GETARG_OID(0);
 2590 noah@leadboat.com         291                 :             73 :     text       *in = PG_GETARG_TEXT_PP(1);
 6081 tgl@sss.pgh.pa.us         292                 :             73 :     TSQuery     query = PG_GETARG_TSQUERY(2);
 2590 noah@leadboat.com         293   [ +  +  +  - ]:             73 :     text       *opt = (PG_NARGS() > 3 && PG_GETARG_POINTER(3)) ? PG_GETARG_TEXT_PP(3) : NULL;
                                294                 :                :     HeadlineParsedText prs;
                                295                 :                :     List       *prsoptions;
                                296                 :                :     text       *out;
                                297                 :                :     TSConfigCacheEntry *cfg;
                                298                 :                :     TSParserCacheEntry *prsobj;
                                299                 :                : 
 2525 tgl@sss.pgh.pa.us         300                 :             73 :     cfg = lookup_ts_config_cache(tsconfig);
 6081                           301                 :             73 :     prsobj = lookup_ts_parser_cache(cfg->prsId);
                                302                 :                : 
 5934                           303         [ -  + ]:             73 :     if (!OidIsValid(prsobj->headlineOid))
 5421 bruce@momjian.us          304         [ #  # ]:UBC           0 :         ereport(ERROR,
                                305                 :                :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                306                 :                :                  errmsg("text search parser does not support headline creation")));
                                307                 :                : 
 6077 tgl@sss.pgh.pa.us         308                 :CBC          73 :     memset(&prs, 0, sizeof(HeadlineParsedText));
 6081                           309                 :             73 :     prs.lenwords = 32;
 6077                           310                 :             73 :     prs.words = (HeadlineWordEntry *) palloc(sizeof(HeadlineWordEntry) * prs.lenwords);
                                311                 :                : 
 2590 noah@leadboat.com         312                 :UBC           0 :     hlparsetext(cfg->cfgId, &prs, query,
 2590 noah@leadboat.com         313   [ -  +  -  -  :CBC         146 :                 VARDATA_ANY(in), VARSIZE_ANY_EXHDR(in));
                                     -  -  -  -  -  
                                           +  -  + ]
                                314                 :                : 
 6080 tgl@sss.pgh.pa.us         315         [ +  + ]:             73 :     if (opt)
                                316                 :             33 :         prsoptions = deserialize_deflist(PointerGetDatum(opt));
                                317                 :                :     else
                                318                 :             40 :         prsoptions = NIL;
                                319                 :                : 
 6081                           320                 :             73 :     FunctionCall3(&(prsobj->prsheadline),
                                321                 :                :                   PointerGetDatum(&prs),
                                322                 :                :                   PointerGetDatum(prsoptions),
                                323                 :                :                   PointerGetDatum(query));
                                324                 :                : 
 6077                           325                 :             73 :     out = generateHeadline(&prs);
                                326                 :                : 
 6081                           327         [ -  + ]:             73 :     PG_FREE_IF_COPY(in, 1);
                                328         [ -  + ]:             73 :     PG_FREE_IF_COPY(query, 2);
                                329         [ +  + ]:             73 :     if (opt)
                                330         [ -  + ]:             33 :         PG_FREE_IF_COPY(opt, 3);
                                331                 :             73 :     pfree(prs.words);
                                332                 :             73 :     pfree(prs.startsel);
                                333                 :             73 :     pfree(prs.stopsel);
                                334                 :                : 
                                335                 :             73 :     PG_RETURN_POINTER(out);
                                336                 :                : }
                                337                 :                : 
                                338                 :                : Datum
                                339                 :             40 : ts_headline_byid(PG_FUNCTION_ARGS)
                                340                 :                : {
                                341                 :             40 :     PG_RETURN_DATUM(DirectFunctionCall3(ts_headline_byid_opt,
                                342                 :                :                                         PG_GETARG_DATUM(0),
                                343                 :                :                                         PG_GETARG_DATUM(1),
                                344                 :                :                                         PG_GETARG_DATUM(2)));
                                345                 :                : }
                                346                 :                : 
                                347                 :                : Datum
 6081 tgl@sss.pgh.pa.us         348                 :UBC           0 : ts_headline(PG_FUNCTION_ARGS)
                                349                 :                : {
                                350                 :              0 :     PG_RETURN_DATUM(DirectFunctionCall3(ts_headline_byid_opt,
                                351                 :                :                                         ObjectIdGetDatum(getTSCurrentConfig(true)),
                                352                 :                :                                         PG_GETARG_DATUM(0),
                                353                 :                :                                         PG_GETARG_DATUM(1)));
                                354                 :                : }
                                355                 :                : 
                                356                 :                : Datum
                                357                 :              0 : ts_headline_opt(PG_FUNCTION_ARGS)
                                358                 :                : {
                                359                 :              0 :     PG_RETURN_DATUM(DirectFunctionCall4(ts_headline_byid_opt,
                                360                 :                :                                         ObjectIdGetDatum(getTSCurrentConfig(true)),
                                361                 :                :                                         PG_GETARG_DATUM(0),
                                362                 :                :                                         PG_GETARG_DATUM(1),
                                363                 :                :                                         PG_GETARG_DATUM(2)));
                                364                 :                : }
                                365                 :                : 
                                366                 :                : Datum
 2571 andrew@dunslane.net       367                 :CBC          21 : ts_headline_jsonb_byid_opt(PG_FUNCTION_ARGS)
                                368                 :                : {
 2524 bruce@momjian.us          369                 :             21 :     Oid         tsconfig = PG_GETARG_OID(0);
 2400 tgl@sss.pgh.pa.us         370                 :             21 :     Jsonb      *jb = PG_GETARG_JSONB_P(1);
 2524 bruce@momjian.us          371                 :             21 :     TSQuery     query = PG_GETARG_TSQUERY(2);
                                372   [ +  +  +  - ]:             21 :     text       *opt = (PG_NARGS() > 3 && PG_GETARG_POINTER(3)) ? PG_GETARG_TEXT_P(3) : NULL;
                                373                 :                :     Jsonb      *out;
 2571 andrew@dunslane.net       374                 :             21 :     JsonTransformStringValuesAction action = (JsonTransformStringValuesAction) headline_json_value;
                                375                 :                :     HeadlineParsedText prs;
                                376                 :             21 :     HeadlineJsonState *state = palloc0(sizeof(HeadlineJsonState));
                                377                 :                : 
                                378                 :             21 :     memset(&prs, 0, sizeof(HeadlineParsedText));
                                379                 :             21 :     prs.lenwords = 32;
                                380                 :             21 :     prs.words = (HeadlineWordEntry *) palloc(sizeof(HeadlineWordEntry) * prs.lenwords);
                                381                 :                : 
                                382                 :             21 :     state->prs = &prs;
 2525 tgl@sss.pgh.pa.us         383                 :             21 :     state->cfg = lookup_ts_config_cache(tsconfig);
 2571 andrew@dunslane.net       384                 :             21 :     state->prsobj = lookup_ts_parser_cache(state->cfg->prsId);
                                385                 :             21 :     state->query = query;
                                386         [ +  + ]:             21 :     if (opt)
                                387                 :              6 :         state->prsoptions = deserialize_deflist(PointerGetDatum(opt));
                                388                 :                :     else
                                389                 :             15 :         state->prsoptions = NIL;
                                390                 :                : 
                                391         [ -  + ]:             21 :     if (!OidIsValid(state->prsobj->headlineOid))
 2571 andrew@dunslane.net       392         [ #  # ]:UBC           0 :         ereport(ERROR,
                                393                 :                :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                394                 :                :                  errmsg("text search parser does not support headline creation")));
                                395                 :                : 
 2571 andrew@dunslane.net       396                 :CBC          21 :     out = transform_jsonb_string_values(jb, state, action);
                                397                 :                : 
                                398         [ -  + ]:             21 :     PG_FREE_IF_COPY(jb, 1);
                                399         [ -  + ]:             21 :     PG_FREE_IF_COPY(query, 2);
                                400         [ +  + ]:             21 :     if (opt)
                                401         [ -  + ]:              6 :         PG_FREE_IF_COPY(opt, 3);
                                402                 :                : 
                                403                 :             21 :     pfree(prs.words);
                                404                 :                : 
                                405         [ +  + ]:             21 :     if (state->transformed)
                                406                 :                :     {
                                407                 :             12 :         pfree(prs.startsel);
                                408                 :             12 :         pfree(prs.stopsel);
                                409                 :                :     }
                                410                 :                : 
 2400 tgl@sss.pgh.pa.us         411                 :             21 :     PG_RETURN_JSONB_P(out);
                                412                 :                : }
                                413                 :                : 
                                414                 :                : Datum
 2571 andrew@dunslane.net       415                 :             12 : ts_headline_jsonb(PG_FUNCTION_ARGS)
                                416                 :                : {
                                417                 :             12 :     PG_RETURN_DATUM(DirectFunctionCall3(ts_headline_jsonb_byid_opt,
                                418                 :                :                                         ObjectIdGetDatum(getTSCurrentConfig(true)),
                                419                 :                :                                         PG_GETARG_DATUM(0),
                                420                 :                :                                         PG_GETARG_DATUM(1)));
                                421                 :                : }
                                422                 :                : 
                                423                 :                : Datum
                                424                 :              3 : ts_headline_jsonb_byid(PG_FUNCTION_ARGS)
                                425                 :                : {
                                426                 :              3 :     PG_RETURN_DATUM(DirectFunctionCall3(ts_headline_jsonb_byid_opt,
                                427                 :                :                                         PG_GETARG_DATUM(0),
                                428                 :                :                                         PG_GETARG_DATUM(1),
                                429                 :                :                                         PG_GETARG_DATUM(2)));
                                430                 :                : }
                                431                 :                : 
                                432                 :                : Datum
                                433                 :              3 : ts_headline_jsonb_opt(PG_FUNCTION_ARGS)
                                434                 :                : {
                                435                 :              3 :     PG_RETURN_DATUM(DirectFunctionCall4(ts_headline_jsonb_byid_opt,
                                436                 :                :                                         ObjectIdGetDatum(getTSCurrentConfig(true)),
                                437                 :                :                                         PG_GETARG_DATUM(0),
                                438                 :                :                                         PG_GETARG_DATUM(1),
                                439                 :                :                                         PG_GETARG_DATUM(2)));
                                440                 :                : }
                                441                 :                : 
                                442                 :                : Datum
                                443                 :             21 : ts_headline_json_byid_opt(PG_FUNCTION_ARGS)
                                444                 :                : {
 2524 bruce@momjian.us          445                 :             21 :     Oid         tsconfig = PG_GETARG_OID(0);
                                446                 :             21 :     text       *json = PG_GETARG_TEXT_P(1);
                                447                 :             21 :     TSQuery     query = PG_GETARG_TSQUERY(2);
                                448   [ +  +  +  - ]:             21 :     text       *opt = (PG_NARGS() > 3 && PG_GETARG_POINTER(3)) ? PG_GETARG_TEXT_P(3) : NULL;
                                449                 :                :     text       *out;
 2571 andrew@dunslane.net       450                 :             21 :     JsonTransformStringValuesAction action = (JsonTransformStringValuesAction) headline_json_value;
                                451                 :                : 
                                452                 :                :     HeadlineParsedText prs;
                                453                 :             21 :     HeadlineJsonState *state = palloc0(sizeof(HeadlineJsonState));
                                454                 :                : 
                                455                 :             21 :     memset(&prs, 0, sizeof(HeadlineParsedText));
                                456                 :             21 :     prs.lenwords = 32;
                                457                 :             21 :     prs.words = (HeadlineWordEntry *) palloc(sizeof(HeadlineWordEntry) * prs.lenwords);
                                458                 :                : 
                                459                 :             21 :     state->prs = &prs;
 2525 tgl@sss.pgh.pa.us         460                 :             21 :     state->cfg = lookup_ts_config_cache(tsconfig);
 2571 andrew@dunslane.net       461                 :             21 :     state->prsobj = lookup_ts_parser_cache(state->cfg->prsId);
                                462                 :             21 :     state->query = query;
                                463         [ +  + ]:             21 :     if (opt)
                                464                 :              6 :         state->prsoptions = deserialize_deflist(PointerGetDatum(opt));
                                465                 :                :     else
                                466                 :             15 :         state->prsoptions = NIL;
                                467                 :                : 
                                468         [ -  + ]:             21 :     if (!OidIsValid(state->prsobj->headlineOid))
 2571 andrew@dunslane.net       469         [ #  # ]:UBC           0 :         ereport(ERROR,
                                470                 :                :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                471                 :                :                  errmsg("text search parser does not support headline creation")));
                                472                 :                : 
 2571 andrew@dunslane.net       473                 :CBC          21 :     out = transform_json_string_values(json, state, action);
                                474                 :                : 
                                475         [ -  + ]:             21 :     PG_FREE_IF_COPY(json, 1);
                                476         [ -  + ]:             21 :     PG_FREE_IF_COPY(query, 2);
                                477         [ +  + ]:             21 :     if (opt)
                                478         [ -  + ]:              6 :         PG_FREE_IF_COPY(opt, 3);
                                479                 :             21 :     pfree(prs.words);
                                480                 :                : 
                                481         [ +  + ]:             21 :     if (state->transformed)
                                482                 :                :     {
                                483                 :             12 :         pfree(prs.startsel);
                                484                 :             12 :         pfree(prs.stopsel);
                                485                 :                :     }
                                486                 :                : 
                                487                 :             21 :     PG_RETURN_TEXT_P(out);
                                488                 :                : }
                                489                 :                : 
                                490                 :                : Datum
                                491                 :             12 : ts_headline_json(PG_FUNCTION_ARGS)
                                492                 :                : {
                                493                 :             12 :     PG_RETURN_DATUM(DirectFunctionCall3(ts_headline_json_byid_opt,
                                494                 :                :                                         ObjectIdGetDatum(getTSCurrentConfig(true)),
                                495                 :                :                                         PG_GETARG_DATUM(0),
                                496                 :                :                                         PG_GETARG_DATUM(1)));
                                497                 :                : }
                                498                 :                : 
                                499                 :                : Datum
                                500                 :              3 : ts_headline_json_byid(PG_FUNCTION_ARGS)
                                501                 :                : {
                                502                 :              3 :     PG_RETURN_DATUM(DirectFunctionCall3(ts_headline_json_byid_opt,
                                503                 :                :                                         PG_GETARG_DATUM(0),
                                504                 :                :                                         PG_GETARG_DATUM(1),
                                505                 :                :                                         PG_GETARG_DATUM(2)));
                                506                 :                : }
                                507                 :                : 
                                508                 :                : Datum
                                509                 :              3 : ts_headline_json_opt(PG_FUNCTION_ARGS)
                                510                 :                : {
                                511                 :              3 :     PG_RETURN_DATUM(DirectFunctionCall4(ts_headline_json_byid_opt,
                                512                 :                :                                         ObjectIdGetDatum(getTSCurrentConfig(true)),
                                513                 :                :                                         PG_GETARG_DATUM(0),
                                514                 :                :                                         PG_GETARG_DATUM(1),
                                515                 :                :                                         PG_GETARG_DATUM(2)));
                                516                 :                : }
                                517                 :                : 
                                518                 :                : 
                                519                 :                : /*
                                520                 :                :  * Return headline in text from, generated from a json(b) element
                                521                 :                :  */
                                522                 :                : static text *
                                523                 :            114 : headline_json_value(void *_state, char *elem_value, int elem_len)
                                524                 :                : {
                                525                 :            114 :     HeadlineJsonState *state = (HeadlineJsonState *) _state;
                                526                 :                : 
                                527                 :            114 :     HeadlineParsedText *prs = state->prs;
                                528                 :            114 :     TSConfigCacheEntry *cfg = state->cfg;
                                529                 :            114 :     TSParserCacheEntry *prsobj = state->prsobj;
 2524 bruce@momjian.us          530                 :            114 :     TSQuery     query = state->query;
                                531                 :            114 :     List       *prsoptions = state->prsoptions;
                                532                 :                : 
 2571 andrew@dunslane.net       533                 :            114 :     prs->curwords = 0;
                                534                 :            114 :     hlparsetext(cfg->cfgId, prs, query, elem_value, elem_len);
                                535                 :            114 :     FunctionCall3(&(prsobj->prsheadline),
                                536                 :                :                   PointerGetDatum(prs),
                                537                 :                :                   PointerGetDatum(prsoptions),
                                538                 :                :                   PointerGetDatum(query));
                                539                 :                : 
                                540                 :            114 :     state->transformed = true;
                                541                 :            114 :     return generateHeadline(prs);
                                542                 :                : }
        

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