_int_bool.c File Reference

#include "postgres.h"
#include "_int.h"
#include "miscadmin.h"

Include dependency graph for _int_bool.c:

Go to the source code of this file.

Data Structures
struct	NODE
struct	WORKSTATE
struct	CHKVAL
struct	GinChkVal
struct	INFIX

Macros
#define	WAITOPERAND   1
#define	WAITENDOPERAND   2
#define	WAITOPERATOR   3
#define	STACKDEPTH   16
#define	RESIZEBUF(inf, addsize)

Typedefs
typedef struct NODE	NODE

Functions
	PG_FUNCTION_INFO_V1 (bqarr_in)
	PG_FUNCTION_INFO_V1 (bqarr_out)
	PG_FUNCTION_INFO_V1 (boolop)
	PG_FUNCTION_INFO_V1 (rboolop)
	PG_FUNCTION_INFO_V1 (querytree)
static int32	gettoken (WORKSTATE *state, int32 *val)
static void	pushquery (WORKSTATE *state, int32 type, int32 val)
static int32	makepol (WORKSTATE *state)
static bool	checkcondition_arr (void *checkval, ITEM *item, void *options)
static bool	checkcondition_bit (void *checkval, ITEM *item, void *siglen)
static bool	execute (ITEM *curitem, void *checkval, void *options, bool calcnot, bool(*chkcond)(void *checkval, ITEM *item, void *options))
bool	signconsistent (QUERYTYPE *query, BITVECP sign, int siglen, bool calcnot)
bool	execconsistent (QUERYTYPE *query, ArrayType *array, bool calcnot)
static bool	checkcondition_gin (void *checkval, ITEM *item, void *options)
bool	gin_bool_consistent (QUERYTYPE *query, bool *check)
static bool	contains_required_value (ITEM *curitem)
bool	query_has_required_values (QUERYTYPE *query)
Datum	rboolop (PG_FUNCTION_ARGS)
Datum	boolop (PG_FUNCTION_ARGS)
static bool	findoprnd (WORKSTATE *state, ITEM *ptr, int32 *pos)
Datum	bqarr_in (PG_FUNCTION_ARGS)
static void	infix (INFIX *in, bool first)
Datum	bqarr_out (PG_FUNCTION_ARGS)
Datum	querytree (PG_FUNCTION_ARGS)

Macro Definition Documentation

RESIZEBUF

#define RESIZEBUF	(		inf,
			addsize
	)

Value:

    while( ( (inf)->cur - (inf)->buf ) + (addsize) + 1 >= (inf)->buflen ) { \
    int32 len = inf->cur - inf->buf; \
    inf->buflen *= 2; \
    inf->buf = (char*) repalloc( (void*)inf->buf, inf->buflen ); \
    inf->cur = inf->buf + len; \
}

Definition at line 603 of file _int_bool.c.

                                                                                                     { \
    int32 len = inf->cur - inf->buf; \
    inf->buflen *= 2; \
    inf->buf = (char*) repalloc( (void*)inf->buf, inf->buflen ); \
    inf->cur = inf->buf + len; \
}

STACKDEPTH

#define STACKDEPTH   16

Definition at line 147 of file _int_bool.c.

WAITENDOPERAND

#define WAITENDOPERAND   2

Definition at line 18 of file _int_bool.c.

WAITOPERAND

#define WAITOPERAND   1

Definition at line 17 of file _int_bool.c.

WAITOPERATOR

#define WAITOPERATOR   3

Definition at line 19 of file _int_bool.c.

Typedef Documentation

NODE

typedef struct NODE NODE

Function Documentation

boolop()

Datum boolop

(

PG_FUNCTION_ARGS

)

Definition at line 417 of file _int_bool.c.

{
    ArrayType  *val = PG_GETARG_ARRAYTYPE_P_COPY(0);
    QUERYTYPE  *query = PG_GETARG_QUERYTYPE_P(1);
    CHKVAL      chkval;
    bool        result;
 
    CHECKARRVALID(val);
    PREPAREARR(val);
    chkval.arrb = ARRPTR(val);
    chkval.arre = chkval.arrb + ARRNELEMS(val);
    result = execute(GETQUERY(query) + query->size - 1,
                     &chkval, NULL, true,
                     checkcondition_arr);
    pfree(val);
 
    PG_FREE_IF_COPY(query, 1);
    PG_RETURN_BOOL(result);
}

