outfuncs.c File Reference

#include "postgres.h"
#include <ctype.h>
#include "access/attnum.h"
#include "common/shortest_dec.h"
#include "lib/stringinfo.h"
#include "miscadmin.h"
#include "nodes/bitmapset.h"
#include "nodes/nodes.h"
#include "nodes/pg_list.h"
#include "utils/datum.h"
#include "outfuncs.funcs.c"
#include "outfuncs.switch.c"

Include dependency graph for outfuncs.c:

Go to the source code of this file.

Macros
#define	WRITE_NODE_TYPE(nodelabel)    appendStringInfoString(str, nodelabel)
#define	WRITE_INT_FIELD(fldname)    appendStringInfo(str, " :" CppAsString(fldname) " %d", node->fldname)
#define	WRITE_UINT_FIELD(fldname)    appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
#define	WRITE_INT64_FIELD(fldname)
#define	WRITE_UINT64_FIELD(fldname)
#define	WRITE_OID_FIELD(fldname)    appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
#define	WRITE_LONG_FIELD(fldname)    appendStringInfo(str, " :" CppAsString(fldname) " %ld", node->fldname)
#define	WRITE_CHAR_FIELD(fldname)
#define	WRITE_ENUM_FIELD(fldname, enumtype)
#define	WRITE_FLOAT_FIELD(fldname)
#define	WRITE_BOOL_FIELD(fldname)
#define	WRITE_STRING_FIELD(fldname)
#define	WRITE_LOCATION_FIELD(fldname)    appendStringInfo(str, " :" CppAsString(fldname) " %d", write_location_fields ? node->fldname : -1)
#define	WRITE_NODE_FIELD(fldname)
#define	WRITE_BITMAPSET_FIELD(fldname)
#define	WRITE_NODE_ARRAY(fldname, len)
#define	WRITE_ATTRNUMBER_ARRAY(fldname, len)
#define	WRITE_OID_ARRAY(fldname, len)
#define	WRITE_INDEX_ARRAY(fldname, len)
#define	WRITE_INT_ARRAY(fldname, len)
#define	WRITE_BOOL_ARRAY(fldname, len)
#define	booltostr(x)   ((x) ? "true" : "false")
#define	WRITE_SCALAR_ARRAY(fnname, datatype, fmtstr, convfunc)

Functions
static void	outChar (StringInfo str, char c)
static void	outDouble (StringInfo str, double d)
void	outToken (StringInfo str, const char *s)
static void	writeNodeArray (StringInfo str, const Node *const *arr, int len)
static void	_outList (StringInfo str, const List *node)
void	outBitmapset (StringInfo str, const Bitmapset *bms)
void	outDatum (StringInfo str, Datum value, int typlen, bool typbyval)
static void	_outConst (StringInfo str, const Const *node)
static void	_outBoolExpr (StringInfo str, const BoolExpr *node)
static void	_outForeignKeyOptInfo (StringInfo str, const ForeignKeyOptInfo *node)
static void	_outEquivalenceClass (StringInfo str, const EquivalenceClass *node)
static void	_outExtensibleNode (StringInfo str, const ExtensibleNode *node)
static void	_outRangeTblEntry (StringInfo str, const RangeTblEntry *node)
static void	_outA_Expr (StringInfo str, const A_Expr *node)
static void	_outInteger (StringInfo str, const Integer *node)
static void	_outFloat (StringInfo str, const Float *node)
static void	_outBoolean (StringInfo str, const Boolean *node)
static void	_outString (StringInfo str, const String *node)
static void	_outBitString (StringInfo str, const BitString *node)
static void	_outA_Const (StringInfo str, const A_Const *node)
void	outNode (StringInfo str, const void *obj)
static char *	nodeToStringInternal (const void *obj, bool write_loc_fields)
char *	nodeToString (const void *obj)
char *	nodeToStringWithLocations (const void *obj)
char *	bmsToString (const Bitmapset *bms)

Variables
static bool	write_location_fields = false

Macro Definition Documentation

booltostr

#define booltostr

(

x

)

((x) ? "true" : "false")

Definition at line 142 of file outfuncs.c.

WRITE_ATTRNUMBER_ARRAY

#define WRITE_ATTRNUMBER_ARRAY	(		fldname,
			len
	)

Value:

    (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
	 writeAttrNumberCols(str, node->fldname, len))

Definition at line 118 of file outfuncs.c.

                                   :" CppAsString(fldname) " "), \
     writeAttrNumberCols(str, node->fldname, len))

WRITE_BITMAPSET_FIELD

#define WRITE_BITMAPSET_FIELD

(

fldname

)

