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

Generated by: LCOV version 1.13