References ARRNELEMS, ARRPTR, CHECKARRVALID, checkcondition_arr(), execute(), fb(), GETQUERY, pfree(), PG_FREE_IF_COPY, PG_GETARG_ARRAYTYPE_P_COPY, PG_GETARG_QUERYTYPE_P, PG_RETURN_BOOL, PREPAREARR, result, QUERYTYPE::size, and val.

Referenced by is_andclause(), is_notclause(), is_orclause(), makeBoolExpr(), and rboolop().

bqarr_in()

Datum bqarr_in

(

PG_FUNCTION_ARGS

)

Definition at line 515 of file _int_bool.c.

{
    char       *buf = (char *) PG_GETARG_POINTER(0);
    WORKSTATE   state;
    int32       i;
    QUERYTYPE  *query;
    int32       commonlen;
    ITEM       *ptr;
    NODE       *tmp;
    int32       pos = 0;
    struct Node *escontext = fcinfo->context;
 
#ifdef BS_DEBUG
    StringInfoData pbuf;
#endif
 
    state.buf = buf;
    state.state = WAITOPERAND;
    state.count = 0;
    state.num = 0;
    state.str = NULL;
    state.escontext = escontext;
 
    /* make polish notation (postfix, but in reverse order) */
    if (makepol(&state) == ERR)
        PG_RETURN_NULL();
    if (!state.num)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("empty query")));
 
    if (state.num > QUERYTYPEMAXITEMS)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("number of query items (%d) exceeds the maximum allowed (%d)",
                        state.num, (int) QUERYTYPEMAXITEMS)));
    commonlen = COMPUTESIZE(state.num);
 
    query = (QUERYTYPE *) palloc(commonlen);
    SET_VARSIZE(query, commonlen);
    query->size = state.num;
    ptr = GETQUERY(query);
 
    /* fill the query array from the data makepol constructed */
    for (i = state.num - 1; i >= 0; i--)
    {
        ptr[i].type = state.str->type;
        ptr[i].val = state.str->val;
        tmp = state.str->next;
        pfree(state.str);
        state.str = tmp;
    }
 
    /* now fill the "left" fields */
    pos = query->size - 1;
    if (!findoprnd(&state, ptr, &pos))
        PG_RETURN_NULL();
    /* if successful, findoprnd should have scanned the whole array */
    Assert(pos == -1);
 
#ifdef BS_DEBUG
    initStringInfo(&pbuf);
    for (i = 0; i < query->size; i++)
    {
        if (ptr[i].type == OPR)
            appendStringInfo(&pbuf, "%c(%d) ", ptr[i].val, ptr[i].left);
        else
            appendStringInfo(&pbuf, "%d ", ptr[i].val);
    }
    elog(DEBUG3, "POR: %s", pbuf.data);
    pfree(pbuf.data);
#endif
 
    PG_RETURN_POINTER(query);
}

References appendStringInfo(), Assert, buf, COMPUTESIZE, DEBUG3, elog, ereturn, ERR, errcode(), errmsg, fb(), findoprnd(), GETQUERY, i, initStringInfo(), makepol(), state::next, OPR, palloc(), pfree(), PG_GETARG_POINTER, PG_RETURN_NULL, PG_RETURN_POINTER, QUERYTYPEMAXITEMS, SET_VARSIZE(), QUERYTYPE::size, ITEM::type, type, ITEM::val, val, and WAITOPERAND.

bqarr_out()

Datum bqarr_out

(

PG_FUNCTION_ARGS

)

Definition at line 688 of file _int_bool.c.

{
    QUERYTYPE  *query = PG_GETARG_QUERYTYPE_P(0);
    INFIX       nrm;
 
    if (query->size == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("empty query")));
 
    nrm.curpol = GETQUERY(query) + query->size - 1;
    nrm.buflen = 32;
    nrm.cur = nrm.buf = palloc_array(char, nrm.buflen);
    *(nrm.cur) = '\0';
    infix(&nrm, true);
 
    PG_FREE_IF_COPY(query, 0);
    PG_RETURN_POINTER(nrm.buf);
}