Value:

    (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
	 outBitmapset(str, node->fldname))

Definition at line 108 of file outfuncs.c.

                                   :" CppAsString(fldname) " "), \
     outBitmapset(str, node->fldname))

WRITE_BOOL_ARRAY

#define WRITE_BOOL_ARRAY	(		fldname,
			len
	)

Value:

    (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
	 writeBoolCols(str, node->fldname, len))

Definition at line 138 of file outfuncs.c.

                                   :" CppAsString(fldname) " "), \
     writeBoolCols(str, node->fldname, len))

WRITE_BOOL_FIELD

#define WRITE_BOOL_FIELD

(

fldname

)

Value:

    appendStringInfo(str, " :" CppAsString(fldname) " %s", \
                     booltostr(node->fldname))

Definition at line 89 of file outfuncs.c.

                            :" CppAsString(fldname) " %s", \
                     booltostr(node->fldname))

WRITE_CHAR_FIELD

#define WRITE_CHAR_FIELD

(

fldname

)

Value:

    (appendStringInfo(str, " :" CppAsString(fldname) " "), \
	 outChar(str, node->fldname))

Definition at line 74 of file outfuncs.c.

                             :" CppAsString(fldname) " "), \
     outChar(str, node->fldname))

WRITE_ENUM_FIELD

#define WRITE_ENUM_FIELD	(		fldname,
			enumtype
	)

Value:

    appendStringInfo(str, " :" CppAsString(fldname) " %d", \
                     (int) node->fldname)

Definition at line 79 of file outfuncs.c.

                            :" CppAsString(fldname) " %d", \
                     (int) node->fldname)

WRITE_FLOAT_FIELD

#define WRITE_FLOAT_FIELD

(

fldname

)

Value:

    (appendStringInfo(str, " :" CppAsString(fldname) " "), \
	 outDouble(str, node->fldname))

Definition at line 84 of file outfuncs.c.

                             :" CppAsString(fldname) " "), \
     outDouble(str, node->fldname))

WRITE_INDEX_ARRAY

#define WRITE_INDEX_ARRAY	(		fldname,
			len
	)

Value:

    (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
	 writeIndexCols(str, node->fldname, len))

Definition at line 128 of file outfuncs.c.

                                   :" CppAsString(fldname) " "), \
     writeIndexCols(str, node->fldname, len))

WRITE_INT64_FIELD

#define WRITE_INT64_FIELD

(

fldname

)

Value:

    appendStringInfo(str, \
                     " :" CppAsString(fldname) " " INT64_FORMAT, \
                     node->fldname)

Definition at line 55 of file outfuncs.c.

                       :" CppAsString(fldname) " " INT64_FORMAT, \
                     node->fldname)

WRITE_INT_ARRAY

#define WRITE_INT_ARRAY	(		fldname,
			len
	)

Value:

    (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
	 writeIntCols(str, node->fldname, len))

Definition at line 133 of file outfuncs.c.

                                   :" CppAsString(fldname) " "), \
     writeIntCols(str, node->fldname, len))

WRITE_INT_FIELD

#define WRITE_INT_FIELD

(

fldname

)

appendStringInfo(str, " :" CppAsString(fldname) " %d", node->fldname)

Definition at line 47 of file outfuncs.c.

                            :" CppAsString(fldname) " %d", node->fldname)

WRITE_LOCATION_FIELD

#define WRITE_LOCATION_FIELD

(

fldname

)

appendStringInfo(str, " :" CppAsString(fldname) " %d", write_location_fields ? node->fldname : -1)

Definition at line 99 of file outfuncs.c.

                            :" CppAsString(fldname) " %d", write_location_fields ? node->fldname : -1)

WRITE_LONG_FIELD

#define WRITE_LONG_FIELD

(

fldname

)

appendStringInfo(str, " :" CppAsString(fldname) " %ld", node->fldname)

Definition at line 70 of file outfuncs.c.

                            :" CppAsString(fldname) " %ld", node->fldname)

WRITE_NODE_ARRAY

#define WRITE_NODE_ARRAY	(		fldname,
			len
	)

Value:

    (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
	 writeNodeArray(str, (const Node * const *) node->fldname, len))

Definition at line 113 of file outfuncs.c.

                                   :" CppAsString(fldname) " "), \
     writeNodeArray(str, (const Node * const *) node->fldname, len))

WRITE_NODE_FIELD

#define WRITE_NODE_FIELD

(

fldname

)

Value:

    (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
	 outNode(str, node->fldname))

Definition at line 103 of file outfuncs.c.

                                   :" CppAsString(fldname) " "), \
     outNode(str, node->fldname))

