LCOV - code coverage report
Current view: top level - src/backend/tsearch - dict_synonym.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 78 90 86.7 %
Date: 2020-06-01 00:06:26 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * dict_synonym.c
       4             :  *      Synonym dictionary: replace word by its synonym
       5             :  *
       6             :  * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
       7             :  *
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *    src/backend/tsearch/dict_synonym.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : #include "postgres.h"
      15             : 
      16             : #include "commands/defrem.h"
      17             : #include "tsearch/ts_locale.h"
      18             : #include "tsearch/ts_utils.h"
      19             : #include "utils/builtins.h"
      20             : 
      21             : typedef struct
      22             : {
      23             :     char       *in;
      24             :     char       *out;
      25             :     int         outlen;
      26             :     uint16      flags;
      27             : } Syn;
      28             : 
      29             : typedef struct
      30             : {
      31             :     int         len;            /* length of syn array */
      32             :     Syn        *syn;
      33             :     bool        case_sensitive;
      34             : } DictSyn;
      35             : 
      36             : /*
      37             :  * Finds the next whitespace-delimited word within the 'in' string.
      38             :  * Returns a pointer to the first character of the word, and a pointer
      39             :  * to the next byte after the last character in the word (in *end).
      40             :  * Character '*' at the end of word will not be treated as word
      41             :  * character if flags is not null.
      42             :  */
      43             : static char *
      44         300 : findwrd(char *in, char **end, uint16 *flags)
      45             : {
      46             :     char       *start;
      47             :     char       *lastchar;
      48             : 
      49             :     /* Skip leading spaces */
      50         300 :     while (*in && t_isspace(in))
      51           0 :         in += pg_mblen(in);
      52             : 
      53             :     /* Return NULL on empty lines */
      54         300 :     if (*in == '\0')
      55             :     {
      56           0 :         *end = NULL;
      57           0 :         return NULL;
      58             :     }
      59             : 
      60         300 :     lastchar = start = in;
      61             : 
      62             :     /* Find end of word */
      63        2190 :     while (*in && !t_isspace(in))
      64             :     {
      65        1890 :         lastchar = in;
      66        1890 :         in += pg_mblen(in);
      67             :     }
      68             : 
      69         300 :     if (in - lastchar == 1 && t_iseq(lastchar, '*') && flags)
      70             :     {
      71          30 :         *flags = TSL_PREFIX;
      72          30 :         *end = lastchar;
      73             :     }
      74             :     else
      75             :     {
      76         270 :         if (flags)
      77         120 :             *flags = 0;
      78         270 :         *end = in;
      79             :     }
      80             : 
      81         300 :     return start;
      82             : }
      83             : 
      84             : static int
      85         876 : compareSyn(const void *a, const void *b)
      86             : {
      87         876 :     return strcmp(((const Syn *) a)->in, ((const Syn *) b)->in);
      88             : }
      89             : 
      90             : 
      91             : Datum
      92          34 : dsynonym_init(PG_FUNCTION_ARGS)
      93             : {
      94          34 :     List       *dictoptions = (List *) PG_GETARG_POINTER(0);
      95             :     DictSyn    *d;
      96             :     ListCell   *l;
      97          34 :     char       *filename = NULL;
      98          34 :     bool        case_sensitive = false;
      99             :     tsearch_readline_state trst;
     100             :     char       *starti,
     101             :                *starto,
     102          34 :                *end = NULL;
     103          34 :     int         cur = 0;
     104          34 :     char       *line = NULL;
     105          34 :     uint16      flags = 0;
     106             : 
     107          90 :     foreach(l, dictoptions)
     108             :     {
     109          60 :         DefElem    *defel = (DefElem *) lfirst(l);
     110             : 
     111          60 :         if (strcmp(defel->defname, "synonyms") == 0)
     112          34 :             filename = defGetString(defel);
     113          26 :         else if (strcmp(defel->defname, "casesensitive") == 0)
     114          26 :             case_sensitive = defGetBoolean(defel);
     115             :         else
     116           0 :             ereport(ERROR,
     117             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     118             :                      errmsg("unrecognized synonym parameter: \"%s\"",
     119             :                             defel->defname)));
     120             :     }
     121             : 
     122          30 :     if (!filename)
     123           0 :         ereport(ERROR,
     124             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     125             :                  errmsg("missing Synonyms parameter")));
     126             : 
     127          30 :     filename = get_tsearch_config_filename(filename, "syn");
     128             : 
     129          30 :     if (!tsearch_readline_begin(&trst, filename))
     130           0 :         ereport(ERROR,
     131             :                 (errcode(ERRCODE_CONFIG_FILE_ERROR),
     132             :                  errmsg("could not open synonym file \"%s\": %m",
     133             :                         filename)));
     134             : 
     135          30 :     d = (DictSyn *) palloc0(sizeof(DictSyn));
     136             : 
     137         180 :     while ((line = tsearch_readline(&trst)) != NULL)
     138             :     {
     139         150 :         starti = findwrd(line, &end, NULL);
     140         150 :         if (!starti)
     141             :         {
     142             :             /* Empty line */
     143           0 :             goto skipline;
     144             :         }
     145         150 :         if (*end == '\0')
     146             :         {
     147             :             /* A line with only one word. Ignore silently. */
     148           0 :             goto skipline;
     149             :         }
     150         150 :         *end = '\0';
     151             : 
     152         150 :         starto = findwrd(end + 1, &end, &flags);
     153         150 :         if (!starto)
     154             :         {
     155             :             /* A line with only one word (+whitespace). Ignore silently. */
     156           0 :             goto skipline;
     157             :         }
     158         150 :         *end = '\0';
     159             : 
     160             :         /*
     161             :          * starti now points to the first word, and starto to the second word
     162             :          * on the line, with a \0 terminator at the end of both words.
     163             :          */
     164             : 
     165         150 :         if (cur >= d->len)
     166             :         {
     167          30 :             if (d->len == 0)
     168             :             {
     169          30 :                 d->len = 64;
     170          30 :                 d->syn = (Syn *) palloc(sizeof(Syn) * d->len);
     171             :             }
     172             :             else
     173             :             {
     174           0 :                 d->len *= 2;
     175           0 :                 d->syn = (Syn *) repalloc(d->syn, sizeof(Syn) * d->len);
     176             :             }
     177             :         }
     178             : 
     179         150 :         if (case_sensitive)
     180             :         {
     181          40 :             d->syn[cur].in = pstrdup(starti);
     182          40 :             d->syn[cur].out = pstrdup(starto);
     183             :         }
     184             :         else
     185             :         {
     186         110 :             d->syn[cur].in = lowerstr(starti);
     187         110 :             d->syn[cur].out = lowerstr(starto);
     188             :         }
     189             : 
     190         150 :         d->syn[cur].outlen = strlen(starto);
     191         150 :         d->syn[cur].flags = flags;
     192             : 
     193         150 :         cur++;
     194             : 
     195         150 : skipline:
     196         150 :         pfree(line);
     197             :     }
     198             : 
     199          30 :     tsearch_readline_end(&trst);
     200             : 
     201          30 :     d->len = cur;
     202          30 :     qsort(d->syn, d->len, sizeof(Syn), compareSyn);
     203             : 
     204          30 :     d->case_sensitive = case_sensitive;
     205             : 
     206          30 :     PG_RETURN_POINTER(d);
     207             : }
     208             : 
     209             : Datum
     210         244 : dsynonym_lexize(PG_FUNCTION_ARGS)
     211             : {
     212         244 :     DictSyn    *d = (DictSyn *) PG_GETARG_POINTER(0);
     213         244 :     char       *in = (char *) PG_GETARG_POINTER(1);
     214         244 :     int32       len = PG_GETARG_INT32(2);
     215             :     Syn         key,
     216             :                *found;
     217             :     TSLexeme   *res;
     218             : 
     219             :     /* note: d->len test protects against Solaris bsearch-of-no-items bug */
     220         244 :     if (len <= 0 || d->len <= 0)
     221           0 :         PG_RETURN_POINTER(NULL);
     222             : 
     223         244 :     if (d->case_sensitive)
     224           4 :         key.in = pnstrdup(in, len);
     225             :     else
     226         240 :         key.in = lowerstr_with_len(in, len);
     227             : 
     228         244 :     key.out = NULL;
     229             : 
     230         244 :     found = (Syn *) bsearch(&key, d->syn, d->len, sizeof(Syn), compareSyn);
     231         244 :     pfree(key.in);
     232             : 
     233         244 :     if (!found)
     234         200 :         PG_RETURN_POINTER(NULL);
     235             : 
     236          44 :     res = palloc0(sizeof(TSLexeme) * 2);
     237          44 :     res[0].lexeme = pnstrdup(found->out, found->outlen);
     238          44 :     res[0].flags = found->flags;
     239             : 
     240          44 :     PG_RETURN_POINTER(res);
     241             : }

Generated by: LCOV version 1.13