References ereport, errcode(), errmsg, ERROR, fb(), GETQUERY, infix(), palloc_array, PG_FREE_IF_COPY, PG_GETARG_QUERYTYPE_P, PG_RETURN_POINTER, and QUERYTYPE::size.

checkcondition_arr()

static bool checkcondition_arr ( void *  checkval, ITEM *  item, void *  options  )

static

Definition at line 233 of file _int_bool.c.

{
    int32      *StopLow = ((CHKVAL *) checkval)->arrb;
    int32      *StopHigh = ((CHKVAL *) checkval)->arre;
    int32      *StopMiddle;
 
    /* Loop invariant: StopLow <= val < StopHigh */
 
    while (StopLow < StopHigh)
    {
        StopMiddle = StopLow + (StopHigh - StopLow) / 2;
        if (*StopMiddle == item->val)
            return true;
        else if (*StopMiddle < item->val)
            StopLow = StopMiddle + 1;
        else
            StopHigh = StopMiddle;
    }
    return false;
}

References CHKVAL::arrb, fb(), ITEM::val, and val.

Referenced by boolop(), and execconsistent().

checkcondition_bit()

static bool checkcondition_bit ( void *  checkval, ITEM *  item, void *  siglen  )

static

Definition at line 255 of file _int_bool.c.

{
    return GETBIT(checkval, HASHVAL(item->val, (int) (intptr_t) siglen));
}

References fb(), GETBIT, HASHVAL, and ITEM::val.

Referenced by signconsistent().

checkcondition_gin()

static bool checkcondition_gin ( void *  checkval, ITEM *  item, void *  options  )

static

Definition at line 326 of file _int_bool.c.

{
    GinChkVal  *gcv = (GinChkVal *) checkval;
 
    return gcv->mapped_check[item - gcv->first];
}

References fb(), and GinChkVal::mapped_check.

Referenced by gin_bool_consistent().

contains_required_value()

static bool contains_required_value ( ITEM *  curitem )

static

Definition at line 362 of file _int_bool.c.

{
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    if (curitem->type == VAL)
        return true;
    else if (curitem->val == (int32) '!')
    {
        /*
         * Assume anything under a NOT is non-required.  For some cases with
         * nested NOTs, we could prove there's a required value, but it seems
         * unlikely to be worth the trouble.
         */
        return false;
    }
    else if (curitem->val == (int32) '&')
    {
        /* If either side has a required value, we're good */
        if (contains_required_value(curitem + curitem->left))
            return true;
        else
            return contains_required_value(curitem - 1);
    }
    else
    {                           /* |-operator */
        /* Both sides must have required values */
        if (contains_required_value(curitem + curitem->left))
            return contains_required_value(curitem - 1);
        else
            return false;
    }
}

References check_stack_depth(), contains_required_value(), ITEM::left, ITEM::type, ITEM::val, and VAL.

Referenced by contains_required_value(), and query_has_required_values().

execconsistent()

bool execconsistent	(	QUERYTYPE *	query,
		ArrayType *	array,
		bool	calcnot
	)

Definition at line 307 of file _int_bool.c.

{
    CHKVAL      chkval;
 
    CHECKARRVALID(array);
    chkval.arrb = ARRPTR(array);
    chkval.arre = chkval.arrb + ARRNELEMS(array);
    return execute(GETQUERY(query) + query->size - 1,
                   &chkval, NULL, calcnot,
                   checkcondition_arr);
}

References ARRNELEMS, ARRPTR, CHECKARRVALID, checkcondition_arr(), execute(), fb(), GETQUERY, and QUERYTYPE::size.

Referenced by g_int_consistent().

execute()

static bool execute ( ITEM *  curitem, void *  checkval, void *  options, bool  calcnot, bool(*)(void *checkval, ITEM *item, void *options)  chkcond  )

static

Definition at line 264 of file _int_bool.c.

{
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    if (curitem->type == VAL)
        return (*chkcond) (checkval, curitem, options);
    else if (curitem->val == (int32) '!')
    {
        return calcnot ?
            ((execute(curitem - 1, checkval, options, calcnot, chkcond)) ? false : true)
            : true;
    }
    else if (curitem->val == (int32) '&')
    {
        if (execute(curitem + curitem->left, checkval, options, calcnot, chkcond))
            return execute(curitem - 1, checkval, options, calcnot, chkcond);
        else
            return false;
    }
    else
    {                           /* |-operator */
        if (execute(curitem + curitem->left, checkval, options, calcnot, chkcond))
            return true;
        else
            return execute(curitem - 1, checkval, options, calcnot, chkcond);
    }
}

