readfuncs.c File Reference

#include "postgres.h"
#include "miscadmin.h"
#include "nodes/bitmapset.h"
#include "nodes/readfuncs.h"
#include "readfuncs.funcs.c"
#include "readfuncs.switch.c"

Include dependency graph for readfuncs.c:

Go to the source code of this file.

Macros
#define	READ_LOCALS_NO_FIELDS(nodeTypeName)    nodeTypeName *local_node = makeNode(nodeTypeName)
#define	READ_TEMP_LOCALS()
#define	READ_LOCALS(nodeTypeName)
#define	READ_INT_FIELD(fldname)
#define	READ_UINT_FIELD(fldname)
#define	READ_INT64_FIELD(fldname)
#define	READ_UINT64_FIELD(fldname)
#define	READ_LONG_FIELD(fldname)
#define	READ_OID_FIELD(fldname)
#define	READ_CHAR_FIELD(fldname)
#define	READ_ENUM_FIELD(fldname, enumtype)
#define	READ_FLOAT_FIELD(fldname)
#define	READ_BOOL_FIELD(fldname)
#define	READ_STRING_FIELD(fldname)
#define	READ_LOCATION_FIELD(fldname)
#define	READ_NODE_FIELD(fldname)
#define	READ_BITMAPSET_FIELD(fldname)
#define	READ_ATTRNUMBER_ARRAY(fldname, len)
#define	READ_OID_ARRAY(fldname, len)
#define	READ_INT_ARRAY(fldname, len)
#define	READ_BOOL_ARRAY(fldname, len)
#define	READ_DONE()    return local_node
#define	atoui(x)   ((unsigned int) strtoul((x), NULL, 10))
#define	strtobool(x)   ((*(x) == 't') ? true : false)
#define	MATCH(tokname, namelen)    (length == namelen && memcmp(token, tokname, namelen) == 0)
#define	READ_SCALAR_ARRAY(fnname, datatype, convfunc)

Functions
static char *	nullable_string (const char *token, int length)
static Bitmapset *	_readBitmapset (void)
Bitmapset *	readBitmapset (void)
static Const *	_readConst (void)
static BoolExpr *	_readBoolExpr (void)
static A_Const *	_readA_Const (void)
static RangeTblEntry *	_readRangeTblEntry (void)
static A_Expr *	_readA_Expr (void)
static ExtensibleNode *	_readExtensibleNode (void)
Node *	parseNodeString (void)
Datum	readDatum (bool typbyval)

Macro Definition Documentation

atoui

#define atoui

(

x

)

((unsigned int) strtoul((x), NULL, 10))

Definition at line 181 of file readfuncs.c.

MATCH

#define MATCH	(		tokname,
			namelen
	)		(length == namelen && memcmp(token, tokname, namelen) == 0)

READ_ATTRNUMBER_ARRAY

#define READ_ATTRNUMBER_ARRAY	(		fldname,
			len
	)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    local_node->fldname = readAttrNumberCols(len)

Definition at line 151 of file readfuncs.c.

                                            : false)
 
static char *
nullable_string(const char *token, int length)
{
    /* outToken emits <> for NULL, and pg_strtok makes that an empty string */
    if (length == 0)
        return NULL;
    /* outToken emits "" for empty string */
    if (length == 2 && token[0] == '"' && token[1] == '"')
        return pstrdup("");
    /* otherwise, we must remove protective backslashes added by outToken */
    return debackslash(token, length);
}
 
 
/*
 * _readBitmapset
 *
 * Note: this code is used in contexts where we know that a Bitmapset
 * is expected.  There is equivalent code in nodeRead() that can read a
 * Bitmapset when we come across one in other contexts.
 */
static Bitmapset *
_readBitmapset(void)
{
    Bitmapset  *result = NULL;
 
    READ_TEMP_LOCALS();
 
    token = pg_strtok(&length);
    if (token == NULL)
        elog(ERROR, "incomplete Bitmapset structure");
    if (length != 1 || token[0] != '(')
        elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
 
    token = pg_strtok(&length);
    if (token == NULL)
        elog(ERROR, "incomplete Bitmapset structure");
    if (length != 1 || token[0] != 'b')
        elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
 
    for (;;)
    {
        int         val;
        char       *endptr;
 
        token = pg_strtok(&length);
        if (token == NULL)
            elog(ERROR, "unterminated Bitmapset structure");
        if (length == 1 && token[0] == ')')
            break;
        val = (int) strtol(token, &endptr, 10);
        if (endptr != token + length)
            elog(ERROR, "unrecognized integer: \"%.*s\"", length, token);
        result = bms_add_member(result, val);
    }
 
    return result;
}
 
/*
 * We export this function for use by extensions that define extensible nodes.
 * That's somewhat historical, though, because calling nodeRead() will work.
 */
Bitmapset *
readBitmapset(void)
{
    return _readBitmapset();
}
 
#include "readfuncs.funcs.c"
 
 
/*
 * Support functions for nodes with custom_read_write attribute or
 * special_read_write attribute
 */
 
static Const *
_readConst(void)
{
    READ_LOCALS(Const);
 
    READ_OID_FIELD(consttype);
    READ_INT_FIELD(consttypmod);
    READ_OID_FIELD(constcollid);
    READ_INT_FIELD(constlen);
    READ_BOOL_FIELD(constbyval);
    READ_BOOL_FIELD(constisnull);
    READ_LOCATION_FIELD(location);
 
    token = pg_strtok(&length); /* skip :constvalue */
    if (local_node->constisnull)
        token = pg_strtok(&length); /* skip "<>" */
    else
        local_node->constvalue = readDatum(local_node->constbyval);
 
    READ_DONE();
}
 