WRITE_NODE_TYPE

#define WRITE_NODE_TYPE

(

nodelabel

)

appendStringInfoString(str, nodelabel)

Definition at line 43 of file outfuncs.c.

WRITE_OID_ARRAY

#define WRITE_OID_ARRAY	(		fldname,
			len
	)

Value:

    (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
	 writeOidCols(str, node->fldname, len))

Definition at line 123 of file outfuncs.c.

                                   :" CppAsString(fldname) " "), \
     writeOidCols(str, node->fldname, len))

WRITE_OID_FIELD

#define WRITE_OID_FIELD

(

fldname

)

appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)

Definition at line 66 of file outfuncs.c.

                            :" CppAsString(fldname) " %u", node->fldname)

WRITE_SCALAR_ARRAY

#define WRITE_SCALAR_ARRAY	(		fnname,
			datatype,
			fmtstr,
			convfunc
	)

Value:

static void \
fnname(StringInfo str, const datatype *arr, int len) \
{ \
	if (arr != NULL) \
    { \
		appendStringInfoChar(str, '('); \
		for (int i = 0; i < len; i++) \
            appendStringInfo(str, fmtstr, convfunc(arr[i])); \
		appendStringInfoChar(str, ')'); \
    } \
	else \
		appendStringInfoString(str, "<>"); \
}

Definition at line 233 of file outfuncs.c.

{ \
	if (arr != NULL) \
    { \
		appendStringInfoChar(str, '('); \
		for (int i = 0; i < len; i++) \
            appendStringInfo(str, fmtstr, convfunc(arr[i])); \
		appendStringInfoChar(str, ')'); \
    } \
	else \
		appendStringInfoString(str, "<>"); \
}

WRITE_STRING_FIELD

#define WRITE_STRING_FIELD

(

fldname

)

Value:

    (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
	 outToken(str, node->fldname))

Definition at line 94 of file outfuncs.c.

                                   :" CppAsString(fldname) " "), \
     outToken(str, node->fldname))

WRITE_UINT64_FIELD

#define WRITE_UINT64_FIELD

(

fldname

)

Value:

    appendStringInfo(str, " :" CppAsString(fldname) " " UINT64_FORMAT, \
                     node->fldname)

Definition at line 61 of file outfuncs.c.

                            :" CppAsString(fldname) " " UINT64_FORMAT, \
                     node->fldname)

WRITE_UINT_FIELD

#define WRITE_UINT_FIELD

(

fldname

)

appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)

Definition at line 51 of file outfuncs.c.

                            :" CppAsString(fldname) " %u", node->fldname)

Function Documentation

_outA_Const()

static void _outA_Const ( StringInfo  str, const A_Const *  node  )

static

Definition at line 707 of file outfuncs.c.

{
    WRITE_NODE_TYPE("A_CONST");
 
    if (node->isnull)
        appendStringInfoString(str, " NULL");
    else
    {
        appendStringInfoString(str, " :val ");
        outNode(str, &node->val);
    }
    WRITE_LOCATION_FIELD(location);
}

References appendStringInfoString(), A_Const::isnull, outNode(), str, A_Const::val, WRITE_LOCATION_FIELD, and WRITE_NODE_TYPE.

_outA_Expr()

static void _outA_Expr ( StringInfo  str, const A_Expr *  node  )

static

Definition at line 585 of file outfuncs.c.

{
    WRITE_NODE_TYPE("A_EXPR");
 
    switch (node->kind)
    {
        case AEXPR_OP:
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_OP_ANY:
            appendStringInfoString(str, " ANY");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_OP_ALL:
            appendStringInfoString(str, " ALL");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_DISTINCT:
            appendStringInfoString(str, " DISTINCT");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_NOT_DISTINCT:
            appendStringInfoString(str, " NOT_DISTINCT");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_NULLIF:
            appendStringInfoString(str, " NULLIF");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_IN:
            appendStringInfoString(str, " IN");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_LIKE:
            appendStringInfoString(str, " LIKE");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_ILIKE:
            appendStringInfoString(str, " ILIKE");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_SIMILAR:
            appendStringInfoString(str, " SIMILAR");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_BETWEEN:
            appendStringInfoString(str, " BETWEEN");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_NOT_BETWEEN:
            appendStringInfoString(str, " NOT_BETWEEN");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_BETWEEN_SYM:
            appendStringInfoString(str, " BETWEEN_SYM");
            WRITE_NODE_FIELD(name);
            break;
        case AEXPR_NOT_BETWEEN_SYM:
            appendStringInfoString(str, " NOT_BETWEEN_SYM");
            WRITE_NODE_FIELD(name);
            break;
        default:
            elog(ERROR, "unrecognized A_Expr_Kind: %d", (int) node->kind);
            break;
    }
 
    WRITE_NODE_FIELD(lexpr);
    WRITE_NODE_FIELD(rexpr);
    WRITE_LOCATION_FIELD(rexpr_list_start);
    WRITE_LOCATION_FIELD(rexpr_list_end);
    WRITE_LOCATION_FIELD(location);
}

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, appendStringInfoString(), elog, ERROR, A_Expr::kind, name, str, WRITE_LOCATION_FIELD, WRITE_NODE_FIELD, and WRITE_NODE_TYPE.