References check_stack_depth(), execute(), fb(), ITEM::type, and VAL.

Referenced by boolop(), execconsistent(), execute(), gin_bool_consistent(), and signconsistent().

findoprnd()

static bool findoprnd ( WORKSTATE *  state, ITEM *  ptr, int32 *  pos  )

static

Definition at line 452 of file _int_bool.c.

{
    int32       mypos;
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    /* get the position this call is supposed to update */
    mypos = *pos;
    Assert(mypos >= 0);
 
    /* in all cases, we should decrement *pos to advance over this item */
    (*pos)--;
 
#ifdef BS_DEBUG
    elog(DEBUG3, (ptr[mypos].type == OPR) ?
         "%d  %c" : "%d  %d", mypos, ptr[mypos].val);
#endif
 
    if (ptr[mypos].type == VAL)
    {
        /* base case: a VAL has no operand, so just set its left to zero */
        ptr[mypos].left = 0;
    }
    else if (ptr[mypos].val == (int32) '!')
    {
        /* unary operator, likewise easy: operand is just before it */
        ptr[mypos].left = -1;
        /* recurse to scan operand */
        if (!findoprnd(state, ptr, pos))
            return false;
    }
    else
    {
        /* binary operator */
        int32       delta;
 
        /* recurse to scan right operand */
        if (!findoprnd(state, ptr, pos))
            return false;
        /* we must fill left with offset to left operand's top */
        /* abs(delta) < QUERYTYPEMAXITEMS, so it can't overflow ... */
        delta = *pos - mypos;
        /* ... but it might be too large to fit in the 16-bit left field */
        Assert(delta < 0);
        if (unlikely(delta < PG_INT16_MIN))
            ereturn(state->escontext, false,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("query_int expression is too complex")));
        ptr[mypos].left = (int16) delta;
        /* recurse to scan left operand */
        if (!findoprnd(state, ptr, pos))
            return false;
    }
 
    return true;
}

References Assert, check_stack_depth(), DEBUG3, elog, ereturn, errcode(), errmsg, fb(), findoprnd(), ITEM::left, OPR, PG_INT16_MIN, type, unlikely, ITEM::val, VAL, and val.

Referenced by bqarr_in(), and findoprnd().

gettoken()

static int32 gettoken ( WORKSTATE *  state, int32 *  val  )

static

Definition at line 48 of file _int_bool.c.

{
    char        nnn[16];
    int         innn;
 
    *val = 0;                   /* default result */
 
    innn = 0;
    while (1)
    {
        if (innn >= sizeof(nnn))
            return ERR;         /* buffer overrun => syntax error */
        switch (state->state)
        {
            case WAITOPERAND:
                innn = 0;
                if ((*(state->buf) >= '0' && *(state->buf) <= '9') ||
                    *(state->buf) == '-')
                {
                    state->state = WAITENDOPERAND;
                    nnn[innn++] = *(state->buf);
                }
                else if (*(state->buf) == '!')
                {
                    (state->buf)++;
                    *val = (int32) '!';
                    return OPR;
                }
                else if (*(state->buf) == '(')
                {
                    state->count++;
                    (state->buf)++;
                    return OPEN;
                }
                else if (*(state->buf) != ' ')
                    return ERR;
                break;
            case WAITENDOPERAND:
                if (*(state->buf) >= '0' && *(state->buf) <= '9')
                {
                    nnn[innn++] = *(state->buf);
                }
                else
                {
                    long        lval;
 
                    nnn[innn] = '\0';
                    errno = 0;
                    lval = strtol(nnn, NULL, 0);
                    *val = (int32) lval;
                    if (errno != 0 || (long) *val != lval)
                        return ERR;
                    state->state = WAITOPERATOR;
                    return (state->count && *(state->buf) == '\0')
                        ? ERR : VAL;
                }
                break;
            case WAITOPERATOR:
                if (*(state->buf) == '&' || *(state->buf) == '|')
                {
                    state->state = WAITOPERAND;
                    *val = (int32) *(state->buf);
                    (state->buf)++;
                    return OPR;
                }
                else if (*(state->buf) == ')')
                {
                    (state->buf)++;
                    state->count--;
                    return (state->count < 0) ? ERR : CLOSE;
                }
                else if (*(state->buf) == '\0')
                    return (state->count) ? ERR : END;
                else if (*(state->buf) != ' ')
                    return ERR;
                break;
            default:
                return ERR;
                break;
        }
        (state->buf)++;
    }
}

