LCOV - code coverage report
Current view: top level - src/backend/nodes - outfuncs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 19devel Lines: 299 370 80.8 %
Date: 2025-07-29 03:18:01 Functions: 24 30 80.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * outfuncs.c
       4             :  *    Output functions for Postgres tree nodes.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/nodes/outfuncs.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include <ctype.h>
      18             : 
      19             : #include "access/attnum.h"
      20             : #include "common/shortest_dec.h"
      21             : #include "lib/stringinfo.h"
      22             : #include "miscadmin.h"
      23             : #include "nodes/bitmapset.h"
      24             : #include "nodes/nodes.h"
      25             : #include "nodes/pg_list.h"
      26             : #include "utils/datum.h"
      27             : 
      28             : /* State flag that determines how nodeToStringInternal() should treat location fields */
      29             : static bool write_location_fields = false;
      30             : 
      31             : static void outChar(StringInfo str, char c);
      32             : static void outDouble(StringInfo str, double d);
      33             : 
      34             : 
      35             : /*
      36             :  * Macros to simplify output of different kinds of fields.  Use these
      37             :  * wherever possible to reduce the chance for silly typos.  Note that these
      38             :  * hard-wire conventions about the names of the local variables in an Out
      39             :  * routine.
      40             :  */
      41             : 
      42             : /* Write the label for the node type */
      43             : #define WRITE_NODE_TYPE(nodelabel) \
      44             :     appendStringInfoString(str, nodelabel)
      45             : 
      46             : /* Write an integer field (anything written as ":fldname %d") */
      47             : #define WRITE_INT_FIELD(fldname) \
      48             :     appendStringInfo(str, " :" CppAsString(fldname) " %d", node->fldname)
      49             : 
      50             : /* Write an unsigned integer field (anything written as ":fldname %u") */
      51             : #define WRITE_UINT_FIELD(fldname) \
      52             :     appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
      53             : 
      54             : /* Write a signed integer field (anything written with INT64_FORMAT) */
      55             : #define WRITE_INT64_FIELD(fldname) \
      56             :     appendStringInfo(str, \
      57             :                      " :" CppAsString(fldname) " " INT64_FORMAT, \
      58             :                      node->fldname)
      59             : 
      60             : /* Write an unsigned integer field (anything written with UINT64_FORMAT) */
      61             : #define WRITE_UINT64_FIELD(fldname) \
      62             :     appendStringInfo(str, " :" CppAsString(fldname) " " UINT64_FORMAT, \
      63             :                      node->fldname)
      64             : 
      65             : /* Write an OID field (don't hard-wire assumption that OID is same as uint) */
      66             : #define WRITE_OID_FIELD(fldname) \
      67             :     appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
      68             : 
      69             : /* Write a long-integer field */
      70             : #define WRITE_LONG_FIELD(fldname) \
      71             :     appendStringInfo(str, " :" CppAsString(fldname) " %ld", node->fldname)
      72             : 
      73             : /* Write a char field (ie, one ascii character) */
      74             : #define WRITE_CHAR_FIELD(fldname) \
      75             :     (appendStringInfo(str, " :" CppAsString(fldname) " "), \
      76             :      outChar(str, node->fldname))
      77             : 
      78             : /* Write an enumerated-type field as an integer code */
      79             : #define WRITE_ENUM_FIELD(fldname, enumtype) \
      80             :     appendStringInfo(str, " :" CppAsString(fldname) " %d", \
      81             :                      (int) node->fldname)
      82             : 
      83             : /* Write a float field (actually, they're double) */
      84             : #define WRITE_FLOAT_FIELD(fldname) \
      85             :     (appendStringInfo(str, " :" CppAsString(fldname) " "), \
      86             :      outDouble(str, node->fldname))
      87             : 
      88             : /* Write a boolean field */
      89             : #define WRITE_BOOL_FIELD(fldname) \
      90             :     appendStringInfo(str, " :" CppAsString(fldname) " %s", \
      91             :                      booltostr(node->fldname))
      92             : 
      93             : /* Write a character-string (possibly NULL) field */
      94             : #define WRITE_STRING_FIELD(fldname) \
      95             :     (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
      96             :      outToken(str, node->fldname))
      97             : 
      98             : /* Write a parse location field (actually same as INT case) */
      99             : #define WRITE_LOCATION_FIELD(fldname) \
     100             :     appendStringInfo(str, " :" CppAsString(fldname) " %d", write_location_fields ? node->fldname : -1)
     101             : 
     102             : /* Write a Node field */
     103             : #define WRITE_NODE_FIELD(fldname) \
     104             :     (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
     105             :      outNode(str, node->fldname))
     106             : 
     107             : /* Write a bitmapset field */
     108             : #define WRITE_BITMAPSET_FIELD(fldname) \
     109             :     (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
     110             :      outBitmapset(str, node->fldname))
     111             : 
     112             : /* Write a variable-length array (not a List) of Node pointers */
     113             : #define WRITE_NODE_ARRAY(fldname, len) \
     114             :     (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
     115             :      writeNodeArray(str, (const Node * const *) node->fldname, len))
     116             : 
     117             : /* Write a variable-length array of AttrNumber */
     118             : #define WRITE_ATTRNUMBER_ARRAY(fldname, len) \
     119             :     (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
     120             :      writeAttrNumberCols(str, node->fldname, len))
     121             : 
     122             : /* Write a variable-length array of Oid */
     123             : #define WRITE_OID_ARRAY(fldname, len) \
     124             :     (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
     125             :      writeOidCols(str, node->fldname, len))
     126             : 
     127             : /* Write a variable-length array of Index */
     128             : #define WRITE_INDEX_ARRAY(fldname, len) \
     129             :     (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
     130             :      writeIndexCols(str, node->fldname, len))
     131             : 
     132             : /* Write a variable-length array of int */
     133             : #define WRITE_INT_ARRAY(fldname, len) \
     134             :     (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
     135             :      writeIntCols(str, node->fldname, len))
     136             : 
     137             : /* Write a variable-length array of bool */
     138             : #define WRITE_BOOL_ARRAY(fldname, len) \
     139             :     (appendStringInfoString(str, " :" CppAsString(fldname) " "), \
     140             :      writeBoolCols(str, node->fldname, len))
     141             : 
     142             : #define booltostr(x)  ((x) ? "true" : "false")
     143             : 
     144             : 
     145             : /*
     146             :  * outToken
     147             :  *    Convert an ordinary string (eg, an identifier) into a form that
     148             :  *    will be decoded back to a plain token by read.c's functions.
     149             :  *
     150             :  *    If a null string pointer is given, it is encoded as '<>'.
     151             :  *    An empty string is encoded as '""'.  To avoid ambiguity, input
     152             :  *    strings beginning with '<' or '"' receive a leading backslash.
     153             :  */
     154             : void
     155    49203782 : outToken(StringInfo str, const char *s)
     156             : {
     157    49203782 :     if (s == NULL)
     158             :     {
     159    10036684 :         appendStringInfoString(str, "<>");
     160    10036684 :         return;
     161             :     }
     162    39167098 :     if (*s == '\0')
     163             :     {
     164         156 :         appendStringInfoString(str, "\"\"");
     165         156 :         return;
     166             :     }
     167             : 
     168             :     /*
     169             :      * Look for characters or patterns that are treated specially by read.c
     170             :      * (either in pg_strtok() or in nodeRead()), and therefore need a
     171             :      * protective backslash.
     172             :      */
     173             :     /* These characters only need to be quoted at the start of the string */
     174    39166942 :     if (*s == '<' ||
     175    39098376 :         *s == '"' ||
     176    39092190 :         isdigit((unsigned char) *s) ||
     177    38901482 :         ((*s == '+' || *s == '-') &&
     178       31692 :          (isdigit((unsigned char) s[1]) || s[1] == '.')))
     179      270894 :         appendStringInfoChar(str, '\\');
     180   352795514 :     while (*s)
     181             :     {
     182             :         /* These chars must be backslashed anywhere in the string */
     183   313628572 :         if (*s == ' ' || *s == '\n' || *s == '\t' ||
     184   312271228 :             *s == '(' || *s == ')' || *s == '{' || *s == '}' ||
     185   312042068 :             *s == '\\')
     186     1597574 :             appendStringInfoChar(str, '\\');
     187   313628572 :         appendStringInfoChar(str, *s++);
     188             :     }
     189             : }
     190             : 
     191             : /*
     192             :  * Convert one char.  Goes through outToken() so that special characters are
     193             :  * escaped.
     194             :  */
     195             : static void
     196     3019984 : outChar(StringInfo str, char c)
     197             : {
     198             :     char        in[2];
     199             : 
     200             :     /* Traditionally, we've represented \0 as <>, so keep doing that */
     201     3019984 :     if (c == '\0')
     202             :     {
     203      918508 :         appendStringInfoString(str, "<>");
     204      918508 :         return;
     205             :     }
     206             : 
     207     2101476 :     in[0] = c;
     208     2101476 :     in[1] = '\0';
     209             : 
     210     2101476 :     outToken(str, in);
     211             : }
     212             : 
     213             : /*
     214             :  * Convert a double value, attempting to ensure the value is preserved exactly.
     215             :  */
     216             : static void
     217     3578220 : outDouble(StringInfo str, double d)
     218             : {
     219             :     char        buf[DOUBLE_SHORTEST_DECIMAL_LEN];
     220             : 
     221     3578220 :     double_to_shortest_decimal_buf(d, buf);
     222     3578220 :     appendStringInfoString(str, buf);
     223     3578220 : }
     224             : 
     225             : /*
     226             :  * common implementation for scalar-array-writing functions
     227             :  *
     228             :  * The data format is either "<>" for a NULL pointer or "(item item item)".
     229             :  * fmtstr must include a leading space, and the rest of it must produce
     230             :  * something that will be seen as a single simple token by pg_strtok().
     231             :  * convfunc can be empty, or the name of a conversion macro or function.
     232             :  */
     233             : #define WRITE_SCALAR_ARRAY(fnname, datatype, fmtstr, convfunc) \
     234             : static void \
     235             : fnname(StringInfo str, const datatype *arr, int len) \
     236             : { \
     237             :     if (arr != NULL) \
     238             :     { \
     239             :         appendStringInfoChar(str, '('); \
     240             :         for (int i = 0; i < len; i++) \
     241             :             appendStringInfo(str, fmtstr, convfunc(arr[i])); \
     242             :         appendStringInfoChar(str, ')'); \
     243             :     } \
     244             :     else \
     245             :         appendStringInfoString(str, "<>"); \
     246             : }
     247             : 
     248      477536 : WRITE_SCALAR_ARRAY(writeAttrNumberCols, AttrNumber, " %d",)
     249      644298 : WRITE_SCALAR_ARRAY(writeOidCols, Oid, " %u",)
     250           0 : WRITE_SCALAR_ARRAY(writeIndexCols, Index, " %u",)
     251       14622 : WRITE_SCALAR_ARRAY(writeIntCols, int, " %d",)
     252      244298 : WRITE_SCALAR_ARRAY(writeBoolCols, bool, " %s", booltostr)
     253             : 
     254             : /*
     255             :  * Print an array (not a List) of Node pointers.
     256             :  *
     257             :  * The decoration is identical to that of scalar arrays, but we can't
     258             :  * quite use appendStringInfo() in the loop.
     259             :  */
     260             : static void
     261           0 : writeNodeArray(StringInfo str, const Node *const *arr, int len)
     262             : {
     263           0 :     if (arr != NULL)
     264             :     {
     265           0 :         appendStringInfoChar(str, '(');
     266           0 :         for (int i = 0; i < len; i++)
     267             :         {
     268           0 :             appendStringInfoChar(str, ' ');
     269           0 :             outNode(str, arr[i]);
     270             :         }
     271           0 :         appendStringInfoChar(str, ')');
     272             :     }
     273             :     else
     274           0 :         appendStringInfoString(str, "<>");
     275           0 : }
     276             : 
     277             : /*
     278             :  * Print a List.
     279             :  */
     280             : static void
     281    18394434 : _outList(StringInfo str, const List *node)
     282             : {
     283             :     const ListCell *lc;
     284             : 
     285    18394434 :     appendStringInfoChar(str, '(');
     286             : 
     287    18394434 :     if (IsA(node, IntList))
     288      493106 :         appendStringInfoChar(str, 'i');
     289    17901328 :     else if (IsA(node, OidList))
     290      706700 :         appendStringInfoChar(str, 'o');
     291    17194628 :     else if (IsA(node, XidList))
     292           0 :         appendStringInfoChar(str, 'x');
     293             : 
     294    78210314 :     foreach(lc, node)
     295             :     {
     296             :         /*
     297             :          * For the sake of backward compatibility, we emit a slightly
     298             :          * different whitespace format for lists of nodes vs. other types of
     299             :          * lists. XXX: is this necessary?
     300             :          */
     301    59815880 :         if (IsA(node, List))
     302             :         {
     303    54055022 :             outNode(str, lfirst(lc));
     304    54055022 :             if (lnext(node, lc))
     305    36860394 :                 appendStringInfoChar(str, ' ');
     306             :         }
     307     5760858 :         else if (IsA(node, IntList))
     308     4356740 :             appendStringInfo(str, " %d", lfirst_int(lc));
     309     1404118 :         else if (IsA(node, OidList))
     310     1404118 :             appendStringInfo(str, " %u", lfirst_oid(lc));
     311           0 :         else if (IsA(node, XidList))
     312           0 :             appendStringInfo(str, " %u", lfirst_xid(lc));
     313             :         else
     314           0 :             elog(ERROR, "unrecognized list node type: %d",
     315             :                  (int) node->type);
     316             :     }
     317             : 
     318    18394434 :     appendStringInfoChar(str, ')');
     319    18394434 : }
     320             : 
     321             : /*
     322             :  * outBitmapset -
     323             :  *     converts a bitmap set of integers
     324             :  *
     325             :  * Note: the output format is "(b int int ...)", similar to an integer List.
     326             :  *
     327             :  * We export this function for use by extensions that define extensible nodes.
     328             :  * That's somewhat historical, though, because calling outNode() will work.
     329             :  */
     330             : void
     331    18910832 : outBitmapset(StringInfo str, const Bitmapset *bms)
     332             : {
     333             :     int         x;
     334             : 
     335    18910832 :     appendStringInfoChar(str, '(');
     336    18910832 :     appendStringInfoChar(str, 'b');
     337    18910832 :     x = -1;
     338    24340198 :     while ((x = bms_next_member(bms, x)) >= 0)
     339     5429366 :         appendStringInfo(str, " %d", x);
     340    18910832 :     appendStringInfoChar(str, ')');
     341    18910832 : }
     342             : 
     343             : /*
     344             :  * Print the value of a Datum given its type.
     345             :  */
     346             : void
     347     2453168 : outDatum(StringInfo str, Datum value, int typlen, bool typbyval)
     348             : {
     349             :     Size        length,
     350             :                 i;
     351             :     char       *s;
     352             : 
     353     2453168 :     length = datumGetSize(value, typbyval, typlen);
     354             : 
     355     2453168 :     if (typbyval)
     356             :     {
     357     1581628 :         s = (char *) (&value);
     358     1581628 :         appendStringInfo(str, "%u [ ", (unsigned int) length);
     359    14234652 :         for (i = 0; i < (Size) sizeof(Datum); i++)
     360    12653024 :             appendStringInfo(str, "%d ", (int) (s[i]));
     361     1581628 :         appendStringInfoChar(str, ']');
     362             :     }
     363             :     else
     364             :     {
     365      871540 :         s = (char *) DatumGetPointer(value);
     366      871540 :         if (!PointerIsValid(s))
     367           0 :             appendStringInfoString(str, "0 [ ]");
     368             :         else
     369             :         {
     370      871540 :             appendStringInfo(str, "%u [ ", (unsigned int) length);
     371   118559888 :             for (i = 0; i < length; i++)
     372   117688348 :                 appendStringInfo(str, "%d ", (int) (s[i]));
     373      871540 :             appendStringInfoChar(str, ']');
     374             :         }
     375             :     }
     376     2453168 : }
     377             : 
     378             : 
     379             : #include "outfuncs.funcs.c"
     380             : 
     381             : 
     382             : /*
     383             :  * Support functions for nodes with custom_read_write attribute or
     384             :  * special_read_write attribute
     385             :  */
     386             : 
     387             : static void
     388     2662420 : _outConst(StringInfo str, const Const *node)
     389             : {
     390     2662420 :     WRITE_NODE_TYPE("CONST");
     391             : 
     392     2662420 :     WRITE_OID_FIELD(consttype);
     393     2662420 :     WRITE_INT_FIELD(consttypmod);
     394     2662420 :     WRITE_OID_FIELD(constcollid);
     395     2662420 :     WRITE_INT_FIELD(constlen);
     396     2662420 :     WRITE_BOOL_FIELD(constbyval);
     397     2662420 :     WRITE_BOOL_FIELD(constisnull);
     398     2662420 :     WRITE_LOCATION_FIELD(location);
     399             : 
     400     2662420 :     appendStringInfoString(str, " :constvalue ");
     401     2662420 :     if (node->constisnull)
     402      209252 :         appendStringInfoString(str, "<>");
     403             :     else
     404     2453168 :         outDatum(str, node->constvalue, node->constlen, node->constbyval);
     405     2662420 : }
     406             : 
     407             : static void
     408      381672 : _outBoolExpr(StringInfo str, const BoolExpr *node)
     409             : {
     410      381672 :     char       *opstr = NULL;
     411             : 
     412      381672 :     WRITE_NODE_TYPE("BOOLEXPR");
     413             : 
     414             :     /* do-it-yourself enum representation */
     415      381672 :     switch (node->boolop)
     416             :     {
     417      288050 :         case AND_EXPR:
     418      288050 :             opstr = "and";
     419      288050 :             break;
     420       44452 :         case OR_EXPR:
     421       44452 :             opstr = "or";
     422       44452 :             break;
     423       49170 :         case NOT_EXPR:
     424       49170 :             opstr = "not";
     425       49170 :             break;
     426             :     }
     427      381672 :     appendStringInfoString(str, " :boolop ");
     428      381672 :     outToken(str, opstr);
     429             : 
     430      381672 :     WRITE_NODE_FIELD(args);
     431      381672 :     WRITE_LOCATION_FIELD(location);
     432      381672 : }
     433             : 
     434             : static void
     435           0 : _outForeignKeyOptInfo(StringInfo str, const ForeignKeyOptInfo *node)
     436             : {
     437             :     int         i;
     438             : 
     439           0 :     WRITE_NODE_TYPE("FOREIGNKEYOPTINFO");
     440             : 
     441           0 :     WRITE_UINT_FIELD(con_relid);
     442           0 :     WRITE_UINT_FIELD(ref_relid);
     443           0 :     WRITE_INT_FIELD(nkeys);
     444           0 :     WRITE_ATTRNUMBER_ARRAY(conkey, node->nkeys);
     445           0 :     WRITE_ATTRNUMBER_ARRAY(confkey, node->nkeys);
     446           0 :     WRITE_OID_ARRAY(conpfeqop, node->nkeys);
     447           0 :     WRITE_INT_FIELD(nmatched_ec);
     448           0 :     WRITE_INT_FIELD(nconst_ec);
     449           0 :     WRITE_INT_FIELD(nmatched_rcols);
     450           0 :     WRITE_INT_FIELD(nmatched_ri);
     451             :     /* for compactness, just print the number of matches per column: */
     452           0 :     appendStringInfoString(str, " :eclass");
     453           0 :     for (i = 0; i < node->nkeys; i++)
     454           0 :         appendStringInfo(str, " %d", (node->eclass[i] != NULL));
     455           0 :     appendStringInfoString(str, " :rinfos");
     456           0 :     for (i = 0; i < node->nkeys; i++)
     457           0 :         appendStringInfo(str, " %d", list_length(node->rinfos[i]));
     458           0 : }
     459             : 
     460             : static void
     461           0 : _outEquivalenceClass(StringInfo str, const EquivalenceClass *node)
     462             : {
     463             :     /*
     464             :      * To simplify reading, we just chase up to the topmost merged EC and
     465             :      * print that, without bothering to show the merge-ees separately.
     466             :      */
     467           0 :     while (node->ec_merged)
     468           0 :         node = node->ec_merged;
     469             : 
     470           0 :     WRITE_NODE_TYPE("EQUIVALENCECLASS");
     471             : 
     472           0 :     WRITE_NODE_FIELD(ec_opfamilies);
     473           0 :     WRITE_OID_FIELD(ec_collation);
     474           0 :     WRITE_INT_FIELD(ec_childmembers_size);
     475           0 :     WRITE_NODE_FIELD(ec_members);
     476           0 :     WRITE_NODE_ARRAY(ec_childmembers, node->ec_childmembers_size);
     477           0 :     WRITE_NODE_FIELD(ec_sources);
     478             :     /* Only ec_derives_list is written; hash is not serialized. */
     479           0 :     WRITE_NODE_FIELD(ec_derives_list);
     480           0 :     WRITE_BITMAPSET_FIELD(ec_relids);
     481           0 :     WRITE_BOOL_FIELD(ec_has_const);
     482           0 :     WRITE_BOOL_FIELD(ec_has_volatile);
     483           0 :     WRITE_BOOL_FIELD(ec_broken);
     484           0 :     WRITE_UINT_FIELD(ec_sortref);
     485           0 :     WRITE_UINT_FIELD(ec_min_security);
     486           0 :     WRITE_UINT_FIELD(ec_max_security);
     487           0 : }
     488             : 
     489             : static void
     490           0 : _outExtensibleNode(StringInfo str, const ExtensibleNode *node)
     491             : {
     492             :     const ExtensibleNodeMethods *methods;
     493             : 
     494           0 :     methods = GetExtensibleNodeMethods(node->extnodename, false);
     495             : 
     496           0 :     WRITE_NODE_TYPE("EXTENSIBLENODE");
     497             : 
     498           0 :     WRITE_STRING_FIELD(extnodename);
     499             : 
     500             :     /* serialize the private fields */
     501           0 :     methods->nodeOut(str, node);
     502           0 : }
     503             : 
     504             : static void
     505     1699538 : _outRangeTblEntry(StringInfo str, const RangeTblEntry *node)
     506             : {
     507     1699538 :     WRITE_NODE_TYPE("RANGETBLENTRY");
     508             : 
     509     1699538 :     WRITE_NODE_FIELD(alias);
     510     1699538 :     WRITE_NODE_FIELD(eref);
     511     1699538 :     WRITE_ENUM_FIELD(rtekind, RTEKind);
     512             : 
     513     1699538 :     switch (node->rtekind)
     514             :     {
     515     1021304 :         case RTE_RELATION:
     516     1021304 :             WRITE_OID_FIELD(relid);
     517     1021304 :             WRITE_BOOL_FIELD(inh);
     518     1021304 :             WRITE_CHAR_FIELD(relkind);
     519     1021304 :             WRITE_INT_FIELD(rellockmode);
     520     1021304 :             WRITE_UINT_FIELD(perminfoindex);
     521     1021304 :             WRITE_NODE_FIELD(tablesample);
     522     1021304 :             break;
     523      139602 :         case RTE_SUBQUERY:
     524      139602 :             WRITE_NODE_FIELD(subquery);
     525      139602 :             WRITE_BOOL_FIELD(security_barrier);
     526             :             /* we re-use these RELATION fields, too: */
     527      139602 :             WRITE_OID_FIELD(relid);
     528      139602 :             WRITE_BOOL_FIELD(inh);
     529      139602 :             WRITE_CHAR_FIELD(relkind);
     530      139602 :             WRITE_INT_FIELD(rellockmode);
     531      139602 :             WRITE_UINT_FIELD(perminfoindex);
     532      139602 :             break;
     533      190004 :         case RTE_JOIN:
     534      190004 :             WRITE_ENUM_FIELD(jointype, JoinType);
     535      190004 :             WRITE_INT_FIELD(joinmergedcols);
     536      190004 :             WRITE_NODE_FIELD(joinaliasvars);
     537      190004 :             WRITE_NODE_FIELD(joinleftcols);
     538      190004 :             WRITE_NODE_FIELD(joinrightcols);
     539      190004 :             WRITE_NODE_FIELD(join_using_alias);
     540      190004 :             break;
     541      107046 :         case RTE_FUNCTION:
     542      107046 :             WRITE_NODE_FIELD(functions);
     543      107046 :             WRITE_BOOL_FIELD(funcordinality);
     544      107046 :             break;
     545        1296 :         case RTE_TABLEFUNC:
     546        1296 :             WRITE_NODE_FIELD(tablefunc);
     547        1296 :             break;
     548       21414 :         case RTE_VALUES:
     549       21414 :             WRITE_NODE_FIELD(values_lists);
     550       21414 :             WRITE_NODE_FIELD(coltypes);
     551       21414 :             WRITE_NODE_FIELD(coltypmods);
     552       21414 :             WRITE_NODE_FIELD(colcollations);
     553       21414 :             break;
     554       12064 :         case RTE_CTE:
     555       12064 :             WRITE_STRING_FIELD(ctename);
     556       12064 :             WRITE_UINT_FIELD(ctelevelsup);
     557       12064 :             WRITE_BOOL_FIELD(self_reference);
     558       12064 :             WRITE_NODE_FIELD(coltypes);
     559       12064 :             WRITE_NODE_FIELD(coltypmods);
     560       12064 :             WRITE_NODE_FIELD(colcollations);
     561       12064 :             break;
     562         950 :         case RTE_NAMEDTUPLESTORE:
     563         950 :             WRITE_STRING_FIELD(enrname);
     564         950 :             WRITE_FLOAT_FIELD(enrtuples);
     565         950 :             WRITE_NODE_FIELD(coltypes);
     566         950 :             WRITE_NODE_FIELD(coltypmods);
     567         950 :             WRITE_NODE_FIELD(colcollations);
     568             :             /* we re-use these RELATION fields, too: */
     569         950 :             WRITE_OID_FIELD(relid);
     570         950 :             break;
     571      196468 :         case RTE_RESULT:
     572             :             /* no extra fields */
     573      196468 :             break;
     574        9390 :         case RTE_GROUP:
     575        9390 :             WRITE_NODE_FIELD(groupexprs);
     576        9390 :             break;
     577           0 :         default:
     578           0 :             elog(ERROR, "unrecognized RTE kind: %d", (int) node->rtekind);
     579             :             break;
     580             :     }
     581             : 
     582     1699538 :     WRITE_BOOL_FIELD(lateral);
     583     1699538 :     WRITE_BOOL_FIELD(inFromCl);
     584     1699538 :     WRITE_NODE_FIELD(securityQuals);
     585     1699538 : }
     586             : 
     587             : static void
     588      670642 : _outA_Expr(StringInfo str, const A_Expr *node)
     589             : {
     590      670642 :     WRITE_NODE_TYPE("A_EXPR");
     591             : 
     592      670642 :     switch (node->kind)
     593             :     {
     594      619458 :         case AEXPR_OP:
     595      619458 :             WRITE_NODE_FIELD(name);
     596      619458 :             break;
     597       16922 :         case AEXPR_OP_ANY:
     598       16922 :             appendStringInfoString(str, " ANY");
     599       16922 :             WRITE_NODE_FIELD(name);
     600       16922 :             break;
     601         144 :         case AEXPR_OP_ALL:
     602         144 :             appendStringInfoString(str, " ALL");
     603         144 :             WRITE_NODE_FIELD(name);
     604         144 :             break;
     605        1262 :         case AEXPR_DISTINCT:
     606        1262 :             appendStringInfoString(str, " DISTINCT");
     607        1262 :             WRITE_NODE_FIELD(name);
     608        1262 :             break;
     609          74 :         case AEXPR_NOT_DISTINCT:
     610          74 :             appendStringInfoString(str, " NOT_DISTINCT");
     611          74 :             WRITE_NODE_FIELD(name);
     612          74 :             break;
     613         696 :         case AEXPR_NULLIF:
     614         696 :             appendStringInfoString(str, " NULLIF");
     615         696 :             WRITE_NODE_FIELD(name);
     616         696 :             break;
     617       28826 :         case AEXPR_IN:
     618       28826 :             appendStringInfoString(str, " IN");
     619       28826 :             WRITE_NODE_FIELD(name);
     620       28826 :             break;
     621        2346 :         case AEXPR_LIKE:
     622        2346 :             appendStringInfoString(str, " LIKE");
     623        2346 :             WRITE_NODE_FIELD(name);
     624        2346 :             break;
     625         202 :         case AEXPR_ILIKE:
     626         202 :             appendStringInfoString(str, " ILIKE");
     627         202 :             WRITE_NODE_FIELD(name);
     628         202 :             break;
     629         118 :         case AEXPR_SIMILAR:
     630         118 :             appendStringInfoString(str, " SIMILAR");
     631         118 :             WRITE_NODE_FIELD(name);
     632         118 :             break;
     633         558 :         case AEXPR_BETWEEN:
     634         558 :             appendStringInfoString(str, " BETWEEN");
     635         558 :             WRITE_NODE_FIELD(name);
     636         558 :             break;
     637          12 :         case AEXPR_NOT_BETWEEN:
     638          12 :             appendStringInfoString(str, " NOT_BETWEEN");
     639          12 :             WRITE_NODE_FIELD(name);
     640          12 :             break;
     641          12 :         case AEXPR_BETWEEN_SYM:
     642          12 :             appendStringInfoString(str, " BETWEEN_SYM");
     643          12 :             WRITE_NODE_FIELD(name);
     644          12 :             break;
     645          12 :         case AEXPR_NOT_BETWEEN_SYM:
     646          12 :             appendStringInfoString(str, " NOT_BETWEEN_SYM");
     647          12 :             WRITE_NODE_FIELD(name);
     648          12 :             break;
     649           0 :         default:
     650           0 :             elog(ERROR, "unrecognized A_Expr_Kind: %d", (int) node->kind);
     651             :             break;
     652             :     }
     653             : 
     654      670642 :     WRITE_NODE_FIELD(lexpr);
     655      670642 :     WRITE_NODE_FIELD(rexpr);
     656      670642 :     WRITE_LOCATION_FIELD(rexpr_list_start);
     657      670642 :     WRITE_LOCATION_FIELD(rexpr_list_end);
     658      670642 :     WRITE_LOCATION_FIELD(location);
     659      670642 : }
     660             : 
     661             : static void
     662      473048 : _outInteger(StringInfo str, const Integer *node)
     663             : {
     664      473048 :     appendStringInfo(str, "%d", node->ival);
     665      473048 : }
     666             : 
     667             : static void
     668       12046 : _outFloat(StringInfo str, const Float *node)
     669             : {
     670             :     /*
     671             :      * We assume the value is a valid numeric literal and so does not need
     672             :      * quoting.
     673             :      */
     674       12046 :     appendStringInfoString(str, node->fval);
     675       12046 : }
     676             : 
     677             : static void
     678      105520 : _outBoolean(StringInfo str, const Boolean *node)
     679             : {
     680      105520 :     appendStringInfoString(str, node->boolval ? "true" : "false");
     681      105520 : }
     682             : 
     683             : static void
     684    27780352 : _outString(StringInfo str, const String *node)
     685             : {
     686             :     /*
     687             :      * We use outToken to provide escaping of the string's content, but we
     688             :      * don't want it to convert an empty string to '""', because we're putting
     689             :      * double quotes around the string already.
     690             :      */
     691    27780352 :     appendStringInfoChar(str, '"');
     692    27780352 :     if (node->sval[0] != '\0')
     693    27748050 :         outToken(str, node->sval);
     694    27780352 :     appendStringInfoChar(str, '"');
     695    27780352 : }
     696             : 
     697             : static void
     698        4068 : _outBitString(StringInfo str, const BitString *node)
     699             : {
     700             :     /*
     701             :      * The lexer will always produce a string starting with 'b' or 'x'.  There
     702             :      * might be characters following that that need escaping, but outToken
     703             :      * won't escape the 'b' or 'x'.  This is relied on by nodeTokenType.
     704             :      */
     705             :     Assert(node->bsval[0] == 'b' || node->bsval[0] == 'x');
     706        4068 :     outToken(str, node->bsval);
     707        4068 : }
     708             : 
     709             : static void
     710     1459866 : _outA_Const(StringInfo str, const A_Const *node)
     711             : {
     712     1459866 :     WRITE_NODE_TYPE("A_CONST");
     713             : 
     714     1459866 :     if (node->isnull)
     715       87186 :         appendStringInfoString(str, " NULL");
     716             :     else
     717             :     {
     718     1372680 :         appendStringInfoString(str, " :val ");
     719     1372680 :         outNode(str, &node->val);
     720             :     }
     721     1459866 :     WRITE_LOCATION_FIELD(location);
     722     1459866 : }
     723             : 
     724             : 
     725             : /*
     726             :  * outNode -
     727             :  *    converts a Node into ascii string and append it to 'str'
     728             :  */
     729             : void
     730   148654232 : outNode(StringInfo str, const void *obj)
     731             : {
     732             :     /* Guard against stack overflow due to overly complex expressions */
     733   148654232 :     check_stack_depth();
     734             : 
     735   148654232 :     if (obj == NULL)
     736    53273814 :         appendStringInfoString(str, "<>");
     737    95380418 :     else if (IsA(obj, List) || IsA(obj, IntList) || IsA(obj, OidList) ||
     738    76985974 :              IsA(obj, XidList))
     739    18394444 :         _outList(str, obj);
     740             :     /* nodeRead does not want to see { } around these! */
     741    76985974 :     else if (IsA(obj, Integer))
     742      473048 :         _outInteger(str, (Integer *) obj);
     743    76512926 :     else if (IsA(obj, Float))
     744       12046 :         _outFloat(str, (Float *) obj);
     745    76500880 :     else if (IsA(obj, Boolean))
     746      105520 :         _outBoolean(str, (Boolean *) obj);
     747    76395360 :     else if (IsA(obj, String))
     748    27780352 :         _outString(str, (String *) obj);
     749    48615008 :     else if (IsA(obj, BitString))
     750        4068 :         _outBitString(str, (BitString *) obj);
     751    48610940 :     else if (IsA(obj, Bitmapset))
     752           0 :         outBitmapset(str, (Bitmapset *) obj);
     753             :     else
     754             :     {
     755    48610940 :         appendStringInfoChar(str, '{');
     756    48610940 :         switch (nodeTag(obj))
     757             :         {
     758             : #include "outfuncs.switch.c"
     759             : 
     760           0 :             default:
     761             : 
     762             :                 /*
     763             :                  * This should be an ERROR, but it's too useful to be able to
     764             :                  * dump structures that outNode only understands part of.
     765             :                  */
     766           0 :                 elog(WARNING, "could not dump unrecognized node type: %d",
     767             :                      (int) nodeTag(obj));
     768           0 :                 break;
     769             :         }
     770    48610940 :         appendStringInfoChar(str, '}');
     771             :     }
     772   148654232 : }
     773             : 
     774             : /*
     775             :  * nodeToString -
     776             :  *     returns the ascii representation of the Node as a palloc'd string
     777             :  *
     778             :  * write_loc_fields determines whether location fields are output with their
     779             :  * actual value rather than -1.  The actual value can be useful for debugging,
     780             :  * but for most uses, the actual value is not useful, since the original query
     781             :  * string is no longer available.
     782             :  */
     783             : static char *
     784     2033002 : nodeToStringInternal(const void *obj, bool write_loc_fields)
     785             : {
     786             :     StringInfoData str;
     787             :     bool        save_write_location_fields;
     788             : 
     789     2033002 :     save_write_location_fields = write_location_fields;
     790     2033002 :     write_location_fields = write_loc_fields;
     791             : 
     792             :     /* see stringinfo.h for an explanation of this maneuver */
     793     2033002 :     initStringInfo(&str);
     794     2033002 :     outNode(&str, obj);
     795             : 
     796     2033002 :     write_location_fields = save_write_location_fields;
     797             : 
     798     2033002 :     return str.data;
     799             : }
     800             : 
     801             : /*
     802             :  * Externally visible entry points
     803             :  */
     804             : char *
     805       70448 : nodeToString(const void *obj)
     806             : {
     807       70448 :     return nodeToStringInternal(obj, false);
     808             : }
     809             : 
     810             : char *
     811     1962554 : nodeToStringWithLocations(const void *obj)
     812             : {
     813     1962554 :     return nodeToStringInternal(obj, true);
     814             : }
     815             : 
     816             : 
     817             : /*
     818             :  * bmsToString -
     819             :  *     returns the ascii representation of the Bitmapset as a palloc'd string
     820             :  */
     821             : char *
     822           0 : bmsToString(const Bitmapset *bms)
     823             : {
     824             :     StringInfoData str;
     825             : 
     826             :     /* see stringinfo.h for an explanation of this maneuver */
     827           0 :     initStringInfo(&str);
     828           0 :     outBitmapset(&str, bms);
     829           0 :     return str.data;
     830             : }

Generated by: LCOV version 1.16