lquery_op.c File Reference

#include "postgres.h"
#include <ctype.h>
#include "catalog/pg_collation.h"
#include "ltree.h"
#include "miscadmin.h"
#include "utils/array.h"
#include "utils/formatting.h"

Include dependency graph for lquery_op.c:

Go to the source code of this file.

Macros
#define	NEXTVAL(x)   ( (lquery*)( (char*)(x) + INTALIGN( VARSIZE(x) ) ) )

Functions
	PG_FUNCTION_INFO_V1 (ltq_regex)
	PG_FUNCTION_INFO_V1 (ltq_rregex)
	PG_FUNCTION_INFO_V1 (lt_q_regex)
	PG_FUNCTION_INFO_V1 (lt_q_rregex)
static char *	getlexeme (char *start, char *end, int *len)
bool	compare_subnode (ltree_level *t, char *qn, int len, ltree_prefix_eq_func prefix_eq, bool anyend)
bool	ltree_prefix_eq (const char *a, size_t a_sz, const char *b, size_t b_sz)
bool	ltree_prefix_eq_ci (const char *a, size_t a_sz, const char *b, size_t b_sz)
static bool	checkLevel (lquery_level *curq, ltree_level *curt)
static bool	checkCond (lquery_level *curq, int qlen, ltree_level *curt, int tlen)
Datum	ltq_regex (PG_FUNCTION_ARGS)
Datum	ltq_rregex (PG_FUNCTION_ARGS)
Datum	lt_q_regex (PG_FUNCTION_ARGS)
Datum	lt_q_rregex (PG_FUNCTION_ARGS)

Macro Definition Documentation

NEXTVAL

#define NEXTVAL

(

x

)

( (lquery*)( (char*)(x) + INTALIGN( VARSIZE(x) ) ) )

Definition at line 22 of file lquery_op.c.

Function Documentation

checkCond()

static bool checkCond ( lquery_level *  curq, int  qlen, ltree_level *  curt, int  tlen  )

static

Definition at line 185 of file lquery_op.c.

{
    /* Since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    /* Pathological patterns could take awhile, too */
    CHECK_FOR_INTERRUPTS();
 
    /* Loop while we have query items to consider */
    while (qlen > 0)
    {
        int         low,
                    high;
        lquery_level *nextq;
 
        /*
         * Get min and max repetition counts for this query item, dealing with
         * the backwards-compatibility hack that the low/high fields aren't
         * meaningful for non-'*' items unless LQL_COUNT is set.
         */
        if ((curq->flag & LQL_COUNT) || curq->numvar == 0)
            low = curq->low, high = curq->high;
        else
            low = high = 1;
 
        /*
         * We may limit "high" to the remaining text length; this avoids
         * separate tests below.
         */
        if (high > tlen)
            high = tlen;
 
        /* Fail if a match of required number of items is impossible */
        if (high < low)
            return false;
 
        /*
         * Recursively check the rest of the pattern against each possible
         * start point following some of this item's match(es).
         */
        nextq = LQL_NEXT(curq);
        qlen--;
 
        for (int matchcnt = 0; matchcnt < high; matchcnt++)
        {
            /*
             * If we've consumed an acceptable number of matches of this item,
             * and the rest of the pattern matches beginning here, we're good.
             */
            if (matchcnt >= low && checkCond(nextq, qlen, curt, tlen))
                return true;
 
            /*
             * Otherwise, try to match one more text item to this query item.
             */
            if (!checkLevel(curq, curt))
                return false;
 
            curt = LEVEL_NEXT(curt);
            tlen--;
        }
 
        /*
         * Once we've consumed "high" matches, we can succeed only if the rest
         * of the pattern matches beginning here.  Loop around (if you prefer,
         * think of this as tail recursion).
         */
        curq = nextq;
    }
 
    /*
     * Once we're out of query items, we match only if there's no remaining
     * text either.
     */
    return (tlen == 0);
}

References CHECK_FOR_INTERRUPTS, check_stack_depth(), checkCond(), checkLevel(), lquery_level::flag, lquery_level::high, LEVEL_NEXT, lquery_level::low, LQL_COUNT, LQL_NEXT, and lquery_level::numvar.

Referenced by checkCond(), and ltq_regex().

checkLevel()

static bool checkLevel ( lquery_level *  curq, ltree_level *  curt  )

static

Definition at line 148 of file lquery_op.c.

