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

Generated by: LCOV version 1.14