tsquery_util.c File Reference

#include "postgres.h"
#include "miscadmin.h"
#include "tsearch/ts_utils.h"
#include "varatt.h"

Include dependency graph for tsquery_util.c:

Go to the source code of this file.

Data Structures
struct	QTN2QTState

Functions
QTNode *	QT2QTN (QueryItem *in, char *operand)
void	QTNFree (QTNode *in)
int	QTNodeCompare (QTNode *an, QTNode *bn)
static int	cmpQTN (const void *a, const void *b)
void	QTNSort (QTNode *in)
bool	QTNEq (QTNode *a, QTNode *b)
void	QTNTernary (QTNode *in)
void	QTNBinary (QTNode *in)
static void	cntsize (QTNode *in, int *sumlen, int *nnode)
static void	fillQT (QTN2QTState *state, QTNode *in)
TSQuery	QTN2QT (QTNode *in)
QTNode *	QTNCopy (QTNode *in)
void	QTNClearFlags (QTNode *in, uint32 flags)

Function Documentation

cmpQTN()

static int cmpQTN ( const void *  a, const void *  b  )

static

Definition at line 153 of file tsquery_util.c.

{
    return QTNodeCompare(*(QTNode *const *) a, *(QTNode *const *) b);
}

References a, b, and QTNodeCompare().

Referenced by QTNSort().

cntsize()

static void cntsize ( QTNode *  in, int *  sumlen, int *  nnode  )

static

Definition at line 292 of file tsquery_util.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    *nnode += 1;
    if (in->valnode->type == QI_OPR)
    {
        int         i;
 
        for (i = 0; i < in->nchild; i++)
            cntsize(in->child[i], sumlen, nnode);
    }
    else
    {
        *sumlen += in->valnode->qoperand.length + 1;
    }
}

References check_stack_depth(), QTNode::child, cntsize(), i, QueryOperand::length, QTNode::nchild, QI_OPR, QueryItem::qoperand, QueryItem::type, and QTNode::valnode.

Referenced by cntsize(), and QTN2QT().

fillQT()

static void fillQT ( QTN2QTState *  state, QTNode *  in  )

static

Definition at line 323 of file tsquery_util.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->valnode->type == QI_VAL)
    {
        memcpy(state->curitem, in->valnode, sizeof(QueryOperand));
 
        memcpy(state->curoperand, in->word, in->valnode->qoperand.length);
        state->curitem->qoperand.distance = state->curoperand - state->operand;
        state->curoperand[in->valnode->qoperand.length] = '\0';
        state->curoperand += in->valnode->qoperand.length + 1;
        state->curitem++;
    }
    else
    {
        QueryItem  *curitem = state->curitem;
 
        Assert(in->valnode->type == QI_OPR);
 
        memcpy(state->curitem, in->valnode, sizeof(QueryOperator));
 
        Assert(in->nchild <= 2);
        state->curitem++;
 
        fillQT(state, in->child[0]);
 
        if (in->nchild == 2)
        {
            curitem->qoperator.left = state->curitem - curitem;
            fillQT(state, in->child[1]);
        }
    }
}

References Assert, check_stack_depth(), QTNode::child, fillQT(), QueryOperator::left, QueryOperand::length, QTNode::nchild, QI_OPR, QI_VAL, QueryItem::qoperand, QueryItem::qoperator, QueryItem::type, QTNode::valnode, and QTNode::word.

Referenced by fillQT(), and QTN2QT().

QT2QTN()

QTNode * QT2QTN	(	QueryItem *	in,
		char *	operand
	)

Definition at line 25 of file tsquery_util.c.

