#include "postgres.h"
#include <limits.h>
#include <math.h>
#include "miscadmin.h"
#include "tsearch/ts_utils.h"
#include "utils/array.h"
#include "utils/fmgrprotos.h"

Include dependency graph for tsrank.c:

Go to the source code of this file.

Data Structures
struct	DocRepresentation

struct	QueryRepresentationOperand

struct	QueryRepresentation

struct	CoverExt

Macros
#define	NUM_WEIGHTS 4

#define	wpos(wep) ( w[ WEP_GETWEIGHT(wep) ] )

#define	RANK_NO_NORM 0x00

#define	RANK_NORM_LOGLENGTH 0x01

#define	RANK_NORM_LENGTH 0x02

#define	RANK_NORM_EXTDIST 0x04

#define	RANK_NORM_UNIQ 0x08

#define	RANK_NORM_LOGUNIQ 0x10

#define	RANK_NORM_RDIVRPLUS1 0x20

#define	DEF_NORM_METHOD RANK_NO_NORM

#define	WordECompareQueryItem(e, q, p, i, m)

#define	MAXQROPOS MAXENTRYPOS

#define	QR_GET_OPERAND_DATA(q, v) ( (q)->operandData + (((QueryItem*)(v)) - GETQUERY((q)->query)) )

Functions
static float	calc_rank_or (const float *w, TSVector t, TSQuery q)

static float	calc_rank_and (const float *w, TSVector t, TSQuery q)

static float4	word_distance (int32 w)

static int	cnt_length (TSVector t)

static WordEntry *	find_wordentry (TSVector t, TSQuery q, QueryOperand item, int32 nitem)

static int	compareQueryOperand (const void a, const void b, void *arg)

static QueryOperand **	SortAndUniqItems (TSQuery q, int *size)

static float	calc_rank (const float *w, TSVector t, TSQuery q, int32 method)

static void	getWeights (ArrayType win, float ws)

Datum	ts_rank_wttf (PG_FUNCTION_ARGS)

Datum	ts_rank_wtt (PG_FUNCTION_ARGS)

Datum	ts_rank_ttf (PG_FUNCTION_ARGS)

Datum	ts_rank_tt (PG_FUNCTION_ARGS)

static int	compareDocR (const void va, const void vb)

static TSTernaryValue	checkcondition_QueryOperand (void checkval, QueryOperand val, ExecPhraseData *data)

static void	resetQueryRepresentation (QueryRepresentation *qr, bool reverseinsert)

static void	fillQueryRepresentationData (QueryRepresentation qr, DocRepresentation entry)

static bool	Cover (DocRepresentation doc, int len, QueryRepresentation qr, CoverExt *ext)

static DocRepresentation *	get_docrep (TSVector txt, QueryRepresentation qr, int doclen)

static float4	calc_rank_cd (const float4 *arrdata, TSVector txt, TSQuery query, int method)

Datum	ts_rankcd_wttf (PG_FUNCTION_ARGS)

Datum	ts_rankcd_wtt (PG_FUNCTION_ARGS)

Datum	ts_rankcd_ttf (PG_FUNCTION_ARGS)

Datum	ts_rankcd_tt (PG_FUNCTION_ARGS)

Variables
static const float	default_weights [NUM_WEIGHTS] = {0.1f, 0.2f, 0.4f, 1.0f}

Macro Definition Documentation

◆ DEF_NORM_METHOD

#define DEF_NORM_METHOD RANK_NO_NORM

Definition at line 36 of file tsrank.c.

◆ MAXQROPOS

#define MAXQROPOS MAXENTRYPOS

Definition at line 545 of file tsrank.c.

◆ NUM_WEIGHTS

#define NUM_WEIGHTS 4

Definition at line 24 of file tsrank.c.

◆ QR_GET_OPERAND_DATA

#define QR_GET_OPERAND_DATA	(	q,
		v
	)	( (q)->operandData + (((QueryItem*)(v)) - GETQUERY((q)->query)) )

Definition at line 561 of file tsrank.c.

◆ RANK_NO_NORM

#define RANK_NO_NORM 0x00

Definition at line 29 of file tsrank.c.

◆ RANK_NORM_EXTDIST

#define RANK_NORM_EXTDIST 0x04

Definition at line 32 of file tsrank.c.

◆ RANK_NORM_LENGTH

#define RANK_NORM_LENGTH 0x02

Definition at line 31 of file tsrank.c.

◆ RANK_NORM_LOGLENGTH

#define RANK_NORM_LOGLENGTH 0x01

Definition at line 30 of file tsrank.c.

◆ RANK_NORM_LOGUNIQ

#define RANK_NORM_LOGUNIQ 0x10

Definition at line 34 of file tsrank.c.

◆ RANK_NORM_RDIVRPLUS1

#define RANK_NORM_RDIVRPLUS1 0x20

Definition at line 35 of file tsrank.c.

◆ RANK_NORM_UNIQ

#define RANK_NORM_UNIQ 0x08

Definition at line 33 of file tsrank.c.

◆ WordECompareQueryItem

#define WordECompareQueryItem	(	e,
		q,
		p,
		i,
		m
	)

Value:

tsCompareString((q) + (i)->distance, (i)->length, \

(e) + (p)->pos, (p)->len, (m))

i

int i

Definition: isn.c:73

len

const void size_t len

Definition: pg_crc32c_sse42.c:24

e

Definition: preproc-init.c:82

tsCompareString