_outBitString()

static void _outBitString ( StringInfo  str, const BitString *  node  )

static

Definition at line 695 of file outfuncs.c.

{
    /*
     * The lexer will always produce a string starting with 'b' or 'x'.  There
     * might be characters following that that need escaping, but outToken
     * won't escape the 'b' or 'x'.  This is relied on by nodeTokenType.
     */
    Assert(node->bsval[0] == 'b' || node->bsval[0] == 'x');
    outToken(str, node->bsval);
}

References Assert, BitString::bsval, outToken(), and str.

Referenced by outNode().

_outBoolean()

static void _outBoolean ( StringInfo  str, const Boolean *  node  )

static

Definition at line 675 of file outfuncs.c.

{
    appendStringInfoString(str, node->boolval ? "true" : "false");
}

References appendStringInfoString(), Boolean::boolval, and str.

Referenced by outNode().

_outBoolExpr()

static void _outBoolExpr ( StringInfo  str, const BoolExpr *  node  )

static

Definition at line 407 of file outfuncs.c.

{
    char       *opstr = NULL;
 
    WRITE_NODE_TYPE("BOOLEXPR");
 
    /* do-it-yourself enum representation */
    switch (node->boolop)
    {
        case AND_EXPR:
            opstr = "and";
            break;
        case OR_EXPR:
            opstr = "or";
            break;
        case NOT_EXPR:
            opstr = "not";
            break;
    }
    appendStringInfoString(str, " :boolop ");
    outToken(str, opstr);
 
    WRITE_NODE_FIELD(args);
    WRITE_LOCATION_FIELD(location);
}

References AND_EXPR, appendStringInfoString(), BoolExpr::boolop, fb(), NOT_EXPR, OR_EXPR, outToken(), str, WRITE_LOCATION_FIELD, WRITE_NODE_FIELD, and WRITE_NODE_TYPE.

_outConst()

static void _outConst ( StringInfo  str, const Const *  node  )

static

Definition at line 387 of file outfuncs.c.

{
    WRITE_NODE_TYPE("CONST");
 
    WRITE_OID_FIELD(consttype);
    WRITE_INT_FIELD(consttypmod);
    WRITE_OID_FIELD(constcollid);
    WRITE_INT_FIELD(constlen);
    WRITE_BOOL_FIELD(constbyval);
    WRITE_BOOL_FIELD(constisnull);
    WRITE_LOCATION_FIELD(location);
 
    appendStringInfoString(str, " :constvalue ");
    if (node->constisnull)
        appendStringInfoString(str, "<>");
    else
        outDatum(str, node->constvalue, node->constlen, node->constbyval);
}

References appendStringInfoString(), fb(), outDatum(), str, WRITE_BOOL_FIELD, WRITE_INT_FIELD, WRITE_LOCATION_FIELD, WRITE_NODE_TYPE, and WRITE_OID_FIELD.

_outEquivalenceClass()

static void _outEquivalenceClass ( StringInfo  str, const EquivalenceClass *  node  )

static

Definition at line 458 of file outfuncs.c.

{
    /*
     * To simplify reading, we just chase up to the topmost merged EC and
     * print that, without bothering to show the merge-ees separately.
     */
    while (node->ec_merged)
        node = node->ec_merged;
 
    WRITE_NODE_TYPE("EQUIVALENCECLASS");
 
    WRITE_NODE_FIELD(ec_opfamilies);
    WRITE_OID_FIELD(ec_collation);
    WRITE_INT_FIELD(ec_childmembers_size);
    WRITE_NODE_FIELD(ec_members);
    WRITE_NODE_ARRAY(ec_childmembers, node->ec_childmembers_size);
    WRITE_NODE_FIELD(ec_sources);
    /* Only ec_derives_list is written; hash is not serialized. */
    WRITE_NODE_FIELD(ec_derives_list);
    WRITE_BITMAPSET_FIELD(ec_relids);
    WRITE_BOOL_FIELD(ec_has_const);
    WRITE_BOOL_FIELD(ec_has_volatile);
    WRITE_BOOL_FIELD(ec_broken);
    WRITE_UINT_FIELD(ec_sortref);
    WRITE_UINT_FIELD(ec_min_security);
    WRITE_UINT_FIELD(ec_max_security);
}