{
    QTNode     *node = (QTNode *) palloc0(sizeof(QTNode));
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    node->valnode = in;
 
    if (in->type == QI_OPR)
    {
        node->child = (QTNode **) palloc0(sizeof(QTNode *) * 2);
        node->child[0] = QT2QTN(in + 1, operand);
        node->sign = node->child[0]->sign;
        if (in->qoperator.oper == OP_NOT)
            node->nchild = 1;
        else
        {
            node->nchild = 2;
            node->child[1] = QT2QTN(in + in->qoperator.left, operand);
            node->sign |= node->child[1]->sign;
        }
    }
    else if (operand)
    {
        node->word = operand + in->qoperand.distance;
        node->sign = ((uint32) 1) << (((unsigned int) in->qoperand.valcrc) % 32);
    }
 
    return node;
}

References check_stack_depth(), QTNode::child, QueryOperand::distance, QueryOperator::left, QTNode::nchild, OP_NOT, QueryOperator::oper, palloc0(), QI_OPR, QueryItem::qoperand, QueryItem::qoperator, QT2QTN(), QTNode::sign, QueryItem::type, QueryOperand::valcrc, QTNode::valnode, and QTNode::word.

Referenced by CompareTSQ(), join_tsqueries(), QT2QTN(), tsquery_not(), tsquery_rewrite(), and tsquery_rewrite_query().

QTN2QT()

TSQuery QTN2QT

(

QTNode *

in

)

Definition at line 363 of file tsquery_util.c.

{
    TSQuery     out;
    int         len;
    int         sumlen = 0,
                nnode = 0;
    QTN2QTState state;
 
    cntsize(in, &sumlen, &nnode);
 
    if (TSQUERY_TOO_BIG(nnode, sumlen))
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("tsquery is too large")));
    len = COMPUTESIZE(nnode, sumlen);
 
    out = (TSQuery) palloc0(len);
    SET_VARSIZE(out, len);
    out->size = nnode;
 
    state.curitem = GETQUERY(out);
    state.operand = state.curoperand = GETOPERAND(out);
 
    fillQT(&state, in);
    return out;
}

References cntsize(), COMPUTESIZE, ereport, errcode(), errmsg(), ERROR, fillQT(), GETOPERAND, GETQUERY, len, palloc0(), SET_VARSIZE, TSQueryData::size, and TSQUERY_TOO_BIG.

Referenced by tsquery_and(), tsquery_not(), tsquery_or(), tsquery_phrase_distance(), tsquery_rewrite(), and tsquery_rewrite_query().

QTNBinary()

void QTNBinary

(

QTNode *

in

)

Definition at line 250 of file tsquery_util.c.

{
    int         i;
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->valnode->type != QI_OPR)
        return;
 
    for (i = 0; i < in->nchild; i++)
        QTNBinary(in->child[i]);
 
    while (in->nchild > 2)
    {
        QTNode     *nn = (QTNode *) palloc0(sizeof(QTNode));
 
        nn->valnode = (QueryItem *) palloc0(sizeof(QueryItem));
        nn->child = (QTNode **) palloc0(sizeof(QTNode *) * 2);
 
        nn->nchild = 2;
        nn->flags = QTN_NEEDFREE;
 
        nn->child[0] = in->child[0];
        nn->child[1] = in->child[1];
        nn->sign = nn->child[0]->sign | nn->child[1]->sign;
 
        nn->valnode->type = in->valnode->type;
        nn->valnode->qoperator.oper = in->valnode->qoperator.oper;
 
        in->child[0] = nn;
        in->child[1] = in->child[in->nchild - 1];
        in->nchild--;
    }
}

References check_stack_depth(), QTNode::child, QTNode::flags, i, QTNode::nchild, QueryOperator::oper, palloc0(), QI_OPR, QueryItem::qoperator, QTN_NEEDFREE, QTNBinary(), QTNode::sign, QueryItem::type, and QTNode::valnode.

Referenced by QTNBinary(), tsquery_rewrite(), and tsquery_rewrite_query().

QTNClearFlags()

void QTNClearFlags	(	QTNode *	in,
		uint32	flags
	)

Definition at line 434 of file tsquery_util.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    in->flags &= ~flags;
 
    if (in->valnode->type != QI_VAL)
    {
        int         i;
 
        for (i = 0; i < in->nchild; i++)
            QTNClearFlags(in->child[i], flags);
    }
}

