LCOV - code coverage report
Current view: top level - src/backend/utils/adt - tsrank.c (source / functions) Hit Total Coverage
Test: PostgreSQL 14devel Lines: 322 434 74.2 %
Date: 2021-01-26 02:06:48 Functions: 17 24 70.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * tsrank.c
       4             :  *      rank tsvector by tsquery
       5             :  *
       6             :  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
       7             :  *
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *    src/backend/utils/adt/tsrank.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : #include "postgres.h"
      15             : 
      16             : #include <limits.h>
      17             : #include <math.h>
      18             : 
      19             : #include "miscadmin.h"
      20             : #include "tsearch/ts_utils.h"
      21             : #include "utils/array.h"
      22             : #include "utils/builtins.h"
      23             : 
      24             : static const float weights[] = {0.1f, 0.2f, 0.4f, 1.0f};
      25             : 
      26             : #define wpos(wep)   ( w[ WEP_GETWEIGHT(wep) ] )
      27             : 
      28             : #define RANK_NO_NORM            0x00
      29             : #define RANK_NORM_LOGLENGTH     0x01
      30             : #define RANK_NORM_LENGTH        0x02
      31             : #define RANK_NORM_EXTDIST       0x04
      32             : #define RANK_NORM_UNIQ          0x08
      33             : #define RANK_NORM_LOGUNIQ       0x10
      34             : #define RANK_NORM_RDIVRPLUS1    0x20
      35             : #define DEF_NORM_METHOD         RANK_NO_NORM
      36             : 
      37             : static float calc_rank_or(const float *w, TSVector t, TSQuery q);
      38             : static float calc_rank_and(const float *w, TSVector t, TSQuery q);
      39             : 
      40             : /*
      41             :  * Returns a weight of a word collocation
      42             :  */
      43             : static float4
      44          12 : word_distance(int32 w)
      45             : {
      46          12 :     if (w > 100)
      47           0 :         return 1e-30f;
      48             : 
      49          12 :     return 1.0 / (1.005 + 0.05 * exp(((float4) w) / 1.5 - 2));
      50             : }
      51             : 
      52             : static int
      53           0 : cnt_length(TSVector t)
      54             : {
      55           0 :     WordEntry  *ptr = ARRPTR(t),
      56           0 :                *end = (WordEntry *) STRPTR(t);
      57           0 :     int         len = 0;
      58             : 
      59           0 :     while (ptr < end)
      60             :     {
      61           0 :         int         clen = POSDATALEN(t, ptr);
      62             : 
      63           0 :         if (clen == 0)
      64           0 :             len += 1;
      65             :         else
      66           0 :             len += clen;
      67             : 
      68           0 :         ptr++;
      69             :     }
      70             : 
      71           0 :     return len;
      72             : }
      73             : 
      74             : 
      75             : #define WordECompareQueryItem(e,q,p,i,m) \
      76             :     tsCompareString((q) + (i)->distance, (i)->length, \
      77             :                     (e) + (p)->pos, (p)->len, (m))
      78             : 
      79             : 
      80             : /*
      81             :  * Returns a pointer to a WordEntry's array corresponding to 'item' from
      82             :  * tsvector 't'. 'q' is the TSQuery containing 'item'.
      83             :  * Returns NULL if not found.
      84             :  */
      85             : static WordEntry *
      86         284 : find_wordentry(TSVector t, TSQuery q, QueryOperand *item, int32 *nitem)
      87             : {
      88         284 :     WordEntry  *StopLow = ARRPTR(t);
      89         284 :     WordEntry  *StopHigh = (WordEntry *) STRPTR(t);
      90         284 :     WordEntry  *StopMiddle = StopHigh;
      91             :     int         difference;
      92             : 
      93         284 :     *nitem = 0;
      94             : 
      95             :     /* Loop invariant: StopLow <= item < StopHigh */
      96         764 :     while (StopLow < StopHigh)
      97             :     {
      98         732 :         StopMiddle = StopLow + (StopHigh - StopLow) / 2;
      99         732 :         difference = WordECompareQueryItem(STRPTR(t), GETOPERAND(q), StopMiddle, item, false);
     100         732 :         if (difference == 0)
     101             :         {
     102         252 :             StopHigh = StopMiddle;
     103         252 :             *nitem = 1;
     104         252 :             break;
     105             :         }
     106         480 :         else if (difference > 0)
     107         168 :             StopLow = StopMiddle + 1;
     108             :         else
     109         312 :             StopHigh = StopMiddle;
     110             :     }
     111             : 
     112         284 :     if (item->prefix)
     113             :     {
     114          36 :         if (StopLow >= StopHigh)
     115          36 :             StopMiddle = StopHigh;
     116             : 
     117          36 :         *nitem = 0;
     118             : 
     119         148 :         while (StopMiddle < (WordEntry *) STRPTR(t) &&
     120          56 :                WordECompareQueryItem(STRPTR(t), GETOPERAND(q), StopMiddle, item, true) == 0)
     121             :         {
     122          56 :             (*nitem)++;
     123          56 :             StopMiddle++;
     124             :         }
     125             :     }
     126             : 
     127         284 :     return (*nitem > 0) ? StopHigh : NULL;
     128             : }
     129             : 
     130             : 
     131             : /*
     132             :  * sort QueryOperands by (length, word)
     133             :  */
     134             : static int
     135          72 : compareQueryOperand(const void *a, const void *b, void *arg)
     136             : {
     137          72 :     char       *operand = (char *) arg;
     138          72 :     QueryOperand *qa = (*(QueryOperand *const *) a);
     139          72 :     QueryOperand *qb = (*(QueryOperand *const *) b);
     140             : 
     141         216 :     return tsCompareString(operand + qa->distance, qa->length,
     142          72 :                            operand + qb->distance, qb->length,
     143             :                            false);
     144             : }
     145             : 
     146             : /*
     147             :  * Returns a sorted, de-duplicated array of QueryOperands in a query.
     148             :  * The returned QueryOperands are pointers to the original QueryOperands
     149             :  * in the query.
     150             :  *
     151             :  * Length of the returned array is stored in *size
     152             :  */
     153             : static QueryOperand **
     154          36 : SortAndUniqItems(TSQuery q, int *size)
     155             : {
     156          36 :     char       *operand = GETOPERAND(q);
     157          36 :     QueryItem  *item = GETQUERY(q);
     158             :     QueryOperand **res,
     159             :               **ptr,
     160             :               **prevptr;
     161             : 
     162          36 :     ptr = res = (QueryOperand **) palloc(sizeof(QueryOperand *) * *size);
     163             : 
     164             :     /* Collect all operands from the tree to res */
     165         144 :     while ((*size)--)
     166             :     {
     167         108 :         if (item->type == QI_VAL)
     168             :         {
     169          72 :             *ptr = (QueryOperand *) item;
     170          72 :             ptr++;
     171             :         }
     172         108 :         item++;
     173             :     }
     174             : 
     175          36 :     *size = ptr - res;
     176          36 :     if (*size < 2)
     177           0 :         return res;
     178             : 
     179          36 :     qsort_arg(res, *size, sizeof(QueryOperand *), compareQueryOperand, (void *) operand);
     180             : 
     181          36 :     ptr = res + 1;
     182          36 :     prevptr = res;
     183             : 
     184             :     /* remove duplicates */
     185          72 :     while (ptr - res < *size)
     186             :     {
     187          36 :         if (compareQueryOperand((void *) ptr, (void *) prevptr, (void *) operand) != 0)
     188             :         {
     189          36 :             prevptr++;
     190          36 :             *prevptr = *ptr;
     191             :         }
     192          36 :         ptr++;
     193             :     }
     194             : 
     195          36 :     *size = prevptr + 1 - res;
     196          36 :     return res;
     197             : }
     198             : 
     199             : static float
     200          12 : calc_rank_and(const float *w, TSVector t, TSQuery q)
     201             : {
     202             :     WordEntryPosVector **pos;
     203             :     WordEntryPosVector1 posnull;
     204             :     WordEntryPosVector *POSNULL;
     205             :     int         i,
     206             :                 k,
     207             :                 l,
     208             :                 p;
     209             :     WordEntry  *entry,
     210             :                *firstentry;
     211             :     WordEntryPos *post,
     212             :                *ct;
     213             :     int32       dimt,
     214             :                 lenct,
     215             :                 dist,
     216             :                 nitem;
     217          12 :     float       res = -1.0;
     218             :     QueryOperand **item;
     219          12 :     int         size = q->size;
     220             : 
     221          12 :     item = SortAndUniqItems(q, &size);
     222          12 :     if (size < 2)
     223             :     {
     224           0 :         pfree(item);
     225           0 :         return calc_rank_or(w, t, q);
     226             :     }
     227          12 :     pos = (WordEntryPosVector **) palloc0(sizeof(WordEntryPosVector *) * q->size);
     228             : 
     229             :     /* A dummy WordEntryPos array to use when haspos is false */
     230          12 :     posnull.npos = 1;
     231          12 :     posnull.pos[0] = 0;
     232          12 :     WEP_SETPOS(posnull.pos[0], MAXENTRYPOS - 1);
     233          12 :     POSNULL = (WordEntryPosVector *) &posnull;
     234             : 
     235          36 :     for (i = 0; i < size; i++)
     236             :     {
     237          24 :         firstentry = entry = find_wordentry(t, q, item[i], &nitem);
     238          24 :         if (!entry)
     239           0 :             continue;
     240             : 
     241          48 :         while (entry - firstentry < nitem)
     242             :         {
     243          24 :             if (entry->haspos)
     244          24 :                 pos[i] = _POSVECPTR(t, entry);
     245             :             else
     246           0 :                 pos[i] = POSNULL;
     247             : 
     248          24 :             dimt = pos[i]->npos;
     249          24 :             post = pos[i]->pos;
     250          36 :             for (k = 0; k < i; k++)
     251             :             {
     252          12 :                 if (!pos[k])
     253           0 :                     continue;
     254          12 :                 lenct = pos[k]->npos;
     255          12 :                 ct = pos[k]->pos;
     256          24 :                 for (l = 0; l < dimt; l++)
     257             :                 {
     258          24 :                     for (p = 0; p < lenct; p++)
     259             :                     {
     260          12 :                         dist = Abs((int) WEP_GETPOS(post[l]) - (int) WEP_GETPOS(ct[p]));
     261          12 :                         if (dist || (dist == 0 && (pos[i] == POSNULL || pos[k] == POSNULL)))
     262             :                         {
     263             :                             float       curw;
     264             : 
     265          12 :                             if (!dist)
     266           0 :                                 dist = MAXENTRYPOS;
     267          12 :                             curw = sqrt(wpos(post[l]) * wpos(ct[p]) * word_distance(dist));
     268          12 :                             res = (res < 0) ? curw : 1.0 - (1.0 - res) * (1.0 - curw);
     269             :                         }
     270             :                     }
     271             :                 }
     272             :             }
     273             : 
     274          24 :             entry++;
     275             :         }
     276             :     }
     277          12 :     pfree(pos);
     278          12 :     pfree(item);
     279          12 :     return res;
     280             : }
     281             : 
     282             : static float
     283          24 : calc_rank_or(const float *w, TSVector t, TSQuery q)
     284             : {
     285             :     WordEntry  *entry,
     286             :                *firstentry;
     287             :     WordEntryPosVector1 posnull;
     288             :     WordEntryPos *post;
     289             :     int32       dimt,
     290             :                 j,
     291             :                 i,
     292             :                 nitem;
     293          24 :     float       res = 0.0;
     294             :     QueryOperand **item;
     295          24 :     int         size = q->size;
     296             : 
     297             :     /* A dummy WordEntryPos array to use when haspos is false */
     298          24 :     posnull.npos = 1;
     299          24 :     posnull.pos[0] = 0;
     300             : 
     301          24 :     item = SortAndUniqItems(q, &size);
     302             : 
     303          72 :     for (i = 0; i < size; i++)
     304             :     {
     305             :         float       resj,
     306             :                     wjm;
     307             :         int32       jm;
     308             : 
     309          48 :         firstentry = entry = find_wordentry(t, q, item[i], &nitem);
     310          48 :         if (!entry)
     311           4 :             continue;
     312             : 
     313          88 :         while (entry - firstentry < nitem)
     314             :         {
     315          44 :             if (entry->haspos)
     316             :             {
     317          44 :                 dimt = POSDATALEN(t, entry);
     318          44 :                 post = POSDATAPTR(t, entry);
     319             :             }
     320             :             else
     321             :             {
     322           0 :                 dimt = posnull.npos;
     323           0 :                 post = posnull.pos;
     324             :             }
     325             : 
     326          44 :             resj = 0.0;
     327          44 :             wjm = -1.0;
     328          44 :             jm = 0;
     329          88 :             for (j = 0; j < dimt; j++)
     330             :             {
     331          44 :                 resj = resj + wpos(post[j]) / ((j + 1) * (j + 1));
     332          44 :                 if (wpos(post[j]) > wjm)
     333             :                 {
     334          44 :                     wjm = wpos(post[j]);
     335          44 :                     jm = j;
     336             :                 }
     337             :             }
     338             : /*
     339             :             limit (sum(1/i^2),i=1,inf) = pi^2/6
     340             :             resj = sum(wi/i^2),i=1,noccurence,
     341             :             wi - should be sorted desc,
     342             :             don't sort for now, just choose maximum weight. This should be corrected
     343             :             Oleg Bartunov
     344             : */
     345          44 :             res = res + (wjm + resj - wjm / ((jm + 1) * (jm + 1))) / 1.64493406685;
     346             : 
     347          44 :             entry++;
     348             :         }
     349             :     }
     350          24 :     if (size > 0)
     351          24 :         res = res / size;
     352          24 :     pfree(item);
     353          24 :     return res;
     354             : }
     355             : 
     356             : static float
     357          36 : calc_rank(const float *w, TSVector t, TSQuery q, int32 method)
     358             : {
     359          36 :     QueryItem  *item = GETQUERY(q);
     360          36 :     float       res = 0.0;
     361             :     int         len;
     362             : 
     363          36 :     if (!t->size || !q->size)
     364           0 :         return 0.0;
     365             : 
     366             :     /* XXX: What about NOT? */
     367          36 :     res = (item->type == QI_OPR && (item->qoperator.oper == OP_AND ||
     368          24 :                                     item->qoperator.oper == OP_PHRASE)) ?
     369          48 :         calc_rank_and(w, t, q) :
     370          24 :         calc_rank_or(w, t, q);
     371             : 
     372          36 :     if (res < 0)
     373           0 :         res = 1e-20f;
     374             : 
     375          36 :     if ((method & RANK_NORM_LOGLENGTH) && t->size > 0)
     376           0 :         res /= log((double) (cnt_length(t) + 1)) / log(2.0);
     377             : 
     378          36 :     if (method & RANK_NORM_LENGTH)
     379             :     {
     380           0 :         len = cnt_length(t);
     381           0 :         if (len > 0)
     382           0 :             res /= (float) len;
     383             :     }
     384             : 
     385             :     /* RANK_NORM_EXTDIST not applicable */
     386             : 
     387          36 :     if ((method & RANK_NORM_UNIQ) && t->size > 0)
     388           0 :         res /= (float) (t->size);
     389             : 
     390          36 :     if ((method & RANK_NORM_LOGUNIQ) && t->size > 0)
     391           0 :         res /= log((double) (t->size + 1)) / log(2.0);
     392             : 
     393          36 :     if (method & RANK_NORM_RDIVRPLUS1)
     394           0 :         res /= (res + 1);
     395             : 
     396          36 :     return res;
     397             : }
     398             : 
     399             : static const float *
     400         140 : getWeights(ArrayType *win)
     401             : {
     402             :     static float ws[lengthof(weights)];
     403             :     int         i;
     404             :     float4     *arrdata;
     405             : 
     406         140 :     if (win == NULL)
     407         140 :         return weights;
     408             : 
     409           0 :     if (ARR_NDIM(win) != 1)
     410           0 :         ereport(ERROR,
     411             :                 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     412             :                  errmsg("array of weight must be one-dimensional")));
     413             : 
     414           0 :     if (ArrayGetNItems(ARR_NDIM(win), ARR_DIMS(win)) < lengthof(weights))
     415           0 :         ereport(ERROR,
     416             :                 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     417             :                  errmsg("array of weight is too short")));
     418             : 
     419           0 :     if (array_contains_nulls(win))
     420           0 :         ereport(ERROR,
     421             :                 (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
     422             :                  errmsg("array of weight must not contain nulls")));
     423             : 
     424           0 :     arrdata = (float4 *) ARR_DATA_PTR(win);
     425           0 :     for (i = 0; i < lengthof(weights); i++)
     426             :     {
     427           0 :         ws[i] = (arrdata[i] >= 0) ? arrdata[i] : weights[i];
     428           0 :         if (ws[i] > 1.0)
     429           0 :             ereport(ERROR,
     430             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     431             :                      errmsg("weight out of range")));
     432             :     }
     433             : 
     434           0 :     return ws;
     435             : }
     436             : 
     437             : Datum
     438           0 : ts_rank_wttf(PG_FUNCTION_ARGS)
     439             : {
     440           0 :     ArrayType  *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
     441           0 :     TSVector    txt = PG_GETARG_TSVECTOR(1);
     442           0 :     TSQuery     query = PG_GETARG_TSQUERY(2);
     443           0 :     int         method = PG_GETARG_INT32(3);
     444             :     float       res;
     445             : 
     446           0 :     res = calc_rank(getWeights(win), txt, query, method);
     447             : 
     448           0 :     PG_FREE_IF_COPY(win, 0);
     449           0 :     PG_FREE_IF_COPY(txt, 1);
     450           0 :     PG_FREE_IF_COPY(query, 2);
     451           0 :     PG_RETURN_FLOAT4(res);
     452             : }
     453             : 
     454             : Datum
     455           0 : ts_rank_wtt(PG_FUNCTION_ARGS)
     456             : {
     457           0 :     ArrayType  *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
     458           0 :     TSVector    txt = PG_GETARG_TSVECTOR(1);
     459           0 :     TSQuery     query = PG_GETARG_TSQUERY(2);
     460             :     float       res;
     461             : 
     462           0 :     res = calc_rank(getWeights(win), txt, query, DEF_NORM_METHOD);
     463             : 
     464           0 :     PG_FREE_IF_COPY(win, 0);
     465           0 :     PG_FREE_IF_COPY(txt, 1);
     466           0 :     PG_FREE_IF_COPY(query, 2);
     467           0 :     PG_RETURN_FLOAT4(res);
     468             : }
     469             : 
     470             : Datum
     471           0 : ts_rank_ttf(PG_FUNCTION_ARGS)
     472             : {
     473           0 :     TSVector    txt = PG_GETARG_TSVECTOR(0);
     474           0 :     TSQuery     query = PG_GETARG_TSQUERY(1);
     475           0 :     int         method = PG_GETARG_INT32(2);
     476             :     float       res;
     477             : 
     478           0 :     res = calc_rank(getWeights(NULL), txt, query, method);
     479             : 
     480           0 :     PG_FREE_IF_COPY(txt, 0);
     481           0 :     PG_FREE_IF_COPY(query, 1);
     482           0 :     PG_RETURN_FLOAT4(res);
     483             : }
     484             : 
     485             : Datum
     486          36 : ts_rank_tt(PG_FUNCTION_ARGS)
     487             : {
     488          36 :     TSVector    txt = PG_GETARG_TSVECTOR(0);
     489          36 :     TSQuery     query = PG_GETARG_TSQUERY(1);
     490             :     float       res;
     491             : 
     492          36 :     res = calc_rank(getWeights(NULL), txt, query, DEF_NORM_METHOD);
     493             : 
     494          36 :     PG_FREE_IF_COPY(txt, 0);
     495          36 :     PG_FREE_IF_COPY(query, 1);
     496          36 :     PG_RETURN_FLOAT4(res);
     497             : }
     498             : 
     499             : typedef struct
     500             : {
     501             :     union
     502             :     {
     503             :         struct
     504             :         {                       /* compiled doc representation */
     505             :             QueryItem **items;
     506             :             int16       nitem;
     507             :         }           query;
     508             :         struct
     509             :         {                       /* struct is used for preparing doc
     510             :                                  * representation */
     511             :             QueryItem  *item;
     512             :             WordEntry  *entry;
     513             :         }           map;
     514             :     }           data;
     515             :     WordEntryPos pos;
     516             : } DocRepresentation;
     517             : 
     518             : static int
     519         232 : compareDocR(const void *va, const void *vb)
     520             : {
     521         232 :     const DocRepresentation *a = (const DocRepresentation *) va;
     522         232 :     const DocRepresentation *b = (const DocRepresentation *) vb;
     523             : 
     524         232 :     if (WEP_GETPOS(a->pos) == WEP_GETPOS(b->pos))
     525             :     {
     526          24 :         if (WEP_GETWEIGHT(a->pos) == WEP_GETWEIGHT(b->pos))
     527             :         {
     528           4 :             if (a->data.map.entry == b->data.map.entry)
     529           4 :                 return 0;
     530             : 
     531           0 :             return (a->data.map.entry > b->data.map.entry) ? 1 : -1;
     532             :         }
     533             : 
     534          20 :         return (WEP_GETWEIGHT(a->pos) > WEP_GETWEIGHT(b->pos)) ? 1 : -1;
     535             :     }
     536             : 
     537         208 :     return (WEP_GETPOS(a->pos) > WEP_GETPOS(b->pos)) ? 1 : -1;
     538             : }
     539             : 
     540             : #define MAXQROPOS   MAXENTRYPOS
     541             : typedef struct
     542             : {
     543             :     bool        operandexists;
     544             :     bool        reverseinsert;  /* indicates insert order, true means
     545             :                                  * descending order */
     546             :     uint32      npos;
     547             :     WordEntryPos pos[MAXQROPOS];
     548             : } QueryRepresentationOperand;
     549             : 
     550             : typedef struct
     551             : {
     552             :     TSQuery     query;
     553             :     QueryRepresentationOperand *operandData;
     554             : } QueryRepresentation;
     555             : 
     556             : #define QR_GET_OPERAND_DATA(q, v) \
     557             :     ( (q)->operandData + (((QueryItem*)(v)) - GETQUERY((q)->query)) )
     558             : 
     559             : /*
     560             :  * TS_execute callback for matching a tsquery operand to QueryRepresentation
     561             :  */
     562             : static TSTernaryValue
     563         772 : checkcondition_QueryOperand(void *checkval, QueryOperand *val,
     564             :                             ExecPhraseData *data)
     565             : {
     566         772 :     QueryRepresentation *qr = (QueryRepresentation *) checkval;
     567         772 :     QueryRepresentationOperand *opData = QR_GET_OPERAND_DATA(qr, val);
     568             : 
     569         772 :     if (!opData->operandexists)
     570         296 :         return TS_NO;
     571             : 
     572         476 :     if (data)
     573             :     {
     574         232 :         data->npos = opData->npos;
     575         232 :         data->pos = opData->pos;
     576         232 :         if (opData->reverseinsert)
     577          72 :             data->pos += MAXQROPOS - opData->npos;
     578             :     }
     579             : 
     580         476 :     return TS_YES;
     581             : }
     582             : 
     583             : typedef struct
     584             : {
     585             :     int         pos;
     586             :     int         p;
     587             :     int         q;
     588             :     DocRepresentation *begin;
     589             :     DocRepresentation *end;
     590             : } CoverExt;
     591             : 
     592             : static void
     593         332 : resetQueryRepresentation(QueryRepresentation *qr, bool reverseinsert)
     594             : {
     595             :     int         i;
     596             : 
     597        1344 :     for (i = 0; i < qr->query->size; i++)
     598             :     {
     599        1012 :         qr->operandData[i].operandexists = false;
     600        1012 :         qr->operandData[i].reverseinsert = reverseinsert;
     601        1012 :         qr->operandData[i].npos = 0;
     602             :     }
     603         332 : }
     604             : 
     605             : static void
     606         480 : fillQueryRepresentationData(QueryRepresentation *qr, DocRepresentation *entry)
     607             : {
     608             :     int         i;
     609             :     int         lastPos;
     610             :     QueryRepresentationOperand *opData;
     611             : 
     612         964 :     for (i = 0; i < entry->data.query.nitem; i++)
     613             :     {
     614         484 :         if (entry->data.query.items[i]->type != QI_VAL)
     615           0 :             continue;
     616             : 
     617         484 :         opData = QR_GET_OPERAND_DATA(qr, entry->data.query.items[i]);
     618             : 
     619         484 :         opData->operandexists = true;
     620             : 
     621         484 :         if (opData->npos == 0)
     622             :         {
     623         440 :             lastPos = (opData->reverseinsert) ? (MAXQROPOS - 1) : 0;
     624         440 :             opData->pos[lastPos] = entry->pos;
     625         440 :             opData->npos++;
     626         440 :             continue;
     627             :         }
     628             : 
     629          88 :         lastPos = opData->reverseinsert ?
     630          44 :             (MAXQROPOS - opData->npos) :
     631          44 :             (opData->npos - 1);
     632             : 
     633          44 :         if (WEP_GETPOS(opData->pos[lastPos]) != WEP_GETPOS(entry->pos))
     634             :         {
     635          56 :             lastPos = opData->reverseinsert ?
     636          28 :                 (MAXQROPOS - 1 - opData->npos) :
     637          28 :                 (opData->npos);
     638             : 
     639          28 :             opData->pos[lastPos] = entry->pos;
     640          28 :             opData->npos++;
     641             :         }
     642             :     }
     643         480 : }
     644             : 
     645             : static bool
     646         216 : Cover(DocRepresentation *doc, int len, QueryRepresentation *qr, CoverExt *ext)
     647             : {
     648             :     DocRepresentation *ptr;
     649         216 :     int         lastpos = ext->pos;
     650         216 :     bool        found = false;
     651             : 
     652             :     /*
     653             :      * since this function recurses, it could be driven to stack overflow.
     654             :      * (though any decent compiler will optimize away the tail-recursion.
     655             :      */
     656         216 :     check_stack_depth();
     657             : 
     658         216 :     resetQueryRepresentation(qr, false);
     659             : 
     660         216 :     ext->p = INT_MAX;
     661         216 :     ext->q = 0;
     662         216 :     ptr = doc + ext->pos;
     663             : 
     664             :     /* find upper bound of cover from current position, move up */
     665         404 :     while (ptr - doc < len)
     666             :     {
     667         304 :         fillQueryRepresentationData(qr, ptr);
     668             : 
     669         304 :         if (TS_execute(GETQUERY(qr->query), (void *) qr,
     670             :                        TS_EXEC_EMPTY, checkcondition_QueryOperand))
     671             :         {
     672         116 :             if (WEP_GETPOS(ptr->pos) > ext->q)
     673             :             {
     674         116 :                 ext->q = WEP_GETPOS(ptr->pos);
     675         116 :                 ext->end = ptr;
     676         116 :                 lastpos = ptr - doc;
     677         116 :                 found = true;
     678             :             }
     679         116 :             break;
     680             :         }
     681         188 :         ptr++;
     682             :     }
     683             : 
     684         216 :     if (!found)
     685         100 :         return false;
     686             : 
     687         116 :     resetQueryRepresentation(qr, true);
     688             : 
     689         116 :     ptr = doc + lastpos;
     690             : 
     691             :     /* find lower bound of cover from found upper bound, move down */
     692         176 :     while (ptr >= doc + ext->pos)
     693             :     {
     694             :         /*
     695             :          * we scan doc from right to left, so pos info in reverse order!
     696             :          */
     697         176 :         fillQueryRepresentationData(qr, ptr);
     698             : 
     699         176 :         if (TS_execute(GETQUERY(qr->query), (void *) qr,
     700             :                        TS_EXEC_EMPTY, checkcondition_QueryOperand))
     701             :         {
     702         116 :             if (WEP_GETPOS(ptr->pos) < ext->p)
     703             :             {
     704         116 :                 ext->begin = ptr;
     705         116 :                 ext->p = WEP_GETPOS(ptr->pos);
     706             :             }
     707         116 :             break;
     708             :         }
     709          60 :         ptr--;
     710             :     }
     711             : 
     712         116 :     if (ext->p <= ext->q)
     713             :     {
     714             :         /*
     715             :          * set position for next try to next lexeme after beginning of found
     716             :          * cover
     717             :          */
     718         116 :         ext->pos = (ptr - doc) + 1;
     719         116 :         return true;
     720             :     }
     721             : 
     722           0 :     ext->pos++;
     723           0 :     return Cover(doc, len, qr, ext);
     724             : }
     725             : 
     726             : static DocRepresentation *
     727         104 : get_docrep(TSVector txt, QueryRepresentation *qr, int *doclen)
     728             : {
     729         104 :     QueryItem  *item = GETQUERY(qr->query);
     730             :     WordEntry  *entry,
     731             :                *firstentry;
     732             :     WordEntryPos *post;
     733             :     int32       dimt,           /* number of 'post' items */
     734             :                 j,
     735             :                 i,
     736             :                 nitem;
     737         104 :     int         len = qr->query->size * 4,
     738         104 :                 cur = 0;
     739             :     DocRepresentation *doc;
     740             : 
     741         104 :     doc = (DocRepresentation *) palloc(sizeof(DocRepresentation) * len);
     742             : 
     743             :     /*
     744             :      * Iterate through query to make DocRepresentation for words and it's
     745             :      * entries satisfied by query
     746             :      */
     747         424 :     for (i = 0; i < qr->query->size; i++)
     748             :     {
     749             :         QueryOperand *curoperand;
     750             : 
     751         320 :         if (item[i].type != QI_VAL)
     752         108 :             continue;
     753             : 
     754         212 :         curoperand = &item[i].qoperand;
     755             : 
     756         212 :         firstentry = entry = find_wordentry(txt, qr->query, curoperand, &nitem);
     757         212 :         if (!entry)
     758           4 :             continue;
     759             : 
     760             :         /* iterations over entries in tsvector */
     761         436 :         while (entry - firstentry < nitem)
     762             :         {
     763         228 :             if (entry->haspos)
     764             :             {
     765         220 :                 dimt = POSDATALEN(txt, entry);
     766         220 :                 post = POSDATAPTR(txt, entry);
     767             :             }
     768             :             else
     769             :             {
     770             :                 /* ignore words without positions */
     771           8 :                 entry++;
     772           8 :                 continue;
     773             :             }
     774             : 
     775         220 :             while (cur + dimt >= len)
     776             :             {
     777           0 :                 len *= 2;
     778           0 :                 doc = (DocRepresentation *) repalloc(doc, sizeof(DocRepresentation) * len);
     779             :             }
     780             : 
     781             :             /* iterations over entry's positions */
     782         476 :             for (j = 0; j < dimt; j++)
     783             :             {
     784         256 :                 if (curoperand->weight == 0 ||
     785          20 :                     curoperand->weight & (1 << WEP_GETWEIGHT(post[j])))
     786             :                 {
     787         248 :                     doc[cur].pos = post[j];
     788         248 :                     doc[cur].data.map.entry = entry;
     789         248 :                     doc[cur].data.map.item = (QueryItem *) curoperand;
     790         248 :                     cur++;
     791             :                 }
     792             :             }
     793             : 
     794         220 :             entry++;
     795             :         }
     796             :     }
     797             : 
     798         104 :     if (cur > 0)
     799             :     {
     800         100 :         DocRepresentation *rptr = doc + 1,
     801         100 :                    *wptr = doc,
     802             :                     storage;
     803             : 
     804             :         /*
     805             :          * Sort representation in ascending order by pos and entry
     806             :          */
     807         100 :         qsort((void *) doc, cur, sizeof(DocRepresentation), compareDocR);
     808             : 
     809             :         /*
     810             :          * Join QueryItem per WordEntry and it's position
     811             :          */
     812         100 :         storage.pos = doc->pos;
     813         100 :         storage.data.query.items = palloc(sizeof(QueryItem *) * qr->query->size);
     814         100 :         storage.data.query.items[0] = doc->data.map.item;
     815         100 :         storage.data.query.nitem = 1;
     816             : 
     817         248 :         while (rptr - doc < cur)
     818             :         {
     819         148 :             if (rptr->pos == (rptr - 1)->pos &&
     820           4 :                 rptr->data.map.entry == (rptr - 1)->data.map.entry)
     821             :             {
     822           4 :                 storage.data.query.items[storage.data.query.nitem] = rptr->data.map.item;
     823           4 :                 storage.data.query.nitem++;
     824             :             }
     825             :             else
     826             :             {
     827         144 :                 *wptr = storage;
     828         144 :                 wptr++;
     829         144 :                 storage.pos = rptr->pos;
     830         144 :                 storage.data.query.items = palloc(sizeof(QueryItem *) * qr->query->size);
     831         144 :                 storage.data.query.items[0] = rptr->data.map.item;
     832         144 :                 storage.data.query.nitem = 1;
     833             :             }
     834             : 
     835         148 :             rptr++;
     836             :         }
     837             : 
     838         100 :         *wptr = storage;
     839         100 :         wptr++;
     840             : 
     841         100 :         *doclen = wptr - doc;
     842         100 :         return doc;
     843             :     }
     844             : 
     845           4 :     pfree(doc);
     846           4 :     return NULL;
     847             : }
     848             : 
     849             : static float4
     850         104 : calc_rank_cd(const float4 *arrdata, TSVector txt, TSQuery query, int method)
     851             : {
     852             :     DocRepresentation *doc;
     853             :     int         len,
     854             :                 i,
     855         104 :                 doclen = 0;
     856             :     CoverExt    ext;
     857         104 :     double      Wdoc = 0.0;
     858             :     double      invws[lengthof(weights)];
     859         104 :     double      SumDist = 0.0,
     860         104 :                 PrevExtPos = 0.0;
     861         104 :     int         NExtent = 0;
     862             :     QueryRepresentation qr;
     863             : 
     864             : 
     865         520 :     for (i = 0; i < lengthof(weights); i++)
     866             :     {
     867         416 :         invws[i] = ((double) ((arrdata[i] >= 0) ? arrdata[i] : weights[i]));
     868         416 :         if (invws[i] > 1.0)
     869           0 :             ereport(ERROR,
     870             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     871             :                      errmsg("weight out of range")));
     872         416 :         invws[i] = 1.0 / invws[i];
     873             :     }
     874             : 
     875         104 :     qr.query = query;
     876         104 :     qr.operandData = (QueryRepresentationOperand *)
     877         104 :         palloc0(sizeof(QueryRepresentationOperand) * query->size);
     878             : 
     879         104 :     doc = get_docrep(txt, &qr, &doclen);
     880         104 :     if (!doc)
     881             :     {
     882           4 :         pfree(qr.operandData);
     883           4 :         return 0.0;
     884             :     }
     885             : 
     886         500 :     MemSet(&ext, 0, sizeof(CoverExt));
     887         216 :     while (Cover(doc, doclen, &qr, &ext))
     888             :     {
     889         116 :         double      Cpos = 0.0;
     890         116 :         double      InvSum = 0.0;
     891             :         double      CurExtPos;
     892             :         int         nNoise;
     893         116 :         DocRepresentation *ptr = ext.begin;
     894             : 
     895         292 :         while (ptr <= ext.end)
     896             :         {
     897         176 :             InvSum += invws[WEP_GETWEIGHT(ptr->pos)];
     898         176 :             ptr++;
     899             :         }
     900             : 
     901         116 :         Cpos = ((double) (ext.end - ext.begin + 1)) / InvSum;
     902             : 
     903             :         /*
     904             :          * if doc are big enough then ext.q may be equal to ext.p due to limit
     905             :          * of positional information. In this case we approximate number of
     906             :          * noise word as half cover's length
     907             :          */
     908         116 :         nNoise = (ext.q - ext.p) - (ext.end - ext.begin);
     909         116 :         if (nNoise < 0)
     910           0 :             nNoise = (ext.end - ext.begin) / 2;
     911         116 :         Wdoc += Cpos / ((double) (1 + nNoise));
     912             : 
     913         116 :         CurExtPos = ((double) (ext.q + ext.p)) / 2.0;
     914         116 :         if (NExtent > 0 && CurExtPos > PrevExtPos /* prevent division by
     915             :                                                      * zero in a case of
     916             :               * multiple lexize */ )
     917          28 :             SumDist += 1.0 / (CurExtPos - PrevExtPos);
     918             : 
     919         116 :         PrevExtPos = CurExtPos;
     920         116 :         NExtent++;
     921             :     }
     922             : 
     923         100 :     if ((method & RANK_NORM_LOGLENGTH) && txt->size > 0)
     924           0 :         Wdoc /= log((double) (cnt_length(txt) + 1));
     925             : 
     926         100 :     if (method & RANK_NORM_LENGTH)
     927             :     {
     928           0 :         len = cnt_length(txt);
     929           0 :         if (len > 0)
     930           0 :             Wdoc /= (double) len;
     931             :     }
     932             : 
     933         100 :     if ((method & RANK_NORM_EXTDIST) && NExtent > 0 && SumDist > 0)
     934           0 :         Wdoc /= ((double) NExtent) / SumDist;
     935             : 
     936         100 :     if ((method & RANK_NORM_UNIQ) && txt->size > 0)
     937           0 :         Wdoc /= (double) (txt->size);
     938             : 
     939         100 :     if ((method & RANK_NORM_LOGUNIQ) && txt->size > 0)
     940           0 :         Wdoc /= log((double) (txt->size + 1)) / log(2.0);
     941             : 
     942         100 :     if (method & RANK_NORM_RDIVRPLUS1)
     943           0 :         Wdoc /= (Wdoc + 1);
     944             : 
     945         100 :     pfree(doc);
     946             : 
     947         100 :     pfree(qr.operandData);
     948             : 
     949         100 :     return (float4) Wdoc;
     950             : }
     951             : 
     952             : Datum
     953           0 : ts_rankcd_wttf(PG_FUNCTION_ARGS)
     954             : {
     955           0 :     ArrayType  *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
     956           0 :     TSVector    txt = PG_GETARG_TSVECTOR(1);
     957           0 :     TSQuery     query = PG_GETARG_TSQUERY(2);
     958           0 :     int         method = PG_GETARG_INT32(3);
     959             :     float       res;
     960             : 
     961           0 :     res = calc_rank_cd(getWeights(win), txt, query, method);
     962             : 
     963           0 :     PG_FREE_IF_COPY(win, 0);
     964           0 :     PG_FREE_IF_COPY(txt, 1);
     965           0 :     PG_FREE_IF_COPY(query, 2);
     966           0 :     PG_RETURN_FLOAT4(res);
     967             : }
     968             : 
     969             : Datum
     970           0 : ts_rankcd_wtt(PG_FUNCTION_ARGS)
     971             : {
     972           0 :     ArrayType  *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
     973           0 :     TSVector    txt = PG_GETARG_TSVECTOR(1);
     974           0 :     TSQuery     query = PG_GETARG_TSQUERY(2);
     975             :     float       res;
     976             : 
     977           0 :     res = calc_rank_cd(getWeights(win), txt, query, DEF_NORM_METHOD);
     978             : 
     979           0 :     PG_FREE_IF_COPY(win, 0);
     980           0 :     PG_FREE_IF_COPY(txt, 1);
     981           0 :     PG_FREE_IF_COPY(query, 2);
     982           0 :     PG_RETURN_FLOAT4(res);
     983             : }
     984             : 
     985             : Datum
     986           0 : ts_rankcd_ttf(PG_FUNCTION_ARGS)
     987             : {
     988           0 :     TSVector    txt = PG_GETARG_TSVECTOR(0);
     989           0 :     TSQuery     query = PG_GETARG_TSQUERY(1);
     990           0 :     int         method = PG_GETARG_INT32(2);
     991             :     float       res;
     992             : 
     993           0 :     res = calc_rank_cd(getWeights(NULL), txt, query, method);
     994             : 
     995           0 :     PG_FREE_IF_COPY(txt, 0);
     996           0 :     PG_FREE_IF_COPY(query, 1);
     997           0 :     PG_RETURN_FLOAT4(res);
     998             : }
     999             : 
    1000             : Datum
    1001         104 : ts_rankcd_tt(PG_FUNCTION_ARGS)
    1002             : {
    1003         104 :     TSVector    txt = PG_GETARG_TSVECTOR(0);
    1004         104 :     TSQuery     query = PG_GETARG_TSQUERY(1);
    1005             :     float       res;
    1006             : 
    1007         104 :     res = calc_rank_cd(getWeights(NULL), txt, query, DEF_NORM_METHOD);
    1008             : 
    1009         104 :     PG_FREE_IF_COPY(txt, 0);
    1010         104 :     PG_FREE_IF_COPY(query, 1);
    1011         104 :     PG_RETURN_FLOAT4(res);
    1012             : }

Generated by: LCOV version 1.13