static BoolExpr *
_readBoolExpr(void)
{
    READ_LOCALS(BoolExpr);
 
    /* do-it-yourself enum representation */
    token = pg_strtok(&length); /* skip :boolop */
    token = pg_strtok(&length); /* get field value */
    if (length == 3 && strncmp(token, "and", 3) == 0)
        local_node->boolop = AND_EXPR;
    else if (length == 2 && strncmp(token, "or", 2) == 0)
        local_node->boolop = OR_EXPR;
    else if (length == 3 && strncmp(token, "not", 3) == 0)
        local_node->boolop = NOT_EXPR;
    else
        elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
 
    READ_NODE_FIELD(args);
    READ_LOCATION_FIELD(location);
 
    READ_DONE();
}
 
static A_Const *
_readA_Const(void)
{
    READ_LOCALS(A_Const);
 
    /* We expect either NULL or :val here */
    token = pg_strtok(&length);
    if (length == 4 && strncmp(token, "NULL", 4) == 0)
        local_node->isnull = true;
    else
    {
        union ValUnion *tmp = nodeRead(NULL, 0);
 
        /* To forestall valgrind complaints, copy only the valid data */
        switch (nodeTag(tmp))
        {
            case T_Integer:
                memcpy(&local_node->val, tmp, sizeof(Integer));
                break;
            case T_Float:
                memcpy(&local_node->val, tmp, sizeof(Float));
                break;
            case T_Boolean:
                memcpy(&local_node->val, tmp, sizeof(Boolean));
                break;
            case T_String:
                memcpy(&local_node->val, tmp, sizeof(String));
                break;
            case T_BitString:
                memcpy(&local_node->val, tmp, sizeof(BitString));
                break;
            default:
                elog(ERROR, "unrecognized node type: %d",
                     (int) nodeTag(tmp));
                break;
        }
    }
 
    READ_LOCATION_FIELD(location);
 
    READ_DONE();
}
 
static RangeTblEntry *
_readRangeTblEntry(void)
{
    READ_LOCALS(RangeTblEntry);
 
    READ_NODE_FIELD(alias);
    READ_NODE_FIELD(eref);
    READ_ENUM_FIELD(rtekind, RTEKind);
 
    switch (local_node->rtekind)
    {
        case RTE_RELATION:
            READ_OID_FIELD(relid);
            READ_BOOL_FIELD(inh);
            READ_CHAR_FIELD(relkind);
            READ_INT_FIELD(rellockmode);
            READ_UINT_FIELD(perminfoindex);
            READ_NODE_FIELD(tablesample);
            break;
        case RTE_SUBQUERY:
            READ_NODE_FIELD(subquery);
            READ_BOOL_FIELD(security_barrier);
            /* we re-use these RELATION fields, too: */
            READ_OID_FIELD(relid);
            READ_BOOL_FIELD(inh);
            READ_CHAR_FIELD(relkind);
            READ_INT_FIELD(rellockmode);
            READ_UINT_FIELD(perminfoindex);
            break;
        case RTE_JOIN:
            READ_ENUM_FIELD(jointype, JoinType);
            READ_INT_FIELD(joinmergedcols);
            READ_NODE_FIELD(joinaliasvars);
            READ_NODE_FIELD(joinleftcols);
            READ_NODE_FIELD(joinrightcols);
            READ_NODE_FIELD(join_using_alias);
            break;
        case RTE_FUNCTION:
            READ_NODE_FIELD(functions);
            READ_BOOL_FIELD(funcordinality);
            break;
        case RTE_TABLEFUNC:
            READ_NODE_FIELD(tablefunc);
            /* The RTE must have a copy of the column type info, if any */
            if (local_node->tablefunc)
            {
                TableFunc  *tf = local_node->tablefunc;
 
                local_node->coltypes = tf->coltypes;
                local_node->coltypmods = tf->coltypmods;
                local_node->colcollations = tf->colcollations;
            }
            break;
        case RTE_VALUES:
            READ_NODE_FIELD(values_lists);
            READ_NODE_FIELD(coltypes);
            READ_NODE_FIELD(coltypmods);
            READ_NODE_FIELD(colcollations);
            break;
        case RTE_CTE:
            READ_STRING_FIELD(ctename);
            READ_UINT_FIELD(ctelevelsup);
            READ_BOOL_FIELD(self_reference);
            READ_NODE_FIELD(coltypes);
            READ_NODE_FIELD(coltypmods);
            READ_NODE_FIELD(colcollations);
            break;
        case RTE_NAMEDTUPLESTORE:
            READ_STRING_FIELD(enrname);
            READ_FLOAT_FIELD(enrtuples);
            READ_NODE_FIELD(coltypes);
            READ_NODE_FIELD(coltypmods);
            READ_NODE_FIELD(colcollations);
            /* we re-use these RELATION fields, too: */
            READ_OID_FIELD(relid);
            break;
        case RTE_GRAPH_TABLE:
            READ_NODE_FIELD(graph_pattern);
            READ_NODE_FIELD(graph_table_columns);
            /* we re-use these RELATION fields, too: */
            READ_OID_FIELD(relid);
            READ_CHAR_FIELD(relkind);
            READ_INT_FIELD(rellockmode);
            READ_UINT_FIELD(perminfoindex);
            break;
        case RTE_RESULT:
            /* no extra fields */
            break;
        case RTE_GROUP:
            READ_NODE_FIELD(groupexprs);
            break;
        default:
            elog(ERROR, "unrecognized RTE kind: %d",
                 (int) local_node->rtekind);
            break;
    }
 
    READ_BOOL_FIELD(lateral);
    READ_BOOL_FIELD(inFromCl);
    READ_NODE_FIELD(securityQuals);
 
    READ_DONE();
}
 
