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

Generated by: LCOV version 1.13