tsquery_cleanup.c File Reference

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

Include dependency graph for tsquery_cleanup.c:

Go to the source code of this file.

Data Structures
struct	NODE
struct	PLAINTREE

Typedefs
typedef struct NODE	NODE

Functions
static NODE *	maketree (QueryItem *in)
static void	plainnode (PLAINTREE *state, NODE *node)
static QueryItem *	plaintree (NODE *root, int *len)
static void	freetree (NODE *node)
static NODE *	clean_NOT_intree (NODE *node)
QueryItem *	clean_NOT (QueryItem *ptr, int *len)
static NODE *	clean_stopword_intree (NODE *node, int *ladd, int *radd)
static int32	calcstrlen (NODE *node)
TSQuery	cleanup_tsquery_stopwords (TSQuery in, bool noisy)

Typedef Documentation

NODE

typedef struct NODE NODE

Function Documentation

calcstrlen()

static int32 calcstrlen ( NODE *  node )

static

Definition at line 363 of file tsquery_cleanup.c.

{
    int32       size = 0;
 
    if (node->valnode->type == QI_VAL)
    {
        size = node->valnode->qoperand.length + 1;
    }
    else
    {
        Assert(node->valnode->type == QI_OPR);
 
        size = calcstrlen(node->right);
        if (node->valnode->qoperator.oper != OP_NOT)
            size += calcstrlen(node->left);
    }
 
    return size;
}

References Assert, calcstrlen(), NODE::left, QueryOperand::length, OP_NOT, QueryOperator::oper, QI_OPR, QI_VAL, QueryItem::qoperand, QueryItem::qoperator, NODE::right, size, QueryItem::type, and NODE::valnode.

Referenced by calcstrlen(), and cleanup_tsquery_stopwords().

clean_NOT()

QueryItem * clean_NOT	(	QueryItem *	ptr,
		int *	len
	)

Definition at line 190 of file tsquery_cleanup.c.

{
    NODE       *root = maketree(ptr);
 
    return plaintree(clean_NOT_intree(root), len);
}

References clean_NOT_intree(), len, maketree(), plaintree(), and root.

Referenced by tsquerytree().

clean_NOT_intree()

static NODE * clean_NOT_intree ( NODE *  node )

static

Definition at line 136 of file tsquery_cleanup.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (node->valnode->type == QI_VAL)
        return node;
 
    if (node->valnode->qoperator.oper == OP_NOT)
    {
        freetree(node);
        return NULL;
    }
 
    /* operator & or | */
    if (node->valnode->qoperator.oper == OP_OR)
    {
        if ((node->left = clean_NOT_intree(node->left)) == NULL ||
            (node->right = clean_NOT_intree(node->right)) == NULL)
        {
            freetree(node);
            return NULL;
        }
    }
    else
    {
        NODE       *res = node;
 
        Assert(node->valnode->qoperator.oper == OP_AND ||
               node->valnode->qoperator.oper == OP_PHRASE);
 
        node->left = clean_NOT_intree(node->left);
        node->right = clean_NOT_intree(node->right);
        if (node->left == NULL && node->right == NULL)
        {
            pfree(node);
            res = NULL;
        }
        else if (node->left == NULL)
        {
            res = node->right;
            pfree(node);
        }
        else if (node->right == NULL)
        {
            res = node->left;
            pfree(node);
        }
        return res;
    }
    return node;
}

References Assert, check_stack_depth(), clean_NOT_intree(), freetree(), NODE::left, OP_AND, OP_NOT, OP_OR, OP_PHRASE, QueryOperator::oper, pfree(), QI_VAL, QueryItem::qoperator, res, NODE::right, QueryItem::type, and NODE::valnode.

Referenced by clean_NOT(), and clean_NOT_intree().

clean_stopword_intree()

static NODE * clean_stopword_intree ( NODE *  node, int *  ladd, int *  radd  )

static