References check_stack_depth(), QTNode::child, QTNode::flags, i, QTNode::nchild, QI_VAL, QTNClearFlags(), QueryItem::type, and QTNode::valnode.

Referenced by QTNClearFlags(), and tsquery_rewrite_query().

QTNCopy()

QTNode * QTNCopy

(

QTNode *

in

)

Definition at line 396 of file tsquery_util.c.

{
    QTNode     *out;
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    out = (QTNode *) palloc(sizeof(QTNode));
 
    *out = *in;
    out->valnode = (QueryItem *) palloc(sizeof(QueryItem));
    *(out->valnode) = *(in->valnode);
    out->flags |= QTN_NEEDFREE;
 
    if (in->valnode->type == QI_VAL)
    {
        out->word = palloc(in->valnode->qoperand.length + 1);
        memcpy(out->word, in->word, in->valnode->qoperand.length);
        out->word[in->valnode->qoperand.length] = '\0';
        out->flags |= QTN_WORDFREE;
    }
    else
    {
        int         i;
 
        out->child = (QTNode **) palloc(sizeof(QTNode *) * in->nchild);
 
        for (i = 0; i < in->nchild; i++)
            out->child[i] = QTNCopy(in->child[i]);
    }
 
    return out;
}

References check_stack_depth(), QTNode::child, QTNode::flags, i, QueryOperand::length, QTNode::nchild, palloc(), QI_VAL, QueryItem::qoperand, QTN_NEEDFREE, QTN_WORDFREE, QTNCopy(), QueryItem::type, QTNode::valnode, and QTNode::word.

Referenced by findeq(), and QTNCopy().

QTNEq()

bool QTNEq	(	QTNode *	a,
		QTNode *	b
	)

Definition at line 183 of file tsquery_util.c.

{
    uint32      sign = a->sign & b->sign;
 
    if (!(sign == a->sign && sign == b->sign))
        return false;
 
    return (QTNodeCompare(a, b) == 0);
}

References a, b, QTNodeCompare(), and sign.

Referenced by findeq().

QTNFree()

void QTNFree

(

QTNode *

in

)

Definition at line 64 of file tsquery_util.c.

{
    if (!in)
        return;
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->valnode->type == QI_VAL && in->word && (in->flags & QTN_WORDFREE) != 0)
        pfree(in->word);
 
    if (in->valnode->type == QI_OPR)
    {
        int         i;
 
        for (i = 0; i < in->nchild; i++)
            QTNFree(in->child[i]);
    }
    if (in->child)
        pfree(in->child);
 
    if (in->flags & QTN_NEEDFREE)
        pfree(in->valnode);
 
    pfree(in);
}

References check_stack_depth(), QTNode::child, QTNode::flags, i, QTNode::nchild, pfree(), QI_OPR, QI_VAL, QTN_NEEDFREE, QTN_WORDFREE, QTNFree(), QueryItem::type, QTNode::valnode, and QTNode::word.

Referenced by CompareTSQ(), dofindsubquery(), findeq(), QTNFree(), tsquery_and(), tsquery_not(), tsquery_or(), tsquery_phrase_distance(), tsquery_rewrite(), and tsquery_rewrite_query().

QTNodeCompare()

int QTNodeCompare	(	QTNode *	an,
		QTNode *	bn
	)