int32 tsCompareString(char *a, int lena, char *b, int lenb, bool prefix)

Definition: tsvector_op.c:1152

Definition at line 76 of file tsrank.c.

◆ wpos

#define wpos ( wep ) ( w[ WEP_GETWEIGHT(wep) ] )

Definition at line 27 of file tsrank.c.

Function Documentation

◆ calc_rank()

static float calc_rank	(	const float *	w,
		TSVector	t,
		TSQuery	q,
		int32	method
	)

static

Definition at line 358 of file tsrank.c.

 {
     QueryItem  *item = GETQUERY(q);
     float       res = 0.0;
     int         len;
  
     if (!t->size || !q->size)
         return 0.0;
  
     /* XXX: What about NOT? */
     res = (item->type == QI_OPR && (item->qoperator.oper == OP_AND ||
                                     item->qoperator.oper == OP_PHRASE)) ?
         calc_rank_and(w, t, q) :
         calc_rank_or(w, t, q);
  
     if (res < 0)
         res = 1e-20f;
  
     if ((method & RANK_NORM_LOGLENGTH) && t->size > 0)
         res /= log((double) (cnt_length(t) + 1)) / log(2.0);
  
     if (method & RANK_NORM_LENGTH)
     {
         len = cnt_length(t);
         if (len > 0)
             res /= (float) len;
     }
  
     /* RANK_NORM_EXTDIST not applicable */
  
     if ((method & RANK_NORM_UNIQ) && t->size > 0)
         res /= (float) (t->size);
  
     if ((method & RANK_NORM_LOGUNIQ) && t->size > 0)
         res /= log((double) (t->size + 1)) / log(2.0);
  
     if (method & RANK_NORM_RDIVRPLUS1)
         res /= (res + 1);
  
     return res;
 }

References calc_rank_and(), calc_rank_or(), cnt_length(), GETQUERY, len, OP_AND, OP_PHRASE, QueryOperator::oper, QI_OPR, QueryItem::qoperator, RANK_NORM_LENGTH, RANK_NORM_LOGLENGTH, RANK_NORM_LOGUNIQ, RANK_NORM_RDIVRPLUS1, RANK_NORM_UNIQ, res, TSVectorData::size, TSQueryData::size, and QueryItem::type.

Referenced by ts_rank_tt(), ts_rank_ttf(), ts_rank_wtt(), and ts_rank_wttf().

◆ calc_rank_and()

static float calc_rank_and	(	const float *	w,
		TSVector	t,
		TSQuery	q
	)

static

Definition at line 201 of file tsrank.c.

 {
     WordEntryPosVector **pos;
     WordEntryPosVector1 posnull;
     WordEntryPosVector *POSNULL;
     int         i,
                 k,
                 l,
                 p;
     WordEntry  *entry,
                *firstentry;
     WordEntryPos *post,
                *ct;
     int32       dimt,
                 lenct,
                 dist,
                 nitem;
     float       res = -1.0;
     QueryOperand **item;
     int         size = q->size;
  
     item = SortAndUniqItems(q, &size);
     if (size < 2)
     {
         pfree(item);
         return calc_rank_or(w, t, q);
     }
     pos = (WordEntryPosVector **) palloc0(sizeof(WordEntryPosVector *) * q->size);
  
     /* A dummy WordEntryPos array to use when haspos is false */
     posnull.npos = 1;
     posnull.pos[0] = 0;
     WEP_SETPOS(posnull.pos[0], MAXENTRYPOS - 1);
     POSNULL = (WordEntryPosVector *) &posnull;
  
     for (i = 0; i < size; i++)
     {
         firstentry = entry = find_wordentry(t, q, item[i], &nitem);
         if (!entry)
             continue;
  
         while (entry - firstentry < nitem)
         {
             if (entry->haspos)
                 pos[i] = _POSVECPTR(t, entry);
             else
                 pos[i] = POSNULL;
  
             dimt = pos[i]->npos;
             post = pos[i]->pos;
             for (k = 0; k < i; k++)
             {
                 if (!pos[k])
                     continue;
                 lenct = pos[k]->npos;
                 ct = pos[k]->pos;
                 for (l = 0; l < dimt; l++)
                 {
                     for (p = 0; p < lenct; p++)
                     {
                         dist = abs((int) WEP_GETPOS(post[l]) - (int) WEP_GETPOS(ct[p]));
                         if (dist || (dist == 0 && (pos[i] == POSNULL || pos[k] == POSNULL)))
                         {
                             float       curw;
  
                             if (!dist)
                                 dist = MAXENTRYPOS;
                             curw = sqrt(wpos(post[l]) * wpos(ct[p]) * word_distance(dist));
                             res = (res < 0) ? curw : 1.0 - (1.0 - res) * (1.0 - curw);
                         }
                     }
                 }
             }
  
             entry++;
         }
     }
     pfree(pos);
     pfree(item);
     return res;
 }

References _POSVECPTR, calc_rank_or(), find_wordentry(), WordEntry::haspos, i, MAXENTRYPOS, WordEntryPosVector::npos, WordEntryPosVector1::npos, palloc0(), pfree(), WordEntryPosVector1::pos, WordEntryPosVector::pos, res, size, TSQueryData::size, SortAndUniqItems(), WEP_GETPOS, WEP_SETPOS, word_distance(), and wpos.

Referenced by calc_rank().

◆ calc_rank_cd()

static float4 calc_rank_cd	(	const float4 *	arrdata,
		TSVector	txt,
		TSQuery	query,
		int	method
	)

