LCOV - code coverage report
Current view: top level - src/backend/utils/adt - tsvector.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 168 244 68.9 %
Date: 2020-06-03 10:06:28 Functions: 6 9 66.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * tsvector.c
       4             :  *    I/O functions for tsvector
       5             :  *
       6             :  * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
       7             :  *
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *    src/backend/utils/adt/tsvector.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : 
      15             : #include "postgres.h"
      16             : 
      17             : #include "libpq/pqformat.h"
      18             : #include "tsearch/ts_locale.h"
      19             : #include "tsearch/ts_utils.h"
      20             : #include "utils/builtins.h"
      21             : #include "utils/memutils.h"
      22             : 
      23             : typedef struct
      24             : {
      25             :     WordEntry   entry;          /* must be first! */
      26             :     WordEntryPos *pos;
      27             :     int         poslen;         /* number of elements in pos */
      28             : } WordEntryIN;
      29             : 
      30             : 
      31             : /* Compare two WordEntryPos values for qsort */
      32             : int
      33         684 : compareWordEntryPos(const void *a, const void *b)
      34             : {
      35         684 :     int         apos = WEP_GETPOS(*(const WordEntryPos *) a);
      36         684 :     int         bpos = WEP_GETPOS(*(const WordEntryPos *) b);
      37             : 
      38         684 :     if (apos == bpos)
      39          16 :         return 0;
      40         668 :     return (apos > bpos) ? 1 : -1;
      41             : }
      42             : 
      43             : /*
      44             :  * Removes duplicate pos entries. If there's two entries with same pos but
      45             :  * different weight, the higher weight is retained, so we can't use
      46             :  * qunique here.
      47             :  *
      48             :  * Returns new length.
      49             :  */
      50             : static int
      51        6376 : uniquePos(WordEntryPos *a, int l)
      52             : {
      53             :     WordEntryPos *ptr,
      54             :                *res;
      55             : 
      56        6376 :     if (l <= 1)
      57        6016 :         return l;
      58             : 
      59         360 :     qsort((void *) a, l, sizeof(WordEntryPos), compareWordEntryPos);
      60             : 
      61         360 :     res = a;
      62         360 :     ptr = a + 1;
      63         984 :     while (ptr - a < l)
      64             :     {
      65         624 :         if (WEP_GETPOS(*ptr) != WEP_GETPOS(*res))
      66             :         {
      67         608 :             res++;
      68         608 :             *res = *ptr;
      69         608 :             if (res - a >= MAXNUMPOS - 1 ||
      70         608 :                 WEP_GETPOS(*res) == MAXENTRYPOS - 1)
      71             :                 break;
      72             :         }
      73          16 :         else if (WEP_GETWEIGHT(*ptr) > WEP_GETWEIGHT(*res))
      74           4 :             WEP_SETWEIGHT(*res, WEP_GETWEIGHT(*ptr));
      75         624 :         ptr++;
      76             :     }
      77             : 
      78         360 :     return res + 1 - a;
      79             : }
      80             : 
      81             : /* Compare two WordEntryIN values for qsort */
      82             : static int
      83      714878 : compareentry(const void *va, const void *vb, void *arg)
      84             : {
      85      714878 :     const WordEntryIN *a = (const WordEntryIN *) va;
      86      714878 :     const WordEntryIN *b = (const WordEntryIN *) vb;
      87      714878 :     char       *BufferStr = (char *) arg;
      88             : 
      89     2144634 :     return tsCompareString(&BufferStr[a->entry.pos], a->entry.len,
      90      714878 :                            &BufferStr[b->entry.pos], b->entry.len,
      91             :                            false);
      92             : }
      93             : 
      94             : /*
      95             :  * Sort an array of WordEntryIN, remove duplicates.
      96             :  * *outbuflen receives the amount of space needed for strings and positions.
      97             :  */
      98             : static int
      99        2438 : uniqueentry(WordEntryIN *a, int l, char *buf, int *outbuflen)
     100             : {
     101             :     int         buflen;
     102             :     WordEntryIN *ptr,
     103             :                *res;
     104             : 
     105             :     Assert(l >= 1);
     106             : 
     107        2438 :     if (l > 1)
     108        2406 :         qsort_arg((void *) a, l, sizeof(WordEntryIN), compareentry,
     109             :                   (void *) buf);
     110             : 
     111        2438 :     buflen = 0;
     112        2438 :     res = a;
     113        2438 :     ptr = a + 1;
     114      120494 :     while (ptr - a < l)
     115             :     {
     116      118056 :         if (!(ptr->entry.len == res->entry.len &&
     117      117342 :               strncmp(&buf[ptr->entry.pos], &buf[res->entry.pos],
     118      117342 :                       res->entry.len) == 0))
     119             :         {
     120             :             /* done accumulating data into *res, count space needed */
     121      114384 :             buflen += res->entry.len;
     122      114384 :             if (res->entry.haspos)
     123             :             {
     124        6000 :                 res->poslen = uniquePos(res->pos, res->poslen);
     125        6000 :                 buflen = SHORTALIGN(buflen);
     126        6000 :                 buflen += res->poslen * sizeof(WordEntryPos) + sizeof(uint16);
     127             :             }
     128      114384 :             res++;
     129      173400 :             if (res != ptr)
     130       59016 :                 memcpy(res, ptr, sizeof(WordEntryIN));
     131             :         }
     132        3672 :         else if (ptr->entry.haspos)
     133             :         {
     134         212 :             if (res->entry.haspos)
     135             :             {
     136             :                 /* append ptr's positions to res's positions */
     137         208 :                 int         newlen = ptr->poslen + res->poslen;
     138             : 
     139         208 :                 res->pos = (WordEntryPos *)
     140         208 :                     repalloc(res->pos, newlen * sizeof(WordEntryPos));
     141         208 :                 memcpy(&res->pos[res->poslen], ptr->pos,
     142         208 :                        ptr->poslen * sizeof(WordEntryPos));
     143         208 :                 res->poslen = newlen;
     144         208 :                 pfree(ptr->pos);
     145             :             }
     146             :             else
     147             :             {
     148             :                 /* just give ptr's positions to pos */
     149           4 :                 res->entry.haspos = 1;
     150           4 :                 res->pos = ptr->pos;
     151           4 :                 res->poslen = ptr->poslen;
     152             :             }
     153             :         }
     154      118056 :         ptr++;
     155             :     }
     156             : 
     157             :     /* count space needed for last item */
     158        2438 :     buflen += res->entry.len;
     159        2438 :     if (res->entry.haspos)
     160             :     {
     161         376 :         res->poslen = uniquePos(res->pos, res->poslen);
     162         376 :         buflen = SHORTALIGN(buflen);
     163         376 :         buflen += res->poslen * sizeof(WordEntryPos) + sizeof(uint16);
     164             :     }
     165             : 
     166        2438 :     *outbuflen = buflen;
     167        2438 :     return res + 1 - a;
     168             : }
     169             : 
     170             : static int
     171           0 : WordEntryCMP(WordEntry *a, WordEntry *b, char *buf)
     172             : {
     173           0 :     return compareentry(a, b, buf);
     174             : }
     175             : 
     176             : 
     177             : Datum
     178        2470 : tsvectorin(PG_FUNCTION_ARGS)
     179             : {
     180        2470 :     char       *buf = PG_GETARG_CSTRING(0);
     181             :     TSVectorParseState state;
     182             :     WordEntryIN *arr;
     183             :     int         totallen;
     184             :     int         arrlen;         /* allocated size of arr */
     185             :     WordEntry  *inarr;
     186        2470 :     int         len = 0;
     187             :     TSVector    in;
     188             :     int         i;
     189             :     char       *token;
     190             :     int         toklen;
     191             :     WordEntryPos *pos;
     192             :     int         poslen;
     193             :     char       *strbuf;
     194             :     int         stroff;
     195             : 
     196             :     /*
     197             :      * Tokens are appended to tmpbuf, cur is a pointer to the end of used
     198             :      * space in tmpbuf.
     199             :      */
     200             :     char       *tmpbuf;
     201             :     char       *cur;
     202        2470 :     int         buflen = 256;   /* allocated size of tmpbuf */
     203             : 
     204        2470 :     state = init_tsvector_parser(buf, 0);
     205             : 
     206        2470 :     arrlen = 64;
     207        2470 :     arr = (WordEntryIN *) palloc(sizeof(WordEntryIN) * arrlen);
     208        2470 :     cur = tmpbuf = (char *) palloc(buflen);
     209             : 
     210      122964 :     while (gettoken_tsvector(state, &token, &toklen, &pos, &poslen, NULL))
     211             :     {
     212      120494 :         if (toklen >= MAXSTRLEN)
     213           0 :             ereport(ERROR,
     214             :                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     215             :                      errmsg("word is too long (%ld bytes, max %ld bytes)",
     216             :                             (long) toklen,
     217             :                             (long) (MAXSTRLEN - 1))));
     218             : 
     219      120494 :         if (cur - tmpbuf > MAXSTRPOS)
     220           0 :             ereport(ERROR,
     221             :                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     222             :                      errmsg("string is too long for tsvector (%ld bytes, max %ld bytes)",
     223             :                             (long) (cur - tmpbuf), (long) MAXSTRPOS)));
     224             : 
     225             :         /*
     226             :          * Enlarge buffers if needed
     227             :          */
     228      120494 :         if (len >= arrlen)
     229             :         {
     230         876 :             arrlen *= 2;
     231             :             arr = (WordEntryIN *)
     232         876 :                 repalloc((void *) arr, sizeof(WordEntryIN) * arrlen);
     233             :         }
     234      120494 :         while ((cur - tmpbuf) + toklen >= buflen)
     235             :         {
     236           0 :             int         dist = cur - tmpbuf;
     237             : 
     238           0 :             buflen *= 2;
     239           0 :             tmpbuf = (char *) repalloc((void *) tmpbuf, buflen);
     240           0 :             cur = tmpbuf + dist;
     241             :         }
     242      120494 :         arr[len].entry.len = toklen;
     243      120494 :         arr[len].entry.pos = cur - tmpbuf;
     244      120494 :         memcpy((void *) cur, (void *) token, toklen);
     245      120494 :         cur += toklen;
     246             : 
     247      120494 :         if (poslen != 0)
     248             :         {
     249        6584 :             arr[len].entry.haspos = 1;
     250        6584 :             arr[len].pos = pos;
     251        6584 :             arr[len].poslen = poslen;
     252             :         }
     253             :         else
     254             :         {
     255      113910 :             arr[len].entry.haspos = 0;
     256      113910 :             arr[len].pos = NULL;
     257      113910 :             arr[len].poslen = 0;
     258             :         }
     259      120494 :         len++;
     260             :     }
     261             : 
     262        2470 :     close_tsvector_parser(state);
     263             : 
     264        2470 :     if (len > 0)
     265        2438 :         len = uniqueentry(arr, len, tmpbuf, &buflen);
     266             :     else
     267          32 :         buflen = 0;
     268             : 
     269        2470 :     if (buflen > MAXSTRPOS)
     270           0 :         ereport(ERROR,
     271             :                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     272             :                  errmsg("string is too long for tsvector (%d bytes, max %d bytes)", buflen, MAXSTRPOS)));
     273             : 
     274        2470 :     totallen = CALCDATASIZE(len, buflen);
     275        2470 :     in = (TSVector) palloc0(totallen);
     276        2470 :     SET_VARSIZE(in, totallen);
     277        2470 :     in->size = len;
     278        2470 :     inarr = ARRPTR(in);
     279        2470 :     strbuf = STRPTR(in);
     280        2470 :     stroff = 0;
     281      119292 :     for (i = 0; i < len; i++)
     282             :     {
     283      116822 :         memcpy(strbuf + stroff, &tmpbuf[arr[i].entry.pos], arr[i].entry.len);
     284      116822 :         arr[i].entry.pos = stroff;
     285      116822 :         stroff += arr[i].entry.len;
     286      116822 :         if (arr[i].entry.haspos)
     287             :         {
     288        6376 :             if (arr[i].poslen > 0xFFFF)
     289           0 :                 elog(ERROR, "positions array too long");
     290             : 
     291             :             /* Copy number of positions */
     292        6376 :             stroff = SHORTALIGN(stroff);
     293        6376 :             *(uint16 *) (strbuf + stroff) = (uint16) arr[i].poslen;
     294        6376 :             stroff += sizeof(uint16);
     295             : 
     296             :             /* Copy positions */
     297        6376 :             memcpy(strbuf + stroff, arr[i].pos, arr[i].poslen * sizeof(WordEntryPos));
     298        6376 :             stroff += arr[i].poslen * sizeof(WordEntryPos);
     299             : 
     300        6376 :             pfree(arr[i].pos);
     301             :         }
     302      116822 :         inarr[i] = arr[i].entry;
     303             :     }
     304             : 
     305             :     Assert((strbuf + stroff - (char *) in) == totallen);
     306             : 
     307        2470 :     PG_RETURN_TSVECTOR(in);
     308             : }
     309             : 
     310             : Datum
     311        2480 : tsvectorout(PG_FUNCTION_ARGS)
     312             : {
     313        2480 :     TSVector    out = PG_GETARG_TSVECTOR(0);
     314             :     char       *outbuf;
     315             :     int32       i,
     316        2480 :                 lenbuf = 0,
     317             :                 pp;
     318        2480 :     WordEntry  *ptr = ARRPTR(out);
     319             :     char       *curbegin,
     320             :                *curin,
     321             :                *curout;
     322             : 
     323        2480 :     lenbuf = out->size * 2 /* '' */ + out->size - 1 /* space */ + 2 /* \0 */ ;
     324      119436 :     for (i = 0; i < out->size; i++)
     325             :     {
     326      116956 :         lenbuf += ptr[i].len * 2 * pg_database_encoding_max_length() /* for escape */ ;
     327      116956 :         if (ptr[i].haspos)
     328        6926 :             lenbuf += 1 /* : */ + 7 /* int2 + , + weight */ * POSDATALEN(out, &(ptr[i]));
     329             :     }
     330             : 
     331        2480 :     curout = outbuf = (char *) palloc(lenbuf);
     332      119436 :     for (i = 0; i < out->size; i++)
     333             :     {
     334      116956 :         curbegin = curin = STRPTR(out) + ptr->pos;
     335      116956 :         if (i != 0)
     336      114588 :             *curout++ = ' ';
     337      116956 :         *curout++ = '\'';
     338      355302 :         while (curin - curbegin < ptr->len)
     339             :         {
     340      238346 :             int         len = pg_mblen(curin);
     341             : 
     342      238346 :             if (t_iseq(curin, '\''))
     343          18 :                 *curout++ = '\'';
     344      238328 :             else if (t_iseq(curin, '\\'))
     345          60 :                 *curout++ = '\\';
     346             : 
     347      476692 :             while (len--)
     348      238346 :                 *curout++ = *curin++;
     349             :         }
     350             : 
     351      116956 :         *curout++ = '\'';
     352      116956 :         if ((pp = POSDATALEN(out, ptr)) != 0)
     353             :         {
     354             :             WordEntryPos *wptr;
     355             : 
     356        6926 :             *curout++ = ':';
     357        6926 :             wptr = POSDATAPTR(out, ptr);
     358       14408 :             while (pp)
     359             :             {
     360        7482 :                 curout += sprintf(curout, "%d", WEP_GETPOS(*wptr));
     361        7482 :                 switch (WEP_GETWEIGHT(*wptr))
     362             :                 {
     363          76 :                     case 3:
     364          76 :                         *curout++ = 'A';
     365          76 :                         break;
     366          44 :                     case 2:
     367          44 :                         *curout++ = 'B';
     368          44 :                         break;
     369         152 :                     case 1:
     370         152 :                         *curout++ = 'C';
     371         152 :                         break;
     372        7210 :                     case 0:
     373             :                     default:
     374        7210 :                         break;
     375             :                 }
     376             : 
     377        7482 :                 if (pp > 1)
     378         556 :                     *curout++ = ',';
     379        7482 :                 pp--;
     380        7482 :                 wptr++;
     381             :             }
     382             :         }
     383      116956 :         ptr++;
     384             :     }
     385             : 
     386        2480 :     *curout = '\0';
     387        2480 :     PG_FREE_IF_COPY(out, 0);
     388        2480 :     PG_RETURN_CSTRING(outbuf);
     389             : }
     390             : 
     391             : /*
     392             :  * Binary Input / Output functions. The binary format is as follows:
     393             :  *
     394             :  * uint32   number of lexemes
     395             :  *
     396             :  * for each lexeme:
     397             :  *      lexeme text in client encoding, null-terminated
     398             :  *      uint16  number of positions
     399             :  *      for each position:
     400             :  *          uint16 WordEntryPos
     401             :  */
     402             : 
     403             : Datum
     404           0 : tsvectorsend(PG_FUNCTION_ARGS)
     405             : {
     406           0 :     TSVector    vec = PG_GETARG_TSVECTOR(0);
     407             :     StringInfoData buf;
     408             :     int         i,
     409             :                 j;
     410           0 :     WordEntry  *weptr = ARRPTR(vec);
     411             : 
     412           0 :     pq_begintypsend(&buf);
     413             : 
     414           0 :     pq_sendint32(&buf, vec->size);
     415           0 :     for (i = 0; i < vec->size; i++)
     416             :     {
     417             :         uint16      npos;
     418             : 
     419             :         /*
     420             :          * the strings in the TSVector array are not null-terminated, so we
     421             :          * have to send the null-terminator separately
     422             :          */
     423           0 :         pq_sendtext(&buf, STRPTR(vec) + weptr->pos, weptr->len);
     424           0 :         pq_sendbyte(&buf, '\0');
     425             : 
     426           0 :         npos = POSDATALEN(vec, weptr);
     427           0 :         pq_sendint16(&buf, npos);
     428             : 
     429           0 :         if (npos > 0)
     430             :         {
     431           0 :             WordEntryPos *wepptr = POSDATAPTR(vec, weptr);
     432             : 
     433           0 :             for (j = 0; j < npos; j++)
     434           0 :                 pq_sendint16(&buf, wepptr[j]);
     435             :         }
     436           0 :         weptr++;
     437             :     }
     438             : 
     439           0 :     PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
     440             : }
     441             : 
     442             : Datum
     443           0 : tsvectorrecv(PG_FUNCTION_ARGS)
     444             : {
     445           0 :     StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
     446             :     TSVector    vec;
     447             :     int         i;
     448             :     int32       nentries;
     449             :     int         datalen;        /* number of bytes used in the variable size
     450             :                                  * area after fixed size TSVector header and
     451             :                                  * WordEntries */
     452             :     Size        hdrlen;
     453             :     Size        len;            /* allocated size of vec */
     454           0 :     bool        needSort = false;
     455             : 
     456           0 :     nentries = pq_getmsgint(buf, sizeof(int32));
     457           0 :     if (nentries < 0 || nentries > (MaxAllocSize / sizeof(WordEntry)))
     458           0 :         elog(ERROR, "invalid size of tsvector");
     459             : 
     460           0 :     hdrlen = DATAHDRSIZE + sizeof(WordEntry) * nentries;
     461             : 
     462           0 :     len = hdrlen * 2;           /* times two to make room for lexemes */
     463           0 :     vec = (TSVector) palloc0(len);
     464           0 :     vec->size = nentries;
     465             : 
     466           0 :     datalen = 0;
     467           0 :     for (i = 0; i < nentries; i++)
     468             :     {
     469             :         const char *lexeme;
     470             :         uint16      npos;
     471             :         size_t      lex_len;
     472             : 
     473           0 :         lexeme = pq_getmsgstring(buf);
     474           0 :         npos = (uint16) pq_getmsgint(buf, sizeof(uint16));
     475             : 
     476             :         /* sanity checks */
     477             : 
     478           0 :         lex_len = strlen(lexeme);
     479           0 :         if (lex_len > MAXSTRLEN)
     480           0 :             elog(ERROR, "invalid tsvector: lexeme too long");
     481             : 
     482           0 :         if (datalen > MAXSTRPOS)
     483           0 :             elog(ERROR, "invalid tsvector: maximum total lexeme length exceeded");
     484             : 
     485           0 :         if (npos > MAXNUMPOS)
     486           0 :             elog(ERROR, "unexpected number of tsvector positions");
     487             : 
     488             :         /*
     489             :          * Looks valid. Fill the WordEntry struct, and copy lexeme.
     490             :          *
     491             :          * But make sure the buffer is large enough first.
     492             :          */
     493           0 :         while (hdrlen + SHORTALIGN(datalen + lex_len) +
     494           0 :                (npos + 1) * sizeof(WordEntryPos) >= len)
     495             :         {
     496           0 :             len *= 2;
     497           0 :             vec = (TSVector) repalloc(vec, len);
     498             :         }
     499             : 
     500           0 :         vec->entries[i].haspos = (npos > 0) ? 1 : 0;
     501           0 :         vec->entries[i].len = lex_len;
     502           0 :         vec->entries[i].pos = datalen;
     503             : 
     504           0 :         memcpy(STRPTR(vec) + datalen, lexeme, lex_len);
     505             : 
     506           0 :         datalen += lex_len;
     507             : 
     508           0 :         if (i > 0 && WordEntryCMP(&vec->entries[i],
     509           0 :                                   &vec->entries[i - 1],
     510           0 :                                   STRPTR(vec)) <= 0)
     511           0 :             needSort = true;
     512             : 
     513             :         /* Receive positions */
     514           0 :         if (npos > 0)
     515             :         {
     516             :             uint16      j;
     517             :             WordEntryPos *wepptr;
     518             : 
     519             :             /*
     520             :              * Pad to 2-byte alignment if necessary. Though we used palloc0
     521             :              * for the initial allocation, subsequent repalloc'd memory areas
     522             :              * are not initialized to zero.
     523             :              */
     524           0 :             if (datalen != SHORTALIGN(datalen))
     525             :             {
     526           0 :                 *(STRPTR(vec) + datalen) = '\0';
     527           0 :                 datalen = SHORTALIGN(datalen);
     528             :             }
     529             : 
     530           0 :             memcpy(STRPTR(vec) + datalen, &npos, sizeof(uint16));
     531             : 
     532           0 :             wepptr = POSDATAPTR(vec, &vec->entries[i]);
     533           0 :             for (j = 0; j < npos; j++)
     534             :             {
     535           0 :                 wepptr[j] = (WordEntryPos) pq_getmsgint(buf, sizeof(WordEntryPos));
     536           0 :                 if (j > 0 && WEP_GETPOS(wepptr[j]) <= WEP_GETPOS(wepptr[j - 1]))
     537           0 :                     elog(ERROR, "position information is misordered");
     538             :             }
     539             : 
     540           0 :             datalen += (npos + 1) * sizeof(WordEntry);
     541             :         }
     542             :     }
     543             : 
     544           0 :     SET_VARSIZE(vec, hdrlen + datalen);
     545             : 
     546           0 :     if (needSort)
     547           0 :         qsort_arg((void *) ARRPTR(vec), vec->size, sizeof(WordEntry),
     548           0 :                   compareentry, (void *) STRPTR(vec));
     549             : 
     550           0 :     PG_RETURN_TSVECTOR(vec);
     551             : }

Generated by: LCOV version 1.13