static A_Expr *
_readA_Expr(void)
{
    READ_LOCALS(A_Expr);
 
    token = pg_strtok(&length);
 
    if (length == 3 && strncmp(token, "ANY", 3) == 0)
    {
        local_node->kind = AEXPR_OP_ANY;
        READ_NODE_FIELD(name);
    }
    else if (length == 3 && strncmp(token, "ALL", 3) == 0)
    {
        local_node->kind = AEXPR_OP_ALL;
        READ_NODE_FIELD(name);
    }
    else if (length == 8 && strncmp(token, "DISTINCT", 8) == 0)
    {
        local_node->kind = AEXPR_DISTINCT;
        READ_NODE_FIELD(name);
    }
    else if (length == 12 && strncmp(token, "NOT_DISTINCT", 12) == 0)
    {
        local_node->kind = AEXPR_NOT_DISTINCT;
        READ_NODE_FIELD(name);
    }
    else if (length == 6 && strncmp(token, "NULLIF", 6) == 0)
    {
        local_node->kind = AEXPR_NULLIF;
        READ_NODE_FIELD(name);
    }
    else if (length == 2 && strncmp(token, "IN", 2) == 0)
    {
        local_node->kind = AEXPR_IN;
        READ_NODE_FIELD(name);
    }
    else if (length == 4 && strncmp(token, "LIKE", 4) == 0)
    {
        local_node->kind = AEXPR_LIKE;
        READ_NODE_FIELD(name);
    }
    else if (length == 5 && strncmp(token, "ILIKE", 5) == 0)
    {
        local_node->kind = AEXPR_ILIKE;
        READ_NODE_FIELD(name);
    }
    else if (length == 7 && strncmp(token, "SIMILAR", 7) == 0)
    {
        local_node->kind = AEXPR_SIMILAR;
        READ_NODE_FIELD(name);
    }
    else if (length == 7 && strncmp(token, "BETWEEN", 7) == 0)
    {
        local_node->kind = AEXPR_BETWEEN;
        READ_NODE_FIELD(name);
    }
    else if (length == 11 && strncmp(token, "NOT_BETWEEN", 11) == 0)
    {
        local_node->kind = AEXPR_NOT_BETWEEN;
        READ_NODE_FIELD(name);
    }
    else if (length == 11 && strncmp(token, "BETWEEN_SYM", 11) == 0)
    {
        local_node->kind = AEXPR_BETWEEN_SYM;
        READ_NODE_FIELD(name);
    }
    else if (length == 15 && strncmp(token, "NOT_BETWEEN_SYM", 15) == 0)
    {
        local_node->kind = AEXPR_NOT_BETWEEN_SYM;
        READ_NODE_FIELD(name);
    }
    else if (length == 5 && strncmp(token, ":name", 5) == 0)
    {
        local_node->kind = AEXPR_OP;
        local_node->name = nodeRead(NULL, 0);
    }
    else
        elog(ERROR, "unrecognized A_Expr kind: \"%.*s\"", length, token);
 
    READ_NODE_FIELD(lexpr);
    READ_NODE_FIELD(rexpr);
    READ_LOCATION_FIELD(rexpr_list_start);
    READ_LOCATION_FIELD(rexpr_list_end);
    READ_LOCATION_FIELD(location);
 
    READ_DONE();
}
 
static ExtensibleNode *
_readExtensibleNode(void)
{
    const ExtensibleNodeMethods *methods;
    ExtensibleNode *local_node;
    const char *extnodename;
 
    READ_TEMP_LOCALS();
 
    token = pg_strtok(&length); /* skip :extnodename */
    token = pg_strtok(&length); /* get extnodename */
 
    extnodename = nullable_string(token, length);
    if (!extnodename)
        elog(ERROR, "extnodename has to be supplied");
    methods = GetExtensibleNodeMethods(extnodename, false);
 
    local_node = (ExtensibleNode *) newNode(methods->node_size,
                                            T_ExtensibleNode);
    local_node->extnodename = extnodename;
 
    /* deserialize the private fields */
    methods->nodeRead(local_node);
 
    READ_DONE();
}
 
 
/*
 * parseNodeString
 *
 * Given a character string representing a node tree, parseNodeString creates
 * the internal node structure.
 *
 * The string to be read must already have been loaded into pg_strtok().
 */
Node *
parseNodeString(void)
{
    READ_TEMP_LOCALS();
 
    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();
 
    token = pg_strtok(&length);
 
#define MATCH(tokname, namelen) \
    (length == namelen && memcmp(token, tokname, namelen) == 0)
 
#include "readfuncs.switch.c"
 
    elog(ERROR, "badly formatted node string \"%.32s\"...", token);
    return NULL;                /* keep compiler quiet */
}
 
 
/*
 * readDatum
 *
 * Given a string representation of a constant, recreate the appropriate
 * Datum.  The string representation embeds length info, but not byValue,
 * so we must be told that.
 */