References EquivalenceClass::ec_childmembers_size, EquivalenceClass::ec_merged, WRITE_BITMAPSET_FIELD, WRITE_BOOL_FIELD, WRITE_INT_FIELD, WRITE_NODE_ARRAY, WRITE_NODE_FIELD, WRITE_NODE_TYPE, WRITE_OID_FIELD, and WRITE_UINT_FIELD.

_outExtensibleNode()

static void _outExtensibleNode ( StringInfo  str, const ExtensibleNode *  node  )

static

Definition at line 487 of file outfuncs.c.

{
    const ExtensibleNodeMethods *methods;
 
    methods = GetExtensibleNodeMethods(node->extnodename, false);
 
    WRITE_NODE_TYPE("EXTENSIBLENODE");
 
    WRITE_STRING_FIELD(extnodename);
 
    /* serialize the private fields */
    methods->nodeOut(str, node);
}

References ExtensibleNode::extnodename, GetExtensibleNodeMethods(), ExtensibleNodeMethods::nodeOut, str, WRITE_NODE_TYPE, and WRITE_STRING_FIELD.

_outFloat()

static void _outFloat ( StringInfo  str, const Float *  node  )

static

Definition at line 665 of file outfuncs.c.

{
    /*
     * We assume the value is a valid numeric literal and so does not need
     * quoting.
     */
    appendStringInfoString(str, node->fval);
}

References appendStringInfoString(), Float::fval, and str.

Referenced by outNode().

_outForeignKeyOptInfo()

static void _outForeignKeyOptInfo ( StringInfo  str, const ForeignKeyOptInfo *  node  )

static

Definition at line 434 of file outfuncs.c.

{
    WRITE_NODE_TYPE("FOREIGNKEYOPTINFO");
 
    WRITE_UINT_FIELD(con_relid);
    WRITE_UINT_FIELD(ref_relid);
    WRITE_INT_FIELD(nkeys);
    WRITE_ATTRNUMBER_ARRAY(conkey, node->nkeys);
    WRITE_ATTRNUMBER_ARRAY(confkey, node->nkeys);
    WRITE_OID_ARRAY(conpfeqop, node->nkeys);
    WRITE_INT_FIELD(nmatched_ec);
    WRITE_INT_FIELD(nconst_ec);
    WRITE_INT_FIELD(nmatched_rcols);
    WRITE_INT_FIELD(nmatched_ri);
    /* for compactness, just print the number of matches per column: */
    appendStringInfoString(str, " :eclass");
    for (int i = 0; i < node->nkeys; i++)
        appendStringInfo(str, " %d", (node->eclass[i] != NULL));
    appendStringInfoString(str, " :rinfos");
    for (int i = 0; i < node->nkeys; i++)
        appendStringInfo(str, " %d", list_length(node->rinfos[i]));
}

References appendStringInfo(), appendStringInfoString(), ForeignKeyOptInfo::eclass, fb(), i, list_length(), ForeignKeyOptInfo::nkeys, ForeignKeyOptInfo::rinfos, str, WRITE_ATTRNUMBER_ARRAY, WRITE_INT_FIELD, WRITE_NODE_TYPE, WRITE_OID_ARRAY, and WRITE_UINT_FIELD.

_outInteger()

static void _outInteger ( StringInfo  str, const Integer *  node  )

static

Definition at line 659 of file outfuncs.c.

{
    appendStringInfo(str, "%d", node->ival);
}

References appendStringInfo(), Integer::ival, and str.

Referenced by outNode().

_outList()

static void _outList ( StringInfo  str, const List *  node  )

static

Definition at line 281 of file outfuncs.c.

{
    const ListCell *lc;
 
    appendStringInfoChar(str, '(');
 
    if (IsA(node, IntList))
        appendStringInfoChar(str, 'i');
    else if (IsA(node, OidList))
        appendStringInfoChar(str, 'o');
    else if (IsA(node, XidList))
        appendStringInfoChar(str, 'x');
 
    foreach(lc, node)
    {
        /*
         * For the sake of backward compatibility, we emit a slightly
         * different whitespace format for lists of nodes vs. other types of
         * lists. XXX: is this necessary?
         */
        if (IsA(node, List))
        {
            outNode(str, lfirst(lc));
            if (lnext(node, lc))
                appendStringInfoChar(str, ' ');
        }
        else if (IsA(node, IntList))
            appendStringInfo(str, " %d", lfirst_int(lc));
        else if (IsA(node, OidList))
            appendStringInfo(str, " %u", lfirst_oid(lc));
        else if (IsA(node, XidList))
            appendStringInfo(str, " %u", lfirst_xid(lc));
        else
            elog(ERROR, "unrecognized list node type: %d",
                 (int) node->type);
    }
 
    appendStringInfoChar(str, ')');
}

