tsrank.c File Reference

#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	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 const float *	getWeights (ArrayType *win)
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	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 35 of file tsrank.c.

MAXQROPOS

#define MAXQROPOS   MAXENTRYPOS

Definition at line 540 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 556 of file tsrank.c.

RANK_NO_NORM

#define RANK_NO_NORM   0x00

Definition at line 28 of file tsrank.c.

RANK_NORM_EXTDIST

#define RANK_NORM_EXTDIST   0x04

Definition at line 31 of file tsrank.c.

RANK_NORM_LENGTH

#define RANK_NORM_LENGTH   0x02

Definition at line 30 of file tsrank.c.

RANK_NORM_LOGLENGTH

#define RANK_NORM_LOGLENGTH   0x01

Definition at line 29 of file tsrank.c.

RANK_NORM_LOGUNIQ

#define RANK_NORM_LOGUNIQ   0x10

Definition at line 33 of file tsrank.c.

RANK_NORM_RDIVRPLUS1

#define RANK_NORM_RDIVRPLUS1   0x20

Definition at line 34 of file tsrank.c.

RANK_NORM_UNIQ

#define RANK_NORM_UNIQ   0x08

Definition at line 32 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))

Definition at line 75 of file tsrank.c.

wpos

#define wpos

(

wep

)

( w[ WEP_GETWEIGHT(wep) ] )

Definition at line 26 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 357 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 200 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 850 of file tsrank.c.

{
    DocRepresentation *doc;
    int         len,
                i,
                doclen = 0;
    CoverExt    ext;
    double      Wdoc = 0.0;
    double      invws[lengthof(weights)];
    double      SumDist = 0.0,
                PrevExtPos = 0.0;
    int         NExtent = 0;
    QueryRepresentation qr;
 
 
    for (i = 0; i < lengthof(weights); i++)
    {
        invws[i] = ((double) ((arrdata[i] >= 0) ? arrdata[i] : 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(), CoverExt::end, ereport, errcode(), errmsg(), ERROR, get_docrep(), i, len, lengthof, MemSet, 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, weights, 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 283 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 563 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 53 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 519 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 135 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 646 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 606 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 86 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 727 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 const float* getWeights ( ArrayType *  win )

static

Definition at line 400 of file tsrank.c.

{
    static float ws[lengthof(weights)];
    int         i;
    float4     *arrdata;
 
    if (win == NULL)
        return weights;
 
    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)) < lengthof(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 < lengthof(weights); i++)
    {
        ws[i] = (arrdata[i] >= 0) ? arrdata[i] : weights[i];
        if (ws[i] > 1.0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("weight out of range")));
    }
 
    return ws;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_NDIM, array_contains_nulls(), ArrayGetNItems(), ereport, errcode(), errmsg(), ERROR, i, lengthof, and weights.

Referenced by ts_rank_tt(), ts_rank_ttf(), ts_rank_wtt(), ts_rank_wttf(), ts_rankcd_tt(), ts_rankcd_ttf(), ts_rankcd_wtt(), and ts_rankcd_wttf().

resetQueryRepresentation()

static void resetQueryRepresentation ( QueryRepresentation *  qr, bool  reverseinsert  )

static

Definition at line 593 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 154 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 486 of file tsrank.c.

{
    TSVector    txt = PG_GETARG_TSVECTOR(0);
    TSQuery     query = PG_GETARG_TSQUERY(1);
    float       res;
 
    res = calc_rank(getWeights(NULL), 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, getWeights(), 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 471 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(getWeights(NULL), txt, query, method);
 
    PG_FREE_IF_COPY(txt, 0);
    PG_FREE_IF_COPY(query, 1);
    PG_RETURN_FLOAT4(res);
}

References calc_rank(), getWeights(), 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 455 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       res;
 
    res = calc_rank(getWeights(win), 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(), 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 438 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       res;
 
    res = calc_rank(getWeights(win), 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(), 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 1001 of file tsrank.c.

{
    TSVector    txt = PG_GETARG_TSVECTOR(0);
    TSQuery     query = PG_GETARG_TSQUERY(1);
    float       res;
 
    res = calc_rank_cd(getWeights(NULL), 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, getWeights(), 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 986 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(getWeights(NULL), txt, query, method);
 
    PG_FREE_IF_COPY(txt, 0);
    PG_FREE_IF_COPY(query, 1);
    PG_RETURN_FLOAT4(res);
}

References calc_rank_cd(), getWeights(), 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 970 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       res;
 
    res = calc_rank_cd(getWeights(win), 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(), 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 953 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       res;
 
    res = calc_rank_cd(getWeights(win), 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(), 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 44 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

weights

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

static

Definition at line 24 of file tsrank.c.

Referenced by calc_rank_cd(), getWeights(), tsvector_filter(), and tsvector_unnest().