static

Definition at line 855 of file tsrank.c.

 {
     DocRepresentation *doc;
     int         len,
                 i,
                 doclen = 0;
     CoverExt    ext;
     double      Wdoc = 0.0;
     double      invws[NUM_WEIGHTS];
     double      SumDist = 0.0,
                 PrevExtPos = 0.0;
     int         NExtent = 0;
     QueryRepresentation qr;
  
  
     for (i = 0; i < NUM_WEIGHTS; i++)
     {
         invws[i] = ((double) ((arrdata[i] >= 0) ? arrdata[i] : default_weights[i]));
         if (invws[i] > 1.0)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                      errmsg("weight out of range")));
         invws[i] = 1.0 / invws[i];
     }
  
     qr.query = query;
     qr.operandData = (QueryRepresentationOperand *)
         palloc0(sizeof(QueryRepresentationOperand) * query->size);
  
     doc = get_docrep(txt, &qr, &doclen);
     if (!doc)
     {
         pfree(qr.operandData);
         return 0.0;
     }
  
     MemSet(&ext, 0, sizeof(CoverExt));
     while (Cover(doc, doclen, &qr, &ext))
     {
         double      Cpos = 0.0;
         double      InvSum = 0.0;
         double      CurExtPos;
         int         nNoise;
         DocRepresentation *ptr = ext.begin;
  
         while (ptr <= ext.end)
         {
             InvSum += invws[WEP_GETWEIGHT(ptr->pos)];
             ptr++;
         }
  
         Cpos = ((double) (ext.end - ext.begin + 1)) / InvSum;
  
         /*
          * if doc are big enough then ext.q may be equal to ext.p due to limit
          * of positional information. In this case we approximate number of
          * noise word as half cover's length
          */
         nNoise = (ext.q - ext.p) - (ext.end - ext.begin);
         if (nNoise < 0)
             nNoise = (ext.end - ext.begin) / 2;
         Wdoc += Cpos / ((double) (1 + nNoise));
  
         CurExtPos = ((double) (ext.q + ext.p)) / 2.0;
         if (NExtent > 0 && CurExtPos > PrevExtPos   /* prevent division by
                                                      * zero in a case of
               * multiple lexize */ )
             SumDist += 1.0 / (CurExtPos - PrevExtPos);
  
         PrevExtPos = CurExtPos;
         NExtent++;
     }
  
     if ((method & RANK_NORM_LOGLENGTH) && txt->size > 0)
         Wdoc /= log((double) (cnt_length(txt) + 1));
  
     if (method & RANK_NORM_LENGTH)
     {
         len = cnt_length(txt);
         if (len > 0)
             Wdoc /= (double) len;
     }
  
     if ((method & RANK_NORM_EXTDIST) && NExtent > 0 && SumDist > 0)
         Wdoc /= ((double) NExtent) / SumDist;
  
     if ((method & RANK_NORM_UNIQ) && txt->size > 0)
         Wdoc /= (double) (txt->size);
  
     if ((method & RANK_NORM_LOGUNIQ) && txt->size > 0)
         Wdoc /= log((double) (txt->size + 1)) / log(2.0);
  
     if (method & RANK_NORM_RDIVRPLUS1)
         Wdoc /= (Wdoc + 1);
  
     pfree(doc);
  
     pfree(qr.operandData);
  
     return (float4) Wdoc;
 }

References CoverExt::begin, cnt_length(), Cover(), default_weights, CoverExt::end, ereport, errcode(), errmsg(), ERROR, get_docrep(), i, len, MemSet, NUM_WEIGHTS, QueryRepresentation::operandData, CoverExt::p, palloc0(), pfree(), DocRepresentation::pos, CoverExt::q, QueryRepresentation::query, RANK_NORM_EXTDIST, RANK_NORM_LENGTH, RANK_NORM_LOGLENGTH, RANK_NORM_LOGUNIQ, RANK_NORM_RDIVRPLUS1, RANK_NORM_UNIQ, TSVectorData::size, TSQueryData::size, and WEP_GETWEIGHT.

Referenced by ts_rankcd_tt(), ts_rankcd_ttf(), ts_rankcd_wtt(), and ts_rankcd_wttf().

◆ calc_rank_or()

static float calc_rank_or	(	const float *	w,
		TSVector	t,
		TSQuery	q
	)

static

Definition at line 284 of file tsrank.c.

 {
     WordEntry  *entry,
                *firstentry;
     WordEntryPosVector1 posnull;
     WordEntryPos *post;
     int32       dimt,
                 j,
                 i,
                 nitem;
     float       res = 0.0;
     QueryOperand **item;
     int         size = q->size;
  
     /* A dummy WordEntryPos array to use when haspos is false */
     posnull.npos = 1;
     posnull.pos[0] = 0;
  
     item = SortAndUniqItems(q, &size);
  
     for (i = 0; i < size; i++)
     {
         float       resj,
                     wjm;
         int32       jm;
  
         firstentry = entry = find_wordentry(t, q, item[i], &nitem);
         if (!entry)
             continue;
  
         while (entry - firstentry < nitem)
         {
             if (entry->haspos)
             {
                 dimt = POSDATALEN(t, entry);
                 post = POSDATAPTR(t, entry);
             }
             else
             {
                 dimt = posnull.npos;
                 post = posnull.pos;
             }
  
             resj = 0.0;
             wjm = -1.0;
             jm = 0;
             for (j = 0; j < dimt; j++)
             {
                 resj = resj + wpos(post[j]) / ((j + 1) * (j + 1));
                 if (wpos(post[j]) > wjm)
                 {
                     wjm = wpos(post[j]);
                     jm = j;
                 }
             }
 /*
             limit (sum(1/i^2),i=1,inf) = pi^2/6
             resj = sum(wi/i^2),i=1,noccurrence,
             wi - should be sorted desc,
             don't sort for now, just choose maximum weight. This should be corrected
             Oleg Bartunov
 */
             res = res + (wjm + resj - wjm / ((jm + 1) * (jm + 1))) / 1.64493406685;
  
             entry++;
         }
     }
     if (size > 0)
         res = res / size;
     pfree(item);
     return res;
 }