References appendStringInfo(), appendStringInfoChar(), elog, ERROR, fb(), IsA, lfirst, lfirst_int, lfirst_oid, lfirst_xid, lnext(), outNode(), str, and List::type.

Referenced by outNode().

_outRangeTblEntry()

static void _outRangeTblEntry ( StringInfo  str, const RangeTblEntry *  node  )

static

Definition at line 502 of file outfuncs.c.

{
    WRITE_NODE_TYPE("RANGETBLENTRY");
 
    WRITE_NODE_FIELD(alias);
    WRITE_NODE_FIELD(eref);
    WRITE_ENUM_FIELD(rtekind, RTEKind);
 
    switch (node->rtekind)
    {
        case RTE_RELATION:
            WRITE_OID_FIELD(relid);
            WRITE_BOOL_FIELD(inh);
            WRITE_CHAR_FIELD(relkind);
            WRITE_INT_FIELD(rellockmode);
            WRITE_UINT_FIELD(perminfoindex);
            WRITE_NODE_FIELD(tablesample);
            break;
        case RTE_SUBQUERY:
            WRITE_NODE_FIELD(subquery);
            WRITE_BOOL_FIELD(security_barrier);
            /* we re-use these RELATION fields, too: */
            WRITE_OID_FIELD(relid);
            WRITE_BOOL_FIELD(inh);
            WRITE_CHAR_FIELD(relkind);
            WRITE_INT_FIELD(rellockmode);
            WRITE_UINT_FIELD(perminfoindex);
            break;
        case RTE_JOIN:
            WRITE_ENUM_FIELD(jointype, JoinType);
            WRITE_INT_FIELD(joinmergedcols);
            WRITE_NODE_FIELD(joinaliasvars);
            WRITE_NODE_FIELD(joinleftcols);
            WRITE_NODE_FIELD(joinrightcols);
            WRITE_NODE_FIELD(join_using_alias);
            break;
        case RTE_FUNCTION:
            WRITE_NODE_FIELD(functions);
            WRITE_BOOL_FIELD(funcordinality);
            break;
        case RTE_TABLEFUNC:
            WRITE_NODE_FIELD(tablefunc);
            break;
        case RTE_VALUES:
            WRITE_NODE_FIELD(values_lists);
            WRITE_NODE_FIELD(coltypes);
            WRITE_NODE_FIELD(coltypmods);
            WRITE_NODE_FIELD(colcollations);
            break;
        case RTE_CTE:
            WRITE_STRING_FIELD(ctename);
            WRITE_UINT_FIELD(ctelevelsup);
            WRITE_BOOL_FIELD(self_reference);
            WRITE_NODE_FIELD(coltypes);
            WRITE_NODE_FIELD(coltypmods);
            WRITE_NODE_FIELD(colcollations);
            break;
        case RTE_NAMEDTUPLESTORE:
            WRITE_STRING_FIELD(enrname);
            WRITE_FLOAT_FIELD(enrtuples);
            WRITE_NODE_FIELD(coltypes);
            WRITE_NODE_FIELD(coltypmods);
            WRITE_NODE_FIELD(colcollations);
            /* we re-use these RELATION fields, too: */
            WRITE_OID_FIELD(relid);
            break;
        case RTE_RESULT:
            /* no extra fields */
            break;
        case RTE_GROUP:
            WRITE_NODE_FIELD(groupexprs);
            break;
        default:
            elog(ERROR, "unrecognized RTE kind: %d", (int) node->rtekind);
            break;
    }
 
    WRITE_BOOL_FIELD(lateral);
    WRITE_BOOL_FIELD(inFromCl);
    WRITE_NODE_FIELD(securityQuals);
}

References elog, ERROR, fb(), functions, RTE_CTE, RTE_FUNCTION, RTE_GROUP, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, WRITE_BOOL_FIELD, WRITE_CHAR_FIELD, WRITE_ENUM_FIELD, WRITE_FLOAT_FIELD, WRITE_INT_FIELD, WRITE_NODE_FIELD, WRITE_NODE_TYPE, WRITE_OID_FIELD, WRITE_STRING_FIELD, and WRITE_UINT_FIELD.

