LCOV - code coverage report
Current view: top level - src/backend/nodes - readfuncs.funcs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 19devel Lines: 3195 3251 98.3 %
Date: 2025-07-29 03:18:01 Functions: 305 310 98.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * readfuncs.funcs.c
       4             :  *    Generated node infrastructure code
       5             :  *
       6             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * NOTES
      10             :  *  ******************************
      11             :  *  *** DO NOT EDIT THIS FILE! ***
      12             :  *  ******************************
      13             :  *
      14             :  *  It has been GENERATED by src/backend/nodes/gen_node_support.pl
      15             :  *
      16             :  *-------------------------------------------------------------------------
      17             :  */
      18             : #include "access/amapi.h"
      19             : #include "access/cmptype.h"
      20             : #include "access/sdir.h"
      21             : #include "access/tableam.h"
      22             : #include "access/tsmapi.h"
      23             : #include "commands/event_trigger.h"
      24             : #include "commands/trigger.h"
      25             : #include "executor/tuptable.h"
      26             : #include "foreign/fdwapi.h"
      27             : #include "nodes/bitmapset.h"
      28             : #include "nodes/execnodes.h"
      29             : #include "nodes/extensible.h"
      30             : #include "nodes/lockoptions.h"
      31             : #include "nodes/miscnodes.h"
      32             : #include "nodes/nodes.h"
      33             : #include "nodes/parsenodes.h"
      34             : #include "nodes/pathnodes.h"
      35             : #include "nodes/plannodes.h"
      36             : #include "nodes/primnodes.h"
      37             : #include "nodes/replnodes.h"
      38             : #include "nodes/supportnodes.h"
      39             : #include "nodes/value.h"
      40             : #include "utils/rel.h"
      41             : 
      42             : static Alias *
      43     2898588 : _readAlias(void)
      44             : {
      45     2898588 :     READ_LOCALS(Alias);
      46             : 
      47     2898588 :     READ_STRING_FIELD(aliasname);
      48     2898588 :     READ_NODE_FIELD(colnames);
      49             : 
      50     2898588 :     READ_DONE();
      51             : }
      52             : 
      53             : static RangeVar *
      54      903002 : _readRangeVar(void)
      55             : {
      56      903002 :     READ_LOCALS(RangeVar);
      57             : 
      58      903002 :     READ_STRING_FIELD(catalogname);
      59      903002 :     READ_STRING_FIELD(schemaname);
      60      903002 :     READ_STRING_FIELD(relname);
      61      903002 :     READ_BOOL_FIELD(inh);
      62      903002 :     READ_CHAR_FIELD(relpersistence);
      63      903002 :     READ_NODE_FIELD(alias);
      64      903002 :     READ_LOCATION_FIELD(location);
      65             : 
      66      903002 :     READ_DONE();
      67             : }
      68             : 
      69             : static TableFunc *
      70        1520 : _readTableFunc(void)
      71             : {
      72        1520 :     READ_LOCALS(TableFunc);
      73             : 
      74        1520 :     READ_ENUM_FIELD(functype, TableFuncType);
      75        1520 :     READ_NODE_FIELD(ns_uris);
      76        1520 :     READ_NODE_FIELD(ns_names);
      77        1520 :     READ_NODE_FIELD(docexpr);
      78        1520 :     READ_NODE_FIELD(rowexpr);
      79        1520 :     READ_NODE_FIELD(colnames);
      80        1520 :     READ_NODE_FIELD(coltypes);
      81        1520 :     READ_NODE_FIELD(coltypmods);
      82        1520 :     READ_NODE_FIELD(colcollations);
      83        1520 :     READ_NODE_FIELD(colexprs);
      84        1520 :     READ_NODE_FIELD(coldefexprs);
      85        1520 :     READ_NODE_FIELD(colvalexprs);
      86        1520 :     READ_NODE_FIELD(passingvalexprs);
      87        1520 :     READ_BITMAPSET_FIELD(notnulls);
      88        1520 :     READ_NODE_FIELD(plan);
      89        1520 :     READ_INT_FIELD(ordinalitycol);
      90        1520 :     READ_LOCATION_FIELD(location);
      91             : 
      92        1520 :     READ_DONE();
      93             : }
      94             : 
      95             : static IntoClause *
      96        3950 : _readIntoClause(void)
      97             : {
      98        3950 :     READ_LOCALS(IntoClause);
      99             : 
     100        3950 :     READ_NODE_FIELD(rel);
     101        3950 :     READ_NODE_FIELD(colNames);
     102        3950 :     READ_STRING_FIELD(accessMethod);
     103        3950 :     READ_NODE_FIELD(options);
     104        3950 :     READ_ENUM_FIELD(onCommit, OnCommitAction);
     105        3950 :     READ_STRING_FIELD(tableSpaceName);
     106        3950 :     READ_NODE_FIELD(viewQuery);
     107        3950 :     READ_BOOL_FIELD(skipData);
     108             : 
     109        3950 :     READ_DONE();
     110             : }
     111             : 
     112             : static Var *
     113    13457904 : _readVar(void)
     114             : {
     115    13457904 :     READ_LOCALS(Var);
     116             : 
     117    13457904 :     READ_INT_FIELD(varno);
     118    13457904 :     READ_INT_FIELD(varattno);
     119    13457904 :     READ_OID_FIELD(vartype);
     120    13457904 :     READ_INT_FIELD(vartypmod);
     121    13457904 :     READ_OID_FIELD(varcollid);
     122    13457904 :     READ_BITMAPSET_FIELD(varnullingrels);
     123    13457904 :     READ_UINT_FIELD(varlevelsup);
     124    13457904 :     READ_ENUM_FIELD(varreturningtype, VarReturningType);
     125    13457904 :     READ_UINT_FIELD(varnosyn);
     126    13457904 :     READ_INT_FIELD(varattnosyn);
     127    13457904 :     READ_LOCATION_FIELD(location);
     128             : 
     129    13457904 :     READ_DONE();
     130             : }
     131             : 
     132             : static Param *
     133      327398 : _readParam(void)
     134             : {
     135      327398 :     READ_LOCALS(Param);
     136             : 
     137      327398 :     READ_ENUM_FIELD(paramkind, ParamKind);
     138      327398 :     READ_INT_FIELD(paramid);
     139      327398 :     READ_OID_FIELD(paramtype);
     140      327398 :     READ_INT_FIELD(paramtypmod);
     141      327398 :     READ_OID_FIELD(paramcollid);
     142      327398 :     READ_LOCATION_FIELD(location);
     143             : 
     144      327398 :     READ_DONE();
     145             : }
     146             : 
     147             : static Aggref *
     148       95534 : _readAggref(void)
     149             : {
     150       95534 :     READ_LOCALS(Aggref);
     151             : 
     152       95534 :     READ_OID_FIELD(aggfnoid);
     153       95534 :     READ_OID_FIELD(aggtype);
     154       95534 :     READ_OID_FIELD(aggcollid);
     155       95534 :     READ_OID_FIELD(inputcollid);
     156       95534 :     READ_OID_FIELD(aggtranstype);
     157       95534 :     READ_NODE_FIELD(aggargtypes);
     158       95534 :     READ_NODE_FIELD(aggdirectargs);
     159       95534 :     READ_NODE_FIELD(args);
     160       95534 :     READ_NODE_FIELD(aggorder);
     161       95534 :     READ_NODE_FIELD(aggdistinct);
     162       95534 :     READ_NODE_FIELD(aggfilter);
     163       95534 :     READ_BOOL_FIELD(aggstar);
     164       95534 :     READ_BOOL_FIELD(aggvariadic);
     165       95534 :     READ_CHAR_FIELD(aggkind);
     166       95534 :     READ_BOOL_FIELD(aggpresorted);
     167       95534 :     READ_UINT_FIELD(agglevelsup);
     168       95534 :     READ_ENUM_FIELD(aggsplit, AggSplit);
     169       95534 :     READ_INT_FIELD(aggno);
     170       95534 :     READ_INT_FIELD(aggtransno);
     171       95534 :     READ_LOCATION_FIELD(location);
     172             : 
     173       95534 :     READ_DONE();
     174             : }
     175             : 
     176             : static GroupingFunc *
     177        1090 : _readGroupingFunc(void)
     178             : {
     179        1090 :     READ_LOCALS(GroupingFunc);
     180             : 
     181        1090 :     READ_NODE_FIELD(args);
     182        1090 :     READ_NODE_FIELD(refs);
     183        1090 :     READ_NODE_FIELD(cols);
     184        1090 :     READ_UINT_FIELD(agglevelsup);
     185        1090 :     READ_LOCATION_FIELD(location);
     186             : 
     187        1090 :     READ_DONE();
     188             : }
     189             : 
     190             : static WindowFunc *
     191        7028 : _readWindowFunc(void)
     192             : {
     193        7028 :     READ_LOCALS(WindowFunc);
     194             : 
     195        7028 :     READ_OID_FIELD(winfnoid);
     196        7028 :     READ_OID_FIELD(wintype);
     197        7028 :     READ_OID_FIELD(wincollid);
     198        7028 :     READ_OID_FIELD(inputcollid);
     199        7028 :     READ_NODE_FIELD(args);
     200        7028 :     READ_NODE_FIELD(aggfilter);
     201        7028 :     READ_NODE_FIELD(runCondition);
     202        7028 :     READ_UINT_FIELD(winref);
     203        7028 :     READ_BOOL_FIELD(winstar);
     204        7028 :     READ_BOOL_FIELD(winagg);
     205        7028 :     READ_LOCATION_FIELD(location);
     206             : 
     207        7028 :     READ_DONE();
     208             : }
     209             : 
     210             : static WindowFuncRunCondition *
     211         360 : _readWindowFuncRunCondition(void)
     212             : {
     213         360 :     READ_LOCALS(WindowFuncRunCondition);
     214             : 
     215         360 :     READ_OID_FIELD(opno);
     216         360 :     READ_OID_FIELD(inputcollid);
     217         360 :     READ_BOOL_FIELD(wfunc_left);
     218         360 :     READ_NODE_FIELD(arg);
     219             : 
     220         360 :     READ_DONE();
     221             : }
     222             : 
     223             : static MergeSupportFunc *
     224         834 : _readMergeSupportFunc(void)
     225             : {
     226         834 :     READ_LOCALS(MergeSupportFunc);
     227             : 
     228         834 :     READ_OID_FIELD(msftype);
     229         834 :     READ_OID_FIELD(msfcollid);
     230         834 :     READ_LOCATION_FIELD(location);
     231             : 
     232         834 :     READ_DONE();
     233             : }
     234             : 
     235             : static SubscriptingRef *
     236       37156 : _readSubscriptingRef(void)
     237             : {
     238       37156 :     READ_LOCALS(SubscriptingRef);
     239             : 
     240       37156 :     READ_OID_FIELD(refcontainertype);
     241       37156 :     READ_OID_FIELD(refelemtype);
     242       37156 :     READ_OID_FIELD(refrestype);
     243       37156 :     READ_INT_FIELD(reftypmod);
     244       37156 :     READ_OID_FIELD(refcollid);
     245       37156 :     READ_NODE_FIELD(refupperindexpr);
     246       37156 :     READ_NODE_FIELD(reflowerindexpr);
     247       37156 :     READ_NODE_FIELD(refexpr);
     248       37156 :     READ_NODE_FIELD(refassgnexpr);
     249             : 
     250       37156 :     READ_DONE();
     251             : }
     252             : 
     253             : static FuncExpr *
     254      956508 : _readFuncExpr(void)
     255             : {
     256      956508 :     READ_LOCALS(FuncExpr);
     257             : 
     258      956508 :     READ_OID_FIELD(funcid);
     259      956508 :     READ_OID_FIELD(funcresulttype);
     260      956508 :     READ_BOOL_FIELD(funcretset);
     261      956508 :     READ_BOOL_FIELD(funcvariadic);
     262      956508 :     READ_ENUM_FIELD(funcformat, CoercionForm);
     263      956508 :     READ_OID_FIELD(funccollid);
     264      956508 :     READ_OID_FIELD(inputcollid);
     265      956508 :     READ_NODE_FIELD(args);
     266      956508 :     READ_LOCATION_FIELD(location);
     267             : 
     268      956508 :     READ_DONE();
     269             : }
     270             : 
     271             : static NamedArgExpr *
     272       94066 : _readNamedArgExpr(void)
     273             : {
     274       94066 :     READ_LOCALS(NamedArgExpr);
     275             : 
     276       94066 :     READ_NODE_FIELD(arg);
     277       94066 :     READ_STRING_FIELD(name);
     278       94066 :     READ_INT_FIELD(argnumber);
     279       94066 :     READ_LOCATION_FIELD(location);
     280             : 
     281       94066 :     READ_DONE();
     282             : }
     283             : 
     284             : static OpExpr *
     285     1564496 : _readOpExpr(void)
     286             : {
     287     1564496 :     READ_LOCALS(OpExpr);
     288             : 
     289     1564496 :     READ_OID_FIELD(opno);
     290     1564496 :     READ_OID_FIELD(opfuncid);
     291     1564496 :     READ_OID_FIELD(opresulttype);
     292     1564496 :     READ_BOOL_FIELD(opretset);
     293     1564496 :     READ_OID_FIELD(opcollid);
     294     1564496 :     READ_OID_FIELD(inputcollid);
     295     1564496 :     READ_NODE_FIELD(args);
     296     1564496 :     READ_LOCATION_FIELD(location);
     297             : 
     298     1564496 :     READ_DONE();
     299             : }
     300             : 
     301             : static DistinctExpr *
     302        2544 : _readDistinctExpr(void)
     303             : {
     304        2544 :     READ_LOCALS(DistinctExpr);
     305             : 
     306        2544 :     READ_OID_FIELD(opno);
     307        2544 :     READ_OID_FIELD(opfuncid);
     308        2544 :     READ_OID_FIELD(opresulttype);
     309        2544 :     READ_BOOL_FIELD(opretset);
     310        2544 :     READ_OID_FIELD(opcollid);
     311        2544 :     READ_OID_FIELD(inputcollid);
     312        2544 :     READ_NODE_FIELD(args);
     313        2544 :     READ_LOCATION_FIELD(location);
     314             : 
     315        2544 :     READ_DONE();
     316             : }
     317             : 
     318             : static NullIfExpr *
     319        1258 : _readNullIfExpr(void)
     320             : {
     321        1258 :     READ_LOCALS(NullIfExpr);
     322             : 
     323        1258 :     READ_OID_FIELD(opno);
     324        1258 :     READ_OID_FIELD(opfuncid);
     325        1258 :     READ_OID_FIELD(opresulttype);
     326        1258 :     READ_BOOL_FIELD(opretset);
     327        1258 :     READ_OID_FIELD(opcollid);
     328        1258 :     READ_OID_FIELD(inputcollid);
     329        1258 :     READ_NODE_FIELD(args);
     330        1258 :     READ_LOCATION_FIELD(location);
     331             : 
     332        1258 :     READ_DONE();
     333             : }
     334             : 
     335             : static ScalarArrayOpExpr *
     336       79356 : _readScalarArrayOpExpr(void)
     337             : {
     338       79356 :     READ_LOCALS(ScalarArrayOpExpr);
     339             : 
     340       79356 :     READ_OID_FIELD(opno);
     341       79356 :     READ_OID_FIELD(opfuncid);
     342       79356 :     READ_OID_FIELD(hashfuncid);
     343       79356 :     READ_OID_FIELD(negfuncid);
     344       79356 :     READ_BOOL_FIELD(useOr);
     345       79356 :     READ_OID_FIELD(inputcollid);
     346       79356 :     READ_NODE_FIELD(args);
     347       79356 :     READ_LOCATION_FIELD(location);
     348             : 
     349       79356 :     READ_DONE();
     350             : }
     351             : 
     352             : static SubLink *
     353      108268 : _readSubLink(void)
     354             : {
     355      108268 :     READ_LOCALS(SubLink);
     356             : 
     357      108268 :     READ_ENUM_FIELD(subLinkType, SubLinkType);
     358      108268 :     READ_INT_FIELD(subLinkId);
     359      108268 :     READ_NODE_FIELD(testexpr);
     360      108268 :     READ_NODE_FIELD(operName);
     361      108268 :     READ_NODE_FIELD(subselect);
     362      108268 :     READ_LOCATION_FIELD(location);
     363             : 
     364      108268 :     READ_DONE();
     365             : }
     366             : 
     367             : static SubPlan *
     368       44970 : _readSubPlan(void)
     369             : {
     370       44970 :     READ_LOCALS(SubPlan);
     371             : 
     372       44970 :     READ_ENUM_FIELD(subLinkType, SubLinkType);
     373       44970 :     READ_NODE_FIELD(testexpr);
     374       44970 :     READ_NODE_FIELD(paramIds);
     375       44970 :     READ_INT_FIELD(plan_id);
     376       44970 :     READ_STRING_FIELD(plan_name);
     377       44970 :     READ_OID_FIELD(firstColType);
     378       44970 :     READ_INT_FIELD(firstColTypmod);
     379       44970 :     READ_OID_FIELD(firstColCollation);
     380       44970 :     READ_BOOL_FIELD(useHashTable);
     381       44970 :     READ_BOOL_FIELD(unknownEqFalse);
     382       44970 :     READ_BOOL_FIELD(parallel_safe);
     383       44970 :     READ_NODE_FIELD(setParam);
     384       44970 :     READ_NODE_FIELD(parParam);
     385       44970 :     READ_NODE_FIELD(args);
     386       44970 :     READ_FLOAT_FIELD(startup_cost);
     387       44970 :     READ_FLOAT_FIELD(per_call_cost);
     388             : 
     389       44970 :     READ_DONE();
     390             : }
     391             : 
     392             : static AlternativeSubPlan *
     393           0 : _readAlternativeSubPlan(void)
     394             : {
     395           0 :     READ_LOCALS(AlternativeSubPlan);
     396             : 
     397           0 :     READ_NODE_FIELD(subplans);
     398             : 
     399           0 :     READ_DONE();
     400             : }
     401             : 
     402             : static FieldSelect *
     403       31132 : _readFieldSelect(void)
     404             : {
     405       31132 :     READ_LOCALS(FieldSelect);
     406             : 
     407       31132 :     READ_NODE_FIELD(arg);
     408       31132 :     READ_INT_FIELD(fieldnum);
     409       31132 :     READ_OID_FIELD(resulttype);
     410       31132 :     READ_INT_FIELD(resulttypmod);
     411       31132 :     READ_OID_FIELD(resultcollid);
     412             : 
     413       31132 :     READ_DONE();
     414             : }
     415             : 
     416             : static FieldStore *
     417        1106 : _readFieldStore(void)
     418             : {
     419        1106 :     READ_LOCALS(FieldStore);
     420             : 
     421        1106 :     READ_NODE_FIELD(arg);
     422        1106 :     READ_NODE_FIELD(newvals);
     423        1106 :     READ_NODE_FIELD(fieldnums);
     424        1106 :     READ_OID_FIELD(resulttype);
     425             : 
     426        1106 :     READ_DONE();
     427             : }
     428             : 
     429             : static RelabelType *
     430      275454 : _readRelabelType(void)
     431             : {
     432      275454 :     READ_LOCALS(RelabelType);
     433             : 
     434      275454 :     READ_NODE_FIELD(arg);
     435      275454 :     READ_OID_FIELD(resulttype);
     436      275454 :     READ_INT_FIELD(resulttypmod);
     437      275454 :     READ_OID_FIELD(resultcollid);
     438      275454 :     READ_ENUM_FIELD(relabelformat, CoercionForm);
     439      275454 :     READ_LOCATION_FIELD(location);
     440             : 
     441      275454 :     READ_DONE();
     442             : }
     443             : 
     444             : static CoerceViaIO *
     445       51982 : _readCoerceViaIO(void)
     446             : {
     447       51982 :     READ_LOCALS(CoerceViaIO);
     448             : 
     449       51982 :     READ_NODE_FIELD(arg);
     450       51982 :     READ_OID_FIELD(resulttype);
     451       51982 :     READ_OID_FIELD(resultcollid);
     452       51982 :     READ_ENUM_FIELD(coerceformat, CoercionForm);
     453       51982 :     READ_LOCATION_FIELD(location);
     454             : 
     455       51982 :     READ_DONE();
     456             : }
     457             : 
     458             : static ArrayCoerceExpr *
     459       11272 : _readArrayCoerceExpr(void)
     460             : {
     461       11272 :     READ_LOCALS(ArrayCoerceExpr);
     462             : 
     463       11272 :     READ_NODE_FIELD(arg);
     464       11272 :     READ_NODE_FIELD(elemexpr);
     465       11272 :     READ_OID_FIELD(resulttype);
     466       11272 :     READ_INT_FIELD(resulttypmod);
     467       11272 :     READ_OID_FIELD(resultcollid);
     468       11272 :     READ_ENUM_FIELD(coerceformat, CoercionForm);
     469       11272 :     READ_LOCATION_FIELD(location);
     470             : 
     471       11272 :     READ_DONE();
     472             : }
     473             : 
     474             : static ConvertRowtypeExpr *
     475         842 : _readConvertRowtypeExpr(void)
     476             : {
     477         842 :     READ_LOCALS(ConvertRowtypeExpr);
     478             : 
     479         842 :     READ_NODE_FIELD(arg);
     480         842 :     READ_OID_FIELD(resulttype);
     481         842 :     READ_ENUM_FIELD(convertformat, CoercionForm);
     482         842 :     READ_LOCATION_FIELD(location);
     483             : 
     484         842 :     READ_DONE();
     485             : }
     486             : 
     487             : static CollateExpr *
     488        9030 : _readCollateExpr(void)
     489             : {
     490        9030 :     READ_LOCALS(CollateExpr);
     491             : 
     492        9030 :     READ_NODE_FIELD(arg);
     493        9030 :     READ_OID_FIELD(collOid);
     494        9030 :     READ_LOCATION_FIELD(location);
     495             : 
     496        9030 :     READ_DONE();
     497             : }
     498             : 
     499             : static CaseExpr *
     500      145036 : _readCaseExpr(void)
     501             : {
     502      145036 :     READ_LOCALS(CaseExpr);
     503             : 
     504      145036 :     READ_OID_FIELD(casetype);
     505      145036 :     READ_OID_FIELD(casecollid);
     506      145036 :     READ_NODE_FIELD(arg);
     507      145036 :     READ_NODE_FIELD(args);
     508      145036 :     READ_NODE_FIELD(defresult);
     509      145036 :     READ_LOCATION_FIELD(location);
     510             : 
     511      145036 :     READ_DONE();
     512             : }
     513             : 
     514             : static CaseWhen *
     515      273238 : _readCaseWhen(void)
     516             : {
     517      273238 :     READ_LOCALS(CaseWhen);
     518             : 
     519      273238 :     READ_NODE_FIELD(expr);
     520      273238 :     READ_NODE_FIELD(result);
     521      273238 :     READ_LOCATION_FIELD(location);
     522             : 
     523      273238 :     READ_DONE();
     524             : }
     525             : 
     526             : static CaseTestExpr *
     527       61194 : _readCaseTestExpr(void)
     528             : {
     529       61194 :     READ_LOCALS(CaseTestExpr);
     530             : 
     531       61194 :     READ_OID_FIELD(typeId);
     532       61194 :     READ_INT_FIELD(typeMod);
     533       61194 :     READ_OID_FIELD(collation);
     534             : 
     535       61194 :     READ_DONE();
     536             : }
     537             : 
     538             : static ArrayExpr *
     539       38220 : _readArrayExpr(void)
     540             : {
     541       38220 :     READ_LOCALS(ArrayExpr);
     542             : 
     543       38220 :     READ_OID_FIELD(array_typeid);
     544       38220 :     READ_OID_FIELD(array_collid);
     545       38220 :     READ_OID_FIELD(element_typeid);
     546       38220 :     READ_NODE_FIELD(elements);
     547       38220 :     READ_BOOL_FIELD(multidims);
     548       38220 :     READ_LOCATION_FIELD(list_start);
     549       38220 :     READ_LOCATION_FIELD(list_end);
     550       38220 :     READ_LOCATION_FIELD(location);
     551             : 
     552       38220 :     READ_DONE();
     553             : }
     554             : 
     555             : static RowExpr *
     556       13402 : _readRowExpr(void)
     557             : {
     558       13402 :     READ_LOCALS(RowExpr);
     559             : 
     560       13402 :     READ_NODE_FIELD(args);
     561       13402 :     READ_OID_FIELD(row_typeid);
     562       13402 :     READ_ENUM_FIELD(row_format, CoercionForm);
     563       13402 :     READ_NODE_FIELD(colnames);
     564       13402 :     READ_LOCATION_FIELD(location);
     565             : 
     566       13402 :     READ_DONE();
     567             : }
     568             : 
     569             : static RowCompareExpr *
     570         744 : _readRowCompareExpr(void)
     571             : {
     572         744 :     READ_LOCALS(RowCompareExpr);
     573             : 
     574         744 :     READ_ENUM_FIELD(cmptype, CompareType);
     575         744 :     READ_NODE_FIELD(opnos);
     576         744 :     READ_NODE_FIELD(opfamilies);
     577         744 :     READ_NODE_FIELD(inputcollids);
     578         744 :     READ_NODE_FIELD(largs);
     579         744 :     READ_NODE_FIELD(rargs);
     580             : 
     581         744 :     READ_DONE();
     582             : }
     583             : 
     584             : static CoalesceExpr *
     585       19536 : _readCoalesceExpr(void)
     586             : {
     587       19536 :     READ_LOCALS(CoalesceExpr);
     588             : 
     589       19536 :     READ_OID_FIELD(coalescetype);
     590       19536 :     READ_OID_FIELD(coalescecollid);
     591       19536 :     READ_NODE_FIELD(args);
     592       19536 :     READ_LOCATION_FIELD(location);
     593             : 
     594       19536 :     READ_DONE();
     595             : }
     596             : 
     597             : static MinMaxExpr *
     598         888 : _readMinMaxExpr(void)
     599             : {
     600         888 :     READ_LOCALS(MinMaxExpr);
     601             : 
     602         888 :     READ_OID_FIELD(minmaxtype);
     603         888 :     READ_OID_FIELD(minmaxcollid);
     604         888 :     READ_OID_FIELD(inputcollid);
     605         888 :     READ_ENUM_FIELD(op, MinMaxOp);
     606         888 :     READ_NODE_FIELD(args);
     607         888 :     READ_LOCATION_FIELD(location);
     608             : 
     609         888 :     READ_DONE();
     610             : }
     611             : 
     612             : static SQLValueFunction *
     613       14002 : _readSQLValueFunction(void)
     614             : {
     615       14002 :     READ_LOCALS(SQLValueFunction);
     616             : 
     617       14002 :     READ_ENUM_FIELD(op, SQLValueFunctionOp);
     618       14002 :     READ_OID_FIELD(type);
     619       14002 :     READ_INT_FIELD(typmod);
     620       14002 :     READ_LOCATION_FIELD(location);
     621             : 
     622       14002 :     READ_DONE();
     623             : }
     624             : 
     625             : static XmlExpr *
     626        2710 : _readXmlExpr(void)
     627             : {
     628        2710 :     READ_LOCALS(XmlExpr);
     629             : 
     630        2710 :     READ_ENUM_FIELD(op, XmlExprOp);
     631        2710 :     READ_STRING_FIELD(name);
     632        2710 :     READ_NODE_FIELD(named_args);
     633        2710 :     READ_NODE_FIELD(arg_names);
     634        2710 :     READ_NODE_FIELD(args);
     635        2710 :     READ_ENUM_FIELD(xmloption, XmlOptionType);
     636        2710 :     READ_BOOL_FIELD(indent);
     637        2710 :     READ_OID_FIELD(type);
     638        2710 :     READ_INT_FIELD(typmod);
     639        2710 :     READ_LOCATION_FIELD(location);
     640             : 
     641        2710 :     READ_DONE();
     642             : }
     643             : 
     644             : static JsonFormat *
     645       24532 : _readJsonFormat(void)
     646             : {
     647       24532 :     READ_LOCALS(JsonFormat);
     648             : 
     649       24532 :     READ_ENUM_FIELD(format_type, JsonFormatType);
     650       24532 :     READ_ENUM_FIELD(encoding, JsonEncoding);
     651       24532 :     READ_LOCATION_FIELD(location);
     652             : 
     653       24532 :     READ_DONE();
     654             : }
     655             : 
     656             : static JsonReturning *
     657       10412 : _readJsonReturning(void)
     658             : {
     659       10412 :     READ_LOCALS(JsonReturning);
     660             : 
     661       10412 :     READ_NODE_FIELD(format);
     662       10412 :     READ_OID_FIELD(typid);
     663       10412 :     READ_INT_FIELD(typmod);
     664             : 
     665       10412 :     READ_DONE();
     666             : }
     667             : 
     668             : static JsonValueExpr *
     669        6350 : _readJsonValueExpr(void)
     670             : {
     671        6350 :     READ_LOCALS(JsonValueExpr);
     672             : 
     673        6350 :     READ_NODE_FIELD(raw_expr);
     674        6350 :     READ_NODE_FIELD(formatted_expr);
     675        6350 :     READ_NODE_FIELD(format);
     676             : 
     677        6350 :     READ_DONE();
     678             : }
     679             : 
     680             : static JsonConstructorExpr *
     681        2798 : _readJsonConstructorExpr(void)
     682             : {
     683        2798 :     READ_LOCALS(JsonConstructorExpr);
     684             : 
     685        2798 :     READ_ENUM_FIELD(type, JsonConstructorType);
     686        2798 :     READ_NODE_FIELD(args);
     687        2798 :     READ_NODE_FIELD(func);
     688        2798 :     READ_NODE_FIELD(coercion);
     689        2798 :     READ_NODE_FIELD(returning);
     690        2798 :     READ_BOOL_FIELD(absent_on_null);
     691        2798 :     READ_BOOL_FIELD(unique);
     692        2798 :     READ_LOCATION_FIELD(location);
     693             : 
     694        2798 :     READ_DONE();
     695             : }
     696             : 
     697             : static JsonIsPredicate *
     698        1128 : _readJsonIsPredicate(void)
     699             : {
     700        1128 :     READ_LOCALS(JsonIsPredicate);
     701             : 
     702        1128 :     READ_NODE_FIELD(expr);
     703        1128 :     READ_NODE_FIELD(format);
     704        1128 :     READ_ENUM_FIELD(item_type, JsonValueType);
     705        1128 :     READ_BOOL_FIELD(unique_keys);
     706        1128 :     READ_LOCATION_FIELD(location);
     707             : 
     708        1128 :     READ_DONE();
     709             : }
     710             : 
     711             : static JsonBehavior *
     712       11766 : _readJsonBehavior(void)
     713             : {
     714       11766 :     READ_LOCALS(JsonBehavior);
     715             : 
     716       11766 :     READ_ENUM_FIELD(btype, JsonBehaviorType);
     717       11766 :     READ_NODE_FIELD(expr);
     718       11766 :     READ_BOOL_FIELD(coerce);
     719       11766 :     READ_LOCATION_FIELD(location);
     720             : 
     721       11766 :     READ_DONE();
     722             : }
     723             : 
     724             : static JsonExpr *
     725        6128 : _readJsonExpr(void)
     726             : {
     727        6128 :     READ_LOCALS(JsonExpr);
     728             : 
     729        6128 :     READ_ENUM_FIELD(op, JsonExprOp);
     730        6128 :     READ_STRING_FIELD(column_name);
     731        6128 :     READ_NODE_FIELD(formatted_expr);
     732        6128 :     READ_NODE_FIELD(format);
     733        6128 :     READ_NODE_FIELD(path_spec);
     734        6128 :     READ_NODE_FIELD(returning);
     735        6128 :     READ_NODE_FIELD(passing_names);
     736        6128 :     READ_NODE_FIELD(passing_values);
     737        6128 :     READ_NODE_FIELD(on_empty);
     738        6128 :     READ_NODE_FIELD(on_error);
     739        6128 :     READ_BOOL_FIELD(use_io_coercion);
     740        6128 :     READ_BOOL_FIELD(use_json_coercion);
     741        6128 :     READ_ENUM_FIELD(wrapper, JsonWrapper);
     742        6128 :     READ_BOOL_FIELD(omit_quotes);
     743        6128 :     READ_OID_FIELD(collation);
     744        6128 :     READ_LOCATION_FIELD(location);
     745             : 
     746        6128 :     READ_DONE();
     747             : }
     748             : 
     749             : static JsonTablePath *
     750        1568 : _readJsonTablePath(void)
     751             : {
     752        1568 :     READ_LOCALS(JsonTablePath);
     753             : 
     754        1568 :     READ_NODE_FIELD(value);
     755        1568 :     READ_STRING_FIELD(name);
     756             : 
     757        1568 :     READ_DONE();
     758             : }
     759             : 
     760             : static JsonTablePathScan *
     761        1568 : _readJsonTablePathScan(void)
     762             : {
     763        1568 :     READ_LOCALS(JsonTablePathScan);
     764             : 
     765        1568 :     READ_NODE_FIELD(path);
     766        1568 :     READ_BOOL_FIELD(errorOnError);
     767        1568 :     READ_NODE_FIELD(child);
     768        1568 :     READ_INT_FIELD(colMin);
     769        1568 :     READ_INT_FIELD(colMax);
     770             : 
     771        1568 :     READ_DONE();
     772             : }
     773             : 
     774             : static JsonTableSiblingJoin *
     775         210 : _readJsonTableSiblingJoin(void)
     776             : {
     777         210 :     READ_LOCALS(JsonTableSiblingJoin);
     778             : 
     779         210 :     READ_NODE_FIELD(lplan);
     780         210 :     READ_NODE_FIELD(rplan);
     781             : 
     782         210 :     READ_DONE();
     783             : }
     784             : 
     785             : static NullTest *
     786       57300 : _readNullTest(void)
     787             : {
     788       57300 :     READ_LOCALS(NullTest);
     789             : 
     790       57300 :     READ_NODE_FIELD(arg);
     791       57300 :     READ_ENUM_FIELD(nulltesttype, NullTestType);
     792       57300 :     READ_BOOL_FIELD(argisrow);
     793       57300 :     READ_LOCATION_FIELD(location);
     794             : 
     795       57300 :     READ_DONE();
     796             : }
     797             : 
     798             : static BooleanTest *
     799        3810 : _readBooleanTest(void)
     800             : {
     801        3810 :     READ_LOCALS(BooleanTest);
     802             : 
     803        3810 :     READ_NODE_FIELD(arg);
     804        3810 :     READ_ENUM_FIELD(booltesttype, BoolTestType);
     805        3810 :     READ_LOCATION_FIELD(location);
     806             : 
     807        3810 :     READ_DONE();
     808             : }
     809             : 
     810             : static MergeAction *
     811        6558 : _readMergeAction(void)
     812             : {
     813        6558 :     READ_LOCALS(MergeAction);
     814             : 
     815        6558 :     READ_ENUM_FIELD(matchKind, MergeMatchKind);
     816        6558 :     READ_ENUM_FIELD(commandType, CmdType);
     817        6558 :     READ_ENUM_FIELD(override, OverridingKind);
     818        6558 :     READ_NODE_FIELD(qual);
     819        6558 :     READ_NODE_FIELD(targetList);
     820        6558 :     READ_NODE_FIELD(updateColnos);
     821             : 
     822        6558 :     READ_DONE();
     823             : }
     824             : 
     825             : static CoerceToDomain *
     826      143072 : _readCoerceToDomain(void)
     827             : {
     828      143072 :     READ_LOCALS(CoerceToDomain);
     829             : 
     830      143072 :     READ_NODE_FIELD(arg);
     831      143072 :     READ_OID_FIELD(resulttype);
     832      143072 :     READ_INT_FIELD(resulttypmod);
     833      143072 :     READ_OID_FIELD(resultcollid);
     834      143072 :     READ_ENUM_FIELD(coercionformat, CoercionForm);
     835      143072 :     READ_LOCATION_FIELD(location);
     836             : 
     837      143072 :     READ_DONE();
     838             : }
     839             : 
     840             : static CoerceToDomainValue *
     841        2146 : _readCoerceToDomainValue(void)
     842             : {
     843        2146 :     READ_LOCALS(CoerceToDomainValue);
     844             : 
     845        2146 :     READ_OID_FIELD(typeId);
     846        2146 :     READ_INT_FIELD(typeMod);
     847        2146 :     READ_OID_FIELD(collation);
     848        2146 :     READ_LOCATION_FIELD(location);
     849             : 
     850        2146 :     READ_DONE();
     851             : }
     852             : 
     853             : static SetToDefault *
     854        1902 : _readSetToDefault(void)
     855             : {
     856        1902 :     READ_LOCALS(SetToDefault);
     857             : 
     858        1902 :     READ_OID_FIELD(typeId);
     859        1902 :     READ_INT_FIELD(typeMod);
     860        1902 :     READ_OID_FIELD(collation);
     861        1902 :     READ_LOCATION_FIELD(location);
     862             : 
     863        1902 :     READ_DONE();
     864             : }
     865             : 
     866             : static CurrentOfExpr *
     867         902 : _readCurrentOfExpr(void)
     868             : {
     869         902 :     READ_LOCALS(CurrentOfExpr);
     870             : 
     871         902 :     READ_UINT_FIELD(cvarno);
     872         902 :     READ_STRING_FIELD(cursor_name);
     873         902 :     READ_INT_FIELD(cursor_param);
     874             : 
     875         902 :     READ_DONE();
     876             : }
     877             : 
     878             : static NextValueExpr *
     879         820 : _readNextValueExpr(void)
     880             : {
     881         820 :     READ_LOCALS(NextValueExpr);
     882             : 
     883         820 :     READ_OID_FIELD(seqid);
     884         820 :     READ_OID_FIELD(typeId);
     885             : 
     886         820 :     READ_DONE();
     887             : }
     888             : 
     889             : static InferenceElem *
     890        1882 : _readInferenceElem(void)
     891             : {
     892        1882 :     READ_LOCALS(InferenceElem);
     893             : 
     894        1882 :     READ_NODE_FIELD(expr);
     895        1882 :     READ_OID_FIELD(infercollid);
     896        1882 :     READ_OID_FIELD(inferopclass);
     897             : 
     898        1882 :     READ_DONE();
     899             : }
     900             : 
     901             : static ReturningExpr *
     902        1158 : _readReturningExpr(void)
     903             : {
     904        1158 :     READ_LOCALS(ReturningExpr);
     905             : 
     906        1158 :     READ_INT_FIELD(retlevelsup);
     907        1158 :     READ_BOOL_FIELD(retold);
     908        1158 :     READ_NODE_FIELD(retexpr);
     909             : 
     910        1158 :     READ_DONE();
     911             : }
     912             : 
     913             : static TargetEntry *
     914     7460796 : _readTargetEntry(void)
     915             : {
     916     7460796 :     READ_LOCALS(TargetEntry);
     917             : 
     918     7460796 :     READ_NODE_FIELD(expr);
     919     7460796 :     READ_INT_FIELD(resno);
     920     7460796 :     READ_STRING_FIELD(resname);
     921     7460796 :     READ_UINT_FIELD(ressortgroupref);
     922     7460796 :     READ_OID_FIELD(resorigtbl);
     923     7460796 :     READ_INT_FIELD(resorigcol);
     924     7460796 :     READ_BOOL_FIELD(resjunk);
     925             : 
     926     7460796 :     READ_DONE();
     927             : }
     928             : 
     929             : static RangeTblRef *
     930      636620 : _readRangeTblRef(void)
     931             : {
     932      636620 :     READ_LOCALS(RangeTblRef);
     933             : 
     934      636620 :     READ_INT_FIELD(rtindex);
     935             : 
     936      636620 :     READ_DONE();
     937             : }
     938             : 
     939             : static JoinExpr *
     940      216440 : _readJoinExpr(void)
     941             : {
     942      216440 :     READ_LOCALS(JoinExpr);
     943             : 
     944      216440 :     READ_ENUM_FIELD(jointype, JoinType);
     945      216440 :     READ_BOOL_FIELD(isNatural);
     946      216440 :     READ_NODE_FIELD(larg);
     947      216440 :     READ_NODE_FIELD(rarg);
     948      216440 :     READ_NODE_FIELD(usingClause);
     949      216440 :     READ_NODE_FIELD(join_using_alias);
     950      216440 :     READ_NODE_FIELD(quals);
     951      216440 :     READ_NODE_FIELD(alias);
     952      216440 :     READ_INT_FIELD(rtindex);
     953             : 
     954      216440 :     READ_DONE();
     955             : }
     956             : 
     957             : static FromExpr *
     958      639238 : _readFromExpr(void)
     959             : {
     960      639238 :     READ_LOCALS(FromExpr);
     961             : 
     962      639238 :     READ_NODE_FIELD(fromlist);
     963      639238 :     READ_NODE_FIELD(quals);
     964             : 
     965      639238 :     READ_DONE();
     966             : }
     967             : 
     968             : static OnConflictExpr *
     969        1848 : _readOnConflictExpr(void)
     970             : {
     971        1848 :     READ_LOCALS(OnConflictExpr);
     972             : 
     973        1848 :     READ_ENUM_FIELD(action, OnConflictAction);
     974        1848 :     READ_NODE_FIELD(arbiterElems);
     975        1848 :     READ_NODE_FIELD(arbiterWhere);
     976        1848 :     READ_OID_FIELD(constraint);
     977        1848 :     READ_NODE_FIELD(onConflictSet);
     978        1848 :     READ_NODE_FIELD(onConflictWhere);
     979        1848 :     READ_INT_FIELD(exclRelIndex);
     980        1848 :     READ_NODE_FIELD(exclRelTlist);
     981             : 
     982        1848 :     READ_DONE();
     983             : }
     984             : 
     985             : static Query *
     986     1042330 : _readQuery(void)
     987             : {
     988     1042330 :     READ_LOCALS(Query);
     989             : 
     990     1042330 :     READ_ENUM_FIELD(commandType, CmdType);
     991     1042330 :     READ_ENUM_FIELD(querySource, QuerySource);
     992     1042330 :     local_node->queryId = 0;
     993     1042330 :     READ_BOOL_FIELD(canSetTag);
     994     1042330 :     READ_NODE_FIELD(utilityStmt);
     995     1042330 :     READ_INT_FIELD(resultRelation);
     996     1042330 :     READ_BOOL_FIELD(hasAggs);
     997     1042330 :     READ_BOOL_FIELD(hasWindowFuncs);
     998     1042330 :     READ_BOOL_FIELD(hasTargetSRFs);
     999     1042330 :     READ_BOOL_FIELD(hasSubLinks);
    1000     1042330 :     READ_BOOL_FIELD(hasDistinctOn);
    1001     1042330 :     READ_BOOL_FIELD(hasRecursive);
    1002     1042330 :     READ_BOOL_FIELD(hasModifyingCTE);
    1003     1042330 :     READ_BOOL_FIELD(hasForUpdate);
    1004     1042330 :     READ_BOOL_FIELD(hasRowSecurity);
    1005     1042330 :     READ_BOOL_FIELD(hasGroupRTE);
    1006     1042330 :     READ_BOOL_FIELD(isReturn);
    1007     1042330 :     READ_NODE_FIELD(cteList);
    1008     1042330 :     READ_NODE_FIELD(rtable);
    1009     1042330 :     READ_NODE_FIELD(rteperminfos);
    1010     1042330 :     READ_NODE_FIELD(jointree);
    1011     1042330 :     READ_NODE_FIELD(mergeActionList);
    1012     1042330 :     READ_INT_FIELD(mergeTargetRelation);
    1013     1042330 :     READ_NODE_FIELD(mergeJoinCondition);
    1014     1042330 :     READ_NODE_FIELD(targetList);
    1015     1042330 :     READ_ENUM_FIELD(override, OverridingKind);
    1016     1042330 :     READ_NODE_FIELD(onConflict);
    1017     1042330 :     READ_STRING_FIELD(returningOldAlias);
    1018     1042330 :     READ_STRING_FIELD(returningNewAlias);
    1019     1042330 :     READ_NODE_FIELD(returningList);
    1020     1042330 :     READ_NODE_FIELD(groupClause);
    1021     1042330 :     READ_BOOL_FIELD(groupDistinct);
    1022     1042330 :     READ_NODE_FIELD(groupingSets);
    1023     1042330 :     READ_NODE_FIELD(havingQual);
    1024     1042330 :     READ_NODE_FIELD(windowClause);
    1025     1042330 :     READ_NODE_FIELD(distinctClause);
    1026     1042330 :     READ_NODE_FIELD(sortClause);
    1027     1042330 :     READ_NODE_FIELD(limitOffset);
    1028     1042330 :     READ_NODE_FIELD(limitCount);
    1029     1042330 :     READ_ENUM_FIELD(limitOption, LimitOption);
    1030     1042330 :     READ_NODE_FIELD(rowMarks);
    1031     1042330 :     READ_NODE_FIELD(setOperations);
    1032     1042330 :     READ_NODE_FIELD(constraintDeps);
    1033     1042330 :     READ_NODE_FIELD(withCheckOptions);
    1034     1042330 :     READ_LOCATION_FIELD(stmt_location);
    1035     1042330 :     READ_LOCATION_FIELD(stmt_len);
    1036             : 
    1037     1042330 :     READ_DONE();
    1038             : }
    1039             : 
    1040             : static TypeName *
    1041      840634 : _readTypeName(void)
    1042             : {
    1043      840634 :     READ_LOCALS(TypeName);
    1044             : 
    1045      840634 :     READ_NODE_FIELD(names);
    1046      840634 :     READ_OID_FIELD(typeOid);
    1047      840634 :     READ_BOOL_FIELD(setof);
    1048      840634 :     READ_BOOL_FIELD(pct_type);
    1049      840634 :     READ_NODE_FIELD(typmods);
    1050      840634 :     READ_INT_FIELD(typemod);
    1051      840634 :     READ_NODE_FIELD(arrayBounds);
    1052      840634 :     READ_LOCATION_FIELD(location);
    1053             : 
    1054      840634 :     READ_DONE();
    1055             : }
    1056             : 
    1057             : static ColumnRef *
    1058     2145276 : _readColumnRef(void)
    1059             : {
    1060     2145276 :     READ_LOCALS(ColumnRef);
    1061             : 
    1062     2145276 :     READ_NODE_FIELD(fields);
    1063     2145276 :     READ_LOCATION_FIELD(location);
    1064             : 
    1065     2145276 :     READ_DONE();
    1066             : }
    1067             : 
    1068             : static ParamRef *
    1069       55232 : _readParamRef(void)
    1070             : {
    1071       55232 :     READ_LOCALS(ParamRef);
    1072             : 
    1073       55232 :     READ_INT_FIELD(number);
    1074       55232 :     READ_LOCATION_FIELD(location);
    1075             : 
    1076       55232 :     READ_DONE();
    1077             : }
    1078             : 
    1079             : static TypeCast *
    1080      382490 : _readTypeCast(void)
    1081             : {
    1082      382490 :     READ_LOCALS(TypeCast);
    1083             : 
    1084      382490 :     READ_NODE_FIELD(arg);
    1085      382490 :     READ_NODE_FIELD(typeName);
    1086      382490 :     READ_LOCATION_FIELD(location);
    1087             : 
    1088      382490 :     READ_DONE();
    1089             : }
    1090             : 
    1091             : static CollateClause *
    1092       10704 : _readCollateClause(void)
    1093             : {
    1094       10704 :     READ_LOCALS(CollateClause);
    1095             : 
    1096       10704 :     READ_NODE_FIELD(arg);
    1097       10704 :     READ_NODE_FIELD(collname);
    1098       10704 :     READ_LOCATION_FIELD(location);
    1099             : 
    1100       10704 :     READ_DONE();
    1101             : }
    1102             : 
    1103             : static RoleSpec *
    1104       66220 : _readRoleSpec(void)
    1105             : {
    1106       66220 :     READ_LOCALS(RoleSpec);
    1107             : 
    1108       66220 :     READ_ENUM_FIELD(roletype, RoleSpecType);
    1109       66220 :     READ_STRING_FIELD(rolename);
    1110       66220 :     READ_LOCATION_FIELD(location);
    1111             : 
    1112       66220 :     READ_DONE();
    1113             : }
    1114             : 
    1115             : static FuncCall *
    1116      417436 : _readFuncCall(void)
    1117             : {
    1118      417436 :     READ_LOCALS(FuncCall);
    1119             : 
    1120      417434 :     READ_NODE_FIELD(funcname);
    1121      417434 :     READ_NODE_FIELD(args);
    1122      417434 :     READ_NODE_FIELD(agg_order);
    1123      417434 :     READ_NODE_FIELD(agg_filter);
    1124      417434 :     READ_NODE_FIELD(over);
    1125      417434 :     READ_BOOL_FIELD(agg_within_group);
    1126      417434 :     READ_BOOL_FIELD(agg_star);
    1127      417434 :     READ_BOOL_FIELD(agg_distinct);
    1128      417434 :     READ_BOOL_FIELD(func_variadic);
    1129      417434 :     READ_ENUM_FIELD(funcformat, CoercionForm);
    1130      417434 :     READ_LOCATION_FIELD(location);
    1131             : 
    1132      417434 :     READ_DONE();
    1133             : }
    1134             : 
    1135             : static A_Star *
    1136       65144 : _readA_Star(void)
    1137             : {
    1138       65144 :     READ_LOCALS_NO_FIELDS(A_Star);
    1139             : 
    1140             : 
    1141       65144 :     READ_DONE();
    1142             : }
    1143             : 
    1144             : static A_Indices *
    1145       15352 : _readA_Indices(void)
    1146             : {
    1147       15352 :     READ_LOCALS(A_Indices);
    1148             : 
    1149       15352 :     READ_BOOL_FIELD(is_slice);
    1150       15352 :     READ_NODE_FIELD(lidx);
    1151       15352 :     READ_NODE_FIELD(uidx);
    1152             : 
    1153       15352 :     READ_DONE();
    1154             : }
    1155             : 
    1156             : static A_Indirection *
    1157       36388 : _readA_Indirection(void)
    1158             : {
    1159       36388 :     READ_LOCALS(A_Indirection);
    1160             : 
    1161       36388 :     READ_NODE_FIELD(arg);
    1162       36388 :     READ_NODE_FIELD(indirection);
    1163             : 
    1164       36388 :     READ_DONE();
    1165             : }
    1166             : 
    1167             : static A_ArrayExpr *
    1168        7112 : _readA_ArrayExpr(void)
    1169             : {
    1170        7112 :     READ_LOCALS(A_ArrayExpr);
    1171             : 
    1172        7112 :     READ_NODE_FIELD(elements);
    1173        7112 :     READ_LOCATION_FIELD(list_start);
    1174        7112 :     READ_LOCATION_FIELD(list_end);
    1175        7112 :     READ_LOCATION_FIELD(location);
    1176             : 
    1177        7112 :     READ_DONE();
    1178             : }
    1179             : 
    1180             : static ResTarget *
    1181     1356112 : _readResTarget(void)
    1182             : {
    1183     1356112 :     READ_LOCALS(ResTarget);
    1184             : 
    1185     1356112 :     READ_STRING_FIELD(name);
    1186     1356112 :     READ_NODE_FIELD(indirection);
    1187     1356112 :     READ_NODE_FIELD(val);
    1188     1356112 :     READ_LOCATION_FIELD(location);
    1189             : 
    1190     1356112 :     READ_DONE();
    1191             : }
    1192             : 
    1193             : static MultiAssignRef *
    1194         402 : _readMultiAssignRef(void)
    1195             : {
    1196         402 :     READ_LOCALS(MultiAssignRef);
    1197             : 
    1198         402 :     READ_NODE_FIELD(source);
    1199         402 :     READ_INT_FIELD(colno);
    1200         402 :     READ_INT_FIELD(ncolumns);
    1201             : 
    1202         402 :     READ_DONE();
    1203             : }
    1204             : 
    1205             : static SortBy *
    1206      113594 : _readSortBy(void)
    1207             : {
    1208      113594 :     READ_LOCALS(SortBy);
    1209             : 
    1210      113594 :     READ_NODE_FIELD(node);
    1211      113594 :     READ_ENUM_FIELD(sortby_dir, SortByDir);
    1212      113594 :     READ_ENUM_FIELD(sortby_nulls, SortByNulls);
    1213      113594 :     READ_NODE_FIELD(useOp);
    1214      113594 :     READ_LOCATION_FIELD(location);
    1215             : 
    1216      113594 :     READ_DONE();
    1217             : }
    1218             : 
    1219             : static WindowDef *
    1220        4180 : _readWindowDef(void)
    1221             : {
    1222        4180 :     READ_LOCALS(WindowDef);
    1223             : 
    1224        4180 :     READ_STRING_FIELD(name);
    1225        4180 :     READ_STRING_FIELD(refname);
    1226        4180 :     READ_NODE_FIELD(partitionClause);
    1227        4180 :     READ_NODE_FIELD(orderClause);
    1228        4180 :     READ_INT_FIELD(frameOptions);
    1229        4180 :     READ_NODE_FIELD(startOffset);
    1230        4180 :     READ_NODE_FIELD(endOffset);
    1231        4180 :     READ_LOCATION_FIELD(location);
    1232             : 
    1233        4180 :     READ_DONE();
    1234             : }
    1235             : 
    1236             : static RangeSubselect *
    1237       19028 : _readRangeSubselect(void)
    1238             : {
    1239       19028 :     READ_LOCALS(RangeSubselect);
    1240             : 
    1241       19028 :     READ_BOOL_FIELD(lateral);
    1242       19028 :     READ_NODE_FIELD(subquery);
    1243       19028 :     READ_NODE_FIELD(alias);
    1244             : 
    1245       19028 :     READ_DONE();
    1246             : }
    1247             : 
    1248             : static RangeFunction *
    1249       53646 : _readRangeFunction(void)
    1250             : {
    1251       53646 :     READ_LOCALS(RangeFunction);
    1252             : 
    1253       53646 :     READ_BOOL_FIELD(lateral);
    1254       53646 :     READ_BOOL_FIELD(ordinality);
    1255       53646 :     READ_BOOL_FIELD(is_rowsfrom);
    1256       53646 :     READ_NODE_FIELD(functions);
    1257       53646 :     READ_NODE_FIELD(alias);
    1258       53646 :     READ_NODE_FIELD(coldeflist);
    1259             : 
    1260       53646 :     READ_DONE();
    1261             : }
    1262             : 
    1263             : static RangeTableFunc *
    1264         250 : _readRangeTableFunc(void)
    1265             : {
    1266         250 :     READ_LOCALS(RangeTableFunc);
    1267             : 
    1268         250 :     READ_BOOL_FIELD(lateral);
    1269         250 :     READ_NODE_FIELD(docexpr);
    1270         250 :     READ_NODE_FIELD(rowexpr);
    1271         250 :     READ_NODE_FIELD(namespaces);
    1272         250 :     READ_NODE_FIELD(columns);
    1273         250 :     READ_NODE_FIELD(alias);
    1274         250 :     READ_LOCATION_FIELD(location);
    1275             : 
    1276         250 :     READ_DONE();
    1277             : }
    1278             : 
    1279             : static RangeTableFuncCol *
    1280         906 : _readRangeTableFuncCol(void)
    1281             : {
    1282         906 :     READ_LOCALS(RangeTableFuncCol);
    1283             : 
    1284         906 :     READ_STRING_FIELD(colname);
    1285         906 :     READ_NODE_FIELD(typeName);
    1286         906 :     READ_BOOL_FIELD(for_ordinality);
    1287         906 :     READ_BOOL_FIELD(is_not_null);
    1288         906 :     READ_NODE_FIELD(colexpr);
    1289         906 :     READ_NODE_FIELD(coldefexpr);
    1290         906 :     READ_LOCATION_FIELD(location);
    1291             : 
    1292         906 :     READ_DONE();
    1293             : }
    1294             : 
    1295             : static RangeTableSample *
    1296         288 : _readRangeTableSample(void)
    1297             : {
    1298         288 :     READ_LOCALS(RangeTableSample);
    1299             : 
    1300         288 :     READ_NODE_FIELD(relation);
    1301         288 :     READ_NODE_FIELD(method);
    1302         288 :     READ_NODE_FIELD(args);
    1303         288 :     READ_NODE_FIELD(repeatable);
    1304         288 :     READ_LOCATION_FIELD(location);
    1305             : 
    1306         288 :     READ_DONE();
    1307             : }
    1308             : 
    1309             : static ColumnDef *
    1310      153302 : _readColumnDef(void)
    1311             : {
    1312      153302 :     READ_LOCALS(ColumnDef);
    1313             : 
    1314      153302 :     READ_STRING_FIELD(colname);
    1315      153302 :     READ_NODE_FIELD(typeName);
    1316      153302 :     READ_STRING_FIELD(compression);
    1317      153302 :     READ_INT_FIELD(inhcount);
    1318      153302 :     READ_BOOL_FIELD(is_local);
    1319      153302 :     READ_BOOL_FIELD(is_not_null);
    1320      153302 :     READ_BOOL_FIELD(is_from_type);
    1321      153302 :     READ_CHAR_FIELD(storage);
    1322      153302 :     READ_STRING_FIELD(storage_name);
    1323      153302 :     READ_NODE_FIELD(raw_default);
    1324      153302 :     READ_NODE_FIELD(cooked_default);
    1325      153302 :     READ_CHAR_FIELD(identity);
    1326      153302 :     READ_NODE_FIELD(identitySequence);
    1327      153302 :     READ_CHAR_FIELD(generated);
    1328      153302 :     READ_NODE_FIELD(collClause);
    1329      153302 :     READ_OID_FIELD(collOid);
    1330      153302 :     READ_NODE_FIELD(constraints);
    1331      153302 :     READ_NODE_FIELD(fdwoptions);
    1332      153302 :     READ_LOCATION_FIELD(location);
    1333             : 
    1334      153302 :     READ_DONE();
    1335             : }
    1336             : 
    1337             : static TableLikeClause *
    1338        1548 : _readTableLikeClause(void)
    1339             : {
    1340        1548 :     READ_LOCALS(TableLikeClause);
    1341             : 
    1342        1548 :     READ_NODE_FIELD(relation);
    1343        1548 :     READ_UINT_FIELD(options);
    1344        1548 :     READ_OID_FIELD(relationOid);
    1345             : 
    1346        1548 :     READ_DONE();
    1347             : }
    1348             : 
    1349             : static IndexElem *
    1350       20384 : _readIndexElem(void)
    1351             : {
    1352       20384 :     READ_LOCALS(IndexElem);
    1353             : 
    1354       20384 :     READ_STRING_FIELD(name);
    1355       20384 :     READ_NODE_FIELD(expr);
    1356       20384 :     READ_STRING_FIELD(indexcolname);
    1357       20384 :     READ_NODE_FIELD(collation);
    1358       20384 :     READ_NODE_FIELD(opclass);
    1359       20384 :     READ_NODE_FIELD(opclassopts);
    1360       20384 :     READ_ENUM_FIELD(ordering, SortByDir);
    1361       20384 :     READ_ENUM_FIELD(nulls_ordering, SortByNulls);
    1362             : 
    1363       20384 :     READ_DONE();
    1364             : }
    1365             : 
    1366             : static DefElem *
    1367      354748 : _readDefElem(void)
    1368             : {
    1369      354748 :     READ_LOCALS(DefElem);
    1370             : 
    1371      354748 :     READ_STRING_FIELD(defnamespace);
    1372      354748 :     READ_STRING_FIELD(defname);
    1373      354748 :     READ_NODE_FIELD(arg);
    1374      354748 :     READ_ENUM_FIELD(defaction, DefElemAction);
    1375      354748 :     READ_LOCATION_FIELD(location);
    1376             : 
    1377      354748 :     READ_DONE();
    1378             : }
    1379             : 
    1380             : static LockingClause *
    1381        2178 : _readLockingClause(void)
    1382             : {
    1383        2178 :     READ_LOCALS(LockingClause);
    1384             : 
    1385        2178 :     READ_NODE_FIELD(lockedRels);
    1386        2178 :     READ_ENUM_FIELD(strength, LockClauseStrength);
    1387        2178 :     READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
    1388             : 
    1389        2178 :     READ_DONE();
    1390             : }
    1391             : 
    1392             : static XmlSerialize *
    1393         266 : _readXmlSerialize(void)
    1394             : {
    1395         266 :     READ_LOCALS(XmlSerialize);
    1396             : 
    1397         266 :     READ_ENUM_FIELD(xmloption, XmlOptionType);
    1398         266 :     READ_NODE_FIELD(expr);
    1399         266 :     READ_NODE_FIELD(typeName);
    1400         266 :     READ_BOOL_FIELD(indent);
    1401         266 :     READ_LOCATION_FIELD(location);
    1402             : 
    1403         266 :     READ_DONE();
    1404             : }
    1405             : 
    1406             : static PartitionElem *
    1407       11240 : _readPartitionElem(void)
    1408             : {
    1409       11240 :     READ_LOCALS(PartitionElem);
    1410             : 
    1411       11240 :     READ_STRING_FIELD(name);
    1412       11240 :     READ_NODE_FIELD(expr);
    1413       11240 :     READ_NODE_FIELD(collation);
    1414       11240 :     READ_NODE_FIELD(opclass);
    1415       11240 :     READ_LOCATION_FIELD(location);
    1416             : 
    1417       11240 :     READ_DONE();
    1418             : }
    1419             : 
    1420             : static PartitionSpec *
    1421       10308 : _readPartitionSpec(void)
    1422             : {
    1423       10308 :     READ_LOCALS(PartitionSpec);
    1424             : 
    1425       10308 :     READ_ENUM_FIELD(strategy, PartitionStrategy);
    1426       10308 :     READ_NODE_FIELD(partParams);
    1427       10308 :     READ_LOCATION_FIELD(location);
    1428             : 
    1429       10308 :     READ_DONE();
    1430             : }
    1431             : 
    1432             : static PartitionBoundSpec *
    1433       65680 : _readPartitionBoundSpec(void)
    1434             : {
    1435       65680 :     READ_LOCALS(PartitionBoundSpec);
    1436             : 
    1437       65680 :     READ_CHAR_FIELD(strategy);
    1438       65680 :     READ_BOOL_FIELD(is_default);
    1439       65680 :     READ_INT_FIELD(modulus);
    1440       65680 :     READ_INT_FIELD(remainder);
    1441       65680 :     READ_NODE_FIELD(listdatums);
    1442       65680 :     READ_NODE_FIELD(lowerdatums);
    1443       65680 :     READ_NODE_FIELD(upperdatums);
    1444       65680 :     READ_LOCATION_FIELD(location);
    1445             : 
    1446       65680 :     READ_DONE();
    1447             : }
    1448             : 
    1449             : static PartitionRangeDatum *
    1450       51156 : _readPartitionRangeDatum(void)
    1451             : {
    1452       51156 :     READ_LOCALS(PartitionRangeDatum);
    1453             : 
    1454       51156 :     READ_ENUM_FIELD(kind, PartitionRangeDatumKind);
    1455       51156 :     READ_NODE_FIELD(value);
    1456       51156 :     READ_LOCATION_FIELD(location);
    1457             : 
    1458       51156 :     READ_DONE();
    1459             : }
    1460             : 
    1461             : static PartitionCmd *
    1462        7850 : _readPartitionCmd(void)
    1463             : {
    1464        7850 :     READ_LOCALS(PartitionCmd);
    1465             : 
    1466        7850 :     READ_NODE_FIELD(name);
    1467        7850 :     READ_NODE_FIELD(bound);
    1468        7850 :     READ_BOOL_FIELD(concurrent);
    1469             : 
    1470        7850 :     READ_DONE();
    1471             : }
    1472             : 
    1473             : static RTEPermissionInfo *
    1474     1061988 : _readRTEPermissionInfo(void)
    1475             : {
    1476     1061988 :     READ_LOCALS(RTEPermissionInfo);
    1477             : 
    1478     1061988 :     READ_OID_FIELD(relid);
    1479     1061988 :     READ_BOOL_FIELD(inh);
    1480     1061988 :     READ_UINT64_FIELD(requiredPerms);
    1481     1061988 :     READ_OID_FIELD(checkAsUser);
    1482     1061988 :     READ_BITMAPSET_FIELD(selectedCols);
    1483     1061988 :     READ_BITMAPSET_FIELD(insertedCols);
    1484     1061988 :     READ_BITMAPSET_FIELD(updatedCols);
    1485             : 
    1486     1061988 :     READ_DONE();
    1487             : }
    1488             : 
    1489             : static RangeTblFunction *
    1490      115894 : _readRangeTblFunction(void)
    1491             : {
    1492      115894 :     READ_LOCALS(RangeTblFunction);
    1493             : 
    1494      115894 :     READ_NODE_FIELD(funcexpr);
    1495      115894 :     READ_INT_FIELD(funccolcount);
    1496      115894 :     READ_NODE_FIELD(funccolnames);
    1497      115894 :     READ_NODE_FIELD(funccoltypes);
    1498      115894 :     READ_NODE_FIELD(funccoltypmods);
    1499      115894 :     READ_NODE_FIELD(funccolcollations);
    1500      115894 :     READ_BITMAPSET_FIELD(funcparams);
    1501             : 
    1502      115894 :     READ_DONE();
    1503             : }
    1504             : 
    1505             : static TableSampleClause *
    1506         646 : _readTableSampleClause(void)
    1507             : {
    1508         646 :     READ_LOCALS(TableSampleClause);
    1509             : 
    1510         646 :     READ_OID_FIELD(tsmhandler);
    1511         646 :     READ_NODE_FIELD(args);
    1512         646 :     READ_NODE_FIELD(repeatable);
    1513             : 
    1514         646 :     READ_DONE();
    1515             : }
    1516             : 
    1517             : static WithCheckOption *
    1518        4842 : _readWithCheckOption(void)
    1519             : {
    1520        4842 :     READ_LOCALS(WithCheckOption);
    1521             : 
    1522        4842 :     READ_ENUM_FIELD(kind, WCOKind);
    1523        4842 :     READ_STRING_FIELD(relname);
    1524        4842 :     READ_STRING_FIELD(polname);
    1525        4842 :     READ_NODE_FIELD(qual);
    1526        4842 :     READ_BOOL_FIELD(cascaded);
    1527             : 
    1528        4842 :     READ_DONE();
    1529             : }
    1530             : 
    1531             : static SortGroupClause *
    1532      169664 : _readSortGroupClause(void)
    1533             : {
    1534      169664 :     READ_LOCALS(SortGroupClause);
    1535             : 
    1536      169664 :     READ_UINT_FIELD(tleSortGroupRef);
    1537      169664 :     READ_OID_FIELD(eqop);
    1538      169664 :     READ_OID_FIELD(sortop);
    1539      169664 :     READ_BOOL_FIELD(reverse_sort);
    1540      169664 :     READ_BOOL_FIELD(nulls_first);
    1541      169664 :     READ_BOOL_FIELD(hashable);
    1542             : 
    1543      169664 :     READ_DONE();
    1544             : }
    1545             : 
    1546             : static GroupingSet *
    1547        4306 : _readGroupingSet(void)
    1548             : {
    1549        4306 :     READ_LOCALS(GroupingSet);
    1550             : 
    1551        4306 :     READ_ENUM_FIELD(kind, GroupingSetKind);
    1552        4306 :     READ_NODE_FIELD(content);
    1553        4306 :     READ_LOCATION_FIELD(location);
    1554             : 
    1555        4306 :     READ_DONE();
    1556             : }
    1557             : 
    1558             : static WindowClause *
    1559        2946 : _readWindowClause(void)
    1560             : {
    1561        2946 :     READ_LOCALS(WindowClause);
    1562             : 
    1563        2946 :     READ_STRING_FIELD(name);
    1564        2946 :     READ_STRING_FIELD(refname);
    1565        2946 :     READ_NODE_FIELD(partitionClause);
    1566        2946 :     READ_NODE_FIELD(orderClause);
    1567        2946 :     READ_INT_FIELD(frameOptions);
    1568        2946 :     READ_NODE_FIELD(startOffset);
    1569        2946 :     READ_NODE_FIELD(endOffset);
    1570        2946 :     READ_OID_FIELD(startInRangeFunc);
    1571        2946 :     READ_OID_FIELD(endInRangeFunc);
    1572        2946 :     READ_OID_FIELD(inRangeColl);
    1573        2946 :     READ_BOOL_FIELD(inRangeAsc);
    1574        2946 :     READ_BOOL_FIELD(inRangeNullsFirst);
    1575        2946 :     READ_UINT_FIELD(winref);
    1576        2946 :     READ_BOOL_FIELD(copiedOrder);
    1577             : 
    1578        2946 :     READ_DONE();
    1579             : }
    1580             : 
    1581             : static RowMarkClause *
    1582        5364 : _readRowMarkClause(void)
    1583             : {
    1584        5364 :     READ_LOCALS(RowMarkClause);
    1585             : 
    1586        5364 :     READ_UINT_FIELD(rti);
    1587        5364 :     READ_ENUM_FIELD(strength, LockClauseStrength);
    1588        5364 :     READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
    1589        5364 :     READ_BOOL_FIELD(pushedDown);
    1590             : 
    1591        5364 :     READ_DONE();
    1592             : }
    1593             : 
    1594             : static WithClause *
    1595        3410 : _readWithClause(void)
    1596             : {
    1597        3410 :     READ_LOCALS(WithClause);
    1598             : 
    1599        3410 :     READ_NODE_FIELD(ctes);
    1600        3410 :     READ_BOOL_FIELD(recursive);
    1601        3410 :     READ_LOCATION_FIELD(location);
    1602             : 
    1603        3410 :     READ_DONE();
    1604             : }
    1605             : 
    1606             : static InferClause *
    1607        1632 : _readInferClause(void)
    1608             : {
    1609        1632 :     READ_LOCALS(InferClause);
    1610             : 
    1611        1632 :     READ_NODE_FIELD(indexElems);
    1612        1632 :     READ_NODE_FIELD(whereClause);
    1613        1632 :     READ_STRING_FIELD(conname);
    1614        1632 :     READ_LOCATION_FIELD(location);
    1615             : 
    1616        1632 :     READ_DONE();
    1617             : }
    1618             : 
    1619             : static OnConflictClause *
    1620        1872 : _readOnConflictClause(void)
    1621             : {
    1622        1872 :     READ_LOCALS(OnConflictClause);
    1623             : 
    1624        1872 :     READ_ENUM_FIELD(action, OnConflictAction);
    1625        1872 :     READ_NODE_FIELD(infer);
    1626        1872 :     READ_NODE_FIELD(targetList);
    1627        1872 :     READ_NODE_FIELD(whereClause);
    1628        1872 :     READ_LOCATION_FIELD(location);
    1629             : 
    1630        1872 :     READ_DONE();
    1631             : }
    1632             : 
    1633             : static CTESearchClause *
    1634         228 : _readCTESearchClause(void)
    1635             : {
    1636         228 :     READ_LOCALS(CTESearchClause);
    1637             : 
    1638         228 :     READ_NODE_FIELD(search_col_list);
    1639         228 :     READ_BOOL_FIELD(search_breadth_first);
    1640         228 :     READ_STRING_FIELD(search_seq_column);
    1641         228 :     READ_LOCATION_FIELD(location);
    1642             : 
    1643         228 :     READ_DONE();
    1644             : }
    1645             : 
    1646             : static CTECycleClause *
    1647         246 : _readCTECycleClause(void)
    1648             : {
    1649         246 :     READ_LOCALS(CTECycleClause);
    1650             : 
    1651         246 :     READ_NODE_FIELD(cycle_col_list);
    1652         246 :     READ_STRING_FIELD(cycle_mark_column);
    1653         246 :     READ_NODE_FIELD(cycle_mark_value);
    1654         246 :     READ_NODE_FIELD(cycle_mark_default);
    1655         246 :     READ_STRING_FIELD(cycle_path_column);
    1656         246 :     READ_LOCATION_FIELD(location);
    1657         246 :     READ_OID_FIELD(cycle_mark_type);
    1658         246 :     READ_INT_FIELD(cycle_mark_typmod);
    1659         246 :     READ_OID_FIELD(cycle_mark_collation);
    1660         246 :     READ_OID_FIELD(cycle_mark_neop);
    1661             : 
    1662         246 :     READ_DONE();
    1663             : }
    1664             : 
    1665             : static CommonTableExpr *
    1666        9152 : _readCommonTableExpr(void)
    1667             : {
    1668        9152 :     READ_LOCALS(CommonTableExpr);
    1669             : 
    1670        9152 :     READ_STRING_FIELD(ctename);
    1671        9152 :     READ_NODE_FIELD(aliascolnames);
    1672        9152 :     READ_ENUM_FIELD(ctematerialized, CTEMaterialize);
    1673        9152 :     READ_NODE_FIELD(ctequery);
    1674        9152 :     READ_NODE_FIELD(search_clause);
    1675        9152 :     READ_NODE_FIELD(cycle_clause);
    1676        9152 :     READ_LOCATION_FIELD(location);
    1677        9152 :     READ_BOOL_FIELD(cterecursive);
    1678        9152 :     READ_INT_FIELD(cterefcount);
    1679        9152 :     READ_NODE_FIELD(ctecolnames);
    1680        9152 :     READ_NODE_FIELD(ctecoltypes);
    1681        9152 :     READ_NODE_FIELD(ctecoltypmods);
    1682        9152 :     READ_NODE_FIELD(ctecolcollations);
    1683             : 
    1684        9152 :     READ_DONE();
    1685             : }
    1686             : 
    1687             : static MergeWhenClause *
    1688        3014 : _readMergeWhenClause(void)
    1689             : {
    1690        3014 :     READ_LOCALS(MergeWhenClause);
    1691             : 
    1692        3014 :     READ_ENUM_FIELD(matchKind, MergeMatchKind);
    1693        3014 :     READ_ENUM_FIELD(commandType, CmdType);
    1694        3014 :     READ_ENUM_FIELD(override, OverridingKind);
    1695        3014 :     READ_NODE_FIELD(condition);
    1696        3014 :     READ_NODE_FIELD(targetList);
    1697        3014 :     READ_NODE_FIELD(values);
    1698             : 
    1699        3014 :     READ_DONE();
    1700             : }
    1701             : 
    1702             : static ReturningOption *
    1703         150 : _readReturningOption(void)
    1704             : {
    1705         150 :     READ_LOCALS(ReturningOption);
    1706             : 
    1707         150 :     READ_ENUM_FIELD(option, ReturningOptionKind);
    1708         150 :     READ_STRING_FIELD(value);
    1709         150 :     READ_LOCATION_FIELD(location);
    1710             : 
    1711         150 :     READ_DONE();
    1712             : }
    1713             : 
    1714             : static ReturningClause *
    1715        3298 : _readReturningClause(void)
    1716             : {
    1717        3298 :     READ_LOCALS(ReturningClause);
    1718             : 
    1719        3298 :     READ_NODE_FIELD(options);
    1720        3298 :     READ_NODE_FIELD(exprs);
    1721             : 
    1722        3298 :     READ_DONE();
    1723             : }
    1724             : 
    1725             : static TriggerTransition *
    1726        1228 : _readTriggerTransition(void)
    1727             : {
    1728        1228 :     READ_LOCALS(TriggerTransition);
    1729             : 
    1730        1228 :     READ_STRING_FIELD(name);
    1731        1228 :     READ_BOOL_FIELD(isNew);
    1732        1228 :     READ_BOOL_FIELD(isTable);
    1733             : 
    1734        1228 :     READ_DONE();
    1735             : }
    1736             : 
    1737             : static JsonOutput *
    1738        1486 : _readJsonOutput(void)
    1739             : {
    1740        1486 :     READ_LOCALS(JsonOutput);
    1741             : 
    1742        1486 :     READ_NODE_FIELD(typeName);
    1743        1486 :     READ_NODE_FIELD(returning);
    1744             : 
    1745        1486 :     READ_DONE();
    1746             : }
    1747             : 
    1748             : static JsonArgument *
    1749         630 : _readJsonArgument(void)
    1750             : {
    1751         630 :     READ_LOCALS(JsonArgument);
    1752             : 
    1753         630 :     READ_NODE_FIELD(val);
    1754         630 :     READ_STRING_FIELD(name);
    1755             : 
    1756         630 :     READ_DONE();
    1757             : }
    1758             : 
    1759             : static JsonFuncExpr *
    1760        1992 : _readJsonFuncExpr(void)
    1761             : {
    1762        1992 :     READ_LOCALS(JsonFuncExpr);
    1763             : 
    1764        1992 :     READ_ENUM_FIELD(op, JsonExprOp);
    1765        1992 :     READ_STRING_FIELD(column_name);
    1766        1992 :     READ_NODE_FIELD(context_item);
    1767        1992 :     READ_NODE_FIELD(pathspec);
    1768        1992 :     READ_NODE_FIELD(passing);
    1769        1992 :     READ_NODE_FIELD(output);
    1770        1992 :     READ_NODE_FIELD(on_empty);
    1771        1992 :     READ_NODE_FIELD(on_error);
    1772        1992 :     READ_ENUM_FIELD(wrapper, JsonWrapper);
    1773        1992 :     READ_ENUM_FIELD(quotes, JsonQuotes);
    1774        1992 :     READ_LOCATION_FIELD(location);
    1775             : 
    1776        1992 :     READ_DONE();
    1777             : }
    1778             : 
    1779             : static JsonTablePathSpec *
    1780        1972 : _readJsonTablePathSpec(void)
    1781             : {
    1782        1972 :     READ_LOCALS(JsonTablePathSpec);
    1783             : 
    1784        1972 :     READ_NODE_FIELD(string);
    1785        1972 :     READ_STRING_FIELD(name);
    1786        1972 :     READ_LOCATION_FIELD(name_location);
    1787        1972 :     READ_LOCATION_FIELD(location);
    1788             : 
    1789        1972 :     READ_DONE();
    1790             : }
    1791             : 
    1792             : static JsonTable *
    1793         590 : _readJsonTable(void)
    1794             : {
    1795         590 :     READ_LOCALS(JsonTable);
    1796             : 
    1797         590 :     READ_NODE_FIELD(context_item);
    1798         590 :     READ_NODE_FIELD(pathspec);
    1799         590 :     READ_NODE_FIELD(passing);
    1800         590 :     READ_NODE_FIELD(columns);
    1801         590 :     READ_NODE_FIELD(on_error);
    1802         590 :     READ_NODE_FIELD(alias);
    1803         590 :     READ_BOOL_FIELD(lateral);
    1804         590 :     READ_LOCATION_FIELD(location);
    1805             : 
    1806         590 :     READ_DONE();
    1807             : }
    1808             : 
    1809             : static JsonTableColumn *
    1810        1648 : _readJsonTableColumn(void)
    1811             : {
    1812        1648 :     READ_LOCALS(JsonTableColumn);
    1813             : 
    1814        1648 :     READ_ENUM_FIELD(coltype, JsonTableColumnType);
    1815        1648 :     READ_STRING_FIELD(name);
    1816        1648 :     READ_NODE_FIELD(typeName);
    1817        1648 :     READ_NODE_FIELD(pathspec);
    1818        1648 :     READ_NODE_FIELD(format);
    1819        1648 :     READ_ENUM_FIELD(wrapper, JsonWrapper);
    1820        1648 :     READ_ENUM_FIELD(quotes, JsonQuotes);
    1821        1648 :     READ_NODE_FIELD(columns);
    1822        1648 :     READ_NODE_FIELD(on_empty);
    1823        1648 :     READ_NODE_FIELD(on_error);
    1824        1648 :     READ_LOCATION_FIELD(location);
    1825             : 
    1826        1648 :     READ_DONE();
    1827             : }
    1828             : 
    1829             : static JsonKeyValue *
    1830         826 : _readJsonKeyValue(void)
    1831             : {
    1832         826 :     READ_LOCALS(JsonKeyValue);
    1833             : 
    1834         826 :     READ_NODE_FIELD(key);
    1835         826 :     READ_NODE_FIELD(value);
    1836             : 
    1837         826 :     READ_DONE();
    1838             : }
    1839             : 
    1840             : static JsonParseExpr *
    1841         164 : _readJsonParseExpr(void)
    1842             : {
    1843         164 :     READ_LOCALS(JsonParseExpr);
    1844             : 
    1845         164 :     READ_NODE_FIELD(expr);
    1846         164 :     READ_NODE_FIELD(output);
    1847         164 :     READ_BOOL_FIELD(unique_keys);
    1848         164 :     READ_LOCATION_FIELD(location);
    1849             : 
    1850         164 :     READ_DONE();
    1851             : }
    1852             : 
    1853             : static JsonScalarExpr *
    1854         112 : _readJsonScalarExpr(void)
    1855             : {
    1856         112 :     READ_LOCALS(JsonScalarExpr);
    1857             : 
    1858         112 :     READ_NODE_FIELD(expr);
    1859         112 :     READ_NODE_FIELD(output);
    1860         112 :     READ_LOCATION_FIELD(location);
    1861             : 
    1862         112 :     READ_DONE();
    1863             : }
    1864             : 
    1865             : static JsonSerializeExpr *
    1866         108 : _readJsonSerializeExpr(void)
    1867             : {
    1868         108 :     READ_LOCALS(JsonSerializeExpr);
    1869             : 
    1870         108 :     READ_NODE_FIELD(expr);
    1871         108 :     READ_NODE_FIELD(output);
    1872         108 :     READ_LOCATION_FIELD(location);
    1873             : 
    1874         108 :     READ_DONE();
    1875             : }
    1876             : 
    1877             : static JsonObjectConstructor *
    1878         446 : _readJsonObjectConstructor(void)
    1879             : {
    1880         446 :     READ_LOCALS(JsonObjectConstructor);
    1881             : 
    1882         446 :     READ_NODE_FIELD(exprs);
    1883         446 :     READ_NODE_FIELD(output);
    1884         446 :     READ_BOOL_FIELD(absent_on_null);
    1885         446 :     READ_BOOL_FIELD(unique);
    1886         446 :     READ_LOCATION_FIELD(location);
    1887             : 
    1888         446 :     READ_DONE();
    1889             : }
    1890             : 
    1891             : static JsonArrayConstructor *
    1892         200 : _readJsonArrayConstructor(void)
    1893             : {
    1894         200 :     READ_LOCALS(JsonArrayConstructor);
    1895             : 
    1896         200 :     READ_NODE_FIELD(exprs);
    1897         200 :     READ_NODE_FIELD(output);
    1898         200 :     READ_BOOL_FIELD(absent_on_null);
    1899         200 :     READ_LOCATION_FIELD(location);
    1900             : 
    1901         200 :     READ_DONE();
    1902             : }
    1903             : 
    1904             : static JsonArrayQueryConstructor *
    1905          66 : _readJsonArrayQueryConstructor(void)
    1906             : {
    1907          66 :     READ_LOCALS(JsonArrayQueryConstructor);
    1908             : 
    1909          66 :     READ_NODE_FIELD(query);
    1910          66 :     READ_NODE_FIELD(output);
    1911          66 :     READ_NODE_FIELD(format);
    1912          66 :     READ_BOOL_FIELD(absent_on_null);
    1913          66 :     READ_LOCATION_FIELD(location);
    1914             : 
    1915          66 :     READ_DONE();
    1916             : }
    1917             : 
    1918             : static JsonAggConstructor *
    1919         372 : _readJsonAggConstructor(void)
    1920             : {
    1921         372 :     READ_LOCALS(JsonAggConstructor);
    1922             : 
    1923         372 :     READ_NODE_FIELD(output);
    1924         372 :     READ_NODE_FIELD(agg_filter);
    1925         372 :     READ_NODE_FIELD(agg_order);
    1926         372 :     READ_NODE_FIELD(over);
    1927         372 :     READ_LOCATION_FIELD(location);
    1928             : 
    1929         372 :     READ_DONE();
    1930             : }
    1931             : 
    1932             : static JsonObjectAgg *
    1933         210 : _readJsonObjectAgg(void)
    1934             : {
    1935         210 :     READ_LOCALS(JsonObjectAgg);
    1936             : 
    1937         210 :     READ_NODE_FIELD(constructor);
    1938         210 :     READ_NODE_FIELD(arg);
    1939         210 :     READ_BOOL_FIELD(absent_on_null);
    1940         210 :     READ_BOOL_FIELD(unique);
    1941             : 
    1942         210 :     READ_DONE();
    1943             : }
    1944             : 
    1945             : static JsonArrayAgg *
    1946         162 : _readJsonArrayAgg(void)
    1947             : {
    1948         162 :     READ_LOCALS(JsonArrayAgg);
    1949             : 
    1950         162 :     READ_NODE_FIELD(constructor);
    1951         162 :     READ_NODE_FIELD(arg);
    1952         162 :     READ_BOOL_FIELD(absent_on_null);
    1953             : 
    1954         162 :     READ_DONE();
    1955             : }
    1956             : 
    1957             : static RawStmt *
    1958      750662 : _readRawStmt(void)
    1959             : {
    1960      750662 :     READ_LOCALS(RawStmt);
    1961             : 
    1962      750662 :     READ_NODE_FIELD(stmt);
    1963      750662 :     READ_LOCATION_FIELD(stmt_location);
    1964      750662 :     READ_LOCATION_FIELD(stmt_len);
    1965             : 
    1966      750662 :     READ_DONE();
    1967             : }
    1968             : 
    1969             : static InsertStmt *
    1970       67718 : _readInsertStmt(void)
    1971             : {
    1972       67718 :     READ_LOCALS(InsertStmt);
    1973             : 
    1974       67718 :     READ_NODE_FIELD(relation);
    1975       67718 :     READ_NODE_FIELD(cols);
    1976       67718 :     READ_NODE_FIELD(selectStmt);
    1977       67718 :     READ_NODE_FIELD(onConflictClause);
    1978       67718 :     READ_NODE_FIELD(returningClause);
    1979       67718 :     READ_NODE_FIELD(withClause);
    1980       67718 :     READ_ENUM_FIELD(override, OverridingKind);
    1981             : 
    1982       67718 :     READ_DONE();
    1983             : }
    1984             : 
    1985             : static DeleteStmt *
    1986        4474 : _readDeleteStmt(void)
    1987             : {
    1988        4474 :     READ_LOCALS(DeleteStmt);
    1989             : 
    1990        4474 :     READ_NODE_FIELD(relation);
    1991        4474 :     READ_NODE_FIELD(usingClause);
    1992        4474 :     READ_NODE_FIELD(whereClause);
    1993        4474 :     READ_NODE_FIELD(returningClause);
    1994        4474 :     READ_NODE_FIELD(withClause);
    1995             : 
    1996        4474 :     READ_DONE();
    1997             : }
    1998             : 
    1999             : static UpdateStmt *
    2000       13626 : _readUpdateStmt(void)
    2001             : {
    2002       13626 :     READ_LOCALS(UpdateStmt);
    2003             : 
    2004       13626 :     READ_NODE_FIELD(relation);
    2005       13626 :     READ_NODE_FIELD(targetList);
    2006       13626 :     READ_NODE_FIELD(whereClause);
    2007       13626 :     READ_NODE_FIELD(fromClause);
    2008       13626 :     READ_NODE_FIELD(returningClause);
    2009       13626 :     READ_NODE_FIELD(withClause);
    2010             : 
    2011       13626 :     READ_DONE();
    2012             : }
    2013             : 
    2014             : static MergeStmt *
    2015        1960 : _readMergeStmt(void)
    2016             : {
    2017        1960 :     READ_LOCALS(MergeStmt);
    2018             : 
    2019        1960 :     READ_NODE_FIELD(relation);
    2020        1960 :     READ_NODE_FIELD(sourceRelation);
    2021        1960 :     READ_NODE_FIELD(joinCondition);
    2022        1960 :     READ_NODE_FIELD(mergeWhenClauses);
    2023        1960 :     READ_NODE_FIELD(returningClause);
    2024        1960 :     READ_NODE_FIELD(withClause);
    2025             : 
    2026        1960 :     READ_DONE();
    2027             : }
    2028             : 
    2029             : static SelectStmt *
    2030      520940 : _readSelectStmt(void)
    2031             : {
    2032      520940 :     READ_LOCALS(SelectStmt);
    2033             : 
    2034      520940 :     READ_NODE_FIELD(distinctClause);
    2035      520940 :     READ_NODE_FIELD(intoClause);
    2036      520940 :     READ_NODE_FIELD(targetList);
    2037      520940 :     READ_NODE_FIELD(fromClause);
    2038      520940 :     READ_NODE_FIELD(whereClause);
    2039      520940 :     READ_NODE_FIELD(groupClause);
    2040      520940 :     READ_BOOL_FIELD(groupDistinct);
    2041      520940 :     READ_NODE_FIELD(havingClause);
    2042      520940 :     READ_NODE_FIELD(windowClause);
    2043      520940 :     READ_NODE_FIELD(valuesLists);
    2044      520940 :     READ_NODE_FIELD(sortClause);
    2045      520940 :     READ_NODE_FIELD(limitOffset);
    2046      520940 :     READ_NODE_FIELD(limitCount);
    2047      520940 :     READ_ENUM_FIELD(limitOption, LimitOption);
    2048      520940 :     READ_NODE_FIELD(lockingClause);
    2049      520940 :     READ_NODE_FIELD(withClause);
    2050      520940 :     READ_ENUM_FIELD(op, SetOperation);
    2051      520940 :     READ_BOOL_FIELD(all);
    2052      520940 :     READ_NODE_FIELD(larg);
    2053      520940 :     READ_NODE_FIELD(rarg);
    2054             : 
    2055      520940 :     READ_DONE();
    2056             : }
    2057             : 
    2058             : static SetOperationStmt *
    2059       22118 : _readSetOperationStmt(void)
    2060             : {
    2061       22118 :     READ_LOCALS(SetOperationStmt);
    2062             : 
    2063       22118 :     READ_ENUM_FIELD(op, SetOperation);
    2064       22118 :     READ_BOOL_FIELD(all);
    2065       22118 :     READ_NODE_FIELD(larg);
    2066       22118 :     READ_NODE_FIELD(rarg);
    2067       22118 :     READ_NODE_FIELD(colTypes);
    2068       22118 :     READ_NODE_FIELD(colTypmods);
    2069       22118 :     READ_NODE_FIELD(colCollations);
    2070       22118 :     READ_NODE_FIELD(groupClauses);
    2071             : 
    2072       22118 :     READ_DONE();
    2073             : }
    2074             : 
    2075             : static ReturnStmt *
    2076        9960 : _readReturnStmt(void)
    2077             : {
    2078        9960 :     READ_LOCALS(ReturnStmt);
    2079             : 
    2080        9960 :     READ_NODE_FIELD(returnval);
    2081             : 
    2082        9960 :     READ_DONE();
    2083             : }
    2084             : 
    2085             : static PLAssignStmt *
    2086           0 : _readPLAssignStmt(void)
    2087             : {
    2088           0 :     READ_LOCALS(PLAssignStmt);
    2089             : 
    2090           0 :     READ_STRING_FIELD(name);
    2091           0 :     READ_NODE_FIELD(indirection);
    2092           0 :     READ_INT_FIELD(nnames);
    2093           0 :     READ_NODE_FIELD(val);
    2094           0 :     READ_LOCATION_FIELD(location);
    2095             : 
    2096           0 :     READ_DONE();
    2097             : }
    2098             : 
    2099             : static CreateSchemaStmt *
    2100        2176 : _readCreateSchemaStmt(void)
    2101             : {
    2102        2176 :     READ_LOCALS(CreateSchemaStmt);
    2103             : 
    2104        2176 :     READ_STRING_FIELD(schemaname);
    2105        2176 :     READ_NODE_FIELD(authrole);
    2106        2176 :     READ_NODE_FIELD(schemaElts);
    2107        2176 :     READ_BOOL_FIELD(if_not_exists);
    2108             : 
    2109        2176 :     READ_DONE();
    2110             : }
    2111             : 
    2112             : static AlterTableStmt *
    2113       66400 : _readAlterTableStmt(void)
    2114             : {
    2115       66400 :     READ_LOCALS(AlterTableStmt);
    2116             : 
    2117       66400 :     READ_NODE_FIELD(relation);
    2118       66400 :     READ_NODE_FIELD(cmds);
    2119       66400 :     READ_ENUM_FIELD(objtype, ObjectType);
    2120       66400 :     READ_BOOL_FIELD(missing_ok);
    2121             : 
    2122       66400 :     READ_DONE();
    2123             : }
    2124             : 
    2125             : static AlterTableCmd *
    2126       68416 : _readAlterTableCmd(void)
    2127             : {
    2128       68416 :     READ_LOCALS(AlterTableCmd);
    2129             : 
    2130       68416 :     READ_ENUM_FIELD(subtype, AlterTableType);
    2131       68416 :     READ_STRING_FIELD(name);
    2132       68416 :     READ_INT_FIELD(num);
    2133       68416 :     READ_NODE_FIELD(newowner);
    2134       68416 :     READ_NODE_FIELD(def);
    2135       68416 :     READ_ENUM_FIELD(behavior, DropBehavior);
    2136       68416 :     READ_BOOL_FIELD(missing_ok);
    2137       68416 :     READ_BOOL_FIELD(recurse);
    2138             : 
    2139       68416 :     READ_DONE();
    2140             : }
    2141             : 
    2142             : static ATAlterConstraint *
    2143         588 : _readATAlterConstraint(void)
    2144             : {
    2145         588 :     READ_LOCALS(ATAlterConstraint);
    2146             : 
    2147         588 :     READ_STRING_FIELD(conname);
    2148         588 :     READ_BOOL_FIELD(alterEnforceability);
    2149         588 :     READ_BOOL_FIELD(is_enforced);
    2150         588 :     READ_BOOL_FIELD(alterDeferrability);
    2151         588 :     READ_BOOL_FIELD(deferrable);
    2152         588 :     READ_BOOL_FIELD(initdeferred);
    2153         588 :     READ_BOOL_FIELD(alterInheritability);
    2154         588 :     READ_BOOL_FIELD(noinherit);
    2155             : 
    2156         588 :     READ_DONE();
    2157             : }
    2158             : 
    2159             : static ReplicaIdentityStmt *
    2160         980 : _readReplicaIdentityStmt(void)
    2161             : {
    2162         980 :     READ_LOCALS(ReplicaIdentityStmt);
    2163             : 
    2164         980 :     READ_CHAR_FIELD(identity_type);
    2165         980 :     READ_STRING_FIELD(name);
    2166             : 
    2167         980 :     READ_DONE();
    2168             : }
    2169             : 
    2170             : static AlterCollationStmt *
    2171          12 : _readAlterCollationStmt(void)
    2172             : {
    2173          12 :     READ_LOCALS(AlterCollationStmt);
    2174             : 
    2175          12 :     READ_NODE_FIELD(collname);
    2176             : 
    2177          12 :     READ_DONE();
    2178             : }
    2179             : 
    2180             : static AlterDomainStmt *
    2181         584 : _readAlterDomainStmt(void)
    2182             : {
    2183         584 :     READ_LOCALS(AlterDomainStmt);
    2184             : 
    2185         584 :     READ_ENUM_FIELD(subtype, AlterDomainType);
    2186         584 :     READ_NODE_FIELD(typeName);
    2187         584 :     READ_STRING_FIELD(name);
    2188         584 :     READ_NODE_FIELD(def);
    2189         584 :     READ_ENUM_FIELD(behavior, DropBehavior);
    2190         584 :     READ_BOOL_FIELD(missing_ok);
    2191             : 
    2192         584 :     READ_DONE();
    2193             : }
    2194             : 
    2195             : static GrantStmt *
    2196       42738 : _readGrantStmt(void)
    2197             : {
    2198       42738 :     READ_LOCALS(GrantStmt);
    2199             : 
    2200       42738 :     READ_BOOL_FIELD(is_grant);
    2201       42738 :     READ_ENUM_FIELD(targtype, GrantTargetType);
    2202       42738 :     READ_ENUM_FIELD(objtype, ObjectType);
    2203       42738 :     READ_NODE_FIELD(objects);
    2204       42738 :     READ_NODE_FIELD(privileges);
    2205       42738 :     READ_NODE_FIELD(grantees);
    2206       42738 :     READ_BOOL_FIELD(grant_option);
    2207       42738 :     READ_NODE_FIELD(grantor);
    2208       42738 :     READ_ENUM_FIELD(behavior, DropBehavior);
    2209             : 
    2210       42738 :     READ_DONE();
    2211             : }
    2212             : 
    2213             : static ObjectWithArgs *
    2214       41338 : _readObjectWithArgs(void)
    2215             : {
    2216       41338 :     READ_LOCALS(ObjectWithArgs);
    2217             : 
    2218       41338 :     READ_NODE_FIELD(objname);
    2219       41338 :     READ_NODE_FIELD(objargs);
    2220       41338 :     READ_NODE_FIELD(objfuncargs);
    2221       41338 :     READ_BOOL_FIELD(args_unspecified);
    2222             : 
    2223       41338 :     READ_DONE();
    2224             : }
    2225             : 
    2226             : static AccessPriv *
    2227       40042 : _readAccessPriv(void)
    2228             : {
    2229       40042 :     READ_LOCALS(AccessPriv);
    2230             : 
    2231       40042 :     READ_STRING_FIELD(priv_name);
    2232       40042 :     READ_NODE_FIELD(cols);
    2233             : 
    2234       40042 :     READ_DONE();
    2235             : }
    2236             : 
    2237             : static GrantRoleStmt *
    2238        1836 : _readGrantRoleStmt(void)
    2239             : {
    2240        1836 :     READ_LOCALS(GrantRoleStmt);
    2241             : 
    2242        1836 :     READ_NODE_FIELD(granted_roles);
    2243        1836 :     READ_NODE_FIELD(grantee_roles);
    2244        1836 :     READ_BOOL_FIELD(is_grant);
    2245        1836 :     READ_NODE_FIELD(opt);
    2246        1836 :     READ_NODE_FIELD(grantor);
    2247        1836 :     READ_ENUM_FIELD(behavior, DropBehavior);
    2248             : 
    2249        1836 :     READ_DONE();
    2250             : }
    2251             : 
    2252             : static AlterDefaultPrivilegesStmt *
    2253         380 : _readAlterDefaultPrivilegesStmt(void)
    2254             : {
    2255         380 :     READ_LOCALS(AlterDefaultPrivilegesStmt);
    2256             : 
    2257         380 :     READ_NODE_FIELD(options);
    2258         380 :     READ_NODE_FIELD(action);
    2259             : 
    2260         380 :     READ_DONE();
    2261             : }
    2262             : 
    2263             : static CopyStmt *
    2264       33340 : _readCopyStmt(void)
    2265             : {
    2266       33340 :     READ_LOCALS(CopyStmt);
    2267             : 
    2268       33340 :     READ_NODE_FIELD(relation);
    2269       33340 :     READ_NODE_FIELD(query);
    2270       33340 :     READ_NODE_FIELD(attlist);
    2271       33340 :     READ_BOOL_FIELD(is_from);
    2272       33340 :     READ_BOOL_FIELD(is_program);
    2273       33340 :     READ_STRING_FIELD(filename);
    2274       33340 :     READ_NODE_FIELD(options);
    2275       33340 :     READ_NODE_FIELD(whereClause);
    2276             : 
    2277       33340 :     READ_DONE();
    2278             : }
    2279             : 
    2280             : static VariableSetStmt *
    2281       58792 : _readVariableSetStmt(void)
    2282             : {
    2283       58792 :     READ_LOCALS(VariableSetStmt);
    2284             : 
    2285       58792 :     READ_ENUM_FIELD(kind, VariableSetKind);
    2286       58792 :     READ_STRING_FIELD(name);
    2287       58792 :     READ_NODE_FIELD(args);
    2288       58792 :     READ_BOOL_FIELD(jumble_args);
    2289       58792 :     READ_BOOL_FIELD(is_local);
    2290       58792 :     READ_LOCATION_FIELD(location);
    2291             : 
    2292       58792 :     READ_DONE();
    2293             : }
    2294             : 
    2295             : static VariableShowStmt *
    2296        1756 : _readVariableShowStmt(void)
    2297             : {
    2298        1756 :     READ_LOCALS(VariableShowStmt);
    2299             : 
    2300        1756 :     READ_STRING_FIELD(name);
    2301             : 
    2302        1756 :     READ_DONE();
    2303             : }
    2304             : 
    2305             : static CreateStmt *
    2306       77660 : _readCreateStmt(void)
    2307             : {
    2308       77660 :     READ_LOCALS(CreateStmt);
    2309             : 
    2310       77660 :     READ_NODE_FIELD(relation);
    2311       77660 :     READ_NODE_FIELD(tableElts);
    2312       77660 :     READ_NODE_FIELD(inhRelations);
    2313       77660 :     READ_NODE_FIELD(partbound);
    2314       77660 :     READ_NODE_FIELD(partspec);
    2315       77660 :     READ_NODE_FIELD(ofTypename);
    2316       77660 :     READ_NODE_FIELD(constraints);
    2317       77660 :     READ_NODE_FIELD(nnconstraints);
    2318       77660 :     READ_NODE_FIELD(options);
    2319       77660 :     READ_ENUM_FIELD(oncommit, OnCommitAction);
    2320       77660 :     READ_STRING_FIELD(tablespacename);
    2321       77660 :     READ_STRING_FIELD(accessMethod);
    2322       77660 :     READ_BOOL_FIELD(if_not_exists);
    2323             : 
    2324       77660 :     READ_DONE();
    2325             : }
    2326             : 
    2327             : static Constraint *
    2328       74378 : _readConstraint(void)
    2329             : {
    2330       74378 :     READ_LOCALS(Constraint);
    2331             : 
    2332       74378 :     READ_ENUM_FIELD(contype, ConstrType);
    2333       74378 :     READ_STRING_FIELD(conname);
    2334       74378 :     READ_BOOL_FIELD(deferrable);
    2335       74378 :     READ_BOOL_FIELD(initdeferred);
    2336       74378 :     READ_BOOL_FIELD(is_enforced);
    2337       74378 :     READ_BOOL_FIELD(skip_validation);
    2338       74378 :     READ_BOOL_FIELD(initially_valid);
    2339       74378 :     READ_BOOL_FIELD(is_no_inherit);
    2340       74378 :     READ_NODE_FIELD(raw_expr);
    2341       74378 :     READ_STRING_FIELD(cooked_expr);
    2342       74378 :     READ_CHAR_FIELD(generated_when);
    2343       74378 :     READ_CHAR_FIELD(generated_kind);
    2344       74378 :     READ_BOOL_FIELD(nulls_not_distinct);
    2345       74378 :     READ_NODE_FIELD(keys);
    2346       74378 :     READ_BOOL_FIELD(without_overlaps);
    2347       74378 :     READ_NODE_FIELD(including);
    2348       74378 :     READ_NODE_FIELD(exclusions);
    2349       74378 :     READ_NODE_FIELD(options);
    2350       74378 :     READ_STRING_FIELD(indexname);
    2351       74378 :     READ_STRING_FIELD(indexspace);
    2352       74378 :     READ_BOOL_FIELD(reset_default_tblspc);
    2353       74378 :     READ_STRING_FIELD(access_method);
    2354       74378 :     READ_NODE_FIELD(where_clause);
    2355       74378 :     READ_NODE_FIELD(pktable);
    2356       74378 :     READ_NODE_FIELD(fk_attrs);
    2357       74378 :     READ_NODE_FIELD(pk_attrs);
    2358       74378 :     READ_BOOL_FIELD(fk_with_period);
    2359       74378 :     READ_BOOL_FIELD(pk_with_period);
    2360       74378 :     READ_CHAR_FIELD(fk_matchtype);
    2361       74378 :     READ_CHAR_FIELD(fk_upd_action);
    2362       74378 :     READ_CHAR_FIELD(fk_del_action);
    2363       74378 :     READ_NODE_FIELD(fk_del_set_cols);
    2364       74378 :     READ_NODE_FIELD(old_conpfeqop);
    2365       74378 :     READ_OID_FIELD(old_pktable_oid);
    2366       74378 :     READ_LOCATION_FIELD(location);
    2367             : 
    2368       74378 :     READ_DONE();
    2369             : }
    2370             : 
    2371             : static CreateTableSpaceStmt *
    2372         232 : _readCreateTableSpaceStmt(void)
    2373             : {
    2374         232 :     READ_LOCALS(CreateTableSpaceStmt);
    2375             : 
    2376         232 :     READ_STRING_FIELD(tablespacename);
    2377         232 :     READ_NODE_FIELD(owner);
    2378         232 :     READ_STRING_FIELD(location);
    2379         232 :     READ_NODE_FIELD(options);
    2380             : 
    2381         232 :     READ_DONE();
    2382             : }
    2383             : 
    2384             : static DropTableSpaceStmt *
    2385         128 : _readDropTableSpaceStmt(void)
    2386             : {
    2387         128 :     READ_LOCALS(DropTableSpaceStmt);
    2388             : 
    2389         128 :     READ_STRING_FIELD(tablespacename);
    2390         128 :     READ_BOOL_FIELD(missing_ok);
    2391             : 
    2392         128 :     READ_DONE();
    2393             : }
    2394             : 
    2395             : static AlterTableSpaceOptionsStmt *
    2396          48 : _readAlterTableSpaceOptionsStmt(void)
    2397             : {
    2398          48 :     READ_LOCALS(AlterTableSpaceOptionsStmt);
    2399             : 
    2400          48 :     READ_STRING_FIELD(tablespacename);
    2401          48 :     READ_NODE_FIELD(options);
    2402          48 :     READ_BOOL_FIELD(isReset);
    2403             : 
    2404          48 :     READ_DONE();
    2405             : }
    2406             : 
    2407             : static AlterTableMoveAllStmt *
    2408          60 : _readAlterTableMoveAllStmt(void)
    2409             : {
    2410          60 :     READ_LOCALS(AlterTableMoveAllStmt);
    2411             : 
    2412          60 :     READ_STRING_FIELD(orig_tablespacename);
    2413          60 :     READ_ENUM_FIELD(objtype, ObjectType);
    2414          60 :     READ_NODE_FIELD(roles);
    2415          60 :     READ_STRING_FIELD(new_tablespacename);
    2416          60 :     READ_BOOL_FIELD(nowait);
    2417             : 
    2418          60 :     READ_DONE();
    2419             : }
    2420             : 
    2421             : static CreateExtensionStmt *
    2422        1068 : _readCreateExtensionStmt(void)
    2423             : {
    2424        1068 :     READ_LOCALS(CreateExtensionStmt);
    2425             : 
    2426        1068 :     READ_STRING_FIELD(extname);
    2427        1068 :     READ_BOOL_FIELD(if_not_exists);
    2428        1068 :     READ_NODE_FIELD(options);
    2429             : 
    2430        1068 :     READ_DONE();
    2431             : }
    2432             : 
    2433             : static AlterExtensionStmt *
    2434          70 : _readAlterExtensionStmt(void)
    2435             : {
    2436          70 :     READ_LOCALS(AlterExtensionStmt);
    2437             : 
    2438          70 :     READ_STRING_FIELD(extname);
    2439          70 :     READ_NODE_FIELD(options);
    2440             : 
    2441          70 :     READ_DONE();
    2442             : }
    2443             : 
    2444             : static AlterExtensionContentsStmt *
    2445         484 : _readAlterExtensionContentsStmt(void)
    2446             : {
    2447         484 :     READ_LOCALS(AlterExtensionContentsStmt);
    2448             : 
    2449         484 :     READ_STRING_FIELD(extname);
    2450         484 :     READ_INT_FIELD(action);
    2451         484 :     READ_ENUM_FIELD(objtype, ObjectType);
    2452         484 :     READ_NODE_FIELD(object);
    2453             : 
    2454         484 :     READ_DONE();
    2455             : }
    2456             : 
    2457             : static CreateFdwStmt *
    2458         412 : _readCreateFdwStmt(void)
    2459             : {
    2460         412 :     READ_LOCALS(CreateFdwStmt);
    2461             : 
    2462         412 :     READ_STRING_FIELD(fdwname);
    2463         412 :     READ_NODE_FIELD(func_options);
    2464         412 :     READ_NODE_FIELD(options);
    2465             : 
    2466         412 :     READ_DONE();
    2467             : }
    2468             : 
    2469             : static AlterFdwStmt *
    2470         244 : _readAlterFdwStmt(void)
    2471             : {
    2472         244 :     READ_LOCALS(AlterFdwStmt);
    2473             : 
    2474         244 :     READ_STRING_FIELD(fdwname);
    2475         244 :     READ_NODE_FIELD(func_options);
    2476         244 :     READ_NODE_FIELD(options);
    2477             : 
    2478         244 :     READ_DONE();
    2479             : }
    2480             : 
    2481             : static CreateForeignServerStmt *
    2482         582 : _readCreateForeignServerStmt(void)
    2483             : {
    2484         582 :     READ_LOCALS(CreateForeignServerStmt);
    2485             : 
    2486         582 :     READ_STRING_FIELD(servername);
    2487         582 :     READ_STRING_FIELD(servertype);
    2488         582 :     READ_STRING_FIELD(version);
    2489         582 :     READ_STRING_FIELD(fdwname);
    2490         582 :     READ_BOOL_FIELD(if_not_exists);
    2491         582 :     READ_NODE_FIELD(options);
    2492             : 
    2493         582 :     READ_DONE();
    2494             : }
    2495             : 
    2496             : static AlterForeignServerStmt *
    2497         454 : _readAlterForeignServerStmt(void)
    2498             : {
    2499         454 :     READ_LOCALS(AlterForeignServerStmt);
    2500             : 
    2501         454 :     READ_STRING_FIELD(servername);
    2502         454 :     READ_STRING_FIELD(version);
    2503         454 :     READ_NODE_FIELD(options);
    2504         454 :     READ_BOOL_FIELD(has_version);
    2505             : 
    2506         454 :     READ_DONE();
    2507             : }
    2508             : 
    2509             : static CreateForeignTableStmt *
    2510         904 : _readCreateForeignTableStmt(void)
    2511             : {
    2512         904 :     READ_LOCALS(CreateForeignTableStmt);
    2513             : 
    2514         904 :     READ_NODE_FIELD(base.relation);
    2515         904 :     READ_NODE_FIELD(base.tableElts);
    2516         904 :     READ_NODE_FIELD(base.inhRelations);
    2517         904 :     READ_NODE_FIELD(base.partbound);
    2518         904 :     READ_NODE_FIELD(base.partspec);
    2519         904 :     READ_NODE_FIELD(base.ofTypename);
    2520         904 :     READ_NODE_FIELD(base.constraints);
    2521         904 :     READ_NODE_FIELD(base.nnconstraints);
    2522         904 :     READ_NODE_FIELD(base.options);
    2523         904 :     READ_ENUM_FIELD(base.oncommit, OnCommitAction);
    2524         904 :     READ_STRING_FIELD(base.tablespacename);
    2525         904 :     READ_STRING_FIELD(base.accessMethod);
    2526         904 :     READ_BOOL_FIELD(base.if_not_exists);
    2527         904 :     READ_STRING_FIELD(servername);
    2528         904 :     READ_NODE_FIELD(options);
    2529             : 
    2530         904 :     READ_DONE();
    2531             : }
    2532             : 
    2533             : static CreateUserMappingStmt *
    2534         504 : _readCreateUserMappingStmt(void)
    2535             : {
    2536         504 :     READ_LOCALS(CreateUserMappingStmt);
    2537             : 
    2538         504 :     READ_NODE_FIELD(user);
    2539         504 :     READ_STRING_FIELD(servername);
    2540         504 :     READ_BOOL_FIELD(if_not_exists);
    2541         504 :     READ_NODE_FIELD(options);
    2542             : 
    2543         504 :     READ_DONE();
    2544             : }
    2545             : 
    2546             : static AlterUserMappingStmt *
    2547         236 : _readAlterUserMappingStmt(void)
    2548             : {
    2549         236 :     READ_LOCALS(AlterUserMappingStmt);
    2550             : 
    2551         236 :     READ_NODE_FIELD(user);
    2552         236 :     READ_STRING_FIELD(servername);
    2553         236 :     READ_NODE_FIELD(options);
    2554             : 
    2555         236 :     READ_DONE();
    2556             : }
    2557             : 
    2558             : static DropUserMappingStmt *
    2559         252 : _readDropUserMappingStmt(void)
    2560             : {
    2561         252 :     READ_LOCALS(DropUserMappingStmt);
    2562             : 
    2563         252 :     READ_NODE_FIELD(user);
    2564         252 :     READ_STRING_FIELD(servername);
    2565         252 :     READ_BOOL_FIELD(missing_ok);
    2566             : 
    2567         252 :     READ_DONE();
    2568             : }
    2569             : 
    2570             : static ImportForeignSchemaStmt *
    2571          96 : _readImportForeignSchemaStmt(void)
    2572             : {
    2573          96 :     READ_LOCALS(ImportForeignSchemaStmt);
    2574             : 
    2575          96 :     READ_STRING_FIELD(server_name);
    2576          96 :     READ_STRING_FIELD(remote_schema);
    2577          96 :     READ_STRING_FIELD(local_schema);
    2578          96 :     READ_ENUM_FIELD(list_type, ImportForeignSchemaType);
    2579          96 :     READ_NODE_FIELD(table_list);
    2580          96 :     READ_NODE_FIELD(options);
    2581             : 
    2582          96 :     READ_DONE();
    2583             : }
    2584             : 
    2585             : static CreatePolicyStmt *
    2586        1412 : _readCreatePolicyStmt(void)
    2587             : {
    2588        1412 :     READ_LOCALS(CreatePolicyStmt);
    2589             : 
    2590        1412 :     READ_STRING_FIELD(policy_name);
    2591        1412 :     READ_NODE_FIELD(table);
    2592        1412 :     READ_STRING_FIELD(cmd_name);
    2593        1412 :     READ_BOOL_FIELD(permissive);
    2594        1412 :     READ_NODE_FIELD(roles);
    2595        1412 :     READ_NODE_FIELD(qual);
    2596        1412 :     READ_NODE_FIELD(with_check);
    2597             : 
    2598        1412 :     READ_DONE();
    2599             : }
    2600             : 
    2601             : static AlterPolicyStmt *
    2602         168 : _readAlterPolicyStmt(void)
    2603             : {
    2604         168 :     READ_LOCALS(AlterPolicyStmt);
    2605             : 
    2606         168 :     READ_STRING_FIELD(policy_name);
    2607         168 :     READ_NODE_FIELD(table);
    2608         168 :     READ_NODE_FIELD(roles);
    2609         168 :     READ_NODE_FIELD(qual);
    2610         168 :     READ_NODE_FIELD(with_check);
    2611             : 
    2612         168 :     READ_DONE();
    2613             : }
    2614             : 
    2615             : static CreateAmStmt *
    2616         128 : _readCreateAmStmt(void)
    2617             : {
    2618         128 :     READ_LOCALS(CreateAmStmt);
    2619             : 
    2620         128 :     READ_STRING_FIELD(amname);
    2621         128 :     READ_NODE_FIELD(handler_name);
    2622         128 :     READ_CHAR_FIELD(amtype);
    2623             : 
    2624         128 :     READ_DONE();
    2625             : }
    2626             : 
    2627             : static CreateTrigStmt *
    2628        6644 : _readCreateTrigStmt(void)
    2629             : {
    2630        6644 :     READ_LOCALS(CreateTrigStmt);
    2631             : 
    2632        6644 :     READ_BOOL_FIELD(replace);
    2633        6644 :     READ_BOOL_FIELD(isconstraint);
    2634        6644 :     READ_STRING_FIELD(trigname);
    2635        6644 :     READ_NODE_FIELD(relation);
    2636        6644 :     READ_NODE_FIELD(funcname);
    2637        6644 :     READ_NODE_FIELD(args);
    2638        6644 :     READ_BOOL_FIELD(row);
    2639        6644 :     READ_INT_FIELD(timing);
    2640        6644 :     READ_INT_FIELD(events);
    2641        6644 :     READ_NODE_FIELD(columns);
    2642        6644 :     READ_NODE_FIELD(whenClause);
    2643        6644 :     READ_NODE_FIELD(transitionRels);
    2644        6644 :     READ_BOOL_FIELD(deferrable);
    2645        6644 :     READ_BOOL_FIELD(initdeferred);
    2646        6644 :     READ_NODE_FIELD(constrrel);
    2647             : 
    2648        6644 :     READ_DONE();
    2649             : }
    2650             : 
    2651             : static CreateEventTrigStmt *
    2652         396 : _readCreateEventTrigStmt(void)
    2653             : {
    2654         396 :     READ_LOCALS(CreateEventTrigStmt);
    2655             : 
    2656         396 :     READ_STRING_FIELD(trigname);
    2657         396 :     READ_STRING_FIELD(eventname);
    2658         396 :     READ_NODE_FIELD(whenclause);
    2659         396 :     READ_NODE_FIELD(funcname);
    2660             : 
    2661         396 :     READ_DONE();
    2662             : }
    2663             : 
    2664             : static AlterEventTrigStmt *
    2665          96 : _readAlterEventTrigStmt(void)
    2666             : {
    2667          96 :     READ_LOCALS(AlterEventTrigStmt);
    2668             : 
    2669          96 :     READ_STRING_FIELD(trigname);
    2670          96 :     READ_CHAR_FIELD(tgenabled);
    2671             : 
    2672          96 :     READ_DONE();
    2673             : }
    2674             : 
    2675             : static CreatePLangStmt *
    2676         288 : _readCreatePLangStmt(void)
    2677             : {
    2678         288 :     READ_LOCALS(CreatePLangStmt);
    2679             : 
    2680         288 :     READ_BOOL_FIELD(replace);
    2681         288 :     READ_STRING_FIELD(plname);
    2682         288 :     READ_NODE_FIELD(plhandler);
    2683         288 :     READ_NODE_FIELD(plinline);
    2684         288 :     READ_NODE_FIELD(plvalidator);
    2685         288 :     READ_BOOL_FIELD(pltrusted);
    2686             : 
    2687         288 :     READ_DONE();
    2688             : }
    2689             : 
    2690             : static CreateRoleStmt *
    2691        3700 : _readCreateRoleStmt(void)
    2692             : {
    2693        3700 :     READ_LOCALS(CreateRoleStmt);
    2694             : 
    2695        3700 :     READ_ENUM_FIELD(stmt_type, RoleStmtType);
    2696        3700 :     READ_STRING_FIELD(role);
    2697        3700 :     READ_NODE_FIELD(options);
    2698             : 
    2699        3700 :     READ_DONE();
    2700             : }
    2701             : 
    2702             : static AlterRoleStmt *
    2703         920 : _readAlterRoleStmt(void)
    2704             : {
    2705         920 :     READ_LOCALS(AlterRoleStmt);
    2706             : 
    2707         920 :     READ_NODE_FIELD(role);
    2708         920 :     READ_NODE_FIELD(options);
    2709         920 :     READ_INT_FIELD(action);
    2710             : 
    2711         920 :     READ_DONE();
    2712             : }
    2713             : 
    2714             : static AlterRoleSetStmt *
    2715         164 : _readAlterRoleSetStmt(void)
    2716             : {
    2717         164 :     READ_LOCALS(AlterRoleSetStmt);
    2718             : 
    2719         164 :     READ_NODE_FIELD(role);
    2720         164 :     READ_STRING_FIELD(database);
    2721         164 :     READ_NODE_FIELD(setstmt);
    2722             : 
    2723         164 :     READ_DONE();
    2724             : }
    2725             : 
    2726             : static DropRoleStmt *
    2727        3444 : _readDropRoleStmt(void)
    2728             : {
    2729        3444 :     READ_LOCALS(DropRoleStmt);
    2730             : 
    2731        3444 :     READ_NODE_FIELD(roles);
    2732        3444 :     READ_BOOL_FIELD(missing_ok);
    2733             : 
    2734        3444 :     READ_DONE();
    2735             : }
    2736             : 
    2737             : static CreateSeqStmt *
    2738        1468 : _readCreateSeqStmt(void)
    2739             : {
    2740        1468 :     READ_LOCALS(CreateSeqStmt);
    2741             : 
    2742        1468 :     READ_NODE_FIELD(sequence);
    2743        1468 :     READ_NODE_FIELD(options);
    2744        1468 :     READ_OID_FIELD(ownerId);
    2745        1468 :     READ_BOOL_FIELD(for_identity);
    2746        1468 :     READ_BOOL_FIELD(if_not_exists);
    2747             : 
    2748        1468 :     READ_DONE();
    2749             : }
    2750             : 
    2751             : static AlterSeqStmt *
    2752         448 : _readAlterSeqStmt(void)
    2753             : {
    2754         448 :     READ_LOCALS(AlterSeqStmt);
    2755             : 
    2756         448 :     READ_NODE_FIELD(sequence);
    2757         448 :     READ_NODE_FIELD(options);
    2758         448 :     READ_BOOL_FIELD(for_identity);
    2759         448 :     READ_BOOL_FIELD(missing_ok);
    2760             : 
    2761         448 :     READ_DONE();
    2762             : }
    2763             : 
    2764             : static DefineStmt *
    2765       18992 : _readDefineStmt(void)
    2766             : {
    2767       18992 :     READ_LOCALS(DefineStmt);
    2768             : 
    2769       18992 :     READ_ENUM_FIELD(kind, ObjectType);
    2770       18992 :     READ_BOOL_FIELD(oldstyle);
    2771       18992 :     READ_NODE_FIELD(defnames);
    2772       18992 :     READ_NODE_FIELD(args);
    2773       18992 :     READ_NODE_FIELD(definition);
    2774       18992 :     READ_BOOL_FIELD(if_not_exists);
    2775       18992 :     READ_BOOL_FIELD(replace);
    2776             : 
    2777       18992 :     READ_DONE();
    2778             : }
    2779             : 
    2780             : static CreateDomainStmt *
    2781        3020 : _readCreateDomainStmt(void)
    2782             : {
    2783        3020 :     READ_LOCALS(CreateDomainStmt);
    2784             : 
    2785        3020 :     READ_NODE_FIELD(domainname);
    2786        3020 :     READ_NODE_FIELD(typeName);
    2787        3020 :     READ_NODE_FIELD(collClause);
    2788        3020 :     READ_NODE_FIELD(constraints);
    2789             : 
    2790        3020 :     READ_DONE();
    2791             : }
    2792             : 
    2793             : static CreateOpClassStmt *
    2794         788 : _readCreateOpClassStmt(void)
    2795             : {
    2796         788 :     READ_LOCALS(CreateOpClassStmt);
    2797             : 
    2798         788 :     READ_NODE_FIELD(opclassname);
    2799         788 :     READ_NODE_FIELD(opfamilyname);
    2800         788 :     READ_STRING_FIELD(amname);
    2801         788 :     READ_NODE_FIELD(datatype);
    2802         788 :     READ_NODE_FIELD(items);
    2803         788 :     READ_BOOL_FIELD(isDefault);
    2804             : 
    2805         788 :     READ_DONE();
    2806             : }
    2807             : 
    2808             : static CreateOpClassItem *
    2809        8500 : _readCreateOpClassItem(void)
    2810             : {
    2811        8500 :     READ_LOCALS(CreateOpClassItem);
    2812             : 
    2813        8500 :     READ_INT_FIELD(itemtype);
    2814        8500 :     READ_NODE_FIELD(name);
    2815        8500 :     READ_INT_FIELD(number);
    2816        8500 :     READ_NODE_FIELD(order_family);
    2817        8500 :     READ_NODE_FIELD(class_args);
    2818        8500 :     READ_NODE_FIELD(storedtype);
    2819             : 
    2820        8500 :     READ_DONE();
    2821             : }
    2822             : 
    2823             : static CreateOpFamilyStmt *
    2824         324 : _readCreateOpFamilyStmt(void)
    2825             : {
    2826         324 :     READ_LOCALS(CreateOpFamilyStmt);
    2827             : 
    2828         324 :     READ_NODE_FIELD(opfamilyname);
    2829         324 :     READ_STRING_FIELD(amname);
    2830             : 
    2831         324 :     READ_DONE();
    2832             : }
    2833             : 
    2834             : static AlterOpFamilyStmt *
    2835        1196 : _readAlterOpFamilyStmt(void)
    2836             : {
    2837        1196 :     READ_LOCALS(AlterOpFamilyStmt);
    2838             : 
    2839        1196 :     READ_NODE_FIELD(opfamilyname);
    2840        1196 :     READ_STRING_FIELD(amname);
    2841        1196 :     READ_BOOL_FIELD(isDrop);
    2842        1196 :     READ_NODE_FIELD(items);
    2843             : 
    2844        1196 :     READ_DONE();
    2845             : }
    2846             : 
    2847             : static DropStmt *
    2848       50774 : _readDropStmt(void)
    2849             : {
    2850       50774 :     READ_LOCALS(DropStmt);
    2851             : 
    2852       50774 :     READ_NODE_FIELD(objects);
    2853       50774 :     READ_ENUM_FIELD(removeType, ObjectType);
    2854       50774 :     READ_ENUM_FIELD(behavior, DropBehavior);
    2855       50774 :     READ_BOOL_FIELD(missing_ok);
    2856       50774 :     READ_BOOL_FIELD(concurrent);
    2857             : 
    2858       50774 :     READ_DONE();
    2859             : }
    2860             : 
    2861             : static TruncateStmt *
    2862        5894 : _readTruncateStmt(void)
    2863             : {
    2864        5894 :     READ_LOCALS(TruncateStmt);
    2865             : 
    2866        5894 :     READ_NODE_FIELD(relations);
    2867        5894 :     READ_BOOL_FIELD(restart_seqs);
    2868        5894 :     READ_ENUM_FIELD(behavior, DropBehavior);
    2869             : 
    2870        5894 :     READ_DONE();
    2871             : }
    2872             : 
    2873             : static CommentStmt *
    2874       14388 : _readCommentStmt(void)
    2875             : {
    2876       14388 :     READ_LOCALS(CommentStmt);
    2877             : 
    2878       14388 :     READ_ENUM_FIELD(objtype, ObjectType);
    2879       14388 :     READ_NODE_FIELD(object);
    2880       14388 :     READ_STRING_FIELD(comment);
    2881             : 
    2882       14388 :     READ_DONE();
    2883             : }
    2884             : 
    2885             : static SecLabelStmt *
    2886         200 : _readSecLabelStmt(void)
    2887             : {
    2888         200 :     READ_LOCALS(SecLabelStmt);
    2889             : 
    2890         200 :     READ_ENUM_FIELD(objtype, ObjectType);
    2891         200 :     READ_NODE_FIELD(object);
    2892         200 :     READ_STRING_FIELD(provider);
    2893         200 :     READ_STRING_FIELD(label);
    2894             : 
    2895         200 :     READ_DONE();
    2896             : }
    2897             : 
    2898             : static DeclareCursorStmt *
    2899        7384 : _readDeclareCursorStmt(void)
    2900             : {
    2901        7384 :     READ_LOCALS(DeclareCursorStmt);
    2902             : 
    2903        7384 :     READ_STRING_FIELD(portalname);
    2904        7384 :     READ_INT_FIELD(options);
    2905        7384 :     READ_NODE_FIELD(query);
    2906             : 
    2907        7384 :     READ_DONE();
    2908             : }
    2909             : 
    2910             : static ClosePortalStmt *
    2911        4448 : _readClosePortalStmt(void)
    2912             : {
    2913        4448 :     READ_LOCALS(ClosePortalStmt);
    2914             : 
    2915        4448 :     READ_STRING_FIELD(portalname);
    2916             : 
    2917        4448 :     READ_DONE();
    2918             : }
    2919             : 
    2920             : static FetchStmt *
    2921       13438 : _readFetchStmt(void)
    2922             : {
    2923       13438 :     READ_LOCALS(FetchStmt);
    2924             : 
    2925       13438 :     READ_ENUM_FIELD(direction, FetchDirection);
    2926       13438 :     READ_LONG_FIELD(howMany);
    2927       13438 :     READ_STRING_FIELD(portalname);
    2928       13438 :     READ_BOOL_FIELD(ismove);
    2929       13438 :     READ_ENUM_FIELD(direction_keyword, FetchDirectionKeywords);
    2930       13438 :     READ_LOCATION_FIELD(location);
    2931             : 
    2932       13438 :     READ_DONE();
    2933             : }
    2934             : 
    2935             : static IndexStmt *
    2936       13404 : _readIndexStmt(void)
    2937             : {
    2938       13404 :     READ_LOCALS(IndexStmt);
    2939             : 
    2940       13404 :     READ_STRING_FIELD(idxname);
    2941       13404 :     READ_NODE_FIELD(relation);
    2942       13404 :     READ_STRING_FIELD(accessMethod);
    2943       13404 :     READ_STRING_FIELD(tableSpace);
    2944       13404 :     READ_NODE_FIELD(indexParams);
    2945       13404 :     READ_NODE_FIELD(indexIncludingParams);
    2946       13404 :     READ_NODE_FIELD(options);
    2947       13404 :     READ_NODE_FIELD(whereClause);
    2948       13404 :     READ_NODE_FIELD(excludeOpNames);
    2949       13404 :     READ_STRING_FIELD(idxcomment);
    2950       13404 :     READ_OID_FIELD(indexOid);
    2951       13404 :     READ_OID_FIELD(oldNumber);
    2952       13404 :     READ_UINT_FIELD(oldCreateSubid);
    2953       13404 :     READ_UINT_FIELD(oldFirstRelfilelocatorSubid);
    2954       13404 :     READ_BOOL_FIELD(unique);
    2955       13404 :     READ_BOOL_FIELD(nulls_not_distinct);
    2956       13404 :     READ_BOOL_FIELD(primary);
    2957       13404 :     READ_BOOL_FIELD(isconstraint);
    2958       13404 :     READ_BOOL_FIELD(iswithoutoverlaps);
    2959       13404 :     READ_BOOL_FIELD(deferrable);
    2960       13404 :     READ_BOOL_FIELD(initdeferred);
    2961       13404 :     READ_BOOL_FIELD(transformed);
    2962       13404 :     READ_BOOL_FIELD(concurrent);
    2963       13404 :     READ_BOOL_FIELD(if_not_exists);
    2964       13404 :     READ_BOOL_FIELD(reset_default_tblspc);
    2965             : 
    2966       13404 :     READ_DONE();
    2967             : }
    2968             : 
    2969             : static CreateStatsStmt *
    2970        1346 : _readCreateStatsStmt(void)
    2971             : {
    2972        1346 :     READ_LOCALS(CreateStatsStmt);
    2973             : 
    2974        1346 :     READ_NODE_FIELD(defnames);
    2975        1346 :     READ_NODE_FIELD(stat_types);
    2976        1346 :     READ_NODE_FIELD(exprs);
    2977        1346 :     READ_NODE_FIELD(relations);
    2978        1346 :     READ_STRING_FIELD(stxcomment);
    2979        1346 :     READ_BOOL_FIELD(transformed);
    2980        1346 :     READ_BOOL_FIELD(if_not_exists);
    2981             : 
    2982        1346 :     READ_DONE();
    2983             : }
    2984             : 
    2985             : static StatsElem *
    2986        3240 : _readStatsElem(void)
    2987             : {
    2988        3240 :     READ_LOCALS(StatsElem);
    2989             : 
    2990        3240 :     READ_STRING_FIELD(name);
    2991        3240 :     READ_NODE_FIELD(expr);
    2992             : 
    2993        3240 :     READ_DONE();
    2994             : }
    2995             : 
    2996             : static AlterStatsStmt *
    2997          52 : _readAlterStatsStmt(void)
    2998             : {
    2999          52 :     READ_LOCALS(AlterStatsStmt);
    3000             : 
    3001          52 :     READ_NODE_FIELD(defnames);
    3002          52 :     READ_NODE_FIELD(stxstattarget);
    3003          52 :     READ_BOOL_FIELD(missing_ok);
    3004             : 
    3005          52 :     READ_DONE();
    3006             : }
    3007             : 
    3008             : static CreateFunctionStmt *
    3009       50092 : _readCreateFunctionStmt(void)
    3010             : {
    3011       50092 :     READ_LOCALS(CreateFunctionStmt);
    3012             : 
    3013       50092 :     READ_BOOL_FIELD(is_procedure);
    3014       50092 :     READ_BOOL_FIELD(replace);
    3015       50092 :     READ_NODE_FIELD(funcname);
    3016       50092 :     READ_NODE_FIELD(parameters);
    3017       50092 :     READ_NODE_FIELD(returnType);
    3018       50092 :     READ_NODE_FIELD(options);
    3019       50092 :     READ_NODE_FIELD(sql_body);
    3020             : 
    3021       50092 :     READ_DONE();
    3022             : }
    3023             : 
    3024             : static FunctionParameter *
    3025      149474 : _readFunctionParameter(void)
    3026             : {
    3027      149474 :     READ_LOCALS(FunctionParameter);
    3028             : 
    3029      149474 :     READ_STRING_FIELD(name);
    3030      149474 :     READ_NODE_FIELD(argType);
    3031      149474 :     READ_ENUM_FIELD(mode, FunctionParameterMode);
    3032      149474 :     READ_NODE_FIELD(defexpr);
    3033      149474 :     READ_LOCATION_FIELD(location);
    3034             : 
    3035      149474 :     READ_DONE();
    3036             : }
    3037             : 
    3038             : static AlterFunctionStmt *
    3039        1344 : _readAlterFunctionStmt(void)
    3040             : {
    3041        1344 :     READ_LOCALS(AlterFunctionStmt);
    3042             : 
    3043        1344 :     READ_ENUM_FIELD(objtype, ObjectType);
    3044        1344 :     READ_NODE_FIELD(func);
    3045        1344 :     READ_NODE_FIELD(actions);
    3046             : 
    3047        1344 :     READ_DONE();
    3048             : }
    3049             : 
    3050             : static DoStmt *
    3051        2208 : _readDoStmt(void)
    3052             : {
    3053        2208 :     READ_LOCALS(DoStmt);
    3054             : 
    3055        2208 :     READ_NODE_FIELD(args);
    3056             : 
    3057        2208 :     READ_DONE();
    3058             : }
    3059             : 
    3060             : static CallStmt *
    3061         898 : _readCallStmt(void)
    3062             : {
    3063         898 :     READ_LOCALS(CallStmt);
    3064             : 
    3065         898 :     READ_NODE_FIELD(funccall);
    3066         898 :     READ_NODE_FIELD(funcexpr);
    3067         898 :     READ_NODE_FIELD(outargs);
    3068             : 
    3069         898 :     READ_DONE();
    3070             : }
    3071             : 
    3072             : static RenameStmt *
    3073        2832 : _readRenameStmt(void)
    3074             : {
    3075        2832 :     READ_LOCALS(RenameStmt);
    3076             : 
    3077        2832 :     READ_ENUM_FIELD(renameType, ObjectType);
    3078        2832 :     READ_ENUM_FIELD(relationType, ObjectType);
    3079        2832 :     READ_NODE_FIELD(relation);
    3080        2832 :     READ_NODE_FIELD(object);
    3081        2832 :     READ_STRING_FIELD(subname);
    3082        2832 :     READ_STRING_FIELD(newname);
    3083        2832 :     READ_ENUM_FIELD(behavior, DropBehavior);
    3084        2832 :     READ_BOOL_FIELD(missing_ok);
    3085             : 
    3086        2832 :     READ_DONE();
    3087             : }
    3088             : 
    3089             : static AlterObjectDependsStmt *
    3090          92 : _readAlterObjectDependsStmt(void)
    3091             : {
    3092          92 :     READ_LOCALS(AlterObjectDependsStmt);
    3093             : 
    3094          92 :     READ_ENUM_FIELD(objectType, ObjectType);
    3095          92 :     READ_NODE_FIELD(relation);
    3096          92 :     READ_NODE_FIELD(object);
    3097          92 :     READ_NODE_FIELD(extname);
    3098          92 :     READ_BOOL_FIELD(remove);
    3099             : 
    3100          92 :     READ_DONE();
    3101             : }
    3102             : 
    3103             : static AlterObjectSchemaStmt *
    3104         796 : _readAlterObjectSchemaStmt(void)
    3105             : {
    3106         796 :     READ_LOCALS(AlterObjectSchemaStmt);
    3107             : 
    3108         796 :     READ_ENUM_FIELD(objectType, ObjectType);
    3109         796 :     READ_NODE_FIELD(relation);
    3110         796 :     READ_NODE_FIELD(object);
    3111         796 :     READ_STRING_FIELD(newschema);
    3112         796 :     READ_BOOL_FIELD(missing_ok);
    3113             : 
    3114         796 :     READ_DONE();
    3115             : }
    3116             : 
    3117             : static AlterOwnerStmt *
    3118        5030 : _readAlterOwnerStmt(void)
    3119             : {
    3120        5030 :     READ_LOCALS(AlterOwnerStmt);
    3121             : 
    3122        5030 :     READ_ENUM_FIELD(objectType, ObjectType);
    3123        5030 :     READ_NODE_FIELD(relation);
    3124        5030 :     READ_NODE_FIELD(object);
    3125        5030 :     READ_NODE_FIELD(newowner);
    3126             : 
    3127        5030 :     READ_DONE();
    3128             : }
    3129             : 
    3130             : static AlterOperatorStmt *
    3131        1216 : _readAlterOperatorStmt(void)
    3132             : {
    3133        1216 :     READ_LOCALS(AlterOperatorStmt);
    3134             : 
    3135        1216 :     READ_NODE_FIELD(opername);
    3136        1216 :     READ_NODE_FIELD(options);
    3137             : 
    3138        1216 :     READ_DONE();
    3139             : }
    3140             : 
    3141             : static AlterTypeStmt *
    3142         120 : _readAlterTypeStmt(void)
    3143             : {
    3144         120 :     READ_LOCALS(AlterTypeStmt);
    3145             : 
    3146         120 :     READ_NODE_FIELD(typeName);
    3147         120 :     READ_NODE_FIELD(options);
    3148             : 
    3149         120 :     READ_DONE();
    3150             : }
    3151             : 
    3152             : static RuleStmt *
    3153        2348 : _readRuleStmt(void)
    3154             : {
    3155        2348 :     READ_LOCALS(RuleStmt);
    3156             : 
    3157        2348 :     READ_NODE_FIELD(relation);
    3158        2348 :     READ_STRING_FIELD(rulename);
    3159        2348 :     READ_NODE_FIELD(whereClause);
    3160        2348 :     READ_ENUM_FIELD(event, CmdType);
    3161        2348 :     READ_BOOL_FIELD(instead);
    3162        2348 :     READ_NODE_FIELD(actions);
    3163        2348 :     READ_BOOL_FIELD(replace);
    3164             : 
    3165        2348 :     READ_DONE();
    3166             : }
    3167             : 
    3168             : static NotifyStmt *
    3169         406 : _readNotifyStmt(void)
    3170             : {
    3171         406 :     READ_LOCALS(NotifyStmt);
    3172             : 
    3173         406 :     READ_STRING_FIELD(conditionname);
    3174         406 :     READ_STRING_FIELD(payload);
    3175             : 
    3176         406 :     READ_DONE();
    3177             : }
    3178             : 
    3179             : static ListenStmt *
    3180         148 : _readListenStmt(void)
    3181             : {
    3182         148 :     READ_LOCALS(ListenStmt);
    3183             : 
    3184         148 :     READ_STRING_FIELD(conditionname);
    3185             : 
    3186         148 :     READ_DONE();
    3187             : }
    3188             : 
    3189             : static UnlistenStmt *
    3190          76 : _readUnlistenStmt(void)
    3191             : {
    3192          76 :     READ_LOCALS(UnlistenStmt);
    3193             : 
    3194          76 :     READ_STRING_FIELD(conditionname);
    3195             : 
    3196          76 :     READ_DONE();
    3197             : }
    3198             : 
    3199             : static TransactionStmt *
    3200       75658 : _readTransactionStmt(void)
    3201             : {
    3202       75658 :     READ_LOCALS(TransactionStmt);
    3203             : 
    3204       75658 :     READ_ENUM_FIELD(kind, TransactionStmtKind);
    3205       75658 :     READ_NODE_FIELD(options);
    3206       75658 :     READ_STRING_FIELD(savepoint_name);
    3207       75658 :     READ_STRING_FIELD(gid);
    3208       75658 :     READ_BOOL_FIELD(chain);
    3209       75658 :     READ_LOCATION_FIELD(location);
    3210             : 
    3211       75658 :     READ_DONE();
    3212             : }
    3213             : 
    3214             : static CompositeTypeStmt *
    3215        5288 : _readCompositeTypeStmt(void)
    3216             : {
    3217        5288 :     READ_LOCALS(CompositeTypeStmt);
    3218             : 
    3219        5288 :     READ_NODE_FIELD(typevar);
    3220        5288 :     READ_NODE_FIELD(coldeflist);
    3221             : 
    3222        5288 :     READ_DONE();
    3223             : }
    3224             : 
    3225             : static CreateEnumStmt *
    3226         412 : _readCreateEnumStmt(void)
    3227             : {
    3228         412 :     READ_LOCALS(CreateEnumStmt);
    3229             : 
    3230         412 :     READ_NODE_FIELD(typeName);
    3231         412 :     READ_NODE_FIELD(vals);
    3232             : 
    3233         412 :     READ_DONE();
    3234             : }
    3235             : 
    3236             : static CreateRangeStmt *
    3237         392 : _readCreateRangeStmt(void)
    3238             : {
    3239         392 :     READ_LOCALS(CreateRangeStmt);
    3240             : 
    3241         392 :     READ_NODE_FIELD(typeName);
    3242         392 :     READ_NODE_FIELD(params);
    3243             : 
    3244         392 :     READ_DONE();
    3245             : }
    3246             : 
    3247             : static AlterEnumStmt *
    3248         792 : _readAlterEnumStmt(void)
    3249             : {
    3250         792 :     READ_LOCALS(AlterEnumStmt);
    3251             : 
    3252         792 :     READ_NODE_FIELD(typeName);
    3253         792 :     READ_STRING_FIELD(oldVal);
    3254         792 :     READ_STRING_FIELD(newVal);
    3255         792 :     READ_STRING_FIELD(newValNeighbor);
    3256         792 :     READ_BOOL_FIELD(newValIsAfter);
    3257         792 :     READ_BOOL_FIELD(skipIfNewValExists);
    3258             : 
    3259         792 :     READ_DONE();
    3260             : }
    3261             : 
    3262             : static ViewStmt *
    3263       34656 : _readViewStmt(void)
    3264             : {
    3265       34656 :     READ_LOCALS(ViewStmt);
    3266             : 
    3267       34656 :     READ_NODE_FIELD(view);
    3268       34656 :     READ_NODE_FIELD(aliases);
    3269       34656 :     READ_NODE_FIELD(query);
    3270       34656 :     READ_BOOL_FIELD(replace);
    3271       34656 :     READ_NODE_FIELD(options);
    3272       34656 :     READ_ENUM_FIELD(withCheckOption, ViewCheckOption);
    3273             : 
    3274       34656 :     READ_DONE();
    3275             : }
    3276             : 
    3277             : static LoadStmt *
    3278         104 : _readLoadStmt(void)
    3279             : {
    3280         104 :     READ_LOCALS(LoadStmt);
    3281             : 
    3282         104 :     READ_STRING_FIELD(filename);
    3283             : 
    3284         104 :     READ_DONE();
    3285             : }
    3286             : 
    3287             : static CreatedbStmt *
    3288        1580 : _readCreatedbStmt(void)
    3289             : {
    3290        1580 :     READ_LOCALS(CreatedbStmt);
    3291             : 
    3292        1580 :     READ_STRING_FIELD(dbname);
    3293        1580 :     READ_NODE_FIELD(options);
    3294             : 
    3295        1580 :     READ_DONE();
    3296             : }
    3297             : 
    3298             : static AlterDatabaseStmt *
    3299         152 : _readAlterDatabaseStmt(void)
    3300             : {
    3301         152 :     READ_LOCALS(AlterDatabaseStmt);
    3302             : 
    3303         152 :     READ_STRING_FIELD(dbname);
    3304         152 :     READ_NODE_FIELD(options);
    3305             : 
    3306         152 :     READ_DONE();
    3307             : }
    3308             : 
    3309             : static AlterDatabaseRefreshCollStmt *
    3310          12 : _readAlterDatabaseRefreshCollStmt(void)
    3311             : {
    3312          12 :     READ_LOCALS(AlterDatabaseRefreshCollStmt);
    3313             : 
    3314          12 :     READ_STRING_FIELD(dbname);
    3315             : 
    3316          12 :     READ_DONE();
    3317             : }
    3318             : 
    3319             : static AlterDatabaseSetStmt *
    3320        2412 : _readAlterDatabaseSetStmt(void)
    3321             : {
    3322        2412 :     READ_LOCALS(AlterDatabaseSetStmt);
    3323             : 
    3324        2412 :     READ_STRING_FIELD(dbname);
    3325        2412 :     READ_NODE_FIELD(setstmt);
    3326             : 
    3327        2412 :     READ_DONE();
    3328             : }
    3329             : 
    3330             : static DropdbStmt *
    3331         244 : _readDropdbStmt(void)
    3332             : {
    3333         244 :     READ_LOCALS(DropdbStmt);
    3334             : 
    3335         244 :     READ_STRING_FIELD(dbname);
    3336         244 :     READ_BOOL_FIELD(missing_ok);
    3337         244 :     READ_NODE_FIELD(options);
    3338             : 
    3339         244 :     READ_DONE();
    3340             : }
    3341             : 
    3342             : static AlterSystemStmt *
    3343         372 : _readAlterSystemStmt(void)
    3344             : {
    3345         372 :     READ_LOCALS(AlterSystemStmt);
    3346             : 
    3347         372 :     READ_NODE_FIELD(setstmt);
    3348             : 
    3349         372 :     READ_DONE();
    3350             : }
    3351             : 
    3352             : static ClusterStmt *
    3353         464 : _readClusterStmt(void)
    3354             : {
    3355         464 :     READ_LOCALS(ClusterStmt);
    3356             : 
    3357         464 :     READ_NODE_FIELD(relation);
    3358         464 :     READ_STRING_FIELD(indexname);
    3359         464 :     READ_NODE_FIELD(params);
    3360             : 
    3361         464 :     READ_DONE();
    3362             : }
    3363             : 
    3364             : static VacuumStmt *
    3365       26966 : _readVacuumStmt(void)
    3366             : {
    3367       26966 :     READ_LOCALS(VacuumStmt);
    3368             : 
    3369       26966 :     READ_NODE_FIELD(options);
    3370       26966 :     READ_NODE_FIELD(rels);
    3371       26966 :     READ_BOOL_FIELD(is_vacuumcmd);
    3372             : 
    3373       26966 :     READ_DONE();
    3374             : }
    3375             : 
    3376             : static VacuumRelation *
    3377       26502 : _readVacuumRelation(void)
    3378             : {
    3379       26502 :     READ_LOCALS(VacuumRelation);
    3380             : 
    3381       26502 :     READ_NODE_FIELD(relation);
    3382       26502 :     READ_OID_FIELD(oid);
    3383       26502 :     READ_NODE_FIELD(va_cols);
    3384             : 
    3385       26502 :     READ_DONE();
    3386             : }
    3387             : 
    3388             : static ExplainStmt *
    3389       39654 : _readExplainStmt(void)
    3390             : {
    3391       39654 :     READ_LOCALS(ExplainStmt);
    3392             : 
    3393       39654 :     READ_NODE_FIELD(query);
    3394       39654 :     READ_NODE_FIELD(options);
    3395             : 
    3396       39654 :     READ_DONE();
    3397             : }
    3398             : 
    3399             : static CreateTableAsStmt *
    3400        3824 : _readCreateTableAsStmt(void)
    3401             : {
    3402        3824 :     READ_LOCALS(CreateTableAsStmt);
    3403             : 
    3404        3824 :     READ_NODE_FIELD(query);
    3405        3824 :     READ_NODE_FIELD(into);
    3406        3824 :     READ_ENUM_FIELD(objtype, ObjectType);
    3407        3824 :     READ_BOOL_FIELD(is_select_into);
    3408        3824 :     READ_BOOL_FIELD(if_not_exists);
    3409             : 
    3410        3824 :     READ_DONE();
    3411             : }
    3412             : 
    3413             : static RefreshMatViewStmt *
    3414         568 : _readRefreshMatViewStmt(void)
    3415             : {
    3416         568 :     READ_LOCALS(RefreshMatViewStmt);
    3417             : 
    3418         568 :     READ_BOOL_FIELD(concurrent);
    3419         568 :     READ_BOOL_FIELD(skipData);
    3420         568 :     READ_NODE_FIELD(relation);
    3421             : 
    3422         568 :     READ_DONE();
    3423             : }
    3424             : 
    3425             : static CheckPointStmt *
    3426         482 : _readCheckPointStmt(void)
    3427             : {
    3428         482 :     READ_LOCALS(CheckPointStmt);
    3429             : 
    3430         482 :     READ_NODE_FIELD(options);
    3431             : 
    3432         482 :     READ_DONE();
    3433             : }
    3434             : 
    3435             : static DiscardStmt *
    3436          60 : _readDiscardStmt(void)
    3437             : {
    3438          60 :     READ_LOCALS(DiscardStmt);
    3439             : 
    3440          60 :     READ_ENUM_FIELD(target, DiscardMode);
    3441             : 
    3442          60 :     READ_DONE();
    3443             : }
    3444             : 
    3445             : static LockStmt *
    3446        5052 : _readLockStmt(void)
    3447             : {
    3448        5052 :     READ_LOCALS(LockStmt);
    3449             : 
    3450        5052 :     READ_NODE_FIELD(relations);
    3451        5052 :     READ_INT_FIELD(mode);
    3452        5052 :     READ_BOOL_FIELD(nowait);
    3453             : 
    3454        5052 :     READ_DONE();
    3455             : }
    3456             : 
    3457             : static ConstraintsSetStmt *
    3458         202 : _readConstraintsSetStmt(void)
    3459             : {
    3460         202 :     READ_LOCALS(ConstraintsSetStmt);
    3461             : 
    3462         202 :     READ_NODE_FIELD(constraints);
    3463         202 :     READ_BOOL_FIELD(deferred);
    3464             : 
    3465         202 :     READ_DONE();
    3466             : }
    3467             : 
    3468             : static ReindexStmt *
    3469        2204 : _readReindexStmt(void)
    3470             : {
    3471        2204 :     READ_LOCALS(ReindexStmt);
    3472             : 
    3473        2204 :     READ_ENUM_FIELD(kind, ReindexObjectType);
    3474        2204 :     READ_NODE_FIELD(relation);
    3475        2204 :     READ_STRING_FIELD(name);
    3476        2204 :     READ_NODE_FIELD(params);
    3477             : 
    3478        2204 :     READ_DONE();
    3479             : }
    3480             : 
    3481             : static CreateConversionStmt *
    3482         128 : _readCreateConversionStmt(void)
    3483             : {
    3484         128 :     READ_LOCALS(CreateConversionStmt);
    3485             : 
    3486         128 :     READ_NODE_FIELD(conversion_name);
    3487         128 :     READ_STRING_FIELD(for_encoding_name);
    3488         128 :     READ_STRING_FIELD(to_encoding_name);
    3489         128 :     READ_NODE_FIELD(func_name);
    3490         128 :     READ_BOOL_FIELD(def);
    3491             : 
    3492         128 :     READ_DONE();
    3493             : }
    3494             : 
    3495             : static CreateCastStmt *
    3496         580 : _readCreateCastStmt(void)
    3497             : {
    3498         580 :     READ_LOCALS(CreateCastStmt);
    3499             : 
    3500         580 :     READ_NODE_FIELD(sourcetype);
    3501         580 :     READ_NODE_FIELD(targettype);
    3502         580 :     READ_NODE_FIELD(func);
    3503         580 :     READ_ENUM_FIELD(context, CoercionContext);
    3504         580 :     READ_BOOL_FIELD(inout);
    3505             : 
    3506         580 :     READ_DONE();
    3507             : }
    3508             : 
    3509             : static CreateTransformStmt *
    3510         104 : _readCreateTransformStmt(void)
    3511             : {
    3512         104 :     READ_LOCALS(CreateTransformStmt);
    3513             : 
    3514         104 :     READ_BOOL_FIELD(replace);
    3515         104 :     READ_NODE_FIELD(type_name);
    3516         104 :     READ_STRING_FIELD(lang);
    3517         104 :     READ_NODE_FIELD(fromsql);
    3518         104 :     READ_NODE_FIELD(tosql);
    3519             : 
    3520         104 :     READ_DONE();
    3521             : }
    3522             : 
    3523             : static PrepareStmt *
    3524        4288 : _readPrepareStmt(void)
    3525             : {
    3526        4288 :     READ_LOCALS(PrepareStmt);
    3527             : 
    3528        4288 :     READ_STRING_FIELD(name);
    3529        4288 :     READ_NODE_FIELD(argtypes);
    3530        4288 :     READ_NODE_FIELD(query);
    3531             : 
    3532        4288 :     READ_DONE();
    3533             : }
    3534             : 
    3535             : static ExecuteStmt *
    3536       40126 : _readExecuteStmt(void)
    3537             : {
    3538       40126 :     READ_LOCALS(ExecuteStmt);
    3539             : 
    3540       40126 :     READ_STRING_FIELD(name);
    3541       40126 :     READ_NODE_FIELD(params);
    3542             : 
    3543       40126 :     READ_DONE();
    3544             : }
    3545             : 
    3546             : static DeallocateStmt *
    3547        8132 : _readDeallocateStmt(void)
    3548             : {
    3549        8132 :     READ_LOCALS(DeallocateStmt);
    3550             : 
    3551        8132 :     READ_STRING_FIELD(name);
    3552        8132 :     READ_BOOL_FIELD(isall);
    3553        8132 :     READ_LOCATION_FIELD(location);
    3554             : 
    3555        8132 :     READ_DONE();
    3556             : }
    3557             : 
    3558             : static DropOwnedStmt *
    3559         308 : _readDropOwnedStmt(void)
    3560             : {
    3561         308 :     READ_LOCALS(DropOwnedStmt);
    3562             : 
    3563         308 :     READ_NODE_FIELD(roles);
    3564         308 :     READ_ENUM_FIELD(behavior, DropBehavior);
    3565             : 
    3566         308 :     READ_DONE();
    3567             : }
    3568             : 
    3569             : static ReassignOwnedStmt *
    3570         104 : _readReassignOwnedStmt(void)
    3571             : {
    3572         104 :     READ_LOCALS(ReassignOwnedStmt);
    3573             : 
    3574         104 :     READ_NODE_FIELD(roles);
    3575         104 :     READ_NODE_FIELD(newrole);
    3576             : 
    3577         104 :     READ_DONE();
    3578             : }
    3579             : 
    3580             : static AlterTSDictionaryStmt *
    3581          80 : _readAlterTSDictionaryStmt(void)
    3582             : {
    3583          80 :     READ_LOCALS(AlterTSDictionaryStmt);
    3584             : 
    3585          80 :     READ_NODE_FIELD(dictname);
    3586          80 :     READ_NODE_FIELD(options);
    3587             : 
    3588          80 :     READ_DONE();
    3589             : }
    3590             : 
    3591             : static AlterTSConfigurationStmt *
    3592       17836 : _readAlterTSConfigurationStmt(void)
    3593             : {
    3594       17836 :     READ_LOCALS(AlterTSConfigurationStmt);
    3595             : 
    3596       17836 :     READ_ENUM_FIELD(kind, AlterTSConfigType);
    3597       17836 :     READ_NODE_FIELD(cfgname);
    3598       17836 :     READ_NODE_FIELD(tokentype);
    3599       17836 :     READ_NODE_FIELD(dicts);
    3600       17836 :     READ_BOOL_FIELD(override);
    3601       17836 :     READ_BOOL_FIELD(replace);
    3602       17836 :     READ_BOOL_FIELD(missing_ok);
    3603             : 
    3604       17836 :     READ_DONE();
    3605             : }
    3606             : 
    3607             : static PublicationTable *
    3608        2780 : _readPublicationTable(void)
    3609             : {
    3610        2780 :     READ_LOCALS(PublicationTable);
    3611             : 
    3612        2780 :     READ_NODE_FIELD(relation);
    3613        2780 :     READ_NODE_FIELD(whereClause);
    3614        2780 :     READ_NODE_FIELD(columns);
    3615             : 
    3616        2780 :     READ_DONE();
    3617             : }
    3618             : 
    3619             : static PublicationObjSpec *
    3620        3492 : _readPublicationObjSpec(void)
    3621             : {
    3622        3492 :     READ_LOCALS(PublicationObjSpec);
    3623             : 
    3624        3492 :     READ_ENUM_FIELD(pubobjtype, PublicationObjSpecType);
    3625        3492 :     READ_STRING_FIELD(name);
    3626        3492 :     READ_NODE_FIELD(pubtable);
    3627        3492 :     READ_LOCATION_FIELD(location);
    3628             : 
    3629        3492 :     READ_DONE();
    3630             : }
    3631             : 
    3632             : static CreatePublicationStmt *
    3633        1632 : _readCreatePublicationStmt(void)
    3634             : {
    3635        1632 :     READ_LOCALS(CreatePublicationStmt);
    3636             : 
    3637        1632 :     READ_STRING_FIELD(pubname);
    3638        1632 :     READ_NODE_FIELD(options);
    3639        1632 :     READ_NODE_FIELD(pubobjects);
    3640        1632 :     READ_BOOL_FIELD(for_all_tables);
    3641             : 
    3642        1632 :     READ_DONE();
    3643             : }
    3644             : 
    3645             : static AlterPublicationStmt *
    3646        2140 : _readAlterPublicationStmt(void)
    3647             : {
    3648        2140 :     READ_LOCALS(AlterPublicationStmt);
    3649             : 
    3650        2140 :     READ_STRING_FIELD(pubname);
    3651        2140 :     READ_NODE_FIELD(options);
    3652        2140 :     READ_NODE_FIELD(pubobjects);
    3653        2140 :     READ_BOOL_FIELD(for_all_tables);
    3654        2140 :     READ_ENUM_FIELD(action, AlterPublicationAction);
    3655             : 
    3656        2140 :     READ_DONE();
    3657             : }
    3658             : 
    3659             : static CreateSubscriptionStmt *
    3660         932 : _readCreateSubscriptionStmt(void)
    3661             : {
    3662         932 :     READ_LOCALS(CreateSubscriptionStmt);
    3663             : 
    3664         932 :     READ_STRING_FIELD(subname);
    3665         932 :     READ_STRING_FIELD(conninfo);
    3666         932 :     READ_NODE_FIELD(publication);
    3667         932 :     READ_NODE_FIELD(options);
    3668             : 
    3669         932 :     READ_DONE();
    3670             : }
    3671             : 
    3672             : static AlterSubscriptionStmt *
    3673         990 : _readAlterSubscriptionStmt(void)
    3674             : {
    3675         990 :     READ_LOCALS(AlterSubscriptionStmt);
    3676             : 
    3677         990 :     READ_ENUM_FIELD(kind, AlterSubscriptionType);
    3678         990 :     READ_STRING_FIELD(subname);
    3679         990 :     READ_STRING_FIELD(conninfo);
    3680         990 :     READ_NODE_FIELD(publication);
    3681         990 :     READ_NODE_FIELD(options);
    3682             : 
    3683         990 :     READ_DONE();
    3684             : }
    3685             : 
    3686             : static DropSubscriptionStmt *
    3687         476 : _readDropSubscriptionStmt(void)
    3688             : {
    3689         476 :     READ_LOCALS(DropSubscriptionStmt);
    3690             : 
    3691         476 :     READ_STRING_FIELD(subname);
    3692         476 :     READ_BOOL_FIELD(missing_ok);
    3693         476 :     READ_ENUM_FIELD(behavior, DropBehavior);
    3694             : 
    3695         476 :     READ_DONE();
    3696             : }
    3697             : 
    3698             : static GroupByOrdering *
    3699           0 : _readGroupByOrdering(void)
    3700             : {
    3701           0 :     READ_LOCALS(GroupByOrdering);
    3702             : 
    3703           0 :     READ_NODE_FIELD(pathkeys);
    3704           0 :     READ_NODE_FIELD(clauses);
    3705             : 
    3706           0 :     READ_DONE();
    3707             : }
    3708             : 
    3709             : static PlaceHolderVar *
    3710           0 : _readPlaceHolderVar(void)
    3711             : {
    3712           0 :     READ_LOCALS(PlaceHolderVar);
    3713             : 
    3714           0 :     READ_NODE_FIELD(phexpr);
    3715           0 :     READ_BITMAPSET_FIELD(phrels);
    3716           0 :     READ_BITMAPSET_FIELD(phnullingrels);
    3717           0 :     READ_UINT_FIELD(phid);
    3718           0 :     READ_UINT_FIELD(phlevelsup);
    3719             : 
    3720           0 :     READ_DONE();
    3721             : }
    3722             : 
    3723             : static AppendRelInfo *
    3724       50436 : _readAppendRelInfo(void)
    3725             : {
    3726       50436 :     READ_LOCALS(AppendRelInfo);
    3727             : 
    3728       50436 :     READ_UINT_FIELD(parent_relid);
    3729       50436 :     READ_UINT_FIELD(child_relid);
    3730       50436 :     READ_OID_FIELD(parent_reltype);
    3731       50436 :     READ_OID_FIELD(child_reltype);
    3732       50436 :     READ_NODE_FIELD(translated_vars);
    3733       50436 :     READ_INT_FIELD(num_child_cols);
    3734       50436 :     READ_ATTRNUMBER_ARRAY(parent_colnos, local_node->num_child_cols);
    3735       50436 :     READ_OID_FIELD(parent_reloid);
    3736             : 
    3737       50436 :     READ_DONE();
    3738             : }
    3739             : 
    3740             : static PlannedStmt *
    3741      451858 : _readPlannedStmt(void)
    3742             : {
    3743      451858 :     READ_LOCALS(PlannedStmt);
    3744             : 
    3745      451858 :     READ_ENUM_FIELD(commandType, CmdType);
    3746      451858 :     READ_INT64_FIELD(queryId);
    3747      451858 :     READ_INT64_FIELD(planId);
    3748      451858 :     READ_ENUM_FIELD(cached_plan_type, CachedPlanType);
    3749      451858 :     READ_BOOL_FIELD(hasReturning);
    3750      451858 :     READ_BOOL_FIELD(hasModifyingCTE);
    3751      451858 :     READ_BOOL_FIELD(canSetTag);
    3752      451858 :     READ_BOOL_FIELD(transientPlan);
    3753      451858 :     READ_BOOL_FIELD(dependsOnRole);
    3754      451858 :     READ_BOOL_FIELD(parallelModeNeeded);
    3755      451858 :     READ_INT_FIELD(jitFlags);
    3756      451858 :     READ_NODE_FIELD(planTree);
    3757      451858 :     READ_NODE_FIELD(partPruneInfos);
    3758      451858 :     READ_NODE_FIELD(rtable);
    3759      451858 :     READ_BITMAPSET_FIELD(unprunableRelids);
    3760      451858 :     READ_NODE_FIELD(permInfos);
    3761      451858 :     READ_NODE_FIELD(resultRelations);
    3762      451858 :     READ_NODE_FIELD(appendRelations);
    3763      451858 :     READ_NODE_FIELD(subplans);
    3764      451858 :     READ_BITMAPSET_FIELD(rewindPlanIDs);
    3765      451858 :     READ_NODE_FIELD(rowMarks);
    3766      451858 :     READ_NODE_FIELD(relationOids);
    3767      451858 :     READ_NODE_FIELD(invalItems);
    3768      451858 :     READ_NODE_FIELD(paramExecTypes);
    3769      451858 :     READ_NODE_FIELD(utilityStmt);
    3770      451858 :     READ_LOCATION_FIELD(stmt_location);
    3771      451858 :     READ_LOCATION_FIELD(stmt_len);
    3772             : 
    3773      451858 :     READ_DONE();
    3774             : }
    3775             : 
    3776             : static Result *
    3777      208000 : _readResult(void)
    3778             : {
    3779      208000 :     READ_LOCALS(Result);
    3780             : 
    3781      208000 :     READ_INT_FIELD(plan.disabled_nodes);
    3782      208000 :     READ_FLOAT_FIELD(plan.startup_cost);
    3783      208000 :     READ_FLOAT_FIELD(plan.total_cost);
    3784      208000 :     READ_FLOAT_FIELD(plan.plan_rows);
    3785      208000 :     READ_INT_FIELD(plan.plan_width);
    3786      208000 :     READ_BOOL_FIELD(plan.parallel_aware);
    3787      208000 :     READ_BOOL_FIELD(plan.parallel_safe);
    3788      208000 :     READ_BOOL_FIELD(plan.async_capable);
    3789      208000 :     READ_INT_FIELD(plan.plan_node_id);
    3790      208000 :     READ_NODE_FIELD(plan.targetlist);
    3791      208000 :     READ_NODE_FIELD(plan.qual);
    3792      208000 :     READ_NODE_FIELD(plan.lefttree);
    3793      208000 :     READ_NODE_FIELD(plan.righttree);
    3794      208000 :     READ_NODE_FIELD(plan.initPlan);
    3795      208000 :     READ_BITMAPSET_FIELD(plan.extParam);
    3796      208000 :     READ_BITMAPSET_FIELD(plan.allParam);
    3797      208000 :     READ_NODE_FIELD(resconstantqual);
    3798             : 
    3799      208000 :     READ_DONE();
    3800             : }
    3801             : 
    3802             : static ProjectSet *
    3803       12060 : _readProjectSet(void)
    3804             : {
    3805       12060 :     READ_LOCALS(ProjectSet);
    3806             : 
    3807       12060 :     READ_INT_FIELD(plan.disabled_nodes);
    3808       12060 :     READ_FLOAT_FIELD(plan.startup_cost);
    3809       12060 :     READ_FLOAT_FIELD(plan.total_cost);
    3810       12060 :     READ_FLOAT_FIELD(plan.plan_rows);
    3811       12060 :     READ_INT_FIELD(plan.plan_width);
    3812       12060 :     READ_BOOL_FIELD(plan.parallel_aware);
    3813       12060 :     READ_BOOL_FIELD(plan.parallel_safe);
    3814       12060 :     READ_BOOL_FIELD(plan.async_capable);
    3815       12060 :     READ_INT_FIELD(plan.plan_node_id);
    3816       12060 :     READ_NODE_FIELD(plan.targetlist);
    3817       12060 :     READ_NODE_FIELD(plan.qual);
    3818       12060 :     READ_NODE_FIELD(plan.lefttree);
    3819       12060 :     READ_NODE_FIELD(plan.righttree);
    3820       12060 :     READ_NODE_FIELD(plan.initPlan);
    3821       12060 :     READ_BITMAPSET_FIELD(plan.extParam);
    3822       12060 :     READ_BITMAPSET_FIELD(plan.allParam);
    3823             : 
    3824       12060 :     READ_DONE();
    3825             : }
    3826             : 
    3827             : static ModifyTable *
    3828       86416 : _readModifyTable(void)
    3829             : {
    3830       86416 :     READ_LOCALS(ModifyTable);
    3831             : 
    3832       86416 :     READ_INT_FIELD(plan.disabled_nodes);
    3833       86416 :     READ_FLOAT_FIELD(plan.startup_cost);
    3834       86416 :     READ_FLOAT_FIELD(plan.total_cost);
    3835       86416 :     READ_FLOAT_FIELD(plan.plan_rows);
    3836       86416 :     READ_INT_FIELD(plan.plan_width);
    3837       86416 :     READ_BOOL_FIELD(plan.parallel_aware);
    3838       86416 :     READ_BOOL_FIELD(plan.parallel_safe);
    3839       86416 :     READ_BOOL_FIELD(plan.async_capable);
    3840       86416 :     READ_INT_FIELD(plan.plan_node_id);
    3841       86416 :     READ_NODE_FIELD(plan.targetlist);
    3842       86416 :     READ_NODE_FIELD(plan.qual);
    3843       86416 :     READ_NODE_FIELD(plan.lefttree);
    3844       86416 :     READ_NODE_FIELD(plan.righttree);
    3845       86416 :     READ_NODE_FIELD(plan.initPlan);
    3846       86416 :     READ_BITMAPSET_FIELD(plan.extParam);
    3847       86416 :     READ_BITMAPSET_FIELD(plan.allParam);
    3848       86416 :     READ_ENUM_FIELD(operation, CmdType);
    3849       86416 :     READ_BOOL_FIELD(canSetTag);
    3850       86416 :     READ_UINT_FIELD(nominalRelation);
    3851       86416 :     READ_UINT_FIELD(rootRelation);
    3852       86416 :     READ_BOOL_FIELD(partColsUpdated);
    3853       86416 :     READ_NODE_FIELD(resultRelations);
    3854       86416 :     READ_NODE_FIELD(updateColnosLists);
    3855       86416 :     READ_NODE_FIELD(withCheckOptionLists);
    3856       86416 :     READ_STRING_FIELD(returningOldAlias);
    3857       86416 :     READ_STRING_FIELD(returningNewAlias);
    3858       86416 :     READ_NODE_FIELD(returningLists);
    3859       86416 :     READ_NODE_FIELD(fdwPrivLists);
    3860       86416 :     READ_BITMAPSET_FIELD(fdwDirectModifyPlans);
    3861       86416 :     READ_NODE_FIELD(rowMarks);
    3862       86416 :     READ_INT_FIELD(epqParam);
    3863       86416 :     READ_ENUM_FIELD(onConflictAction, OnConflictAction);
    3864       86416 :     READ_NODE_FIELD(arbiterIndexes);
    3865       86416 :     READ_NODE_FIELD(onConflictSet);
    3866       86416 :     READ_NODE_FIELD(onConflictCols);
    3867       86416 :     READ_NODE_FIELD(onConflictWhere);
    3868       86416 :     READ_UINT_FIELD(exclRelRTI);
    3869       86416 :     READ_NODE_FIELD(exclRelTlist);
    3870       86416 :     READ_NODE_FIELD(mergeActionLists);
    3871       86416 :     READ_NODE_FIELD(mergeJoinConditions);
    3872             : 
    3873       86416 :     READ_DONE();
    3874             : }
    3875             : 
    3876             : static Append *
    3877       17214 : _readAppend(void)
    3878             : {
    3879       17214 :     READ_LOCALS(Append);
    3880             : 
    3881       17214 :     READ_INT_FIELD(plan.disabled_nodes);
    3882       17214 :     READ_FLOAT_FIELD(plan.startup_cost);
    3883       17214 :     READ_FLOAT_FIELD(plan.total_cost);
    3884       17214 :     READ_FLOAT_FIELD(plan.plan_rows);
    3885       17214 :     READ_INT_FIELD(plan.plan_width);
    3886       17214 :     READ_BOOL_FIELD(plan.parallel_aware);
    3887       17214 :     READ_BOOL_FIELD(plan.parallel_safe);
    3888       17214 :     READ_BOOL_FIELD(plan.async_capable);
    3889       17214 :     READ_INT_FIELD(plan.plan_node_id);
    3890       17214 :     READ_NODE_FIELD(plan.targetlist);
    3891       17214 :     READ_NODE_FIELD(plan.qual);
    3892       17214 :     READ_NODE_FIELD(plan.lefttree);
    3893       17214 :     READ_NODE_FIELD(plan.righttree);
    3894       17214 :     READ_NODE_FIELD(plan.initPlan);
    3895       17214 :     READ_BITMAPSET_FIELD(plan.extParam);
    3896       17214 :     READ_BITMAPSET_FIELD(plan.allParam);
    3897       17214 :     READ_BITMAPSET_FIELD(apprelids);
    3898       17214 :     READ_NODE_FIELD(appendplans);
    3899       17214 :     READ_INT_FIELD(nasyncplans);
    3900       17214 :     READ_INT_FIELD(first_partial_plan);
    3901       17214 :     READ_INT_FIELD(part_prune_index);
    3902             : 
    3903       17214 :     READ_DONE();
    3904             : }
    3905             : 
    3906             : static MergeAppend *
    3907         532 : _readMergeAppend(void)
    3908             : {
    3909         532 :     READ_LOCALS(MergeAppend);
    3910             : 
    3911         532 :     READ_INT_FIELD(plan.disabled_nodes);
    3912         532 :     READ_FLOAT_FIELD(plan.startup_cost);
    3913         532 :     READ_FLOAT_FIELD(plan.total_cost);
    3914         532 :     READ_FLOAT_FIELD(plan.plan_rows);
    3915         532 :     READ_INT_FIELD(plan.plan_width);
    3916         532 :     READ_BOOL_FIELD(plan.parallel_aware);
    3917         532 :     READ_BOOL_FIELD(plan.parallel_safe);
    3918         532 :     READ_BOOL_FIELD(plan.async_capable);
    3919         532 :     READ_INT_FIELD(plan.plan_node_id);
    3920         532 :     READ_NODE_FIELD(plan.targetlist);
    3921         532 :     READ_NODE_FIELD(plan.qual);
    3922         532 :     READ_NODE_FIELD(plan.lefttree);
    3923         532 :     READ_NODE_FIELD(plan.righttree);
    3924         532 :     READ_NODE_FIELD(plan.initPlan);
    3925         532 :     READ_BITMAPSET_FIELD(plan.extParam);
    3926         532 :     READ_BITMAPSET_FIELD(plan.allParam);
    3927         532 :     READ_BITMAPSET_FIELD(apprelids);
    3928         532 :     READ_NODE_FIELD(mergeplans);
    3929         532 :     READ_INT_FIELD(numCols);
    3930         532 :     READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
    3931         532 :     READ_OID_ARRAY(sortOperators, local_node->numCols);
    3932         532 :     READ_OID_ARRAY(collations, local_node->numCols);
    3933         532 :     READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
    3934         532 :     READ_INT_FIELD(part_prune_index);
    3935             : 
    3936         532 :     READ_DONE();
    3937             : }
    3938             : 
    3939             : static RecursiveUnion *
    3940        1012 : _readRecursiveUnion(void)
    3941             : {
    3942        1012 :     READ_LOCALS(RecursiveUnion);
    3943             : 
    3944        1012 :     READ_INT_FIELD(plan.disabled_nodes);
    3945        1012 :     READ_FLOAT_FIELD(plan.startup_cost);
    3946        1012 :     READ_FLOAT_FIELD(plan.total_cost);
    3947        1012 :     READ_FLOAT_FIELD(plan.plan_rows);
    3948        1012 :     READ_INT_FIELD(plan.plan_width);
    3949        1012 :     READ_BOOL_FIELD(plan.parallel_aware);
    3950        1012 :     READ_BOOL_FIELD(plan.parallel_safe);
    3951        1012 :     READ_BOOL_FIELD(plan.async_capable);
    3952        1012 :     READ_INT_FIELD(plan.plan_node_id);
    3953        1012 :     READ_NODE_FIELD(plan.targetlist);
    3954        1012 :     READ_NODE_FIELD(plan.qual);
    3955        1012 :     READ_NODE_FIELD(plan.lefttree);
    3956        1012 :     READ_NODE_FIELD(plan.righttree);
    3957        1012 :     READ_NODE_FIELD(plan.initPlan);
    3958        1012 :     READ_BITMAPSET_FIELD(plan.extParam);
    3959        1012 :     READ_BITMAPSET_FIELD(plan.allParam);
    3960        1012 :     READ_INT_FIELD(wtParam);
    3961        1012 :     READ_INT_FIELD(numCols);
    3962        1012 :     READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
    3963        1012 :     READ_OID_ARRAY(dupOperators, local_node->numCols);
    3964        1012 :     READ_OID_ARRAY(dupCollations, local_node->numCols);
    3965        1012 :     READ_LONG_FIELD(numGroups);
    3966             : 
    3967        1012 :     READ_DONE();
    3968             : }
    3969             : 
    3970             : static BitmapAnd *
    3971         226 : _readBitmapAnd(void)
    3972             : {
    3973         226 :     READ_LOCALS(BitmapAnd);
    3974             : 
    3975         226 :     READ_INT_FIELD(plan.disabled_nodes);
    3976         226 :     READ_FLOAT_FIELD(plan.startup_cost);
    3977         226 :     READ_FLOAT_FIELD(plan.total_cost);
    3978         226 :     READ_FLOAT_FIELD(plan.plan_rows);
    3979         226 :     READ_INT_FIELD(plan.plan_width);
    3980         226 :     READ_BOOL_FIELD(plan.parallel_aware);
    3981         226 :     READ_BOOL_FIELD(plan.parallel_safe);
    3982         226 :     READ_BOOL_FIELD(plan.async_capable);
    3983         226 :     READ_INT_FIELD(plan.plan_node_id);
    3984         226 :     READ_NODE_FIELD(plan.targetlist);
    3985         226 :     READ_NODE_FIELD(plan.qual);
    3986         226 :     READ_NODE_FIELD(plan.lefttree);
    3987         226 :     READ_NODE_FIELD(plan.righttree);
    3988         226 :     READ_NODE_FIELD(plan.initPlan);
    3989         226 :     READ_BITMAPSET_FIELD(plan.extParam);
    3990         226 :     READ_BITMAPSET_FIELD(plan.allParam);
    3991         226 :     READ_NODE_FIELD(bitmapplans);
    3992             : 
    3993         226 :     READ_DONE();
    3994             : }
    3995             : 
    3996             : static BitmapOr *
    3997         404 : _readBitmapOr(void)
    3998             : {
    3999         404 :     READ_LOCALS(BitmapOr);
    4000             : 
    4001         404 :     READ_INT_FIELD(plan.disabled_nodes);
    4002         404 :     READ_FLOAT_FIELD(plan.startup_cost);
    4003         404 :     READ_FLOAT_FIELD(plan.total_cost);
    4004         404 :     READ_FLOAT_FIELD(plan.plan_rows);
    4005         404 :     READ_INT_FIELD(plan.plan_width);
    4006         404 :     READ_BOOL_FIELD(plan.parallel_aware);
    4007         404 :     READ_BOOL_FIELD(plan.parallel_safe);
    4008         404 :     READ_BOOL_FIELD(plan.async_capable);
    4009         404 :     READ_INT_FIELD(plan.plan_node_id);
    4010         404 :     READ_NODE_FIELD(plan.targetlist);
    4011         404 :     READ_NODE_FIELD(plan.qual);
    4012         404 :     READ_NODE_FIELD(plan.lefttree);
    4013         404 :     READ_NODE_FIELD(plan.righttree);
    4014         404 :     READ_NODE_FIELD(plan.initPlan);
    4015         404 :     READ_BITMAPSET_FIELD(plan.extParam);
    4016         404 :     READ_BITMAPSET_FIELD(plan.allParam);
    4017         404 :     READ_BOOL_FIELD(isshared);
    4018         404 :     READ_NODE_FIELD(bitmapplans);
    4019             : 
    4020         404 :     READ_DONE();
    4021             : }
    4022             : 
    4023             : static SeqScan *
    4024      218914 : _readSeqScan(void)
    4025             : {
    4026      218914 :     READ_LOCALS(SeqScan);
    4027             : 
    4028      218914 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4029      218914 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4030      218914 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4031      218914 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4032      218914 :     READ_INT_FIELD(scan.plan.plan_width);
    4033      218914 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4034      218914 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4035      218914 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4036      218914 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4037      218914 :     READ_NODE_FIELD(scan.plan.targetlist);
    4038      218914 :     READ_NODE_FIELD(scan.plan.qual);
    4039      218914 :     READ_NODE_FIELD(scan.plan.lefttree);
    4040      218914 :     READ_NODE_FIELD(scan.plan.righttree);
    4041      218914 :     READ_NODE_FIELD(scan.plan.initPlan);
    4042      218914 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4043      218914 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4044      218914 :     READ_UINT_FIELD(scan.scanrelid);
    4045             : 
    4046      218914 :     READ_DONE();
    4047             : }
    4048             : 
    4049             : static SampleScan *
    4050         306 : _readSampleScan(void)
    4051             : {
    4052         306 :     READ_LOCALS(SampleScan);
    4053             : 
    4054         306 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4055         306 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4056         306 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4057         306 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4058         306 :     READ_INT_FIELD(scan.plan.plan_width);
    4059         306 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4060         306 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4061         306 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4062         306 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4063         306 :     READ_NODE_FIELD(scan.plan.targetlist);
    4064         306 :     READ_NODE_FIELD(scan.plan.qual);
    4065         306 :     READ_NODE_FIELD(scan.plan.lefttree);
    4066         306 :     READ_NODE_FIELD(scan.plan.righttree);
    4067         306 :     READ_NODE_FIELD(scan.plan.initPlan);
    4068         306 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4069         306 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4070         306 :     READ_UINT_FIELD(scan.scanrelid);
    4071         306 :     READ_NODE_FIELD(tablesample);
    4072             : 
    4073         306 :     READ_DONE();
    4074             : }
    4075             : 
    4076             : static IndexScan *
    4077      142616 : _readIndexScan(void)
    4078             : {
    4079      142616 :     READ_LOCALS(IndexScan);
    4080             : 
    4081      142616 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4082      142616 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4083      142616 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4084      142616 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4085      142616 :     READ_INT_FIELD(scan.plan.plan_width);
    4086      142616 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4087      142616 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4088      142616 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4089      142616 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4090      142616 :     READ_NODE_FIELD(scan.plan.targetlist);
    4091      142616 :     READ_NODE_FIELD(scan.plan.qual);
    4092      142616 :     READ_NODE_FIELD(scan.plan.lefttree);
    4093      142616 :     READ_NODE_FIELD(scan.plan.righttree);
    4094      142616 :     READ_NODE_FIELD(scan.plan.initPlan);
    4095      142616 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4096      142616 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4097      142616 :     READ_UINT_FIELD(scan.scanrelid);
    4098      142616 :     READ_OID_FIELD(indexid);
    4099      142616 :     READ_NODE_FIELD(indexqual);
    4100      142616 :     READ_NODE_FIELD(indexqualorig);
    4101      142616 :     READ_NODE_FIELD(indexorderby);
    4102      142616 :     READ_NODE_FIELD(indexorderbyorig);
    4103      142616 :     READ_NODE_FIELD(indexorderbyops);
    4104      142616 :     READ_ENUM_FIELD(indexorderdir, ScanDirection);
    4105             : 
    4106      142616 :     READ_DONE();
    4107             : }
    4108             : 
    4109             : static IndexOnlyScan *
    4110       16640 : _readIndexOnlyScan(void)
    4111             : {
    4112       16640 :     READ_LOCALS(IndexOnlyScan);
    4113             : 
    4114       16640 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4115       16640 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4116       16640 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4117       16640 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4118       16640 :     READ_INT_FIELD(scan.plan.plan_width);
    4119       16640 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4120       16640 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4121       16640 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4122       16640 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4123       16640 :     READ_NODE_FIELD(scan.plan.targetlist);
    4124       16640 :     READ_NODE_FIELD(scan.plan.qual);
    4125       16640 :     READ_NODE_FIELD(scan.plan.lefttree);
    4126       16640 :     READ_NODE_FIELD(scan.plan.righttree);
    4127       16640 :     READ_NODE_FIELD(scan.plan.initPlan);
    4128       16640 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4129       16640 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4130       16640 :     READ_UINT_FIELD(scan.scanrelid);
    4131       16640 :     READ_OID_FIELD(indexid);
    4132       16640 :     READ_NODE_FIELD(indexqual);
    4133       16640 :     READ_NODE_FIELD(recheckqual);
    4134       16640 :     READ_NODE_FIELD(indexorderby);
    4135       16640 :     READ_NODE_FIELD(indextlist);
    4136       16640 :     READ_ENUM_FIELD(indexorderdir, ScanDirection);
    4137             : 
    4138       16640 :     READ_DONE();
    4139             : }
    4140             : 
    4141             : static BitmapIndexScan *
    4142       22028 : _readBitmapIndexScan(void)
    4143             : {
    4144       22028 :     READ_LOCALS(BitmapIndexScan);
    4145             : 
    4146       22028 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4147       22028 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4148       22028 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4149       22028 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4150       22028 :     READ_INT_FIELD(scan.plan.plan_width);
    4151       22028 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4152       22028 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4153       22028 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4154       22028 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4155       22028 :     READ_NODE_FIELD(scan.plan.targetlist);
    4156       22028 :     READ_NODE_FIELD(scan.plan.qual);
    4157       22028 :     READ_NODE_FIELD(scan.plan.lefttree);
    4158       22028 :     READ_NODE_FIELD(scan.plan.righttree);
    4159       22028 :     READ_NODE_FIELD(scan.plan.initPlan);
    4160       22028 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4161       22028 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4162       22028 :     READ_UINT_FIELD(scan.scanrelid);
    4163       22028 :     READ_OID_FIELD(indexid);
    4164       22028 :     READ_BOOL_FIELD(isshared);
    4165       22028 :     READ_NODE_FIELD(indexqual);
    4166       22028 :     READ_NODE_FIELD(indexqualorig);
    4167             : 
    4168       22028 :     READ_DONE();
    4169             : }
    4170             : 
    4171             : static BitmapHeapScan *
    4172       21392 : _readBitmapHeapScan(void)
    4173             : {
    4174       21392 :     READ_LOCALS(BitmapHeapScan);
    4175             : 
    4176       21392 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4177       21392 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4178       21392 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4179       21392 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4180       21392 :     READ_INT_FIELD(scan.plan.plan_width);
    4181       21392 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4182       21392 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4183       21392 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4184       21392 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4185       21392 :     READ_NODE_FIELD(scan.plan.targetlist);
    4186       21392 :     READ_NODE_FIELD(scan.plan.qual);
    4187       21392 :     READ_NODE_FIELD(scan.plan.lefttree);
    4188       21392 :     READ_NODE_FIELD(scan.plan.righttree);
    4189       21392 :     READ_NODE_FIELD(scan.plan.initPlan);
    4190       21392 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4191       21392 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4192       21392 :     READ_UINT_FIELD(scan.scanrelid);
    4193       21392 :     READ_NODE_FIELD(bitmapqualorig);
    4194             : 
    4195       21392 :     READ_DONE();
    4196             : }
    4197             : 
    4198             : static TidScan *
    4199         732 : _readTidScan(void)
    4200             : {
    4201         732 :     READ_LOCALS(TidScan);
    4202             : 
    4203         732 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4204         732 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4205         732 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4206         732 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4207         732 :     READ_INT_FIELD(scan.plan.plan_width);
    4208         732 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4209         732 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4210         732 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4211         732 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4212         732 :     READ_NODE_FIELD(scan.plan.targetlist);
    4213         732 :     READ_NODE_FIELD(scan.plan.qual);
    4214         732 :     READ_NODE_FIELD(scan.plan.lefttree);
    4215         732 :     READ_NODE_FIELD(scan.plan.righttree);
    4216         732 :     READ_NODE_FIELD(scan.plan.initPlan);
    4217         732 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4218         732 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4219         732 :     READ_UINT_FIELD(scan.scanrelid);
    4220         732 :     READ_NODE_FIELD(tidquals);
    4221             : 
    4222         732 :     READ_DONE();
    4223             : }
    4224             : 
    4225             : static TidRangeScan *
    4226        1940 : _readTidRangeScan(void)
    4227             : {
    4228        1940 :     READ_LOCALS(TidRangeScan);
    4229             : 
    4230        1940 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4231        1940 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4232        1940 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4233        1940 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4234        1940 :     READ_INT_FIELD(scan.plan.plan_width);
    4235        1940 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4236        1940 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4237        1940 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4238        1940 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4239        1940 :     READ_NODE_FIELD(scan.plan.targetlist);
    4240        1940 :     READ_NODE_FIELD(scan.plan.qual);
    4241        1940 :     READ_NODE_FIELD(scan.plan.lefttree);
    4242        1940 :     READ_NODE_FIELD(scan.plan.righttree);
    4243        1940 :     READ_NODE_FIELD(scan.plan.initPlan);
    4244        1940 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4245        1940 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4246        1940 :     READ_UINT_FIELD(scan.scanrelid);
    4247        1940 :     READ_NODE_FIELD(tidrangequals);
    4248             : 
    4249        1940 :     READ_DONE();
    4250             : }
    4251             : 
    4252             : static SubqueryScan *
    4253       10892 : _readSubqueryScan(void)
    4254             : {
    4255       10892 :     READ_LOCALS(SubqueryScan);
    4256             : 
    4257       10892 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4258       10892 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4259       10892 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4260       10892 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4261       10892 :     READ_INT_FIELD(scan.plan.plan_width);
    4262       10892 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4263       10892 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4264       10892 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4265       10892 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4266       10892 :     READ_NODE_FIELD(scan.plan.targetlist);
    4267       10892 :     READ_NODE_FIELD(scan.plan.qual);
    4268       10892 :     READ_NODE_FIELD(scan.plan.lefttree);
    4269       10892 :     READ_NODE_FIELD(scan.plan.righttree);
    4270       10892 :     READ_NODE_FIELD(scan.plan.initPlan);
    4271       10892 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4272       10892 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4273       10892 :     READ_UINT_FIELD(scan.scanrelid);
    4274       10892 :     READ_NODE_FIELD(subplan);
    4275       10892 :     READ_ENUM_FIELD(scanstatus, SubqueryScanStatus);
    4276             : 
    4277       10892 :     READ_DONE();
    4278             : }
    4279             : 
    4280             : static FunctionScan *
    4281       51636 : _readFunctionScan(void)
    4282             : {
    4283       51636 :     READ_LOCALS(FunctionScan);
    4284             : 
    4285       51636 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4286       51636 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4287       51636 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4288       51636 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4289       51636 :     READ_INT_FIELD(scan.plan.plan_width);
    4290       51636 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4291       51636 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4292       51636 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4293       51636 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4294       51636 :     READ_NODE_FIELD(scan.plan.targetlist);
    4295       51636 :     READ_NODE_FIELD(scan.plan.qual);
    4296       51636 :     READ_NODE_FIELD(scan.plan.lefttree);
    4297       51636 :     READ_NODE_FIELD(scan.plan.righttree);
    4298       51636 :     READ_NODE_FIELD(scan.plan.initPlan);
    4299       51636 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4300       51636 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4301       51636 :     READ_UINT_FIELD(scan.scanrelid);
    4302       51636 :     READ_NODE_FIELD(functions);
    4303       51636 :     READ_BOOL_FIELD(funcordinality);
    4304             : 
    4305       51636 :     READ_DONE();
    4306             : }
    4307             : 
    4308             : static ValuesScan *
    4309        8256 : _readValuesScan(void)
    4310             : {
    4311        8256 :     READ_LOCALS(ValuesScan);
    4312             : 
    4313        8256 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4314        8256 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4315        8256 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4316        8256 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4317        8256 :     READ_INT_FIELD(scan.plan.plan_width);
    4318        8256 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4319        8256 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4320        8256 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4321        8256 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4322        8256 :     READ_NODE_FIELD(scan.plan.targetlist);
    4323        8256 :     READ_NODE_FIELD(scan.plan.qual);
    4324        8256 :     READ_NODE_FIELD(scan.plan.lefttree);
    4325        8256 :     READ_NODE_FIELD(scan.plan.righttree);
    4326        8256 :     READ_NODE_FIELD(scan.plan.initPlan);
    4327        8256 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4328        8256 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4329        8256 :     READ_UINT_FIELD(scan.scanrelid);
    4330        8256 :     READ_NODE_FIELD(values_lists);
    4331             : 
    4332        8256 :     READ_DONE();
    4333             : }
    4334             : 
    4335             : static TableFuncScan *
    4336         626 : _readTableFuncScan(void)
    4337             : {
    4338         626 :     READ_LOCALS(TableFuncScan);
    4339             : 
    4340         626 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4341         626 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4342         626 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4343         626 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4344         626 :     READ_INT_FIELD(scan.plan.plan_width);
    4345         626 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4346         626 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4347         626 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4348         626 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4349         626 :     READ_NODE_FIELD(scan.plan.targetlist);
    4350         626 :     READ_NODE_FIELD(scan.plan.qual);
    4351         626 :     READ_NODE_FIELD(scan.plan.lefttree);
    4352         626 :     READ_NODE_FIELD(scan.plan.righttree);
    4353         626 :     READ_NODE_FIELD(scan.plan.initPlan);
    4354         626 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4355         626 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4356         626 :     READ_UINT_FIELD(scan.scanrelid);
    4357         626 :     READ_NODE_FIELD(tablefunc);
    4358             : 
    4359         626 :     READ_DONE();
    4360             : }
    4361             : 
    4362             : static CteScan *
    4363        4146 : _readCteScan(void)
    4364             : {
    4365        4146 :     READ_LOCALS(CteScan);
    4366             : 
    4367        4146 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4368        4146 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4369        4146 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4370        4146 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4371        4146 :     READ_INT_FIELD(scan.plan.plan_width);
    4372        4146 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4373        4146 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4374        4146 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4375        4146 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4376        4146 :     READ_NODE_FIELD(scan.plan.targetlist);
    4377        4146 :     READ_NODE_FIELD(scan.plan.qual);
    4378        4146 :     READ_NODE_FIELD(scan.plan.lefttree);
    4379        4146 :     READ_NODE_FIELD(scan.plan.righttree);
    4380        4146 :     READ_NODE_FIELD(scan.plan.initPlan);
    4381        4146 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4382        4146 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4383        4146 :     READ_UINT_FIELD(scan.scanrelid);
    4384        4146 :     READ_INT_FIELD(ctePlanId);
    4385        4146 :     READ_INT_FIELD(cteParam);
    4386             : 
    4387        4146 :     READ_DONE();
    4388             : }
    4389             : 
    4390             : static NamedTuplestoreScan *
    4391         466 : _readNamedTuplestoreScan(void)
    4392             : {
    4393         466 :     READ_LOCALS(NamedTuplestoreScan);
    4394             : 
    4395         466 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4396         466 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4397         466 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4398         466 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4399         466 :     READ_INT_FIELD(scan.plan.plan_width);
    4400         466 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4401         466 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4402         466 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4403         466 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4404         466 :     READ_NODE_FIELD(scan.plan.targetlist);
    4405         466 :     READ_NODE_FIELD(scan.plan.qual);
    4406         466 :     READ_NODE_FIELD(scan.plan.lefttree);
    4407         466 :     READ_NODE_FIELD(scan.plan.righttree);
    4408         466 :     READ_NODE_FIELD(scan.plan.initPlan);
    4409         466 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4410         466 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4411         466 :     READ_UINT_FIELD(scan.scanrelid);
    4412         466 :     READ_STRING_FIELD(enrname);
    4413             : 
    4414         466 :     READ_DONE();
    4415             : }
    4416             : 
    4417             : static WorkTableScan *
    4418        1012 : _readWorkTableScan(void)
    4419             : {
    4420        1012 :     READ_LOCALS(WorkTableScan);
    4421             : 
    4422        1012 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4423        1012 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4424        1012 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4425        1012 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4426        1012 :     READ_INT_FIELD(scan.plan.plan_width);
    4427        1012 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4428        1012 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4429        1012 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4430        1012 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4431        1012 :     READ_NODE_FIELD(scan.plan.targetlist);
    4432        1012 :     READ_NODE_FIELD(scan.plan.qual);
    4433        1012 :     READ_NODE_FIELD(scan.plan.lefttree);
    4434        1012 :     READ_NODE_FIELD(scan.plan.righttree);
    4435        1012 :     READ_NODE_FIELD(scan.plan.initPlan);
    4436        1012 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4437        1012 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4438        1012 :     READ_UINT_FIELD(scan.scanrelid);
    4439        1012 :     READ_INT_FIELD(wtParam);
    4440             : 
    4441        1012 :     READ_DONE();
    4442             : }
    4443             : 
    4444             : static ForeignScan *
    4445        2004 : _readForeignScan(void)
    4446             : {
    4447        2004 :     READ_LOCALS(ForeignScan);
    4448             : 
    4449        2004 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4450        2004 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4451        2004 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4452        2004 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4453        2004 :     READ_INT_FIELD(scan.plan.plan_width);
    4454        2004 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4455        2004 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4456        2004 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4457        2004 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4458        2004 :     READ_NODE_FIELD(scan.plan.targetlist);
    4459        2004 :     READ_NODE_FIELD(scan.plan.qual);
    4460        2004 :     READ_NODE_FIELD(scan.plan.lefttree);
    4461        2004 :     READ_NODE_FIELD(scan.plan.righttree);
    4462        2004 :     READ_NODE_FIELD(scan.plan.initPlan);
    4463        2004 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4464        2004 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4465        2004 :     READ_UINT_FIELD(scan.scanrelid);
    4466        2004 :     READ_ENUM_FIELD(operation, CmdType);
    4467        2004 :     READ_UINT_FIELD(resultRelation);
    4468        2004 :     READ_OID_FIELD(checkAsUser);
    4469        2004 :     READ_OID_FIELD(fs_server);
    4470        2004 :     READ_NODE_FIELD(fdw_exprs);
    4471        2004 :     READ_NODE_FIELD(fdw_private);
    4472        2004 :     READ_NODE_FIELD(fdw_scan_tlist);
    4473        2004 :     READ_NODE_FIELD(fdw_recheck_quals);
    4474        2004 :     READ_BITMAPSET_FIELD(fs_relids);
    4475        2004 :     READ_BITMAPSET_FIELD(fs_base_relids);
    4476        2004 :     READ_BOOL_FIELD(fsSystemCol);
    4477             : 
    4478        2004 :     READ_DONE();
    4479             : }
    4480             : 
    4481             : static CustomScan *
    4482           0 : _readCustomScan(void)
    4483             : {
    4484           0 :     READ_LOCALS(CustomScan);
    4485             : 
    4486           0 :     READ_INT_FIELD(scan.plan.disabled_nodes);
    4487           0 :     READ_FLOAT_FIELD(scan.plan.startup_cost);
    4488           0 :     READ_FLOAT_FIELD(scan.plan.total_cost);
    4489           0 :     READ_FLOAT_FIELD(scan.plan.plan_rows);
    4490           0 :     READ_INT_FIELD(scan.plan.plan_width);
    4491           0 :     READ_BOOL_FIELD(scan.plan.parallel_aware);
    4492           0 :     READ_BOOL_FIELD(scan.plan.parallel_safe);
    4493           0 :     READ_BOOL_FIELD(scan.plan.async_capable);
    4494           0 :     READ_INT_FIELD(scan.plan.plan_node_id);
    4495           0 :     READ_NODE_FIELD(scan.plan.targetlist);
    4496           0 :     READ_NODE_FIELD(scan.plan.qual);
    4497           0 :     READ_NODE_FIELD(scan.plan.lefttree);
    4498           0 :     READ_NODE_FIELD(scan.plan.righttree);
    4499           0 :     READ_NODE_FIELD(scan.plan.initPlan);
    4500           0 :     READ_BITMAPSET_FIELD(scan.plan.extParam);
    4501           0 :     READ_BITMAPSET_FIELD(scan.plan.allParam);
    4502           0 :     READ_UINT_FIELD(scan.scanrelid);
    4503           0 :     READ_UINT_FIELD(flags);
    4504           0 :     READ_NODE_FIELD(custom_plans);
    4505           0 :     READ_NODE_FIELD(custom_exprs);
    4506           0 :     READ_NODE_FIELD(custom_private);
    4507           0 :     READ_NODE_FIELD(custom_scan_tlist);
    4508           0 :     READ_BITMAPSET_FIELD(custom_relids);
    4509             : 
    4510             :     {
    4511             :         /* Lookup CustomScanMethods by CustomName */
    4512             :         char       *custom_name;
    4513             :         const CustomScanMethods *methods;
    4514           0 :         token = pg_strtok(&length); /* skip methods: */
    4515           0 :         token = pg_strtok(&length); /* CustomName */
    4516           0 :         custom_name = nullable_string(token, length);
    4517           0 :         methods = GetCustomScanMethods(custom_name, false);
    4518           0 :         local_node->methods = methods;
    4519             :     }
    4520             : 
    4521           0 :     READ_DONE();
    4522             : }
    4523             : 
    4524             : static NestLoop *
    4525       94082 : _readNestLoop(void)
    4526             : {
    4527       94082 :     READ_LOCALS(NestLoop);
    4528             : 
    4529       94082 :     READ_INT_FIELD(join.plan.disabled_nodes);
    4530       94082 :     READ_FLOAT_FIELD(join.plan.startup_cost);
    4531       94082 :     READ_FLOAT_FIELD(join.plan.total_cost);
    4532       94082 :     READ_FLOAT_FIELD(join.plan.plan_rows);
    4533       94082 :     READ_INT_FIELD(join.plan.plan_width);
    4534       94082 :     READ_BOOL_FIELD(join.plan.parallel_aware);
    4535       94082 :     READ_BOOL_FIELD(join.plan.parallel_safe);
    4536       94082 :     READ_BOOL_FIELD(join.plan.async_capable);
    4537       94082 :     READ_INT_FIELD(join.plan.plan_node_id);
    4538       94082 :     READ_NODE_FIELD(join.plan.targetlist);
    4539       94082 :     READ_NODE_FIELD(join.plan.qual);
    4540       94082 :     READ_NODE_FIELD(join.plan.lefttree);
    4541       94082 :     READ_NODE_FIELD(join.plan.righttree);
    4542       94082 :     READ_NODE_FIELD(join.plan.initPlan);
    4543       94082 :     READ_BITMAPSET_FIELD(join.plan.extParam);
    4544       94082 :     READ_BITMAPSET_FIELD(join.plan.allParam);
    4545       94082 :     READ_ENUM_FIELD(join.jointype, JoinType);
    4546       94082 :     READ_BOOL_FIELD(join.inner_unique);
    4547       94082 :     READ_NODE_FIELD(join.joinqual);
    4548       94082 :     READ_NODE_FIELD(nestParams);
    4549             : 
    4550       94082 :     READ_DONE();
    4551             : }
    4552             : 
    4553             : static NestLoopParam *
    4554       52610 : _readNestLoopParam(void)
    4555             : {
    4556       52610 :     READ_LOCALS(NestLoopParam);
    4557             : 
    4558       52610 :     READ_INT_FIELD(paramno);
    4559       52610 :     READ_NODE_FIELD(paramval);
    4560             : 
    4561       52610 :     READ_DONE();
    4562             : }
    4563             : 
    4564             : static MergeJoin *
    4565        8172 : _readMergeJoin(void)
    4566             : {
    4567        8172 :     READ_LOCALS(MergeJoin);
    4568             : 
    4569        8172 :     READ_INT_FIELD(join.plan.disabled_nodes);
    4570        8172 :     READ_FLOAT_FIELD(join.plan.startup_cost);
    4571        8172 :     READ_FLOAT_FIELD(join.plan.total_cost);
    4572        8172 :     READ_FLOAT_FIELD(join.plan.plan_rows);
    4573        8172 :     READ_INT_FIELD(join.plan.plan_width);
    4574        8172 :     READ_BOOL_FIELD(join.plan.parallel_aware);
    4575        8172 :     READ_BOOL_FIELD(join.plan.parallel_safe);
    4576        8172 :     READ_BOOL_FIELD(join.plan.async_capable);
    4577        8172 :     READ_INT_FIELD(join.plan.plan_node_id);
    4578        8172 :     READ_NODE_FIELD(join.plan.targetlist);
    4579        8172 :     READ_NODE_FIELD(join.plan.qual);
    4580        8172 :     READ_NODE_FIELD(join.plan.lefttree);
    4581        8172 :     READ_NODE_FIELD(join.plan.righttree);
    4582        8172 :     READ_NODE_FIELD(join.plan.initPlan);
    4583        8172 :     READ_BITMAPSET_FIELD(join.plan.extParam);
    4584        8172 :     READ_BITMAPSET_FIELD(join.plan.allParam);
    4585        8172 :     READ_ENUM_FIELD(join.jointype, JoinType);
    4586        8172 :     READ_BOOL_FIELD(join.inner_unique);
    4587        8172 :     READ_NODE_FIELD(join.joinqual);
    4588        8172 :     READ_BOOL_FIELD(skip_mark_restore);
    4589        8172 :     READ_NODE_FIELD(mergeclauses);
    4590        8172 :     READ_OID_ARRAY(mergeFamilies, list_length(local_node->mergeclauses));
    4591        8172 :     READ_OID_ARRAY(mergeCollations, list_length(local_node->mergeclauses));
    4592        8172 :     READ_BOOL_ARRAY(mergeReversals, list_length(local_node->mergeclauses));
    4593        8172 :     READ_BOOL_ARRAY(mergeNullsFirst, list_length(local_node->mergeclauses));
    4594             : 
    4595        8172 :     READ_DONE();
    4596             : }
    4597             : 
    4598             : static HashJoin *
    4599       34198 : _readHashJoin(void)
    4600             : {
    4601       34198 :     READ_LOCALS(HashJoin);
    4602             : 
    4603       34198 :     READ_INT_FIELD(join.plan.disabled_nodes);
    4604       34198 :     READ_FLOAT_FIELD(join.plan.startup_cost);
    4605       34198 :     READ_FLOAT_FIELD(join.plan.total_cost);
    4606       34198 :     READ_FLOAT_FIELD(join.plan.plan_rows);
    4607       34198 :     READ_INT_FIELD(join.plan.plan_width);
    4608       34198 :     READ_BOOL_FIELD(join.plan.parallel_aware);
    4609       34198 :     READ_BOOL_FIELD(join.plan.parallel_safe);
    4610       34198 :     READ_BOOL_FIELD(join.plan.async_capable);
    4611       34198 :     READ_INT_FIELD(join.plan.plan_node_id);
    4612       34198 :     READ_NODE_FIELD(join.plan.targetlist);
    4613       34198 :     READ_NODE_FIELD(join.plan.qual);
    4614       34198 :     READ_NODE_FIELD(join.plan.lefttree);
    4615       34198 :     READ_NODE_FIELD(join.plan.righttree);
    4616       34198 :     READ_NODE_FIELD(join.plan.initPlan);
    4617       34198 :     READ_BITMAPSET_FIELD(join.plan.extParam);
    4618       34198 :     READ_BITMAPSET_FIELD(join.plan.allParam);
    4619       34198 :     READ_ENUM_FIELD(join.jointype, JoinType);
    4620       34198 :     READ_BOOL_FIELD(join.inner_unique);
    4621       34198 :     READ_NODE_FIELD(join.joinqual);
    4622       34198 :     READ_NODE_FIELD(hashclauses);
    4623       34198 :     READ_NODE_FIELD(hashoperators);
    4624       34198 :     READ_NODE_FIELD(hashcollations);
    4625       34198 :     READ_NODE_FIELD(hashkeys);
    4626             : 
    4627       34198 :     READ_DONE();
    4628             : }
    4629             : 
    4630             : static Material *
    4631        4538 : _readMaterial(void)
    4632             : {
    4633        4538 :     READ_LOCALS(Material);
    4634             : 
    4635        4538 :     READ_INT_FIELD(plan.disabled_nodes);
    4636        4538 :     READ_FLOAT_FIELD(plan.startup_cost);
    4637        4538 :     READ_FLOAT_FIELD(plan.total_cost);
    4638        4538 :     READ_FLOAT_FIELD(plan.plan_rows);
    4639        4538 :     READ_INT_FIELD(plan.plan_width);
    4640        4538 :     READ_BOOL_FIELD(plan.parallel_aware);
    4641        4538 :     READ_BOOL_FIELD(plan.parallel_safe);
    4642        4538 :     READ_BOOL_FIELD(plan.async_capable);
    4643        4538 :     READ_INT_FIELD(plan.plan_node_id);
    4644        4538 :     READ_NODE_FIELD(plan.targetlist);
    4645        4538 :     READ_NODE_FIELD(plan.qual);
    4646        4538 :     READ_NODE_FIELD(plan.lefttree);
    4647        4538 :     READ_NODE_FIELD(plan.righttree);
    4648        4538 :     READ_NODE_FIELD(plan.initPlan);
    4649        4538 :     READ_BITMAPSET_FIELD(plan.extParam);
    4650        4538 :     READ_BITMAPSET_FIELD(plan.allParam);
    4651             : 
    4652        4538 :     READ_DONE();
    4653             : }
    4654             : 
    4655             : static Memoize *
    4656        1936 : _readMemoize(void)
    4657             : {
    4658        1936 :     READ_LOCALS(Memoize);
    4659             : 
    4660        1936 :     READ_INT_FIELD(plan.disabled_nodes);
    4661        1936 :     READ_FLOAT_FIELD(plan.startup_cost);
    4662        1936 :     READ_FLOAT_FIELD(plan.total_cost);
    4663        1936 :     READ_FLOAT_FIELD(plan.plan_rows);
    4664        1936 :     READ_INT_FIELD(plan.plan_width);
    4665        1936 :     READ_BOOL_FIELD(plan.parallel_aware);
    4666        1936 :     READ_BOOL_FIELD(plan.parallel_safe);
    4667        1936 :     READ_BOOL_FIELD(plan.async_capable);
    4668        1936 :     READ_INT_FIELD(plan.plan_node_id);
    4669        1936 :     READ_NODE_FIELD(plan.targetlist);
    4670        1936 :     READ_NODE_FIELD(plan.qual);
    4671        1936 :     READ_NODE_FIELD(plan.lefttree);
    4672        1936 :     READ_NODE_FIELD(plan.righttree);
    4673        1936 :     READ_NODE_FIELD(plan.initPlan);
    4674        1936 :     READ_BITMAPSET_FIELD(plan.extParam);
    4675        1936 :     READ_BITMAPSET_FIELD(plan.allParam);
    4676        1936 :     READ_INT_FIELD(numKeys);
    4677        1936 :     READ_OID_ARRAY(hashOperators, local_node->numKeys);
    4678        1936 :     READ_OID_ARRAY(collations, local_node->numKeys);
    4679        1936 :     READ_NODE_FIELD(param_exprs);
    4680        1936 :     READ_BOOL_FIELD(singlerow);
    4681        1936 :     READ_BOOL_FIELD(binary_mode);
    4682        1936 :     READ_UINT_FIELD(est_entries);
    4683        1936 :     READ_BITMAPSET_FIELD(keyparamids);
    4684             : 
    4685        1936 :     READ_DONE();
    4686             : }
    4687             : 
    4688             : static Sort *
    4689       81840 : _readSort(void)
    4690             : {
    4691       81840 :     READ_LOCALS(Sort);
    4692             : 
    4693       81840 :     READ_INT_FIELD(plan.disabled_nodes);
    4694       81840 :     READ_FLOAT_FIELD(plan.startup_cost);
    4695       81840 :     READ_FLOAT_FIELD(plan.total_cost);
    4696       81840 :     READ_FLOAT_FIELD(plan.plan_rows);
    4697       81840 :     READ_INT_FIELD(plan.plan_width);
    4698       81840 :     READ_BOOL_FIELD(plan.parallel_aware);
    4699       81840 :     READ_BOOL_FIELD(plan.parallel_safe);
    4700       81840 :     READ_BOOL_FIELD(plan.async_capable);
    4701       81840 :     READ_INT_FIELD(plan.plan_node_id);
    4702       81840 :     READ_NODE_FIELD(plan.targetlist);
    4703       81840 :     READ_NODE_FIELD(plan.qual);
    4704       81840 :     READ_NODE_FIELD(plan.lefttree);
    4705       81840 :     READ_NODE_FIELD(plan.righttree);
    4706       81840 :     READ_NODE_FIELD(plan.initPlan);
    4707       81840 :     READ_BITMAPSET_FIELD(plan.extParam);
    4708       81840 :     READ_BITMAPSET_FIELD(plan.allParam);
    4709       81840 :     READ_INT_FIELD(numCols);
    4710       81840 :     READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
    4711       81840 :     READ_OID_ARRAY(sortOperators, local_node->numCols);
    4712       81840 :     READ_OID_ARRAY(collations, local_node->numCols);
    4713       81840 :     READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
    4714             : 
    4715       81840 :     READ_DONE();
    4716             : }
    4717             : 
    4718             : static IncrementalSort *
    4719        1010 : _readIncrementalSort(void)
    4720             : {
    4721        1010 :     READ_LOCALS(IncrementalSort);
    4722             : 
    4723        1010 :     READ_INT_FIELD(sort.plan.disabled_nodes);
    4724        1010 :     READ_FLOAT_FIELD(sort.plan.startup_cost);
    4725        1010 :     READ_FLOAT_FIELD(sort.plan.total_cost);
    4726        1010 :     READ_FLOAT_FIELD(sort.plan.plan_rows);
    4727        1010 :     READ_INT_FIELD(sort.plan.plan_width);
    4728        1010 :     READ_BOOL_FIELD(sort.plan.parallel_aware);
    4729        1010 :     READ_BOOL_FIELD(sort.plan.parallel_safe);
    4730        1010 :     READ_BOOL_FIELD(sort.plan.async_capable);
    4731        1010 :     READ_INT_FIELD(sort.plan.plan_node_id);
    4732        1010 :     READ_NODE_FIELD(sort.plan.targetlist);
    4733        1010 :     READ_NODE_FIELD(sort.plan.qual);
    4734        1010 :     READ_NODE_FIELD(sort.plan.lefttree);
    4735        1010 :     READ_NODE_FIELD(sort.plan.righttree);
    4736        1010 :     READ_NODE_FIELD(sort.plan.initPlan);
    4737        1010 :     READ_BITMAPSET_FIELD(sort.plan.extParam);
    4738        1010 :     READ_BITMAPSET_FIELD(sort.plan.allParam);
    4739        1010 :     READ_INT_FIELD(sort.numCols);
    4740        1010 :     READ_ATTRNUMBER_ARRAY(sort.sortColIdx, local_node->sort.numCols);
    4741        1010 :     READ_OID_ARRAY(sort.sortOperators, local_node->sort.numCols);
    4742        1010 :     READ_OID_ARRAY(sort.collations, local_node->sort.numCols);
    4743        1010 :     READ_BOOL_ARRAY(sort.nullsFirst, local_node->sort.numCols);
    4744        1010 :     READ_INT_FIELD(nPresortedCols);
    4745             : 
    4746        1010 :     READ_DONE();
    4747             : }
    4748             : 
    4749             : static Group *
    4750         246 : _readGroup(void)
    4751             : {
    4752         246 :     READ_LOCALS(Group);
    4753             : 
    4754         246 :     READ_INT_FIELD(plan.disabled_nodes);
    4755         246 :     READ_FLOAT_FIELD(plan.startup_cost);
    4756         246 :     READ_FLOAT_FIELD(plan.total_cost);
    4757         246 :     READ_FLOAT_FIELD(plan.plan_rows);
    4758         246 :     READ_INT_FIELD(plan.plan_width);
    4759         246 :     READ_BOOL_FIELD(plan.parallel_aware);
    4760         246 :     READ_BOOL_FIELD(plan.parallel_safe);
    4761         246 :     READ_BOOL_FIELD(plan.async_capable);
    4762         246 :     READ_INT_FIELD(plan.plan_node_id);
    4763         246 :     READ_NODE_FIELD(plan.targetlist);
    4764         246 :     READ_NODE_FIELD(plan.qual);
    4765         246 :     READ_NODE_FIELD(plan.lefttree);
    4766         246 :     READ_NODE_FIELD(plan.righttree);
    4767         246 :     READ_NODE_FIELD(plan.initPlan);
    4768         246 :     READ_BITMAPSET_FIELD(plan.extParam);
    4769         246 :     READ_BITMAPSET_FIELD(plan.allParam);
    4770         246 :     READ_INT_FIELD(numCols);
    4771         246 :     READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
    4772         246 :     READ_OID_ARRAY(grpOperators, local_node->numCols);
    4773         246 :     READ_OID_ARRAY(grpCollations, local_node->numCols);
    4774             : 
    4775         246 :     READ_DONE();
    4776             : }
    4777             : 
    4778             : static Agg *
    4779       44190 : _readAgg(void)
    4780             : {
    4781       44190 :     READ_LOCALS(Agg);
    4782             : 
    4783       44190 :     READ_INT_FIELD(plan.disabled_nodes);
    4784       44190 :     READ_FLOAT_FIELD(plan.startup_cost);
    4785       44190 :     READ_FLOAT_FIELD(plan.total_cost);
    4786       44190 :     READ_FLOAT_FIELD(plan.plan_rows);
    4787       44190 :     READ_INT_FIELD(plan.plan_width);
    4788       44190 :     READ_BOOL_FIELD(plan.parallel_aware);
    4789       44190 :     READ_BOOL_FIELD(plan.parallel_safe);
    4790       44190 :     READ_BOOL_FIELD(plan.async_capable);
    4791       44190 :     READ_INT_FIELD(plan.plan_node_id);
    4792       44190 :     READ_NODE_FIELD(plan.targetlist);
    4793       44190 :     READ_NODE_FIELD(plan.qual);
    4794       44190 :     READ_NODE_FIELD(plan.lefttree);
    4795       44190 :     READ_NODE_FIELD(plan.righttree);
    4796       44190 :     READ_NODE_FIELD(plan.initPlan);
    4797       44190 :     READ_BITMAPSET_FIELD(plan.extParam);
    4798       44190 :     READ_BITMAPSET_FIELD(plan.allParam);
    4799       44190 :     READ_ENUM_FIELD(aggstrategy, AggStrategy);
    4800       44190 :     READ_ENUM_FIELD(aggsplit, AggSplit);
    4801       44190 :     READ_INT_FIELD(numCols);
    4802       44190 :     READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
    4803       44190 :     READ_OID_ARRAY(grpOperators, local_node->numCols);
    4804       44190 :     READ_OID_ARRAY(grpCollations, local_node->numCols);
    4805       44190 :     READ_LONG_FIELD(numGroups);
    4806       44190 :     READ_UINT64_FIELD(transitionSpace);
    4807       44190 :     READ_BITMAPSET_FIELD(aggParams);
    4808       44190 :     READ_NODE_FIELD(groupingSets);
    4809       44190 :     READ_NODE_FIELD(chain);
    4810             : 
    4811       44190 :     READ_DONE();
    4812             : }
    4813             : 
    4814             : static WindowAgg *
    4815        2546 : _readWindowAgg(void)
    4816             : {
    4817        2546 :     READ_LOCALS(WindowAgg);
    4818             : 
    4819        2546 :     READ_INT_FIELD(plan.disabled_nodes);
    4820        2546 :     READ_FLOAT_FIELD(plan.startup_cost);
    4821        2546 :     READ_FLOAT_FIELD(plan.total_cost);
    4822        2546 :     READ_FLOAT_FIELD(plan.plan_rows);
    4823        2546 :     READ_INT_FIELD(plan.plan_width);
    4824        2546 :     READ_BOOL_FIELD(plan.parallel_aware);
    4825        2546 :     READ_BOOL_FIELD(plan.parallel_safe);
    4826        2546 :     READ_BOOL_FIELD(plan.async_capable);
    4827        2546 :     READ_INT_FIELD(plan.plan_node_id);
    4828        2546 :     READ_NODE_FIELD(plan.targetlist);
    4829        2546 :     READ_NODE_FIELD(plan.qual);
    4830        2546 :     READ_NODE_FIELD(plan.lefttree);
    4831        2546 :     READ_NODE_FIELD(plan.righttree);
    4832        2546 :     READ_NODE_FIELD(plan.initPlan);
    4833        2546 :     READ_BITMAPSET_FIELD(plan.extParam);
    4834        2546 :     READ_BITMAPSET_FIELD(plan.allParam);
    4835        2546 :     READ_STRING_FIELD(winname);
    4836        2546 :     READ_UINT_FIELD(winref);
    4837        2546 :     READ_INT_FIELD(partNumCols);
    4838        2546 :     READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
    4839        2546 :     READ_OID_ARRAY(partOperators, local_node->partNumCols);
    4840        2546 :     READ_OID_ARRAY(partCollations, local_node->partNumCols);
    4841        2546 :     READ_INT_FIELD(ordNumCols);
    4842        2546 :     READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
    4843        2546 :     READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
    4844        2546 :     READ_OID_ARRAY(ordCollations, local_node->ordNumCols);
    4845        2546 :     READ_INT_FIELD(frameOptions);
    4846        2546 :     READ_NODE_FIELD(startOffset);
    4847        2546 :     READ_NODE_FIELD(endOffset);
    4848        2546 :     READ_NODE_FIELD(runCondition);
    4849        2546 :     READ_NODE_FIELD(runConditionOrig);
    4850        2546 :     READ_OID_FIELD(startInRangeFunc);
    4851        2546 :     READ_OID_FIELD(endInRangeFunc);
    4852        2546 :     READ_OID_FIELD(inRangeColl);
    4853        2546 :     READ_BOOL_FIELD(inRangeAsc);
    4854        2546 :     READ_BOOL_FIELD(inRangeNullsFirst);
    4855        2546 :     READ_BOOL_FIELD(topWindow);
    4856             : 
    4857        2546 :     READ_DONE();
    4858             : }
    4859             : 
    4860             : static Unique *
    4861        5512 : _readUnique(void)
    4862             : {
    4863        5512 :     READ_LOCALS(Unique);
    4864             : 
    4865        5512 :     READ_INT_FIELD(plan.disabled_nodes);
    4866        5512 :     READ_FLOAT_FIELD(plan.startup_cost);
    4867        5512 :     READ_FLOAT_FIELD(plan.total_cost);
    4868        5512 :     READ_FLOAT_FIELD(plan.plan_rows);
    4869        5512 :     READ_INT_FIELD(plan.plan_width);
    4870        5512 :     READ_BOOL_FIELD(plan.parallel_aware);
    4871        5512 :     READ_BOOL_FIELD(plan.parallel_safe);
    4872        5512 :     READ_BOOL_FIELD(plan.async_capable);
    4873        5512 :     READ_INT_FIELD(plan.plan_node_id);
    4874        5512 :     READ_NODE_FIELD(plan.targetlist);
    4875        5512 :     READ_NODE_FIELD(plan.qual);
    4876        5512 :     READ_NODE_FIELD(plan.lefttree);
    4877        5512 :     READ_NODE_FIELD(plan.righttree);
    4878        5512 :     READ_NODE_FIELD(plan.initPlan);
    4879        5512 :     READ_BITMAPSET_FIELD(plan.extParam);
    4880        5512 :     READ_BITMAPSET_FIELD(plan.allParam);
    4881        5512 :     READ_INT_FIELD(numCols);
    4882        5512 :     READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
    4883        5512 :     READ_OID_ARRAY(uniqOperators, local_node->numCols);
    4884        5512 :     READ_OID_ARRAY(uniqCollations, local_node->numCols);
    4885             : 
    4886        5512 :     READ_DONE();
    4887             : }
    4888             : 
    4889             : static Gather *
    4890        1078 : _readGather(void)
    4891             : {
    4892        1078 :     READ_LOCALS(Gather);
    4893             : 
    4894        1078 :     READ_INT_FIELD(plan.disabled_nodes);
    4895        1078 :     READ_FLOAT_FIELD(plan.startup_cost);
    4896        1078 :     READ_FLOAT_FIELD(plan.total_cost);
    4897        1078 :     READ_FLOAT_FIELD(plan.plan_rows);
    4898        1078 :     READ_INT_FIELD(plan.plan_width);
    4899        1078 :     READ_BOOL_FIELD(plan.parallel_aware);
    4900        1078 :     READ_BOOL_FIELD(plan.parallel_safe);
    4901        1078 :     READ_BOOL_FIELD(plan.async_capable);
    4902        1078 :     READ_INT_FIELD(plan.plan_node_id);
    4903        1078 :     READ_NODE_FIELD(plan.targetlist);
    4904        1078 :     READ_NODE_FIELD(plan.qual);
    4905        1078 :     READ_NODE_FIELD(plan.lefttree);
    4906        1078 :     READ_NODE_FIELD(plan.righttree);
    4907        1078 :     READ_NODE_FIELD(plan.initPlan);
    4908        1078 :     READ_BITMAPSET_FIELD(plan.extParam);
    4909        1078 :     READ_BITMAPSET_FIELD(plan.allParam);
    4910        1078 :     READ_INT_FIELD(num_workers);
    4911        1078 :     READ_INT_FIELD(rescan_param);
    4912        1078 :     READ_BOOL_FIELD(single_copy);
    4913        1078 :     READ_BOOL_FIELD(invisible);
    4914        1078 :     READ_BITMAPSET_FIELD(initParam);
    4915             : 
    4916        1078 :     READ_DONE();
    4917             : }
    4918             : 
    4919             : static GatherMerge *
    4920         330 : _readGatherMerge(void)
    4921             : {
    4922         330 :     READ_LOCALS(GatherMerge);
    4923             : 
    4924         330 :     READ_INT_FIELD(plan.disabled_nodes);
    4925         330 :     READ_FLOAT_FIELD(plan.startup_cost);
    4926         330 :     READ_FLOAT_FIELD(plan.total_cost);
    4927         330 :     READ_FLOAT_FIELD(plan.plan_rows);
    4928         330 :     READ_INT_FIELD(plan.plan_width);
    4929         330 :     READ_BOOL_FIELD(plan.parallel_aware);
    4930         330 :     READ_BOOL_FIELD(plan.parallel_safe);
    4931         330 :     READ_BOOL_FIELD(plan.async_capable);
    4932         330 :     READ_INT_FIELD(plan.plan_node_id);
    4933         330 :     READ_NODE_FIELD(plan.targetlist);
    4934         330 :     READ_NODE_FIELD(plan.qual);
    4935         330 :     READ_NODE_FIELD(plan.lefttree);
    4936         330 :     READ_NODE_FIELD(plan.righttree);
    4937         330 :     READ_NODE_FIELD(plan.initPlan);
    4938         330 :     READ_BITMAPSET_FIELD(plan.extParam);
    4939         330 :     READ_BITMAPSET_FIELD(plan.allParam);
    4940         330 :     READ_INT_FIELD(num_workers);
    4941         330 :     READ_INT_FIELD(rescan_param);
    4942         330 :     READ_INT_FIELD(numCols);
    4943         330 :     READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
    4944         330 :     READ_OID_ARRAY(sortOperators, local_node->numCols);
    4945         330 :     READ_OID_ARRAY(collations, local_node->numCols);
    4946         330 :     READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
    4947         330 :     READ_BITMAPSET_FIELD(initParam);
    4948             : 
    4949         330 :     READ_DONE();
    4950             : }
    4951             : 
    4952             : static Hash *
    4953       34198 : _readHash(void)
    4954             : {
    4955       34198 :     READ_LOCALS(Hash);
    4956             : 
    4957       34198 :     READ_INT_FIELD(plan.disabled_nodes);
    4958       34198 :     READ_FLOAT_FIELD(plan.startup_cost);
    4959       34198 :     READ_FLOAT_FIELD(plan.total_cost);
    4960       34198 :     READ_FLOAT_FIELD(plan.plan_rows);
    4961       34198 :     READ_INT_FIELD(plan.plan_width);
    4962       34198 :     READ_BOOL_FIELD(plan.parallel_aware);
    4963       34198 :     READ_BOOL_FIELD(plan.parallel_safe);
    4964       34198 :     READ_BOOL_FIELD(plan.async_capable);
    4965       34198 :     READ_INT_FIELD(plan.plan_node_id);
    4966       34198 :     READ_NODE_FIELD(plan.targetlist);
    4967       34198 :     READ_NODE_FIELD(plan.qual);
    4968       34198 :     READ_NODE_FIELD(plan.lefttree);
    4969       34198 :     READ_NODE_FIELD(plan.righttree);
    4970       34198 :     READ_NODE_FIELD(plan.initPlan);
    4971       34198 :     READ_BITMAPSET_FIELD(plan.extParam);
    4972       34198 :     READ_BITMAPSET_FIELD(plan.allParam);
    4973       34198 :     READ_NODE_FIELD(hashkeys);
    4974       34198 :     READ_OID_FIELD(skewTable);
    4975       34198 :     READ_INT_FIELD(skewColumn);
    4976       34198 :     READ_BOOL_FIELD(skewInherit);
    4977       34198 :     READ_FLOAT_FIELD(rows_total);
    4978             : 
    4979       34198 :     READ_DONE();
    4980             : }
    4981             : 
    4982             : static SetOp *
    4983         662 : _readSetOp(void)
    4984             : {
    4985         662 :     READ_LOCALS(SetOp);
    4986             : 
    4987         662 :     READ_INT_FIELD(plan.disabled_nodes);
    4988         662 :     READ_FLOAT_FIELD(plan.startup_cost);
    4989         662 :     READ_FLOAT_FIELD(plan.total_cost);
    4990         662 :     READ_FLOAT_FIELD(plan.plan_rows);
    4991         662 :     READ_INT_FIELD(plan.plan_width);
    4992         662 :     READ_BOOL_FIELD(plan.parallel_aware);
    4993         662 :     READ_BOOL_FIELD(plan.parallel_safe);
    4994         662 :     READ_BOOL_FIELD(plan.async_capable);
    4995         662 :     READ_INT_FIELD(plan.plan_node_id);
    4996         662 :     READ_NODE_FIELD(plan.targetlist);
    4997         662 :     READ_NODE_FIELD(plan.qual);
    4998         662 :     READ_NODE_FIELD(plan.lefttree);
    4999         662 :     READ_NODE_FIELD(plan.righttree);
    5000         662 :     READ_NODE_FIELD(plan.initPlan);
    5001         662 :     READ_BITMAPSET_FIELD(plan.extParam);
    5002         662 :     READ_BITMAPSET_FIELD(plan.allParam);
    5003         662 :     READ_ENUM_FIELD(cmd, SetOpCmd);
    5004         662 :     READ_ENUM_FIELD(strategy, SetOpStrategy);
    5005         662 :     READ_INT_FIELD(numCols);
    5006         662 :     READ_ATTRNUMBER_ARRAY(cmpColIdx, local_node->numCols);
    5007         662 :     READ_OID_ARRAY(cmpOperators, local_node->numCols);
    5008         662 :     READ_OID_ARRAY(cmpCollations, local_node->numCols);
    5009         662 :     READ_BOOL_ARRAY(cmpNullsFirst, local_node->numCols);
    5010         662 :     READ_LONG_FIELD(numGroups);
    5011             : 
    5012         662 :     READ_DONE();
    5013             : }
    5014             : 
    5015             : static LockRows *
    5016        7734 : _readLockRows(void)
    5017             : {
    5018        7734 :     READ_LOCALS(LockRows);
    5019             : 
    5020        7734 :     READ_INT_FIELD(plan.disabled_nodes);
    5021        7734 :     READ_FLOAT_FIELD(plan.startup_cost);
    5022        7734 :     READ_FLOAT_FIELD(plan.total_cost);
    5023        7734 :     READ_FLOAT_FIELD(plan.plan_rows);
    5024        7734 :     READ_INT_FIELD(plan.plan_width);
    5025        7734 :     READ_BOOL_FIELD(plan.parallel_aware);
    5026        7734 :     READ_BOOL_FIELD(plan.parallel_safe);
    5027        7734 :     READ_BOOL_FIELD(plan.async_capable);
    5028        7734 :     READ_INT_FIELD(plan.plan_node_id);
    5029        7734 :     READ_NODE_FIELD(plan.targetlist);
    5030        7734 :     READ_NODE_FIELD(plan.qual);
    5031        7734 :     READ_NODE_FIELD(plan.lefttree);
    5032        7734 :     READ_NODE_FIELD(plan.righttree);
    5033        7734 :     READ_NODE_FIELD(plan.initPlan);
    5034        7734 :     READ_BITMAPSET_FIELD(plan.extParam);
    5035        7734 :     READ_BITMAPSET_FIELD(plan.allParam);
    5036        7734 :     READ_NODE_FIELD(rowMarks);
    5037        7734 :     READ_INT_FIELD(epqParam);
    5038             : 
    5039        7734 :     READ_DONE();
    5040             : }
    5041             : 
    5042             : static Limit *
    5043        4818 : _readLimit(void)
    5044             : {
    5045        4818 :     READ_LOCALS(Limit);
    5046             : 
    5047        4818 :     READ_INT_FIELD(plan.disabled_nodes);
    5048        4818 :     READ_FLOAT_FIELD(plan.startup_cost);
    5049        4818 :     READ_FLOAT_FIELD(plan.total_cost);
    5050        4818 :     READ_FLOAT_FIELD(plan.plan_rows);
    5051        4818 :     READ_INT_FIELD(plan.plan_width);
    5052        4818 :     READ_BOOL_FIELD(plan.parallel_aware);
    5053        4818 :     READ_BOOL_FIELD(plan.parallel_safe);
    5054        4818 :     READ_BOOL_FIELD(plan.async_capable);
    5055        4818 :     READ_INT_FIELD(plan.plan_node_id);
    5056        4818 :     READ_NODE_FIELD(plan.targetlist);
    5057        4818 :     READ_NODE_FIELD(plan.qual);
    5058        4818 :     READ_NODE_FIELD(plan.lefttree);
    5059        4818 :     READ_NODE_FIELD(plan.righttree);
    5060        4818 :     READ_NODE_FIELD(plan.initPlan);
    5061        4818 :     READ_BITMAPSET_FIELD(plan.extParam);
    5062        4818 :     READ_BITMAPSET_FIELD(plan.allParam);
    5063        4818 :     READ_NODE_FIELD(limitOffset);
    5064        4818 :     READ_NODE_FIELD(limitCount);
    5065        4818 :     READ_ENUM_FIELD(limitOption, LimitOption);
    5066        4818 :     READ_INT_FIELD(uniqNumCols);
    5067        4818 :     READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->uniqNumCols);
    5068        4818 :     READ_OID_ARRAY(uniqOperators, local_node->uniqNumCols);
    5069        4818 :     READ_OID_ARRAY(uniqCollations, local_node->uniqNumCols);
    5070             : 
    5071        4818 :     READ_DONE();
    5072             : }
    5073             : 
    5074             : static PlanRowMark *
    5075       25984 : _readPlanRowMark(void)
    5076             : {
    5077       25984 :     READ_LOCALS(PlanRowMark);
    5078             : 
    5079       25984 :     READ_UINT_FIELD(rti);
    5080       25984 :     READ_UINT_FIELD(prti);
    5081       25984 :     READ_UINT_FIELD(rowmarkId);
    5082       25984 :     READ_ENUM_FIELD(markType, RowMarkType);
    5083       25984 :     READ_INT_FIELD(allMarkTypes);
    5084       25984 :     READ_ENUM_FIELD(strength, LockClauseStrength);
    5085       25984 :     READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
    5086       25984 :     READ_BOOL_FIELD(isParent);
    5087             : 
    5088       25984 :     READ_DONE();
    5089             : }
    5090             : 
    5091             : static PartitionPruneInfo *
    5092         680 : _readPartitionPruneInfo(void)
    5093             : {
    5094         680 :     READ_LOCALS(PartitionPruneInfo);
    5095             : 
    5096         680 :     READ_BITMAPSET_FIELD(relids);
    5097         680 :     READ_NODE_FIELD(prune_infos);
    5098         680 :     READ_BITMAPSET_FIELD(other_subplans);
    5099             : 
    5100         680 :     READ_DONE();
    5101             : }
    5102             : 
    5103             : static PartitionedRelPruneInfo *
    5104        1370 : _readPartitionedRelPruneInfo(void)
    5105             : {
    5106        1370 :     READ_LOCALS(PartitionedRelPruneInfo);
    5107             : 
    5108        1370 :     READ_UINT_FIELD(rtindex);
    5109        1370 :     READ_BITMAPSET_FIELD(present_parts);
    5110        1370 :     READ_INT_FIELD(nparts);
    5111        1370 :     READ_INT_ARRAY(subplan_map, local_node->nparts);
    5112        1370 :     READ_INT_ARRAY(subpart_map, local_node->nparts);
    5113        1370 :     READ_INT_ARRAY(leafpart_rti_map, local_node->nparts);
    5114        1370 :     READ_OID_ARRAY(relid_map, local_node->nparts);
    5115        1370 :     READ_NODE_FIELD(initial_pruning_steps);
    5116        1370 :     READ_NODE_FIELD(exec_pruning_steps);
    5117        1370 :     READ_BITMAPSET_FIELD(execparamids);
    5118             : 
    5119        1370 :     READ_DONE();
    5120             : }
    5121             : 
    5122             : static PartitionPruneStepOp *
    5123        1148 : _readPartitionPruneStepOp(void)
    5124             : {
    5125        1148 :     READ_LOCALS(PartitionPruneStepOp);
    5126             : 
    5127        1148 :     READ_INT_FIELD(step.step_id);
    5128        1148 :     READ_INT_FIELD(opstrategy);
    5129        1148 :     READ_NODE_FIELD(exprs);
    5130        1148 :     READ_NODE_FIELD(cmpfns);
    5131        1148 :     READ_BITMAPSET_FIELD(nullkeys);
    5132             : 
    5133        1148 :     READ_DONE();
    5134             : }
    5135             : 
    5136             : static PartitionPruneStepCombine *
    5137         218 : _readPartitionPruneStepCombine(void)
    5138             : {
    5139         218 :     READ_LOCALS(PartitionPruneStepCombine);
    5140             : 
    5141         218 :     READ_INT_FIELD(step.step_id);
    5142         218 :     READ_ENUM_FIELD(combineOp, PartitionPruneCombineOp);
    5143         218 :     READ_NODE_FIELD(source_stepids);
    5144             : 
    5145         218 :     READ_DONE();
    5146             : }
    5147             : 
    5148             : static PlanInvalItem *
    5149       58506 : _readPlanInvalItem(void)
    5150             : {
    5151       58506 :     READ_LOCALS(PlanInvalItem);
    5152             : 
    5153       58506 :     READ_INT_FIELD(cacheId);
    5154       58506 :     READ_UINT_FIELD(hashValue);
    5155             : 
    5156       58506 :     READ_DONE();
    5157             : }

Generated by: LCOV version 1.16