#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:

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_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", node->fldname)

#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)

static void	_outConstraint (StringInfo str, const Constraint *node)

void	outNode (StringInfo str, const void *obj)

char *	nodeToString (const void *obj)

char *	bmsToString (const Bitmapset *bms)

Macro Definition Documentation

◆ booltostr

#define booltostr ( x ) ((x) ? "true" : "false")

Definition at line 133 of file outfuncs.c.

◆ WRITE_ATTRNUMBER_ARRAY

#define WRITE_ATTRNUMBER_ARRAY	(	fldname,
		len
	)

Value:

(appendStringInfoString(str, " :" CppAsString(fldname) " "), \

writeAttrNumberCols(str, node->fldname, len))

CppAsString

#define CppAsString(identifier)

Definition: c.h:315

generate_unaccent_rules.str

str

Definition: generate_unaccent_rules.py:280

len

const void size_t len

Definition: pg_crc32c_sse42.c:24

appendStringInfoString

void appendStringInfoString(StringInfo str, const char *s)

Definition: stringinfo.c:182

Definition at line 109 of file outfuncs.c.

◆ WRITE_BITMAPSET_FIELD

#define WRITE_BITMAPSET_FIELD ( fldname )

Value:

(appendStringInfoString(str, " :" CppAsString(fldname) " "), \

outBitmapset(str, node->fldname))

Definition at line 99 of file outfuncs.c.

◆ WRITE_BOOL_ARRAY

#define WRITE_BOOL_ARRAY	(	fldname,
		len
	)

Value:

(appendStringInfoString(str, " :" CppAsString(fldname) " "), \

writeBoolCols(str, node->fldname, len))

Definition at line 129 of file outfuncs.c.

◆ WRITE_BOOL_FIELD

#define WRITE_BOOL_FIELD ( fldname )

Value:

appendStringInfo(str, " :" CppAsString(fldname) " %s", \

booltostr(node->fldname))

booltostr

#define booltostr(x)

Definition: outfuncs.c:133

appendStringInfo

void appendStringInfo(StringInfo str, const char *fmt,...)

Definition: stringinfo.c:97

Definition at line 80 of file outfuncs.c.

◆ WRITE_CHAR_FIELD

#define WRITE_CHAR_FIELD ( fldname )

Value:

(appendStringInfo(str, " :" CppAsString(fldname) " "), \

outChar(str, node->fldname))

Definition at line 65 of file outfuncs.c.

◆ WRITE_ENUM_FIELD

#define WRITE_ENUM_FIELD	(	fldname,
		enumtype
	)

Value:

appendStringInfo(str, " :" CppAsString(fldname) " %d", \

(int) node->fldname)

Definition at line 70 of file outfuncs.c.

◆ WRITE_FLOAT_FIELD

#define WRITE_FLOAT_FIELD ( fldname )

Value:

(appendStringInfo(str, " :" CppAsString(fldname) " "), \

outDouble(str, node->fldname))

Definition at line 75 of file outfuncs.c.

◆ WRITE_INDEX_ARRAY

#define WRITE_INDEX_ARRAY	(	fldname,
		len
	)

Value:

(appendStringInfoString(str, " :" CppAsString(fldname) " "), \

writeIndexCols(str, node->fldname, len))

Definition at line 119 of file outfuncs.c.

◆ WRITE_INT_ARRAY

#define WRITE_INT_ARRAY	(	fldname,
		len
	)

Value:

(appendStringInfoString(str, " :" CppAsString(fldname) " "), \

writeIntCols(str, node->fldname, len))

Definition at line 124 of file outfuncs.c.

◆ WRITE_INT_FIELD

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

Definition at line 44 of file outfuncs.c.

◆ WRITE_LOCATION_FIELD

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

Definition at line 90 of file outfuncs.c.

◆ WRITE_LONG_FIELD

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

Definition at line 61 of file outfuncs.c.

◆ WRITE_NODE_ARRAY

#define WRITE_NODE_ARRAY	(	fldname,
		len
	)

Value:

(appendStringInfoString(str, " :" CppAsString(fldname) " "), \

writeNodeArray(str, (const Node * const *) node->fldname, len))

Node

Definition: nodes.h:129

Definition at line 104 of file outfuncs.c.

◆ WRITE_NODE_FIELD

#define WRITE_NODE_FIELD ( fldname )

Value:

(appendStringInfoString(str, " :" CppAsString(fldname) " "), \

outNode(str, node->fldname))

Definition at line 94 of file outfuncs.c.

◆ WRITE_NODE_TYPE

#define WRITE_NODE_TYPE ( nodelabel ) appendStringInfoString(str, nodelabel)

Definition at line 40 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 114 of file outfuncs.c.

◆ WRITE_OID_FIELD

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

Definition at line 57 of file outfuncs.c.

◆ 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 224 of file outfuncs.c.

◆ WRITE_STRING_FIELD

#define WRITE_STRING_FIELD ( fldname )

Value:

(appendStringInfoString(str, " :" CppAsString(fldname) " "), \

outToken(str, node->fldname))

Definition at line 85 of file outfuncs.c.

◆ WRITE_UINT64_FIELD

#define WRITE_UINT64_FIELD ( fldname )

Value:

appendStringInfo(str, " :" CppAsString(fldname) " " UINT64_FORMAT, \

node->fldname)

UINT64_FORMAT

#define UINT64_FORMAT

Definition: c.h:538

Definition at line 52 of file outfuncs.c.

◆ WRITE_UINT_FIELD

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

Definition at line 48 of file outfuncs.c.

Function Documentation

◆ _outA_Const()

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

static