_outString()

static void _outString ( StringInfo  str, const String *  node  )

static

Definition at line 681 of file outfuncs.c.

{
    /*
     * We use outToken to provide escaping of the string's content, but we
     * don't want it to convert an empty string to '""', because we're putting
     * double quotes around the string already.
     */
    appendStringInfoChar(str, '"');
    if (node->sval[0] != '\0')
        outToken(str, node->sval);
    appendStringInfoChar(str, '"');
}

References appendStringInfoChar(), outToken(), str, and String::sval.

Referenced by outNode().

bmsToString()

char * bmsToString

(

const Bitmapset *

bms

)

Definition at line 819 of file outfuncs.c.

{
    StringInfoData str;
 
    /* see stringinfo.h for an explanation of this maneuver */
    initStringInfo(&str);
    outBitmapset(&str, bms);
    return str.data;
}

References fb(), initStringInfo(), outBitmapset(), and str.

Referenced by ExecInitPartitionExecPruning(), search_indexed_tlist_for_phv(), and search_indexed_tlist_for_var().

nodeToString()

char * nodeToString

(

const void *

obj

)

Definition at line 802 of file outfuncs.c.

{
    return nodeToStringInternal(obj, false);
}

References nodeToStringInternal().

Referenced by AlterDomainDefault(), AlterPolicy(), CreatePolicy(), CreateStatistics(), createTableConstraints(), CreateTriggerFiringOn(), DefineDomain(), domainAddCheckConstraint(), ExecSerializePlan(), expandTableLikeClause(), InsertRule(), ProcedureCreate(), publication_add_relation(), StoreAttrDefault(), StorePartitionBound(), StorePartitionKey(), StoreRelCheck(), and UpdateIndexRelation().

nodeToStringInternal()

static char * nodeToStringInternal ( const void *  obj, bool  write_loc_fields  )

static

Definition at line 781 of file outfuncs.c.

{
    StringInfoData str;
    bool        save_write_location_fields;
 
    save_write_location_fields = write_location_fields;
    write_location_fields = write_loc_fields;
 
    /* see stringinfo.h for an explanation of this maneuver */
    initStringInfo(&str);
    outNode(&str, obj);
 
    write_location_fields = save_write_location_fields;
 
    return str.data;
}

References fb(), initStringInfo(), outNode(), str, and write_location_fields.

Referenced by nodeToString(), and nodeToStringWithLocations().

nodeToStringWithLocations()

char * nodeToStringWithLocations

(

const void *

obj

)

Definition at line 808 of file outfuncs.c.

{
    return nodeToStringInternal(obj, true);
}

References nodeToStringInternal().

Referenced by elog_node_display(), pg_parse_query(), pg_plan_query(), pg_rewrite_query(), pprint(), and print().

outBitmapset()

void outBitmapset	(	StringInfo	str,
		const Bitmapset *	bms
	)

Definition at line 331 of file outfuncs.c.

{
    int         x;
 
    appendStringInfoChar(str, '(');
    appendStringInfoChar(str, 'b');
    x = -1;
    while ((x = bms_next_member(bms, x)) >= 0)
        appendStringInfo(str, " %d", x);
    appendStringInfoChar(str, ')');
}

References appendStringInfo(), appendStringInfoChar(), bms_next_member(), fb(), str, and x.

Referenced by bmsToString(), and outNode().

outChar()

static void outChar ( StringInfo  str, char  c  )

static

Definition at line 196 of file outfuncs.c.

{
    char        in[2];
 
    /* Traditionally, we've represented \0 as <>, so keep doing that */
    if (c == '\0')
    {
        appendStringInfoString(str, "<>");
        return;
    }
 
    in[0] = c;
    in[1] = '\0';
 
    outToken(str, in);
}

References appendStringInfoString(), outToken(), and str.

outDatum()

void outDatum	(	StringInfo	str,
		Datum	value,
		int	typlen,
		bool	typbyval
	)

Definition at line 347 of file outfuncs.c.

{
    Size        length;
    char       *s;
 
    length = datumGetSize(value, typbyval, typlen);
 
    if (typbyval)
    {
        s = (char *) (&value);
        appendStringInfo(str, "%zu [ ", length);
        for (Size i = 0; i < (Size) sizeof(Datum); i++)
            appendStringInfo(str, "%d ", (int) (s[i]));
        appendStringInfoChar(str, ']');
    }
    else
    {
        s = (char *) DatumGetPointer(value);
        if (!s)
            appendStringInfoString(str, "0 [ ]");
        else
        {
            appendStringInfo(str, "%zu [ ", length);
            for (Size i = 0; i < length; i++)
                appendStringInfo(str, "%d ", (int) (s[i]));
            appendStringInfoChar(str, ']');
        }
    }
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), DatumGetPointer(), datumGetSize(), i, str, and value.