References CLOSE, END, ERR, fb(), OPEN, OPR, VAL, val, WAITENDOPERAND, WAITOPERAND, and WAITOPERATOR.

Referenced by makepol().

gin_bool_consistent()

bool gin_bool_consistent	(	QUERYTYPE *	query,
		bool *	check
	)

Definition at line 334 of file _int_bool.c.

{
    GinChkVal   gcv;
    ITEM       *items = GETQUERY(query);
    int         i,
                j = 0;
 
    if (query->size <= 0)
        return false;
 
    /*
     * Set up data for checkcondition_gin.  This must agree with the query
     * extraction code in ginint4_queryextract.
     */
    gcv.first = items;
    gcv.mapped_check = palloc_array(bool, query->size);
    for (i = 0; i < query->size; i++)
    {
        if (items[i].type == VAL)
            gcv.mapped_check[i] = check[j++];
    }
 
    return execute(GETQUERY(query) + query->size - 1,
                   &gcv, NULL, true,
                   checkcondition_gin);
}

References checkcondition_gin(), execute(), fb(), GETQUERY, i, items, j, palloc_array, QUERYTYPE::size, type, and VAL.

Referenced by ginint4_consistent().

infix()

static void infix ( INFIX *  in, bool  first  )

static

Definition at line 611 of file _int_bool.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->curpol->type == VAL)
    {
        RESIZEBUF(in, 11);
        sprintf(in->cur, "%d", in->curpol->val);
        in->cur = strchr(in->cur, '\0');
        in->curpol--;
    }
    else if (in->curpol->val == (int32) '!')
    {
        bool        isopr = false;
 
        RESIZEBUF(in, 1);
        *(in->cur) = '!';
        in->cur++;
        *(in->cur) = '\0';
        in->curpol--;
        if (in->curpol->type == OPR)
        {
            isopr = true;
            RESIZEBUF(in, 2);
            sprintf(in->cur, "( ");
            in->cur = strchr(in->cur, '\0');
        }
        infix(in, isopr);
        if (isopr)
        {
            RESIZEBUF(in, 2);
            sprintf(in->cur, " )");
            in->cur = strchr(in->cur, '\0');
        }
    }
    else
    {
        int32       op = in->curpol->val;
        INFIX       nrm;
 
        in->curpol--;
        if (op == (int32) '|' && !first)
        {
            RESIZEBUF(in, 2);
            sprintf(in->cur, "( ");
            in->cur = strchr(in->cur, '\0');
        }
 
        nrm.curpol = in->curpol;
        nrm.buflen = 16;
        nrm.cur = nrm.buf = palloc_array(char, nrm.buflen);
 
        /* get right operand */
        infix(&nrm, false);
 
        /* get & print left operand */
        in->curpol = nrm.curpol;
        infix(in, false);
 
        /* print operator & right operand */
        RESIZEBUF(in, 3 + (nrm.cur - nrm.buf));
        sprintf(in->cur, " %c %s", op, nrm.buf);
        in->cur = strchr(in->cur, '\0');
        pfree(nrm.buf);
 
        if (op == (int32) '|' && !first)
        {
            RESIZEBUF(in, 2);
            sprintf(in->cur, " )");
            in->cur = strchr(in->cur, '\0');
        }
    }
}

References check_stack_depth(), INFIX::cur, INFIX::curpol, fb(), infix(), OPR, palloc_array, pfree(), RESIZEBUF, sprintf, ITEM::type, ITEM::val, and VAL.

Referenced by bqarr_out(), and infix().

makepol()

static int32 makepol ( WORKSTATE *  state )

static

Definition at line 153 of file _int_bool.c.