{
    lquery_variant *curvar = LQL_FIRST(curq);
    bool        success;
 
    success = (curq->flag & LQL_NOT) ? false : true;
 
    /* numvar == 0 means '*' which matches anything */
    if (curq->numvar == 0)
        return success;
 
    for (int i = 0; i < curq->numvar; i++)
    {
        ltree_prefix_eq_func prefix_eq;
 
        prefix_eq = (curvar->flag & LVAR_INCASE) ? ltree_prefix_eq_ci : ltree_prefix_eq;
 
        if (curvar->flag & LVAR_SUBLEXEME)
        {
            if (compare_subnode(curt, curvar->name, curvar->len, prefix_eq,
                                (curvar->flag & LVAR_ANYEND)))
                return success;
        }
        else if ((curvar->len == curt->len ||
                  (curt->len > curvar->len && (curvar->flag & LVAR_ANYEND))) &&
                 (*prefix_eq) (curvar->name, curvar->len, curt->name, curt->len))
            return success;
 
        curvar = LVAR_NEXT(curvar);
    }
    return !success;
}

References compare_subnode(), lquery_variant::flag, lquery_level::flag, i, ltree_level::len, lquery_variant::len, LQL_FIRST, LQL_NOT, ltree_prefix_eq(), ltree_prefix_eq_ci(), LVAR_ANYEND, LVAR_INCASE, LVAR_NEXT, LVAR_SUBLEXEME, ltree_level::name, lquery_variant::name, lquery_level::numvar, and success.

Referenced by checkCond().

compare_subnode()

bool compare_subnode	(	ltree_level *	t,
		char *	qn,
		int	len,
		ltree_prefix_eq_func	prefix_eq,
		bool	anyend
	)

Definition at line 44 of file lquery_op.c.

{
    char       *endt = t->name + t->len;
    char       *endq = qn + len;
    char       *tn;
    int         lent,
                lenq;
    bool        isok;
 
    while ((qn = getlexeme(qn, endq, &lenq)) != NULL)
    {
        tn = t->name;
        isok = false;
        while ((tn = getlexeme(tn, endt, &lent)) != NULL)
        {
            if ((lent == lenq || (lent > lenq && anyend)) &&
                (*prefix_eq) (qn, lenq, tn, lent))
            {
 
                isok = true;
                break;
            }
            tn += lent;
        }
 
        if (!isok)
            return false;
        qn += lenq;
    }
 
    return true;
}

References getlexeme(), ltree_level::len, len, and ltree_level::name.

Referenced by checkcondition_str(), and checkLevel().

getlexeme()

static char * getlexeme ( char *  start, char *  end, int *  len  )

static

Definition at line 25 of file lquery_op.c.

{
    char       *ptr;
 
    while (start < end && t_iseq(start, '_'))
        start += pg_mblen(start);
 
    ptr = start;
    if (ptr >= end)
        return NULL;
 
    while (ptr < end && !t_iseq(ptr, '_'))
        ptr += pg_mblen(ptr);
 
    *len = ptr - start;
    return start;
}

References len, pg_mblen(), start, and t_iseq.

Referenced by compare_subnode().

lt_q_regex()

Datum lt_q_regex

(

PG_FUNCTION_ARGS

)

Definition at line 288 of file lquery_op.c.

{
    ltree      *tree = PG_GETARG_LTREE_P(0);
    ArrayType  *_query = PG_GETARG_ARRAYTYPE_P(1);
    lquery     *query = (lquery *) ARR_DATA_PTR(_query);
    bool        res = false;
    int         num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
 
    if (ARR_NDIM(_query) > 1)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("array must be one-dimensional")));
    if (array_contains_nulls(_query))
        ereport(ERROR,
                (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                 errmsg("array must not contain nulls")));
 
    while (num > 0)
    {
        if (DatumGetBool(DirectFunctionCall2(ltq_regex,
                                             PointerGetDatum(tree), PointerGetDatum(query))))
        {
 
            res = true;
            break;
        }
        num--;
        query = NEXTVAL(query);
    }
 
    PG_FREE_IF_COPY(tree, 0);
    PG_FREE_IF_COPY(_query, 1);
    PG_RETURN_BOOL(res);
}

References ARR_DATA_PTR, ARR_DIMS, ARR_NDIM, array_contains_nulls(), ArrayGetNItems(), DatumGetBool(), DirectFunctionCall2, ereport, errcode(), errmsg(), ERROR, ltq_regex(), NEXTVAL, PG_FREE_IF_COPY, PG_GETARG_ARRAYTYPE_P, PG_GETARG_LTREE_P, PG_RETURN_BOOL, PointerGetDatum(), and tree.

Referenced by lt_q_rregex(), and ltree_consistent().

lt_q_rregex()

Datum lt_q_rregex

(

PG_FUNCTION_ARGS

)