References find_wordentry(), WordEntry::haspos, i, j, WordEntryPosVector1::npos, pfree(), WordEntryPosVector1::pos, POSDATALEN, POSDATAPTR, res, size, TSQueryData::size, SortAndUniqItems(), and wpos.

Referenced by calc_rank(), and calc_rank_and().

◆ checkcondition_QueryOperand()

static TSTernaryValue checkcondition_QueryOperand	(	void *	checkval,
		QueryOperand *	val,
		ExecPhraseData *	data
	)

static

Definition at line 568 of file tsrank.c.

 {
     QueryRepresentation *qr = (QueryRepresentation *) checkval;
     QueryRepresentationOperand *opData = QR_GET_OPERAND_DATA(qr, val);
  
     if (!opData->operandexists)
         return TS_NO;
  
     if (data)
     {
         data->npos = opData->npos;
         data->pos = opData->pos;
         if (opData->reverseinsert)
             data->pos += MAXQROPOS - opData->npos;
     }
  
     return TS_YES;
 }

References data, MAXQROPOS, QueryRepresentationOperand::npos, QueryRepresentationOperand::operandexists, QueryRepresentationOperand::pos, QR_GET_OPERAND_DATA, QueryRepresentationOperand::reverseinsert, TS_NO, TS_YES, and val.

Referenced by Cover().

◆ cnt_length()

static int cnt_length ( TSVector t )

static

Definition at line 54 of file tsrank.c.

 {
     WordEntry  *ptr = ARRPTR(t),
                *end = (WordEntry *) STRPTR(t);
     int         len = 0;
  
     while (ptr < end)
     {
         int         clen = POSDATALEN(t, ptr);
  
         if (clen == 0)
             len += 1;
         else
             len += clen;
  
         ptr++;
     }
  
     return len;
 }

References ARRPTR, len, POSDATALEN, and STRPTR.

Referenced by calc_rank(), and calc_rank_cd().

◆ compareDocR()

static int compareDocR	(	const void *	va,
		const void *	vb
	)

static

Definition at line 524 of file tsrank.c.

 {
     const DocRepresentation *a = (const DocRepresentation *) va;
     const DocRepresentation *b = (const DocRepresentation *) vb;
  
     if (WEP_GETPOS(a->pos) == WEP_GETPOS(b->pos))
     {
         if (WEP_GETWEIGHT(a->pos) == WEP_GETWEIGHT(b->pos))
         {
             if (a->data.map.entry == b->data.map.entry)
                 return 0;
  
             return (a->data.map.entry > b->data.map.entry) ? 1 : -1;
         }
  
         return (WEP_GETWEIGHT(a->pos) > WEP_GETWEIGHT(b->pos)) ? 1 : -1;
     }
  
     return (WEP_GETPOS(a->pos) > WEP_GETPOS(b->pos)) ? 1 : -1;
 }

References a, b, WEP_GETPOS, and WEP_GETWEIGHT.

Referenced by get_docrep().

◆ compareQueryOperand()

static int compareQueryOperand	(	const void *	a,
		const void *	b,
		void *	arg
	)

static

Definition at line 136 of file tsrank.c.

 {
     char       *operand = (char *) arg;
     QueryOperand *qa = (*(QueryOperand *const *) a);
     QueryOperand *qb = (*(QueryOperand *const *) b);
  
     return tsCompareString(operand + qa->distance, qa->length,
                            operand + qb->distance, qb->length,
                            false);
 }

References a, arg, b, QueryOperand::distance, QueryOperand::length, and tsCompareString().

Referenced by SortAndUniqItems().

◆ Cover()

static bool Cover	(	DocRepresentation *	doc,
		int	len,
		QueryRepresentation *	qr,
		CoverExt *	ext
	)

static