Datum
readDatum(bool typbyval)
{
    Size        length;
    int         tokenLength;
    const char *token;
    Datum       res;
    char       *s;
 
    /*
     * read the actual length of the value
     */
    token = pg_strtok(&tokenLength);
    length = atoui(token);
 
    token = pg_strtok(&tokenLength);    /* read the '[' */
    if (token == NULL || token[0] != '[')
        elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
             token ? token : "[NULL]", length);
 
    if (typbyval)
    {
        if (length > (Size) sizeof(Datum))
            elog(ERROR, "byval datum but length = %zu", length);
        res = (Datum) 0;
        s = (char *) (&res);
        for (Size i = 0; i < (Size) sizeof(Datum); i++)
        {
            token = pg_strtok(&tokenLength);
            s[i] = (char) atoi(token);
        }
    }
    else if (length <= 0)
        res = (Datum) 0;
    else
    {
        s = (char *) palloc(length);
        for (Size i = 0; i < length; i++)
        {
            token = pg_strtok(&tokenLength);
            s[i] = (char) atoi(token);
        }
        res = PointerGetDatum(s);
    }
 
    token = pg_strtok(&tokenLength);    /* read the ']' */
    if (token == NULL || token[0] != ']')
        elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
             token ? token : "[NULL]", length);
 
    return res;
}
 
/*
 * common implementation for scalar-array-reading functions
 *
 * The data format is either "<>" for a NULL pointer (in which case numCols
 * is ignored) or "(item item item)" where the number of items must equal
 * numCols.  The convfunc must be okay with stopping at whitespace or a
 * right parenthesis, since pg_strtok won't null-terminate the token.
 */
#define READ_SCALAR_ARRAY(fnname, datatype, convfunc) \
datatype * \
fnname(int numCols) \
{ \
    datatype   *vals; \
    READ_TEMP_LOCALS(); \
    token = pg_strtok(&length); \
    if (token == NULL) \
        elog(ERROR, "incomplete scalar array"); \
    if (length == 0) \
        return NULL;            /* it was "<>", so return NULL pointer */ \
    if (length != 1 || token[0] != '(') \
        elog(ERROR, "unrecognized token: \"%.*s\"", length, token); \
    vals = (datatype *) palloc(numCols * sizeof(datatype)); \
    for (int i = 0; i < numCols; i++) \
    { \
        token = pg_strtok(&length); \
        if (token == NULL || token[0] == ')') \
            elog(ERROR, "incomplete scalar array"); \
        vals[i] = convfunc(token); \
    } \
    token = pg_strtok(&length); \
    if (token == NULL || length != 1 || token[0] != ')') \
        elog(ERROR, "incomplete scalar array"); \
    return vals; \
}
 
/*
 * Note: these functions are exported in nodes.h for possible use by
 * extensions, so don't mess too much with their names or API.
 */
READ_SCALAR_ARRAY(readAttrNumberCols, int16, atoi)
READ_SCALAR_ARRAY(readOidCols, Oid, atooid)
/* outfuncs.c has writeIndexCols, but we don't yet need that here */
/* READ_SCALAR_ARRAY(readIndexCols, Index, atoui) */
READ_SCALAR_ARRAY(readIntCols, int, atoi)
READ_SCALAR_ARRAY(readBoolCols, bool, strtobool)

READ_BITMAPSET_FIELD

#define READ_BITMAPSET_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    (void) token;               /* in case not used elsewhere */ \
    local_node->fldname = _readBitmapset()

Definition at line 145 of file readfuncs.c.

READ_BOOL_ARRAY

#define READ_BOOL_ARRAY	(		fldname,
			len
	)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    local_node->fldname = readBoolCols(len)

Definition at line 166 of file readfuncs.c.

READ_BOOL_FIELD

#define READ_BOOL_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    token = pg_strtok(&length);     /* get field value */ \
    local_node->fldname = strtobool(token)

Definition at line 113 of file readfuncs.c.

READ_CHAR_FIELD

#define READ_CHAR_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    token = pg_strtok(&length);     /* get field value */ \
    /* avoid overhead of calling debackslash() for one char */ \
    local_node->fldname = (length == 0) ? '\0' : (token[0] == '\\' ? token[1] : token[0])

Definition at line 94 of file readfuncs.c.

                                               : (token[0] == '\\' ? token[1] : token[0])

READ_DONE

#define READ_DONE

(

)

return local_node

Definition at line 171 of file readfuncs.c.

READ_ENUM_FIELD

#define READ_ENUM_FIELD	(		fldname,
			enumtype
	)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    token = pg_strtok(&length);     /* get field value */ \
    local_node->fldname = (enumtype) atoi(token)

Definition at line 101 of file readfuncs.c.

READ_FLOAT_FIELD

#define READ_FLOAT_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    token = pg_strtok(&length);     /* get field value */ \
    local_node->fldname = atof(token)

Definition at line 107 of file readfuncs.c.

READ_INT64_FIELD

#define READ_INT64_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length); /* skip :fldname */ \
    token = pg_strtok(&length); /* get field value */ \
    local_node->fldname = strtoi64(token, NULL, 10)

Definition at line 70 of file readfuncs.c.

READ_INT_ARRAY

#define READ_INT_ARRAY	(		fldname,
			len
	)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    local_node->fldname = readIntCols(len)

Definition at line 161 of file readfuncs.c.

READ_INT_FIELD

#define READ_INT_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    token = pg_strtok(&length);     /* get field value */ \
    local_node->fldname = atoi(token)

