LCOV - code coverage report
Current view: top level - src/backend/nodes - readfuncs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 12beta2 Lines: 1364 1460 93.4 %
Date: 2019-06-19 16:07:09 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     7321956 : _readBitmapset(void)
     198             : {
     199     7321956 :     Bitmapset  *result = NULL;
     200             : 
     201             :     READ_TEMP_LOCALS();
     202             : 
     203     7321956 :     token = pg_strtok(&length);
     204     7321956 :     if (token == NULL)
     205           0 :         elog(ERROR, "incomplete Bitmapset structure");
     206     7321956 :     if (length != 1 || token[0] != '(')
     207           0 :         elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
     208             : 
     209     7321956 :     token = pg_strtok(&length);
     210     7321956 :     if (token == NULL)
     211           0 :         elog(ERROR, "incomplete Bitmapset structure");
     212     7321956 :     if (length != 1 || token[0] != 'b')
     213           0 :         elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
     214             : 
     215             :     for (;;)
     216     3388920 :     {
     217             :         int         val;
     218             :         char       *endptr;
     219             : 
     220    10710876 :         token = pg_strtok(&length);
     221    10710876 :         if (token == NULL)
     222           0 :             elog(ERROR, "unterminated Bitmapset structure");
     223    10710876 :         if (length == 1 && token[0] == ')')
     224     7321956 :             break;
     225     3388920 :         val = (int) strtol(token, &endptr, 10);
     226     3388920 :         if (endptr != token + length)
     227           0 :             elog(ERROR, "unrecognized integer: \"%.*s\"", length, token);
     228     3388920 :         result = bms_add_member(result, val);
     229             :     }
     230             : 
     231    14643912 :     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      441444 : _readQuery(void)
     248             : {
     249      441444 :     READ_LOCALS(Query);
     250             : 
     251      441444 :     READ_ENUM_FIELD(commandType, CmdType);
     252      441444 :     READ_ENUM_FIELD(querySource, QuerySource);
     253      441444 :     local_node->queryId = UINT64CONST(0);    /* not saved in output format */
     254      441444 :     READ_BOOL_FIELD(canSetTag);
     255      441444 :     READ_NODE_FIELD(utilityStmt);
     256      441444 :     READ_INT_FIELD(resultRelation);
     257      441444 :     READ_BOOL_FIELD(hasAggs);
     258      441444 :     READ_BOOL_FIELD(hasWindowFuncs);
     259      441444 :     READ_BOOL_FIELD(hasTargetSRFs);
     260      441444 :     READ_BOOL_FIELD(hasSubLinks);
     261      441444 :     READ_BOOL_FIELD(hasDistinctOn);
     262      441444 :     READ_BOOL_FIELD(hasRecursive);
     263      441444 :     READ_BOOL_FIELD(hasModifyingCTE);
     264      441444 :     READ_BOOL_FIELD(hasForUpdate);
     265      441444 :     READ_BOOL_FIELD(hasRowSecurity);
     266      441444 :     READ_NODE_FIELD(cteList);
     267      441444 :     READ_NODE_FIELD(rtable);
     268      441444 :     READ_NODE_FIELD(jointree);
     269      441444 :     READ_NODE_FIELD(targetList);
     270      441444 :     READ_ENUM_FIELD(override, OverridingKind);
     271      441444 :     READ_NODE_FIELD(onConflict);
     272      441444 :     READ_NODE_FIELD(returningList);
     273      441444 :     READ_NODE_FIELD(groupClause);
     274      441444 :     READ_NODE_FIELD(groupingSets);
     275      441444 :     READ_NODE_FIELD(havingQual);
     276      441444 :     READ_NODE_FIELD(windowClause);
     277      441444 :     READ_NODE_FIELD(distinctClause);
     278      441444 :     READ_NODE_FIELD(sortClause);
     279      441444 :     READ_NODE_FIELD(limitOffset);
     280      441444 :     READ_NODE_FIELD(limitCount);
     281      441444 :     READ_NODE_FIELD(rowMarks);
     282      441444 :     READ_NODE_FIELD(setOperations);
     283      441444 :     READ_NODE_FIELD(constraintDeps);
     284      441444 :     READ_NODE_FIELD(withCheckOptions);
     285      441444 :     READ_LOCATION_FIELD(stmt_location);
     286      441444 :     READ_LOCATION_FIELD(stmt_len);
     287             : 
     288      441444 :     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        2200 : _readWithCheckOption(void)
     325             : {
     326        2200 :     READ_LOCALS(WithCheckOption);
     327             : 
     328        2200 :     READ_ENUM_FIELD(kind, WCOKind);
     329        2200 :     READ_STRING_FIELD(relname);
     330        2200 :     READ_STRING_FIELD(polname);
     331        2200 :     READ_NODE_FIELD(qual);
     332        2200 :     READ_BOOL_FIELD(cascaded);
     333             : 
     334        2200 :     READ_DONE();
     335             : }
     336             : 
     337             : /*
     338             :  * _readSortGroupClause
     339             :  */
     340             : static SortGroupClause *
     341       96634 : _readSortGroupClause(void)
     342             : {
     343       96634 :     READ_LOCALS(SortGroupClause);
     344             : 
     345       96634 :     READ_UINT_FIELD(tleSortGroupRef);
     346       96634 :     READ_OID_FIELD(eqop);
     347       96634 :     READ_OID_FIELD(sortop);
     348       96634 :     READ_BOOL_FIELD(nulls_first);
     349       96634 :     READ_BOOL_FIELD(hashable);
     350             : 
     351       96634 :     READ_DONE();
     352             : }
     353             : 
     354             : /*
     355             :  * _readGroupingSet
     356             :  */
     357             : static GroupingSet *
     358        1098 : _readGroupingSet(void)
     359             : {
     360        1098 :     READ_LOCALS(GroupingSet);
     361             : 
     362        1098 :     READ_ENUM_FIELD(kind, GroupingSetKind);
     363        1098 :     READ_NODE_FIELD(content);
     364        1098 :     READ_LOCATION_FIELD(location);
     365             : 
     366        1098 :     READ_DONE();
     367             : }
     368             : 
     369             : /*
     370             :  * _readWindowClause
     371             :  */
     372             : static WindowClause *
     373        1452 : _readWindowClause(void)
     374             : {
     375        1452 :     READ_LOCALS(WindowClause);
     376             : 
     377        1452 :     READ_STRING_FIELD(name);
     378        1452 :     READ_STRING_FIELD(refname);
     379        1452 :     READ_NODE_FIELD(partitionClause);
     380        1452 :     READ_NODE_FIELD(orderClause);
     381        1452 :     READ_INT_FIELD(frameOptions);
     382        1452 :     READ_NODE_FIELD(startOffset);
     383        1452 :     READ_NODE_FIELD(endOffset);
     384        1452 :     READ_OID_FIELD(startInRangeFunc);
     385        1452 :     READ_OID_FIELD(endInRangeFunc);
     386        1452 :     READ_OID_FIELD(inRangeColl);
     387        1452 :     READ_BOOL_FIELD(inRangeAsc);
     388        1452 :     READ_BOOL_FIELD(inRangeNullsFirst);
     389        1452 :     READ_UINT_FIELD(winref);
     390        1452 :     READ_BOOL_FIELD(copiedOrder);
     391             : 
     392        1452 :     READ_DONE();
     393             : }
     394             : 
     395             : /*
     396             :  * _readRowMarkClause
     397             :  */
     398             : static RowMarkClause *
     399        3282 : _readRowMarkClause(void)
     400             : {
     401        3282 :     READ_LOCALS(RowMarkClause);
     402             : 
     403        3282 :     READ_UINT_FIELD(rti);
     404        3282 :     READ_ENUM_FIELD(strength, LockClauseStrength);
     405        3282 :     READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
     406        3282 :     READ_BOOL_FIELD(pushedDown);
     407             : 
     408        3282 :     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       20480 : _readSetOperationStmt(void)
     439             : {
     440       20480 :     READ_LOCALS(SetOperationStmt);
     441             : 
     442       20480 :     READ_ENUM_FIELD(op, SetOperation);
     443       20480 :     READ_BOOL_FIELD(all);
     444       20480 :     READ_NODE_FIELD(larg);
     445       20480 :     READ_NODE_FIELD(rarg);
     446       20480 :     READ_NODE_FIELD(colTypes);
     447       20480 :     READ_NODE_FIELD(colTypmods);
     448       20480 :     READ_NODE_FIELD(colCollations);
     449       20480 :     READ_NODE_FIELD(groupClauses);
     450             : 
     451       20480 :     READ_DONE();
     452             : }
     453             : 
     454             : 
     455             : /*
     456             :  *  Stuff from primnodes.h.
     457             :  */
     458             : 
     459             : static Alias *
     460     2121686 : _readAlias(void)
     461             : {
     462     2121686 :     READ_LOCALS(Alias);
     463             : 
     464     2121686 :     READ_STRING_FIELD(aliasname);
     465     2121686 :     READ_NODE_FIELD(colnames);
     466             : 
     467     2121686 :     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    10694078 : _readVar(void)
     534             : {
     535    10694078 :     READ_LOCALS(Var);
     536             : 
     537    10694078 :     READ_UINT_FIELD(varno);
     538    10694078 :     READ_INT_FIELD(varattno);
     539    10694078 :     READ_OID_FIELD(vartype);
     540    10694078 :     READ_INT_FIELD(vartypmod);
     541    10694078 :     READ_OID_FIELD(varcollid);
     542    10694078 :     READ_UINT_FIELD(varlevelsup);
     543    10694078 :     READ_UINT_FIELD(varnoold);
     544    10694078 :     READ_INT_FIELD(varoattno);
     545    10694078 :     READ_LOCATION_FIELD(location);
     546             : 
     547    10694078 :     READ_DONE();
     548             : }
     549             : 
     550             : /*
     551             :  * _readConst
     552             :  */
     553             : static Const *
     554     2047690 : _readConst(void)
     555             : {
     556     2047690 :     READ_LOCALS(Const);
     557             : 
     558     2047690 :     READ_OID_FIELD(consttype);
     559     2047690 :     READ_INT_FIELD(consttypmod);
     560     2047690 :     READ_OID_FIELD(constcollid);
     561     2047690 :     READ_INT_FIELD(constlen);
     562     2047690 :     READ_BOOL_FIELD(constbyval);
     563     2047690 :     READ_BOOL_FIELD(constisnull);
     564     2047690 :     READ_LOCATION_FIELD(location);
     565             : 
     566     2047690 :     token = pg_strtok(&length); /* skip :constvalue */
     567     2047690 :     if (local_node->constisnull)
     568      246770 :         token = pg_strtok(&length); /* skip "<>" */
     569             :     else
     570     1800920 :         local_node->constvalue = readDatum(local_node->constbyval);
     571             : 
     572     2047690 :     READ_DONE();
     573             : }
     574             : 
     575             : /*
     576             :  * _readParam
     577             :  */
     578             : static Param *
     579      192138 : _readParam(void)
     580             : {
     581      192138 :     READ_LOCALS(Param);
     582             : 
     583      192138 :     READ_ENUM_FIELD(paramkind, ParamKind);
     584      192138 :     READ_INT_FIELD(paramid);
     585      192138 :     READ_OID_FIELD(paramtype);
     586      192138 :     READ_INT_FIELD(paramtypmod);
     587      192138 :     READ_OID_FIELD(paramcollid);
     588      192138 :     READ_LOCATION_FIELD(location);
     589             : 
     590      192138 :     READ_DONE();
     591             : }
     592             : 
     593             : /*
     594             :  * _readAggref
     595             :  */
     596             : static Aggref *
     597       57038 : _readAggref(void)
     598             : {
     599       57038 :     READ_LOCALS(Aggref);
     600             : 
     601       57038 :     READ_OID_FIELD(aggfnoid);
     602       57038 :     READ_OID_FIELD(aggtype);
     603       57038 :     READ_OID_FIELD(aggcollid);
     604       57038 :     READ_OID_FIELD(inputcollid);
     605       57038 :     READ_OID_FIELD(aggtranstype);
     606       57038 :     READ_NODE_FIELD(aggargtypes);
     607       57038 :     READ_NODE_FIELD(aggdirectargs);
     608       57038 :     READ_NODE_FIELD(args);
     609       57038 :     READ_NODE_FIELD(aggorder);
     610       57038 :     READ_NODE_FIELD(aggdistinct);
     611       57038 :     READ_NODE_FIELD(aggfilter);
     612       57038 :     READ_BOOL_FIELD(aggstar);
     613       57038 :     READ_BOOL_FIELD(aggvariadic);
     614       57038 :     READ_CHAR_FIELD(aggkind);
     615       57038 :     READ_UINT_FIELD(agglevelsup);
     616       57038 :     READ_ENUM_FIELD(aggsplit, AggSplit);
     617       57038 :     READ_LOCATION_FIELD(location);
     618             : 
     619       57038 :     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        3056 : _readWindowFunc(void)
     644             : {
     645        3056 :     READ_LOCALS(WindowFunc);
     646             : 
     647        3056 :     READ_OID_FIELD(winfnoid);
     648        3056 :     READ_OID_FIELD(wintype);
     649        3056 :     READ_OID_FIELD(wincollid);
     650        3056 :     READ_OID_FIELD(inputcollid);
     651        3056 :     READ_NODE_FIELD(args);
     652        3056 :     READ_NODE_FIELD(aggfilter);
     653        3056 :     READ_UINT_FIELD(winref);
     654        3056 :     READ_BOOL_FIELD(winstar);
     655        3056 :     READ_BOOL_FIELD(winagg);
     656        3056 :     READ_LOCATION_FIELD(location);
     657             : 
     658        3056 :     READ_DONE();
     659             : }
     660             : 
     661             : /*
     662             :  * _readSubscriptingRef
     663             :  */
     664             : static SubscriptingRef *
     665       11678 : _readSubscriptingRef(void)
     666             : {
     667       11678 :     READ_LOCALS(SubscriptingRef);
     668             : 
     669       11678 :     READ_OID_FIELD(refcontainertype);
     670       11678 :     READ_OID_FIELD(refelemtype);
     671       11678 :     READ_INT_FIELD(reftypmod);
     672       11678 :     READ_OID_FIELD(refcollid);
     673       11678 :     READ_NODE_FIELD(refupperindexpr);
     674       11678 :     READ_NODE_FIELD(reflowerindexpr);
     675       11678 :     READ_NODE_FIELD(refexpr);
     676       11678 :     READ_NODE_FIELD(refassgnexpr);
     677             : 
     678       11678 :     READ_DONE();
     679             : }
     680             : 
     681             : /*
     682             :  * _readFuncExpr
     683             :  */
     684             : static FuncExpr *
     685      778978 : _readFuncExpr(void)
     686             : {
     687      778978 :     READ_LOCALS(FuncExpr);
     688             : 
     689      778978 :     READ_OID_FIELD(funcid);
     690      778978 :     READ_OID_FIELD(funcresulttype);
     691      778978 :     READ_BOOL_FIELD(funcretset);
     692      778978 :     READ_BOOL_FIELD(funcvariadic);
     693      778978 :     READ_ENUM_FIELD(funcformat, CoercionForm);
     694      778978 :     READ_OID_FIELD(funccollid);
     695      778978 :     READ_OID_FIELD(inputcollid);
     696      778978 :     READ_NODE_FIELD(args);
     697      778978 :     READ_LOCATION_FIELD(location);
     698             : 
     699      778978 :     READ_DONE();
     700             : }
     701             : 
     702             : /*
     703             :  * _readNamedArgExpr
     704             :  */
     705             : static NamedArgExpr *
     706         728 : _readNamedArgExpr(void)
     707             : {
     708         728 :     READ_LOCALS(NamedArgExpr);
     709             : 
     710         728 :     READ_NODE_FIELD(arg);
     711         728 :     READ_STRING_FIELD(name);
     712         728 :     READ_INT_FIELD(argnumber);
     713         728 :     READ_LOCATION_FIELD(location);
     714             : 
     715         728 :     READ_DONE();
     716             : }
     717             : 
     718             : /*
     719             :  * _readOpExpr
     720             :  */
     721             : static OpExpr *
     722     1007550 : _readOpExpr(void)
     723             : {
     724     1007550 :     READ_LOCALS(OpExpr);
     725             : 
     726     1007550 :     READ_OID_FIELD(opno);
     727     1007550 :     READ_OID_FIELD(opfuncid);
     728     1007550 :     READ_OID_FIELD(opresulttype);
     729     1007550 :     READ_BOOL_FIELD(opretset);
     730     1007550 :     READ_OID_FIELD(opcollid);
     731     1007550 :     READ_OID_FIELD(inputcollid);
     732     1007550 :     READ_NODE_FIELD(args);
     733     1007550 :     READ_LOCATION_FIELD(location);
     734             : 
     735     1007550 :     READ_DONE();
     736             : }
     737             : 
     738             : /*
     739             :  * _readDistinctExpr
     740             :  */
     741             : static DistinctExpr *
     742         930 : _readDistinctExpr(void)
     743             : {
     744         930 :     READ_LOCALS(DistinctExpr);
     745             : 
     746         930 :     READ_OID_FIELD(opno);
     747         930 :     READ_OID_FIELD(opfuncid);
     748         930 :     READ_OID_FIELD(opresulttype);
     749         930 :     READ_BOOL_FIELD(opretset);
     750         930 :     READ_OID_FIELD(opcollid);
     751         930 :     READ_OID_FIELD(inputcollid);
     752         930 :     READ_NODE_FIELD(args);
     753         930 :     READ_LOCATION_FIELD(location);
     754             : 
     755         930 :     READ_DONE();
     756             : }
     757             : 
     758             : /*
     759             :  * _readNullIfExpr
     760             :  */
     761             : static NullIfExpr *
     762         768 : _readNullIfExpr(void)
     763             : {
     764         768 :     READ_LOCALS(NullIfExpr);
     765             : 
     766         768 :     READ_OID_FIELD(opno);
     767         768 :     READ_OID_FIELD(opfuncid);
     768         768 :     READ_OID_FIELD(opresulttype);
     769         768 :     READ_BOOL_FIELD(opretset);
     770         768 :     READ_OID_FIELD(opcollid);
     771         768 :     READ_OID_FIELD(inputcollid);
     772         768 :     READ_NODE_FIELD(args);
     773         768 :     READ_LOCATION_FIELD(location);
     774             : 
     775         768 :     READ_DONE();
     776             : }
     777             : 
     778             : /*
     779             :  * _readScalarArrayOpExpr
     780             :  */
     781             : static ScalarArrayOpExpr *
     782       60930 : _readScalarArrayOpExpr(void)
     783             : {
     784       60930 :     READ_LOCALS(ScalarArrayOpExpr);
     785             : 
     786       60930 :     READ_OID_FIELD(opno);
     787       60930 :     READ_OID_FIELD(opfuncid);
     788       60930 :     READ_BOOL_FIELD(useOr);
     789       60930 :     READ_OID_FIELD(inputcollid);
     790       60930 :     READ_NODE_FIELD(args);
     791       60930 :     READ_LOCATION_FIELD(location);
     792             : 
     793       60930 :     READ_DONE();
     794             : }
     795             : 
     796             : /*
     797             :  * _readBoolExpr
     798             :  */
     799             : static BoolExpr *
     800      212486 : _readBoolExpr(void)
     801             : {
     802      212486 :     READ_LOCALS(BoolExpr);
     803             : 
     804             :     /* do-it-yourself enum representation */
     805      212486 :     token = pg_strtok(&length); /* skip :boolop */
     806      212486 :     token = pg_strtok(&length); /* get field value */
     807      212486 :     if (strncmp(token, "and", 3) == 0)
     808      132062 :         local_node->boolop = AND_EXPR;
     809       80424 :     else if (strncmp(token, "or", 2) == 0)
     810       40032 :         local_node->boolop = OR_EXPR;
     811       40392 :     else if (strncmp(token, "not", 3) == 0)
     812       40392 :         local_node->boolop = NOT_EXPR;
     813             :     else
     814           0 :         elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
     815             : 
     816      212486 :     READ_NODE_FIELD(args);
     817      212486 :     READ_LOCATION_FIELD(location);
     818             : 
     819      212486 :     READ_DONE();
     820             : }
     821             : 
     822             : /*
     823             :  * _readSubLink
     824             :  */
     825             : static SubLink *
     826       62264 : _readSubLink(void)
     827             : {
     828       62264 :     READ_LOCALS(SubLink);
     829             : 
     830       62264 :     READ_ENUM_FIELD(subLinkType, SubLinkType);
     831       62264 :     READ_INT_FIELD(subLinkId);
     832       62264 :     READ_NODE_FIELD(testexpr);
     833       62264 :     READ_NODE_FIELD(operName);
     834       62264 :     READ_NODE_FIELD(subselect);
     835       62264 :     READ_LOCATION_FIELD(location);
     836             : 
     837       62264 :     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       39068 : _readFieldSelect(void)
     849             : {
     850       39068 :     READ_LOCALS(FieldSelect);
     851             : 
     852       39068 :     READ_NODE_FIELD(arg);
     853       39068 :     READ_INT_FIELD(fieldnum);
     854       39068 :     READ_OID_FIELD(resulttype);
     855       39068 :     READ_INT_FIELD(resulttypmod);
     856       39068 :     READ_OID_FIELD(resultcollid);
     857             : 
     858       39068 :     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      146474 : _readRelabelType(void)
     882             : {
     883      146474 :     READ_LOCALS(RelabelType);
     884             : 
     885      146474 :     READ_NODE_FIELD(arg);
     886      146474 :     READ_OID_FIELD(resulttype);
     887      146474 :     READ_INT_FIELD(resulttypmod);
     888      146474 :     READ_OID_FIELD(resultcollid);
     889      146474 :     READ_ENUM_FIELD(relabelformat, CoercionForm);
     890      146474 :     READ_LOCATION_FIELD(location);
     891             : 
     892      146474 :     READ_DONE();
     893             : }
     894             : 
     895             : /*
     896             :  * _readCoerceViaIO
     897             :  */
     898             : static CoerceViaIO *
     899       25766 : _readCoerceViaIO(void)
     900             : {
     901       25766 :     READ_LOCALS(CoerceViaIO);
     902             : 
     903       25766 :     READ_NODE_FIELD(arg);
     904       25766 :     READ_OID_FIELD(resulttype);
     905       25766 :     READ_OID_FIELD(resultcollid);
     906       25766 :     READ_ENUM_FIELD(coerceformat, CoercionForm);
     907       25766 :     READ_LOCATION_FIELD(location);
     908             : 
     909       25766 :     READ_DONE();
     910             : }
     911             : 
     912             : /*
     913             :  * _readArrayCoerceExpr
     914             :  */
     915             : static ArrayCoerceExpr *
     916        3038 : _readArrayCoerceExpr(void)
     917             : {
     918        3038 :     READ_LOCALS(ArrayCoerceExpr);
     919             : 
     920        3038 :     READ_NODE_FIELD(arg);
     921        3038 :     READ_NODE_FIELD(elemexpr);
     922        3038 :     READ_OID_FIELD(resulttype);
     923        3038 :     READ_INT_FIELD(resulttypmod);
     924        3038 :     READ_OID_FIELD(resultcollid);
     925        3038 :     READ_ENUM_FIELD(coerceformat, CoercionForm);
     926        3038 :     READ_LOCATION_FIELD(location);
     927             : 
     928        3038 :     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        2366 : _readCollateExpr(void)
     952             : {
     953        2366 :     READ_LOCALS(CollateExpr);
     954             : 
     955        2366 :     READ_NODE_FIELD(arg);
     956        2366 :     READ_OID_FIELD(collOid);
     957        2366 :     READ_LOCATION_FIELD(location);
     958             : 
     959        2366 :     READ_DONE();
     960             : }
     961             : 
     962             : /*
     963             :  * _readCaseExpr
     964             :  */
     965             : static CaseExpr *
     966      103976 : _readCaseExpr(void)
     967             : {
     968      103976 :     READ_LOCALS(CaseExpr);
     969             : 
     970      103976 :     READ_OID_FIELD(casetype);
     971      103976 :     READ_OID_FIELD(casecollid);
     972      103976 :     READ_NODE_FIELD(arg);
     973      103976 :     READ_NODE_FIELD(args);
     974      103976 :     READ_NODE_FIELD(defresult);
     975      103976 :     READ_LOCATION_FIELD(location);
     976             : 
     977      103976 :     READ_DONE();
     978             : }
     979             : 
     980             : /*
     981             :  * _readCaseWhen
     982             :  */
     983             : static CaseWhen *
     984      153702 : _readCaseWhen(void)
     985             : {
     986      153702 :     READ_LOCALS(CaseWhen);
     987             : 
     988      153702 :     READ_NODE_FIELD(expr);
     989      153702 :     READ_NODE_FIELD(result);
     990      153702 :     READ_LOCATION_FIELD(location);
     991             : 
     992      153702 :     READ_DONE();
     993             : }
     994             : 
     995             : /*
     996             :  * _readCaseTestExpr
     997             :  */
     998             : static CaseTestExpr *
     999       37930 : _readCaseTestExpr(void)
    1000             : {
    1001       37930 :     READ_LOCALS(CaseTestExpr);
    1002             : 
    1003       37930 :     READ_OID_FIELD(typeId);
    1004       37930 :     READ_INT_FIELD(typeMod);
    1005       37930 :     READ_OID_FIELD(collation);
    1006             : 
    1007       37930 :     READ_DONE();
    1008             : }
    1009             : 
    1010             : /*
    1011             :  * _readArrayExpr
    1012             :  */
    1013             : static ArrayExpr *
    1014       35840 : _readArrayExpr(void)
    1015             : {
    1016       35840 :     READ_LOCALS(ArrayExpr);
    1017             : 
    1018       35840 :     READ_OID_FIELD(array_typeid);
    1019       35840 :     READ_OID_FIELD(array_collid);
    1020       35840 :     READ_OID_FIELD(element_typeid);
    1021       35840 :     READ_NODE_FIELD(elements);
    1022       35840 :     READ_BOOL_FIELD(multidims);
    1023       35840 :     READ_LOCATION_FIELD(location);
    1024             : 
    1025       35840 :     READ_DONE();
    1026             : }
    1027             : 
    1028             : /*
    1029             :  * _readRowExpr
    1030             :  */
    1031             : static RowExpr *
    1032        2812 : _readRowExpr(void)
    1033             : {
    1034        2812 :     READ_LOCALS(RowExpr);
    1035             : 
    1036        2812 :     READ_NODE_FIELD(args);
    1037        2812 :     READ_OID_FIELD(row_typeid);
    1038        2812 :     READ_ENUM_FIELD(row_format, CoercionForm);
    1039        2812 :     READ_NODE_FIELD(colnames);
    1040        2812 :     READ_LOCATION_FIELD(location);
    1041             : 
    1042        2812 :     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       50984 : _readCoalesceExpr(void)
    1068             : {
    1069       50984 :     READ_LOCALS(CoalesceExpr);
    1070             : 
    1071       50984 :     READ_OID_FIELD(coalescetype);
    1072       50984 :     READ_OID_FIELD(coalescecollid);
    1073       50984 :     READ_NODE_FIELD(args);
    1074       50984 :     READ_LOCATION_FIELD(location);
    1075             : 
    1076       50984 :     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        5450 : _readSQLValueFunction(void)
    1102             : {
    1103        5450 :     READ_LOCALS(SQLValueFunction);
    1104             : 
    1105        5450 :     READ_ENUM_FIELD(op, SQLValueFunctionOp);
    1106        5450 :     READ_OID_FIELD(type);
    1107        5450 :     READ_INT_FIELD(typmod);
    1108        5450 :     READ_LOCATION_FIELD(location);
    1109             : 
    1110        5450 :     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       25308 : _readNullTest(void)
    1139             : {
    1140       25308 :     READ_LOCALS(NullTest);
    1141             : 
    1142       25308 :     READ_NODE_FIELD(arg);
    1143       25308 :     READ_ENUM_FIELD(nulltesttype, NullTestType);
    1144       25308 :     READ_BOOL_FIELD(argisrow);
    1145       25308 :     READ_LOCATION_FIELD(location);
    1146             : 
    1147       25308 :     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      423276 : _readCoerceToDomain(void)
    1170             : {
    1171      423276 :     READ_LOCALS(CoerceToDomain);
    1172             : 
    1173      423276 :     READ_NODE_FIELD(arg);
    1174      423276 :     READ_OID_FIELD(resulttype);
    1175      423276 :     READ_INT_FIELD(resulttypmod);
    1176      423276 :     READ_OID_FIELD(resultcollid);
    1177      423276 :     READ_ENUM_FIELD(coercionformat, CoercionForm);
    1178      423276 :     READ_LOCATION_FIELD(location);
    1179             : 
    1180      423276 :     READ_DONE();
    1181             : }
    1182             : 
    1183             : /*
    1184             :  * _readCoerceToDomainValue
    1185             :  */
    1186             : static CoerceToDomainValue *
    1187        2570 : _readCoerceToDomainValue(void)
    1188             : {
    1189        2570 :     READ_LOCALS(CoerceToDomainValue);
    1190             : 
    1191        2570 :     READ_OID_FIELD(typeId);
    1192        2570 :     READ_INT_FIELD(typeMod);
    1193        2570 :     READ_OID_FIELD(collation);
    1194        2570 :     READ_LOCATION_FIELD(location);
    1195             : 
    1196        2570 :     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         276 : _readNextValueExpr(void)
    1235             : {
    1236         276 :     READ_LOCALS(NextValueExpr);
    1237             : 
    1238         276 :     READ_OID_FIELD(seqid);
    1239         276 :     READ_OID_FIELD(typeId);
    1240             : 
    1241         276 :     READ_DONE();
    1242             : }
    1243             : 
    1244             : /*
    1245             :  * _readInferenceElem
    1246             :  */
    1247             : static InferenceElem *
    1248         832 : _readInferenceElem(void)
    1249             : {
    1250         832 :     READ_LOCALS(InferenceElem);
    1251             : 
    1252         832 :     READ_NODE_FIELD(expr);
    1253         832 :     READ_OID_FIELD(infercollid);
    1254         832 :     READ_OID_FIELD(inferopclass);
    1255             : 
    1256         832 :     READ_DONE();
    1257             : }
    1258             : 
    1259             : /*
    1260             :  * _readTargetEntry
    1261             :  */
    1262             : static TargetEntry *
    1263     4821694 : _readTargetEntry(void)
    1264             : {
    1265     4821694 :     READ_LOCALS(TargetEntry);
    1266             : 
    1267     4821694 :     READ_NODE_FIELD(expr);
    1268     4821694 :     READ_INT_FIELD(resno);
    1269     4821694 :     READ_STRING_FIELD(resname);
    1270     4821694 :     READ_UINT_FIELD(ressortgroupref);
    1271     4821694 :     READ_OID_FIELD(resorigtbl);
    1272     4821694 :     READ_INT_FIELD(resorigcol);
    1273     4821694 :     READ_BOOL_FIELD(resjunk);
    1274             : 
    1275     4821694 :     READ_DONE();
    1276             : }
    1277             : 
    1278             : /*
    1279             :  * _readRangeTblRef
    1280             :  */
    1281             : static RangeTblRef *
    1282      518182 : _readRangeTblRef(void)
    1283             : {
    1284      518182 :     READ_LOCALS(RangeTblRef);
    1285             : 
    1286      518182 :     READ_INT_FIELD(rtindex);
    1287             : 
    1288      518182 :     READ_DONE();
    1289             : }
    1290             : 
    1291             : /*
    1292             :  * _readJoinExpr
    1293             :  */
    1294             : static JoinExpr *
    1295      109092 : _readJoinExpr(void)
    1296             : {
    1297      109092 :     READ_LOCALS(JoinExpr);
    1298             : 
    1299      109092 :     READ_ENUM_FIELD(jointype, JoinType);
    1300      109092 :     READ_BOOL_FIELD(isNatural);
    1301      109092 :     READ_NODE_FIELD(larg);
    1302      109092 :     READ_NODE_FIELD(rarg);
    1303      109092 :     READ_NODE_FIELD(usingClause);
    1304      109092 :     READ_NODE_FIELD(quals);
    1305      109092 :     READ_NODE_FIELD(alias);
    1306      109092 :     READ_INT_FIELD(rtindex);
    1307             : 
    1308      109092 :     READ_DONE();
    1309             : }
    1310             : 
    1311             : /*
    1312             :  * _readFromExpr
    1313             :  */
    1314             : static FromExpr *
    1315      441402 : _readFromExpr(void)
    1316             : {
    1317      441402 :     READ_LOCALS(FromExpr);
    1318             : 
    1319      441402 :     READ_NODE_FIELD(fromlist);
    1320      441402 :     READ_NODE_FIELD(quals);
    1321             : 
    1322      441402 :     READ_DONE();
    1323             : }
    1324             : 
    1325             : /*
    1326             :  * _readOnConflictExpr
    1327             :  */
    1328             : static OnConflictExpr *
    1329         892 : _readOnConflictExpr(void)
    1330             : {
    1331         892 :     READ_LOCALS(OnConflictExpr);
    1332             : 
    1333         892 :     READ_ENUM_FIELD(action, OnConflictAction);
    1334         892 :     READ_NODE_FIELD(arbiterElems);
    1335         892 :     READ_NODE_FIELD(arbiterWhere);
    1336         892 :     READ_OID_FIELD(constraint);
    1337         892 :     READ_NODE_FIELD(onConflictSet);
    1338         892 :     READ_NODE_FIELD(onConflictWhere);
    1339         892 :     READ_INT_FIELD(exclRelIndex);
    1340         892 :     READ_NODE_FIELD(exclRelTlist);
    1341             : 
    1342         892 :     READ_DONE();
    1343             : }
    1344             : 
    1345             : /*
    1346             :  *  Stuff from parsenodes.h.
    1347             :  */
    1348             : 
    1349             : /*
    1350             :  * _readRangeTblEntry
    1351             :  */
    1352             : static RangeTblEntry *
    1353     1412152 : _readRangeTblEntry(void)
    1354             : {
    1355     1412152 :     READ_LOCALS(RangeTblEntry);
    1356             : 
    1357             :     /* put alias + eref first to make dump more legible */
    1358     1412152 :     READ_NODE_FIELD(alias);
    1359     1412152 :     READ_NODE_FIELD(eref);
    1360     1412152 :     READ_ENUM_FIELD(rtekind, RTEKind);
    1361             : 
    1362     1412152 :     switch (local_node->rtekind)
    1363             :     {
    1364             :         case RTE_RELATION:
    1365      925618 :             READ_OID_FIELD(relid);
    1366      925618 :             READ_CHAR_FIELD(relkind);
    1367      925618 :             READ_INT_FIELD(rellockmode);
    1368      925618 :             READ_NODE_FIELD(tablesample);
    1369      925618 :             break;
    1370             :         case RTE_SUBQUERY:
    1371      134562 :             READ_NODE_FIELD(subquery);
    1372      134562 :             READ_BOOL_FIELD(security_barrier);
    1373      134562 :             break;
    1374             :         case RTE_JOIN:
    1375      158604 :             READ_ENUM_FIELD(jointype, JoinType);
    1376      158604 :             READ_NODE_FIELD(joinaliasvars);
    1377      158604 :             break;
    1378             :         case RTE_FUNCTION:
    1379       69864 :             READ_NODE_FIELD(functions);
    1380       69864 :             READ_BOOL_FIELD(funcordinality);
    1381       69864 :             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        8884 :             READ_NODE_FIELD(values_lists);
    1396        8884 :             READ_NODE_FIELD(coltypes);
    1397        8884 :             READ_NODE_FIELD(coltypmods);
    1398        8884 :             READ_NODE_FIELD(colcollations);
    1399        8884 :             break;
    1400             :         case RTE_CTE:
    1401        3036 :             READ_STRING_FIELD(ctename);
    1402        3036 :             READ_UINT_FIELD(ctelevelsup);
    1403        3036 :             READ_BOOL_FIELD(self_reference);
    1404        3036 :             READ_NODE_FIELD(coltypes);
    1405        3036 :             READ_NODE_FIELD(coltypmods);
    1406        3036 :             READ_NODE_FIELD(colcollations);
    1407        3036 :             break;
    1408             :         case RTE_NAMEDTUPLESTORE:
    1409         504 :             READ_STRING_FIELD(enrname);
    1410         504 :             READ_FLOAT_FIELD(enrtuples);
    1411         504 :             READ_OID_FIELD(relid);
    1412         504 :             READ_NODE_FIELD(coltypes);
    1413         504 :             READ_NODE_FIELD(coltypmods);
    1414         504 :             READ_NODE_FIELD(colcollations);
    1415         504 :             break;
    1416             :         case RTE_RESULT:
    1417             :             /* no extra fields */
    1418      110772 :             break;
    1419             :         default:
    1420           0 :             elog(ERROR, "unrecognized RTE kind: %d",
    1421             :                  (int) local_node->rtekind);
    1422             :             break;
    1423             :     }
    1424             : 
    1425     1412152 :     READ_BOOL_FIELD(lateral);
    1426     1412152 :     READ_BOOL_FIELD(inh);
    1427     1412152 :     READ_BOOL_FIELD(inFromCl);
    1428     1412152 :     READ_UINT_FIELD(requiredPerms);
    1429     1412152 :     READ_OID_FIELD(checkAsUser);
    1430     1412152 :     READ_BITMAPSET_FIELD(selectedCols);
    1431     1412152 :     READ_BITMAPSET_FIELD(insertedCols);
    1432     1412152 :     READ_BITMAPSET_FIELD(updatedCols);
    1433     1412152 :     READ_BITMAPSET_FIELD(extraUpdatedCols);
    1434     1412152 :     READ_NODE_FIELD(securityQuals);
    1435             : 
    1436     1412152 :     READ_DONE();
    1437             : }
    1438             : 
    1439             : /*
    1440             :  * _readRangeTblFunction
    1441             :  */
    1442             : static RangeTblFunction *
    1443       70360 : _readRangeTblFunction(void)
    1444             : {
    1445       70360 :     READ_LOCALS(RangeTblFunction);
    1446             : 
    1447       70360 :     READ_NODE_FIELD(funcexpr);
    1448       70360 :     READ_INT_FIELD(funccolcount);
    1449       70360 :     READ_NODE_FIELD(funccolnames);
    1450       70360 :     READ_NODE_FIELD(funccoltypes);
    1451       70360 :     READ_NODE_FIELD(funccoltypmods);
    1452       70360 :     READ_NODE_FIELD(funccolcollations);
    1453       70360 :     READ_BITMAPSET_FIELD(funcparams);
    1454             : 
    1455       70360 :     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      243184 : _readPlannedStmt(void)
    1499             : {
    1500      243184 :     READ_LOCALS(PlannedStmt);
    1501             : 
    1502      243184 :     READ_ENUM_FIELD(commandType, CmdType);
    1503      243184 :     READ_UINT64_FIELD(queryId);
    1504      243184 :     READ_BOOL_FIELD(hasReturning);
    1505      243184 :     READ_BOOL_FIELD(hasModifyingCTE);
    1506      243184 :     READ_BOOL_FIELD(canSetTag);
    1507      243184 :     READ_BOOL_FIELD(transientPlan);
    1508      243184 :     READ_BOOL_FIELD(dependsOnRole);
    1509      243184 :     READ_BOOL_FIELD(parallelModeNeeded);
    1510      243184 :     READ_INT_FIELD(jitFlags);
    1511      243184 :     READ_NODE_FIELD(planTree);
    1512      243184 :     READ_NODE_FIELD(rtable);
    1513      243184 :     READ_NODE_FIELD(resultRelations);
    1514      243184 :     READ_NODE_FIELD(rootResultRelations);
    1515      243184 :     READ_NODE_FIELD(subplans);
    1516      243184 :     READ_BITMAPSET_FIELD(rewindPlanIDs);
    1517      243184 :     READ_NODE_FIELD(rowMarks);
    1518      243184 :     READ_NODE_FIELD(relationOids);
    1519      243184 :     READ_NODE_FIELD(invalItems);
    1520      243184 :     READ_NODE_FIELD(paramExecTypes);
    1521      243184 :     READ_NODE_FIELD(utilityStmt);
    1522      243184 :     READ_LOCATION_FIELD(stmt_location);
    1523      243184 :     READ_LOCATION_FIELD(stmt_len);
    1524             : 
    1525      243184 :     READ_DONE();
    1526             : }
    1527             : 
    1528             : /*
    1529             :  * ReadCommonPlan
    1530             :  *  Assign the basic stuff of all nodes that inherit from Plan
    1531             :  */
    1532             : static void
    1533      627846 : ReadCommonPlan(Plan *local_node)
    1534             : {
    1535             :     READ_TEMP_LOCALS();
    1536             : 
    1537      627846 :     READ_FLOAT_FIELD(startup_cost);
    1538      627846 :     READ_FLOAT_FIELD(total_cost);
    1539      627846 :     READ_FLOAT_FIELD(plan_rows);
    1540      627846 :     READ_INT_FIELD(plan_width);
    1541      627846 :     READ_BOOL_FIELD(parallel_aware);
    1542      627846 :     READ_BOOL_FIELD(parallel_safe);
    1543      627846 :     READ_INT_FIELD(plan_node_id);
    1544      627846 :     READ_NODE_FIELD(targetlist);
    1545      627846 :     READ_NODE_FIELD(qual);
    1546      627846 :     READ_NODE_FIELD(lefttree);
    1547      627846 :     READ_NODE_FIELD(righttree);
    1548      627846 :     READ_NODE_FIELD(initPlan);
    1549      627846 :     READ_BITMAPSET_FIELD(extParam);
    1550      627846 :     READ_BITMAPSET_FIELD(allParam);
    1551      627846 : }
    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      114488 : _readResult(void)
    1571             : {
    1572      114488 :     READ_LOCALS(Result);
    1573             : 
    1574      114488 :     ReadCommonPlan(&local_node->plan);
    1575             : 
    1576      114488 :     READ_NODE_FIELD(resconstantqual);
    1577             : 
    1578      114488 :     READ_DONE();
    1579             : }
    1580             : 
    1581             : /*
    1582             :  * _readProjectSet
    1583             :  */
    1584             : static ProjectSet *
    1585        3262 : _readProjectSet(void)
    1586             : {
    1587        3262 :     READ_LOCALS_NO_FIELDS(ProjectSet);
    1588             : 
    1589        3262 :     ReadCommonPlan(&local_node->plan);
    1590             : 
    1591        3262 :     READ_DONE();
    1592             : }
    1593             : 
    1594             : /*
    1595             :  * _readModifyTable
    1596             :  */
    1597             : static ModifyTable *
    1598       72616 : _readModifyTable(void)
    1599             : {
    1600       72616 :     READ_LOCALS(ModifyTable);
    1601             : 
    1602       72616 :     ReadCommonPlan(&local_node->plan);
    1603             : 
    1604       72616 :     READ_ENUM_FIELD(operation, CmdType);
    1605       72616 :     READ_BOOL_FIELD(canSetTag);
    1606       72616 :     READ_UINT_FIELD(nominalRelation);
    1607       72616 :     READ_UINT_FIELD(rootRelation);
    1608       72616 :     READ_BOOL_FIELD(partColsUpdated);
    1609       72616 :     READ_NODE_FIELD(resultRelations);
    1610       72616 :     READ_INT_FIELD(resultRelIndex);
    1611       72616 :     READ_INT_FIELD(rootResultRelIndex);
    1612       72616 :     READ_NODE_FIELD(plans);
    1613       72616 :     READ_NODE_FIELD(withCheckOptionLists);
    1614       72616 :     READ_NODE_FIELD(returningLists);
    1615       72616 :     READ_NODE_FIELD(fdwPrivLists);
    1616       72616 :     READ_BITMAPSET_FIELD(fdwDirectModifyPlans);
    1617       72616 :     READ_NODE_FIELD(rowMarks);
    1618       72616 :     READ_INT_FIELD(epqParam);
    1619       72616 :     READ_ENUM_FIELD(onConflictAction, OnConflictAction);
    1620       72616 :     READ_NODE_FIELD(arbiterIndexes);
    1621       72616 :     READ_NODE_FIELD(onConflictSet);
    1622       72616 :     READ_NODE_FIELD(onConflictWhere);
    1623       72616 :     READ_UINT_FIELD(exclRelRTI);
    1624       72616 :     READ_NODE_FIELD(exclRelTlist);
    1625             : 
    1626       72616 :     READ_DONE();
    1627             : }
    1628             : 
    1629             : /*
    1630             :  * _readAppend
    1631             :  */
    1632             : static Append *
    1633        5754 : _readAppend(void)
    1634             : {
    1635        5754 :     READ_LOCALS(Append);
    1636             : 
    1637        5754 :     ReadCommonPlan(&local_node->plan);
    1638             : 
    1639        5754 :     READ_NODE_FIELD(appendplans);
    1640        5754 :     READ_INT_FIELD(first_partial_plan);
    1641        5754 :     READ_NODE_FIELD(part_prune_info);
    1642             : 
    1643        5754 :     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         326 : _readRecursiveUnion(void)
    1672             : {
    1673         326 :     READ_LOCALS(RecursiveUnion);
    1674             : 
    1675         326 :     ReadCommonPlan(&local_node->plan);
    1676             : 
    1677         326 :     READ_INT_FIELD(wtParam);
    1678         326 :     READ_INT_FIELD(numCols);
    1679         326 :     READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
    1680         326 :     READ_OID_ARRAY(dupOperators, local_node->numCols);
    1681         326 :     READ_OID_ARRAY(dupCollations, local_node->numCols);
    1682         326 :     READ_LONG_FIELD(numGroups);
    1683             : 
    1684         326 :     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      273670 : ReadCommonScan(Scan *local_node)
    1724             : {
    1725             :     READ_TEMP_LOCALS();
    1726             : 
    1727      273670 :     ReadCommonPlan(&local_node->plan);
    1728             : 
    1729      273670 :     READ_UINT_FIELD(scanrelid);
    1730      273670 : }
    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      117834 : _readSeqScan(void)
    1750             : {
    1751      117834 :     READ_LOCALS_NO_FIELDS(SeqScan);
    1752             : 
    1753      117834 :     ReadCommonScan(local_node);
    1754             : 
    1755      117834 :     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       70520 : _readIndexScan(void)
    1778             : {
    1779       70520 :     READ_LOCALS(IndexScan);
    1780             : 
    1781       70520 :     ReadCommonScan(&local_node->scan);
    1782             : 
    1783       70520 :     READ_OID_FIELD(indexid);
    1784       70520 :     READ_NODE_FIELD(indexqual);
    1785       70520 :     READ_NODE_FIELD(indexqualorig);
    1786       70520 :     READ_NODE_FIELD(indexorderby);
    1787       70520 :     READ_NODE_FIELD(indexorderbyorig);
    1788       70520 :     READ_NODE_FIELD(indexorderbyops);
    1789       70520 :     READ_ENUM_FIELD(indexorderdir, ScanDirection);
    1790             : 
    1791       70520 :     READ_DONE();
    1792             : }
    1793             : 
    1794             : /*
    1795             :  * _readIndexOnlyScan
    1796             :  */
    1797             : static IndexOnlyScan *
    1798        8108 : _readIndexOnlyScan(void)
    1799             : {
    1800        8108 :     READ_LOCALS(IndexOnlyScan);
    1801             : 
    1802        8108 :     ReadCommonScan(&local_node->scan);
    1803             : 
    1804        8108 :     READ_OID_FIELD(indexid);
    1805        8108 :     READ_NODE_FIELD(indexqual);
    1806        8108 :     READ_NODE_FIELD(indexorderby);
    1807        8108 :     READ_NODE_FIELD(indextlist);
    1808        8108 :     READ_ENUM_FIELD(indexorderdir, ScanDirection);
    1809             : 
    1810        8108 :     READ_DONE();
    1811             : }
    1812             : 
    1813             : /*
    1814             :  * _readBitmapIndexScan
    1815             :  */
    1816             : static BitmapIndexScan *
    1817       19748 : _readBitmapIndexScan(void)
    1818             : {
    1819       19748 :     READ_LOCALS(BitmapIndexScan);
    1820             : 
    1821       19748 :     ReadCommonScan(&local_node->scan);
    1822             : 
    1823       19748 :     READ_OID_FIELD(indexid);
    1824       19748 :     READ_BOOL_FIELD(isshared);
    1825       19748 :     READ_NODE_FIELD(indexqual);
    1826       19748 :     READ_NODE_FIELD(indexqualorig);
    1827             : 
    1828       19748 :     READ_DONE();
    1829             : }
    1830             : 
    1831             : /*
    1832             :  * _readBitmapHeapScan
    1833             :  */
    1834             : static BitmapHeapScan *
    1835       19580 : _readBitmapHeapScan(void)
    1836             : {
    1837       19580 :     READ_LOCALS(BitmapHeapScan);
    1838             : 
    1839       19580 :     ReadCommonScan(&local_node->scan);
    1840             : 
    1841       19580 :     READ_NODE_FIELD(bitmapqualorig);
    1842             : 
    1843       19580 :     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        1798 : _readSubqueryScan(void)
    1866             : {
    1867        1798 :     READ_LOCALS(SubqueryScan);
    1868             : 
    1869        1798 :     ReadCommonScan(&local_node->scan);
    1870             : 
    1871        1798 :     READ_NODE_FIELD(subplan);
    1872             : 
    1873        1798 :     READ_DONE();
    1874             : }
    1875             : 
    1876             : /*
    1877             :  * _readFunctionScan
    1878             :  */
    1879             : static FunctionScan *
    1880       28764 : _readFunctionScan(void)
    1881             : {
    1882       28764 :     READ_LOCALS(FunctionScan);
    1883             : 
    1884       28764 :     ReadCommonScan(&local_node->scan);
    1885             : 
    1886       28764 :     READ_NODE_FIELD(functions);
    1887       28764 :     READ_BOOL_FIELD(funcordinality);
    1888             : 
    1889       28764 :     READ_DONE();
    1890             : }
    1891             : 
    1892             : /*
    1893             :  * _readValuesScan
    1894             :  */
    1895             : static ValuesScan *
    1896        3766 : _readValuesScan(void)
    1897             : {
    1898        3766 :     READ_LOCALS(ValuesScan);
    1899             : 
    1900        3766 :     ReadCommonScan(&local_node->scan);
    1901             : 
    1902        3766 :     READ_NODE_FIELD(values_lists);
    1903             : 
    1904        3766 :     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         874 : _readCteScan(void)
    1927             : {
    1928         874 :     READ_LOCALS(CteScan);
    1929             : 
    1930         874 :     ReadCommonScan(&local_node->scan);
    1931             : 
    1932         874 :     READ_INT_FIELD(ctePlanId);
    1933         874 :     READ_INT_FIELD(cteParam);
    1934             : 
    1935         874 :     READ_DONE();
    1936             : }
    1937             : 
    1938             : /*
    1939             :  * _readNamedTuplestoreScan
    1940             :  */
    1941             : static NamedTuplestoreScan *
    1942         260 : _readNamedTuplestoreScan(void)
    1943             : {
    1944         260 :     READ_LOCALS(NamedTuplestoreScan);
    1945             : 
    1946         260 :     ReadCommonScan(&local_node->scan);
    1947             : 
    1948         260 :     READ_STRING_FIELD(enrname);
    1949             : 
    1950         260 :     READ_DONE();
    1951             : }
    1952             : 
    1953             : /*
    1954             :  * _readWorkTableScan
    1955             :  */
    1956             : static WorkTableScan *
    1957         326 : _readWorkTableScan(void)
    1958             : {
    1959         326 :     READ_LOCALS(WorkTableScan);
    1960             : 
    1961         326 :     ReadCommonScan(&local_node->scan);
    1962             : 
    1963         326 :     READ_INT_FIELD(wtParam);
    1964             : 
    1965         326 :     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       60132 : ReadCommonJoin(Join *local_node)
    2025             : {
    2026             :     READ_TEMP_LOCALS();
    2027             : 
    2028       60132 :     ReadCommonPlan(&local_node->plan);
    2029             : 
    2030       60132 :     READ_ENUM_FIELD(jointype, JoinType);
    2031       60132 :     READ_BOOL_FIELD(inner_unique);
    2032       60132 :     READ_NODE_FIELD(joinqual);
    2033       60132 : }
    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       31430 : _readNestLoop(void)
    2053             : {
    2054       31430 :     READ_LOCALS(NestLoop);
    2055             : 
    2056       31430 :     ReadCommonJoin(&local_node->join);
    2057             : 
    2058       31430 :     READ_NODE_FIELD(nestParams);
    2059             : 
    2060       31430 :     READ_DONE();
    2061             : }
    2062             : 
    2063             : /*
    2064             :  * _readMergeJoin
    2065             :  */
    2066             : static MergeJoin *
    2067        1956 : _readMergeJoin(void)
    2068             : {
    2069             :     int         numCols;
    2070             : 
    2071        1956 :     READ_LOCALS(MergeJoin);
    2072             : 
    2073        1956 :     ReadCommonJoin(&local_node->join);
    2074             : 
    2075        1956 :     READ_BOOL_FIELD(skip_mark_restore);
    2076        1956 :     READ_NODE_FIELD(mergeclauses);
    2077             : 
    2078        1956 :     numCols = list_length(local_node->mergeclauses);
    2079             : 
    2080        1956 :     READ_OID_ARRAY(mergeFamilies, numCols);
    2081        1956 :     READ_OID_ARRAY(mergeCollations, numCols);
    2082        1956 :     READ_INT_ARRAY(mergeStrategies, numCols);
    2083        1956 :     READ_BOOL_ARRAY(mergeNullsFirst, numCols);
    2084             : 
    2085        1956 :     READ_DONE();
    2086             : }
    2087             : 
    2088             : /*
    2089             :  * _readHashJoin
    2090             :  */
    2091             : static HashJoin *
    2092       26746 : _readHashJoin(void)
    2093             : {
    2094       26746 :     READ_LOCALS(HashJoin);
    2095             : 
    2096       26746 :     ReadCommonJoin(&local_node->join);
    2097             : 
    2098       26746 :     READ_NODE_FIELD(hashclauses);
    2099             : 
    2100       26746 :     READ_DONE();
    2101             : }
    2102             : 
    2103             : /*
    2104             :  * _readMaterial
    2105             :  */
    2106             : static Material *
    2107        2722 : _readMaterial(void)
    2108             : {
    2109        2722 :     READ_LOCALS_NO_FIELDS(Material);
    2110             : 
    2111        2722 :     ReadCommonPlan(&local_node->plan);
    2112             : 
    2113        2722 :     READ_DONE();
    2114             : }
    2115             : 
    2116             : /*
    2117             :  * _readSort
    2118             :  */
    2119             : static Sort *
    2120       31218 : _readSort(void)
    2121             : {
    2122       31218 :     READ_LOCALS(Sort);
    2123             : 
    2124       31218 :     ReadCommonPlan(&local_node->plan);
    2125             : 
    2126       31218 :     READ_INT_FIELD(numCols);
    2127       31218 :     READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
    2128       31218 :     READ_OID_ARRAY(sortOperators, local_node->numCols);
    2129       31218 :     READ_OID_ARRAY(collations, local_node->numCols);
    2130       31218 :     READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
    2131             : 
    2132       31218 :     READ_DONE();
    2133             : }
    2134             : 
    2135             : /*
    2136             :  * _readGroup
    2137             :  */
    2138             : static Group *
    2139         106 : _readGroup(void)
    2140             : {
    2141         106 :     READ_LOCALS(Group);
    2142             : 
    2143         106 :     ReadCommonPlan(&local_node->plan);
    2144             : 
    2145         106 :     READ_INT_FIELD(numCols);
    2146         106 :     READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
    2147         106 :     READ_OID_ARRAY(grpOperators, local_node->numCols);
    2148         106 :     READ_OID_ARRAY(grpCollations, local_node->numCols);
    2149             : 
    2150         106 :     READ_DONE();
    2151             : }
    2152             : 
    2153             : /*
    2154             :  * _readAgg
    2155             :  */
    2156             : static Agg *
    2157       26324 : _readAgg(void)
    2158             : {
    2159       26324 :     READ_LOCALS(Agg);
    2160             : 
    2161       26324 :     ReadCommonPlan(&local_node->plan);
    2162             : 
    2163       26324 :     READ_ENUM_FIELD(aggstrategy, AggStrategy);
    2164       26324 :     READ_ENUM_FIELD(aggsplit, AggSplit);
    2165       26324 :     READ_INT_FIELD(numCols);
    2166       26324 :     READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
    2167       26324 :     READ_OID_ARRAY(grpOperators, local_node->numCols);
    2168       26324 :     READ_OID_ARRAY(grpCollations, local_node->numCols);
    2169       26324 :     READ_LONG_FIELD(numGroups);
    2170       26324 :     READ_BITMAPSET_FIELD(aggParams);
    2171       26324 :     READ_NODE_FIELD(groupingSets);
    2172       26324 :     READ_NODE_FIELD(chain);
    2173             : 
    2174       26324 :     READ_DONE();
    2175             : }
    2176             : 
    2177             : /*
    2178             :  * _readWindowAgg
    2179             :  */
    2180             : static WindowAgg *
    2181        1124 : _readWindowAgg(void)
    2182             : {
    2183        1124 :     READ_LOCALS(WindowAgg);
    2184             : 
    2185        1124 :     ReadCommonPlan(&local_node->plan);
    2186             : 
    2187        1124 :     READ_UINT_FIELD(winref);
    2188        1124 :     READ_INT_FIELD(partNumCols);
    2189        1124 :     READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
    2190        1124 :     READ_OID_ARRAY(partOperators, local_node->partNumCols);
    2191        1124 :     READ_OID_ARRAY(partCollations, local_node->partNumCols);
    2192        1124 :     READ_INT_FIELD(ordNumCols);
    2193        1124 :     READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
    2194        1124 :     READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
    2195        1124 :     READ_OID_ARRAY(ordCollations, local_node->ordNumCols);
    2196        1124 :     READ_INT_FIELD(frameOptions);
    2197        1124 :     READ_NODE_FIELD(startOffset);
    2198        1124 :     READ_NODE_FIELD(endOffset);
    2199        1124 :     READ_OID_FIELD(startInRangeFunc);
    2200        1124 :     READ_OID_FIELD(endInRangeFunc);
    2201        1124 :     READ_OID_FIELD(inRangeColl);
    2202        1124 :     READ_BOOL_FIELD(inRangeAsc);
    2203        1124 :     READ_BOOL_FIELD(inRangeNullsFirst);
    2204             : 
    2205        1124 :     READ_DONE();
    2206             : }
    2207             : 
    2208             : /*
    2209             :  * _readUnique
    2210             :  */
    2211             : static Unique *
    2212         326 : _readUnique(void)
    2213             : {
    2214         326 :     READ_LOCALS(Unique);
    2215             : 
    2216         326 :     ReadCommonPlan(&local_node->plan);
    2217             : 
    2218         326 :     READ_INT_FIELD(numCols);
    2219         326 :     READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
    2220         326 :     READ_OID_ARRAY(uniqOperators, local_node->numCols);
    2221         326 :     READ_OID_ARRAY(uniqCollations, local_node->numCols);
    2222             : 
    2223         326 :     READ_DONE();
    2224             : }
    2225             : 
    2226             : /*
    2227             :  * _readGather
    2228             :  */
    2229             : static Gather *
    2230         550 : _readGather(void)
    2231             : {
    2232         550 :     READ_LOCALS(Gather);
    2233             : 
    2234         550 :     ReadCommonPlan(&local_node->plan);
    2235             : 
    2236         550 :     READ_INT_FIELD(num_workers);
    2237         550 :     READ_INT_FIELD(rescan_param);
    2238         550 :     READ_BOOL_FIELD(single_copy);
    2239         550 :     READ_BOOL_FIELD(invisible);
    2240         550 :     READ_BITMAPSET_FIELD(initParam);
    2241             : 
    2242         550 :     READ_DONE();
    2243             : }
    2244             : 
    2245             : /*
    2246             :  * _readGatherMerge
    2247             :  */
    2248             : static GatherMerge *
    2249         136 : _readGatherMerge(void)
    2250             : {
    2251         136 :     READ_LOCALS(GatherMerge);
    2252             : 
    2253         136 :     ReadCommonPlan(&local_node->plan);
    2254             : 
    2255         136 :     READ_INT_FIELD(num_workers);
    2256         136 :     READ_INT_FIELD(rescan_param);
    2257         136 :     READ_INT_FIELD(numCols);
    2258         136 :     READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
    2259         136 :     READ_OID_ARRAY(sortOperators, local_node->numCols);
    2260         136 :     READ_OID_ARRAY(collations, local_node->numCols);
    2261         136 :     READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
    2262         136 :     READ_BITMAPSET_FIELD(initParam);
    2263             : 
    2264         136 :     READ_DONE();
    2265             : }
    2266             : 
    2267             : /*
    2268             :  * _readHash
    2269             :  */
    2270             : static Hash *
    2271       26746 : _readHash(void)
    2272             : {
    2273       26746 :     READ_LOCALS(Hash);
    2274             : 
    2275       26746 :     ReadCommonPlan(&local_node->plan);
    2276             : 
    2277       26746 :     READ_OID_FIELD(skewTable);
    2278       26746 :     READ_INT_FIELD(skewColumn);
    2279       26746 :     READ_BOOL_FIELD(skewInherit);
    2280       26746 :     READ_FLOAT_FIELD(rows_total);
    2281             : 
    2282       26746 :     READ_DONE();
    2283             : }
    2284             : 
    2285             : /*
    2286             :  * _readSetOp
    2287             :  */
    2288             : static SetOp *
    2289         208 : _readSetOp(void)
    2290             : {
    2291         208 :     READ_LOCALS(SetOp);
    2292             : 
    2293         208 :     ReadCommonPlan(&local_node->plan);
    2294             : 
    2295         208 :     READ_ENUM_FIELD(cmd, SetOpCmd);
    2296         208 :     READ_ENUM_FIELD(strategy, SetOpStrategy);
    2297         208 :     READ_INT_FIELD(numCols);
    2298         208 :     READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
    2299         208 :     READ_OID_ARRAY(dupOperators, local_node->numCols);
    2300         208 :     READ_OID_ARRAY(dupCollations, local_node->numCols);
    2301         208 :     READ_INT_FIELD(flagColIdx);
    2302         208 :     READ_INT_FIELD(firstFlag);
    2303         208 :     READ_LONG_FIELD(numGroups);
    2304             : 
    2305         208 :     READ_DONE();
    2306             : }
    2307             : 
    2308             : /*
    2309             :  * _readLockRows
    2310             :  */
    2311             : static LockRows *
    2312        4808 : _readLockRows(void)
    2313             : {
    2314        4808 :     READ_LOCALS(LockRows);
    2315             : 
    2316        4808 :     ReadCommonPlan(&local_node->plan);
    2317             : 
    2318        4808 :     READ_NODE_FIELD(rowMarks);
    2319        4808 :     READ_INT_FIELD(epqParam);
    2320             : 
    2321        4808 :     READ_DONE();
    2322             : }
    2323             : 
    2324             : /*
    2325             :  * _readLimit
    2326             :  */
    2327             : static Limit *
    2328        2942 : _readLimit(void)
    2329             : {
    2330        2942 :     READ_LOCALS(Limit);
    2331             : 
    2332        2942 :     ReadCommonPlan(&local_node->plan);
    2333             : 
    2334        2942 :     READ_NODE_FIELD(limitOffset);
    2335        2942 :     READ_NODE_FIELD(limitCount);
    2336             : 
    2337        2942 :     READ_DONE();
    2338             : }
    2339             : 
    2340             : /*
    2341             :  * _readNestLoopParam
    2342             :  */
    2343             : static NestLoopParam *
    2344       17348 : _readNestLoopParam(void)
    2345             : {
    2346       17348 :     READ_LOCALS(NestLoopParam);
    2347             : 
    2348       17348 :     READ_INT_FIELD(paramno);
    2349       17348 :     READ_NODE_FIELD(paramval);
    2350             : 
    2351       17348 :     READ_DONE();
    2352             : }
    2353             : 
    2354             : /*
    2355             :  * _readPlanRowMark
    2356             :  */
    2357             : static PlanRowMark *
    2358       13256 : _readPlanRowMark(void)
    2359             : {
    2360       13256 :     READ_LOCALS(PlanRowMark);
    2361             : 
    2362       13256 :     READ_UINT_FIELD(rti);
    2363       13256 :     READ_UINT_FIELD(prti);
    2364       13256 :     READ_UINT_FIELD(rowmarkId);
    2365       13256 :     READ_ENUM_FIELD(markType, RowMarkType);
    2366       13256 :     READ_INT_FIELD(allMarkTypes);
    2367       13256 :     READ_ENUM_FIELD(strength, LockClauseStrength);
    2368       13256 :     READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
    2369       13256 :     READ_BOOL_FIELD(isParent);
    2370             : 
    2371       13256 :     READ_DONE();
    2372             : }
    2373             : 
    2374             : static PartitionPruneInfo *
    2375         336 : _readPartitionPruneInfo(void)
    2376             : {
    2377         336 :     READ_LOCALS(PartitionPruneInfo);
    2378             : 
    2379         336 :     READ_NODE_FIELD(prune_infos);
    2380         336 :     READ_BITMAPSET_FIELD(other_subplans);
    2381             : 
    2382         336 :     READ_DONE();
    2383             : }
    2384             : 
    2385             : static PartitionedRelPruneInfo *
    2386         904 : _readPartitionedRelPruneInfo(void)
    2387             : {
    2388         904 :     READ_LOCALS(PartitionedRelPruneInfo);
    2389             : 
    2390         904 :     READ_UINT_FIELD(rtindex);
    2391         904 :     READ_BITMAPSET_FIELD(present_parts);
    2392         904 :     READ_INT_FIELD(nparts);
    2393         904 :     READ_INT_ARRAY(subplan_map, local_node->nparts);
    2394         904 :     READ_INT_ARRAY(subpart_map, local_node->nparts);
    2395         904 :     READ_OID_ARRAY(relid_map, local_node->nparts);
    2396         904 :     READ_NODE_FIELD(initial_pruning_steps);
    2397         904 :     READ_NODE_FIELD(exec_pruning_steps);
    2398         904 :     READ_BITMAPSET_FIELD(execparamids);
    2399             : 
    2400         904 :     READ_DONE();
    2401             : }
    2402             : 
    2403             : static PartitionPruneStepOp *
    2404         672 : _readPartitionPruneStepOp(void)
    2405             : {
    2406         672 :     READ_LOCALS(PartitionPruneStepOp);
    2407             : 
    2408         672 :     READ_INT_FIELD(step.step_id);
    2409         672 :     READ_INT_FIELD(opstrategy);
    2410         672 :     READ_NODE_FIELD(exprs);
    2411         672 :     READ_NODE_FIELD(cmpfns);
    2412         672 :     READ_BITMAPSET_FIELD(nullkeys);
    2413             : 
    2414         672 :     READ_DONE();
    2415             : }
    2416             : 
    2417             : static PartitionPruneStepCombine *
    2418         140 : _readPartitionPruneStepCombine(void)
    2419             : {
    2420         140 :     READ_LOCALS(PartitionPruneStepCombine);
    2421             : 
    2422         140 :     READ_INT_FIELD(step.step_id);
    2423         140 :     READ_ENUM_FIELD(combineOp, PartitionPruneCombineOp);
    2424         140 :     READ_NODE_FIELD(source_stepids);
    2425             : 
    2426         140 :     READ_DONE();
    2427             : }
    2428             : 
    2429             : /*
    2430             :  * _readPlanInvalItem
    2431             :  */
    2432             : static PlanInvalItem *
    2433       91184 : _readPlanInvalItem(void)
    2434             : {
    2435       91184 :     READ_LOCALS(PlanInvalItem);
    2436             : 
    2437       91184 :     READ_INT_FIELD(cacheId);
    2438       91184 :     READ_UINT_FIELD(hashValue);
    2439             : 
    2440       91184 :     READ_DONE();
    2441             : }
    2442             : 
    2443             : /*
    2444             :  * _readSubPlan
    2445             :  */
    2446             : static SubPlan *
    2447       46318 : _readSubPlan(void)
    2448             : {
    2449       46318 :     READ_LOCALS(SubPlan);
    2450             : 
    2451       46318 :     READ_ENUM_FIELD(subLinkType, SubLinkType);
    2452       46318 :     READ_NODE_FIELD(testexpr);
    2453       46318 :     READ_NODE_FIELD(paramIds);
    2454       46318 :     READ_INT_FIELD(plan_id);
    2455       46318 :     READ_STRING_FIELD(plan_name);
    2456       46318 :     READ_OID_FIELD(firstColType);
    2457       46318 :     READ_INT_FIELD(firstColTypmod);
    2458       46318 :     READ_OID_FIELD(firstColCollation);
    2459       46318 :     READ_BOOL_FIELD(useHashTable);
    2460       46318 :     READ_BOOL_FIELD(unknownEqFalse);
    2461       46318 :     READ_BOOL_FIELD(parallel_safe);
    2462       46318 :     READ_NODE_FIELD(setParam);
    2463       46318 :     READ_NODE_FIELD(parParam);
    2464       46318 :     READ_NODE_FIELD(args);
    2465       46318 :     READ_FLOAT_FIELD(startup_cost);
    2466       46318 :     READ_FLOAT_FIELD(per_call_cost);
    2467             : 
    2468       46318 :     READ_DONE();
    2469             : }
    2470             : 
    2471             : /*
    2472             :  * _readAlternativeSubPlan
    2473             :  */
    2474             : static AlternativeSubPlan *
    2475        1166 : _readAlternativeSubPlan(void)
    2476             : {
    2477        1166 :     READ_LOCALS(AlternativeSubPlan);
    2478             : 
    2479        1166 :     READ_NODE_FIELD(subplans);
    2480             : 
    2481        1166 :     READ_DONE();
    2482             : }
    2483             : 
    2484             : /*
    2485             :  * _readExtensibleNode
    2486             :  */
    2487             : static ExtensibleNode *
    2488           0 : _readExtensibleNode(void)
    2489             : {
    2490             :     const ExtensibleNodeMethods *methods;
    2491             :     ExtensibleNode *local_node;
    2492             :     const char *extnodename;
    2493             : 
    2494             :     READ_TEMP_LOCALS();
    2495             : 
    2496           0 :     token = pg_strtok(&length); /* skip :extnodename */
    2497           0 :     token = pg_strtok(&length); /* get extnodename */
    2498             : 
    2499           0 :     extnodename = nullable_string(token, length);
    2500           0 :     if (!extnodename)
    2501           0 :         elog(ERROR, "extnodename has to be supplied");
    2502           0 :     methods = GetExtensibleNodeMethods(extnodename, false);
    2503             : 
    2504           0 :     local_node = (ExtensibleNode *) newNode(methods->node_size,
    2505             :                                             T_ExtensibleNode);
    2506           0 :     local_node->extnodename = extnodename;
    2507             : 
    2508             :     /* deserialize the private fields */
    2509           0 :     methods->nodeRead(local_node);
    2510             : 
    2511           0 :     READ_DONE();
    2512             : }
    2513             : 
    2514             : /*
    2515             :  * _readPartitionBoundSpec
    2516             :  */
    2517             : static PartitionBoundSpec *
    2518       26864 : _readPartitionBoundSpec(void)
    2519             : {
    2520       26864 :     READ_LOCALS(PartitionBoundSpec);
    2521             : 
    2522       26864 :     READ_CHAR_FIELD(strategy);
    2523       26864 :     READ_BOOL_FIELD(is_default);
    2524       26864 :     READ_INT_FIELD(modulus);
    2525       26864 :     READ_INT_FIELD(remainder);
    2526       26864 :     READ_NODE_FIELD(listdatums);
    2527       26864 :     READ_NODE_FIELD(lowerdatums);
    2528       26864 :     READ_NODE_FIELD(upperdatums);
    2529       26864 :     READ_LOCATION_FIELD(location);
    2530             : 
    2531       26864 :     READ_DONE();
    2532             : }
    2533             : 
    2534             : /*
    2535             :  * _readPartitionRangeDatum
    2536             :  */
    2537             : static PartitionRangeDatum *
    2538       35744 : _readPartitionRangeDatum(void)
    2539             : {
    2540       35744 :     READ_LOCALS(PartitionRangeDatum);
    2541             : 
    2542       35744 :     READ_ENUM_FIELD(kind, PartitionRangeDatumKind);
    2543       35744 :     READ_NODE_FIELD(value);
    2544       35744 :     READ_LOCATION_FIELD(location);
    2545             : 
    2546       35744 :     READ_DONE();
    2547             : }
    2548             : 
    2549             : /*
    2550             :  * parseNodeString
    2551             :  *
    2552             :  * Given a character string representing a node tree, parseNodeString creates
    2553             :  * the internal node structure.
    2554             :  *
    2555             :  * The string to be read must already have been loaded into pg_strtok().
    2556             :  */
    2557             : Node *
    2558    27362564 : parseNodeString(void)
    2559             : {
    2560             :     void       *return_value;
    2561             : 
    2562             :     READ_TEMP_LOCALS();
    2563             : 
    2564             :     /* Guard against stack overflow due to overly complex expressions */
    2565    27362564 :     check_stack_depth();
    2566             : 
    2567    27362564 :     token = pg_strtok(&length);
    2568             : 
    2569             : #define MATCH(tokname, namelen) \
    2570             :     (length == namelen && memcmp(token, tokname, namelen) == 0)
    2571             : 
    2572    27362564 :     if (MATCH("QUERY", 5))
    2573      441444 :         return_value = _readQuery();
    2574    26921120 :     else if (MATCH("WITHCHECKOPTION", 15))
    2575        2200 :         return_value = _readWithCheckOption();
    2576    26918920 :     else if (MATCH("SORTGROUPCLAUSE", 15))
    2577       96634 :         return_value = _readSortGroupClause();
    2578    26822286 :     else if (MATCH("GROUPINGSET", 11))
    2579        1098 :         return_value = _readGroupingSet();
    2580    26821188 :     else if (MATCH("WINDOWCLAUSE", 12))
    2581        1452 :         return_value = _readWindowClause();
    2582    26819736 :     else if (MATCH("ROWMARKCLAUSE", 13))
    2583        3282 :         return_value = _readRowMarkClause();
    2584    26816454 :     else if (MATCH("COMMONTABLEEXPR", 15))
    2585        1328 :         return_value = _readCommonTableExpr();
    2586    26815126 :     else if (MATCH("SETOPERATIONSTMT", 16))
    2587       20480 :         return_value = _readSetOperationStmt();
    2588    26794646 :     else if (MATCH("ALIAS", 5))
    2589     2121686 :         return_value = _readAlias();
    2590    24672960 :     else if (MATCH("RANGEVAR", 8))
    2591           0 :         return_value = _readRangeVar();
    2592    24672960 :     else if (MATCH("INTOCLAUSE", 10))
    2593           0 :         return_value = _readIntoClause();
    2594    24672960 :     else if (MATCH("TABLEFUNC", 9))
    2595         308 :         return_value = _readTableFunc();
    2596    24672652 :     else if (MATCH("VAR", 3))
    2597    10694078 :         return_value = _readVar();
    2598    13978574 :     else if (MATCH("CONST", 5))
    2599     2047690 :         return_value = _readConst();
    2600    11930884 :     else if (MATCH("PARAM", 5))
    2601      192138 :         return_value = _readParam();
    2602    11738746 :     else if (MATCH("AGGREF", 6))
    2603       57038 :         return_value = _readAggref();
    2604    11681708 :     else if (MATCH("GROUPINGFUNC", 12))
    2605         318 :         return_value = _readGroupingFunc();
    2606    11681390 :     else if (MATCH("WINDOWFUNC", 10))
    2607        3056 :         return_value = _readWindowFunc();
    2608    11678334 :     else if (MATCH("SUBSCRIPTINGREF", 15))
    2609       11678 :         return_value = _readSubscriptingRef();
    2610    11666656 :     else if (MATCH("FUNCEXPR", 8))
    2611      778978 :         return_value = _readFuncExpr();
    2612    10887678 :     else if (MATCH("NAMEDARGEXPR", 12))
    2613         728 :         return_value = _readNamedArgExpr();
    2614    10886950 :     else if (MATCH("OPEXPR", 6))
    2615     1007550 :         return_value = _readOpExpr();
    2616     9879400 :     else if (MATCH("DISTINCTEXPR", 12))
    2617         930 :         return_value = _readDistinctExpr();
    2618     9878470 :     else if (MATCH("NULLIFEXPR", 10))
    2619         768 :         return_value = _readNullIfExpr();
    2620     9877702 :     else if (MATCH("SCALARARRAYOPEXPR", 17))
    2621       60930 :         return_value = _readScalarArrayOpExpr();
    2622     9816772 :     else if (MATCH("BOOLEXPR", 8))
    2623      212486 :         return_value = _readBoolExpr();
    2624     9604286 :     else if (MATCH("SUBLINK", 7))
    2625       62264 :         return_value = _readSubLink();
    2626     9542022 :     else if (MATCH("FIELDSELECT", 11))
    2627       39068 :         return_value = _readFieldSelect();
    2628     9502954 :     else if (MATCH("FIELDSTORE", 10))
    2629         420 :         return_value = _readFieldStore();
    2630     9502534 :     else if (MATCH("RELABELTYPE", 11))
    2631      146474 :         return_value = _readRelabelType();
    2632     9356060 :     else if (MATCH("COERCEVIAIO", 11))
    2633       25766 :         return_value = _readCoerceViaIO();
    2634     9330294 :     else if (MATCH("ARRAYCOERCEEXPR", 15))
    2635        3038 :         return_value = _readArrayCoerceExpr();
    2636     9327256 :     else if (MATCH("CONVERTROWTYPEEXPR", 18))
    2637         462 :         return_value = _readConvertRowtypeExpr();
    2638     9326794 :     else if (MATCH("COLLATE", 7))
    2639        2366 :         return_value = _readCollateExpr();
    2640     9324428 :     else if (MATCH("CASE", 4))
    2641      103976 :         return_value = _readCaseExpr();
    2642     9220452 :     else if (MATCH("WHEN", 4))
    2643      153702 :         return_value = _readCaseWhen();
    2644     9066750 :     else if (MATCH("CASETESTEXPR", 12))
    2645       37930 :         return_value = _readCaseTestExpr();
    2646     9028820 :     else if (MATCH("ARRAY", 5))
    2647       35840 :         return_value = _readArrayExpr();
    2648     8992980 :     else if (MATCH("ROW", 3))
    2649        2812 :         return_value = _readRowExpr();
    2650     8990168 :     else if (MATCH("ROWCOMPARE", 10))
    2651         220 :         return_value = _readRowCompareExpr();
    2652     8989948 :     else if (MATCH("COALESCE", 8))
    2653       50984 :         return_value = _readCoalesceExpr();
    2654     8938964 :     else if (MATCH("MINMAX", 6))
    2655         208 :         return_value = _readMinMaxExpr();
    2656     8938756 :     else if (MATCH("SQLVALUEFUNCTION", 16))
    2657        5450 :         return_value = _readSQLValueFunction();
    2658     8933306 :     else if (MATCH("XMLEXPR", 7))
    2659         952 :         return_value = _readXmlExpr();
    2660     8932354 :     else if (MATCH("NULLTEST", 8))
    2661       25308 :         return_value = _readNullTest();
    2662     8907046 :     else if (MATCH("BOOLEANTEST", 11))
    2663         524 :         return_value = _readBooleanTest();
    2664     8906522 :     else if (MATCH("COERCETODOMAIN", 14))
    2665      423276 :         return_value = _readCoerceToDomain();
    2666     8483246 :     else if (MATCH("COERCETODOMAINVALUE", 19))
    2667        2570 :         return_value = _readCoerceToDomainValue();
    2668     8480676 :     else if (MATCH("SETTODEFAULT", 12))
    2669           0 :         return_value = _readSetToDefault();
    2670     8480676 :     else if (MATCH("CURRENTOFEXPR", 13))
    2671         402 :         return_value = _readCurrentOfExpr();
    2672     8480274 :     else if (MATCH("NEXTVALUEEXPR", 13))
    2673         276 :         return_value = _readNextValueExpr();
    2674     8479998 :     else if (MATCH("INFERENCEELEM", 13))
    2675         832 :         return_value = _readInferenceElem();
    2676     8479166 :     else if (MATCH("TARGETENTRY", 11))
    2677     4821694 :         return_value = _readTargetEntry();
    2678     3657472 :     else if (MATCH("RANGETBLREF", 11))
    2679      518182 :         return_value = _readRangeTblRef();
    2680     3139290 :     else if (MATCH("JOINEXPR", 8))
    2681      109092 :         return_value = _readJoinExpr();
    2682     3030198 :     else if (MATCH("FROMEXPR", 8))
    2683      441402 :         return_value = _readFromExpr();
    2684     2588796 :     else if (MATCH("ONCONFLICTEXPR", 14))
    2685         892 :         return_value = _readOnConflictExpr();
    2686     2587904 :     else if (MATCH("RTE", 3))
    2687     1412152 :         return_value = _readRangeTblEntry();
    2688     1175752 :     else if (MATCH("RANGETBLFUNCTION", 16))
    2689       70360 :         return_value = _readRangeTblFunction();
    2690     1105392 :     else if (MATCH("TABLESAMPLECLAUSE", 17))
    2691         376 :         return_value = _readTableSampleClause();
    2692     1105016 :     else if (MATCH("NOTIFY", 6))
    2693          42 :         return_value = _readNotifyStmt();
    2694     1104974 :     else if (MATCH("DEFELEM", 7))
    2695          12 :         return_value = _readDefElem();
    2696     1104962 :     else if (MATCH("DECLARECURSOR", 13))
    2697           0 :         return_value = _readDeclareCursorStmt();
    2698     1104962 :     else if (MATCH("PLANNEDSTMT", 11))
    2699      243184 :         return_value = _readPlannedStmt();
    2700      861778 :     else if (MATCH("PLAN", 4))
    2701           0 :         return_value = _readPlan();
    2702      861778 :     else if (MATCH("RESULT", 6))
    2703      114488 :         return_value = _readResult();
    2704      747290 :     else if (MATCH("PROJECTSET", 10))
    2705        3262 :         return_value = _readProjectSet();
    2706      744028 :     else if (MATCH("MODIFYTABLE", 11))
    2707       72616 :         return_value = _readModifyTable();
    2708      671412 :     else if (MATCH("APPEND", 6))
    2709        5754 :         return_value = _readAppend();
    2710      665658 :     else if (MATCH("MERGEAPPEND", 11))
    2711         240 :         return_value = _readMergeAppend();
    2712      665418 :     else if (MATCH("RECURSIVEUNION", 14))
    2713         326 :         return_value = _readRecursiveUnion();
    2714      665092 :     else if (MATCH("BITMAPAND", 9))
    2715          44 :         return_value = _readBitmapAnd();
    2716      665048 :     else if (MATCH("BITMAPOR", 8))
    2717         104 :         return_value = _readBitmapOr();
    2718      664944 :     else if (MATCH("SCAN", 4))
    2719           0 :         return_value = _readScan();
    2720      664944 :     else if (MATCH("SEQSCAN", 7))
    2721      117834 :         return_value = _readSeqScan();
    2722      547110 :     else if (MATCH("SAMPLESCAN", 10))
    2723         180 :         return_value = _readSampleScan();
    2724      546930 :     else if (MATCH("INDEXSCAN", 9))
    2725       70520 :         return_value = _readIndexScan();
    2726      476410 :     else if (MATCH("INDEXONLYSCAN", 13))
    2727        8108 :         return_value = _readIndexOnlyScan();
    2728      468302 :     else if (MATCH("BITMAPINDEXSCAN", 15))
    2729       19748 :         return_value = _readBitmapIndexScan();
    2730      448554 :     else if (MATCH("BITMAPHEAPSCAN", 14))
    2731       19580 :         return_value = _readBitmapHeapScan();
    2732      428974 :     else if (MATCH("TIDSCAN", 7))
    2733         410 :         return_value = _readTidScan();
    2734      428564 :     else if (MATCH("SUBQUERYSCAN", 12))
    2735        1798 :         return_value = _readSubqueryScan();
    2736      426766 :     else if (MATCH("FUNCTIONSCAN", 12))
    2737       28764 :         return_value = _readFunctionScan();
    2738      398002 :     else if (MATCH("VALUESSCAN", 10))
    2739        3766 :         return_value = _readValuesScan();
    2740      394236 :     else if (MATCH("TABLEFUNCSCAN", 13))
    2741         140 :         return_value = _readTableFuncScan();
    2742      394096 :     else if (MATCH("CTESCAN", 7))
    2743         874 :         return_value = _readCteScan();
    2744      393222 :     else if (MATCH("NAMEDTUPLESTORESCAN", 19))
    2745         260 :         return_value = _readNamedTuplestoreScan();
    2746      392962 :     else if (MATCH("WORKTABLESCAN", 13))
    2747         326 :         return_value = _readWorkTableScan();
    2748      392636 :     else if (MATCH("FOREIGNSCAN", 11))
    2749        1362 :         return_value = _readForeignScan();
    2750      391274 :     else if (MATCH("CUSTOMSCAN", 10))
    2751           0 :         return_value = _readCustomScan();
    2752      391274 :     else if (MATCH("JOIN", 4))
    2753           0 :         return_value = _readJoin();
    2754      391274 :     else if (MATCH("NESTLOOP", 8))
    2755       31430 :         return_value = _readNestLoop();
    2756      359844 :     else if (MATCH("MERGEJOIN", 9))
    2757        1956 :         return_value = _readMergeJoin();
    2758      357888 :     else if (MATCH("HASHJOIN", 8))
    2759       26746 :         return_value = _readHashJoin();
    2760      331142 :     else if (MATCH("MATERIAL", 8))
    2761        2722 :         return_value = _readMaterial();
    2762      328420 :     else if (MATCH("SORT", 4))
    2763       31218 :         return_value = _readSort();
    2764      297202 :     else if (MATCH("GROUP", 5))
    2765         106 :         return_value = _readGroup();
    2766      297096 :     else if (MATCH("AGG", 3))
    2767       26324 :         return_value = _readAgg();
    2768      270772 :     else if (MATCH("WINDOWAGG", 9))
    2769        1124 :         return_value = _readWindowAgg();
    2770      269648 :     else if (MATCH("UNIQUE", 6))
    2771         326 :         return_value = _readUnique();
    2772      269322 :     else if (MATCH("GATHER", 6))
    2773         550 :         return_value = _readGather();
    2774      268772 :     else if (MATCH("GATHERMERGE", 11))
    2775         136 :         return_value = _readGatherMerge();
    2776      268636 :     else if (MATCH("HASH", 4))
    2777       26746 :         return_value = _readHash();
    2778      241890 :     else if (MATCH("SETOP", 5))
    2779         208 :         return_value = _readSetOp();
    2780      241682 :     else if (MATCH("LOCKROWS", 8))
    2781        4808 :         return_value = _readLockRows();
    2782      236874 :     else if (MATCH("LIMIT", 5))
    2783        2942 :         return_value = _readLimit();
    2784      233932 :     else if (MATCH("NESTLOOPPARAM", 13))
    2785       17348 :         return_value = _readNestLoopParam();
    2786      216584 :     else if (MATCH("PLANROWMARK", 11))
    2787       13256 :         return_value = _readPlanRowMark();
    2788      203328 :     else if (MATCH("PARTITIONPRUNEINFO", 18))
    2789         336 :         return_value = _readPartitionPruneInfo();
    2790      202992 :     else if (MATCH("PARTITIONEDRELPRUNEINFO", 23))
    2791         904 :         return_value = _readPartitionedRelPruneInfo();
    2792      202088 :     else if (MATCH("PARTITIONPRUNESTEPOP", 20))
    2793         672 :         return_value = _readPartitionPruneStepOp();
    2794      201416 :     else if (MATCH("PARTITIONPRUNESTEPCOMBINE", 25))
    2795         140 :         return_value = _readPartitionPruneStepCombine();
    2796      201276 :     else if (MATCH("PLANINVALITEM", 13))
    2797       91184 :         return_value = _readPlanInvalItem();
    2798      110092 :     else if (MATCH("SUBPLAN", 7))
    2799       46318 :         return_value = _readSubPlan();
    2800       63774 :     else if (MATCH("ALTERNATIVESUBPLAN", 18))
    2801        1166 :         return_value = _readAlternativeSubPlan();
    2802       62608 :     else if (MATCH("EXTENSIBLENODE", 14))
    2803           0 :         return_value = _readExtensibleNode();
    2804       62608 :     else if (MATCH("PARTITIONBOUNDSPEC", 18))
    2805       26864 :         return_value = _readPartitionBoundSpec();
    2806       35744 :     else if (MATCH("PARTITIONRANGEDATUM", 19))
    2807       35744 :         return_value = _readPartitionRangeDatum();
    2808             :     else
    2809             :     {
    2810           0 :         elog(ERROR, "badly formatted node string \"%.32s\"...", token);
    2811             :         return_value = NULL;    /* keep compiler quiet */
    2812             :     }
    2813             : 
    2814    27362564 :     return (Node *) return_value;
    2815             : }
    2816             : 
    2817             : 
    2818             : /*
    2819             :  * readDatum
    2820             :  *
    2821             :  * Given a string representation of a constant, recreate the appropriate
    2822             :  * Datum.  The string representation embeds length info, but not byValue,
    2823             :  * so we must be told that.
    2824             :  */
    2825             : Datum
    2826     1800920 : readDatum(bool typbyval)
    2827             : {
    2828             :     Size        length,
    2829             :                 i;
    2830             :     int         tokenLength;
    2831             :     const char *token;
    2832             :     Datum       res;
    2833             :     char       *s;
    2834             : 
    2835             :     /*
    2836             :      * read the actual length of the value
    2837             :      */
    2838     1800920 :     token = pg_strtok(&tokenLength);
    2839     1800920 :     length = atoui(token);
    2840             : 
    2841     1800920 :     token = pg_strtok(&tokenLength);    /* read the '[' */
    2842     1800920 :     if (token == NULL || token[0] != '[')
    2843           0 :         elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
    2844             :              token ? token : "[NULL]", length);
    2845             : 
    2846     1800920 :     if (typbyval)
    2847             :     {
    2848     1118096 :         if (length > (Size) sizeof(Datum))
    2849           0 :             elog(ERROR, "byval datum but length = %zu", length);
    2850     1118096 :         res = (Datum) 0;
    2851     1118096 :         s = (char *) (&res);
    2852    10062864 :         for (i = 0; i < (Size) sizeof(Datum); i++)
    2853             :         {
    2854     8944768 :             token = pg_strtok(&tokenLength);
    2855     8944768 :             s[i] = (char) atoi(token);
    2856             :         }
    2857             :     }
    2858      682824 :     else if (length <= 0)
    2859           0 :         res = (Datum) NULL;
    2860             :     else
    2861             :     {
    2862      682824 :         s = (char *) palloc(length);
    2863    37945774 :         for (i = 0; i < length; i++)
    2864             :         {
    2865    37262950 :             token = pg_strtok(&tokenLength);
    2866    37262950 :             s[i] = (char) atoi(token);
    2867             :         }
    2868      682824 :         res = PointerGetDatum(s);
    2869             :     }
    2870             : 
    2871     1800920 :     token = pg_strtok(&tokenLength);    /* read the ']' */
    2872     1800920 :     if (token == NULL || token[0] != ']')
    2873           0 :         elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
    2874             :              token ? token : "[NULL]", length);
    2875             : 
    2876     1800920 :     return res;
    2877             : }
    2878             : 
    2879             : /*
    2880             :  * readAttrNumberCols
    2881             :  */
    2882             : AttrNumber *
    2883       61132 : readAttrNumberCols(int numCols)
    2884             : {
    2885             :     int         tokenLength,
    2886             :                 i;
    2887             :     const char *token;
    2888             :     AttrNumber *attr_vals;
    2889             : 
    2890       61132 :     if (numCols <= 0)
    2891       23478 :         return NULL;
    2892             : 
    2893       37654 :     attr_vals = (AttrNumber *) palloc(numCols * sizeof(AttrNumber));
    2894       86210 :     for (i = 0; i < numCols; i++)
    2895             :     {
    2896       48556 :         token = pg_strtok(&tokenLength);
    2897       48556 :         attr_vals[i] = atoi(token);
    2898             :     }
    2899             : 
    2900       37654 :     return attr_vals;
    2901             : }
    2902             : 
    2903             : /*
    2904             :  * readOidCols
    2905             :  */
    2906             : Oid *
    2907      127080 : readOidCols(int numCols)
    2908             : {
    2909             :     int         tokenLength,
    2910             :                 i;
    2911             :     const char *token;
    2912             :     Oid        *oid_vals;
    2913             : 
    2914      127080 :     if (numCols <= 0)
    2915       46984 :         return NULL;
    2916             : 
    2917       80096 :     oid_vals = (Oid *) palloc(numCols * sizeof(Oid));
    2918      184172 :     for (i = 0; i < numCols; i++)
    2919             :     {
    2920      104076 :         token = pg_strtok(&tokenLength);
    2921      104076 :         oid_vals[i] = atooid(token);
    2922             :     }
    2923             : 
    2924       80096 :     return oid_vals;
    2925             : }
    2926             : 
    2927             : /*
    2928             :  * readIntCols
    2929             :  */
    2930             : int *
    2931        3764 : readIntCols(int numCols)
    2932             : {
    2933             :     int         tokenLength,
    2934             :                 i;
    2935             :     const char *token;
    2936             :     int        *int_vals;
    2937             : 
    2938        3764 :     if (numCols <= 0)
    2939          14 :         return NULL;
    2940             : 
    2941        3750 :     int_vals = (int *) palloc(numCols * sizeof(int));
    2942       11384 :     for (i = 0; i < numCols; i++)
    2943             :     {
    2944        7634 :         token = pg_strtok(&tokenLength);
    2945        7634 :         int_vals[i] = atoi(token);
    2946             :     }
    2947             : 
    2948        3750 :     return int_vals;
    2949             : }
    2950             : 
    2951             : /*
    2952             :  * readBoolCols
    2953             :  */
    2954             : bool *
    2955       33550 : readBoolCols(int numCols)
    2956             : {
    2957             :     int         tokenLength,
    2958             :                 i;
    2959             :     const char *token;
    2960             :     bool       *bool_vals;
    2961             : 
    2962       33550 :     if (numCols <= 0)
    2963          14 :         return NULL;
    2964             : 
    2965       33536 :     bool_vals = (bool *) palloc(numCols * sizeof(bool));
    2966       76038 :     for (i = 0; i < numCols; i++)
    2967             :     {
    2968       42502 :         token = pg_strtok(&tokenLength);
    2969       42502 :         bool_vals[i] = strtobool(token);
    2970             :     }
    2971             : 
    2972       33536 :     return bool_vals;
    2973             : }

Generated by: LCOV version 1.13