Definition at line 688 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(), generate_unaccent_rules::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 573 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(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, generate_unaccent_rules::str, WRITE_LOCATION_FIELD, WRITE_NODE_FIELD, and WRITE_NODE_TYPE.

◆ _outBitString()

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

static

Definition at line 681 of file outfuncs.c.

 {
     /* internal representation already has leading 'b' */
     appendStringInfoString(str, node->bsval);
 }

References appendStringInfoString(), BitString::bsval, and generate_unaccent_rules::str.

Referenced by outNode().

◆ _outBoolean()

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

static

Definition at line 661 of file outfuncs.c.

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

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

Referenced by outNode().

◆ _outBoolExpr()

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

static

Definition at line 399 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(), generate_unaccent_rules::args, BoolExpr::boolop, NOT_EXPR, OR_EXPR, outToken(), generate_unaccent_rules::str, WRITE_LOCATION_FIELD, WRITE_NODE_FIELD, and WRITE_NODE_TYPE.

◆ _outConst()

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

static

Definition at line 379 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(), outDatum(), generate_unaccent_rules::str, WRITE_BOOL_FIELD, WRITE_INT_FIELD, WRITE_LOCATION_FIELD, WRITE_NODE_TYPE, and WRITE_OID_FIELD.

◆ _outConstraint()

static void _outConstraint	(	StringInfo	str,
		const Constraint *	node
	)

static

Definition at line 703 of file outfuncs.c.

 {
     WRITE_NODE_TYPE("CONSTRAINT");
  
     WRITE_STRING_FIELD(conname);
     WRITE_BOOL_FIELD(deferrable);
     WRITE_BOOL_FIELD(initdeferred);
     WRITE_LOCATION_FIELD(location);
  
     appendStringInfoString(str, " :contype ");
     switch (node->contype)
     {
         case CONSTR_NULL:
             appendStringInfoString(str, "NULL");
             break;
  
         case CONSTR_NOTNULL:
             appendStringInfoString(str, "NOT_NULL");
             WRITE_NODE_FIELD(keys);
             WRITE_INT_FIELD(inhcount);
             WRITE_BOOL_FIELD(is_no_inherit);
             WRITE_BOOL_FIELD(skip_validation);
             WRITE_BOOL_FIELD(initially_valid);
             break;
  
         case CONSTR_DEFAULT:
             appendStringInfoString(str, "DEFAULT");
             WRITE_NODE_FIELD(raw_expr);
             WRITE_STRING_FIELD(cooked_expr);
             break;
  
         case CONSTR_IDENTITY:
             appendStringInfoString(str, "IDENTITY");
             WRITE_NODE_FIELD(options);
             WRITE_CHAR_FIELD(generated_when);
             break;
  
         case CONSTR_GENERATED:
             appendStringInfoString(str, "GENERATED");
             WRITE_NODE_FIELD(raw_expr);
             WRITE_STRING_FIELD(cooked_expr);
             WRITE_CHAR_FIELD(generated_when);
             break;
  
         case CONSTR_CHECK:
             appendStringInfoString(str, "CHECK");
             WRITE_BOOL_FIELD(is_no_inherit);
             WRITE_NODE_FIELD(raw_expr);
             WRITE_STRING_FIELD(cooked_expr);
             WRITE_BOOL_FIELD(skip_validation);
             WRITE_BOOL_FIELD(initially_valid);
             break;
  
         case CONSTR_PRIMARY:
             appendStringInfoString(str, "PRIMARY_KEY");
             WRITE_NODE_FIELD(keys);
             WRITE_NODE_FIELD(including);
             WRITE_NODE_FIELD(options);
             WRITE_STRING_FIELD(indexname);
             WRITE_STRING_FIELD(indexspace);
             WRITE_BOOL_FIELD(reset_default_tblspc);
             /* access_method and where_clause not currently used */
             break;
  
         case CONSTR_UNIQUE:
             appendStringInfoString(str, "UNIQUE");
             WRITE_BOOL_FIELD(nulls_not_distinct);
             WRITE_NODE_FIELD(keys);
             WRITE_NODE_FIELD(including);
             WRITE_NODE_FIELD(options);
             WRITE_STRING_FIELD(indexname);
             WRITE_STRING_FIELD(indexspace);
             WRITE_BOOL_FIELD(reset_default_tblspc);
             /* access_method and where_clause not currently used */
             break;
  
         case CONSTR_EXCLUSION:
             appendStringInfoString(str, "EXCLUSION");
             WRITE_NODE_FIELD(exclusions);
             WRITE_NODE_FIELD(including);
             WRITE_NODE_FIELD(options);
             WRITE_STRING_FIELD(indexname);
             WRITE_STRING_FIELD(indexspace);
             WRITE_BOOL_FIELD(reset_default_tblspc);
             WRITE_STRING_FIELD(access_method);
             WRITE_NODE_FIELD(where_clause);
             break;
  
         case CONSTR_FOREIGN:
             appendStringInfoString(str, "FOREIGN_KEY");
             WRITE_NODE_FIELD(pktable);
             WRITE_NODE_FIELD(fk_attrs);
             WRITE_NODE_FIELD(pk_attrs);
             WRITE_CHAR_FIELD(fk_matchtype);
             WRITE_CHAR_FIELD(fk_upd_action);
             WRITE_CHAR_FIELD(fk_del_action);
             WRITE_NODE_FIELD(fk_del_set_cols);
             WRITE_NODE_FIELD(old_conpfeqop);
             WRITE_OID_FIELD(old_pktable_oid);
             WRITE_BOOL_FIELD(skip_validation);
             WRITE_BOOL_FIELD(initially_valid);
             break;
  
         case CONSTR_ATTR_DEFERRABLE:
             appendStringInfoString(str, "ATTR_DEFERRABLE");
             break;
  
         case CONSTR_ATTR_NOT_DEFERRABLE:
             appendStringInfoString(str, "ATTR_NOT_DEFERRABLE");
             break;
  
         case CONSTR_ATTR_DEFERRED:
             appendStringInfoString(str, "ATTR_DEFERRED");
             break;
  
         case CONSTR_ATTR_IMMEDIATE:
             appendStringInfoString(str, "ATTR_IMMEDIATE");
             break;
  
         default:
             elog(ERROR, "unrecognized ConstrType: %d", (int) node->contype);
             break;
     }
 }

References appendStringInfoString(), CONSTR_ATTR_DEFERRABLE, CONSTR_ATTR_DEFERRED, CONSTR_ATTR_IMMEDIATE, CONSTR_ATTR_NOT_DEFERRABLE, CONSTR_CHECK, CONSTR_DEFAULT, CONSTR_EXCLUSION, CONSTR_FOREIGN, CONSTR_GENERATED, CONSTR_IDENTITY, CONSTR_NOTNULL, CONSTR_NULL, CONSTR_PRIMARY, CONSTR_UNIQUE, Constraint::contype, elog(), ERROR, generate_unaccent_rules::str, WRITE_BOOL_FIELD, WRITE_CHAR_FIELD, WRITE_INT_FIELD, WRITE_LOCATION_FIELD, WRITE_NODE_FIELD, WRITE_NODE_TYPE, WRITE_OID_FIELD, and WRITE_STRING_FIELD.

◆ _outEquivalenceClass()

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

static

Definition at line 452 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_NODE_FIELD(ec_members);
     WRITE_NODE_FIELD(ec_sources);
     WRITE_NODE_FIELD(ec_derives);
     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_merged, WRITE_BITMAPSET_FIELD, WRITE_BOOL_FIELD, 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 478 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, generate_unaccent_rules::str, WRITE_NODE_TYPE, and WRITE_STRING_FIELD.

◆ _outFloat()

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

static

Definition at line 651 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 generate_unaccent_rules::str.

Referenced by outNode().

◆ _outForeignKeyOptInfo()

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

static

Definition at line 426 of file outfuncs.c.

 {
     int         i;
  
     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 (i = 0; i < node->nkeys; i++)
         appendStringInfo(str, " %d", (node->eclass[i] != NULL));
     appendStringInfoString(str, " :rinfos");
     for (i = 0; i < node->nkeys; i++)
         appendStringInfo(str, " %d", list_length(node->rinfos[i]));
 }

References appendStringInfo(), appendStringInfoString(), ForeignKeyOptInfo::eclass, i, list_length(), ForeignKeyOptInfo::nkeys, ForeignKeyOptInfo::rinfos, generate_unaccent_rules::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 645 of file outfuncs.c.

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

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

Referenced by outNode().

◆ _outList()

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

static

Definition at line 272 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, IsA, lfirst, lfirst_int, lfirst_oid, lfirst_xid, lnext(), outNode(), generate_unaccent_rules::str, and List::type.

Referenced by outNode().

◆ _outRangeTblEntry()

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

static

Definition at line 493 of file outfuncs.c.

 {
     WRITE_NODE_TYPE("RANGETBLENTRY");
  
     /* put alias + eref first to make dump more legible */
     WRITE_NODE_FIELD(alias);
     WRITE_NODE_FIELD(eref);
     WRITE_ENUM_FIELD(rtekind, RTEKind);
  
     switch (node->rtekind)
     {
         case RTE_RELATION:
             WRITE_OID_FIELD(relid);
             WRITE_CHAR_FIELD(relkind);
             WRITE_INT_FIELD(rellockmode);
             WRITE_NODE_FIELD(tablesample);
             WRITE_UINT_FIELD(perminfoindex);
             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_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;
         default:
             elog(ERROR, "unrecognized RTE kind: %d", (int) node->rtekind);
             break;
     }
  
     WRITE_BOOL_FIELD(lateral);
     WRITE_BOOL_FIELD(inh);
     WRITE_BOOL_FIELD(inFromCl);
     WRITE_NODE_FIELD(securityQuals);
 }

References elog(), ERROR, functions, RTE_CTE, RTE_FUNCTION, 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 667 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(), generate_unaccent_rules::str, and String::sval.

Referenced by outNode().

◆ bmsToString()

char* bmsToString ( const Bitmapset * bms )

Definition at line 898 of file outfuncs.c.

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

References initStringInfo(), outBitmapset(), and generate_unaccent_rules::str.

Referenced by search_indexed_tlist_for_phv(), and search_indexed_tlist_for_var().

◆ nodeToString()

char* nodeToString ( const void * obj )

Definition at line 883 of file outfuncs.c.

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

References initStringInfo(), outNode(), and generate_unaccent_rules::str.

Referenced by AlterDomainDefault(), AlterPolicy(), CreatePolicy(), CreateStatistics(), CreateTriggerFiringOn(), DefineDomain(), DetachAddConstraintIfNeeded(), domainAddConstraint(), elog_node_display(), ExecSerializePlan(), expandTableLikeClause(), InsertRule(), pg_parse_query(), pg_plan_query(), pg_rewrite_query(), pprint(), print(), ProcedureCreate(), publication_add_relation(), StoreAttrDefault(), StorePartitionBound(), StorePartitionKey(), StoreRelCheck(), and UpdateIndexRelation().

◆ outBitmapset()

void outBitmapset	(	StringInfo	str,
		const Bitmapset *	bms
	)

Definition at line 322 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(), generate_unaccent_rules::str, and x.

Referenced by bmsToString(), and outNode().

◆ outChar()

static void outChar	(	StringInfo	str,
		char	c
	)

static

Definition at line 187 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 generate_unaccent_rules::str.

◆ outDatum()

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

Definition at line 338 of file outfuncs.c.

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

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

Referenced by _outConst().

◆ outDouble()

static void outDouble	(	StringInfo	str,
		double	d
	)

static

Definition at line 208 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 generate_unaccent_rules::str.

◆ outNode()

void outNode	(	StringInfo	str,
		const void *	obj
	)

Definition at line 834 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, (Integer *) obj);
     else if (IsA(obj, Float))
         _outFloat(str, (Float *) obj);
     else if (IsA(obj, Boolean))
         _outBoolean(str, (Boolean *) obj);
     else if (IsA(obj, String))
         _outString(str, (String *) obj);
     else if (IsA(obj, BitString))
         _outBitString(str, (BitString *) obj);
     else if (IsA(obj, Bitmapset))
         outBitmapset(str, (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(), IsA, nodeTag, outBitmapset(), generate_unaccent_rules::str, and WARNING.

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

◆ outToken()

void outToken	(	StringInfo	str,
		const char *	s
	)

Definition at line 146 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(), and generate_unaccent_rules::str.

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

◆ writeNodeArray()

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

static

Definition at line 252 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(), i, len, outNode(), and generate_unaccent_rules::str.

Macros

Functions

Macro Definition Documentation

◆ booltostr

◆ WRITE_ATTRNUMBER_ARRAY

◆ WRITE_BITMAPSET_FIELD

◆ WRITE_BOOL_ARRAY

◆ WRITE_BOOL_FIELD

◆ WRITE_CHAR_FIELD

◆ WRITE_ENUM_FIELD

◆ WRITE_FLOAT_FIELD

◆ WRITE_INDEX_ARRAY

◆ WRITE_INT_ARRAY

◆ WRITE_INT_FIELD

◆ WRITE_LOCATION_FIELD

◆ WRITE_LONG_FIELD

◆ WRITE_NODE_ARRAY

◆ WRITE_NODE_FIELD

◆ WRITE_NODE_TYPE

◆ WRITE_OID_ARRAY

◆ WRITE_OID_FIELD

◆ WRITE_SCALAR_ARRAY

◆ WRITE_STRING_FIELD

◆ WRITE_UINT64_FIELD

◆ WRITE_UINT_FIELD

Function Documentation

◆ _outA_Const()

◆ _outA_Expr()

◆ _outBitString()

◆ _outBoolean()

◆ _outBoolExpr()

◆ _outConst()

◆ _outConstraint()

◆ _outEquivalenceClass()

◆ _outExtensibleNode()

◆ _outFloat()

◆ _outForeignKeyOptInfo()

◆ _outInteger()

◆ _outList()

◆ _outRangeTblEntry()

◆ _outString()

◆ bmsToString()

◆ nodeToString()

◆ outBitmapset()

◆ outChar()

◆ outDatum()

◆ outDouble()

◆ outNode()

◆ outToken()

◆ writeNodeArray()