Definition at line 58 of file readfuncs.c.

READ_LOCALS

#define READ_LOCALS

(

nodeTypeName

)

Value:

    READ_LOCALS_NO_FIELDS(nodeTypeName);    \
	READ_TEMP_LOCALS()

Definition at line 53 of file readfuncs.c.

READ_LOCALS_NO_FIELDS

#define READ_LOCALS_NO_FIELDS

(

nodeTypeName

)

nodeTypeName *local_node = makeNode(nodeTypeName)

Definition at line 44 of file readfuncs.c.

READ_LOCATION_FIELD

#define READ_LOCATION_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    token = pg_strtok(&length);     /* get field value */ \
    (void) token;               /* in case not used elsewhere */ \
    local_node->fldname = -1    /* set field to "unknown" */

Definition at line 131 of file readfuncs.c.

READ_LONG_FIELD

#define READ_LONG_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    token = pg_strtok(&length);     /* get field value */ \
    local_node->fldname = atol(token)

Definition at line 82 of file readfuncs.c.

READ_NODE_FIELD

#define READ_NODE_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    (void) token;               /* in case not used elsewhere */ \
    local_node->fldname = nodeRead(NULL, 0)

Definition at line 139 of file readfuncs.c.

READ_OID_ARRAY

#define READ_OID_ARRAY	(		fldname,
			len
	)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    local_node->fldname = readOidCols(len)

Definition at line 156 of file readfuncs.c.

READ_OID_FIELD

#define READ_OID_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    token = pg_strtok(&length);     /* get field value */ \
    local_node->fldname = atooid(token)

Definition at line 88 of file readfuncs.c.

READ_SCALAR_ARRAY

#define READ_SCALAR_ARRAY	(		fnname,
			datatype,
			convfunc
	)

Value:

datatype * \
fnname(int numCols) \
{ \
    datatype   *vals; \
	READ_TEMP_LOCALS(); \
    token = pg_strtok(&length); \
	if (token == NULL) \
		elog(ERROR, "incomplete scalar array"); \
	if (length == 0) \
        return NULL;            /* it was "<>", so return NULL pointer */ \
	if (length != 1 || token[0] != '(') \
		elog(ERROR, "unrecognized token: \"%.*s\"", length, token); \
    vals = (datatype *) palloc(numCols * sizeof(datatype)); \
	for (int i = 0; i < numCols; i++) \
    { \
        token = pg_strtok(&length); \
		if (token == NULL || token[0] == ')') \
			elog(ERROR, "incomplete scalar array"); \
        vals[i] = convfunc(token); \
    } \
    token = pg_strtok(&length); \
	if (token == NULL || length != 1 || token[0] != ')') \
		elog(ERROR, "incomplete scalar array"); \
    return vals; \
}

Definition at line 667 of file readfuncs.c.

{ \
    datatype   *vals; \
	READ_TEMP_LOCALS(); \
    token = pg_strtok(&length); \
	if (token == NULL) \
		elog(ERROR, "incomplete scalar array"); \
	if (length == 0) \
        return NULL;            /* it was "<>", so return NULL pointer */ \
	if (length != 1 || token[0] != '(') \
		elog(ERROR, "unrecognized token: \"%.*s\"", length, token); \
    vals = (datatype *) palloc(numCols * sizeof(datatype)); \
	for (int i = 0; i < numCols; i++) \
    { \
        token = pg_strtok(&length); \
		if (token == NULL || token[0] == ')') \
			elog(ERROR, "incomplete scalar array"); \
        vals[i] = convfunc(token); \
    } \
    token = pg_strtok(&length); \
	if (token == NULL || length != 1 || token[0] != ')') \
		elog(ERROR, "incomplete scalar array"); \
    return vals; \
}

READ_STRING_FIELD

#define READ_STRING_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    token = pg_strtok(&length);     /* get field value */ \
    local_node->fldname = nullable_string(token, length)

Definition at line 119 of file readfuncs.c.

READ_TEMP_LOCALS

#define READ_TEMP_LOCALS

(

)

Value:

    const char *token;      \
    int         length

Definition at line 48 of file readfuncs.c.

READ_UINT64_FIELD

#define READ_UINT64_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    token = pg_strtok(&length);     /* get field value */ \
    local_node->fldname = strtou64(token, NULL, 10)

Definition at line 76 of file readfuncs.c.

READ_UINT_FIELD

#define READ_UINT_FIELD

(

fldname

)

Value:

    token = pg_strtok(&length);     /* skip :fldname */ \
    token = pg_strtok(&length);     /* get field value */ \
    local_node->fldname = atoui(token)

Definition at line 64 of file readfuncs.c.

strtobool

#define strtobool

(

x

)

((*(x) == 't') ? true : false)

Definition at line 183 of file readfuncs.c.

Function Documentation

_readA_Const()

static A_Const * _readA_Const ( void  )

static

Definition at line 308 of file readfuncs.c.

{
    READ_LOCALS(A_Const);
 
    /* We expect either NULL or :val here */
    token = pg_strtok(&length);
    if (length == 4 && strncmp(token, "NULL", 4) == 0)
        local_node->isnull = true;
    else
    {
        union ValUnion *tmp = nodeRead(NULL, 0);
 
        /* To forestall valgrind complaints, copy only the valid data */
        switch (nodeTag(tmp))
        {
            case T_Integer:
                memcpy(&local_node->val, tmp, sizeof(Integer));
                break;
            case T_Float:
                memcpy(&local_node->val, tmp, sizeof(Float));
                break;
            case T_Boolean:
                memcpy(&local_node->val, tmp, sizeof(Boolean));
                break;
            case T_String:
                memcpy(&local_node->val, tmp, sizeof(String));
                break;
            case T_BitString:
                memcpy(&local_node->val, tmp, sizeof(BitString));
                break;
            default:
                elog(ERROR, "unrecognized node type: %d",
                     (int) nodeTag(tmp));
                break;
        }
    }
 
    READ_LOCATION_FIELD(location);
 
    READ_DONE();
}