{
    int32       val,
                type;
    int32       stack[STACKDEPTH];
    int32       lenstack = 0;
 
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    while ((type = gettoken(state, &val)) != END)
    {
        switch (type)
        {
            case VAL:
                pushquery(state, type, val);
                while (lenstack && (stack[lenstack - 1] == (int32) '&' ||
                                    stack[lenstack - 1] == (int32) '!'))
                {
                    lenstack--;
                    pushquery(state, OPR, stack[lenstack]);
                }
                break;
            case OPR:
                if (lenstack && val == (int32) '|')
                    pushquery(state, OPR, val);
                else
                {
                    if (lenstack == STACKDEPTH)
                        ereturn(state->escontext, ERR,
                                (errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
                                 errmsg("statement too complex")));
                    stack[lenstack] = val;
                    lenstack++;
                }
                break;
            case OPEN:
                if (makepol(state) == ERR)
                    return ERR;
                while (lenstack && (stack[lenstack - 1] == (int32) '&' ||
                                    stack[lenstack - 1] == (int32) '!'))
                {
                    lenstack--;
                    pushquery(state, OPR, stack[lenstack]);
                }
                break;
            case CLOSE:
                while (lenstack)
                {
                    lenstack--;
                    pushquery(state, OPR, stack[lenstack]);
                };
                return END;
                break;
            case ERR:
            default:
                ereturn(state->escontext, ERR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("syntax error")));
        }
    }
 
    while (lenstack)
    {
        lenstack--;
        pushquery(state, OPR, stack[lenstack]);
    };
    return END;
}

References check_stack_depth(), CLOSE, END, ereturn, ERR, errcode(), errmsg, fb(), gettoken(), makepol(), OPEN, OPR, pushquery(), STACKDEPTH, type, VAL, and val.

Referenced by bqarr_in(), and makepol().

PG_FUNCTION_INFO_V1() [1/5]

PG_FUNCTION_INFO_V1

(

boolop

)

PG_FUNCTION_INFO_V1() [2/5]

PG_FUNCTION_INFO_V1

(

bqarr_in

)

PG_FUNCTION_INFO_V1() [3/5]

PG_FUNCTION_INFO_V1

(

bqarr_out

)

PG_FUNCTION_INFO_V1() [4/5]

PG_FUNCTION_INFO_V1

(

querytree

)

PG_FUNCTION_INFO_V1() [5/5]

PG_FUNCTION_INFO_V1

(

rboolop

)

pushquery()

static void pushquery ( WORKSTATE *  state, int32  type, int32  val  )

static

Definition at line 136 of file _int_bool.c.

{
    NODE       *tmp = palloc_object(NODE);
 
    tmp->type = type;
    tmp->val = val;
    tmp->next = state->str;
    state->str = tmp;
    state->num++;
}

References NODE::next, palloc_object, NODE::type, type, NODE::val, and val.

Referenced by makepol().

query_has_required_values()

bool query_has_required_values

(

QUERYTYPE *

query

)

Definition at line 397 of file _int_bool.c.

{
    if (query->size <= 0)
        return false;
    return contains_required_value(GETQUERY(query) + query->size - 1);
}

References contains_required_value(), GETQUERY, and QUERYTYPE::size.

Referenced by ginint4_queryextract().

querytree()

Datum querytree

(

PG_FUNCTION_ARGS

)

Definition at line 711 of file _int_bool.c.

{
    elog(ERROR, "querytree is no longer implemented");
    PG_RETURN_NULL();
}

References elog, ERROR, and PG_RETURN_NULL.

Referenced by inline_function(), inline_function_in_from(), inline_sql_function_in_from(), pg_plan_query(), and test_inline_in_from_support_func().

rboolop()

Datum rboolop

(

PG_FUNCTION_ARGS

)

Definition at line 408 of file _int_bool.c.

{
    /* just reverse the operands */
    return DirectFunctionCall2(boolop,
                               PG_GETARG_DATUM(1),
                               PG_GETARG_DATUM(0));
}

References boolop(), DirectFunctionCall2, and PG_GETARG_DATUM.

signconsistent()

bool signconsistent	(	QUERYTYPE *	query,
		BITVECP	sign,
		int	siglen,
		bool	calcnot
	)

Definition at line 298 of file _int_bool.c.

{
    return execute(GETQUERY(query) + query->size - 1,
                   sign, (void *) (intptr_t) siglen, calcnot,
                   checkcondition_bit);
}

References checkcondition_bit(), execute(), fb(), GETQUERY, sign, and QUERYTYPE::size.

Referenced by g_intbig_consistent().