Definition at line 238 of file tsquery_cleanup.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    /* default output parameters indicate no change in parent distance */
    *ladd = *radd = 0;
 
    if (node->valnode->type == QI_VAL)
        return node;
    else if (node->valnode->type == QI_VALSTOP)
    {
        pfree(node);
        return NULL;
    }
 
    Assert(node->valnode->type == QI_OPR);
 
    if (node->valnode->qoperator.oper == OP_NOT)
    {
        /* NOT doesn't change pattern width, so just report child distances */
        node->right = clean_stopword_intree(node->right, ladd, radd);
        if (!node->right)
        {
            freetree(node);
            return NULL;
        }
    }
    else
    {
        NODE       *res = node;
        bool        isphrase;
        int         ndistance,
                    lladd,
                    lradd,
                    rladd,
                    rradd;
 
        /* First, recurse */
        node->left = clean_stopword_intree(node->left, &lladd, &lradd);
        node->right = clean_stopword_intree(node->right, &rladd, &rradd);
 
        /* Check if current node is OP_PHRASE, get its distance */
        isphrase = (node->valnode->qoperator.oper == OP_PHRASE);
        ndistance = isphrase ? node->valnode->qoperator.distance : 0;
 
        if (node->left == NULL && node->right == NULL)
        {
            /*
             * When we collapse out a phrase node entirely, propagate its own
             * distance into both *ladd and *radd; it is the responsibility of
             * the parent node to count it only once.  Also, for a phrase
             * node, distances coming from children are summed and propagated
             * up to parent (we assume lladd == lradd and rladd == rradd, else
             * rule was broken at a lower level).  But if this isn't a phrase
             * node, take the larger of the two child distances; that
             * corresponds to what TS_execute will do in non-stopword cases.
             */
            if (isphrase)
                *ladd = *radd = lladd + ndistance + rladd;
            else
                *ladd = *radd = Max(lladd, rladd);
            freetree(node);
            return NULL;
        }
        else if (node->left == NULL)
        {
            /* Removing this operator and left subnode */
            /* lladd and lradd are equal/redundant, don't count both */
            if (isphrase)
            {
                /* operator's own distance must propagate to left */
                *ladd = lladd + ndistance + rladd;
                *radd = rradd;
            }
            else
            {
                /* at non-phrase op, just forget the left subnode entirely */
                *ladd = rladd;
                *radd = rradd;
            }
            res = node->right;
            pfree(node);
        }
        else if (node->right == NULL)
        {
            /* Removing this operator and right subnode */
            /* rladd and rradd are equal/redundant, don't count both */
            if (isphrase)
            {
                /* operator's own distance must propagate to right */
                *ladd = lladd;
                *radd = lradd + ndistance + rradd;
            }
            else
            {
                /* at non-phrase op, just forget the right subnode entirely */
                *ladd = lladd;
                *radd = lradd;
            }
            res = node->left;
            pfree(node);
        }
        else if (isphrase)
        {
            /* Absorb appropriate corrections at this level */
            node->valnode->qoperator.distance += lradd + rladd;
            /* Propagate up any unaccounted-for corrections */
            *ladd = lladd;
            *radd = rradd;
        }
        else
        {
            /* We're keeping a non-phrase operator, so ladd/radd remain 0 */
        }
 
        return res;
    }
    return node;
}

References Assert, check_stack_depth(), clean_stopword_intree(), QueryOperator::distance, freetree(), NODE::left, Max, OP_NOT, OP_PHRASE, QueryOperator::oper, pfree(), QI_OPR, QI_VAL, QI_VALSTOP, QueryItem::qoperator, res, NODE::right, QueryItem::type, and NODE::valnode.

Referenced by clean_stopword_intree(), and cleanup_tsquery_stopwords().

cleanup_tsquery_stopwords()

TSQuery cleanup_tsquery_stopwords	(	TSQuery	in,
		bool	noisy
	)

Definition at line 387 of file tsquery_cleanup.c.

{
    int32       len,
                lenstr,
                commonlen,
                i;
    NODE       *root;
    int         ladd,
                radd;
    TSQuery     out;
    QueryItem  *items;
    char       *operands;
 
    if (in->size == 0)
        return in;
 
    /* eliminate stop words */
    root = clean_stopword_intree(maketree(GETQUERY(in)), &ladd, &radd);
    if (root == NULL)
    {
        if (noisy)
            ereport(NOTICE,
                    (errmsg("text-search query contains only stop words or doesn't contain lexemes, ignored")));
        out = palloc(HDRSIZETQ);
        out->size = 0;
        SET_VARSIZE(out, HDRSIZETQ);
        return out;
    }
 
    /*
     * Build TSQuery from plain view
     */
 
    lenstr = calcstrlen(root);
    items = plaintree(root, &len);
    commonlen = COMPUTESIZE(len, lenstr);
 
    out = palloc(commonlen);
    SET_VARSIZE(out, commonlen);
    out->size = len;
 
    memcpy(GETQUERY(out), items, len * sizeof(QueryItem));
 
    items = GETQUERY(out);
    operands = GETOPERAND(out);
    for (i = 0; i < out->size; i++)
    {
        QueryOperand *op = (QueryOperand *) &items[i];
 
        if (op->type != QI_VAL)
            continue;
 
        memcpy(operands, GETOPERAND(in) + op->distance, op->length);
        operands[op->length] = '\0';
        op->distance = operands - GETOPERAND(out);
        operands += op->length + 1;
    }
 
    return out;
}