References elog, ERROR, fb(), nodeRead(), nodeTag, pg_strtok(), READ_DONE, READ_LOCALS, and READ_LOCATION_FIELD.

_readA_Expr()

static A_Expr * _readA_Expr ( void  )

static

Definition at line 455 of file readfuncs.c.

{
    READ_LOCALS(A_Expr);
 
    token = pg_strtok(&length);
 
    if (length == 3 && strncmp(token, "ANY", 3) == 0)
    {
        local_node->kind = AEXPR_OP_ANY;
        READ_NODE_FIELD(name);
    }
    else if (length == 3 && strncmp(token, "ALL", 3) == 0)
    {
        local_node->kind = AEXPR_OP_ALL;
        READ_NODE_FIELD(name);
    }
    else if (length == 8 && strncmp(token, "DISTINCT", 8) == 0)
    {
        local_node->kind = AEXPR_DISTINCT;
        READ_NODE_FIELD(name);
    }
    else if (length == 12 && strncmp(token, "NOT_DISTINCT", 12) == 0)
    {
        local_node->kind = AEXPR_NOT_DISTINCT;
        READ_NODE_FIELD(name);
    }
    else if (length == 6 && strncmp(token, "NULLIF", 6) == 0)
    {
        local_node->kind = AEXPR_NULLIF;
        READ_NODE_FIELD(name);
    }
    else if (length == 2 && strncmp(token, "IN", 2) == 0)
    {
        local_node->kind = AEXPR_IN;
        READ_NODE_FIELD(name);
    }
    else if (length == 4 && strncmp(token, "LIKE", 4) == 0)
    {
        local_node->kind = AEXPR_LIKE;
        READ_NODE_FIELD(name);
    }
    else if (length == 5 && strncmp(token, "ILIKE", 5) == 0)
    {
        local_node->kind = AEXPR_ILIKE;
        READ_NODE_FIELD(name);
    }
    else if (length == 7 && strncmp(token, "SIMILAR", 7) == 0)
    {
        local_node->kind = AEXPR_SIMILAR;
        READ_NODE_FIELD(name);
    }
    else if (length == 7 && strncmp(token, "BETWEEN", 7) == 0)
    {
        local_node->kind = AEXPR_BETWEEN;
        READ_NODE_FIELD(name);
    }
    else if (length == 11 && strncmp(token, "NOT_BETWEEN", 11) == 0)
    {
        local_node->kind = AEXPR_NOT_BETWEEN;
        READ_NODE_FIELD(name);
    }
    else if (length == 11 && strncmp(token, "BETWEEN_SYM", 11) == 0)
    {
        local_node->kind = AEXPR_BETWEEN_SYM;
        READ_NODE_FIELD(name);
    }
    else if (length == 15 && strncmp(token, "NOT_BETWEEN_SYM", 15) == 0)
    {
        local_node->kind = AEXPR_NOT_BETWEEN_SYM;
        READ_NODE_FIELD(name);
    }
    else if (length == 5 && strncmp(token, ":name", 5) == 0)
    {
        local_node->kind = AEXPR_OP;
        local_node->name = nodeRead(NULL, 0);
    }
    else
        elog(ERROR, "unrecognized A_Expr kind: \"%.*s\"", length, token);
 
    READ_NODE_FIELD(lexpr);
    READ_NODE_FIELD(rexpr);
    READ_LOCATION_FIELD(rexpr_list_start);
    READ_LOCATION_FIELD(rexpr_list_end);
    READ_LOCATION_FIELD(location);
 
    READ_DONE();
}

References AEXPR_BETWEEN, AEXPR_BETWEEN_SYM, AEXPR_DISTINCT, AEXPR_ILIKE, AEXPR_IN, AEXPR_LIKE, AEXPR_NOT_BETWEEN, AEXPR_NOT_BETWEEN_SYM, AEXPR_NOT_DISTINCT, AEXPR_NULLIF, AEXPR_OP, AEXPR_OP_ALL, AEXPR_OP_ANY, AEXPR_SIMILAR, elog, ERROR, fb(), name, nodeRead(), pg_strtok(), READ_DONE, READ_LOCALS, READ_LOCATION_FIELD, and READ_NODE_FIELD.

_readBitmapset()

static Bitmapset * _readBitmapset ( void  )

static

Definition at line 207 of file readfuncs.c.

{
    Bitmapset  *result = NULL;
 
    READ_TEMP_LOCALS();
 
    token = pg_strtok(&length);
    if (token == NULL)
        elog(ERROR, "incomplete Bitmapset structure");
    if (length != 1 || token[0] != '(')
        elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
 
    token = pg_strtok(&length);
    if (token == NULL)
        elog(ERROR, "incomplete Bitmapset structure");
    if (length != 1 || token[0] != 'b')
        elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
 
    for (;;)
    {
        int         val;
        char       *endptr;
 
        token = pg_strtok(&length);
        if (token == NULL)
            elog(ERROR, "unterminated Bitmapset structure");
        if (length == 1 && token[0] == ')')
            break;
        val = (int) strtol(token, &endptr, 10);
        if (endptr != token + length)
            elog(ERROR, "unrecognized integer: \"%.*s\"", length, token);
        result = bms_add_member(result, val);
    }
 
    return result;
}