Definition at line 651 of file tsrank.c.

 {
     DocRepresentation *ptr;
     int         lastpos = ext->pos;
     bool        found = false;
  
     /*
      * since this function recurses, it could be driven to stack overflow.
      * (though any decent compiler will optimize away the tail-recursion.
      */
     check_stack_depth();
  
     resetQueryRepresentation(qr, false);
  
     ext->p = INT_MAX;
     ext->q = 0;
     ptr = doc + ext->pos;
  
     /* find upper bound of cover from current position, move up */
     while (ptr - doc < len)
     {
         fillQueryRepresentationData(qr, ptr);
  
         if (TS_execute(GETQUERY(qr->query), (void *) qr,
                        TS_EXEC_EMPTY, checkcondition_QueryOperand))
         {
             if (WEP_GETPOS(ptr->pos) > ext->q)
             {
                 ext->q = WEP_GETPOS(ptr->pos);
                 ext->end = ptr;
                 lastpos = ptr - doc;
                 found = true;
             }
             break;
         }
         ptr++;
     }
  
     if (!found)
         return false;
  
     resetQueryRepresentation(qr, true);
  
     ptr = doc + lastpos;
  
     /* find lower bound of cover from found upper bound, move down */
     while (ptr >= doc + ext->pos)
     {
         /*
          * we scan doc from right to left, so pos info in reverse order!
          */
         fillQueryRepresentationData(qr, ptr);
  
         if (TS_execute(GETQUERY(qr->query), (void *) qr,
                        TS_EXEC_EMPTY, checkcondition_QueryOperand))
         {
             if (WEP_GETPOS(ptr->pos) < ext->p)
             {
                 ext->begin = ptr;
                 ext->p = WEP_GETPOS(ptr->pos);
             }
             break;
         }
         ptr--;
     }
  
     if (ext->p <= ext->q)
     {
         /*
          * set position for next try to next lexeme after beginning of found
          * cover
          */
         ext->pos = (ptr - doc) + 1;
         return true;
     }
  
     ext->pos++;
     return Cover(doc, len, qr, ext);
 }

References CoverExt::begin, check_stack_depth(), checkcondition_QueryOperand(), CoverExt::end, fillQueryRepresentationData(), GETQUERY, len, CoverExt::p, DocRepresentation::pos, CoverExt::pos, CoverExt::q, QueryRepresentation::query, resetQueryRepresentation(), TS_EXEC_EMPTY, TS_execute(), and WEP_GETPOS.

Referenced by calc_rank_cd().

◆ fillQueryRepresentationData()

static void fillQueryRepresentationData	(	QueryRepresentation *	qr,
		DocRepresentation *	entry
	)

static

Definition at line 611 of file tsrank.c.

 {
     int         i;
     int         lastPos;
     QueryRepresentationOperand *opData;
  
     for (i = 0; i < entry->data.query.nitem; i++)
     {
         if (entry->data.query.items[i]->type != QI_VAL)
             continue;
  
         opData = QR_GET_OPERAND_DATA(qr, entry->data.query.items[i]);
  
         opData->operandexists = true;
  
         if (opData->npos == 0)
         {
             lastPos = (opData->reverseinsert) ? (MAXQROPOS - 1) : 0;
             opData->pos[lastPos] = entry->pos;
             opData->npos++;
             continue;
         }
  
         lastPos = opData->reverseinsert ?
             (MAXQROPOS - opData->npos) :
             (opData->npos - 1);
  
         if (WEP_GETPOS(opData->pos[lastPos]) != WEP_GETPOS(entry->pos))
         {
             lastPos = opData->reverseinsert ?
                 (MAXQROPOS - 1 - opData->npos) :
                 (opData->npos);
  
             opData->pos[lastPos] = entry->pos;
             opData->npos++;
         }
     }
 }

References DocRepresentation::data, i, MAXQROPOS, QueryRepresentationOperand::npos, QueryRepresentationOperand::operandexists, DocRepresentation::pos, QueryRepresentationOperand::pos, QI_VAL, QR_GET_OPERAND_DATA, DocRepresentation::query, QueryRepresentationOperand::reverseinsert, and WEP_GETPOS.

Referenced by Cover().

◆ find_wordentry()

static WordEntry* find_wordentry	(	TSVector	t,
		TSQuery	q,
		QueryOperand *	item,
		int32 *	nitem
	)

static

Definition at line 87 of file tsrank.c.

 {
     WordEntry  *StopLow = ARRPTR(t);
     WordEntry  *StopHigh = (WordEntry *) STRPTR(t);
     WordEntry  *StopMiddle = StopHigh;
     int         difference;
  
     *nitem = 0;
  
     /* Loop invariant: StopLow <= item < StopHigh */
     while (StopLow < StopHigh)
     {
         StopMiddle = StopLow + (StopHigh - StopLow) / 2;
         difference = WordECompareQueryItem(STRPTR(t), GETOPERAND(q), StopMiddle, item, false);
         if (difference == 0)
         {
             StopHigh = StopMiddle;
             *nitem = 1;
             break;
         }
         else if (difference > 0)
             StopLow = StopMiddle + 1;
         else
             StopHigh = StopMiddle;
     }
  
     if (item->prefix)
     {
         if (StopLow >= StopHigh)
             StopMiddle = StopHigh;
  
         *nitem = 0;
  
         while (StopMiddle < (WordEntry *) STRPTR(t) &&
                WordECompareQueryItem(STRPTR(t), GETOPERAND(q), StopMiddle, item, true) == 0)
         {
             (*nitem)++;
             StopMiddle++;
         }
     }
  
     return (*nitem > 0) ? StopHigh : NULL;
 }

References ARRPTR, difference(), GETOPERAND, QueryOperand::prefix, STRPTR, and WordECompareQueryItem.

Referenced by calc_rank_and(), calc_rank_or(), and get_docrep().

◆ get_docrep()

static DocRepresentation* get_docrep	(	TSVector	txt,
		QueryRepresentation *	qr,
		int *	doclen
	)

static

