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

Generated by: LCOV version 1.14