Definition at line 97 of file tsquery_util.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (an->valnode->type != bn->valnode->type)
        return (an->valnode->type > bn->valnode->type) ? -1 : 1;
 
    if (an->valnode->type == QI_OPR)
    {
        QueryOperator *ao = &an->valnode->qoperator;
        QueryOperator *bo = &bn->valnode->qoperator;
 
        if (ao->oper != bo->oper)
            return (ao->oper > bo->oper) ? -1 : 1;
 
        if (an->nchild != bn->nchild)
            return (an->nchild > bn->nchild) ? -1 : 1;
 
        {
            int         i,
                        res;
 
            for (i = 0; i < an->nchild; i++)
                if ((res = QTNodeCompare(an->child[i], bn->child[i])) != 0)
                    return res;
        }
 
        if (ao->oper == OP_PHRASE && ao->distance != bo->distance)
            return (ao->distance > bo->distance) ? -1 : 1;
 
        return 0;
    }
    else if (an->valnode->type == QI_VAL)
    {
        QueryOperand *ao = &an->valnode->qoperand;
        QueryOperand *bo = &bn->valnode->qoperand;
 
        if (ao->valcrc != bo->valcrc)
        {
            return (ao->valcrc > bo->valcrc) ? -1 : 1;
        }
 
        return tsCompareString(an->word, ao->length, bn->word, bo->length, false);
    }
    else
    {
        elog(ERROR, "unrecognized QueryItem type: %d", an->valnode->type);
        return 0;               /* keep compiler quiet */
    }
}

References check_stack_depth(), QTNode::child, QueryOperator::distance, elog, ERROR, i, QueryOperand::length, QTNode::nchild, OP_PHRASE, QueryOperator::oper, QI_OPR, QI_VAL, QueryItem::qoperand, QueryItem::qoperator, QTNodeCompare(), res, tsCompareString(), QueryItem::type, QueryOperand::valcrc, QTNode::valnode, and QTNode::word.

Referenced by cmpQTN(), CompareTSQ(), findeq(), QTNEq(), and QTNodeCompare().

QTNSort()

void QTNSort

(

QTNode *

in

)

Definition at line 163 of file tsquery_util.c.

{
    int         i;
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->valnode->type != QI_OPR)
        return;
 
    for (i = 0; i < in->nchild; i++)
        QTNSort(in->child[i]);
    if (in->nchild > 1 && in->valnode->qoperator.oper != OP_PHRASE)
        qsort(in->child, in->nchild, sizeof(QTNode *), cmpQTN);
}

References check_stack_depth(), QTNode::child, cmpQTN(), i, QTNode::nchild, OP_PHRASE, QueryOperator::oper, QI_OPR, QueryItem::qoperator, qsort, QTNSort(), QueryItem::type, and QTNode::valnode.

Referenced by findeq(), QTNSort(), tsquery_rewrite(), and tsquery_rewrite_query().

QTNTernary()

void QTNTernary

(

QTNode *

in

)

Definition at line 201 of file tsquery_util.c.

{
    int         i;
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->valnode->type != QI_OPR)
        return;
 
    for (i = 0; i < in->nchild; i++)
        QTNTernary(in->child[i]);
 
    /* Only AND and OR are associative, so don't flatten other node types */
    if (in->valnode->qoperator.oper != OP_AND &&
        in->valnode->qoperator.oper != OP_OR)
        return;
 
    for (i = 0; i < in->nchild; i++)
    {
        QTNode     *cc = in->child[i];
 
        if (cc->valnode->type == QI_OPR &&
            in->valnode->qoperator.oper == cc->valnode->qoperator.oper)
        {
            int         oldnchild = in->nchild;
 
            in->nchild += cc->nchild - 1;
            in->child = (QTNode **) repalloc(in->child, in->nchild * sizeof(QTNode *));
 
            if (i + 1 != oldnchild)
                memmove(in->child + i + cc->nchild, in->child + i + 1,
                        (oldnchild - i - 1) * sizeof(QTNode *));
 
            memcpy(in->child + i, cc->child, cc->nchild * sizeof(QTNode *));
            i += cc->nchild - 1;
 
            if (cc->flags & QTN_NEEDFREE)
                pfree(cc->valnode);
            pfree(cc);
        }
    }
}

References check_stack_depth(), QTNode::child, QTNode::flags, i, QTNode::nchild, OP_AND, OP_OR, QueryOperator::oper, pfree(), QI_OPR, QueryItem::qoperator, QTN_NEEDFREE, QTNTernary(), repalloc(), QueryItem::type, and QTNode::valnode.

Referenced by QTNTernary(), tsquery_rewrite(), and tsquery_rewrite_query().