Definition at line 732 of file tsrank.c.

 {
     QueryItem  *item = GETQUERY(qr->query);
     WordEntry  *entry,
                *firstentry;
     WordEntryPos *post;
     int32       dimt,           /* number of 'post' items */
                 j,
                 i,
                 nitem;
     int         len = qr->query->size * 4,
                 cur = 0;
     DocRepresentation *doc;
  
     doc = (DocRepresentation *) palloc(sizeof(DocRepresentation) * len);
  
     /*
      * Iterate through query to make DocRepresentation for words and it's
      * entries satisfied by query
      */
     for (i = 0; i < qr->query->size; i++)
     {
         QueryOperand *curoperand;
  
         if (item[i].type != QI_VAL)
             continue;
  
         curoperand = &item[i].qoperand;
  
         firstentry = entry = find_wordentry(txt, qr->query, curoperand, &nitem);
         if (!entry)
             continue;
  
         /* iterations over entries in tsvector */
         while (entry - firstentry < nitem)
         {
             if (entry->haspos)
             {
                 dimt = POSDATALEN(txt, entry);
                 post = POSDATAPTR(txt, entry);
             }
             else
             {
                 /* ignore words without positions */
                 entry++;
                 continue;
             }
  
             while (cur + dimt >= len)
             {
                 len *= 2;
                 doc = (DocRepresentation *) repalloc(doc, sizeof(DocRepresentation) * len);
             }
  
             /* iterations over entry's positions */
             for (j = 0; j < dimt; j++)
             {
                 if (curoperand->weight == 0 ||
                     curoperand->weight & (1 << WEP_GETWEIGHT(post[j])))
                 {
                     doc[cur].pos = post[j];
                     doc[cur].data.map.entry = entry;
                     doc[cur].data.map.item = (QueryItem *) curoperand;
                     cur++;
                 }
             }
  
             entry++;
         }
     }
  
     if (cur > 0)
     {
         DocRepresentation *rptr = doc + 1,
                    *wptr = doc,
                     storage;
  
         /*
          * Sort representation in ascending order by pos and entry
          */
         qsort(doc, cur, sizeof(DocRepresentation), compareDocR);
  
         /*
          * Join QueryItem per WordEntry and it's position
          */
         storage.pos = doc->pos;
         storage.data.query.items = palloc(sizeof(QueryItem *) * qr->query->size);
         storage.data.query.items[0] = doc->data.map.item;
         storage.data.query.nitem = 1;
  
         while (rptr - doc < cur)
         {
             if (rptr->pos == (rptr - 1)->pos &&
                 rptr->data.map.entry == (rptr - 1)->data.map.entry)
             {
                 storage.data.query.items[storage.data.query.nitem] = rptr->data.map.item;
                 storage.data.query.nitem++;
             }
             else
             {
                 *wptr = storage;
                 wptr++;
                 storage.pos = rptr->pos;
                 storage.data.query.items = palloc(sizeof(QueryItem *) * qr->query->size);
                 storage.data.query.items[0] = rptr->data.map.item;
                 storage.data.query.nitem = 1;
             }
  
             rptr++;
         }
  
         *wptr = storage;
         wptr++;
  
         *doclen = wptr - doc;
         return doc;
     }
  
     pfree(doc);
     return NULL;
 }

References compareDocR(), cur, DocRepresentation::data, find_wordentry(), GETQUERY, WordEntry::haspos, i, j, len, DocRepresentation::map, palloc(), pfree(), DocRepresentation::pos, POSDATALEN, POSDATAPTR, QI_VAL, QueryItem::qoperand, qsort, QueryRepresentation::query, repalloc(), TSQueryData::size, storage, type, QueryOperand::weight, and WEP_GETWEIGHT.

Referenced by calc_rank_cd().

◆ getWeights()

static void getWeights	(	ArrayType *	win,
		float *	ws
	)

static

Definition at line 405 of file tsrank.c.

 {
     int         i;
     float4     *arrdata;
  
     Assert(win != NULL);
  
     if (ARR_NDIM(win) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                  errmsg("array of weight must be one-dimensional")));
  
     if (ArrayGetNItems(ARR_NDIM(win), ARR_DIMS(win)) < NUM_WEIGHTS)
         ereport(ERROR,
                 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                  errmsg("array of weight is too short")));
  
     if (array_contains_nulls(win))
         ereport(ERROR,
                 (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                  errmsg("array of weight must not contain nulls")));
  
     arrdata = (float4 *) ARR_DATA_PTR(win);
     for (i = 0; i < NUM_WEIGHTS; i++)
     {
         ws[i] = (arrdata[i] >= 0) ? arrdata[i] : default_weights[i];
         if (ws[i] > 1.0)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                      errmsg("weight out of range")));
     }
 }

References ARR_DATA_PTR, ARR_DIMS, ARR_NDIM, array_contains_nulls(), ArrayGetNItems(), Assert, default_weights, ereport, errcode(), errmsg(), ERROR, i, and NUM_WEIGHTS.

Referenced by ts_rank_wtt(), ts_rank_wttf(), ts_rankcd_wtt(), and ts_rankcd_wttf().

◆ resetQueryRepresentation()

static void resetQueryRepresentation	(	QueryRepresentation *	qr,
		bool	reverseinsert
	)

static

Definition at line 598 of file tsrank.c.

 {
     int         i;
  
     for (i = 0; i < qr->query->size; i++)
     {
         qr->operandData[i].operandexists = false;
         qr->operandData[i].reverseinsert = reverseinsert;
         qr->operandData[i].npos = 0;
     }
 }

References i, QueryRepresentationOperand::npos, QueryRepresentation::operandData, QueryRepresentationOperand::operandexists, QueryRepresentation::query, QueryRepresentationOperand::reverseinsert, and TSQueryData::size.

Referenced by Cover().

◆ SortAndUniqItems()

static QueryOperand** SortAndUniqItems	(	TSQuery	q,
		int *	size
	)