Referenced by _outConst().

outDouble()

static void outDouble ( StringInfo  str, double  d  )

static

Definition at line 217 of file outfuncs.c.

{
    char        buf[DOUBLE_SHORTEST_DECIMAL_LEN];
 
    double_to_shortest_decimal_buf(d, buf);
    appendStringInfoString(str, buf);
}

References appendStringInfoString(), buf, DOUBLE_SHORTEST_DECIMAL_LEN, double_to_shortest_decimal_buf(), and str.

outNode()

void outNode	(	StringInfo	str,
		const void *	obj
	)

Definition at line 727 of file outfuncs.c.

{
    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();
 
    if (obj == NULL)
        appendStringInfoString(str, "<>");
    else if (IsA(obj, List) || IsA(obj, IntList) || IsA(obj, OidList) ||
             IsA(obj, XidList))
        _outList(str, obj);
    /* nodeRead does not want to see { } around these! */
    else if (IsA(obj, Integer))
        _outInteger(str, (const Integer *) obj);
    else if (IsA(obj, Float))
        _outFloat(str, (const Float *) obj);
    else if (IsA(obj, Boolean))
        _outBoolean(str, (const Boolean *) obj);
    else if (IsA(obj, String))
        _outString(str, (const String *) obj);
    else if (IsA(obj, BitString))
        _outBitString(str, (const BitString *) obj);
    else if (IsA(obj, Bitmapset))
        outBitmapset(str, (const Bitmapset *) obj);
    else
    {
        appendStringInfoChar(str, '{');
        switch (nodeTag(obj))
        {
#include "outfuncs.switch.c"
 
            default:
 
                /*
                 * This should be an ERROR, but it's too useful to be able to
                 * dump structures that outNode only understands part of.
                 */
                elog(WARNING, "could not dump unrecognized node type: %d",
                     (int) nodeTag(obj));
                break;
        }
        appendStringInfoChar(str, '}');
    }
}

References _outBitString(), _outBoolean(), _outFloat(), _outInteger(), _outList(), _outString(), appendStringInfoChar(), appendStringInfoString(), check_stack_depth(), elog, fb(), IsA, nodeTag, outBitmapset(), str, and WARNING.

Referenced by _outA_Const(), _outList(), nodeToStringInternal(), and writeNodeArray().

outToken()

void outToken	(	StringInfo	str,
		const char *	s
	)

Definition at line 155 of file outfuncs.c.

{
    if (s == NULL)
    {
        appendStringInfoString(str, "<>");
        return;
    }
    if (*s == '\0')
    {
        appendStringInfoString(str, "\"\"");
        return;
    }
 
    /*
     * Look for characters or patterns that are treated specially by read.c
     * (either in pg_strtok() or in nodeRead()), and therefore need a
     * protective backslash.
     */
    /* These characters only need to be quoted at the start of the string */
    if (*s == '<' ||
        *s == '"' ||
        isdigit((unsigned char) *s) ||
        ((*s == '+' || *s == '-') &&
         (isdigit((unsigned char) s[1]) || s[1] == '.')))
        appendStringInfoChar(str, '\\');
    while (*s)
    {
        /* These chars must be backslashed anywhere in the string */
        if (*s == ' ' || *s == '\n' || *s == '\t' ||
            *s == '(' || *s == ')' || *s == '{' || *s == '}' ||
            *s == '\\')
            appendStringInfoChar(str, '\\');
        appendStringInfoChar(str, *s++);
    }
}

References appendStringInfoChar(), appendStringInfoString(), fb(), and str.

Referenced by _outBitString(), _outBoolExpr(), _outString(), and outChar().

writeNodeArray()

static void writeNodeArray ( StringInfo  str, const Node *const *  arr, int  len  )

static

Definition at line 261 of file outfuncs.c.

{
    if (arr != NULL)
    {
        appendStringInfoChar(str, '(');
        for (int i = 0; i < len; i++)
        {
            appendStringInfoChar(str, ' ');
            outNode(str, arr[i]);
        }
        appendStringInfoChar(str, ')');
    }
    else
        appendStringInfoString(str, "<>");
}

References appendStringInfoChar(), appendStringInfoString(), fb(), i, len, outNode(), and str.

Variable Documentation

write_location_fields

bool write_location_fields = false

static

Definition at line 29 of file outfuncs.c.

Referenced by nodeToStringInternal().