LCOV - code coverage report
Current view: top level - src/backend/nodes - readfuncs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 15devel Lines: 1465 1567 93.5 %
Date: 2021-12-09 03:08:47 Functions: 125 136 91.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * readfuncs.c
       4             :  *    Reader functions for Postgres tree nodes.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/nodes/readfuncs.c
      12             :  *
      13             :  * NOTES
      14             :  *    Path nodes do not have any readfuncs support, because we never
      15             :  *    have occasion to read them in.  (There was once code here that
      16             :  *    claimed to read them, but it was broken as well as unused.)  We
      17             :  *    never read executor state trees, either.
      18             :  *
      19             :  *    Parse location fields are written out by outfuncs.c, but only for
      20             :  *    debugging use.  When reading a location field, we normally discard
      21             :  *    the stored value and set the location field to -1 (ie, "unknown").
      22             :  *    This is because nodes coming from a stored rule should not be thought
      23             :  *    to have a known location in the current query's text.
      24             :  *    However, if restore_location_fields is true, we do restore location
      25             :  *    fields from the string.  This is currently intended only for use by the
      26             :  *    WRITE_READ_PARSE_PLAN_TREES test code, which doesn't want to cause
      27             :  *    any change in the node contents.
      28             :  *
      29             :  *-------------------------------------------------------------------------
      30             :  */
      31             : #include "postgres.h"
      32             : 
      33             : #include <math.h>
      34             : 
      35             : #include "fmgr.h"
      36             : #include "miscadmin.h"
      37             : #include "nodes/extensible.h"
      38             : #include "nodes/parsenodes.h"
      39             : #include "nodes/plannodes.h"
      40             : #include "nodes/readfuncs.h"
      41             : #include "utils/builtins.h"
      42             : 
      43             : 
      44             : /*
      45             :  * Macros to simplify reading of different kinds of fields.  Use these
      46             :  * wherever possible to reduce the chance for silly typos.  Note that these
      47             :  * hard-wire conventions about the names of the local variables in a Read
      48             :  * routine.
      49             :  */
      50             : 
      51             : /* Macros for declaring appropriate local variables */
      52             : 
      53             : /* A few guys need only local_node */
      54             : #define READ_LOCALS_NO_FIELDS(nodeTypeName) \
      55             :     nodeTypeName *local_node = makeNode(nodeTypeName)
      56             : 
      57             : /* And a few guys need only the pg_strtok support fields */
      58             : #define READ_TEMP_LOCALS()  \
      59             :     const char *token;      \
      60             :     int         length
      61             : 
      62             : /* ... but most need both */
      63             : #define READ_LOCALS(nodeTypeName)           \
      64             :     READ_LOCALS_NO_FIELDS(nodeTypeName);    \
      65             :     READ_TEMP_LOCALS()
      66             : 
      67             : /* Read an integer field (anything written as ":fldname %d") */
      68             : #define READ_INT_FIELD(fldname) \
      69             :     token = pg_strtok(&length);     /* skip :fldname */ \
      70             :     token = pg_strtok(&length);     /* get field value */ \
      71             :     local_node->fldname = atoi(token)
      72             : 
      73             : /* Read an unsigned integer field (anything written as ":fldname %u") */
      74             : #define READ_UINT_FIELD(fldname) \
      75             :     token = pg_strtok(&length);     /* skip :fldname */ \
      76             :     token = pg_strtok(&length);     /* get field value */ \
      77             :     local_node->fldname = atoui(token)
      78             : 
      79             : /* Read an unsigned integer field (anything written using UINT64_FORMAT) */
      80             : #define READ_UINT64_FIELD(fldname) \
      81             :     token = pg_strtok(&length);     /* skip :fldname */ \
      82             :     token = pg_strtok(&length);     /* get field value */ \
      83             :     local_node->fldname = pg_strtouint64(token, NULL, 10)
      84             : 
      85             : /* Read a long integer field (anything written as ":fldname %ld") */
      86             : #define READ_LONG_FIELD(fldname) \
      87             :     token = pg_strtok(&length);     /* skip :fldname */ \
      88             :     token = pg_strtok(&length);     /* get field value */ \
      89             :     local_node->fldname = atol(token)
      90             : 
      91             : /* Read an OID field (don't hard-wire assumption that OID is same as uint) */
      92             : #define READ_OID_FIELD(fldname) \
      93             :     token = pg_strtok(&length);     /* skip :fldname */ \
      94             :     token = pg_strtok(&length);     /* get field value */ \
      95             :     local_node->fldname = atooid(token)
      96             : 
      97             : /* Read a char field (ie, one ascii character) */
      98             : #define READ_CHAR_FIELD(fldname) \
      99             :     token = pg_strtok(&length);     /* skip :fldname */ \
     100             :     token = pg_strtok(&length);     /* get field value */ \
     101             :     /* avoid overhead of calling debackslash() for one char */ \
     102             :     local_node->fldname = (length == 0) ? '\0' : (token[0] == '\\' ? token[1] : token[0])
     103             : 
     104             : /* Read an enumerated-type field that was written as an integer code */
     105             : #define READ_ENUM_FIELD(fldname, enumtype) \
     106             :     token = pg_strtok(&length);     /* skip :fldname */ \
     107             :     token = pg_strtok(&length);     /* get field value */ \
     108             :     local_node->fldname = (enumtype) atoi(token)
     109             : 
     110             : /* Read a float field */
     111             : #define READ_FLOAT_FIELD(fldname) \
     112             :     token = pg_strtok(&length);     /* skip :fldname */ \
     113             :     token = pg_strtok(&length);     /* get field value */ \
     114             :     local_node->fldname = atof(token)
     115             : 
     116             : /* Read a boolean field */
     117             : #define READ_BOOL_FIELD(fldname) \
     118             :     token = pg_strtok(&length);     /* skip :fldname */ \
     119             :     token = pg_strtok(&length);     /* get field value */ \
     120             :     local_node->fldname = strtobool(token)
     121             : 
     122             : /* Read a character-string field */
     123             : #define READ_STRING_FIELD(fldname) \
     124             :     token = pg_strtok(&length);     /* skip :fldname */ \
     125             :     token = pg_strtok(&length);     /* get field value */ \
     126             :     local_node->fldname = nullable_string(token, length)
     127             : 
     128             : /* Read a parse location field (and possibly throw away the value) */
     129             : #ifdef WRITE_READ_PARSE_PLAN_TREES
     130             : #define READ_LOCATION_FIELD(fldname) \
     131             :     token = pg_strtok(&length);     /* skip :fldname */ \
     132             :     token = pg_strtok(&length);     /* get field value */ \
     133             :     local_node->fldname = restore_location_fields ? atoi(token) : -1
     134             : #else
     135             : #define READ_LOCATION_FIELD(fldname) \
     136             :     token = pg_strtok(&length);     /* skip :fldname */ \
     137             :     token = pg_strtok(&length);     /* get field value */ \
     138             :     (void) token;               /* in case not used elsewhere */ \
     139             :     local_node->fldname = -1 /* set field to "unknown" */
     140             : #endif
     141             : 
     142             : /* Read a Node field */
     143             : #define READ_NODE_FIELD(fldname) \
     144             :     token = pg_strtok(&length);     /* skip :fldname */ \
     145             :     (void) token;               /* in case not used elsewhere */ \
     146             :     local_node->fldname = nodeRead(NULL, 0)
     147             : 
     148             : /* Read a bitmapset field */
     149             : #define READ_BITMAPSET_FIELD(fldname) \
     150             :     token = pg_strtok(&length);     /* skip :fldname */ \
     151             :     (void) token;               /* in case not used elsewhere */ \
     152             :     local_node->fldname = _readBitmapset()
     153             : 
     154             : /* Read an attribute number array */
     155             : #define READ_ATTRNUMBER_ARRAY(fldname, len) \
     156             :     token = pg_strtok(&length);     /* skip :fldname */ \
     157             :     local_node->fldname = readAttrNumberCols(len)
     158             : 
     159             : /* Read an oid array */
     160             : #define READ_OID_ARRAY(fldname, len) \
     161             :     token = pg_strtok(&length);     /* skip :fldname */ \
     162             :     local_node->fldname = readOidCols(len)
     163             : 
     164             : /* Read an int array */
     165             : #define READ_INT_ARRAY(fldname, len) \
     166             :     token = pg_strtok(&length);     /* skip :fldname */ \
     167             :     local_node->fldname = readIntCols(len)
     168             : 
     169             : /* Read a bool array */
     170             : #define READ_BOOL_ARRAY(fldname, len) \
     171             :     token = pg_strtok(&length);     /* skip :fldname */ \
     172             :     local_node->fldname = readBoolCols(len)
     173             : 
     174             : /* Routine exit */
     175             : #define READ_DONE() \
     176             :     return local_node
     177             : 
     178             : 
     179             : /*
     180             :  * NOTE: use atoi() to read values written with %d, or atoui() to read
     181             :  * values written with %u in outfuncs.c.  An exception is OID values,
     182             :  * for which use atooid().  (As of 7.1, outfuncs.c writes OIDs as %u,
     183             :  * but this will probably change in the future.)
     184             :  */
     185             : #define atoui(x)  ((unsigned int) strtoul((x), NULL, 10))
     186             : 
     187             : #define strtobool(x)  ((*(x) == 't') ? true : false)
     188             : 
     189             : #define nullable_string(token,length)  \
     190             :     ((length) == 0 ? NULL : debackslash(token, length))
     191             : 
     192             : 
     193             : /*
     194             :  * _readBitmapset
     195             :  */
     196             : static Bitmapset *
     197     8365254 : _readBitmapset(void)
     198             : {
     199     8365254 :     Bitmapset  *result = NULL;
     200             : 
     201             :     READ_TEMP_LOCALS();
     202             : 
     203     8365254 :     token = pg_strtok(&length);
     204     8365254 :     if (token == NULL)
     205           0 :         elog(ERROR, "incomplete Bitmapset structure");
     206     8365254 :     if (length != 1 || token[0] != '(')
     207           0 :         elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
     208             : 
     209     8365254 :     token = pg_strtok(&length);
     210     8365254 :     if (token == NULL)
     211           0 :         elog(ERROR, "incomplete Bitmapset structure");
     212     8365254 :     if (length != 1 || token[0] != 'b')
     213           0 :         elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
     214             : 
     215             :     for (;;)
     216     3128970 :     {
     217             :         int         val;
     218             :         char       *endptr;
     219             : 
     220    11494224 :         token = pg_strtok(&length);
     221    11494224 :         if (token == NULL)
     222           0 :             elog(ERROR, "unterminated Bitmapset structure");
     223    11494224 :         if (length == 1 && token[0] == ')')
     224     8365254 :             break;
     225     3128970 :         val = (int) strtol(token, &endptr, 10);
     226     3128970 :         if (endptr != token + length)
     227           0 :             elog(ERROR, "unrecognized integer: \"%.*s\"", length, token);
     228     3128970 :         result = bms_add_member(result, val);
     229             :     }
     230             : 
     231     8365254 :     return result;
     232             : }
     233             : 
     234             : /*
     235             :  * for use by extensions which define extensible nodes
     236             :  */
     237             : Bitmapset *
     238           0 : readBitmapset(void)
     239             : {
     240           0 :     return _readBitmapset();
     241             : }
     242             : 
     243             : /*
     244             :  * _readQuery
     245             :  */
     246             : static Query *
     247      565300 : _readQuery(void)
     248             : {
     249      565300 :     READ_LOCALS(Query);
     250             : 
     251      565300 :     READ_ENUM_FIELD(commandType, CmdType);
     252      565300 :     READ_ENUM_FIELD(querySource, QuerySource);
     253      565300 :     local_node->queryId = UINT64CONST(0);    /* not saved in output format */
     254      565300 :     READ_BOOL_FIELD(canSetTag);
     255      565300 :     READ_NODE_FIELD(utilityStmt);
     256      565300 :     READ_INT_FIELD(resultRelation);
     257      565300 :     READ_BOOL_FIELD(hasAggs);
     258      565300 :     READ_BOOL_FIELD(hasWindowFuncs);
     259      565300 :     READ_BOOL_FIELD(hasTargetSRFs);
     260      565300 :     READ_BOOL_FIELD(hasSubLinks);
     261      565300 :     READ_BOOL_FIELD(hasDistinctOn);
     262      565300 :     READ_BOOL_FIELD(hasRecursive);
     263      565300 :     READ_BOOL_FIELD(hasModifyingCTE);
     264      565300 :     READ_BOOL_FIELD(hasForUpdate);
     265      565300 :     READ_BOOL_FIELD(hasRowSecurity);
     266      565300 :     READ_BOOL_FIELD(isReturn);
     267      565300 :     READ_NODE_FIELD(cteList);
     268      565300 :     READ_NODE_FIELD(rtable);
     269      565300 :     READ_NODE_FIELD(jointree);
     270      565300 :     READ_NODE_FIELD(targetList);
     271      565300 :     READ_ENUM_FIELD(override, OverridingKind);
     272      565300 :     READ_NODE_FIELD(onConflict);
     273      565300 :     READ_NODE_FIELD(returningList);
     274      565300 :     READ_NODE_FIELD(groupClause);
     275      565300 :     READ_BOOL_FIELD(groupDistinct);
     276      565300 :     READ_NODE_FIELD(groupingSets);
     277      565300 :     READ_NODE_FIELD(havingQual);
     278      565300 :     READ_NODE_FIELD(windowClause);
     279      565300 :     READ_NODE_FIELD(distinctClause);
     280      565300 :     READ_NODE_FIELD(sortClause);
     281      565300 :     READ_NODE_FIELD(limitOffset);
     282      565300 :     READ_NODE_FIELD(limitCount);
     283      565300 :     READ_ENUM_FIELD(limitOption, LimitOption);
     284      565300 :     READ_NODE_FIELD(rowMarks);
     285      565300 :     READ_NODE_FIELD(setOperations);
     286      565300 :     READ_NODE_FIELD(constraintDeps);
     287      565300 :     READ_NODE_FIELD(withCheckOptions);
     288      565300 :     READ_LOCATION_FIELD(stmt_location);
     289      565300 :     READ_INT_FIELD(stmt_len);
     290             : 
     291      565300 :     READ_DONE();
     292             : }
     293             : 
     294             : /*
     295             :  * _readNotifyStmt
     296             :  */
     297             : static NotifyStmt *
     298          52 : _readNotifyStmt(void)
     299             : {
     300          52 :     READ_LOCALS(NotifyStmt);
     301             : 
     302          52 :     READ_STRING_FIELD(conditionname);
     303          52 :     READ_STRING_FIELD(payload);
     304             : 
     305          52 :     READ_DONE();
     306             : }
     307             : 
     308             : /*
     309             :  * _readDeclareCursorStmt
     310             :  */
     311             : static DeclareCursorStmt *
     312           0 : _readDeclareCursorStmt(void)
     313             : {
     314           0 :     READ_LOCALS(DeclareCursorStmt);
     315             : 
     316           0 :     READ_STRING_FIELD(portalname);
     317           0 :     READ_INT_FIELD(options);
     318           0 :     READ_NODE_FIELD(query);
     319             : 
     320           0 :     READ_DONE();
     321             : }
     322             : 
     323             : /*
     324             :  * _readWithCheckOption
     325             :  */
     326             : static WithCheckOption *
     327        2220 : _readWithCheckOption(void)
     328             : {
     329        2220 :     READ_LOCALS(WithCheckOption);
     330             : 
     331        2220 :     READ_ENUM_FIELD(kind, WCOKind);
     332        2220 :     READ_STRING_FIELD(relname);
     333        2220 :     READ_STRING_FIELD(polname);
     334        2220 :     READ_NODE_FIELD(qual);
     335        2220 :     READ_BOOL_FIELD(cascaded);
     336             : 
     337        2220 :     READ_DONE();
     338             : }
     339             : 
     340             : /*
     341             :  * _readSortGroupClause
     342             :  */
     343             : static SortGroupClause *
     344      127842 : _readSortGroupClause(void)
     345             : {
     346      127842 :     READ_LOCALS(SortGroupClause);
     347             : 
     348      127842 :     READ_UINT_FIELD(tleSortGroupRef);
     349      127842 :     READ_OID_FIELD(eqop);
     350      127842 :     READ_OID_FIELD(sortop);
     351      127842 :     READ_BOOL_FIELD(nulls_first);
     352      127842 :     READ_BOOL_FIELD(hashable);
     353             : 
     354      127842 :     READ_DONE();
     355             : }
     356             : 
     357             : /*
     358             :  * _readGroupingSet
     359             :  */
     360             : static GroupingSet *
     361        1298 : _readGroupingSet(void)
     362             : {
     363        1298 :     READ_LOCALS(GroupingSet);
     364             : 
     365        1298 :     READ_ENUM_FIELD(kind, GroupingSetKind);
     366        1298 :     READ_NODE_FIELD(content);
     367        1298 :     READ_LOCATION_FIELD(location);
     368             : 
     369        1298 :     READ_DONE();
     370             : }
     371             : 
     372             : /*
     373             :  * _readWindowClause
     374             :  */
     375             : static WindowClause *
     376        1732 : _readWindowClause(void)
     377             : {
     378        1732 :     READ_LOCALS(WindowClause);
     379             : 
     380        1732 :     READ_STRING_FIELD(name);
     381        1732 :     READ_STRING_FIELD(refname);
     382        1732 :     READ_NODE_FIELD(partitionClause);
     383        1732 :     READ_NODE_FIELD(orderClause);
     384        1732 :     READ_INT_FIELD(frameOptions);
     385        1732 :     READ_NODE_FIELD(startOffset);
     386        1732 :     READ_NODE_FIELD(endOffset);
     387        1732 :     READ_OID_FIELD(startInRangeFunc);
     388        1732 :     READ_OID_FIELD(endInRangeFunc);
     389        1732 :     READ_OID_FIELD(inRangeColl);
     390        1732 :     READ_BOOL_FIELD(inRangeAsc);
     391        1732 :     READ_BOOL_FIELD(inRangeNullsFirst);
     392        1732 :     READ_UINT_FIELD(winref);
     393        1732 :     READ_BOOL_FIELD(copiedOrder);
     394             : 
     395        1732 :     READ_DONE();
     396             : }
     397             : 
     398             : /*
     399             :  * _readRowMarkClause
     400             :  */
     401             : static RowMarkClause *
     402        3468 : _readRowMarkClause(void)
     403             : {
     404        3468 :     READ_LOCALS(RowMarkClause);
     405             : 
     406        3468 :     READ_UINT_FIELD(rti);
     407        3468 :     READ_ENUM_FIELD(strength, LockClauseStrength);
     408        3468 :     READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
     409        3468 :     READ_BOOL_FIELD(pushedDown);
     410             : 
     411        3468 :     READ_DONE();
     412             : }
     413             : 
     414             : /*
     415             :  * _readCTESearchClause
     416             :  */
     417             : static CTESearchClause *
     418          40 : _readCTESearchClause(void)
     419             : {
     420          40 :     READ_LOCALS(CTESearchClause);
     421             : 
     422          40 :     READ_NODE_FIELD(search_col_list);
     423          40 :     READ_BOOL_FIELD(search_breadth_first);
     424          40 :     READ_STRING_FIELD(search_seq_column);
     425          40 :     READ_LOCATION_FIELD(location);
     426             : 
     427          40 :     READ_DONE();
     428             : }
     429             : 
     430             : /*
     431             :  * _readCTECycleClause
     432             :  */
     433             : static CTECycleClause *
     434          56 : _readCTECycleClause(void)
     435             : {
     436          56 :     READ_LOCALS(CTECycleClause);
     437             : 
     438          56 :     READ_NODE_FIELD(cycle_col_list);
     439          56 :     READ_STRING_FIELD(cycle_mark_column);
     440          56 :     READ_NODE_FIELD(cycle_mark_value);
     441          56 :     READ_NODE_FIELD(cycle_mark_default);
     442          56 :     READ_STRING_FIELD(cycle_path_column);
     443          56 :     READ_LOCATION_FIELD(location);
     444          56 :     READ_OID_FIELD(cycle_mark_type);
     445          56 :     READ_INT_FIELD(cycle_mark_typmod);
     446          56 :     READ_OID_FIELD(cycle_mark_collation);
     447          56 :     READ_OID_FIELD(cycle_mark_neop);
     448             : 
     449          56 :     READ_DONE();
     450             : }
     451             : 
     452             : /*
     453             :  * _readCommonTableExpr
     454             :  */
     455             : static CommonTableExpr *
     456        2400 : _readCommonTableExpr(void)
     457             : {
     458        2400 :     READ_LOCALS(CommonTableExpr);
     459             : 
     460        2400 :     READ_STRING_FIELD(ctename);
     461        2400 :     READ_NODE_FIELD(aliascolnames);
     462        2400 :     READ_ENUM_FIELD(ctematerialized, CTEMaterialize);
     463        2400 :     READ_NODE_FIELD(ctequery);
     464        2400 :     READ_NODE_FIELD(search_clause);
     465        2400 :     READ_NODE_FIELD(cycle_clause);
     466        2400 :     READ_LOCATION_FIELD(location);
     467        2400 :     READ_BOOL_FIELD(cterecursive);
     468        2400 :     READ_INT_FIELD(cterefcount);
     469        2400 :     READ_NODE_FIELD(ctecolnames);
     470        2400 :     READ_NODE_FIELD(ctecoltypes);
     471        2400 :     READ_NODE_FIELD(ctecoltypmods);
     472        2400 :     READ_NODE_FIELD(ctecolcollations);
     473             : 
     474        2400 :     READ_DONE();
     475             : }
     476             : 
     477             : /*
     478             :  * _readSetOperationStmt
     479             :  */
     480             : static SetOperationStmt *
     481       33842 : _readSetOperationStmt(void)
     482             : {
     483       33842 :     READ_LOCALS(SetOperationStmt);
     484             : 
     485       33842 :     READ_ENUM_FIELD(op, SetOperation);
     486       33842 :     READ_BOOL_FIELD(all);
     487       33842 :     READ_NODE_FIELD(larg);
     488       33842 :     READ_NODE_FIELD(rarg);
     489       33842 :     READ_NODE_FIELD(colTypes);
     490       33842 :     READ_NODE_FIELD(colTypmods);
     491       33842 :     READ_NODE_FIELD(colCollations);
     492       33842 :     READ_NODE_FIELD(groupClauses);
     493             : 
     494       33842 :     READ_DONE();
     495             : }
     496             : 
     497             : 
     498             : /*
     499             :  *  Stuff from primnodes.h.
     500             :  */
     501             : 
     502             : static Alias *
     503     2536322 : _readAlias(void)
     504             : {
     505     2536322 :     READ_LOCALS(Alias);
     506             : 
     507     2536322 :     READ_STRING_FIELD(aliasname);
     508     2536322 :     READ_NODE_FIELD(colnames);
     509             : 
     510     2536322 :     READ_DONE();
     511             : }
     512             : 
     513             : static RangeVar *
     514           0 : _readRangeVar(void)
     515             : {
     516           0 :     READ_LOCALS(RangeVar);
     517             : 
     518           0 :     local_node->catalogname = NULL; /* not currently saved in output format */
     519             : 
     520           0 :     READ_STRING_FIELD(schemaname);
     521           0 :     READ_STRING_FIELD(relname);
     522           0 :     READ_BOOL_FIELD(inh);
     523           0 :     READ_CHAR_FIELD(relpersistence);
     524           0 :     READ_NODE_FIELD(alias);
     525           0 :     READ_LOCATION_FIELD(location);
     526             : 
     527           0 :     READ_DONE();
     528             : }
     529             : 
     530             : /*
     531             :  * _readTableFunc
     532             :  */
     533             : static TableFunc *
     534         316 : _readTableFunc(void)
     535             : {
     536         316 :     READ_LOCALS(TableFunc);
     537             : 
     538         316 :     READ_NODE_FIELD(ns_uris);
     539         316 :     READ_NODE_FIELD(ns_names);
     540         316 :     READ_NODE_FIELD(docexpr);
     541         316 :     READ_NODE_FIELD(rowexpr);
     542         316 :     READ_NODE_FIELD(colnames);
     543         316 :     READ_NODE_FIELD(coltypes);
     544         316 :     READ_NODE_FIELD(coltypmods);
     545         316 :     READ_NODE_FIELD(colcollations);
     546         316 :     READ_NODE_FIELD(colexprs);
     547         316 :     READ_NODE_FIELD(coldefexprs);
     548         316 :     READ_BITMAPSET_FIELD(notnulls);
     549         316 :     READ_INT_FIELD(ordinalitycol);
     550         316 :     READ_LOCATION_FIELD(location);
     551             : 
     552         316 :     READ_DONE();
     553             : }
     554             : 
     555             : static IntoClause *
     556           0 : _readIntoClause(void)
     557             : {
     558           0 :     READ_LOCALS(IntoClause);
     559             : 
     560           0 :     READ_NODE_FIELD(rel);
     561           0 :     READ_NODE_FIELD(colNames);
     562           0 :     READ_STRING_FIELD(accessMethod);
     563           0 :     READ_NODE_FIELD(options);
     564           0 :     READ_ENUM_FIELD(onCommit, OnCommitAction);
     565           0 :     READ_STRING_FIELD(tableSpaceName);
     566           0 :     READ_NODE_FIELD(viewQuery);
     567           0 :     READ_BOOL_FIELD(skipData);
     568             : 
     569           0 :     READ_DONE();
     570             : }
     571             : 
     572             : /*
     573             :  * _readVar
     574             :  */
     575             : static Var *
     576    12216556 : _readVar(void)
     577             : {
     578    12216556 :     READ_LOCALS(Var);
     579             : 
     580    12216556 :     READ_INT_FIELD(varno);
     581    12216556 :     READ_INT_FIELD(varattno);
     582    12216556 :     READ_OID_FIELD(vartype);
     583    12216556 :     READ_INT_FIELD(vartypmod);
     584    12216556 :     READ_OID_FIELD(varcollid);
     585    12216556 :     READ_UINT_FIELD(varlevelsup);
     586    12216556 :     READ_UINT_FIELD(varnosyn);
     587    12216556 :     READ_INT_FIELD(varattnosyn);
     588    12216556 :     READ_LOCATION_FIELD(location);
     589             : 
     590    12216556 :     READ_DONE();
     591             : }
     592             : 
     593             : /*
     594             :  * _readConst
     595             :  */
     596             : static Const *
     597     2764916 : _readConst(void)
     598             : {
     599     2764916 :     READ_LOCALS(Const);
     600             : 
     601     2764916 :     READ_OID_FIELD(consttype);
     602     2764916 :     READ_INT_FIELD(consttypmod);
     603     2764916 :     READ_OID_FIELD(constcollid);
     604     2764916 :     READ_INT_FIELD(constlen);
     605     2764916 :     READ_BOOL_FIELD(constbyval);
     606     2764916 :     READ_BOOL_FIELD(constisnull);
     607     2764916 :     READ_LOCATION_FIELD(location);
     608             : 
     609     2764916 :     token = pg_strtok(&length); /* skip :constvalue */
     610     2764916 :     if (local_node->constisnull)
     611      335346 :         token = pg_strtok(&length); /* skip "<>" */
     612             :     else
     613     2429570 :         local_node->constvalue = readDatum(local_node->constbyval);
     614             : 
     615     2764916 :     READ_DONE();
     616             : }
     617             : 
     618             : /*
     619             :  * _readParam
     620             :  */
     621             : static Param *
     622      463456 : _readParam(void)
     623             : {
     624      463456 :     READ_LOCALS(Param);
     625             : 
     626      463456 :     READ_ENUM_FIELD(paramkind, ParamKind);
     627      463456 :     READ_INT_FIELD(paramid);
     628      463456 :     READ_OID_FIELD(paramtype);
     629      463456 :     READ_INT_FIELD(paramtypmod);
     630      463456 :     READ_OID_FIELD(paramcollid);
     631      463456 :     READ_LOCATION_FIELD(location);
     632             : 
     633      463456 :     READ_DONE();
     634             : }
     635             : 
     636             : /*
     637             :  * _readAggref
     638             :  */
     639             : static Aggref *
     640       50910 : _readAggref(void)
     641             : {
     642       50910 :     READ_LOCALS(Aggref);
     643             : 
     644       50910 :     READ_OID_FIELD(aggfnoid);
     645       50910 :     READ_OID_FIELD(aggtype);
     646       50910 :     READ_OID_FIELD(aggcollid);
     647       50910 :     READ_OID_FIELD(inputcollid);
     648       50910 :     READ_OID_FIELD(aggtranstype);
     649       50910 :     READ_NODE_FIELD(aggargtypes);
     650       50910 :     READ_NODE_FIELD(aggdirectargs);
     651       50910 :     READ_NODE_FIELD(args);
     652       50910 :     READ_NODE_FIELD(aggorder);
     653       50910 :     READ_NODE_FIELD(aggdistinct);
     654       50910 :     READ_NODE_FIELD(aggfilter);
     655       50910 :     READ_BOOL_FIELD(aggstar);
     656       50910 :     READ_BOOL_FIELD(aggvariadic);
     657       50910 :     READ_CHAR_FIELD(aggkind);
     658       50910 :     READ_UINT_FIELD(agglevelsup);
     659       50910 :     READ_ENUM_FIELD(aggsplit, AggSplit);
     660       50910 :     READ_INT_FIELD(aggno);
     661       50910 :     READ_INT_FIELD(aggtransno);
     662       50910 :     READ_LOCATION_FIELD(location);
     663             : 
     664       50910 :     READ_DONE();
     665             : }
     666             : 
     667             : /*
     668             :  * _readGroupingFunc
     669             :  */
     670             : static GroupingFunc *
     671         330 : _readGroupingFunc(void)
     672             : {
     673         330 :     READ_LOCALS(GroupingFunc);
     674             : 
     675         330 :     READ_NODE_FIELD(args);
     676         330 :     READ_NODE_FIELD(refs);
     677         330 :     READ_NODE_FIELD(cols);
     678         330 :     READ_UINT_FIELD(agglevelsup);
     679         330 :     READ_LOCATION_FIELD(location);
     680             : 
     681         330 :     READ_DONE();
     682             : }
     683             : 
     684             : /*
     685             :  * _readWindowFunc
     686             :  */
     687             : static WindowFunc *
     688        3504 : _readWindowFunc(void)
     689             : {
     690        3504 :     READ_LOCALS(WindowFunc);
     691             : 
     692        3504 :     READ_OID_FIELD(winfnoid);
     693        3504 :     READ_OID_FIELD(wintype);
     694        3504 :     READ_OID_FIELD(wincollid);
     695        3504 :     READ_OID_FIELD(inputcollid);
     696        3504 :     READ_NODE_FIELD(args);
     697        3504 :     READ_NODE_FIELD(aggfilter);
     698        3504 :     READ_UINT_FIELD(winref);
     699        3504 :     READ_BOOL_FIELD(winstar);
     700        3504 :     READ_BOOL_FIELD(winagg);
     701        3504 :     READ_LOCATION_FIELD(location);
     702             : 
     703        3504 :     READ_DONE();
     704             : }
     705             : 
     706             : /*
     707             :  * _readSubscriptingRef
     708             :  */
     709             : static SubscriptingRef *
     710       18494 : _readSubscriptingRef(void)
     711             : {
     712       18494 :     READ_LOCALS(SubscriptingRef);
     713             : 
     714       18494 :     READ_OID_FIELD(refcontainertype);
     715       18494 :     READ_OID_FIELD(refelemtype);
     716       18494 :     READ_OID_FIELD(refrestype);
     717       18494 :     READ_INT_FIELD(reftypmod);
     718       18494 :     READ_OID_FIELD(refcollid);
     719       18494 :     READ_NODE_FIELD(refupperindexpr);
     720       18494 :     READ_NODE_FIELD(reflowerindexpr);
     721       18494 :     READ_NODE_FIELD(refexpr);
     722       18494 :     READ_NODE_FIELD(refassgnexpr);
     723             : 
     724       18494 :     READ_DONE();
     725             : }
     726             : 
     727             : /*
     728             :  * _readFuncExpr
     729             :  */
     730             : static FuncExpr *
     731     1075182 : _readFuncExpr(void)
     732             : {
     733     1075182 :     READ_LOCALS(FuncExpr);
     734             : 
     735     1075182 :     READ_OID_FIELD(funcid);
     736     1075182 :     READ_OID_FIELD(funcresulttype);
     737     1075182 :     READ_BOOL_FIELD(funcretset);
     738     1075182 :     READ_BOOL_FIELD(funcvariadic);
     739     1075182 :     READ_ENUM_FIELD(funcformat, CoercionForm);
     740     1075182 :     READ_OID_FIELD(funccollid);
     741     1075182 :     READ_OID_FIELD(inputcollid);
     742     1075182 :     READ_NODE_FIELD(args);
     743     1075182 :     READ_LOCATION_FIELD(location);
     744             : 
     745     1075182 :     READ_DONE();
     746             : }
     747             : 
     748             : /*
     749             :  * _readNamedArgExpr
     750             :  */
     751             : static NamedArgExpr *
     752       35564 : _readNamedArgExpr(void)
     753             : {
     754       35564 :     READ_LOCALS(NamedArgExpr);
     755             : 
     756       35564 :     READ_NODE_FIELD(arg);
     757       35564 :     READ_STRING_FIELD(name);
     758       35564 :     READ_INT_FIELD(argnumber);
     759       35564 :     READ_LOCATION_FIELD(location);
     760             : 
     761       35564 :     READ_DONE();
     762             : }
     763             : 
     764             : /*
     765             :  * _readOpExpr
     766             :  */
     767             : static OpExpr *
     768     1240326 : _readOpExpr(void)
     769             : {
     770     1240326 :     READ_LOCALS(OpExpr);
     771             : 
     772     1240326 :     READ_OID_FIELD(opno);
     773     1240326 :     READ_OID_FIELD(opfuncid);
     774     1240326 :     READ_OID_FIELD(opresulttype);
     775     1240326 :     READ_BOOL_FIELD(opretset);
     776     1240326 :     READ_OID_FIELD(opcollid);
     777     1240326 :     READ_OID_FIELD(inputcollid);
     778     1240326 :     READ_NODE_FIELD(args);
     779     1240326 :     READ_LOCATION_FIELD(location);
     780             : 
     781     1240326 :     READ_DONE();
     782             : }
     783             : 
     784             : /*
     785             :  * _readDistinctExpr
     786             :  */
     787             : static DistinctExpr *
     788        1030 : _readDistinctExpr(void)
     789             : {
     790        1030 :     READ_LOCALS(DistinctExpr);
     791             : 
     792        1030 :     READ_OID_FIELD(opno);
     793        1030 :     READ_OID_FIELD(opfuncid);
     794        1030 :     READ_OID_FIELD(opresulttype);
     795        1030 :     READ_BOOL_FIELD(opretset);
     796        1030 :     READ_OID_FIELD(opcollid);
     797        1030 :     READ_OID_FIELD(inputcollid);
     798        1030 :     READ_NODE_FIELD(args);
     799        1030 :     READ_LOCATION_FIELD(location);
     800             : 
     801        1030 :     READ_DONE();
     802             : }
     803             : 
     804             : /*
     805             :  * _readNullIfExpr
     806             :  */
     807             : static NullIfExpr *
     808        1360 : _readNullIfExpr(void)
     809             : {
     810        1360 :     READ_LOCALS(NullIfExpr);
     811             : 
     812        1360 :     READ_OID_FIELD(opno);
     813        1360 :     READ_OID_FIELD(opfuncid);
     814        1360 :     READ_OID_FIELD(opresulttype);
     815        1360 :     READ_BOOL_FIELD(opretset);
     816        1360 :     READ_OID_FIELD(opcollid);
     817        1360 :     READ_OID_FIELD(inputcollid);
     818        1360 :     READ_NODE_FIELD(args);
     819        1360 :     READ_LOCATION_FIELD(location);
     820             : 
     821        1360 :     READ_DONE();
     822             : }
     823             : 
     824             : /*
     825             :  * _readScalarArrayOpExpr
     826             :  */
     827             : static ScalarArrayOpExpr *
     828       72610 : _readScalarArrayOpExpr(void)
     829             : {
     830       72610 :     READ_LOCALS(ScalarArrayOpExpr);
     831             : 
     832       72610 :     READ_OID_FIELD(opno);
     833       72610 :     READ_OID_FIELD(opfuncid);
     834       72610 :     READ_OID_FIELD(hashfuncid);
     835       72610 :     READ_OID_FIELD(negfuncid);
     836       72610 :     READ_BOOL_FIELD(useOr);
     837       72610 :     READ_OID_FIELD(inputcollid);
     838       72610 :     READ_NODE_FIELD(args);
     839       72610 :     READ_LOCATION_FIELD(location);
     840             : 
     841       72610 :     READ_DONE();
     842             : }
     843             : 
     844             : /*
     845             :  * _readBoolExpr
     846             :  */
     847             : static BoolExpr *
     848      245016 : _readBoolExpr(void)
     849             : {
     850      245016 :     READ_LOCALS(BoolExpr);
     851             : 
     852             :     /* do-it-yourself enum representation */
     853      245016 :     token = pg_strtok(&length); /* skip :boolop */
     854      245016 :     token = pg_strtok(&length); /* get field value */
     855      245016 :     if (strncmp(token, "and", 3) == 0)
     856      159874 :         local_node->boolop = AND_EXPR;
     857       85142 :     else if (strncmp(token, "or", 2) == 0)
     858       55044 :         local_node->boolop = OR_EXPR;
     859       30098 :     else if (strncmp(token, "not", 3) == 0)
     860       30098 :         local_node->boolop = NOT_EXPR;
     861             :     else
     862           0 :         elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
     863             : 
     864      245016 :     READ_NODE_FIELD(args);
     865      245016 :     READ_LOCATION_FIELD(location);
     866             : 
     867      245016 :     READ_DONE();
     868             : }
     869             : 
     870             : /*
     871             :  * _readSubLink
     872             :  */
     873             : static SubLink *
     874       50110 : _readSubLink(void)
     875             : {
     876       50110 :     READ_LOCALS(SubLink);
     877             : 
     878       50110 :     READ_ENUM_FIELD(subLinkType, SubLinkType);
     879       50110 :     READ_INT_FIELD(subLinkId);
     880       50110 :     READ_NODE_FIELD(testexpr);
     881       50110 :     READ_NODE_FIELD(operName);
     882       50110 :     READ_NODE_FIELD(subselect);
     883       50110 :     READ_LOCATION_FIELD(location);
     884             : 
     885       50110 :     READ_DONE();
     886             : }
     887             : 
     888             : /*
     889             :  * _readSubPlan is not needed since it doesn't appear in stored rules.
     890             :  */
     891             : 
     892             : /*
     893             :  * _readFieldSelect
     894             :  */
     895             : static FieldSelect *
     896       98400 : _readFieldSelect(void)
     897             : {
     898       98400 :     READ_LOCALS(FieldSelect);
     899             : 
     900       98400 :     READ_NODE_FIELD(arg);
     901       98400 :     READ_INT_FIELD(fieldnum);
     902       98400 :     READ_OID_FIELD(resulttype);
     903       98400 :     READ_INT_FIELD(resulttypmod);
     904       98400 :     READ_OID_FIELD(resultcollid);
     905             : 
     906       98400 :     READ_DONE();
     907             : }
     908             : 
     909             : /*
     910             :  * _readFieldStore
     911             :  */
     912             : static FieldStore *
     913         480 : _readFieldStore(void)
     914             : {
     915         480 :     READ_LOCALS(FieldStore);
     916             : 
     917         480 :     READ_NODE_FIELD(arg);
     918         480 :     READ_NODE_FIELD(newvals);
     919         480 :     READ_NODE_FIELD(fieldnums);
     920         480 :     READ_OID_FIELD(resulttype);
     921             : 
     922         480 :     READ_DONE();
     923             : }
     924             : 
     925             : /*
     926             :  * _readRelabelType
     927             :  */
     928             : static RelabelType *
     929      218010 : _readRelabelType(void)
     930             : {
     931      218010 :     READ_LOCALS(RelabelType);
     932             : 
     933      218010 :     READ_NODE_FIELD(arg);
     934      218010 :     READ_OID_FIELD(resulttype);
     935      218010 :     READ_INT_FIELD(resulttypmod);
     936      218010 :     READ_OID_FIELD(resultcollid);
     937      218010 :     READ_ENUM_FIELD(relabelformat, CoercionForm);
     938      218010 :     READ_LOCATION_FIELD(location);
     939             : 
     940      218010 :     READ_DONE();
     941             : }
     942             : 
     943             : /*
     944             :  * _readCoerceViaIO
     945             :  */
     946             : static CoerceViaIO *
     947       37764 : _readCoerceViaIO(void)
     948             : {
     949       37764 :     READ_LOCALS(CoerceViaIO);
     950             : 
     951       37764 :     READ_NODE_FIELD(arg);
     952       37764 :     READ_OID_FIELD(resulttype);
     953       37764 :     READ_OID_FIELD(resultcollid);
     954       37764 :     READ_ENUM_FIELD(coerceformat, CoercionForm);
     955       37764 :     READ_LOCATION_FIELD(location);
     956             : 
     957       37764 :     READ_DONE();
     958             : }
     959             : 
     960             : /*
     961             :  * _readArrayCoerceExpr
     962             :  */
     963             : static ArrayCoerceExpr *
     964        3488 : _readArrayCoerceExpr(void)
     965             : {
     966        3488 :     READ_LOCALS(ArrayCoerceExpr);
     967             : 
     968        3488 :     READ_NODE_FIELD(arg);
     969        3488 :     READ_NODE_FIELD(elemexpr);
     970        3488 :     READ_OID_FIELD(resulttype);
     971        3488 :     READ_INT_FIELD(resulttypmod);
     972        3488 :     READ_OID_FIELD(resultcollid);
     973        3488 :     READ_ENUM_FIELD(coerceformat, CoercionForm);
     974        3488 :     READ_LOCATION_FIELD(location);
     975             : 
     976        3488 :     READ_DONE();
     977             : }
     978             : 
     979             : /*
     980             :  * _readConvertRowtypeExpr
     981             :  */
     982             : static ConvertRowtypeExpr *
     983         446 : _readConvertRowtypeExpr(void)
     984             : {
     985         446 :     READ_LOCALS(ConvertRowtypeExpr);
     986             : 
     987         446 :     READ_NODE_FIELD(arg);
     988         446 :     READ_OID_FIELD(resulttype);
     989         446 :     READ_ENUM_FIELD(convertformat, CoercionForm);
     990         446 :     READ_LOCATION_FIELD(location);
     991             : 
     992         446 :     READ_DONE();
     993             : }
     994             : 
     995             : /*
     996             :  * _readCollateExpr
     997             :  */
     998             : static CollateExpr *
     999        3330 : _readCollateExpr(void)
    1000             : {
    1001        3330 :     READ_LOCALS(CollateExpr);
    1002             : 
    1003        3330 :     READ_NODE_FIELD(arg);
    1004        3330 :     READ_OID_FIELD(collOid);
    1005        3330 :     READ_LOCATION_FIELD(location);
    1006             : 
    1007        3330 :     READ_DONE();
    1008             : }
    1009             : 
    1010             : /*
    1011             :  * _readCaseExpr
    1012             :  */
    1013             : static CaseExpr *
    1014      118950 : _readCaseExpr(void)
    1015             : {
    1016      118950 :     READ_LOCALS(CaseExpr);
    1017             : 
    1018      118950 :     READ_OID_FIELD(casetype);
    1019      118950 :     READ_OID_FIELD(casecollid);
    1020      118950 :     READ_NODE_FIELD(arg);
    1021      118950 :     READ_NODE_FIELD(args);
    1022      118950 :     READ_NODE_FIELD(defresult);
    1023      118950 :     READ_LOCATION_FIELD(location);
    1024             : 
    1025      118950 :     READ_DONE();
    1026             : }
    1027             : 
    1028             : /*
    1029             :  * _readCaseWhen
    1030             :  */
    1031             : static CaseWhen *
    1032      221344 : _readCaseWhen(void)
    1033             : {
    1034      221344 :     READ_LOCALS(CaseWhen);
    1035             : 
    1036      221344 :     READ_NODE_FIELD(expr);
    1037      221344 :     READ_NODE_FIELD(result);
    1038      221344 :     READ_LOCATION_FIELD(location);
    1039             : 
    1040      221344 :     READ_DONE();
    1041             : }
    1042             : 
    1043             : /*
    1044             :  * _readCaseTestExpr
    1045             :  */
    1046             : static CaseTestExpr *
    1047       66764 : _readCaseTestExpr(void)
    1048             : {
    1049       66764 :     READ_LOCALS(CaseTestExpr);
    1050             : 
    1051       66764 :     READ_OID_FIELD(typeId);
    1052       66764 :     READ_INT_FIELD(typeMod);
    1053       66764 :     READ_OID_FIELD(collation);
    1054             : 
    1055       66764 :     READ_DONE();
    1056             : }
    1057             : 
    1058             : /*
    1059             :  * _readArrayExpr
    1060             :  */
    1061             : static ArrayExpr *
    1062       54662 : _readArrayExpr(void)
    1063             : {
    1064       54662 :     READ_LOCALS(ArrayExpr);
    1065             : 
    1066       54662 :     READ_OID_FIELD(array_typeid);
    1067       54662 :     READ_OID_FIELD(array_collid);
    1068       54662 :     READ_OID_FIELD(element_typeid);
    1069       54662 :     READ_NODE_FIELD(elements);
    1070       54662 :     READ_BOOL_FIELD(multidims);
    1071       54662 :     READ_LOCATION_FIELD(location);
    1072             : 
    1073       54662 :     READ_DONE();
    1074             : }
    1075             : 
    1076             : /*
    1077             :  * _readRowExpr
    1078             :  */
    1079             : static RowExpr *
    1080        3628 : _readRowExpr(void)
    1081             : {
    1082        3628 :     READ_LOCALS(RowExpr);
    1083             : 
    1084        3628 :     READ_NODE_FIELD(args);
    1085        3628 :     READ_OID_FIELD(row_typeid);
    1086        3628 :     READ_ENUM_FIELD(row_format, CoercionForm);
    1087        3628 :     READ_NODE_FIELD(colnames);
    1088        3628 :     READ_LOCATION_FIELD(location);
    1089             : 
    1090        3628 :     READ_DONE();
    1091             : }
    1092             : 
    1093             : /*
    1094             :  * _readRowCompareExpr
    1095             :  */
    1096             : static RowCompareExpr *
    1097         232 : _readRowCompareExpr(void)
    1098             : {
    1099         232 :     READ_LOCALS(RowCompareExpr);
    1100             : 
    1101         232 :     READ_ENUM_FIELD(rctype, RowCompareType);
    1102         232 :     READ_NODE_FIELD(opnos);
    1103         232 :     READ_NODE_FIELD(opfamilies);
    1104         232 :     READ_NODE_FIELD(inputcollids);
    1105         232 :     READ_NODE_FIELD(largs);
    1106         232 :     READ_NODE_FIELD(rargs);
    1107             : 
    1108         232 :     READ_DONE();
    1109             : }
    1110             : 
    1111             : /*
    1112             :  * _readCoalesceExpr
    1113             :  */
    1114             : static CoalesceExpr *
    1115       44296 : _readCoalesceExpr(void)
    1116             : {
    1117       44296 :     READ_LOCALS(CoalesceExpr);
    1118             : 
    1119       44296 :     READ_OID_FIELD(coalescetype);
    1120       44296 :     READ_OID_FIELD(coalescecollid);
    1121       44296 :     READ_NODE_FIELD(args);
    1122       44296 :     READ_LOCATION_FIELD(location);
    1123             : 
    1124       44296 :     READ_DONE();
    1125             : }
    1126             : 
    1127             : /*
    1128             :  * _readMinMaxExpr
    1129             :  */
    1130             : static MinMaxExpr *
    1131         244 : _readMinMaxExpr(void)
    1132             : {
    1133         244 :     READ_LOCALS(MinMaxExpr);
    1134             : 
    1135         244 :     READ_OID_FIELD(minmaxtype);
    1136         244 :     READ_OID_FIELD(minmaxcollid);
    1137         244 :     READ_OID_FIELD(inputcollid);
    1138         244 :     READ_ENUM_FIELD(op, MinMaxOp);
    1139         244 :     READ_NODE_FIELD(args);
    1140         244 :     READ_LOCATION_FIELD(location);
    1141             : 
    1142         244 :     READ_DONE();
    1143             : }
    1144             : 
    1145             : /*
    1146             :  * _readSQLValueFunction
    1147             :  */
    1148             : static SQLValueFunction *
    1149        8220 : _readSQLValueFunction(void)
    1150             : {
    1151        8220 :     READ_LOCALS(SQLValueFunction);
    1152             : 
    1153        8220 :     READ_ENUM_FIELD(op, SQLValueFunctionOp);
    1154        8220 :     READ_OID_FIELD(type);
    1155        8220 :     READ_INT_FIELD(typmod);
    1156        8220 :     READ_LOCATION_FIELD(location);
    1157             : 
    1158        8220 :     READ_DONE();
    1159             : }
    1160             : 
    1161             : /*
    1162             :  * _readXmlExpr
    1163             :  */
    1164             : static XmlExpr *
    1165         952 : _readXmlExpr(void)
    1166             : {
    1167         952 :     READ_LOCALS(XmlExpr);
    1168             : 
    1169         952 :     READ_ENUM_FIELD(op, XmlExprOp);
    1170         952 :     READ_STRING_FIELD(name);
    1171         952 :     READ_NODE_FIELD(named_args);
    1172         952 :     READ_NODE_FIELD(arg_names);
    1173         952 :     READ_NODE_FIELD(args);
    1174         952 :     READ_ENUM_FIELD(xmloption, XmlOptionType);
    1175         952 :     READ_OID_FIELD(type);
    1176         952 :     READ_INT_FIELD(typmod);
    1177         952 :     READ_LOCATION_FIELD(location);
    1178             : 
    1179         952 :     READ_DONE();
    1180             : }
    1181             : 
    1182             : /*
    1183             :  * _readNullTest
    1184             :  */
    1185             : static NullTest *
    1186       34644 : _readNullTest(void)
    1187             : {
    1188       34644 :     READ_LOCALS(NullTest);
    1189             : 
    1190       34644 :     READ_NODE_FIELD(arg);
    1191       34644 :     READ_ENUM_FIELD(nulltesttype, NullTestType);
    1192       34644 :     READ_BOOL_FIELD(argisrow);
    1193       34644 :     READ_LOCATION_FIELD(location);
    1194             : 
    1195       34644 :     READ_DONE();
    1196             : }
    1197             : 
    1198             : /*
    1199             :  * _readBooleanTest
    1200             :  */
    1201             : static BooleanTest *
    1202         524 : _readBooleanTest(void)
    1203             : {
    1204         524 :     READ_LOCALS(BooleanTest);
    1205             : 
    1206         524 :     READ_NODE_FIELD(arg);
    1207         524 :     READ_ENUM_FIELD(booltesttype, BoolTestType);
    1208         524 :     READ_LOCATION_FIELD(location);
    1209             : 
    1210         524 :     READ_DONE();
    1211             : }
    1212             : 
    1213             : /*
    1214             :  * _readCoerceToDomain
    1215             :  */
    1216             : static CoerceToDomain *
    1217      613242 : _readCoerceToDomain(void)
    1218             : {
    1219      613242 :     READ_LOCALS(CoerceToDomain);
    1220             : 
    1221      613242 :     READ_NODE_FIELD(arg);
    1222      613242 :     READ_OID_FIELD(resulttype);
    1223      613242 :     READ_INT_FIELD(resulttypmod);
    1224      613242 :     READ_OID_FIELD(resultcollid);
    1225      613242 :     READ_ENUM_FIELD(coercionformat, CoercionForm);
    1226      613242 :     READ_LOCATION_FIELD(location);
    1227             : 
    1228      613242 :     READ_DONE();
    1229             : }
    1230             : 
    1231             : /*
    1232             :  * _readCoerceToDomainValue
    1233             :  */
    1234             : static CoerceToDomainValue *
    1235        1816 : _readCoerceToDomainValue(void)
    1236             : {
    1237        1816 :     READ_LOCALS(CoerceToDomainValue);
    1238             : 
    1239        1816 :     READ_OID_FIELD(typeId);
    1240        1816 :     READ_INT_FIELD(typeMod);
    1241        1816 :     READ_OID_FIELD(collation);
    1242        1816 :     READ_LOCATION_FIELD(location);
    1243             : 
    1244        1816 :     READ_DONE();
    1245             : }
    1246             : 
    1247             : /*
    1248             :  * _readSetToDefault
    1249             :  */
    1250             : static SetToDefault *
    1251           0 : _readSetToDefault(void)
    1252             : {
    1253           0 :     READ_LOCALS(SetToDefault);
    1254             : 
    1255           0 :     READ_OID_FIELD(typeId);
    1256           0 :     READ_INT_FIELD(typeMod);
    1257           0 :     READ_OID_FIELD(collation);
    1258           0 :     READ_LOCATION_FIELD(location);
    1259             : 
    1260           0 :     READ_DONE();
    1261             : }
    1262             : 
    1263             : /*
    1264             :  * _readCurrentOfExpr
    1265             :  */
    1266             : static CurrentOfExpr *
    1267         414 : _readCurrentOfExpr(void)
    1268             : {
    1269         414 :     READ_LOCALS(CurrentOfExpr);
    1270             : 
    1271         414 :     READ_UINT_FIELD(cvarno);
    1272         414 :     READ_STRING_FIELD(cursor_name);
    1273         414 :     READ_INT_FIELD(cursor_param);
    1274             : 
    1275         414 :     READ_DONE();
    1276             : }
    1277             : 
    1278             : /*
    1279             :  * _readNextValueExpr
    1280             :  */
    1281             : static NextValueExpr *
    1282         404 : _readNextValueExpr(void)
    1283             : {
    1284         404 :     READ_LOCALS(NextValueExpr);
    1285             : 
    1286         404 :     READ_OID_FIELD(seqid);
    1287         404 :     READ_OID_FIELD(typeId);
    1288             : 
    1289         404 :     READ_DONE();
    1290             : }
    1291             : 
    1292             : /*
    1293             :  * _readInferenceElem
    1294             :  */
    1295             : static InferenceElem *
    1296         872 : _readInferenceElem(void)
    1297             : {
    1298         872 :     READ_LOCALS(InferenceElem);
    1299             : 
    1300         872 :     READ_NODE_FIELD(expr);
    1301         872 :     READ_OID_FIELD(infercollid);
    1302         872 :     READ_OID_FIELD(inferopclass);
    1303             : 
    1304         872 :     READ_DONE();
    1305             : }
    1306             : 
    1307             : /*
    1308             :  * _readTargetEntry
    1309             :  */
    1310             : static TargetEntry *
    1311     4915776 : _readTargetEntry(void)
    1312             : {
    1313     4915776 :     READ_LOCALS(TargetEntry);
    1314             : 
    1315     4915776 :     READ_NODE_FIELD(expr);
    1316     4915776 :     READ_INT_FIELD(resno);
    1317     4915776 :     READ_STRING_FIELD(resname);
    1318     4915776 :     READ_UINT_FIELD(ressortgroupref);
    1319     4915776 :     READ_OID_FIELD(resorigtbl);
    1320     4915776 :     READ_INT_FIELD(resorigcol);
    1321     4915776 :     READ_BOOL_FIELD(resjunk);
    1322             : 
    1323     4915776 :     READ_DONE();
    1324             : }
    1325             : 
    1326             : /*
    1327             :  * _readRangeTblRef
    1328             :  */
    1329             : static RangeTblRef *
    1330      657892 : _readRangeTblRef(void)
    1331             : {
    1332      657892 :     READ_LOCALS(RangeTblRef);
    1333             : 
    1334      657892 :     READ_INT_FIELD(rtindex);
    1335             : 
    1336      657892 :     READ_DONE();
    1337             : }
    1338             : 
    1339             : /*
    1340             :  * _readJoinExpr
    1341             :  */
    1342             : static JoinExpr *
    1343      136646 : _readJoinExpr(void)
    1344             : {
    1345      136646 :     READ_LOCALS(JoinExpr);
    1346             : 
    1347      136646 :     READ_ENUM_FIELD(jointype, JoinType);
    1348      136646 :     READ_BOOL_FIELD(isNatural);
    1349      136646 :     READ_NODE_FIELD(larg);
    1350      136646 :     READ_NODE_FIELD(rarg);
    1351      136646 :     READ_NODE_FIELD(usingClause);
    1352      136646 :     READ_NODE_FIELD(join_using_alias);
    1353      136646 :     READ_NODE_FIELD(quals);
    1354      136646 :     READ_NODE_FIELD(alias);
    1355      136646 :     READ_INT_FIELD(rtindex);
    1356             : 
    1357      136646 :     READ_DONE();
    1358             : }
    1359             : 
    1360             : /*
    1361             :  * _readFromExpr
    1362             :  */
    1363             : static FromExpr *
    1364      565250 : _readFromExpr(void)
    1365             : {
    1366      565250 :     READ_LOCALS(FromExpr);
    1367             : 
    1368      565250 :     READ_NODE_FIELD(fromlist);
    1369      565250 :     READ_NODE_FIELD(quals);
    1370             : 
    1371      565250 :     READ_DONE();
    1372             : }
    1373             : 
    1374             : /*
    1375             :  * _readOnConflictExpr
    1376             :  */
    1377             : static OnConflictExpr *
    1378         932 : _readOnConflictExpr(void)
    1379             : {
    1380         932 :     READ_LOCALS(OnConflictExpr);
    1381             : 
    1382         932 :     READ_ENUM_FIELD(action, OnConflictAction);
    1383         932 :     READ_NODE_FIELD(arbiterElems);
    1384         932 :     READ_NODE_FIELD(arbiterWhere);
    1385         932 :     READ_OID_FIELD(constraint);
    1386         932 :     READ_NODE_FIELD(onConflictSet);
    1387         932 :     READ_NODE_FIELD(onConflictWhere);
    1388         932 :     READ_INT_FIELD(exclRelIndex);
    1389         932 :     READ_NODE_FIELD(exclRelTlist);
    1390             : 
    1391         932 :     READ_DONE();
    1392             : }
    1393             : 
    1394             : /*
    1395             :  *  Stuff from pathnodes.h.
    1396             :  *
    1397             :  * Mostly we don't need to read planner nodes back in again, but some
    1398             :  * of these also end up in plan trees.
    1399             :  */
    1400             : 
    1401             : /*
    1402             :  * _readAppendRelInfo
    1403             :  */
    1404             : static AppendRelInfo *
    1405       26054 : _readAppendRelInfo(void)
    1406             : {
    1407       26054 :     READ_LOCALS(AppendRelInfo);
    1408             : 
    1409       26054 :     READ_UINT_FIELD(parent_relid);
    1410       26054 :     READ_UINT_FIELD(child_relid);
    1411       26054 :     READ_OID_FIELD(parent_reltype);
    1412       26054 :     READ_OID_FIELD(child_reltype);
    1413       26054 :     READ_NODE_FIELD(translated_vars);
    1414       26054 :     READ_INT_FIELD(num_child_cols);
    1415       26054 :     READ_ATTRNUMBER_ARRAY(parent_colnos, local_node->num_child_cols);
    1416       26054 :     READ_OID_FIELD(parent_reloid);
    1417             : 
    1418       26054 :     READ_DONE();
    1419             : }
    1420             : 
    1421             : /*
    1422             :  *  Stuff from parsenodes.h.
    1423             :  */
    1424             : 
    1425             : /*
    1426             :  * _readRangeTblEntry
    1427             :  */
    1428             : static RangeTblEntry *
    1429     1649486 : _readRangeTblEntry(void)
    1430             : {
    1431     1649486 :     READ_LOCALS(RangeTblEntry);
    1432             : 
    1433             :     /* put alias + eref first to make dump more legible */
    1434     1649486 :     READ_NODE_FIELD(alias);
    1435     1649486 :     READ_NODE_FIELD(eref);
    1436     1649486 :     READ_ENUM_FIELD(rtekind, RTEKind);
    1437             : 
    1438     1649486 :     switch (local_node->rtekind)
    1439             :     {
    1440     1098488 :         case RTE_RELATION:
    1441     1098488 :             READ_OID_FIELD(relid);
    1442     1098488 :             READ_CHAR_FIELD(relkind);
    1443     1098488 :             READ_INT_FIELD(rellockmode);
    1444     1098488 :             READ_NODE_FIELD(tablesample);
    1445     1098488 :             break;
    1446      144816 :         case RTE_SUBQUERY:
    1447      144816 :             READ_NODE_FIELD(subquery);
    1448      144816 :             READ_BOOL_FIELD(security_barrier);
    1449      144816 :             break;
    1450      177396 :         case RTE_JOIN:
    1451      177396 :             READ_ENUM_FIELD(jointype, JoinType);
    1452      177396 :             READ_INT_FIELD(joinmergedcols);
    1453      177396 :             READ_NODE_FIELD(joinaliasvars);
    1454      177396 :             READ_NODE_FIELD(joinleftcols);
    1455      177396 :             READ_NODE_FIELD(joinrightcols);
    1456      177396 :             READ_NODE_FIELD(join_using_alias);
    1457      177396 :             break;
    1458       75560 :         case RTE_FUNCTION:
    1459       75560 :             READ_NODE_FIELD(functions);
    1460       75560 :             READ_BOOL_FIELD(funcordinality);
    1461       75560 :             break;
    1462         316 :         case RTE_TABLEFUNC:
    1463         316 :             READ_NODE_FIELD(tablefunc);
    1464             :             /* The RTE must have a copy of the column type info, if any */
    1465         316 :             if (local_node->tablefunc)
    1466             :             {
    1467         172 :                 TableFunc  *tf = local_node->tablefunc;
    1468             : 
    1469         172 :                 local_node->coltypes = tf->coltypes;
    1470         172 :                 local_node->coltypmods = tf->coltypmods;
    1471         172 :                 local_node->colcollations = tf->colcollations;
    1472             :             }
    1473         316 :             break;
    1474       11062 :         case RTE_VALUES:
    1475       11062 :             READ_NODE_FIELD(values_lists);
    1476       11062 :             READ_NODE_FIELD(coltypes);
    1477       11062 :             READ_NODE_FIELD(coltypmods);
    1478       11062 :             READ_NODE_FIELD(colcollations);
    1479       11062 :             break;
    1480        5726 :         case RTE_CTE:
    1481        5726 :             READ_STRING_FIELD(ctename);
    1482        5726 :             READ_UINT_FIELD(ctelevelsup);
    1483        5726 :             READ_BOOL_FIELD(self_reference);
    1484        5726 :             READ_NODE_FIELD(coltypes);
    1485        5726 :             READ_NODE_FIELD(coltypmods);
    1486        5726 :             READ_NODE_FIELD(colcollations);
    1487        5726 :             break;
    1488         552 :         case RTE_NAMEDTUPLESTORE:
    1489         552 :             READ_STRING_FIELD(enrname);
    1490         552 :             READ_FLOAT_FIELD(enrtuples);
    1491         552 :             READ_OID_FIELD(relid);
    1492         552 :             READ_NODE_FIELD(coltypes);
    1493         552 :             READ_NODE_FIELD(coltypmods);
    1494         552 :             READ_NODE_FIELD(colcollations);
    1495         552 :             break;
    1496      135570 :         case RTE_RESULT:
    1497             :             /* no extra fields */
    1498      135570 :             break;
    1499           0 :         default:
    1500           0 :             elog(ERROR, "unrecognized RTE kind: %d",
    1501             :                  (int) local_node->rtekind);
    1502             :             break;
    1503             :     }
    1504             : 
    1505     1649486 :     READ_BOOL_FIELD(lateral);
    1506     1649486 :     READ_BOOL_FIELD(inh);
    1507     1649486 :     READ_BOOL_FIELD(inFromCl);
    1508     1649486 :     READ_UINT_FIELD(requiredPerms);
    1509     1649486 :     READ_OID_FIELD(checkAsUser);
    1510     1649486 :     READ_BITMAPSET_FIELD(selectedCols);
    1511     1649486 :     READ_BITMAPSET_FIELD(insertedCols);
    1512     1649486 :     READ_BITMAPSET_FIELD(updatedCols);
    1513     1649486 :     READ_BITMAPSET_FIELD(extraUpdatedCols);
    1514     1649486 :     READ_NODE_FIELD(securityQuals);
    1515             : 
    1516     1649486 :     READ_DONE();
    1517             : }
    1518             : 
    1519             : /*
    1520             :  * _readRangeTblFunction
    1521             :  */
    1522             : static RangeTblFunction *
    1523       76104 : _readRangeTblFunction(void)
    1524             : {
    1525       76104 :     READ_LOCALS(RangeTblFunction);
    1526             : 
    1527       76104 :     READ_NODE_FIELD(funcexpr);
    1528       76104 :     READ_INT_FIELD(funccolcount);
    1529       76104 :     READ_NODE_FIELD(funccolnames);
    1530       76104 :     READ_NODE_FIELD(funccoltypes);
    1531       76104 :     READ_NODE_FIELD(funccoltypmods);
    1532       76104 :     READ_NODE_FIELD(funccolcollations);
    1533       76104 :     READ_BITMAPSET_FIELD(funcparams);
    1534             : 
    1535       76104 :     READ_DONE();
    1536             : }
    1537             : 
    1538             : /*
    1539             :  * _readTableSampleClause
    1540             :  */
    1541             : static TableSampleClause *
    1542         376 : _readTableSampleClause(void)
    1543             : {
    1544         376 :     READ_LOCALS(TableSampleClause);
    1545             : 
    1546         376 :     READ_OID_FIELD(tsmhandler);
    1547         376 :     READ_NODE_FIELD(args);
    1548         376 :     READ_NODE_FIELD(repeatable);
    1549             : 
    1550         376 :     READ_DONE();
    1551             : }
    1552             : 
    1553             : /*
    1554             :  * _readDefElem
    1555             :  */
    1556             : static DefElem *
    1557           8 : _readDefElem(void)
    1558             : {
    1559           8 :     READ_LOCALS(DefElem);
    1560             : 
    1561           8 :     READ_STRING_FIELD(defnamespace);
    1562           8 :     READ_STRING_FIELD(defname);
    1563           8 :     READ_NODE_FIELD(arg);
    1564           8 :     READ_ENUM_FIELD(defaction, DefElemAction);
    1565           8 :     READ_LOCATION_FIELD(location);
    1566             : 
    1567           8 :     READ_DONE();
    1568             : }
    1569             : 
    1570             : /*
    1571             :  *  Stuff from plannodes.h.
    1572             :  */
    1573             : 
    1574             : /*
    1575             :  * _readPlannedStmt
    1576             :  */
    1577             : static PlannedStmt *
    1578      279834 : _readPlannedStmt(void)
    1579             : {
    1580      279834 :     READ_LOCALS(PlannedStmt);
    1581             : 
    1582      279834 :     READ_ENUM_FIELD(commandType, CmdType);
    1583      279834 :     READ_UINT64_FIELD(queryId);
    1584      279834 :     READ_BOOL_FIELD(hasReturning);
    1585      279834 :     READ_BOOL_FIELD(hasModifyingCTE);
    1586      279834 :     READ_BOOL_FIELD(canSetTag);
    1587      279834 :     READ_BOOL_FIELD(transientPlan);
    1588      279834 :     READ_BOOL_FIELD(dependsOnRole);
    1589      279834 :     READ_BOOL_FIELD(parallelModeNeeded);
    1590      279834 :     READ_INT_FIELD(jitFlags);
    1591      279834 :     READ_NODE_FIELD(planTree);
    1592      279834 :     READ_NODE_FIELD(rtable);
    1593      279834 :     READ_NODE_FIELD(resultRelations);
    1594      279834 :     READ_NODE_FIELD(appendRelations);
    1595      279834 :     READ_NODE_FIELD(subplans);
    1596      279834 :     READ_BITMAPSET_FIELD(rewindPlanIDs);
    1597      279834 :     READ_NODE_FIELD(rowMarks);
    1598      279834 :     READ_NODE_FIELD(relationOids);
    1599      279834 :     READ_NODE_FIELD(invalItems);
    1600      279834 :     READ_NODE_FIELD(paramExecTypes);
    1601      279834 :     READ_NODE_FIELD(utilityStmt);
    1602      279834 :     READ_LOCATION_FIELD(stmt_location);
    1603      279834 :     READ_INT_FIELD(stmt_len);
    1604             : 
    1605      279834 :     READ_DONE();
    1606             : }
    1607             : 
    1608             : /*
    1609             :  * ReadCommonPlan
    1610             :  *  Assign the basic stuff of all nodes that inherit from Plan
    1611             :  */
    1612             : static void
    1613      647700 : ReadCommonPlan(Plan *local_node)
    1614             : {
    1615             :     READ_TEMP_LOCALS();
    1616             : 
    1617      647700 :     READ_FLOAT_FIELD(startup_cost);
    1618      647700 :     READ_FLOAT_FIELD(total_cost);
    1619      647700 :     READ_FLOAT_FIELD(plan_rows);
    1620      647700 :     READ_INT_FIELD(plan_width);
    1621      647700 :     READ_BOOL_FIELD(parallel_aware);
    1622      647700 :     READ_BOOL_FIELD(parallel_safe);
    1623      647700 :     READ_BOOL_FIELD(async_capable);
    1624      647700 :     READ_INT_FIELD(plan_node_id);
    1625      647700 :     READ_NODE_FIELD(targetlist);
    1626      647700 :     READ_NODE_FIELD(qual);
    1627      647700 :     READ_NODE_FIELD(lefttree);
    1628      647700 :     READ_NODE_FIELD(righttree);
    1629      647700 :     READ_NODE_FIELD(initPlan);
    1630      647700 :     READ_BITMAPSET_FIELD(extParam);
    1631      647700 :     READ_BITMAPSET_FIELD(allParam);
    1632      647700 : }
    1633             : 
    1634             : /*
    1635             :  * _readPlan
    1636             :  */
    1637             : static Plan *
    1638           0 : _readPlan(void)
    1639             : {
    1640           0 :     READ_LOCALS_NO_FIELDS(Plan);
    1641             : 
    1642           0 :     ReadCommonPlan(local_node);
    1643             : 
    1644           0 :     READ_DONE();
    1645             : }
    1646             : 
    1647             : /*
    1648             :  * _readResult
    1649             :  */
    1650             : static Result *
    1651      141308 : _readResult(void)
    1652             : {
    1653      141308 :     READ_LOCALS(Result);
    1654             : 
    1655      141308 :     ReadCommonPlan(&local_node->plan);
    1656             : 
    1657      141308 :     READ_NODE_FIELD(resconstantqual);
    1658             : 
    1659      141308 :     READ_DONE();
    1660             : }
    1661             : 
    1662             : /*
    1663             :  * _readProjectSet
    1664             :  */
    1665             : static ProjectSet *
    1666        4262 : _readProjectSet(void)
    1667             : {
    1668        4262 :     READ_LOCALS_NO_FIELDS(ProjectSet);
    1669             : 
    1670        4262 :     ReadCommonPlan(&local_node->plan);
    1671             : 
    1672        4262 :     READ_DONE();
    1673             : }
    1674             : 
    1675             : /*
    1676             :  * _readModifyTable
    1677             :  */
    1678             : static ModifyTable *
    1679       76300 : _readModifyTable(void)
    1680             : {
    1681       76300 :     READ_LOCALS(ModifyTable);
    1682             : 
    1683       76300 :     ReadCommonPlan(&local_node->plan);
    1684             : 
    1685       76300 :     READ_ENUM_FIELD(operation, CmdType);
    1686       76300 :     READ_BOOL_FIELD(canSetTag);
    1687       76300 :     READ_UINT_FIELD(nominalRelation);
    1688       76300 :     READ_UINT_FIELD(rootRelation);
    1689       76300 :     READ_BOOL_FIELD(partColsUpdated);
    1690       76300 :     READ_NODE_FIELD(resultRelations);
    1691       76300 :     READ_NODE_FIELD(updateColnosLists);
    1692       76300 :     READ_NODE_FIELD(withCheckOptionLists);
    1693       76300 :     READ_NODE_FIELD(returningLists);
    1694       76300 :     READ_NODE_FIELD(fdwPrivLists);
    1695       76300 :     READ_BITMAPSET_FIELD(fdwDirectModifyPlans);
    1696       76300 :     READ_NODE_FIELD(rowMarks);
    1697       76300 :     READ_INT_FIELD(epqParam);
    1698       76300 :     READ_ENUM_FIELD(onConflictAction, OnConflictAction);
    1699       76300 :     READ_NODE_FIELD(arbiterIndexes);
    1700       76300 :     READ_NODE_FIELD(onConflictSet);
    1701       76300 :     READ_NODE_FIELD(onConflictCols);
    1702       76300 :     READ_NODE_FIELD(onConflictWhere);
    1703       76300 :     READ_UINT_FIELD(exclRelRTI);
    1704       76300 :     READ_NODE_FIELD(exclRelTlist);
    1705             : 
    1706       76300 :     READ_DONE();
    1707             : }
    1708             : 
    1709             : /*
    1710             :  * _readAppend
    1711             :  */
    1712             : static Append *
    1713        8354 : _readAppend(void)
    1714             : {
    1715        8354 :     READ_LOCALS(Append);
    1716             : 
    1717        8354 :     ReadCommonPlan(&local_node->plan);
    1718             : 
    1719        8354 :     READ_BITMAPSET_FIELD(apprelids);
    1720        8354 :     READ_NODE_FIELD(appendplans);
    1721        8354 :     READ_INT_FIELD(nasyncplans);
    1722        8354 :     READ_INT_FIELD(first_partial_plan);
    1723        8354 :     READ_NODE_FIELD(part_prune_info);
    1724             : 
    1725        8354 :     READ_DONE();
    1726             : }
    1727             : 
    1728             : /*
    1729             :  * _readMergeAppend
    1730             :  */
    1731             : static MergeAppend *
    1732         248 : _readMergeAppend(void)
    1733             : {
    1734         248 :     READ_LOCALS(MergeAppend);
    1735             : 
    1736         248 :     ReadCommonPlan(&local_node->plan);
    1737             : 
    1738         248 :     READ_BITMAPSET_FIELD(apprelids);
    1739         248 :     READ_NODE_FIELD(mergeplans);
    1740         248 :     READ_INT_FIELD(numCols);
    1741         248 :     READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
    1742         248 :     READ_OID_ARRAY(sortOperators, local_node->numCols);
    1743         248 :     READ_OID_ARRAY(collations, local_node->numCols);
    1744         248 :     READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
    1745         248 :     READ_NODE_FIELD(part_prune_info);
    1746             : 
    1747         248 :     READ_DONE();
    1748             : }
    1749             : 
    1750             : /*
    1751             :  * _readRecursiveUnion
    1752             :  */
    1753             : static RecursiveUnion *
    1754         454 : _readRecursiveUnion(void)
    1755             : {
    1756         454 :     READ_LOCALS(RecursiveUnion);
    1757             : 
    1758         454 :     ReadCommonPlan(&local_node->plan);
    1759             : 
    1760         454 :     READ_INT_FIELD(wtParam);
    1761         454 :     READ_INT_FIELD(numCols);
    1762         454 :     READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
    1763         454 :     READ_OID_ARRAY(dupOperators, local_node->numCols);
    1764         454 :     READ_OID_ARRAY(dupCollations, local_node->numCols);
    1765         454 :     READ_LONG_FIELD(numGroups);
    1766             : 
    1767         454 :     READ_DONE();
    1768             : }
    1769             : 
    1770             : /*
    1771             :  * _readBitmapAnd
    1772             :  */
    1773             : static BitmapAnd *
    1774          60 : _readBitmapAnd(void)
    1775             : {
    1776          60 :     READ_LOCALS(BitmapAnd);
    1777             : 
    1778          60 :     ReadCommonPlan(&local_node->plan);
    1779             : 
    1780          60 :     READ_NODE_FIELD(bitmapplans);
    1781             : 
    1782          60 :     READ_DONE();
    1783             : }
    1784             : 
    1785             : /*
    1786             :  * _readBitmapOr
    1787             :  */
    1788             : static BitmapOr *
    1789         152 : _readBitmapOr(void)
    1790             : {
    1791         152 :     READ_LOCALS(BitmapOr);
    1792             : 
    1793         152 :     ReadCommonPlan(&local_node->plan);
    1794             : 
    1795         152 :     READ_BOOL_FIELD(isshared);
    1796         152 :     READ_NODE_FIELD(bitmapplans);
    1797             : 
    1798         152 :     READ_DONE();
    1799             : }
    1800             : 
    1801             : /*
    1802             :  * ReadCommonScan
    1803             :  *  Assign the basic stuff of all nodes that inherit from Scan
    1804             :  */
    1805             : static void
    1806      268238 : ReadCommonScan(Scan *local_node)
    1807             : {
    1808             :     READ_TEMP_LOCALS();
    1809             : 
    1810      268238 :     ReadCommonPlan(&local_node->plan);
    1811             : 
    1812      268238 :     READ_UINT_FIELD(scanrelid);
    1813      268238 : }
    1814             : 
    1815             : /*
    1816             :  * _readScan
    1817             :  */
    1818             : static Scan *
    1819           0 : _readScan(void)
    1820             : {
    1821           0 :     READ_LOCALS_NO_FIELDS(Scan);
    1822             : 
    1823           0 :     ReadCommonScan(local_node);
    1824             : 
    1825           0 :     READ_DONE();
    1826             : }
    1827             : 
    1828             : /*
    1829             :  * _readSeqScan
    1830             :  */
    1831             : static SeqScan *
    1832      121348 : _readSeqScan(void)
    1833             : {
    1834      121348 :     READ_LOCALS_NO_FIELDS(SeqScan);
    1835             : 
    1836      121348 :     ReadCommonScan(&local_node->scan);
    1837             : 
    1838      121348 :     READ_DONE();
    1839             : }
    1840             : 
    1841             : /*
    1842             :  * _readSampleScan
    1843             :  */
    1844             : static SampleScan *
    1845         180 : _readSampleScan(void)
    1846             : {
    1847         180 :     READ_LOCALS(SampleScan);
    1848             : 
    1849         180 :     ReadCommonScan(&local_node->scan);
    1850             : 
    1851         180 :     READ_NODE_FIELD(tablesample);
    1852             : 
    1853         180 :     READ_DONE();
    1854             : }
    1855             : 
    1856             : /*
    1857             :  * _readIndexScan
    1858             :  */
    1859             : static IndexScan *
    1860       69642 : _readIndexScan(void)
    1861             : {
    1862       69642 :     READ_LOCALS(IndexScan);
    1863             : 
    1864       69642 :     ReadCommonScan(&local_node->scan);
    1865             : 
    1866       69642 :     READ_OID_FIELD(indexid);
    1867       69642 :     READ_NODE_FIELD(indexqual);
    1868       69642 :     READ_NODE_FIELD(indexqualorig);
    1869       69642 :     READ_NODE_FIELD(indexorderby);
    1870       69642 :     READ_NODE_FIELD(indexorderbyorig);
    1871       69642 :     READ_NODE_FIELD(indexorderbyops);
    1872       69642 :     READ_ENUM_FIELD(indexorderdir, ScanDirection);
    1873             : 
    1874       69642 :     READ_DONE();
    1875             : }
    1876             : 
    1877             : /*
    1878             :  * _readIndexOnlyScan
    1879             :  */
    1880             : static IndexOnlyScan *
    1881        8726 : _readIndexOnlyScan(void)
    1882             : {
    1883        8726 :     READ_LOCALS(IndexOnlyScan);
    1884             : 
    1885        8726 :     ReadCommonScan(&local_node->scan);
    1886             : 
    1887        8726 :     READ_OID_FIELD(indexid);
    1888        8726 :     READ_NODE_FIELD(indexqual);
    1889        8726 :     READ_NODE_FIELD(indexorderby);
    1890        8726 :     READ_NODE_FIELD(indextlist);
    1891        8726 :     READ_ENUM_FIELD(indexorderdir, ScanDirection);
    1892             : 
    1893        8726 :     READ_DONE();
    1894             : }
    1895             : 
    1896             : /*
    1897             :  * _readBitmapIndexScan
    1898             :  */
    1899             : static BitmapIndexScan *
    1900       15648 : _readBitmapIndexScan(void)
    1901             : {
    1902       15648 :     READ_LOCALS(BitmapIndexScan);
    1903             : 
    1904       15648 :     ReadCommonScan(&local_node->scan);
    1905             : 
    1906       15648 :     READ_OID_FIELD(indexid);
    1907       15648 :     READ_BOOL_FIELD(isshared);
    1908       15648 :     READ_NODE_FIELD(indexqual);
    1909       15648 :     READ_NODE_FIELD(indexqualorig);
    1910             : 
    1911       15648 :     READ_DONE();
    1912             : }
    1913             : 
    1914             : /*
    1915             :  * _readBitmapHeapScan
    1916             :  */
    1917             : static BitmapHeapScan *
    1918       15400 : _readBitmapHeapScan(void)
    1919             : {
    1920       15400 :     READ_LOCALS(BitmapHeapScan);
    1921             : 
    1922       15400 :     ReadCommonScan(&local_node->scan);
    1923             : 
    1924       15400 :     READ_NODE_FIELD(bitmapqualorig);
    1925             : 
    1926       15400 :     READ_DONE();
    1927             : }
    1928             : 
    1929             : /*
    1930             :  * _readTidScan
    1931             :  */
    1932             : static TidScan *
    1933         476 : _readTidScan(void)
    1934             : {
    1935         476 :     READ_LOCALS(TidScan);
    1936             : 
    1937         476 :     ReadCommonScan(&local_node->scan);
    1938             : 
    1939         476 :     READ_NODE_FIELD(tidquals);
    1940             : 
    1941         476 :     READ_DONE();
    1942             : }
    1943             : 
    1944             : /*
    1945             :  * _readTidRangeScan
    1946             :  */
    1947             : static TidRangeScan *
    1948         136 : _readTidRangeScan(void)
    1949             : {
    1950         136 :     READ_LOCALS(TidRangeScan);
    1951             : 
    1952         136 :     ReadCommonScan(&local_node->scan);
    1953             : 
    1954         136 :     READ_NODE_FIELD(tidrangequals);
    1955             : 
    1956         136 :     READ_DONE();
    1957             : }
    1958             : 
    1959             : /*
    1960             :  * _readSubqueryScan
    1961             :  */
    1962             : static SubqueryScan *
    1963        3190 : _readSubqueryScan(void)
    1964             : {
    1965        3190 :     READ_LOCALS(SubqueryScan);
    1966             : 
    1967        3190 :     ReadCommonScan(&local_node->scan);
    1968             : 
    1969        3190 :     READ_NODE_FIELD(subplan);
    1970             : 
    1971        3190 :     READ_DONE();
    1972             : }
    1973             : 
    1974             : /*
    1975             :  * _readFunctionScan
    1976             :  */
    1977             : static FunctionScan *
    1978       24458 : _readFunctionScan(void)
    1979             : {
    1980       24458 :     READ_LOCALS(FunctionScan);
    1981             : 
    1982       24458 :     ReadCommonScan(&local_node->scan);
    1983             : 
    1984       24458 :     READ_NODE_FIELD(functions);
    1985       24458 :     READ_BOOL_FIELD(funcordinality);
    1986             : 
    1987       24458 :     READ_DONE();
    1988             : }
    1989             : 
    1990             : /*
    1991             :  * _readValuesScan
    1992             :  */
    1993             : static ValuesScan *
    1994        4740 : _readValuesScan(void)
    1995             : {
    1996        4740 :     READ_LOCALS(ValuesScan);
    1997             : 
    1998        4740 :     ReadCommonScan(&local_node->scan);
    1999             : 
    2000        4740 :     READ_NODE_FIELD(values_lists);
    2001             : 
    2002        4740 :     READ_DONE();
    2003             : }
    2004             : 
    2005             : /*
    2006             :  * _readTableFuncScan
    2007             :  */
    2008             : static TableFuncScan *
    2009         144 : _readTableFuncScan(void)
    2010             : {
    2011         144 :     READ_LOCALS(TableFuncScan);
    2012             : 
    2013         144 :     ReadCommonScan(&local_node->scan);
    2014             : 
    2015         144 :     READ_NODE_FIELD(tablefunc);
    2016             : 
    2017         144 :     READ_DONE();
    2018             : }
    2019             : 
    2020             : /*
    2021             :  * _readCteScan
    2022             :  */
    2023             : static CteScan *
    2024        1702 : _readCteScan(void)
    2025             : {
    2026        1702 :     READ_LOCALS(CteScan);
    2027             : 
    2028        1702 :     ReadCommonScan(&local_node->scan);
    2029             : 
    2030        1702 :     READ_INT_FIELD(ctePlanId);
    2031        1702 :     READ_INT_FIELD(cteParam);
    2032             : 
    2033        1702 :     READ_DONE();
    2034             : }
    2035             : 
    2036             : /*
    2037             :  * _readNamedTuplestoreScan
    2038             :  */
    2039             : static NamedTuplestoreScan *
    2040         284 : _readNamedTuplestoreScan(void)
    2041             : {
    2042         284 :     READ_LOCALS(NamedTuplestoreScan);
    2043             : 
    2044         284 :     ReadCommonScan(&local_node->scan);
    2045             : 
    2046         284 :     READ_STRING_FIELD(enrname);
    2047             : 
    2048         284 :     READ_DONE();
    2049             : }
    2050             : 
    2051             : /*
    2052             :  * _readWorkTableScan
    2053             :  */
    2054             : static WorkTableScan *
    2055         454 : _readWorkTableScan(void)
    2056             : {
    2057         454 :     READ_LOCALS(WorkTableScan);
    2058             : 
    2059         454 :     ReadCommonScan(&local_node->scan);
    2060             : 
    2061         454 :     READ_INT_FIELD(wtParam);
    2062             : 
    2063         454 :     READ_DONE();
    2064             : }
    2065             : 
    2066             : /*
    2067             :  * _readForeignScan
    2068             :  */
    2069             : static ForeignScan *
    2070        1710 : _readForeignScan(void)
    2071             : {
    2072        1710 :     READ_LOCALS(ForeignScan);
    2073             : 
    2074        1710 :     ReadCommonScan(&local_node->scan);
    2075             : 
    2076        1710 :     READ_ENUM_FIELD(operation, CmdType);
    2077        1710 :     READ_UINT_FIELD(resultRelation);
    2078        1710 :     READ_OID_FIELD(fs_server);
    2079        1710 :     READ_NODE_FIELD(fdw_exprs);
    2080        1710 :     READ_NODE_FIELD(fdw_private);
    2081        1710 :     READ_NODE_FIELD(fdw_scan_tlist);
    2082        1710 :     READ_NODE_FIELD(fdw_recheck_quals);
    2083        1710 :     READ_BITMAPSET_FIELD(fs_relids);
    2084        1710 :     READ_BOOL_FIELD(fsSystemCol);
    2085             : 
    2086        1710 :     READ_DONE();
    2087             : }
    2088             : 
    2089             : /*
    2090             :  * _readCustomScan
    2091             :  */
    2092             : static CustomScan *
    2093           0 : _readCustomScan(void)
    2094             : {
    2095           0 :     READ_LOCALS(CustomScan);
    2096             :     char       *custom_name;
    2097             :     const CustomScanMethods *methods;
    2098             : 
    2099           0 :     ReadCommonScan(&local_node->scan);
    2100             : 
    2101           0 :     READ_UINT_FIELD(flags);
    2102           0 :     READ_NODE_FIELD(custom_plans);
    2103           0 :     READ_NODE_FIELD(custom_exprs);
    2104           0 :     READ_NODE_FIELD(custom_private);
    2105           0 :     READ_NODE_FIELD(custom_scan_tlist);
    2106           0 :     READ_BITMAPSET_FIELD(custom_relids);
    2107             : 
    2108             :     /* Lookup CustomScanMethods by CustomName */
    2109           0 :     token = pg_strtok(&length); /* skip methods: */
    2110           0 :     token = pg_strtok(&length); /* CustomName */
    2111           0 :     custom_name = nullable_string(token, length);
    2112           0 :     methods = GetCustomScanMethods(custom_name, false);
    2113           0 :     local_node->methods = methods;
    2114             : 
    2115           0 :     READ_DONE();
    2116             : }
    2117             : 
    2118             : /*
    2119             :  * ReadCommonJoin
    2120             :  *  Assign the basic stuff of all nodes that inherit from Join
    2121             :  */
    2122             : static void
    2123       60404 : ReadCommonJoin(Join *local_node)
    2124             : {
    2125             :     READ_TEMP_LOCALS();
    2126             : 
    2127       60404 :     ReadCommonPlan(&local_node->plan);
    2128             : 
    2129       60404 :     READ_ENUM_FIELD(jointype, JoinType);
    2130       60404 :     READ_BOOL_FIELD(inner_unique);
    2131       60404 :     READ_NODE_FIELD(joinqual);
    2132       60404 : }
    2133             : 
    2134             : /*
    2135             :  * _readJoin
    2136             :  */
    2137             : static Join *
    2138           0 : _readJoin(void)
    2139             : {
    2140           0 :     READ_LOCALS_NO_FIELDS(Join);
    2141             : 
    2142           0 :     ReadCommonJoin(local_node);
    2143             : 
    2144           0 :     READ_DONE();
    2145             : }
    2146             : 
    2147             : /*
    2148             :  * _readNestLoop
    2149             :  */
    2150             : static NestLoop *
    2151       40558 : _readNestLoop(void)
    2152             : {
    2153       40558 :     READ_LOCALS(NestLoop);
    2154             : 
    2155       40558 :     ReadCommonJoin(&local_node->join);
    2156             : 
    2157       40558 :     READ_NODE_FIELD(nestParams);
    2158             : 
    2159       40558 :     READ_DONE();
    2160             : }
    2161             : 
    2162             : /*
    2163             :  * _readMergeJoin
    2164             :  */
    2165             : static MergeJoin *
    2166        2716 : _readMergeJoin(void)
    2167             : {
    2168             :     int         numCols;
    2169             : 
    2170        2716 :     READ_LOCALS(MergeJoin);
    2171             : 
    2172        2716 :     ReadCommonJoin(&local_node->join);
    2173             : 
    2174        2716 :     READ_BOOL_FIELD(skip_mark_restore);
    2175        2716 :     READ_NODE_FIELD(mergeclauses);
    2176             : 
    2177        2716 :     numCols = list_length(local_node->mergeclauses);
    2178             : 
    2179        2716 :     READ_OID_ARRAY(mergeFamilies, numCols);
    2180        2716 :     READ_OID_ARRAY(mergeCollations, numCols);
    2181        2716 :     READ_INT_ARRAY(mergeStrategies, numCols);
    2182        2716 :     READ_BOOL_ARRAY(mergeNullsFirst, numCols);
    2183             : 
    2184        2716 :     READ_DONE();
    2185             : }
    2186             : 
    2187             : /*
    2188             :  * _readHashJoin
    2189             :  */
    2190             : static HashJoin *
    2191       17130 : _readHashJoin(void)
    2192             : {
    2193       17130 :     READ_LOCALS(HashJoin);
    2194             : 
    2195       17130 :     ReadCommonJoin(&local_node->join);
    2196             : 
    2197       17130 :     READ_NODE_FIELD(hashclauses);
    2198       17130 :     READ_NODE_FIELD(hashoperators);
    2199       17130 :     READ_NODE_FIELD(hashcollations);
    2200       17130 :     READ_NODE_FIELD(hashkeys);
    2201             : 
    2202       17130 :     READ_DONE();
    2203             : }
    2204             : 
    2205             : /*
    2206             :  * _readMaterial
    2207             :  */
    2208             : static Material *
    2209        2346 : _readMaterial(void)
    2210             : {
    2211        2346 :     READ_LOCALS_NO_FIELDS(Material);
    2212             : 
    2213        2346 :     ReadCommonPlan(&local_node->plan);
    2214             : 
    2215        2346 :     READ_DONE();
    2216             : }
    2217             : 
    2218             : /*
    2219             :  * _readMemoize
    2220             :  */
    2221             : static Memoize *
    2222         674 : _readMemoize(void)
    2223             : {
    2224         674 :     READ_LOCALS(Memoize);
    2225             : 
    2226         674 :     ReadCommonPlan(&local_node->plan);
    2227             : 
    2228         674 :     READ_INT_FIELD(numKeys);
    2229         674 :     READ_OID_ARRAY(hashOperators, local_node->numKeys);
    2230         674 :     READ_OID_ARRAY(collations, local_node->numKeys);
    2231         674 :     READ_NODE_FIELD(param_exprs);
    2232         674 :     READ_BOOL_FIELD(singlerow);
    2233         674 :     READ_BOOL_FIELD(binary_mode);
    2234         674 :     READ_UINT_FIELD(est_entries);
    2235         674 :     READ_BITMAPSET_FIELD(keyparamids);
    2236             : 
    2237         674 :     READ_DONE();
    2238             : }
    2239             : 
    2240             : /*
    2241             :  * ReadCommonSort
    2242             :  *  Assign the basic stuff of all nodes that inherit from Sort
    2243             :  */
    2244             : static void
    2245       30998 : ReadCommonSort(Sort *local_node)
    2246             : {
    2247             :     READ_TEMP_LOCALS();
    2248             : 
    2249       30998 :     ReadCommonPlan(&local_node->plan);
    2250             : 
    2251       30998 :     READ_INT_FIELD(numCols);
    2252       30998 :     READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
    2253       30998 :     READ_OID_ARRAY(sortOperators, local_node->numCols);
    2254       30998 :     READ_OID_ARRAY(collations, local_node->numCols);
    2255       30998 :     READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
    2256       30998 : }
    2257             : 
    2258             : /*
    2259             :  * _readSort
    2260             :  */
    2261             : static Sort *
    2262       30746 : _readSort(void)
    2263             : {
    2264       30746 :     READ_LOCALS_NO_FIELDS(Sort);
    2265             : 
    2266       30746 :     ReadCommonSort(local_node);
    2267             : 
    2268       30746 :     READ_DONE();
    2269             : }
    2270             : 
    2271             : /*
    2272             :  * _readIncrementalSort
    2273             :  */
    2274             : static IncrementalSort *
    2275         252 : _readIncrementalSort(void)
    2276             : {
    2277         252 :     READ_LOCALS(IncrementalSort);
    2278             : 
    2279         252 :     ReadCommonSort(&local_node->sort);
    2280             : 
    2281         252 :     READ_INT_FIELD(nPresortedCols);
    2282             : 
    2283         252 :     READ_DONE();
    2284             : }
    2285             : 
    2286             : /*
    2287             :  * _readGroup
    2288             :  */
    2289             : static Group *
    2290         152 : _readGroup(void)
    2291             : {
    2292         152 :     READ_LOCALS(Group);
    2293             : 
    2294         152 :     ReadCommonPlan(&local_node->plan);
    2295             : 
    2296         152 :     READ_INT_FIELD(numCols);
    2297         152 :     READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
    2298         152 :     READ_OID_ARRAY(grpOperators, local_node->numCols);
    2299         152 :     READ_OID_ARRAY(grpCollations, local_node->numCols);
    2300             : 
    2301         152 :     READ_DONE();
    2302             : }
    2303             : 
    2304             : /*
    2305             :  * _readAgg
    2306             :  */
    2307             : static Agg *
    2308       24948 : _readAgg(void)
    2309             : {
    2310       24948 :     READ_LOCALS(Agg);
    2311             : 
    2312       24948 :     ReadCommonPlan(&local_node->plan);
    2313             : 
    2314       24948 :     READ_ENUM_FIELD(aggstrategy, AggStrategy);
    2315       24948 :     READ_ENUM_FIELD(aggsplit, AggSplit);
    2316       24948 :     READ_INT_FIELD(numCols);
    2317       24948 :     READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
    2318       24948 :     READ_OID_ARRAY(grpOperators, local_node->numCols);
    2319       24948 :     READ_OID_ARRAY(grpCollations, local_node->numCols);
    2320       24948 :     READ_LONG_FIELD(numGroups);
    2321       24948 :     READ_UINT64_FIELD(transitionSpace);
    2322       24948 :     READ_BITMAPSET_FIELD(aggParams);
    2323       24948 :     READ_NODE_FIELD(groupingSets);
    2324       24948 :     READ_NODE_FIELD(chain);
    2325             : 
    2326       24948 :     READ_DONE();
    2327             : }
    2328             : 
    2329             : /*
    2330             :  * _readWindowAgg
    2331             :  */
    2332             : static WindowAgg *
    2333        1236 : _readWindowAgg(void)
    2334             : {
    2335        1236 :     READ_LOCALS(WindowAgg);
    2336             : 
    2337        1236 :     ReadCommonPlan(&local_node->plan);
    2338             : 
    2339        1236 :     READ_UINT_FIELD(winref);
    2340        1236 :     READ_INT_FIELD(partNumCols);
    2341        1236 :     READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
    2342        1236 :     READ_OID_ARRAY(partOperators, local_node->partNumCols);
    2343        1236 :     READ_OID_ARRAY(partCollations, local_node->partNumCols);
    2344        1236 :     READ_INT_FIELD(ordNumCols);
    2345        1236 :     READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
    2346        1236 :     READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
    2347        1236 :     READ_OID_ARRAY(ordCollations, local_node->ordNumCols);
    2348        1236 :     READ_INT_FIELD(frameOptions);
    2349        1236 :     READ_NODE_FIELD(startOffset);
    2350        1236 :     READ_NODE_FIELD(endOffset);
    2351        1236 :     READ_OID_FIELD(startInRangeFunc);
    2352        1236 :     READ_OID_FIELD(endInRangeFunc);
    2353        1236 :     READ_OID_FIELD(inRangeColl);
    2354        1236 :     READ_BOOL_FIELD(inRangeAsc);
    2355        1236 :     READ_BOOL_FIELD(inRangeNullsFirst);
    2356             : 
    2357        1236 :     READ_DONE();
    2358             : }
    2359             : 
    2360             : /*
    2361             :  * _readUnique
    2362             :  */
    2363             : static Unique *
    2364         672 : _readUnique(void)
    2365             : {
    2366         672 :     READ_LOCALS(Unique);
    2367             : 
    2368         672 :     ReadCommonPlan(&local_node->plan);
    2369             : 
    2370         672 :     READ_INT_FIELD(numCols);
    2371         672 :     READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
    2372         672 :     READ_OID_ARRAY(uniqOperators, local_node->numCols);
    2373         672 :     READ_OID_ARRAY(uniqCollations, local_node->numCols);
    2374             : 
    2375         672 :     READ_DONE();
    2376             : }
    2377             : 
    2378             : /*
    2379             :  * _readGather
    2380             :  */
    2381             : static Gather *
    2382         598 : _readGather(void)
    2383             : {
    2384         598 :     READ_LOCALS(Gather);
    2385             : 
    2386         598 :     ReadCommonPlan(&local_node->plan);
    2387             : 
    2388         598 :     READ_INT_FIELD(num_workers);
    2389         598 :     READ_INT_FIELD(rescan_param);
    2390         598 :     READ_BOOL_FIELD(single_copy);
    2391         598 :     READ_BOOL_FIELD(invisible);
    2392         598 :     READ_BITMAPSET_FIELD(initParam);
    2393             : 
    2394         598 :     READ_DONE();
    2395             : }
    2396             : 
    2397             : /*
    2398             :  * _readGatherMerge
    2399             :  */
    2400             : static GatherMerge *
    2401         180 : _readGatherMerge(void)
    2402             : {
    2403         180 :     READ_LOCALS(GatherMerge);
    2404             : 
    2405         180 :     ReadCommonPlan(&local_node->plan);
    2406             : 
    2407         180 :     READ_INT_FIELD(num_workers);
    2408         180 :     READ_INT_FIELD(rescan_param);
    2409         180 :     READ_INT_FIELD(numCols);
    2410         180 :     READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
    2411         180 :     READ_OID_ARRAY(sortOperators, local_node->numCols);
    2412         180 :     READ_OID_ARRAY(collations, local_node->numCols);
    2413         180 :     READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
    2414         180 :     READ_BITMAPSET_FIELD(initParam);
    2415             : 
    2416         180 :     READ_DONE();
    2417             : }
    2418             : 
    2419             : /*
    2420             :  * _readHash
    2421             :  */
    2422             : static Hash *
    2423       17130 : _readHash(void)
    2424             : {
    2425       17130 :     READ_LOCALS(Hash);
    2426             : 
    2427       17130 :     ReadCommonPlan(&local_node->plan);
    2428             : 
    2429       17130 :     READ_NODE_FIELD(hashkeys);
    2430       17130 :     READ_OID_FIELD(skewTable);
    2431       17130 :     READ_INT_FIELD(skewColumn);
    2432       17130 :     READ_BOOL_FIELD(skewInherit);
    2433       17130 :     READ_FLOAT_FIELD(rows_total);
    2434             : 
    2435       17130 :     READ_DONE();
    2436             : }
    2437             : 
    2438             : /*
    2439             :  * _readSetOp
    2440             :  */
    2441             : static SetOp *
    2442         340 : _readSetOp(void)
    2443             : {
    2444         340 :     READ_LOCALS(SetOp);
    2445             : 
    2446         340 :     ReadCommonPlan(&local_node->plan);
    2447             : 
    2448         340 :     READ_ENUM_FIELD(cmd, SetOpCmd);
    2449         340 :     READ_ENUM_FIELD(strategy, SetOpStrategy);
    2450         340 :     READ_INT_FIELD(numCols);
    2451         340 :     READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
    2452         340 :     READ_OID_ARRAY(dupOperators, local_node->numCols);
    2453         340 :     READ_OID_ARRAY(dupCollations, local_node->numCols);
    2454         340 :     READ_INT_FIELD(flagColIdx);
    2455         340 :     READ_INT_FIELD(firstFlag);
    2456         340 :     READ_LONG_FIELD(numGroups);
    2457             : 
    2458         340 :     READ_DONE();
    2459             : }
    2460             : 
    2461             : /*
    2462             :  * _readLockRows
    2463             :  */
    2464             : static LockRows *
    2465        5152 : _readLockRows(void)
    2466             : {
    2467        5152 :     READ_LOCALS(LockRows);
    2468             : 
    2469        5152 :     ReadCommonPlan(&local_node->plan);
    2470             : 
    2471        5152 :     READ_NODE_FIELD(rowMarks);
    2472        5152 :     READ_INT_FIELD(epqParam);
    2473             : 
    2474        5152 :     READ_DONE();
    2475             : }
    2476             : 
    2477             : /*
    2478             :  * _readLimit
    2479             :  */
    2480             : static Limit *
    2481        3494 : _readLimit(void)
    2482             : {
    2483        3494 :     READ_LOCALS(Limit);
    2484             : 
    2485        3494 :     ReadCommonPlan(&local_node->plan);
    2486             : 
    2487        3494 :     READ_NODE_FIELD(limitOffset);
    2488        3494 :     READ_NODE_FIELD(limitCount);
    2489        3494 :     READ_ENUM_FIELD(limitOption, LimitOption);
    2490        3494 :     READ_INT_FIELD(uniqNumCols);
    2491        3494 :     READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->uniqNumCols);
    2492        3494 :     READ_OID_ARRAY(uniqOperators, local_node->uniqNumCols);
    2493        3494 :     READ_OID_ARRAY(uniqCollations, local_node->uniqNumCols);
    2494             : 
    2495        3494 :     READ_DONE();
    2496             : }
    2497             : 
    2498             : /*
    2499             :  * _readNestLoopParam
    2500             :  */
    2501             : static NestLoopParam *
    2502       21952 : _readNestLoopParam(void)
    2503             : {
    2504       21952 :     READ_LOCALS(NestLoopParam);
    2505             : 
    2506       21952 :     READ_INT_FIELD(paramno);
    2507       21952 :     READ_NODE_FIELD(paramval);
    2508             : 
    2509       21952 :     READ_DONE();
    2510             : }
    2511             : 
    2512             : /*
    2513             :  * _readPlanRowMark
    2514             :  */
    2515             : static PlanRowMark *
    2516       14936 : _readPlanRowMark(void)
    2517             : {
    2518       14936 :     READ_LOCALS(PlanRowMark);
    2519             : 
    2520       14936 :     READ_UINT_FIELD(rti);
    2521       14936 :     READ_UINT_FIELD(prti);
    2522       14936 :     READ_UINT_FIELD(rowmarkId);
    2523       14936 :     READ_ENUM_FIELD(markType, RowMarkType);
    2524       14936 :     READ_INT_FIELD(allMarkTypes);
    2525       14936 :     READ_ENUM_FIELD(strength, LockClauseStrength);
    2526       14936 :     READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
    2527       14936 :     READ_BOOL_FIELD(isParent);
    2528             : 
    2529       14936 :     READ_DONE();
    2530             : }
    2531             : 
    2532             : static PartitionPruneInfo *
    2533         372 : _readPartitionPruneInfo(void)
    2534             : {
    2535         372 :     READ_LOCALS(PartitionPruneInfo);
    2536             : 
    2537         372 :     READ_NODE_FIELD(prune_infos);
    2538         372 :     READ_BITMAPSET_FIELD(other_subplans);
    2539             : 
    2540         372 :     READ_DONE();
    2541             : }
    2542             : 
    2543             : static PartitionedRelPruneInfo *
    2544         820 : _readPartitionedRelPruneInfo(void)
    2545             : {
    2546         820 :     READ_LOCALS(PartitionedRelPruneInfo);
    2547             : 
    2548         820 :     READ_UINT_FIELD(rtindex);
    2549         820 :     READ_BITMAPSET_FIELD(present_parts);
    2550         820 :     READ_INT_FIELD(nparts);
    2551         820 :     READ_INT_ARRAY(subplan_map, local_node->nparts);
    2552         820 :     READ_INT_ARRAY(subpart_map, local_node->nparts);
    2553         820 :     READ_OID_ARRAY(relid_map, local_node->nparts);
    2554         820 :     READ_NODE_FIELD(initial_pruning_steps);
    2555         820 :     READ_NODE_FIELD(exec_pruning_steps);
    2556         820 :     READ_BITMAPSET_FIELD(execparamids);
    2557             : 
    2558         820 :     READ_DONE();
    2559             : }
    2560             : 
    2561             : static PartitionPruneStepOp *
    2562         682 : _readPartitionPruneStepOp(void)
    2563             : {
    2564         682 :     READ_LOCALS(PartitionPruneStepOp);
    2565             : 
    2566         682 :     READ_INT_FIELD(step.step_id);
    2567         682 :     READ_INT_FIELD(opstrategy);
    2568         682 :     READ_NODE_FIELD(exprs);
    2569         682 :     READ_NODE_FIELD(cmpfns);
    2570         682 :     READ_BITMAPSET_FIELD(nullkeys);
    2571             : 
    2572         682 :     READ_DONE();
    2573             : }
    2574             : 
    2575             : static PartitionPruneStepCombine *
    2576         146 : _readPartitionPruneStepCombine(void)
    2577             : {
    2578         146 :     READ_LOCALS(PartitionPruneStepCombine);
    2579             : 
    2580         146 :     READ_INT_FIELD(step.step_id);
    2581         146 :     READ_ENUM_FIELD(combineOp, PartitionPruneCombineOp);
    2582         146 :     READ_NODE_FIELD(source_stepids);
    2583             : 
    2584         146 :     READ_DONE();
    2585             : }
    2586             : 
    2587             : /*
    2588             :  * _readPlanInvalItem
    2589             :  */
    2590             : static PlanInvalItem *
    2591      110104 : _readPlanInvalItem(void)
    2592             : {
    2593      110104 :     READ_LOCALS(PlanInvalItem);
    2594             : 
    2595      110104 :     READ_INT_FIELD(cacheId);
    2596      110104 :     READ_UINT_FIELD(hashValue);
    2597             : 
    2598      110104 :     READ_DONE();
    2599             : }
    2600             : 
    2601             : /*
    2602             :  * _readSubPlan
    2603             :  */
    2604             : static SubPlan *
    2605       28084 : _readSubPlan(void)
    2606             : {
    2607       28084 :     READ_LOCALS(SubPlan);
    2608             : 
    2609       28084 :     READ_ENUM_FIELD(subLinkType, SubLinkType);
    2610       28084 :     READ_NODE_FIELD(testexpr);
    2611       28084 :     READ_NODE_FIELD(paramIds);
    2612       28084 :     READ_INT_FIELD(plan_id);
    2613       28084 :     READ_STRING_FIELD(plan_name);
    2614       28084 :     READ_OID_FIELD(firstColType);
    2615       28084 :     READ_INT_FIELD(firstColTypmod);
    2616       28084 :     READ_OID_FIELD(firstColCollation);
    2617       28084 :     READ_BOOL_FIELD(useHashTable);
    2618       28084 :     READ_BOOL_FIELD(unknownEqFalse);
    2619       28084 :     READ_BOOL_FIELD(parallel_safe);
    2620       28084 :     READ_NODE_FIELD(setParam);
    2621       28084 :     READ_NODE_FIELD(parParam);
    2622       28084 :     READ_NODE_FIELD(args);
    2623       28084 :     READ_FLOAT_FIELD(startup_cost);
    2624       28084 :     READ_FLOAT_FIELD(per_call_cost);
    2625             : 
    2626       28084 :     READ_DONE();
    2627             : }
    2628             : 
    2629             : /*
    2630             :  * _readAlternativeSubPlan
    2631             :  */
    2632             : static AlternativeSubPlan *
    2633           0 : _readAlternativeSubPlan(void)
    2634             : {
    2635           0 :     READ_LOCALS(AlternativeSubPlan);
    2636             : 
    2637           0 :     READ_NODE_FIELD(subplans);
    2638             : 
    2639           0 :     READ_DONE();
    2640             : }
    2641             : 
    2642             : /*
    2643             :  * _readExtensibleNode
    2644             :  */
    2645             : static ExtensibleNode *
    2646           0 : _readExtensibleNode(void)
    2647             : {
    2648             :     const ExtensibleNodeMethods *methods;
    2649             :     ExtensibleNode *local_node;
    2650             :     const char *extnodename;
    2651             : 
    2652             :     READ_TEMP_LOCALS();
    2653             : 
    2654           0 :     token = pg_strtok(&length); /* skip :extnodename */
    2655           0 :     token = pg_strtok(&length); /* get extnodename */
    2656             : 
    2657           0 :     extnodename = nullable_string(token, length);
    2658           0 :     if (!extnodename)
    2659           0 :         elog(ERROR, "extnodename has to be supplied");
    2660           0 :     methods = GetExtensibleNodeMethods(extnodename, false);
    2661             : 
    2662           0 :     local_node = (ExtensibleNode *) newNode(methods->node_size,
    2663             :                                             T_ExtensibleNode);
    2664           0 :     local_node->extnodename = extnodename;
    2665             : 
    2666             :     /* deserialize the private fields */
    2667           0 :     methods->nodeRead(local_node);
    2668             : 
    2669           0 :     READ_DONE();
    2670             : }
    2671             : 
    2672             : /*
    2673             :  * _readPartitionBoundSpec
    2674             :  */
    2675             : static PartitionBoundSpec *
    2676       23128 : _readPartitionBoundSpec(void)
    2677             : {
    2678       23128 :     READ_LOCALS(PartitionBoundSpec);
    2679             : 
    2680       23128 :     READ_CHAR_FIELD(strategy);
    2681       23128 :     READ_BOOL_FIELD(is_default);
    2682       23128 :     READ_INT_FIELD(modulus);
    2683       23128 :     READ_INT_FIELD(remainder);
    2684       23128 :     READ_NODE_FIELD(listdatums);
    2685       23128 :     READ_NODE_FIELD(lowerdatums);
    2686       23128 :     READ_NODE_FIELD(upperdatums);
    2687       23128 :     READ_LOCATION_FIELD(location);
    2688             : 
    2689       23128 :     READ_DONE();
    2690             : }
    2691             : 
    2692             : /*
    2693             :  * _readPartitionRangeDatum
    2694             :  */
    2695             : static PartitionRangeDatum *
    2696       27288 : _readPartitionRangeDatum(void)
    2697             : {
    2698       27288 :     READ_LOCALS(PartitionRangeDatum);
    2699             : 
    2700       27288 :     READ_ENUM_FIELD(kind, PartitionRangeDatumKind);
    2701       27288 :     READ_NODE_FIELD(value);
    2702       27288 :     READ_LOCATION_FIELD(location);
    2703             : 
    2704       27288 :     READ_DONE();
    2705             : }
    2706             : 
    2707             : /*
    2708             :  * parseNodeString
    2709             :  *
    2710             :  * Given a character string representing a node tree, parseNodeString creates
    2711             :  * the internal node structure.
    2712             :  *
    2713             :  * The string to be read must already have been loaded into pg_strtok().
    2714             :  */
    2715             : Node *
    2716    32230998 : parseNodeString(void)
    2717             : {
    2718             :     void       *return_value;
    2719             : 
    2720             :     READ_TEMP_LOCALS();
    2721             : 
    2722             :     /* Guard against stack overflow due to overly complex expressions */
    2723    32230998 :     check_stack_depth();
    2724             : 
    2725    32230998 :     token = pg_strtok(&length);
    2726             : 
    2727             : #define MATCH(tokname, namelen) \
    2728             :     (length == namelen && memcmp(token, tokname, namelen) == 0)
    2729             : 
    2730    32230998 :     if (MATCH("QUERY", 5))
    2731      565302 :         return_value = _readQuery();
    2732    31665696 :     else if (MATCH("WITHCHECKOPTION", 15))
    2733        2220 :         return_value = _readWithCheckOption();
    2734    31663476 :     else if (MATCH("SORTGROUPCLAUSE", 15))
    2735      127842 :         return_value = _readSortGroupClause();
    2736    31535634 :     else if (MATCH("GROUPINGSET", 11))
    2737        1298 :         return_value = _readGroupingSet();
    2738    31534336 :     else if (MATCH("WINDOWCLAUSE", 12))
    2739        1732 :         return_value = _readWindowClause();
    2740    31532604 :     else if (MATCH("ROWMARKCLAUSE", 13))
    2741        3468 :         return_value = _readRowMarkClause();
    2742    31529136 :     else if (MATCH("CTESEARCHCLAUSE", 15))
    2743          40 :         return_value = _readCTESearchClause();
    2744    31529096 :     else if (MATCH("CTECYCLECLAUSE", 14))
    2745          56 :         return_value = _readCTECycleClause();
    2746    31529040 :     else if (MATCH("COMMONTABLEEXPR", 15))
    2747        2400 :         return_value = _readCommonTableExpr();
    2748    31526640 :     else if (MATCH("SETOPERATIONSTMT", 16))
    2749       33842 :         return_value = _readSetOperationStmt();
    2750    31492798 :     else if (MATCH("ALIAS", 5))
    2751     2536334 :         return_value = _readAlias();
    2752    28956464 :     else if (MATCH("RANGEVAR", 8))
    2753           0 :         return_value = _readRangeVar();
    2754    28956464 :     else if (MATCH("INTOCLAUSE", 10))
    2755           0 :         return_value = _readIntoClause();
    2756    28956464 :     else if (MATCH("TABLEFUNC", 9))
    2757         316 :         return_value = _readTableFunc();
    2758    28956148 :     else if (MATCH("VAR", 3))
    2759    12216574 :         return_value = _readVar();
    2760    16739574 :     else if (MATCH("CONST", 5))
    2761     2764922 :         return_value = _readConst();
    2762    13974652 :     else if (MATCH("PARAM", 5))
    2763      463458 :         return_value = _readParam();
    2764    13511194 :     else if (MATCH("AGGREF", 6))
    2765       50910 :         return_value = _readAggref();
    2766    13460284 :     else if (MATCH("GROUPINGFUNC", 12))
    2767         330 :         return_value = _readGroupingFunc();
    2768    13459954 :     else if (MATCH("WINDOWFUNC", 10))
    2769        3504 :         return_value = _readWindowFunc();
    2770    13456450 :     else if (MATCH("SUBSCRIPTINGREF", 15))
    2771       18494 :         return_value = _readSubscriptingRef();
    2772    13437956 :     else if (MATCH("FUNCEXPR", 8))
    2773     1075186 :         return_value = _readFuncExpr();
    2774    12362770 :     else if (MATCH("NAMEDARGEXPR", 12))
    2775       35564 :         return_value = _readNamedArgExpr();
    2776    12327206 :     else if (MATCH("OPEXPR", 6))
    2777     1240332 :         return_value = _readOpExpr();
    2778    11086874 :     else if (MATCH("DISTINCTEXPR", 12))
    2779        1030 :         return_value = _readDistinctExpr();
    2780    11085844 :     else if (MATCH("NULLIFEXPR", 10))
    2781        1360 :         return_value = _readNullIfExpr();
    2782    11084484 :     else if (MATCH("SCALARARRAYOPEXPR", 17))
    2783       72610 :         return_value = _readScalarArrayOpExpr();
    2784    11011874 :     else if (MATCH("BOOLEXPR", 8))
    2785      245016 :         return_value = _readBoolExpr();
    2786    10766858 :     else if (MATCH("SUBLINK", 7))
    2787       50110 :         return_value = _readSubLink();
    2788    10716748 :     else if (MATCH("FIELDSELECT", 11))
    2789       98400 :         return_value = _readFieldSelect();
    2790    10618348 :     else if (MATCH("FIELDSTORE", 10))
    2791         480 :         return_value = _readFieldStore();
    2792    10617868 :     else if (MATCH("RELABELTYPE", 11))
    2793      218010 :         return_value = _readRelabelType();
    2794    10399858 :     else if (MATCH("COERCEVIAIO", 11))
    2795       37764 :         return_value = _readCoerceViaIO();
    2796    10362094 :     else if (MATCH("ARRAYCOERCEEXPR", 15))
    2797        3488 :         return_value = _readArrayCoerceExpr();
    2798    10358606 :     else if (MATCH("CONVERTROWTYPEEXPR", 18))
    2799         446 :         return_value = _readConvertRowtypeExpr();
    2800    10358160 :     else if (MATCH("COLLATEEXPR", 11))
    2801        3330 :         return_value = _readCollateExpr();
    2802    10354830 :     else if (MATCH("CASEEXPR", 8))
    2803      118950 :         return_value = _readCaseExpr();
    2804    10235880 :     else if (MATCH("CASEWHEN", 8))
    2805      221344 :         return_value = _readCaseWhen();
    2806    10014536 :     else if (MATCH("CASETESTEXPR", 12))
    2807       66764 :         return_value = _readCaseTestExpr();
    2808     9947772 :     else if (MATCH("ARRAYEXPR", 9))
    2809       54662 :         return_value = _readArrayExpr();
    2810     9893110 :     else if (MATCH("ROWEXPR", 7))
    2811        3628 :         return_value = _readRowExpr();
    2812     9889482 :     else if (MATCH("ROWCOMPAREEXPR", 14))
    2813         232 :         return_value = _readRowCompareExpr();
    2814     9889250 :     else if (MATCH("COALESCEEXPR", 12))
    2815       44296 :         return_value = _readCoalesceExpr();
    2816     9844954 :     else if (MATCH("MINMAXEXPR", 10))
    2817         244 :         return_value = _readMinMaxExpr();
    2818     9844710 :     else if (MATCH("SQLVALUEFUNCTION", 16))
    2819        8220 :         return_value = _readSQLValueFunction();
    2820     9836490 :     else if (MATCH("XMLEXPR", 7))
    2821         952 :         return_value = _readXmlExpr();
    2822     9835538 :     else if (MATCH("NULLTEST", 8))
    2823       34644 :         return_value = _readNullTest();
    2824     9800894 :     else if (MATCH("BOOLEANTEST", 11))
    2825         524 :         return_value = _readBooleanTest();
    2826     9800370 :     else if (MATCH("COERCETODOMAIN", 14))
    2827      613242 :         return_value = _readCoerceToDomain();
    2828     9187128 :     else if (MATCH("COERCETODOMAINVALUE", 19))
    2829        1816 :         return_value = _readCoerceToDomainValue();
    2830     9185312 :     else if (MATCH("SETTODEFAULT", 12))
    2831           0 :         return_value = _readSetToDefault();
    2832     9185312 :     else if (MATCH("CURRENTOFEXPR", 13))
    2833         414 :         return_value = _readCurrentOfExpr();
    2834     9184898 :     else if (MATCH("NEXTVALUEEXPR", 13))
    2835         404 :         return_value = _readNextValueExpr();
    2836     9184494 :     else if (MATCH("INFERENCEELEM", 13))
    2837         872 :         return_value = _readInferenceElem();
    2838     9183622 :     else if (MATCH("TARGETENTRY", 11))
    2839     4915776 :         return_value = _readTargetEntry();
    2840     4267846 :     else if (MATCH("RANGETBLREF", 11))
    2841      657892 :         return_value = _readRangeTblRef();
    2842     3609954 :     else if (MATCH("JOINEXPR", 8))
    2843      136646 :         return_value = _readJoinExpr();
    2844     3473308 :     else if (MATCH("FROMEXPR", 8))
    2845      565250 :         return_value = _readFromExpr();
    2846     2908058 :     else if (MATCH("ONCONFLICTEXPR", 14))
    2847         932 :         return_value = _readOnConflictExpr();
    2848     2907126 :     else if (MATCH("APPENDRELINFO", 13))
    2849       26054 :         return_value = _readAppendRelInfo();
    2850     2881072 :     else if (MATCH("RANGETBLENTRY", 13))
    2851     1649486 :         return_value = _readRangeTblEntry();
    2852     1231586 :     else if (MATCH("RANGETBLFUNCTION", 16))
    2853       76104 :         return_value = _readRangeTblFunction();
    2854     1155482 :     else if (MATCH("TABLESAMPLECLAUSE", 17))
    2855         376 :         return_value = _readTableSampleClause();
    2856     1155106 :     else if (MATCH("NOTIFYSTMT", 10))
    2857          52 :         return_value = _readNotifyStmt();
    2858     1155054 :     else if (MATCH("DEFELEM", 7))
    2859           8 :         return_value = _readDefElem();
    2860     1155046 :     else if (MATCH("DECLARECURSORSTMT", 17))
    2861           0 :         return_value = _readDeclareCursorStmt();
    2862     1155046 :     else if (MATCH("PLANNEDSTMT", 11))
    2863      279834 :         return_value = _readPlannedStmt();
    2864      875212 :     else if (MATCH("PLAN", 4))
    2865           0 :         return_value = _readPlan();
    2866      875212 :     else if (MATCH("RESULT", 6))
    2867      141308 :         return_value = _readResult();
    2868      733904 :     else if (MATCH("PROJECTSET", 10))
    2869        4262 :         return_value = _readProjectSet();
    2870      729642 :     else if (MATCH("MODIFYTABLE", 11))
    2871       76300 :         return_value = _readModifyTable();
    2872      653342 :     else if (MATCH("APPEND", 6))
    2873        8354 :         return_value = _readAppend();
    2874      644988 :     else if (MATCH("MERGEAPPEND", 11))
    2875         248 :         return_value = _readMergeAppend();
    2876      644740 :     else if (MATCH("RECURSIVEUNION", 14))
    2877         454 :         return_value = _readRecursiveUnion();
    2878      644286 :     else if (MATCH("BITMAPAND", 9))
    2879          60 :         return_value = _readBitmapAnd();
    2880      644226 :     else if (MATCH("BITMAPOR", 8))
    2881         152 :         return_value = _readBitmapOr();
    2882      644074 :     else if (MATCH("SCAN", 4))
    2883           0 :         return_value = _readScan();
    2884      644074 :     else if (MATCH("SEQSCAN", 7))
    2885      121348 :         return_value = _readSeqScan();
    2886      522726 :     else if (MATCH("SAMPLESCAN", 10))
    2887         180 :         return_value = _readSampleScan();
    2888      522546 :     else if (MATCH("INDEXSCAN", 9))
    2889       69642 :         return_value = _readIndexScan();
    2890      452904 :     else if (MATCH("INDEXONLYSCAN", 13))
    2891        8726 :         return_value = _readIndexOnlyScan();
    2892      444178 :     else if (MATCH("BITMAPINDEXSCAN", 15))
    2893       15648 :         return_value = _readBitmapIndexScan();
    2894      428530 :     else if (MATCH("BITMAPHEAPSCAN", 14))
    2895       15400 :         return_value = _readBitmapHeapScan();
    2896      413130 :     else if (MATCH("TIDSCAN", 7))
    2897         476 :         return_value = _readTidScan();
    2898      412654 :     else if (MATCH("TIDRANGESCAN", 12))
    2899         136 :         return_value = _readTidRangeScan();
    2900      412518 :     else if (MATCH("SUBQUERYSCAN", 12))
    2901        3190 :         return_value = _readSubqueryScan();
    2902      409328 :     else if (MATCH("FUNCTIONSCAN", 12))
    2903       24458 :         return_value = _readFunctionScan();
    2904      384870 :     else if (MATCH("VALUESSCAN", 10))
    2905        4740 :         return_value = _readValuesScan();
    2906      380130 :     else if (MATCH("TABLEFUNCSCAN", 13))
    2907         144 :         return_value = _readTableFuncScan();
    2908      379986 :     else if (MATCH("CTESCAN", 7))
    2909        1702 :         return_value = _readCteScan();
    2910      378284 :     else if (MATCH("NAMEDTUPLESTORESCAN", 19))
    2911         284 :         return_value = _readNamedTuplestoreScan();
    2912      378000 :     else if (MATCH("WORKTABLESCAN", 13))
    2913         454 :         return_value = _readWorkTableScan();
    2914      377546 :     else if (MATCH("FOREIGNSCAN", 11))
    2915        1710 :         return_value = _readForeignScan();
    2916      375836 :     else if (MATCH("CUSTOMSCAN", 10))
    2917           0 :         return_value = _readCustomScan();
    2918      375836 :     else if (MATCH("JOIN", 4))
    2919           0 :         return_value = _readJoin();
    2920      375836 :     else if (MATCH("NESTLOOP", 8))
    2921       40558 :         return_value = _readNestLoop();
    2922      335278 :     else if (MATCH("MERGEJOIN", 9))
    2923        2716 :         return_value = _readMergeJoin();
    2924      332562 :     else if (MATCH("HASHJOIN", 8))
    2925       17130 :         return_value = _readHashJoin();
    2926      315432 :     else if (MATCH("MATERIAL", 8))
    2927        2346 :         return_value = _readMaterial();
    2928      313086 :     else if (MATCH("MEMOIZE", 7))
    2929         674 :         return_value = _readMemoize();
    2930      312412 :     else if (MATCH("SORT", 4))
    2931       30746 :         return_value = _readSort();
    2932      281666 :     else if (MATCH("INCREMENTALSORT", 15))
    2933         252 :         return_value = _readIncrementalSort();
    2934      281414 :     else if (MATCH("GROUP", 5))
    2935         152 :         return_value = _readGroup();
    2936      281262 :     else if (MATCH("AGG", 3))
    2937       24948 :         return_value = _readAgg();
    2938      256314 :     else if (MATCH("WINDOWAGG", 9))
    2939        1236 :         return_value = _readWindowAgg();
    2940      255078 :     else if (MATCH("UNIQUE", 6))
    2941         672 :         return_value = _readUnique();
    2942      254406 :     else if (MATCH("GATHER", 6))
    2943         598 :         return_value = _readGather();
    2944      253808 :     else if (MATCH("GATHERMERGE", 11))
    2945         180 :         return_value = _readGatherMerge();
    2946      253628 :     else if (MATCH("HASH", 4))
    2947       17130 :         return_value = _readHash();
    2948      236498 :     else if (MATCH("SETOP", 5))
    2949         340 :         return_value = _readSetOp();
    2950      236158 :     else if (MATCH("LOCKROWS", 8))
    2951        5152 :         return_value = _readLockRows();
    2952      231006 :     else if (MATCH("LIMIT", 5))
    2953        3494 :         return_value = _readLimit();
    2954      227512 :     else if (MATCH("NESTLOOPPARAM", 13))
    2955       21952 :         return_value = _readNestLoopParam();
    2956      205560 :     else if (MATCH("PLANROWMARK", 11))
    2957       14936 :         return_value = _readPlanRowMark();
    2958      190624 :     else if (MATCH("PARTITIONPRUNEINFO", 18))
    2959         372 :         return_value = _readPartitionPruneInfo();
    2960      190252 :     else if (MATCH("PARTITIONEDRELPRUNEINFO", 23))
    2961         820 :         return_value = _readPartitionedRelPruneInfo();
    2962      189432 :     else if (MATCH("PARTITIONPRUNESTEPOP", 20))
    2963         682 :         return_value = _readPartitionPruneStepOp();
    2964      188750 :     else if (MATCH("PARTITIONPRUNESTEPCOMBINE", 25))
    2965         146 :         return_value = _readPartitionPruneStepCombine();
    2966      188604 :     else if (MATCH("PLANINVALITEM", 13))
    2967      110104 :         return_value = _readPlanInvalItem();
    2968       78500 :     else if (MATCH("SUBPLAN", 7))
    2969       28084 :         return_value = _readSubPlan();
    2970       50416 :     else if (MATCH("ALTERNATIVESUBPLAN", 18))
    2971           0 :         return_value = _readAlternativeSubPlan();
    2972       50416 :     else if (MATCH("EXTENSIBLENODE", 14))
    2973           0 :         return_value = _readExtensibleNode();
    2974       50416 :     else if (MATCH("PARTITIONBOUNDSPEC", 18))
    2975       23128 :         return_value = _readPartitionBoundSpec();
    2976       27288 :     else if (MATCH("PARTITIONRANGEDATUM", 19))
    2977       27288 :         return_value = _readPartitionRangeDatum();
    2978             :     else
    2979             :     {
    2980           0 :         elog(ERROR, "badly formatted node string \"%.32s\"...", token);
    2981             :         return_value = NULL;    /* keep compiler quiet */
    2982             :     }
    2983             : 
    2984    32230998 :     return (Node *) return_value;
    2985             : }
    2986             : 
    2987             : 
    2988             : /*
    2989             :  * readDatum
    2990             :  *
    2991             :  * Given a string representation of a constant, recreate the appropriate
    2992             :  * Datum.  The string representation embeds length info, but not byValue,
    2993             :  * so we must be told that.
    2994             :  */
    2995             : Datum
    2996     2429576 : readDatum(bool typbyval)
    2997             : {
    2998             :     Size        length,
    2999             :                 i;
    3000             :     int         tokenLength;
    3001             :     const char *token;
    3002             :     Datum       res;
    3003             :     char       *s;
    3004             : 
    3005             :     /*
    3006             :      * read the actual length of the value
    3007             :      */
    3008     2429576 :     token = pg_strtok(&tokenLength);
    3009     2429576 :     length = atoui(token);
    3010             : 
    3011     2429576 :     token = pg_strtok(&tokenLength);    /* read the '[' */
    3012     2429576 :     if (token == NULL || token[0] != '[')
    3013           0 :         elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
    3014             :              token ? token : "[NULL]", length);
    3015             : 
    3016     2429576 :     if (typbyval)
    3017             :     {
    3018     1574242 :         if (length > (Size) sizeof(Datum))
    3019           0 :             elog(ERROR, "byval datum but length = %zu", length);
    3020     1574242 :         res = (Datum) 0;
    3021     1574242 :         s = (char *) (&res);
    3022    14168178 :         for (i = 0; i < (Size) sizeof(Datum); i++)
    3023             :         {
    3024    12593936 :             token = pg_strtok(&tokenLength);
    3025    12593936 :             s[i] = (char) atoi(token);
    3026             :         }
    3027             :     }
    3028      855334 :     else if (length <= 0)
    3029           0 :         res = (Datum) NULL;
    3030             :     else
    3031             :     {
    3032      855334 :         s = (char *) palloc(length);
    3033    47672656 :         for (i = 0; i < length; i++)
    3034             :         {
    3035    46817322 :             token = pg_strtok(&tokenLength);
    3036    46817322 :             s[i] = (char) atoi(token);
    3037             :         }
    3038      855334 :         res = PointerGetDatum(s);
    3039             :     }
    3040             : 
    3041     2429576 :     token = pg_strtok(&tokenLength);    /* read the ']' */
    3042     2429576 :     if (token == NULL || token[0] != ']')
    3043           0 :         elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
    3044             :              token ? token : "[NULL]", length);
    3045             : 
    3046     2429576 :     return res;
    3047             : }
    3048             : 
    3049             : /*
    3050             :  * readAttrNumberCols
    3051             :  */
    3052             : AttrNumber *
    3053       90012 : readAttrNumberCols(int numCols)
    3054             : {
    3055             :     int         tokenLength,
    3056             :                 i;
    3057             :     const char *token;
    3058             :     AttrNumber *attr_vals;
    3059             : 
    3060       90012 :     if (numCols <= 0)
    3061       23246 :         return NULL;
    3062             : 
    3063       66766 :     attr_vals = (AttrNumber *) palloc(numCols * sizeof(AttrNumber));
    3064      198150 :     for (i = 0; i < numCols; i++)
    3065             :     {
    3066      131384 :         token = pg_strtok(&tokenLength);
    3067      131384 :         attr_vals[i] = atoi(token);
    3068             :     }
    3069             : 
    3070       66766 :     return attr_vals;
    3071             : }
    3072             : 
    3073             : /*
    3074             :  * readOidCols
    3075             :  */
    3076             : Oid *
    3077      135516 : readOidCols(int numCols)
    3078             : {
    3079             :     int         tokenLength,
    3080             :                 i;
    3081             :     const char *token;
    3082             :     Oid        *oid_vals;
    3083             : 
    3084      135516 :     if (numCols <= 0)
    3085       46488 :         return NULL;
    3086             : 
    3087       89028 :     oid_vals = (Oid *) palloc(numCols * sizeof(Oid));
    3088      214194 :     for (i = 0; i < numCols; i++)
    3089             :     {
    3090      125166 :         token = pg_strtok(&tokenLength);
    3091      125166 :         oid_vals[i] = atooid(token);
    3092             :     }
    3093             : 
    3094       89028 :     return oid_vals;
    3095             : }
    3096             : 
    3097             : /*
    3098             :  * readIntCols
    3099             :  */
    3100             : int *
    3101        4356 : readIntCols(int numCols)
    3102             : {
    3103             :     int         tokenLength,
    3104             :                 i;
    3105             :     const char *token;
    3106             :     int        *int_vals;
    3107             : 
    3108        4356 :     if (numCols <= 0)
    3109          14 :         return NULL;
    3110             : 
    3111        4342 :     int_vals = (int *) palloc(numCols * sizeof(int));
    3112       12434 :     for (i = 0; i < numCols; i++)
    3113             :     {
    3114        8092 :         token = pg_strtok(&tokenLength);
    3115        8092 :         int_vals[i] = atoi(token);
    3116             :     }
    3117             : 
    3118        4342 :     return int_vals;
    3119             : }
    3120             : 
    3121             : /*
    3122             :  * readBoolCols
    3123             :  */
    3124             : bool *
    3125       34142 : readBoolCols(int numCols)
    3126             : {
    3127             :     int         tokenLength,
    3128             :                 i;
    3129             :     const char *token;
    3130             :     bool       *bool_vals;
    3131             : 
    3132       34142 :     if (numCols <= 0)
    3133          14 :         return NULL;
    3134             : 
    3135       34128 :     bool_vals = (bool *) palloc(numCols * sizeof(bool));
    3136       81756 :     for (i = 0; i < numCols; i++)
    3137             :     {
    3138       47628 :         token = pg_strtok(&tokenLength);
    3139       47628 :         bool_vals[i] = strtobool(token);
    3140             :     }
    3141             : 
    3142       34128 :     return bool_vals;
    3143             : }

Generated by: LCOV version 1.14