static

Definition at line 155 of file tsrank.c.

 {
     char       *operand = GETOPERAND(q);
     QueryItem  *item = GETQUERY(q);
     QueryOperand **res,
               **ptr,
               **prevptr;
  
     ptr = res = (QueryOperand **) palloc(sizeof(QueryOperand *) * *size);
  
     /* Collect all operands from the tree to res */
     while ((*size)--)
     {
         if (item->type == QI_VAL)
         {
             *ptr = (QueryOperand *) item;
             ptr++;
         }
         item++;
     }
  
     *size = ptr - res;
     if (*size < 2)
         return res;
  
     qsort_arg(res, *size, sizeof(QueryOperand *), compareQueryOperand, operand);
  
     ptr = res + 1;
     prevptr = res;
  
     /* remove duplicates */
     while (ptr - res < *size)
     {
         if (compareQueryOperand((void *) ptr, (void *) prevptr, (void *) operand) != 0)
         {
             prevptr++;
             *prevptr = *ptr;
         }
         ptr++;
     }
  
     *size = prevptr + 1 - res;
     return res;
 }

References compareQueryOperand(), GETOPERAND, GETQUERY, palloc(), QI_VAL, qsort_arg(), res, size, and QueryItem::type.

Referenced by calc_rank_and(), and calc_rank_or().

◆ ts_rank_tt()

Datum ts_rank_tt ( PG_FUNCTION_ARGS )

Definition at line 491 of file tsrank.c.

 {
     TSVector    txt = PG_GETARG_TSVECTOR(0);
     TSQuery     query = PG_GETARG_TSQUERY(1);
     float       res;
  
     res = calc_rank(default_weights, txt, query, DEF_NORM_METHOD);
  
     PG_FREE_IF_COPY(txt, 0);
     PG_FREE_IF_COPY(query, 1);
     PG_RETURN_FLOAT4(res);
 }

References calc_rank(), DEF_NORM_METHOD, default_weights, PG_FREE_IF_COPY, PG_GETARG_TSQUERY, PG_GETARG_TSVECTOR, PG_RETURN_FLOAT4, and res.

◆ ts_rank_ttf()

Datum ts_rank_ttf ( PG_FUNCTION_ARGS )

Definition at line 476 of file tsrank.c.

 {
     TSVector    txt = PG_GETARG_TSVECTOR(0);
     TSQuery     query = PG_GETARG_TSQUERY(1);
     int         method = PG_GETARG_INT32(2);
     float       res;
  
     res = calc_rank(default_weights, txt, query, method);
  
     PG_FREE_IF_COPY(txt, 0);
     PG_FREE_IF_COPY(query, 1);
     PG_RETURN_FLOAT4(res);
 }

References calc_rank(), default_weights, PG_FREE_IF_COPY, PG_GETARG_INT32, PG_GETARG_TSQUERY, PG_GETARG_TSVECTOR, PG_RETURN_FLOAT4, and res.

◆ ts_rank_wtt()

Datum ts_rank_wtt ( PG_FUNCTION_ARGS )

Definition at line 458 of file tsrank.c.

 {
     ArrayType  *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
     TSVector    txt = PG_GETARG_TSVECTOR(1);
     TSQuery     query = PG_GETARG_TSQUERY(2);
     float       weights[NUM_WEIGHTS];
     float       res;
  
     getWeights(win, weights);
     res = calc_rank(weights, txt, query, DEF_NORM_METHOD);
  
     PG_FREE_IF_COPY(win, 0);
     PG_FREE_IF_COPY(txt, 1);
     PG_FREE_IF_COPY(query, 2);
     PG_RETURN_FLOAT4(res);
 }

References calc_rank(), DEF_NORM_METHOD, getWeights(), NUM_WEIGHTS, PG_DETOAST_DATUM, PG_FREE_IF_COPY, PG_GETARG_DATUM, PG_GETARG_TSQUERY, PG_GETARG_TSVECTOR, PG_RETURN_FLOAT4, and res.

◆ ts_rank_wttf()

Datum ts_rank_wttf ( PG_FUNCTION_ARGS )

Definition at line 439 of file tsrank.c.

 {
     ArrayType  *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
     TSVector    txt = PG_GETARG_TSVECTOR(1);
     TSQuery     query = PG_GETARG_TSQUERY(2);
     int         method = PG_GETARG_INT32(3);
     float       weights[NUM_WEIGHTS];
     float       res;
  
     getWeights(win, weights);
     res = calc_rank(weights, txt, query, method);
  
     PG_FREE_IF_COPY(win, 0);
     PG_FREE_IF_COPY(txt, 1);
     PG_FREE_IF_COPY(query, 2);
     PG_RETURN_FLOAT4(res);
 }

References calc_rank(), getWeights(), NUM_WEIGHTS, PG_DETOAST_DATUM, PG_FREE_IF_COPY, PG_GETARG_DATUM, PG_GETARG_INT32, PG_GETARG_TSQUERY, PG_GETARG_TSVECTOR, PG_RETURN_FLOAT4, and res.

◆ ts_rankcd_tt()

Datum ts_rankcd_tt ( PG_FUNCTION_ARGS )

Definition at line 1010 of file tsrank.c.

 {
     TSVector    txt = PG_GETARG_TSVECTOR(0);
     TSQuery     query = PG_GETARG_TSQUERY(1);
     float       res;
  
     res = calc_rank_cd(default_weights, txt, query, DEF_NORM_METHOD);
  
     PG_FREE_IF_COPY(txt, 0);
     PG_FREE_IF_COPY(query, 1);
     PG_RETURN_FLOAT4(res);
 }