References calcstrlen(), clean_stopword_intree(), COMPUTESIZE, QueryOperand::distance, ereport, errmsg(), GETOPERAND, GETQUERY, HDRSIZETQ, i, items, len, QueryOperand::length, maketree(), NOTICE, palloc(), plaintree(), QI_VAL, root, SET_VARSIZE, TSQueryData::size, and QueryOperand::type.

Referenced by parse_tsquery().

freetree()

static void freetree ( NODE *  node )

static

Definition at line 115 of file tsquery_cleanup.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (!node)
        return;
    if (node->left)
        freetree(node->left);
    if (node->right)
        freetree(node->right);
    pfree(node);
}

References check_stack_depth(), freetree(), NODE::left, pfree(), and NODE::right.

Referenced by clean_NOT_intree(), clean_stopword_intree(), and freetree().

maketree()

static NODE * maketree ( QueryItem *  in )

static

Definition at line 33 of file tsquery_cleanup.c.

{
    NODE       *node = (NODE *) palloc(sizeof(NODE));
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    node->valnode = in;
    node->right = node->left = NULL;
    if (in->type == QI_OPR)
    {
        node->right = maketree(in + 1);
        if (in->qoperator.oper != OP_NOT)
            node->left = maketree(in + in->qoperator.left);
    }
    return node;
}

References check_stack_depth(), NODE::left, QueryOperator::left, maketree(), OP_NOT, QueryOperator::oper, palloc(), QI_OPR, QueryItem::qoperator, NODE::right, QueryItem::type, and NODE::valnode.

Referenced by clean_NOT(), cleanup_tsquery_stopwords(), and maketree().

plainnode()

static void plainnode ( PLAINTREE *  state, NODE *  node  )

static

Definition at line 62 of file tsquery_cleanup.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (state->cur == state->len)
    {
        state->len *= 2;
        state->ptr = (QueryItem *) repalloc(state->ptr, state->len * sizeof(QueryItem));
    }
    memcpy(&(state->ptr[state->cur]), node->valnode, sizeof(QueryItem));
    if (node->valnode->type == QI_VAL)
        state->cur++;
    else if (node->valnode->qoperator.oper == OP_NOT)
    {
        state->ptr[state->cur].qoperator.left = 1;
        state->cur++;
        plainnode(state, node->right);
    }
    else
    {
        int         cur = state->cur;
 
        state->cur++;
        plainnode(state, node->right);
        state->ptr[cur].qoperator.left = state->cur - cur;
        plainnode(state, node->left);
    }
    pfree(node);
}

References check_stack_depth(), cur, NODE::left, OP_NOT, QueryOperator::oper, pfree(), plainnode(), QI_VAL, QueryItem::qoperator, repalloc(), NODE::right, QueryItem::type, and NODE::valnode.

Referenced by plainnode(), and plaintree().

plaintree()

static QueryItem * plaintree ( NODE *  root, int *  len  )

static

Definition at line 97 of file tsquery_cleanup.c.

{
    PLAINTREE   pl;
 
    pl.cur = 0;
    pl.len = 16;
    if (root && (root->valnode->type == QI_VAL || root->valnode->type == QI_OPR))
    {
        pl.ptr = (QueryItem *) palloc(pl.len * sizeof(QueryItem));
        plainnode(&pl, root);
    }
    else
        pl.ptr = NULL;
    *len = pl.cur;
    return pl.ptr;
}

References PLAINTREE::cur, PLAINTREE::len, len, palloc(), plainnode(), PLAINTREE::ptr, QI_OPR, QI_VAL, and root.

Referenced by clean_NOT(), and cleanup_tsquery_stopwords().