References bms_add_member(), elog, ERROR, fb(), pg_strtok(), READ_TEMP_LOCALS, and val.

Referenced by readBitmapset().

_readBoolExpr()

static BoolExpr * _readBoolExpr ( void  )

static

Definition at line 285 of file readfuncs.c.

{
    READ_LOCALS(BoolExpr);
 
    /* do-it-yourself enum representation */
    token = pg_strtok(&length); /* skip :boolop */
    token = pg_strtok(&length); /* get field value */
    if (length == 3 && strncmp(token, "and", 3) == 0)
        local_node->boolop = AND_EXPR;
    else if (length == 2 && strncmp(token, "or", 2) == 0)
        local_node->boolop = OR_EXPR;
    else if (length == 3 && strncmp(token, "not", 3) == 0)
        local_node->boolop = NOT_EXPR;
    else
        elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
 
    READ_NODE_FIELD(args);
    READ_LOCATION_FIELD(location);
 
    READ_DONE();
}

References AND_EXPR, elog, ERROR, fb(), NOT_EXPR, OR_EXPR, pg_strtok(), READ_DONE, READ_LOCALS, READ_LOCATION_FIELD, and READ_NODE_FIELD.

_readConst()

static Const * _readConst ( void  )

static

Definition at line 263 of file readfuncs.c.

{
    READ_LOCALS(Const);
 
    READ_OID_FIELD(consttype);
    READ_INT_FIELD(consttypmod);
    READ_OID_FIELD(constcollid);
    READ_INT_FIELD(constlen);
    READ_BOOL_FIELD(constbyval);
    READ_BOOL_FIELD(constisnull);
    READ_LOCATION_FIELD(location);
 
    token = pg_strtok(&length); /* skip :constvalue */
    if (local_node->constisnull)
        token = pg_strtok(&length); /* skip "<>" */
    else
        local_node->constvalue = readDatum(local_node->constbyval);
 
    READ_DONE();
}

References fb(), pg_strtok(), READ_BOOL_FIELD, READ_DONE, READ_INT_FIELD, READ_LOCALS, READ_LOCATION_FIELD, READ_OID_FIELD, and readDatum().

_readExtensibleNode()

static ExtensibleNode * _readExtensibleNode ( void  )

static

Definition at line 544 of file readfuncs.c.

{
    const ExtensibleNodeMethods *methods;
    ExtensibleNode *local_node;
    const char *extnodename;
 
    READ_TEMP_LOCALS();
 
    token = pg_strtok(&length); /* skip :extnodename */
    token = pg_strtok(&length); /* get extnodename */
 
    extnodename = nullable_string(token, length);
    if (!extnodename)
        elog(ERROR, "extnodename has to be supplied");
    methods = GetExtensibleNodeMethods(extnodename, false);
 
    local_node = (ExtensibleNode *) newNode(methods->node_size,
                                            T_ExtensibleNode);
    local_node->extnodename = extnodename;
 
    /* deserialize the private fields */
    methods->nodeRead(local_node);
 
    READ_DONE();
}

References elog, ERROR, fb(), GetExtensibleNodeMethods(), newNode(), ExtensibleNodeMethods::node_size, ExtensibleNodeMethods::nodeRead, nullable_string(), pg_strtok(), READ_DONE, and READ_TEMP_LOCALS.

_readRangeTblEntry()

static RangeTblEntry * _readRangeTblEntry ( void  )

static

Definition at line 351 of file readfuncs.c.