References calc_rank_cd(), DEF_NORM_METHOD, default_weights, PG_FREE_IF_COPY, PG_GETARG_TSQUERY, PG_GETARG_TSVECTOR, PG_RETURN_FLOAT4, and res.

◆ ts_rankcd_ttf()

Datum ts_rankcd_ttf ( PG_FUNCTION_ARGS )

Definition at line 995 of file tsrank.c.

 {
     TSVector    txt = PG_GETARG_TSVECTOR(0);
     TSQuery     query = PG_GETARG_TSQUERY(1);
     int         method = PG_GETARG_INT32(2);
     float       res;
  
     res = calc_rank_cd(default_weights, txt, query, method);
  
     PG_FREE_IF_COPY(txt, 0);
     PG_FREE_IF_COPY(query, 1);
     PG_RETURN_FLOAT4(res);
 }

References calc_rank_cd(), default_weights, PG_FREE_IF_COPY, PG_GETARG_INT32, PG_GETARG_TSQUERY, PG_GETARG_TSVECTOR, PG_RETURN_FLOAT4, and res.

◆ ts_rankcd_wtt()

Datum ts_rankcd_wtt ( PG_FUNCTION_ARGS )

Definition at line 977 of file tsrank.c.

 {
     ArrayType  *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
     TSVector    txt = PG_GETARG_TSVECTOR(1);
     TSQuery     query = PG_GETARG_TSQUERY(2);
     float       weights[NUM_WEIGHTS];
     float       res;
  
     getWeights(win, weights);
     res = calc_rank_cd(weights, txt, query, DEF_NORM_METHOD);
  
     PG_FREE_IF_COPY(win, 0);
     PG_FREE_IF_COPY(txt, 1);
     PG_FREE_IF_COPY(query, 2);
     PG_RETURN_FLOAT4(res);
 }

References calc_rank_cd(), DEF_NORM_METHOD, getWeights(), NUM_WEIGHTS, PG_DETOAST_DATUM, PG_FREE_IF_COPY, PG_GETARG_DATUM, PG_GETARG_TSQUERY, PG_GETARG_TSVECTOR, PG_RETURN_FLOAT4, and res.

◆ ts_rankcd_wttf()

Datum ts_rankcd_wttf ( PG_FUNCTION_ARGS )

Definition at line 958 of file tsrank.c.

 {
     ArrayType  *win = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
     TSVector    txt = PG_GETARG_TSVECTOR(1);
     TSQuery     query = PG_GETARG_TSQUERY(2);
     int         method = PG_GETARG_INT32(3);
     float       weights[NUM_WEIGHTS];
     float       res;
  
     getWeights(win, weights);
     res = calc_rank_cd(weights, txt, query, method);
  
     PG_FREE_IF_COPY(win, 0);
     PG_FREE_IF_COPY(txt, 1);
     PG_FREE_IF_COPY(query, 2);
     PG_RETURN_FLOAT4(res);
 }

References calc_rank_cd(), getWeights(), NUM_WEIGHTS, PG_DETOAST_DATUM, PG_FREE_IF_COPY, PG_GETARG_DATUM, PG_GETARG_INT32, PG_GETARG_TSQUERY, PG_GETARG_TSVECTOR, PG_RETURN_FLOAT4, and res.

◆ word_distance()

static float4 word_distance ( int32 w )

static

Definition at line 45 of file tsrank.c.

 {
     if (w > 100)
         return 1e-30f;
  
     return 1.0 / (1.005 + 0.05 * exp(((float4) w) / 1.5 - 2));
 }

Referenced by calc_rank_and().

Variable Documentation

◆ default_weights

const float default_weights[NUM_WEIGHTS] = {0.1f, 0.2f, 0.4f, 1.0f}

static

Definition at line 25 of file tsrank.c.

Referenced by calc_rank_cd(), getWeights(), ts_rank_tt(), ts_rank_ttf(), ts_rankcd_tt(), and ts_rankcd_ttf().

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ DEF_NORM_METHOD

◆ MAXQROPOS

◆ NUM_WEIGHTS

◆ QR_GET_OPERAND_DATA

◆ RANK_NO_NORM

◆ RANK_NORM_EXTDIST

◆ RANK_NORM_LENGTH

◆ RANK_NORM_LOGLENGTH

◆ RANK_NORM_LOGUNIQ

◆ RANK_NORM_RDIVRPLUS1

◆ RANK_NORM_UNIQ

◆ WordECompareQueryItem

◆ wpos

Function Documentation

◆ calc_rank()

◆ calc_rank_and()

◆ calc_rank_cd()

◆ calc_rank_or()

◆ checkcondition_QueryOperand()

◆ cnt_length()

◆ compareDocR()

◆ compareQueryOperand()

◆ Cover()

◆ fillQueryRepresentationData()

◆ find_wordentry()

◆ get_docrep()

◆ getWeights()

◆ resetQueryRepresentation()

◆ SortAndUniqItems()

◆ ts_rank_tt()

◆ ts_rank_ttf()

◆ ts_rank_wtt()

◆ ts_rank_wttf()

◆ ts_rankcd_tt()

◆ ts_rankcd_ttf()

◆ ts_rankcd_wtt()

◆ ts_rankcd_wttf()

◆ word_distance()

Variable Documentation

◆ default_weights