Definition at line 324 of file lquery_op.c.

{
    PG_RETURN_DATUM(DirectFunctionCall2(lt_q_regex,
                                        PG_GETARG_DATUM(1),
                                        PG_GETARG_DATUM(0)
                                        ));
}

References DirectFunctionCall2, lt_q_regex(), PG_GETARG_DATUM, and PG_RETURN_DATUM.

ltq_regex()

Datum ltq_regex

(

PG_FUNCTION_ARGS

)

Definition at line 264 of file lquery_op.c.

{
    ltree      *tree = PG_GETARG_LTREE_P(0);
    lquery     *query = PG_GETARG_LQUERY_P(1);
    bool        res;
 
    res = checkCond(LQUERY_FIRST(query), query->numlevel,
                    LTREE_FIRST(tree), tree->numlevel);
 
    PG_FREE_IF_COPY(tree, 0);
    PG_FREE_IF_COPY(query, 1);
    PG_RETURN_BOOL(res);
}

References checkCond(), LQUERY_FIRST, LTREE_FIRST, lquery::numlevel, PG_FREE_IF_COPY, PG_GETARG_LQUERY_P, PG_GETARG_LTREE_P, PG_RETURN_BOOL, and tree.

Referenced by _lt_q_regex(), _ltq_extract_regex(), _ltq_regex(), lt_q_regex(), ltq_rregex(), and ltree_consistent().

ltq_rregex()

Datum ltq_rregex

(

PG_FUNCTION_ARGS

)

Definition at line 279 of file lquery_op.c.

{
    PG_RETURN_DATUM(DirectFunctionCall2(ltq_regex,
                                        PG_GETARG_DATUM(1),
                                        PG_GETARG_DATUM(0)
                                        ));
}

References DirectFunctionCall2, ltq_regex(), PG_GETARG_DATUM, and PG_RETURN_DATUM.

ltree_prefix_eq()

bool ltree_prefix_eq	(	const char *	a,
		size_t	a_sz,
		const char *	b,
		size_t	b_sz
	)

Definition at line 82 of file lquery_op.c.

{
    if (a_sz > b_sz)
        return false;
    else
        return (strncmp(a, b, a_sz) == 0);
}

References a, and b.

Referenced by checkcondition_str(), and checkLevel().

ltree_prefix_eq_ci()

bool ltree_prefix_eq_ci	(	const char *	a,
		size_t	a_sz,
		const char *	b,
		size_t	b_sz
	)

Definition at line 94 of file lquery_op.c.

{
    static pg_locale_t locale = NULL;
    size_t      al_sz = a_sz + 1;
    size_t      al_len;
    char       *al = palloc(al_sz);
    size_t      bl_sz = b_sz + 1;
    size_t      bl_len;
    char       *bl = palloc(bl_sz);
    bool        res;
 
    if (!locale)
        locale = pg_database_locale();
 
    /* casefold both a and b */
 
    al_len = pg_strfold(al, al_sz, a, a_sz, locale);
    if (al_len + 1 > al_sz)
    {
        /* grow buffer if needed and retry */
        al_sz = al_len + 1;
        al = repalloc(al, al_sz);
        al_len = pg_strfold(al, al_sz, a, a_sz, locale);
        Assert(al_len + 1 <= al_sz);
    }
 
    bl_len = pg_strfold(bl, bl_sz, b, b_sz, locale);
    if (bl_len + 1 > bl_sz)
    {
        /* grow buffer if needed and retry */
        bl_sz = bl_len + 1;
        bl = repalloc(bl, bl_sz);
        bl_len = pg_strfold(bl, bl_sz, b, b_sz, locale);
        Assert(bl_len + 1 <= bl_sz);
    }
 
    if (al_len > bl_len)
        res = false;
    else
        res = (strncmp(al, bl, al_len) == 0);
 
    pfree(al);
    pfree(bl);
 
    return res;
}

References a, Assert(), b, locale, palloc(), pfree(), pg_database_locale(), pg_strfold(), and repalloc().

Referenced by checkcondition_str(), and checkLevel().

PG_FUNCTION_INFO_V1() [1/4]

PG_FUNCTION_INFO_V1

(

lt_q_regex

)

PG_FUNCTION_INFO_V1() [2/4]

PG_FUNCTION_INFO_V1

(

lt_q_rregex

)

PG_FUNCTION_INFO_V1() [3/4]

PG_FUNCTION_INFO_V1

(

ltq_regex

)

PG_FUNCTION_INFO_V1() [4/4]

PG_FUNCTION_INFO_V1

(

ltq_rregex

)