{
    READ_LOCALS(RangeTblEntry);
 
    READ_NODE_FIELD(alias);
    READ_NODE_FIELD(eref);
    READ_ENUM_FIELD(rtekind, RTEKind);
 
    switch (local_node->rtekind)
    {
        case RTE_RELATION:
            READ_OID_FIELD(relid);
            READ_BOOL_FIELD(inh);
            READ_CHAR_FIELD(relkind);
            READ_INT_FIELD(rellockmode);
            READ_UINT_FIELD(perminfoindex);
            READ_NODE_FIELD(tablesample);
            break;
        case RTE_SUBQUERY:
            READ_NODE_FIELD(subquery);
            READ_BOOL_FIELD(security_barrier);
            /* we re-use these RELATION fields, too: */
            READ_OID_FIELD(relid);
            READ_BOOL_FIELD(inh);
            READ_CHAR_FIELD(relkind);
            READ_INT_FIELD(rellockmode);
            READ_UINT_FIELD(perminfoindex);
            break;
        case RTE_JOIN:
            READ_ENUM_FIELD(jointype, JoinType);
            READ_INT_FIELD(joinmergedcols);
            READ_NODE_FIELD(joinaliasvars);
            READ_NODE_FIELD(joinleftcols);
            READ_NODE_FIELD(joinrightcols);
            READ_NODE_FIELD(join_using_alias);
            break;
        case RTE_FUNCTION:
            READ_NODE_FIELD(functions);
            READ_BOOL_FIELD(funcordinality);
            break;
        case RTE_TABLEFUNC:
            READ_NODE_FIELD(tablefunc);
            /* The RTE must have a copy of the column type info, if any */
            if (local_node->tablefunc)
            {
                TableFunc  *tf = local_node->tablefunc;
 
                local_node->coltypes = tf->coltypes;
                local_node->coltypmods = tf->coltypmods;
                local_node->colcollations = tf->colcollations;
            }
            break;
        case RTE_VALUES:
            READ_NODE_FIELD(values_lists);
            READ_NODE_FIELD(coltypes);
            READ_NODE_FIELD(coltypmods);
            READ_NODE_FIELD(colcollations);
            break;
        case RTE_CTE:
            READ_STRING_FIELD(ctename);
            READ_UINT_FIELD(ctelevelsup);
            READ_BOOL_FIELD(self_reference);
            READ_NODE_FIELD(coltypes);
            READ_NODE_FIELD(coltypmods);
            READ_NODE_FIELD(colcollations);
            break;
        case RTE_NAMEDTUPLESTORE:
            READ_STRING_FIELD(enrname);
            READ_FLOAT_FIELD(enrtuples);
            READ_NODE_FIELD(coltypes);
            READ_NODE_FIELD(coltypmods);
            READ_NODE_FIELD(colcollations);
            /* we re-use these RELATION fields, too: */
            READ_OID_FIELD(relid);
            break;
        case RTE_GRAPH_TABLE:
            READ_NODE_FIELD(graph_pattern);
            READ_NODE_FIELD(graph_table_columns);
            /* we re-use these RELATION fields, too: */
            READ_OID_FIELD(relid);
            READ_CHAR_FIELD(relkind);
            READ_INT_FIELD(rellockmode);
            READ_UINT_FIELD(perminfoindex);
            break;
        case RTE_RESULT:
            /* no extra fields */
            break;
        case RTE_GROUP:
            READ_NODE_FIELD(groupexprs);
            break;
        default:
            elog(ERROR, "unrecognized RTE kind: %d",
                 (int) local_node->rtekind);
            break;
    }
 
    READ_BOOL_FIELD(lateral);
    READ_BOOL_FIELD(inFromCl);
    READ_NODE_FIELD(securityQuals);
 
    READ_DONE();
}

References elog, ERROR, fb(), functions, READ_BOOL_FIELD, READ_CHAR_FIELD, READ_DONE, READ_ENUM_FIELD, READ_FLOAT_FIELD, READ_INT_FIELD, READ_LOCALS, READ_NODE_FIELD, READ_OID_FIELD, READ_STRING_FIELD, READ_UINT_FIELD, RTE_CTE, RTE_FUNCTION, RTE_GRAPH_TABLE, RTE_GROUP, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, and RTE_VALUES.

nullable_string()

static char * nullable_string ( const char *  token, int  length  )

static

Definition at line 186 of file readfuncs.c.

{
    /* outToken emits <> for NULL, and pg_strtok makes that an empty string */
    if (length == 0)
        return NULL;
    /* outToken emits "" for empty string */
    if (length == 2 && token[0] == '"' && token[1] == '"')
        return pstrdup("");
    /* otherwise, we must remove protective backslashes added by outToken */
    return debackslash(token, length);
}

References debackslash(), fb(), and pstrdup().

Referenced by _readExtensibleNode().

parseNodeString()

Node * parseNodeString

(

void

)

Definition at line 580 of file readfuncs.c.

{
    READ_TEMP_LOCALS();
 
    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();
 
    token = pg_strtok(&length);
 
#define MATCH(tokname, namelen) \
    (length == namelen && memcmp(token, tokname, namelen) == 0)
 
#include "readfuncs.switch.c"
 
    elog(ERROR, "badly formatted node string \"%.32s\"...", token);
    return NULL;                /* keep compiler quiet */
}

References check_stack_depth(), elog, ERROR, fb(), pg_strtok(), and READ_TEMP_LOCALS.

Referenced by nodeRead().

readBitmapset()

Bitmapset * readBitmapset

(

void

)

Definition at line 249 of file readfuncs.c.

{
    return _readBitmapset();
}

References _readBitmapset().

readDatum()

Datum readDatum

(

bool

typbyval

)

Definition at line 607 of file readfuncs.c.

{
    Size        length;
    int         tokenLength;
    const char *token;
    Datum       res;
    char       *s;
 
    /*
     * read the actual length of the value
     */
    token = pg_strtok(&tokenLength);
    length = atoui(token);
 
    token = pg_strtok(&tokenLength);    /* read the '[' */
    if (token == NULL || token[0] != '[')
        elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
             token ? token : "[NULL]", length);
 
    if (typbyval)
    {
        if (length > (Size) sizeof(Datum))
            elog(ERROR, "byval datum but length = %zu", length);
        res = (Datum) 0;
        s = (char *) (&res);
        for (Size i = 0; i < (Size) sizeof(Datum); i++)
        {
            token = pg_strtok(&tokenLength);
            s[i] = (char) atoi(token);
        }
    }
    else if (length <= 0)
        res = (Datum) 0;
    else
    {
        s = (char *) palloc(length);
        for (Size i = 0; i < length; i++)
        {
            token = pg_strtok(&tokenLength);
            s[i] = (char) atoi(token);
        }
        res = PointerGetDatum(s);
    }
 
    token = pg_strtok(&tokenLength);    /* read the ']' */
    if (token == NULL || token[0] != ']')
        elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
             token ? token : "[NULL]", length);
 
    return res;
}

References atoui, elog, ERROR, fb(), i, palloc(), pg_strtok(), PointerGetDatum(), and token.

Referenced by _readConst().