LCOV - code coverage report
Current view: top level - src/backend/nodes - outfuncs.funcs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18beta1 Lines: 3196 4482 71.3 %
Date: 2025-06-07 12:18:21 Functions: 305 370 82.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * outfuncs.funcs.c
       4             :  *    Generated node infrastructure code
       5             :  *
       6             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * NOTES
      10             :  *  ******************************
      11             :  *  *** DO NOT EDIT THIS FILE! ***
      12             :  *  ******************************
      13             :  *
      14             :  *  It has been GENERATED by src/backend/nodes/gen_node_support.pl
      15             :  *
      16             :  *-------------------------------------------------------------------------
      17             :  */
      18             : #include "access/amapi.h"
      19             : #include "access/cmptype.h"
      20             : #include "access/sdir.h"
      21             : #include "access/tableam.h"
      22             : #include "access/tsmapi.h"
      23             : #include "commands/event_trigger.h"
      24             : #include "commands/trigger.h"
      25             : #include "executor/tuptable.h"
      26             : #include "foreign/fdwapi.h"
      27             : #include "nodes/bitmapset.h"
      28             : #include "nodes/execnodes.h"
      29             : #include "nodes/extensible.h"
      30             : #include "nodes/lockoptions.h"
      31             : #include "nodes/miscnodes.h"
      32             : #include "nodes/nodes.h"
      33             : #include "nodes/parsenodes.h"
      34             : #include "nodes/pathnodes.h"
      35             : #include "nodes/plannodes.h"
      36             : #include "nodes/primnodes.h"
      37             : #include "nodes/replnodes.h"
      38             : #include "nodes/supportnodes.h"
      39             : #include "nodes/value.h"
      40             : #include "utils/rel.h"
      41             : 
      42             : static void
      43     2746494 : _outAlias(StringInfo str, const Alias *node)
      44             : {
      45     2746494 :     WRITE_NODE_TYPE("ALIAS");
      46             : 
      47     2746494 :     WRITE_STRING_FIELD(aliasname);
      48     2746494 :     WRITE_NODE_FIELD(colnames);
      49     2746494 : }
      50             : 
      51             : static void
      52      892316 : _outRangeVar(StringInfo str, const RangeVar *node)
      53             : {
      54      892316 :     WRITE_NODE_TYPE("RANGEVAR");
      55             : 
      56      892316 :     WRITE_STRING_FIELD(catalogname);
      57      892316 :     WRITE_STRING_FIELD(schemaname);
      58      892316 :     WRITE_STRING_FIELD(relname);
      59      892316 :     WRITE_BOOL_FIELD(inh);
      60      892316 :     WRITE_CHAR_FIELD(relpersistence);
      61      892316 :     WRITE_NODE_FIELD(alias);
      62      892316 :     WRITE_LOCATION_FIELD(location);
      63      892316 : }
      64             : 
      65             : static void
      66        1296 : _outTableFunc(StringInfo str, const TableFunc *node)
      67             : {
      68        1296 :     WRITE_NODE_TYPE("TABLEFUNC");
      69             : 
      70        1296 :     WRITE_ENUM_FIELD(functype, TableFuncType);
      71        1296 :     WRITE_NODE_FIELD(ns_uris);
      72        1296 :     WRITE_NODE_FIELD(ns_names);
      73        1296 :     WRITE_NODE_FIELD(docexpr);
      74        1296 :     WRITE_NODE_FIELD(rowexpr);
      75        1296 :     WRITE_NODE_FIELD(colnames);
      76        1296 :     WRITE_NODE_FIELD(coltypes);
      77        1296 :     WRITE_NODE_FIELD(coltypmods);
      78        1296 :     WRITE_NODE_FIELD(colcollations);
      79        1296 :     WRITE_NODE_FIELD(colexprs);
      80        1296 :     WRITE_NODE_FIELD(coldefexprs);
      81        1296 :     WRITE_NODE_FIELD(colvalexprs);
      82        1296 :     WRITE_NODE_FIELD(passingvalexprs);
      83        1296 :     WRITE_BITMAPSET_FIELD(notnulls);
      84        1296 :     WRITE_NODE_FIELD(plan);
      85        1296 :     WRITE_INT_FIELD(ordinalitycol);
      86        1296 :     WRITE_LOCATION_FIELD(location);
      87        1296 : }
      88             : 
      89             : static void
      90        3938 : _outIntoClause(StringInfo str, const IntoClause *node)
      91             : {
      92        3938 :     WRITE_NODE_TYPE("INTOCLAUSE");
      93             : 
      94        3938 :     WRITE_NODE_FIELD(rel);
      95        3938 :     WRITE_NODE_FIELD(colNames);
      96        3938 :     WRITE_STRING_FIELD(accessMethod);
      97        3938 :     WRITE_NODE_FIELD(options);
      98        3938 :     WRITE_ENUM_FIELD(onCommit, OnCommitAction);
      99        3938 :     WRITE_STRING_FIELD(tableSpaceName);
     100        3938 :     WRITE_NODE_FIELD(viewQuery);
     101        3938 :     WRITE_BOOL_FIELD(skipData);
     102        3938 : }
     103             : 
     104             : static void
     105    12302570 : _outVar(StringInfo str, const Var *node)
     106             : {
     107    12302570 :     WRITE_NODE_TYPE("VAR");
     108             : 
     109    12302570 :     WRITE_INT_FIELD(varno);
     110    12302570 :     WRITE_INT_FIELD(varattno);
     111    12302570 :     WRITE_OID_FIELD(vartype);
     112    12302570 :     WRITE_INT_FIELD(vartypmod);
     113    12302570 :     WRITE_OID_FIELD(varcollid);
     114    12302570 :     WRITE_BITMAPSET_FIELD(varnullingrels);
     115    12302570 :     WRITE_UINT_FIELD(varlevelsup);
     116    12302570 :     WRITE_ENUM_FIELD(varreturningtype, VarReturningType);
     117    12302570 :     WRITE_UINT_FIELD(varnosyn);
     118    12302570 :     WRITE_INT_FIELD(varattnosyn);
     119    12302570 :     WRITE_LOCATION_FIELD(location);
     120    12302570 : }
     121             : 
     122             : static void
     123      314064 : _outParam(StringInfo str, const Param *node)
     124             : {
     125      314064 :     WRITE_NODE_TYPE("PARAM");
     126             : 
     127      314064 :     WRITE_ENUM_FIELD(paramkind, ParamKind);
     128      314064 :     WRITE_INT_FIELD(paramid);
     129      314064 :     WRITE_OID_FIELD(paramtype);
     130      314064 :     WRITE_INT_FIELD(paramtypmod);
     131      314064 :     WRITE_OID_FIELD(paramcollid);
     132      314064 :     WRITE_LOCATION_FIELD(location);
     133      314064 : }
     134             : 
     135             : static void
     136       90954 : _outAggref(StringInfo str, const Aggref *node)
     137             : {
     138       90954 :     WRITE_NODE_TYPE("AGGREF");
     139             : 
     140       90954 :     WRITE_OID_FIELD(aggfnoid);
     141       90954 :     WRITE_OID_FIELD(aggtype);
     142       90954 :     WRITE_OID_FIELD(aggcollid);
     143       90954 :     WRITE_OID_FIELD(inputcollid);
     144       90954 :     WRITE_OID_FIELD(aggtranstype);
     145       90954 :     WRITE_NODE_FIELD(aggargtypes);
     146       90954 :     WRITE_NODE_FIELD(aggdirectargs);
     147       90954 :     WRITE_NODE_FIELD(args);
     148       90954 :     WRITE_NODE_FIELD(aggorder);
     149       90954 :     WRITE_NODE_FIELD(aggdistinct);
     150       90954 :     WRITE_NODE_FIELD(aggfilter);
     151       90954 :     WRITE_BOOL_FIELD(aggstar);
     152       90954 :     WRITE_BOOL_FIELD(aggvariadic);
     153       90954 :     WRITE_CHAR_FIELD(aggkind);
     154       90954 :     WRITE_BOOL_FIELD(aggpresorted);
     155       90954 :     WRITE_UINT_FIELD(agglevelsup);
     156       90954 :     WRITE_ENUM_FIELD(aggsplit, AggSplit);
     157       90954 :     WRITE_INT_FIELD(aggno);
     158       90954 :     WRITE_INT_FIELD(aggtransno);
     159       90954 :     WRITE_LOCATION_FIELD(location);
     160       90954 : }
     161             : 
     162             : static void
     163        1074 : _outGroupingFunc(StringInfo str, const GroupingFunc *node)
     164             : {
     165        1074 :     WRITE_NODE_TYPE("GROUPINGFUNC");
     166             : 
     167        1074 :     WRITE_NODE_FIELD(args);
     168        1074 :     WRITE_NODE_FIELD(refs);
     169        1074 :     WRITE_NODE_FIELD(cols);
     170        1074 :     WRITE_UINT_FIELD(agglevelsup);
     171        1074 :     WRITE_LOCATION_FIELD(location);
     172        1074 : }
     173             : 
     174             : static void
     175        6884 : _outWindowFunc(StringInfo str, const WindowFunc *node)
     176             : {
     177        6884 :     WRITE_NODE_TYPE("WINDOWFUNC");
     178             : 
     179        6884 :     WRITE_OID_FIELD(winfnoid);
     180        6884 :     WRITE_OID_FIELD(wintype);
     181        6884 :     WRITE_OID_FIELD(wincollid);
     182        6884 :     WRITE_OID_FIELD(inputcollid);
     183        6884 :     WRITE_NODE_FIELD(args);
     184        6884 :     WRITE_NODE_FIELD(aggfilter);
     185        6884 :     WRITE_NODE_FIELD(runCondition);
     186        6884 :     WRITE_UINT_FIELD(winref);
     187        6884 :     WRITE_BOOL_FIELD(winstar);
     188        6884 :     WRITE_BOOL_FIELD(winagg);
     189        6884 :     WRITE_LOCATION_FIELD(location);
     190        6884 : }
     191             : 
     192             : static void
     193         360 : _outWindowFuncRunCondition(StringInfo str, const WindowFuncRunCondition *node)
     194             : {
     195         360 :     WRITE_NODE_TYPE("WINDOWFUNCRUNCONDITION");
     196             : 
     197         360 :     WRITE_OID_FIELD(opno);
     198         360 :     WRITE_OID_FIELD(inputcollid);
     199         360 :     WRITE_BOOL_FIELD(wfunc_left);
     200         360 :     WRITE_NODE_FIELD(arg);
     201         360 : }
     202             : 
     203             : static void
     204         828 : _outMergeSupportFunc(StringInfo str, const MergeSupportFunc *node)
     205             : {
     206         828 :     WRITE_NODE_TYPE("MERGESUPPORTFUNC");
     207             : 
     208         828 :     WRITE_OID_FIELD(msftype);
     209         828 :     WRITE_OID_FIELD(msfcollid);
     210         828 :     WRITE_LOCATION_FIELD(location);
     211         828 : }
     212             : 
     213             : static void
     214       34262 : _outSubscriptingRef(StringInfo str, const SubscriptingRef *node)
     215             : {
     216       34262 :     WRITE_NODE_TYPE("SUBSCRIPTINGREF");
     217             : 
     218       34262 :     WRITE_OID_FIELD(refcontainertype);
     219       34262 :     WRITE_OID_FIELD(refelemtype);
     220       34262 :     WRITE_OID_FIELD(refrestype);
     221       34262 :     WRITE_INT_FIELD(reftypmod);
     222       34262 :     WRITE_OID_FIELD(refcollid);
     223       34262 :     WRITE_NODE_FIELD(refupperindexpr);
     224       34262 :     WRITE_NODE_FIELD(reflowerindexpr);
     225       34262 :     WRITE_NODE_FIELD(refexpr);
     226       34262 :     WRITE_NODE_FIELD(refassgnexpr);
     227       34262 : }
     228             : 
     229             : static void
     230      743134 : _outFuncExpr(StringInfo str, const FuncExpr *node)
     231             : {
     232      743134 :     WRITE_NODE_TYPE("FUNCEXPR");
     233             : 
     234      743134 :     WRITE_OID_FIELD(funcid);
     235      743134 :     WRITE_OID_FIELD(funcresulttype);
     236      743134 :     WRITE_BOOL_FIELD(funcretset);
     237      743134 :     WRITE_BOOL_FIELD(funcvariadic);
     238      743134 :     WRITE_ENUM_FIELD(funcformat, CoercionForm);
     239      743134 :     WRITE_OID_FIELD(funccollid);
     240      743134 :     WRITE_OID_FIELD(inputcollid);
     241      743134 :     WRITE_NODE_FIELD(args);
     242      743134 :     WRITE_LOCATION_FIELD(location);
     243      743134 : }
     244             : 
     245             : static void
     246       94038 : _outNamedArgExpr(StringInfo str, const NamedArgExpr *node)
     247             : {
     248       94038 :     WRITE_NODE_TYPE("NAMEDARGEXPR");
     249             : 
     250       94038 :     WRITE_NODE_FIELD(arg);
     251       94038 :     WRITE_STRING_FIELD(name);
     252       94038 :     WRITE_INT_FIELD(argnumber);
     253       94038 :     WRITE_LOCATION_FIELD(location);
     254       94038 : }
     255             : 
     256             : static void
     257     1469784 : _outOpExpr(StringInfo str, const OpExpr *node)
     258             : {
     259     1469784 :     WRITE_NODE_TYPE("OPEXPR");
     260             : 
     261     1469784 :     WRITE_OID_FIELD(opno);
     262     1469784 :     WRITE_OID_FIELD(opfuncid);
     263     1469784 :     WRITE_OID_FIELD(opresulttype);
     264     1469784 :     WRITE_BOOL_FIELD(opretset);
     265     1469784 :     WRITE_OID_FIELD(opcollid);
     266     1469784 :     WRITE_OID_FIELD(inputcollid);
     267     1469784 :     WRITE_NODE_FIELD(args);
     268     1469784 :     WRITE_LOCATION_FIELD(location);
     269     1469784 : }
     270             : 
     271             : static void
     272        2510 : _outDistinctExpr(StringInfo str, const DistinctExpr *node)
     273             : {
     274        2510 :     WRITE_NODE_TYPE("DISTINCTEXPR");
     275             : 
     276        2510 :     WRITE_OID_FIELD(opno);
     277        2510 :     WRITE_OID_FIELD(opfuncid);
     278        2510 :     WRITE_OID_FIELD(opresulttype);
     279        2510 :     WRITE_BOOL_FIELD(opretset);
     280        2510 :     WRITE_OID_FIELD(opcollid);
     281        2510 :     WRITE_OID_FIELD(inputcollid);
     282        2510 :     WRITE_NODE_FIELD(args);
     283        2510 :     WRITE_LOCATION_FIELD(location);
     284        2510 : }
     285             : 
     286             : static void
     287         672 : _outNullIfExpr(StringInfo str, const NullIfExpr *node)
     288             : {
     289         672 :     WRITE_NODE_TYPE("NULLIFEXPR");
     290             : 
     291         672 :     WRITE_OID_FIELD(opno);
     292         672 :     WRITE_OID_FIELD(opfuncid);
     293         672 :     WRITE_OID_FIELD(opresulttype);
     294         672 :     WRITE_BOOL_FIELD(opretset);
     295         672 :     WRITE_OID_FIELD(opcollid);
     296         672 :     WRITE_OID_FIELD(inputcollid);
     297         672 :     WRITE_NODE_FIELD(args);
     298         672 :     WRITE_LOCATION_FIELD(location);
     299         672 : }
     300             : 
     301             : static void
     302       75342 : _outScalarArrayOpExpr(StringInfo str, const ScalarArrayOpExpr *node)
     303             : {
     304       75342 :     WRITE_NODE_TYPE("SCALARARRAYOPEXPR");
     305             : 
     306       75342 :     WRITE_OID_FIELD(opno);
     307       75342 :     WRITE_OID_FIELD(opfuncid);
     308       75342 :     WRITE_OID_FIELD(hashfuncid);
     309       75342 :     WRITE_OID_FIELD(negfuncid);
     310       75342 :     WRITE_BOOL_FIELD(useOr);
     311       75342 :     WRITE_OID_FIELD(inputcollid);
     312       75342 :     WRITE_NODE_FIELD(args);
     313       75342 :     WRITE_LOCATION_FIELD(location);
     314       75342 : }
     315             : 
     316             : static void
     317      104310 : _outSubLink(StringInfo str, const SubLink *node)
     318             : {
     319      104310 :     WRITE_NODE_TYPE("SUBLINK");
     320             : 
     321      104310 :     WRITE_ENUM_FIELD(subLinkType, SubLinkType);
     322      104310 :     WRITE_INT_FIELD(subLinkId);
     323      104310 :     WRITE_NODE_FIELD(testexpr);
     324      104310 :     WRITE_NODE_FIELD(operName);
     325      104310 :     WRITE_NODE_FIELD(subselect);
     326      104310 :     WRITE_LOCATION_FIELD(location);
     327      104310 : }
     328             : 
     329             : static void
     330       44726 : _outSubPlan(StringInfo str, const SubPlan *node)
     331             : {
     332       44726 :     WRITE_NODE_TYPE("SUBPLAN");
     333             : 
     334       44726 :     WRITE_ENUM_FIELD(subLinkType, SubLinkType);
     335       44726 :     WRITE_NODE_FIELD(testexpr);
     336       44726 :     WRITE_NODE_FIELD(paramIds);
     337       44726 :     WRITE_INT_FIELD(plan_id);
     338       44726 :     WRITE_STRING_FIELD(plan_name);
     339       44726 :     WRITE_OID_FIELD(firstColType);
     340       44726 :     WRITE_INT_FIELD(firstColTypmod);
     341       44726 :     WRITE_OID_FIELD(firstColCollation);
     342       44726 :     WRITE_BOOL_FIELD(useHashTable);
     343       44726 :     WRITE_BOOL_FIELD(unknownEqFalse);
     344       44726 :     WRITE_BOOL_FIELD(parallel_safe);
     345       44726 :     WRITE_NODE_FIELD(setParam);
     346       44726 :     WRITE_NODE_FIELD(parParam);
     347       44726 :     WRITE_NODE_FIELD(args);
     348       44726 :     WRITE_FLOAT_FIELD(startup_cost);
     349       44726 :     WRITE_FLOAT_FIELD(per_call_cost);
     350       44726 : }
     351             : 
     352             : static void
     353           0 : _outAlternativeSubPlan(StringInfo str, const AlternativeSubPlan *node)
     354             : {
     355           0 :     WRITE_NODE_TYPE("ALTERNATIVESUBPLAN");
     356             : 
     357           0 :     WRITE_NODE_FIELD(subplans);
     358           0 : }
     359             : 
     360             : static void
     361       23176 : _outFieldSelect(StringInfo str, const FieldSelect *node)
     362             : {
     363       23176 :     WRITE_NODE_TYPE("FIELDSELECT");
     364             : 
     365       23176 :     WRITE_NODE_FIELD(arg);
     366       23176 :     WRITE_INT_FIELD(fieldnum);
     367       23176 :     WRITE_OID_FIELD(resulttype);
     368       23176 :     WRITE_INT_FIELD(resulttypmod);
     369       23176 :     WRITE_OID_FIELD(resultcollid);
     370       23176 : }
     371             : 
     372             : static void
     373         866 : _outFieldStore(StringInfo str, const FieldStore *node)
     374             : {
     375         866 :     WRITE_NODE_TYPE("FIELDSTORE");
     376             : 
     377         866 :     WRITE_NODE_FIELD(arg);
     378         866 :     WRITE_NODE_FIELD(newvals);
     379         866 :     WRITE_NODE_FIELD(fieldnums);
     380         866 :     WRITE_OID_FIELD(resulttype);
     381         866 : }
     382             : 
     383             : static void
     384      265420 : _outRelabelType(StringInfo str, const RelabelType *node)
     385             : {
     386      265420 :     WRITE_NODE_TYPE("RELABELTYPE");
     387             : 
     388      265420 :     WRITE_NODE_FIELD(arg);
     389      265420 :     WRITE_OID_FIELD(resulttype);
     390      265420 :     WRITE_INT_FIELD(resulttypmod);
     391      265420 :     WRITE_OID_FIELD(resultcollid);
     392      265420 :     WRITE_ENUM_FIELD(relabelformat, CoercionForm);
     393      265420 :     WRITE_LOCATION_FIELD(location);
     394      265420 : }
     395             : 
     396             : static void
     397       47204 : _outCoerceViaIO(StringInfo str, const CoerceViaIO *node)
     398             : {
     399       47204 :     WRITE_NODE_TYPE("COERCEVIAIO");
     400             : 
     401       47204 :     WRITE_NODE_FIELD(arg);
     402       47204 :     WRITE_OID_FIELD(resulttype);
     403       47204 :     WRITE_OID_FIELD(resultcollid);
     404       47204 :     WRITE_ENUM_FIELD(coerceformat, CoercionForm);
     405       47204 :     WRITE_LOCATION_FIELD(location);
     406       47204 : }
     407             : 
     408             : static void
     409       10706 : _outArrayCoerceExpr(StringInfo str, const ArrayCoerceExpr *node)
     410             : {
     411       10706 :     WRITE_NODE_TYPE("ARRAYCOERCEEXPR");
     412             : 
     413       10706 :     WRITE_NODE_FIELD(arg);
     414       10706 :     WRITE_NODE_FIELD(elemexpr);
     415       10706 :     WRITE_OID_FIELD(resulttype);
     416       10706 :     WRITE_INT_FIELD(resulttypmod);
     417       10706 :     WRITE_OID_FIELD(resultcollid);
     418       10706 :     WRITE_ENUM_FIELD(coerceformat, CoercionForm);
     419       10706 :     WRITE_LOCATION_FIELD(location);
     420       10706 : }
     421             : 
     422             : static void
     423         842 : _outConvertRowtypeExpr(StringInfo str, const ConvertRowtypeExpr *node)
     424             : {
     425         842 :     WRITE_NODE_TYPE("CONVERTROWTYPEEXPR");
     426             : 
     427         842 :     WRITE_NODE_FIELD(arg);
     428         842 :     WRITE_OID_FIELD(resulttype);
     429         842 :     WRITE_ENUM_FIELD(convertformat, CoercionForm);
     430         842 :     WRITE_LOCATION_FIELD(location);
     431         842 : }
     432             : 
     433             : static void
     434        8746 : _outCollateExpr(StringInfo str, const CollateExpr *node)
     435             : {
     436        8746 :     WRITE_NODE_TYPE("COLLATEEXPR");
     437             : 
     438        8746 :     WRITE_NODE_FIELD(arg);
     439        8746 :     WRITE_OID_FIELD(collOid);
     440        8746 :     WRITE_LOCATION_FIELD(location);
     441        8746 : }
     442             : 
     443             : static void
     444      133746 : _outCaseExpr(StringInfo str, const CaseExpr *node)
     445             : {
     446      133746 :     WRITE_NODE_TYPE("CASEEXPR");
     447             : 
     448      133746 :     WRITE_OID_FIELD(casetype);
     449      133746 :     WRITE_OID_FIELD(casecollid);
     450      133746 :     WRITE_NODE_FIELD(arg);
     451      133746 :     WRITE_NODE_FIELD(args);
     452      133746 :     WRITE_NODE_FIELD(defresult);
     453      133746 :     WRITE_LOCATION_FIELD(location);
     454      133746 : }
     455             : 
     456             : static void
     457      249494 : _outCaseWhen(StringInfo str, const CaseWhen *node)
     458             : {
     459      249494 :     WRITE_NODE_TYPE("CASEWHEN");
     460             : 
     461      249494 :     WRITE_NODE_FIELD(expr);
     462      249494 :     WRITE_NODE_FIELD(result);
     463      249494 :     WRITE_LOCATION_FIELD(location);
     464      249494 : }
     465             : 
     466             : static void
     467       57308 : _outCaseTestExpr(StringInfo str, const CaseTestExpr *node)
     468             : {
     469       57308 :     WRITE_NODE_TYPE("CASETESTEXPR");
     470             : 
     471       57308 :     WRITE_OID_FIELD(typeId);
     472       57308 :     WRITE_INT_FIELD(typeMod);
     473       57308 :     WRITE_OID_FIELD(collation);
     474       57308 : }
     475             : 
     476             : static void
     477       34564 : _outArrayExpr(StringInfo str, const ArrayExpr *node)
     478             : {
     479       34564 :     WRITE_NODE_TYPE("ARRAYEXPR");
     480             : 
     481       34564 :     WRITE_OID_FIELD(array_typeid);
     482       34564 :     WRITE_OID_FIELD(array_collid);
     483       34564 :     WRITE_OID_FIELD(element_typeid);
     484       34564 :     WRITE_NODE_FIELD(elements);
     485       34564 :     WRITE_BOOL_FIELD(multidims);
     486       34564 :     WRITE_LOCATION_FIELD(location);
     487       34564 : }
     488             : 
     489             : static void
     490       13184 : _outRowExpr(StringInfo str, const RowExpr *node)
     491             : {
     492       13184 :     WRITE_NODE_TYPE("ROWEXPR");
     493             : 
     494       13184 :     WRITE_NODE_FIELD(args);
     495       13184 :     WRITE_OID_FIELD(row_typeid);
     496       13184 :     WRITE_ENUM_FIELD(row_format, CoercionForm);
     497       13184 :     WRITE_NODE_FIELD(colnames);
     498       13184 :     WRITE_LOCATION_FIELD(location);
     499       13184 : }
     500             : 
     501             : static void
     502         618 : _outRowCompareExpr(StringInfo str, const RowCompareExpr *node)
     503             : {
     504         618 :     WRITE_NODE_TYPE("ROWCOMPAREEXPR");
     505             : 
     506         618 :     WRITE_ENUM_FIELD(cmptype, CompareType);
     507         618 :     WRITE_NODE_FIELD(opnos);
     508         618 :     WRITE_NODE_FIELD(opfamilies);
     509         618 :     WRITE_NODE_FIELD(inputcollids);
     510         618 :     WRITE_NODE_FIELD(largs);
     511         618 :     WRITE_NODE_FIELD(rargs);
     512         618 : }
     513             : 
     514             : static void
     515       14616 : _outCoalesceExpr(StringInfo str, const CoalesceExpr *node)
     516             : {
     517       14616 :     WRITE_NODE_TYPE("COALESCEEXPR");
     518             : 
     519       14616 :     WRITE_OID_FIELD(coalescetype);
     520       14616 :     WRITE_OID_FIELD(coalescecollid);
     521       14616 :     WRITE_NODE_FIELD(args);
     522       14616 :     WRITE_LOCATION_FIELD(location);
     523       14616 : }
     524             : 
     525             : static void
     526         870 : _outMinMaxExpr(StringInfo str, const MinMaxExpr *node)
     527             : {
     528         870 :     WRITE_NODE_TYPE("MINMAXEXPR");
     529             : 
     530         870 :     WRITE_OID_FIELD(minmaxtype);
     531         870 :     WRITE_OID_FIELD(minmaxcollid);
     532         870 :     WRITE_OID_FIELD(inputcollid);
     533         870 :     WRITE_ENUM_FIELD(op, MinMaxOp);
     534         870 :     WRITE_NODE_FIELD(args);
     535         870 :     WRITE_LOCATION_FIELD(location);
     536         870 : }
     537             : 
     538             : static void
     539       12568 : _outSQLValueFunction(StringInfo str, const SQLValueFunction *node)
     540             : {
     541       12568 :     WRITE_NODE_TYPE("SQLVALUEFUNCTION");
     542             : 
     543       12568 :     WRITE_ENUM_FIELD(op, SQLValueFunctionOp);
     544       12568 :     WRITE_OID_FIELD(type);
     545       12568 :     WRITE_INT_FIELD(typmod);
     546       12568 :     WRITE_LOCATION_FIELD(location);
     547       12568 : }
     548             : 
     549             : static void
     550        2200 : _outXmlExpr(StringInfo str, const XmlExpr *node)
     551             : {
     552        2200 :     WRITE_NODE_TYPE("XMLEXPR");
     553             : 
     554        2200 :     WRITE_ENUM_FIELD(op, XmlExprOp);
     555        2200 :     WRITE_STRING_FIELD(name);
     556        2200 :     WRITE_NODE_FIELD(named_args);
     557        2200 :     WRITE_NODE_FIELD(arg_names);
     558        2200 :     WRITE_NODE_FIELD(args);
     559        2200 :     WRITE_ENUM_FIELD(xmloption, XmlOptionType);
     560        2200 :     WRITE_BOOL_FIELD(indent);
     561        2200 :     WRITE_OID_FIELD(type);
     562        2200 :     WRITE_INT_FIELD(typmod);
     563        2200 :     WRITE_LOCATION_FIELD(location);
     564        2200 : }
     565             : 
     566             : static void
     567       22246 : _outJsonFormat(StringInfo str, const JsonFormat *node)
     568             : {
     569       22246 :     WRITE_NODE_TYPE("JSONFORMAT");
     570             : 
     571       22246 :     WRITE_ENUM_FIELD(format_type, JsonFormatType);
     572       22246 :     WRITE_ENUM_FIELD(encoding, JsonEncoding);
     573       22246 :     WRITE_LOCATION_FIELD(location);
     574       22246 : }
     575             : 
     576             : static void
     577        9554 : _outJsonReturning(StringInfo str, const JsonReturning *node)
     578             : {
     579        9554 :     WRITE_NODE_TYPE("JSONRETURNING");
     580             : 
     581        9554 :     WRITE_NODE_FIELD(format);
     582        9554 :     WRITE_OID_FIELD(typid);
     583        9554 :     WRITE_INT_FIELD(typmod);
     584        9554 : }
     585             : 
     586             : static void
     587        5720 : _outJsonValueExpr(StringInfo str, const JsonValueExpr *node)
     588             : {
     589        5720 :     WRITE_NODE_TYPE("JSONVALUEEXPR");
     590             : 
     591        5720 :     WRITE_NODE_FIELD(raw_expr);
     592        5720 :     WRITE_NODE_FIELD(formatted_expr);
     593        5720 :     WRITE_NODE_FIELD(format);
     594        5720 : }
     595             : 
     596             : static void
     597        2738 : _outJsonConstructorExpr(StringInfo str, const JsonConstructorExpr *node)
     598             : {
     599        2738 :     WRITE_NODE_TYPE("JSONCONSTRUCTOREXPR");
     600             : 
     601        2738 :     WRITE_ENUM_FIELD(type, JsonConstructorType);
     602        2738 :     WRITE_NODE_FIELD(args);
     603        2738 :     WRITE_NODE_FIELD(func);
     604        2738 :     WRITE_NODE_FIELD(coercion);
     605        2738 :     WRITE_NODE_FIELD(returning);
     606        2738 :     WRITE_BOOL_FIELD(absent_on_null);
     607        2738 :     WRITE_BOOL_FIELD(unique);
     608        2738 :     WRITE_LOCATION_FIELD(location);
     609        2738 : }
     610             : 
     611             : static void
     612        1038 : _outJsonIsPredicate(StringInfo str, const JsonIsPredicate *node)
     613             : {
     614        1038 :     WRITE_NODE_TYPE("JSONISPREDICATE");
     615             : 
     616        1038 :     WRITE_NODE_FIELD(expr);
     617        1038 :     WRITE_NODE_FIELD(format);
     618        1038 :     WRITE_ENUM_FIELD(item_type, JsonValueType);
     619        1038 :     WRITE_BOOL_FIELD(unique_keys);
     620        1038 :     WRITE_LOCATION_FIELD(location);
     621        1038 : }
     622             : 
     623             : static void
     624       10380 : _outJsonBehavior(StringInfo str, const JsonBehavior *node)
     625             : {
     626       10380 :     WRITE_NODE_TYPE("JSONBEHAVIOR");
     627             : 
     628       10380 :     WRITE_ENUM_FIELD(btype, JsonBehaviorType);
     629       10380 :     WRITE_NODE_FIELD(expr);
     630       10380 :     WRITE_BOOL_FIELD(coerce);
     631       10380 :     WRITE_LOCATION_FIELD(location);
     632       10380 : }
     633             : 
     634             : static void
     635        5330 : _outJsonExpr(StringInfo str, const JsonExpr *node)
     636             : {
     637        5330 :     WRITE_NODE_TYPE("JSONEXPR");
     638             : 
     639        5330 :     WRITE_ENUM_FIELD(op, JsonExprOp);
     640        5330 :     WRITE_STRING_FIELD(column_name);
     641        5330 :     WRITE_NODE_FIELD(formatted_expr);
     642        5330 :     WRITE_NODE_FIELD(format);
     643        5330 :     WRITE_NODE_FIELD(path_spec);
     644        5330 :     WRITE_NODE_FIELD(returning);
     645        5330 :     WRITE_NODE_FIELD(passing_names);
     646        5330 :     WRITE_NODE_FIELD(passing_values);
     647        5330 :     WRITE_NODE_FIELD(on_empty);
     648        5330 :     WRITE_NODE_FIELD(on_error);
     649        5330 :     WRITE_BOOL_FIELD(use_io_coercion);
     650        5330 :     WRITE_BOOL_FIELD(use_json_coercion);
     651        5330 :     WRITE_ENUM_FIELD(wrapper, JsonWrapper);
     652        5330 :     WRITE_BOOL_FIELD(omit_quotes);
     653        5330 :     WRITE_OID_FIELD(collation);
     654        5330 :     WRITE_LOCATION_FIELD(location);
     655        5330 : }
     656             : 
     657             : static void
     658        1292 : _outJsonTablePath(StringInfo str, const JsonTablePath *node)
     659             : {
     660        1292 :     WRITE_NODE_TYPE("JSONTABLEPATH");
     661             : 
     662        1292 :     WRITE_NODE_FIELD(value);
     663        1292 :     WRITE_STRING_FIELD(name);
     664        1292 : }
     665             : 
     666             : static void
     667        1292 : _outJsonTablePathScan(StringInfo str, const JsonTablePathScan *node)
     668             : {
     669        1292 :     WRITE_NODE_TYPE("JSONTABLEPATHSCAN");
     670             : 
     671        1292 :     WRITE_NODE_FIELD(path);
     672        1292 :     WRITE_BOOL_FIELD(errorOnError);
     673        1292 :     WRITE_NODE_FIELD(child);
     674        1292 :     WRITE_INT_FIELD(colMin);
     675        1292 :     WRITE_INT_FIELD(colMax);
     676        1292 : }
     677             : 
     678             : static void
     679         150 : _outJsonTableSiblingJoin(StringInfo str, const JsonTableSiblingJoin *node)
     680             : {
     681         150 :     WRITE_NODE_TYPE("JSONTABLESIBLINGJOIN");
     682             : 
     683         150 :     WRITE_NODE_FIELD(lplan);
     684         150 :     WRITE_NODE_FIELD(rplan);
     685         150 : }
     686             : 
     687             : static void
     688       55508 : _outNullTest(StringInfo str, const NullTest *node)
     689             : {
     690       55508 :     WRITE_NODE_TYPE("NULLTEST");
     691             : 
     692       55508 :     WRITE_NODE_FIELD(arg);
     693       55508 :     WRITE_ENUM_FIELD(nulltesttype, NullTestType);
     694       55508 :     WRITE_BOOL_FIELD(argisrow);
     695       55508 :     WRITE_LOCATION_FIELD(location);
     696       55508 : }
     697             : 
     698             : static void
     699        3798 : _outBooleanTest(StringInfo str, const BooleanTest *node)
     700             : {
     701        3798 :     WRITE_NODE_TYPE("BOOLEANTEST");
     702             : 
     703        3798 :     WRITE_NODE_FIELD(arg);
     704        3798 :     WRITE_ENUM_FIELD(booltesttype, BoolTestType);
     705        3798 :     WRITE_LOCATION_FIELD(location);
     706        3798 : }
     707             : 
     708             : static void
     709        6480 : _outMergeAction(StringInfo str, const MergeAction *node)
     710             : {
     711        6480 :     WRITE_NODE_TYPE("MERGEACTION");
     712             : 
     713        6480 :     WRITE_ENUM_FIELD(matchKind, MergeMatchKind);
     714        6480 :     WRITE_ENUM_FIELD(commandType, CmdType);
     715        6480 :     WRITE_ENUM_FIELD(override, OverridingKind);
     716        6480 :     WRITE_NODE_FIELD(qual);
     717        6480 :     WRITE_NODE_FIELD(targetList);
     718        6480 :     WRITE_NODE_FIELD(updateColnos);
     719        6480 : }
     720             : 
     721             : static void
     722      103654 : _outCoerceToDomain(StringInfo str, const CoerceToDomain *node)
     723             : {
     724      103654 :     WRITE_NODE_TYPE("COERCETODOMAIN");
     725             : 
     726      103654 :     WRITE_NODE_FIELD(arg);
     727      103654 :     WRITE_OID_FIELD(resulttype);
     728      103654 :     WRITE_INT_FIELD(resulttypmod);
     729      103654 :     WRITE_OID_FIELD(resultcollid);
     730      103654 :     WRITE_ENUM_FIELD(coercionformat, CoercionForm);
     731      103654 :     WRITE_LOCATION_FIELD(location);
     732      103654 : }
     733             : 
     734             : static void
     735         820 : _outCoerceToDomainValue(StringInfo str, const CoerceToDomainValue *node)
     736             : {
     737         820 :     WRITE_NODE_TYPE("COERCETODOMAINVALUE");
     738             : 
     739         820 :     WRITE_OID_FIELD(typeId);
     740         820 :     WRITE_INT_FIELD(typeMod);
     741         820 :     WRITE_OID_FIELD(collation);
     742         820 :     WRITE_LOCATION_FIELD(location);
     743         820 : }
     744             : 
     745             : static void
     746        1542 : _outSetToDefault(StringInfo str, const SetToDefault *node)
     747             : {
     748        1542 :     WRITE_NODE_TYPE("SETTODEFAULT");
     749             : 
     750        1542 :     WRITE_OID_FIELD(typeId);
     751        1542 :     WRITE_INT_FIELD(typeMod);
     752        1542 :     WRITE_OID_FIELD(collation);
     753        1542 :     WRITE_LOCATION_FIELD(location);
     754        1542 : }
     755             : 
     756             : static void
     757         902 : _outCurrentOfExpr(StringInfo str, const CurrentOfExpr *node)
     758             : {
     759         902 :     WRITE_NODE_TYPE("CURRENTOFEXPR");
     760             : 
     761         902 :     WRITE_UINT_FIELD(cvarno);
     762         902 :     WRITE_STRING_FIELD(cursor_name);
     763         902 :     WRITE_INT_FIELD(cursor_param);
     764         902 : }
     765             : 
     766             : static void
     767         820 : _outNextValueExpr(StringInfo str, const NextValueExpr *node)
     768             : {
     769         820 :     WRITE_NODE_TYPE("NEXTVALUEEXPR");
     770             : 
     771         820 :     WRITE_OID_FIELD(seqid);
     772         820 :     WRITE_OID_FIELD(typeId);
     773         820 : }
     774             : 
     775             : static void
     776        1858 : _outInferenceElem(StringInfo str, const InferenceElem *node)
     777             : {
     778        1858 :     WRITE_NODE_TYPE("INFERENCEELEM");
     779             : 
     780        1858 :     WRITE_NODE_FIELD(expr);
     781        1858 :     WRITE_OID_FIELD(infercollid);
     782        1858 :     WRITE_OID_FIELD(inferopclass);
     783        1858 : }
     784             : 
     785             : static void
     786        1158 : _outReturningExpr(StringInfo str, const ReturningExpr *node)
     787             : {
     788        1158 :     WRITE_NODE_TYPE("RETURNINGEXPR");
     789             : 
     790        1158 :     WRITE_INT_FIELD(retlevelsup);
     791        1158 :     WRITE_BOOL_FIELD(retold);
     792        1158 :     WRITE_NODE_FIELD(retexpr);
     793        1158 : }
     794             : 
     795             : static void
     796     7175920 : _outTargetEntry(StringInfo str, const TargetEntry *node)
     797             : {
     798     7175920 :     WRITE_NODE_TYPE("TARGETENTRY");
     799             : 
     800     7175920 :     WRITE_NODE_FIELD(expr);
     801     7175920 :     WRITE_INT_FIELD(resno);
     802     7175920 :     WRITE_STRING_FIELD(resname);
     803     7175920 :     WRITE_UINT_FIELD(ressortgroupref);
     804     7175920 :     WRITE_OID_FIELD(resorigtbl);
     805     7175920 :     WRITE_INT_FIELD(resorigcol);
     806     7175920 :     WRITE_BOOL_FIELD(resjunk);
     807     7175920 : }
     808             : 
     809             : static void
     810      573184 : _outRangeTblRef(StringInfo str, const RangeTblRef *node)
     811             : {
     812      573184 :     WRITE_NODE_TYPE("RANGETBLREF");
     813             : 
     814      573184 :     WRITE_INT_FIELD(rtindex);
     815      573184 : }
     816             : 
     817             : static void
     818      198958 : _outJoinExpr(StringInfo str, const JoinExpr *node)
     819             : {
     820      198958 :     WRITE_NODE_TYPE("JOINEXPR");
     821             : 
     822      198958 :     WRITE_ENUM_FIELD(jointype, JoinType);
     823      198958 :     WRITE_BOOL_FIELD(isNatural);
     824      198958 :     WRITE_NODE_FIELD(larg);
     825      198958 :     WRITE_NODE_FIELD(rarg);
     826      198958 :     WRITE_NODE_FIELD(usingClause);
     827      198958 :     WRITE_NODE_FIELD(join_using_alias);
     828      198958 :     WRITE_NODE_FIELD(quals);
     829      198958 :     WRITE_NODE_FIELD(alias);
     830      198958 :     WRITE_INT_FIELD(rtindex);
     831      198958 : }
     832             : 
     833             : static void
     834      593884 : _outFromExpr(StringInfo str, const FromExpr *node)
     835             : {
     836      593884 :     WRITE_NODE_TYPE("FROMEXPR");
     837             : 
     838      593884 :     WRITE_NODE_FIELD(fromlist);
     839      593884 :     WRITE_NODE_FIELD(quals);
     840      593884 : }
     841             : 
     842             : static void
     843        1818 : _outOnConflictExpr(StringInfo str, const OnConflictExpr *node)
     844             : {
     845        1818 :     WRITE_NODE_TYPE("ONCONFLICTEXPR");
     846             : 
     847        1818 :     WRITE_ENUM_FIELD(action, OnConflictAction);
     848        1818 :     WRITE_NODE_FIELD(arbiterElems);
     849        1818 :     WRITE_NODE_FIELD(arbiterWhere);
     850        1818 :     WRITE_OID_FIELD(constraint);
     851        1818 :     WRITE_NODE_FIELD(onConflictSet);
     852        1818 :     WRITE_NODE_FIELD(onConflictWhere);
     853        1818 :     WRITE_INT_FIELD(exclRelIndex);
     854        1818 :     WRITE_NODE_FIELD(exclRelTlist);
     855        1818 : }
     856             : 
     857             : static void
     858      991680 : _outQuery(StringInfo str, const Query *node)
     859             : {
     860      991680 :     WRITE_NODE_TYPE("QUERY");
     861             : 
     862      991680 :     WRITE_ENUM_FIELD(commandType, CmdType);
     863      991680 :     WRITE_ENUM_FIELD(querySource, QuerySource);
     864      991680 :     WRITE_BOOL_FIELD(canSetTag);
     865      991680 :     WRITE_NODE_FIELD(utilityStmt);
     866      991680 :     WRITE_INT_FIELD(resultRelation);
     867      991680 :     WRITE_BOOL_FIELD(hasAggs);
     868      991680 :     WRITE_BOOL_FIELD(hasWindowFuncs);
     869      991680 :     WRITE_BOOL_FIELD(hasTargetSRFs);
     870      991680 :     WRITE_BOOL_FIELD(hasSubLinks);
     871      991680 :     WRITE_BOOL_FIELD(hasDistinctOn);
     872      991680 :     WRITE_BOOL_FIELD(hasRecursive);
     873      991680 :     WRITE_BOOL_FIELD(hasModifyingCTE);
     874      991680 :     WRITE_BOOL_FIELD(hasForUpdate);
     875      991680 :     WRITE_BOOL_FIELD(hasRowSecurity);
     876      991680 :     WRITE_BOOL_FIELD(hasGroupRTE);
     877      991680 :     WRITE_BOOL_FIELD(isReturn);
     878      991680 :     WRITE_NODE_FIELD(cteList);
     879      991680 :     WRITE_NODE_FIELD(rtable);
     880      991680 :     WRITE_NODE_FIELD(rteperminfos);
     881      991680 :     WRITE_NODE_FIELD(jointree);
     882      991680 :     WRITE_NODE_FIELD(mergeActionList);
     883      991680 :     WRITE_INT_FIELD(mergeTargetRelation);
     884      991680 :     WRITE_NODE_FIELD(mergeJoinCondition);
     885      991680 :     WRITE_NODE_FIELD(targetList);
     886      991680 :     WRITE_ENUM_FIELD(override, OverridingKind);
     887      991680 :     WRITE_NODE_FIELD(onConflict);
     888      991680 :     WRITE_STRING_FIELD(returningOldAlias);
     889      991680 :     WRITE_STRING_FIELD(returningNewAlias);
     890      991680 :     WRITE_NODE_FIELD(returningList);
     891      991680 :     WRITE_NODE_FIELD(groupClause);
     892      991680 :     WRITE_BOOL_FIELD(groupDistinct);
     893      991680 :     WRITE_NODE_FIELD(groupingSets);
     894      991680 :     WRITE_NODE_FIELD(havingQual);
     895      991680 :     WRITE_NODE_FIELD(windowClause);
     896      991680 :     WRITE_NODE_FIELD(distinctClause);
     897      991680 :     WRITE_NODE_FIELD(sortClause);
     898      991680 :     WRITE_NODE_FIELD(limitOffset);
     899      991680 :     WRITE_NODE_FIELD(limitCount);
     900      991680 :     WRITE_ENUM_FIELD(limitOption, LimitOption);
     901      991680 :     WRITE_NODE_FIELD(rowMarks);
     902      991680 :     WRITE_NODE_FIELD(setOperations);
     903      991680 :     WRITE_NODE_FIELD(constraintDeps);
     904      991680 :     WRITE_NODE_FIELD(withCheckOptions);
     905      991680 :     WRITE_LOCATION_FIELD(stmt_location);
     906      991680 :     WRITE_LOCATION_FIELD(stmt_len);
     907      991680 : }
     908             : 
     909             : static void
     910      827568 : _outTypeName(StringInfo str, const TypeName *node)
     911             : {
     912      827568 :     WRITE_NODE_TYPE("TYPENAME");
     913             : 
     914      827568 :     WRITE_NODE_FIELD(names);
     915      827568 :     WRITE_OID_FIELD(typeOid);
     916      827568 :     WRITE_BOOL_FIELD(setof);
     917      827568 :     WRITE_BOOL_FIELD(pct_type);
     918      827568 :     WRITE_NODE_FIELD(typmods);
     919      827568 :     WRITE_INT_FIELD(typemod);
     920      827568 :     WRITE_NODE_FIELD(arrayBounds);
     921      827568 :     WRITE_LOCATION_FIELD(location);
     922      827568 : }
     923             : 
     924             : static void
     925     2116000 : _outColumnRef(StringInfo str, const ColumnRef *node)
     926             : {
     927     2116000 :     WRITE_NODE_TYPE("COLUMNREF");
     928             : 
     929     2116000 :     WRITE_NODE_FIELD(fields);
     930     2116000 :     WRITE_LOCATION_FIELD(location);
     931     2116000 : }
     932             : 
     933             : static void
     934       53932 : _outParamRef(StringInfo str, const ParamRef *node)
     935             : {
     936       53932 :     WRITE_NODE_TYPE("PARAMREF");
     937             : 
     938       53932 :     WRITE_INT_FIELD(number);
     939       53932 :     WRITE_LOCATION_FIELD(location);
     940       53932 : }
     941             : 
     942             : static void
     943      376640 : _outTypeCast(StringInfo str, const TypeCast *node)
     944             : {
     945      376640 :     WRITE_NODE_TYPE("TYPECAST");
     946             : 
     947      376640 :     WRITE_NODE_FIELD(arg);
     948      376640 :     WRITE_NODE_FIELD(typeName);
     949      376640 :     WRITE_LOCATION_FIELD(location);
     950      376640 : }
     951             : 
     952             : static void
     953       10632 : _outCollateClause(StringInfo str, const CollateClause *node)
     954             : {
     955       10632 :     WRITE_NODE_TYPE("COLLATECLAUSE");
     956             : 
     957       10632 :     WRITE_NODE_FIELD(arg);
     958       10632 :     WRITE_NODE_FIELD(collname);
     959       10632 :     WRITE_LOCATION_FIELD(location);
     960       10632 : }
     961             : 
     962             : static void
     963       63972 : _outRoleSpec(StringInfo str, const RoleSpec *node)
     964             : {
     965       63972 :     WRITE_NODE_TYPE("ROLESPEC");
     966             : 
     967       63972 :     WRITE_ENUM_FIELD(roletype, RoleSpecType);
     968       63972 :     WRITE_STRING_FIELD(rolename);
     969       63972 :     WRITE_LOCATION_FIELD(location);
     970       63972 : }
     971             : 
     972             : static void
     973      410938 : _outFuncCall(StringInfo str, const FuncCall *node)
     974             : {
     975      410938 :     WRITE_NODE_TYPE("FUNCCALL");
     976             : 
     977      410938 :     WRITE_NODE_FIELD(funcname);
     978      410938 :     WRITE_NODE_FIELD(args);
     979      410938 :     WRITE_NODE_FIELD(agg_order);
     980      410938 :     WRITE_NODE_FIELD(agg_filter);
     981      410938 :     WRITE_NODE_FIELD(over);
     982      410938 :     WRITE_BOOL_FIELD(agg_within_group);
     983      410938 :     WRITE_BOOL_FIELD(agg_star);
     984      410938 :     WRITE_BOOL_FIELD(agg_distinct);
     985      410938 :     WRITE_BOOL_FIELD(func_variadic);
     986      410938 :     WRITE_ENUM_FIELD(funcformat, CoercionForm);
     987      410938 :     WRITE_LOCATION_FIELD(location);
     988      410938 : }
     989             : 
     990             : static void
     991       64240 : _outA_Star(StringInfo str, const A_Star *node)
     992             : {
     993       64240 :     WRITE_NODE_TYPE("A_STAR");
     994             : 
     995       64240 : }
     996             : 
     997             : static void
     998       15164 : _outA_Indices(StringInfo str, const A_Indices *node)
     999             : {
    1000       15164 :     WRITE_NODE_TYPE("A_INDICES");
    1001             : 
    1002       15164 :     WRITE_BOOL_FIELD(is_slice);
    1003       15164 :     WRITE_NODE_FIELD(lidx);
    1004       15164 :     WRITE_NODE_FIELD(uidx);
    1005       15164 : }
    1006             : 
    1007             : static void
    1008       35206 : _outA_Indirection(StringInfo str, const A_Indirection *node)
    1009             : {
    1010       35206 :     WRITE_NODE_TYPE("A_INDIRECTION");
    1011             : 
    1012       35206 :     WRITE_NODE_FIELD(arg);
    1013       35206 :     WRITE_NODE_FIELD(indirection);
    1014       35206 : }
    1015             : 
    1016             : static void
    1017        7018 : _outA_ArrayExpr(StringInfo str, const A_ArrayExpr *node)
    1018             : {
    1019        7018 :     WRITE_NODE_TYPE("A_ARRAYEXPR");
    1020             : 
    1021        7018 :     WRITE_NODE_FIELD(elements);
    1022        7018 :     WRITE_LOCATION_FIELD(location);
    1023        7018 : }
    1024             : 
    1025             : static void
    1026     1338306 : _outResTarget(StringInfo str, const ResTarget *node)
    1027             : {
    1028     1338306 :     WRITE_NODE_TYPE("RESTARGET");
    1029             : 
    1030     1338306 :     WRITE_STRING_FIELD(name);
    1031     1338306 :     WRITE_NODE_FIELD(indirection);
    1032     1338306 :     WRITE_NODE_FIELD(val);
    1033     1338306 :     WRITE_LOCATION_FIELD(location);
    1034     1338306 : }
    1035             : 
    1036             : static void
    1037         402 : _outMultiAssignRef(StringInfo str, const MultiAssignRef *node)
    1038             : {
    1039         402 :     WRITE_NODE_TYPE("MULTIASSIGNREF");
    1040             : 
    1041         402 :     WRITE_NODE_FIELD(source);
    1042         402 :     WRITE_INT_FIELD(colno);
    1043         402 :     WRITE_INT_FIELD(ncolumns);
    1044         402 : }
    1045             : 
    1046             : static void
    1047      112950 : _outSortBy(StringInfo str, const SortBy *node)
    1048             : {
    1049      112950 :     WRITE_NODE_TYPE("SORTBY");
    1050             : 
    1051      112950 :     WRITE_NODE_FIELD(node);
    1052      112950 :     WRITE_ENUM_FIELD(sortby_dir, SortByDir);
    1053      112950 :     WRITE_ENUM_FIELD(sortby_nulls, SortByNulls);
    1054      112950 :     WRITE_NODE_FIELD(useOp);
    1055      112950 :     WRITE_LOCATION_FIELD(location);
    1056      112950 : }
    1057             : 
    1058             : static void
    1059        4172 : _outWindowDef(StringInfo str, const WindowDef *node)
    1060             : {
    1061        4172 :     WRITE_NODE_TYPE("WINDOWDEF");
    1062             : 
    1063        4172 :     WRITE_STRING_FIELD(name);
    1064        4172 :     WRITE_STRING_FIELD(refname);
    1065        4172 :     WRITE_NODE_FIELD(partitionClause);
    1066        4172 :     WRITE_NODE_FIELD(orderClause);
    1067        4172 :     WRITE_INT_FIELD(frameOptions);
    1068        4172 :     WRITE_NODE_FIELD(startOffset);
    1069        4172 :     WRITE_NODE_FIELD(endOffset);
    1070        4172 :     WRITE_LOCATION_FIELD(location);
    1071        4172 : }
    1072             : 
    1073             : static void
    1074       18600 : _outRangeSubselect(StringInfo str, const RangeSubselect *node)
    1075             : {
    1076       18600 :     WRITE_NODE_TYPE("RANGESUBSELECT");
    1077             : 
    1078       18600 :     WRITE_BOOL_FIELD(lateral);
    1079       18600 :     WRITE_NODE_FIELD(subquery);
    1080       18600 :     WRITE_NODE_FIELD(alias);
    1081       18600 : }
    1082             : 
    1083             : static void
    1084       53086 : _outRangeFunction(StringInfo str, const RangeFunction *node)
    1085             : {
    1086       53086 :     WRITE_NODE_TYPE("RANGEFUNCTION");
    1087             : 
    1088       53086 :     WRITE_BOOL_FIELD(lateral);
    1089       53086 :     WRITE_BOOL_FIELD(ordinality);
    1090       53086 :     WRITE_BOOL_FIELD(is_rowsfrom);
    1091       53086 :     WRITE_NODE_FIELD(functions);
    1092       53086 :     WRITE_NODE_FIELD(alias);
    1093       53086 :     WRITE_NODE_FIELD(coldeflist);
    1094       53086 : }
    1095             : 
    1096             : static void
    1097         250 : _outRangeTableFunc(StringInfo str, const RangeTableFunc *node)
    1098             : {
    1099         250 :     WRITE_NODE_TYPE("RANGETABLEFUNC");
    1100             : 
    1101         250 :     WRITE_BOOL_FIELD(lateral);
    1102         250 :     WRITE_NODE_FIELD(docexpr);
    1103         250 :     WRITE_NODE_FIELD(rowexpr);
    1104         250 :     WRITE_NODE_FIELD(namespaces);
    1105         250 :     WRITE_NODE_FIELD(columns);
    1106         250 :     WRITE_NODE_FIELD(alias);
    1107         250 :     WRITE_LOCATION_FIELD(location);
    1108         250 : }
    1109             : 
    1110             : static void
    1111         906 : _outRangeTableFuncCol(StringInfo str, const RangeTableFuncCol *node)
    1112             : {
    1113         906 :     WRITE_NODE_TYPE("RANGETABLEFUNCCOL");
    1114             : 
    1115         906 :     WRITE_STRING_FIELD(colname);
    1116         906 :     WRITE_NODE_FIELD(typeName);
    1117         906 :     WRITE_BOOL_FIELD(for_ordinality);
    1118         906 :     WRITE_BOOL_FIELD(is_not_null);
    1119         906 :     WRITE_NODE_FIELD(colexpr);
    1120         906 :     WRITE_NODE_FIELD(coldefexpr);
    1121         906 :     WRITE_LOCATION_FIELD(location);
    1122         906 : }
    1123             : 
    1124             : static void
    1125         288 : _outRangeTableSample(StringInfo str, const RangeTableSample *node)
    1126             : {
    1127         288 :     WRITE_NODE_TYPE("RANGETABLESAMPLE");
    1128             : 
    1129         288 :     WRITE_NODE_FIELD(relation);
    1130         288 :     WRITE_NODE_FIELD(method);
    1131         288 :     WRITE_NODE_FIELD(args);
    1132         288 :     WRITE_NODE_FIELD(repeatable);
    1133         288 :     WRITE_LOCATION_FIELD(location);
    1134         288 : }
    1135             : 
    1136             : static void
    1137      152702 : _outColumnDef(StringInfo str, const ColumnDef *node)
    1138             : {
    1139      152702 :     WRITE_NODE_TYPE("COLUMNDEF");
    1140             : 
    1141      152702 :     WRITE_STRING_FIELD(colname);
    1142      152702 :     WRITE_NODE_FIELD(typeName);
    1143      152702 :     WRITE_STRING_FIELD(compression);
    1144      152702 :     WRITE_INT_FIELD(inhcount);
    1145      152702 :     WRITE_BOOL_FIELD(is_local);
    1146      152702 :     WRITE_BOOL_FIELD(is_not_null);
    1147      152702 :     WRITE_BOOL_FIELD(is_from_type);
    1148      152702 :     WRITE_CHAR_FIELD(storage);
    1149      152702 :     WRITE_STRING_FIELD(storage_name);
    1150      152702 :     WRITE_NODE_FIELD(raw_default);
    1151      152702 :     WRITE_NODE_FIELD(cooked_default);
    1152      152702 :     WRITE_CHAR_FIELD(identity);
    1153      152702 :     WRITE_NODE_FIELD(identitySequence);
    1154      152702 :     WRITE_CHAR_FIELD(generated);
    1155      152702 :     WRITE_NODE_FIELD(collClause);
    1156      152702 :     WRITE_OID_FIELD(collOid);
    1157      152702 :     WRITE_NODE_FIELD(constraints);
    1158      152702 :     WRITE_NODE_FIELD(fdwoptions);
    1159      152702 :     WRITE_LOCATION_FIELD(location);
    1160      152702 : }
    1161             : 
    1162             : static void
    1163        1548 : _outTableLikeClause(StringInfo str, const TableLikeClause *node)
    1164             : {
    1165        1548 :     WRITE_NODE_TYPE("TABLELIKECLAUSE");
    1166             : 
    1167        1548 :     WRITE_NODE_FIELD(relation);
    1168        1548 :     WRITE_UINT_FIELD(options);
    1169        1548 :     WRITE_OID_FIELD(relationOid);
    1170        1548 : }
    1171             : 
    1172             : static void
    1173       20224 : _outIndexElem(StringInfo str, const IndexElem *node)
    1174             : {
    1175       20224 :     WRITE_NODE_TYPE("INDEXELEM");
    1176             : 
    1177       20224 :     WRITE_STRING_FIELD(name);
    1178       20224 :     WRITE_NODE_FIELD(expr);
    1179       20224 :     WRITE_STRING_FIELD(indexcolname);
    1180       20224 :     WRITE_NODE_FIELD(collation);
    1181       20224 :     WRITE_NODE_FIELD(opclass);
    1182       20224 :     WRITE_NODE_FIELD(opclassopts);
    1183       20224 :     WRITE_ENUM_FIELD(ordering, SortByDir);
    1184       20224 :     WRITE_ENUM_FIELD(nulls_ordering, SortByNulls);
    1185       20224 : }
    1186             : 
    1187             : static void
    1188      348394 : _outDefElem(StringInfo str, const DefElem *node)
    1189             : {
    1190      348394 :     WRITE_NODE_TYPE("DEFELEM");
    1191             : 
    1192      348394 :     WRITE_STRING_FIELD(defnamespace);
    1193      348394 :     WRITE_STRING_FIELD(defname);
    1194      348394 :     WRITE_NODE_FIELD(arg);
    1195      348394 :     WRITE_ENUM_FIELD(defaction, DefElemAction);
    1196      348394 :     WRITE_LOCATION_FIELD(location);
    1197      348394 : }
    1198             : 
    1199             : static void
    1200        2178 : _outLockingClause(StringInfo str, const LockingClause *node)
    1201             : {
    1202        2178 :     WRITE_NODE_TYPE("LOCKINGCLAUSE");
    1203             : 
    1204        2178 :     WRITE_NODE_FIELD(lockedRels);
    1205        2178 :     WRITE_ENUM_FIELD(strength, LockClauseStrength);
    1206        2178 :     WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
    1207        2178 : }
    1208             : 
    1209             : static void
    1210         266 : _outXmlSerialize(StringInfo str, const XmlSerialize *node)
    1211             : {
    1212         266 :     WRITE_NODE_TYPE("XMLSERIALIZE");
    1213             : 
    1214         266 :     WRITE_ENUM_FIELD(xmloption, XmlOptionType);
    1215         266 :     WRITE_NODE_FIELD(expr);
    1216         266 :     WRITE_NODE_FIELD(typeName);
    1217         266 :     WRITE_BOOL_FIELD(indent);
    1218         266 :     WRITE_LOCATION_FIELD(location);
    1219         266 : }
    1220             : 
    1221             : static void
    1222       11224 : _outPartitionElem(StringInfo str, const PartitionElem *node)
    1223             : {
    1224       11224 :     WRITE_NODE_TYPE("PARTITIONELEM");
    1225             : 
    1226       11224 :     WRITE_STRING_FIELD(name);
    1227       11224 :     WRITE_NODE_FIELD(expr);
    1228       11224 :     WRITE_NODE_FIELD(collation);
    1229       11224 :     WRITE_NODE_FIELD(opclass);
    1230       11224 :     WRITE_LOCATION_FIELD(location);
    1231       11224 : }
    1232             : 
    1233             : static void
    1234       10292 : _outPartitionSpec(StringInfo str, const PartitionSpec *node)
    1235             : {
    1236       10292 :     WRITE_NODE_TYPE("PARTITIONSPEC");
    1237             : 
    1238       10292 :     WRITE_ENUM_FIELD(strategy, PartitionStrategy);
    1239       10292 :     WRITE_NODE_FIELD(partParams);
    1240       10292 :     WRITE_LOCATION_FIELD(location);
    1241       10292 : }
    1242             : 
    1243             : static void
    1244       31644 : _outPartitionBoundSpec(StringInfo str, const PartitionBoundSpec *node)
    1245             : {
    1246       31644 :     WRITE_NODE_TYPE("PARTITIONBOUNDSPEC");
    1247             : 
    1248       31644 :     WRITE_CHAR_FIELD(strategy);
    1249       31644 :     WRITE_BOOL_FIELD(is_default);
    1250       31644 :     WRITE_INT_FIELD(modulus);
    1251       31644 :     WRITE_INT_FIELD(remainder);
    1252       31644 :     WRITE_NODE_FIELD(listdatums);
    1253       31644 :     WRITE_NODE_FIELD(lowerdatums);
    1254       31644 :     WRITE_NODE_FIELD(upperdatums);
    1255       31644 :     WRITE_LOCATION_FIELD(location);
    1256       31644 : }
    1257             : 
    1258             : static void
    1259       10124 : _outPartitionRangeDatum(StringInfo str, const PartitionRangeDatum *node)
    1260             : {
    1261       10124 :     WRITE_NODE_TYPE("PARTITIONRANGEDATUM");
    1262             : 
    1263       10124 :     WRITE_ENUM_FIELD(kind, PartitionRangeDatumKind);
    1264       10124 :     WRITE_NODE_FIELD(value);
    1265       10124 :     WRITE_LOCATION_FIELD(location);
    1266       10124 : }
    1267             : 
    1268             : static void
    1269        7850 : _outPartitionCmd(StringInfo str, const PartitionCmd *node)
    1270             : {
    1271        7850 :     WRITE_NODE_TYPE("PARTITIONCMD");
    1272             : 
    1273        7850 :     WRITE_NODE_FIELD(name);
    1274        7850 :     WRITE_NODE_FIELD(bound);
    1275        7850 :     WRITE_BOOL_FIELD(concurrent);
    1276        7850 : }
    1277             : 
    1278             : static void
    1279     1003564 : _outRTEPermissionInfo(StringInfo str, const RTEPermissionInfo *node)
    1280             : {
    1281     1003564 :     WRITE_NODE_TYPE("RTEPERMISSIONINFO");
    1282             : 
    1283     1003564 :     WRITE_OID_FIELD(relid);
    1284     1003564 :     WRITE_BOOL_FIELD(inh);
    1285     1003564 :     WRITE_UINT64_FIELD(requiredPerms);
    1286     1003564 :     WRITE_OID_FIELD(checkAsUser);
    1287     1003564 :     WRITE_BITMAPSET_FIELD(selectedCols);
    1288     1003564 :     WRITE_BITMAPSET_FIELD(insertedCols);
    1289     1003564 :     WRITE_BITMAPSET_FIELD(updatedCols);
    1290     1003564 : }
    1291             : 
    1292             : static void
    1293      108386 : _outRangeTblFunction(StringInfo str, const RangeTblFunction *node)
    1294             : {
    1295      108386 :     WRITE_NODE_TYPE("RANGETBLFUNCTION");
    1296             : 
    1297      108386 :     WRITE_NODE_FIELD(funcexpr);
    1298      108386 :     WRITE_INT_FIELD(funccolcount);
    1299      108386 :     WRITE_NODE_FIELD(funccolnames);
    1300      108386 :     WRITE_NODE_FIELD(funccoltypes);
    1301      108386 :     WRITE_NODE_FIELD(funccoltypmods);
    1302      108386 :     WRITE_NODE_FIELD(funccolcollations);
    1303      108386 :     WRITE_BITMAPSET_FIELD(funcparams);
    1304      108386 : }
    1305             : 
    1306             : static void
    1307         550 : _outTableSampleClause(StringInfo str, const TableSampleClause *node)
    1308             : {
    1309         550 :     WRITE_NODE_TYPE("TABLESAMPLECLAUSE");
    1310             : 
    1311         550 :     WRITE_OID_FIELD(tsmhandler);
    1312         550 :     WRITE_NODE_FIELD(args);
    1313         550 :     WRITE_NODE_FIELD(repeatable);
    1314         550 : }
    1315             : 
    1316             : static void
    1317        4842 : _outWithCheckOption(StringInfo str, const WithCheckOption *node)
    1318             : {
    1319        4842 :     WRITE_NODE_TYPE("WITHCHECKOPTION");
    1320             : 
    1321        4842 :     WRITE_ENUM_FIELD(kind, WCOKind);
    1322        4842 :     WRITE_STRING_FIELD(relname);
    1323        4842 :     WRITE_STRING_FIELD(polname);
    1324        4842 :     WRITE_NODE_FIELD(qual);
    1325        4842 :     WRITE_BOOL_FIELD(cascaded);
    1326        4842 : }
    1327             : 
    1328             : static void
    1329      163760 : _outSortGroupClause(StringInfo str, const SortGroupClause *node)
    1330             : {
    1331      163760 :     WRITE_NODE_TYPE("SORTGROUPCLAUSE");
    1332             : 
    1333      163760 :     WRITE_UINT_FIELD(tleSortGroupRef);
    1334      163760 :     WRITE_OID_FIELD(eqop);
    1335      163760 :     WRITE_OID_FIELD(sortop);
    1336      163760 :     WRITE_BOOL_FIELD(reverse_sort);
    1337      163760 :     WRITE_BOOL_FIELD(nulls_first);
    1338      163760 :     WRITE_BOOL_FIELD(hashable);
    1339      163760 : }
    1340             : 
    1341             : static void
    1342        4246 : _outGroupingSet(StringInfo str, const GroupingSet *node)
    1343             : {
    1344        4246 :     WRITE_NODE_TYPE("GROUPINGSET");
    1345             : 
    1346        4246 :     WRITE_ENUM_FIELD(kind, GroupingSetKind);
    1347        4246 :     WRITE_NODE_FIELD(content);
    1348        4246 :     WRITE_LOCATION_FIELD(location);
    1349        4246 : }
    1350             : 
    1351             : static void
    1352        2802 : _outWindowClause(StringInfo str, const WindowClause *node)
    1353             : {
    1354        2802 :     WRITE_NODE_TYPE("WINDOWCLAUSE");
    1355             : 
    1356        2802 :     WRITE_STRING_FIELD(name);
    1357        2802 :     WRITE_STRING_FIELD(refname);
    1358        2802 :     WRITE_NODE_FIELD(partitionClause);
    1359        2802 :     WRITE_NODE_FIELD(orderClause);
    1360        2802 :     WRITE_INT_FIELD(frameOptions);
    1361        2802 :     WRITE_NODE_FIELD(startOffset);
    1362        2802 :     WRITE_NODE_FIELD(endOffset);
    1363        2802 :     WRITE_OID_FIELD(startInRangeFunc);
    1364        2802 :     WRITE_OID_FIELD(endInRangeFunc);
    1365        2802 :     WRITE_OID_FIELD(inRangeColl);
    1366        2802 :     WRITE_BOOL_FIELD(inRangeAsc);
    1367        2802 :     WRITE_BOOL_FIELD(inRangeNullsFirst);
    1368        2802 :     WRITE_UINT_FIELD(winref);
    1369        2802 :     WRITE_BOOL_FIELD(copiedOrder);
    1370        2802 : }
    1371             : 
    1372             : static void
    1373        5388 : _outRowMarkClause(StringInfo str, const RowMarkClause *node)
    1374             : {
    1375        5388 :     WRITE_NODE_TYPE("ROWMARKCLAUSE");
    1376             : 
    1377        5388 :     WRITE_UINT_FIELD(rti);
    1378        5388 :     WRITE_ENUM_FIELD(strength, LockClauseStrength);
    1379        5388 :     WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
    1380        5388 :     WRITE_BOOL_FIELD(pushedDown);
    1381        5388 : }
    1382             : 
    1383             : static void
    1384        3382 : _outWithClause(StringInfo str, const WithClause *node)
    1385             : {
    1386        3382 :     WRITE_NODE_TYPE("WITHCLAUSE");
    1387             : 
    1388        3382 :     WRITE_NODE_FIELD(ctes);
    1389        3382 :     WRITE_BOOL_FIELD(recursive);
    1390        3382 :     WRITE_LOCATION_FIELD(location);
    1391        3382 : }
    1392             : 
    1393             : static void
    1394        1632 : _outInferClause(StringInfo str, const InferClause *node)
    1395             : {
    1396        1632 :     WRITE_NODE_TYPE("INFERCLAUSE");
    1397             : 
    1398        1632 :     WRITE_NODE_FIELD(indexElems);
    1399        1632 :     WRITE_NODE_FIELD(whereClause);
    1400        1632 :     WRITE_STRING_FIELD(conname);
    1401        1632 :     WRITE_LOCATION_FIELD(location);
    1402        1632 : }
    1403             : 
    1404             : static void
    1405        1872 : _outOnConflictClause(StringInfo str, const OnConflictClause *node)
    1406             : {
    1407        1872 :     WRITE_NODE_TYPE("ONCONFLICTCLAUSE");
    1408             : 
    1409        1872 :     WRITE_ENUM_FIELD(action, OnConflictAction);
    1410        1872 :     WRITE_NODE_FIELD(infer);
    1411        1872 :     WRITE_NODE_FIELD(targetList);
    1412        1872 :     WRITE_NODE_FIELD(whereClause);
    1413        1872 :     WRITE_LOCATION_FIELD(location);
    1414        1872 : }
    1415             : 
    1416             : static void
    1417         216 : _outCTESearchClause(StringInfo str, const CTESearchClause *node)
    1418             : {
    1419         216 :     WRITE_NODE_TYPE("CTESEARCHCLAUSE");
    1420             : 
    1421         216 :     WRITE_NODE_FIELD(search_col_list);
    1422         216 :     WRITE_BOOL_FIELD(search_breadth_first);
    1423         216 :     WRITE_STRING_FIELD(search_seq_column);
    1424         216 :     WRITE_LOCATION_FIELD(location);
    1425         216 : }
    1426             : 
    1427             : static void
    1428         222 : _outCTECycleClause(StringInfo str, const CTECycleClause *node)
    1429             : {
    1430         222 :     WRITE_NODE_TYPE("CTECYCLECLAUSE");
    1431             : 
    1432         222 :     WRITE_NODE_FIELD(cycle_col_list);
    1433         222 :     WRITE_STRING_FIELD(cycle_mark_column);
    1434         222 :     WRITE_NODE_FIELD(cycle_mark_value);
    1435         222 :     WRITE_NODE_FIELD(cycle_mark_default);
    1436         222 :     WRITE_STRING_FIELD(cycle_path_column);
    1437         222 :     WRITE_LOCATION_FIELD(location);
    1438         222 :     WRITE_OID_FIELD(cycle_mark_type);
    1439         222 :     WRITE_INT_FIELD(cycle_mark_typmod);
    1440         222 :     WRITE_OID_FIELD(cycle_mark_collation);
    1441         222 :     WRITE_OID_FIELD(cycle_mark_neop);
    1442         222 : }
    1443             : 
    1444             : static void
    1445        8748 : _outCommonTableExpr(StringInfo str, const CommonTableExpr *node)
    1446             : {
    1447        8748 :     WRITE_NODE_TYPE("COMMONTABLEEXPR");
    1448             : 
    1449        8748 :     WRITE_STRING_FIELD(ctename);
    1450        8748 :     WRITE_NODE_FIELD(aliascolnames);
    1451        8748 :     WRITE_ENUM_FIELD(ctematerialized, CTEMaterialize);
    1452        8748 :     WRITE_NODE_FIELD(ctequery);
    1453        8748 :     WRITE_NODE_FIELD(search_clause);
    1454        8748 :     WRITE_NODE_FIELD(cycle_clause);
    1455        8748 :     WRITE_LOCATION_FIELD(location);
    1456        8748 :     WRITE_BOOL_FIELD(cterecursive);
    1457        8748 :     WRITE_INT_FIELD(cterefcount);
    1458        8748 :     WRITE_NODE_FIELD(ctecolnames);
    1459        8748 :     WRITE_NODE_FIELD(ctecoltypes);
    1460        8748 :     WRITE_NODE_FIELD(ctecoltypmods);
    1461        8748 :     WRITE_NODE_FIELD(ctecolcollations);
    1462        8748 : }
    1463             : 
    1464             : static void
    1465        3014 : _outMergeWhenClause(StringInfo str, const MergeWhenClause *node)
    1466             : {
    1467        3014 :     WRITE_NODE_TYPE("MERGEWHENCLAUSE");
    1468             : 
    1469        3014 :     WRITE_ENUM_FIELD(matchKind, MergeMatchKind);
    1470        3014 :     WRITE_ENUM_FIELD(commandType, CmdType);
    1471        3014 :     WRITE_ENUM_FIELD(override, OverridingKind);
    1472        3014 :     WRITE_NODE_FIELD(condition);
    1473        3014 :     WRITE_NODE_FIELD(targetList);
    1474        3014 :     WRITE_NODE_FIELD(values);
    1475        3014 : }
    1476             : 
    1477             : static void
    1478         150 : _outReturningOption(StringInfo str, const ReturningOption *node)
    1479             : {
    1480         150 :     WRITE_NODE_TYPE("RETURNINGOPTION");
    1481             : 
    1482         150 :     WRITE_ENUM_FIELD(option, ReturningOptionKind);
    1483         150 :     WRITE_STRING_FIELD(value);
    1484         150 :     WRITE_LOCATION_FIELD(location);
    1485         150 : }
    1486             : 
    1487             : static void
    1488        3316 : _outReturningClause(StringInfo str, const ReturningClause *node)
    1489             : {
    1490        3316 :     WRITE_NODE_TYPE("RETURNINGCLAUSE");
    1491             : 
    1492        3316 :     WRITE_NODE_FIELD(options);
    1493        3316 :     WRITE_NODE_FIELD(exprs);
    1494        3316 : }
    1495             : 
    1496             : static void
    1497        1228 : _outTriggerTransition(StringInfo str, const TriggerTransition *node)
    1498             : {
    1499        1228 :     WRITE_NODE_TYPE("TRIGGERTRANSITION");
    1500             : 
    1501        1228 :     WRITE_STRING_FIELD(name);
    1502        1228 :     WRITE_BOOL_FIELD(isNew);
    1503        1228 :     WRITE_BOOL_FIELD(isTable);
    1504        1228 : }
    1505             : 
    1506             : static void
    1507        1486 : _outJsonOutput(StringInfo str, const JsonOutput *node)
    1508             : {
    1509        1486 :     WRITE_NODE_TYPE("JSONOUTPUT");
    1510             : 
    1511        1486 :     WRITE_NODE_FIELD(typeName);
    1512        1486 :     WRITE_NODE_FIELD(returning);
    1513        1486 : }
    1514             : 
    1515             : static void
    1516         630 : _outJsonArgument(StringInfo str, const JsonArgument *node)
    1517             : {
    1518         630 :     WRITE_NODE_TYPE("JSONARGUMENT");
    1519             : 
    1520         630 :     WRITE_NODE_FIELD(val);
    1521         630 :     WRITE_STRING_FIELD(name);
    1522         630 : }
    1523             : 
    1524             : static void
    1525        1992 : _outJsonFuncExpr(StringInfo str, const JsonFuncExpr *node)
    1526             : {
    1527        1992 :     WRITE_NODE_TYPE("JSONFUNCEXPR");
    1528             : 
    1529        1992 :     WRITE_ENUM_FIELD(op, JsonExprOp);
    1530        1992 :     WRITE_STRING_FIELD(column_name);
    1531        1992 :     WRITE_NODE_FIELD(context_item);
    1532        1992 :     WRITE_NODE_FIELD(pathspec);
    1533        1992 :     WRITE_NODE_FIELD(passing);
    1534        1992 :     WRITE_NODE_FIELD(output);
    1535        1992 :     WRITE_NODE_FIELD(on_empty);
    1536        1992 :     WRITE_NODE_FIELD(on_error);
    1537        1992 :     WRITE_ENUM_FIELD(wrapper, JsonWrapper);
    1538        1992 :     WRITE_ENUM_FIELD(quotes, JsonQuotes);
    1539        1992 :     WRITE_LOCATION_FIELD(location);
    1540        1992 : }
    1541             : 
    1542             : static void
    1543        1972 : _outJsonTablePathSpec(StringInfo str, const JsonTablePathSpec *node)
    1544             : {
    1545        1972 :     WRITE_NODE_TYPE("JSONTABLEPATHSPEC");
    1546             : 
    1547        1972 :     WRITE_NODE_FIELD(string);
    1548        1972 :     WRITE_STRING_FIELD(name);
    1549        1972 :     WRITE_LOCATION_FIELD(name_location);
    1550        1972 :     WRITE_LOCATION_FIELD(location);
    1551        1972 : }
    1552             : 
    1553             : static void
    1554         590 : _outJsonTable(StringInfo str, const JsonTable *node)
    1555             : {
    1556         590 :     WRITE_NODE_TYPE("JSONTABLE");
    1557             : 
    1558         590 :     WRITE_NODE_FIELD(context_item);
    1559         590 :     WRITE_NODE_FIELD(pathspec);
    1560         590 :     WRITE_NODE_FIELD(passing);
    1561         590 :     WRITE_NODE_FIELD(columns);
    1562         590 :     WRITE_NODE_FIELD(on_error);
    1563         590 :     WRITE_NODE_FIELD(alias);
    1564         590 :     WRITE_BOOL_FIELD(lateral);
    1565         590 :     WRITE_LOCATION_FIELD(location);
    1566         590 : }
    1567             : 
    1568             : static void
    1569        1648 : _outJsonTableColumn(StringInfo str, const JsonTableColumn *node)
    1570             : {
    1571        1648 :     WRITE_NODE_TYPE("JSONTABLECOLUMN");
    1572             : 
    1573        1648 :     WRITE_ENUM_FIELD(coltype, JsonTableColumnType);
    1574        1648 :     WRITE_STRING_FIELD(name);
    1575        1648 :     WRITE_NODE_FIELD(typeName);
    1576        1648 :     WRITE_NODE_FIELD(pathspec);
    1577        1648 :     WRITE_NODE_FIELD(format);
    1578        1648 :     WRITE_ENUM_FIELD(wrapper, JsonWrapper);
    1579        1648 :     WRITE_ENUM_FIELD(quotes, JsonQuotes);
    1580        1648 :     WRITE_NODE_FIELD(columns);
    1581        1648 :     WRITE_NODE_FIELD(on_empty);
    1582        1648 :     WRITE_NODE_FIELD(on_error);
    1583        1648 :     WRITE_LOCATION_FIELD(location);
    1584        1648 : }
    1585             : 
    1586             : static void
    1587         826 : _outJsonKeyValue(StringInfo str, const JsonKeyValue *node)
    1588             : {
    1589         826 :     WRITE_NODE_TYPE("JSONKEYVALUE");
    1590             : 
    1591         826 :     WRITE_NODE_FIELD(key);
    1592         826 :     WRITE_NODE_FIELD(value);
    1593         826 : }
    1594             : 
    1595             : static void
    1596         164 : _outJsonParseExpr(StringInfo str, const JsonParseExpr *node)
    1597             : {
    1598         164 :     WRITE_NODE_TYPE("JSONPARSEEXPR");
    1599             : 
    1600         164 :     WRITE_NODE_FIELD(expr);
    1601         164 :     WRITE_NODE_FIELD(output);
    1602         164 :     WRITE_BOOL_FIELD(unique_keys);
    1603         164 :     WRITE_LOCATION_FIELD(location);
    1604         164 : }
    1605             : 
    1606             : static void
    1607         112 : _outJsonScalarExpr(StringInfo str, const JsonScalarExpr *node)
    1608             : {
    1609         112 :     WRITE_NODE_TYPE("JSONSCALAREXPR");
    1610             : 
    1611         112 :     WRITE_NODE_FIELD(expr);
    1612         112 :     WRITE_NODE_FIELD(output);
    1613         112 :     WRITE_LOCATION_FIELD(location);
    1614         112 : }
    1615             : 
    1616             : static void
    1617         108 : _outJsonSerializeExpr(StringInfo str, const JsonSerializeExpr *node)
    1618             : {
    1619         108 :     WRITE_NODE_TYPE("JSONSERIALIZEEXPR");
    1620             : 
    1621         108 :     WRITE_NODE_FIELD(expr);
    1622         108 :     WRITE_NODE_FIELD(output);
    1623         108 :     WRITE_LOCATION_FIELD(location);
    1624         108 : }
    1625             : 
    1626             : static void
    1627         446 : _outJsonObjectConstructor(StringInfo str, const JsonObjectConstructor *node)
    1628             : {
    1629         446 :     WRITE_NODE_TYPE("JSONOBJECTCONSTRUCTOR");
    1630             : 
    1631         446 :     WRITE_NODE_FIELD(exprs);
    1632         446 :     WRITE_NODE_FIELD(output);
    1633         446 :     WRITE_BOOL_FIELD(absent_on_null);
    1634         446 :     WRITE_BOOL_FIELD(unique);
    1635         446 :     WRITE_LOCATION_FIELD(location);
    1636         446 : }
    1637             : 
    1638             : static void
    1639         200 : _outJsonArrayConstructor(StringInfo str, const JsonArrayConstructor *node)
    1640             : {
    1641         200 :     WRITE_NODE_TYPE("JSONARRAYCONSTRUCTOR");
    1642             : 
    1643         200 :     WRITE_NODE_FIELD(exprs);
    1644         200 :     WRITE_NODE_FIELD(output);
    1645         200 :     WRITE_BOOL_FIELD(absent_on_null);
    1646         200 :     WRITE_LOCATION_FIELD(location);
    1647         200 : }
    1648             : 
    1649             : static void
    1650          66 : _outJsonArrayQueryConstructor(StringInfo str, const JsonArrayQueryConstructor *node)
    1651             : {
    1652          66 :     WRITE_NODE_TYPE("JSONARRAYQUERYCONSTRUCTOR");
    1653             : 
    1654          66 :     WRITE_NODE_FIELD(query);
    1655          66 :     WRITE_NODE_FIELD(output);
    1656          66 :     WRITE_NODE_FIELD(format);
    1657          66 :     WRITE_BOOL_FIELD(absent_on_null);
    1658          66 :     WRITE_LOCATION_FIELD(location);
    1659          66 : }
    1660             : 
    1661             : static void
    1662         372 : _outJsonAggConstructor(StringInfo str, const JsonAggConstructor *node)
    1663             : {
    1664         372 :     WRITE_NODE_TYPE("JSONAGGCONSTRUCTOR");
    1665             : 
    1666         372 :     WRITE_NODE_FIELD(output);
    1667         372 :     WRITE_NODE_FIELD(agg_filter);
    1668         372 :     WRITE_NODE_FIELD(agg_order);
    1669         372 :     WRITE_NODE_FIELD(over);
    1670         372 :     WRITE_LOCATION_FIELD(location);
    1671         372 : }
    1672             : 
    1673             : static void
    1674         210 : _outJsonObjectAgg(StringInfo str, const JsonObjectAgg *node)
    1675             : {
    1676         210 :     WRITE_NODE_TYPE("JSONOBJECTAGG");
    1677             : 
    1678         210 :     WRITE_NODE_FIELD(constructor);
    1679         210 :     WRITE_NODE_FIELD(arg);
    1680         210 :     WRITE_BOOL_FIELD(absent_on_null);
    1681         210 :     WRITE_BOOL_FIELD(unique);
    1682         210 : }
    1683             : 
    1684             : static void
    1685         162 : _outJsonArrayAgg(StringInfo str, const JsonArrayAgg *node)
    1686             : {
    1687         162 :     WRITE_NODE_TYPE("JSONARRAYAGG");
    1688             : 
    1689         162 :     WRITE_NODE_FIELD(constructor);
    1690         162 :     WRITE_NODE_FIELD(arg);
    1691         162 :     WRITE_BOOL_FIELD(absent_on_null);
    1692         162 : }
    1693             : 
    1694             : static void
    1695      743868 : _outRawStmt(StringInfo str, const RawStmt *node)
    1696             : {
    1697      743868 :     WRITE_NODE_TYPE("RAWSTMT");
    1698             : 
    1699      743868 :     WRITE_NODE_FIELD(stmt);
    1700      743868 :     WRITE_LOCATION_FIELD(stmt_location);
    1701      743868 :     WRITE_LOCATION_FIELD(stmt_len);
    1702      743868 : }
    1703             : 
    1704             : static void
    1705       67346 : _outInsertStmt(StringInfo str, const InsertStmt *node)
    1706             : {
    1707       67346 :     WRITE_NODE_TYPE("INSERTSTMT");
    1708             : 
    1709       67346 :     WRITE_NODE_FIELD(relation);
    1710       67346 :     WRITE_NODE_FIELD(cols);
    1711       67346 :     WRITE_NODE_FIELD(selectStmt);
    1712       67346 :     WRITE_NODE_FIELD(onConflictClause);
    1713       67346 :     WRITE_NODE_FIELD(returningClause);
    1714       67346 :     WRITE_NODE_FIELD(withClause);
    1715       67346 :     WRITE_ENUM_FIELD(override, OverridingKind);
    1716       67346 :     WRITE_LOCATION_FIELD(stmt_location);
    1717       67346 :     WRITE_LOCATION_FIELD(stmt_len);
    1718       67346 : }
    1719             : 
    1720             : static void
    1721        4472 : _outDeleteStmt(StringInfo str, const DeleteStmt *node)
    1722             : {
    1723        4472 :     WRITE_NODE_TYPE("DELETESTMT");
    1724             : 
    1725        4472 :     WRITE_NODE_FIELD(relation);
    1726        4472 :     WRITE_NODE_FIELD(usingClause);
    1727        4472 :     WRITE_NODE_FIELD(whereClause);
    1728        4472 :     WRITE_NODE_FIELD(returningClause);
    1729        4472 :     WRITE_NODE_FIELD(withClause);
    1730        4472 :     WRITE_LOCATION_FIELD(stmt_location);
    1731        4472 :     WRITE_LOCATION_FIELD(stmt_len);
    1732        4472 : }
    1733             : 
    1734             : static void
    1735       13600 : _outUpdateStmt(StringInfo str, const UpdateStmt *node)
    1736             : {
    1737       13600 :     WRITE_NODE_TYPE("UPDATESTMT");
    1738             : 
    1739       13600 :     WRITE_NODE_FIELD(relation);
    1740       13600 :     WRITE_NODE_FIELD(targetList);
    1741       13600 :     WRITE_NODE_FIELD(whereClause);
    1742       13600 :     WRITE_NODE_FIELD(fromClause);
    1743       13600 :     WRITE_NODE_FIELD(returningClause);
    1744       13600 :     WRITE_NODE_FIELD(withClause);
    1745       13600 :     WRITE_LOCATION_FIELD(stmt_location);
    1746       13600 :     WRITE_LOCATION_FIELD(stmt_len);
    1747       13600 : }
    1748             : 
    1749             : static void
    1750        1960 : _outMergeStmt(StringInfo str, const MergeStmt *node)
    1751             : {
    1752        1960 :     WRITE_NODE_TYPE("MERGESTMT");
    1753             : 
    1754        1960 :     WRITE_NODE_FIELD(relation);
    1755        1960 :     WRITE_NODE_FIELD(sourceRelation);
    1756        1960 :     WRITE_NODE_FIELD(joinCondition);
    1757        1960 :     WRITE_NODE_FIELD(mergeWhenClauses);
    1758        1960 :     WRITE_NODE_FIELD(returningClause);
    1759        1960 :     WRITE_NODE_FIELD(withClause);
    1760        1960 :     WRITE_LOCATION_FIELD(stmt_location);
    1761        1960 :     WRITE_LOCATION_FIELD(stmt_len);
    1762        1960 : }
    1763             : 
    1764             : static void
    1765      515966 : _outSelectStmt(StringInfo str, const SelectStmt *node)
    1766             : {
    1767      515966 :     WRITE_NODE_TYPE("SELECTSTMT");
    1768             : 
    1769      515966 :     WRITE_NODE_FIELD(distinctClause);
    1770      515966 :     WRITE_NODE_FIELD(intoClause);
    1771      515966 :     WRITE_NODE_FIELD(targetList);
    1772      515966 :     WRITE_NODE_FIELD(fromClause);
    1773      515966 :     WRITE_NODE_FIELD(whereClause);
    1774      515966 :     WRITE_NODE_FIELD(groupClause);
    1775      515966 :     WRITE_BOOL_FIELD(groupDistinct);
    1776      515966 :     WRITE_NODE_FIELD(havingClause);
    1777      515966 :     WRITE_NODE_FIELD(windowClause);
    1778      515966 :     WRITE_NODE_FIELD(valuesLists);
    1779      515966 :     WRITE_NODE_FIELD(sortClause);
    1780      515966 :     WRITE_NODE_FIELD(limitOffset);
    1781      515966 :     WRITE_NODE_FIELD(limitCount);
    1782      515966 :     WRITE_ENUM_FIELD(limitOption, LimitOption);
    1783      515966 :     WRITE_NODE_FIELD(lockingClause);
    1784      515966 :     WRITE_NODE_FIELD(withClause);
    1785      515966 :     WRITE_ENUM_FIELD(op, SetOperation);
    1786      515966 :     WRITE_BOOL_FIELD(all);
    1787      515966 :     WRITE_NODE_FIELD(larg);
    1788      515966 :     WRITE_NODE_FIELD(rarg);
    1789      515966 :     WRITE_LOCATION_FIELD(stmt_location);
    1790      515966 :     WRITE_LOCATION_FIELD(stmt_len);
    1791      515966 : }
    1792             : 
    1793             : static void
    1794       19370 : _outSetOperationStmt(StringInfo str, const SetOperationStmt *node)
    1795             : {
    1796       19370 :     WRITE_NODE_TYPE("SETOPERATIONSTMT");
    1797             : 
    1798       19370 :     WRITE_ENUM_FIELD(op, SetOperation);
    1799       19370 :     WRITE_BOOL_FIELD(all);
    1800       19370 :     WRITE_NODE_FIELD(larg);
    1801       19370 :     WRITE_NODE_FIELD(rarg);
    1802       19370 :     WRITE_NODE_FIELD(colTypes);
    1803       19370 :     WRITE_NODE_FIELD(colTypmods);
    1804       19370 :     WRITE_NODE_FIELD(colCollations);
    1805       19370 :     WRITE_NODE_FIELD(groupClauses);
    1806       19370 : }
    1807             : 
    1808             : static void
    1809        9568 : _outReturnStmt(StringInfo str, const ReturnStmt *node)
    1810             : {
    1811        9568 :     WRITE_NODE_TYPE("RETURNSTMT");
    1812             : 
    1813        9568 :     WRITE_NODE_FIELD(returnval);
    1814        9568 : }
    1815             : 
    1816             : static void
    1817           0 : _outPLAssignStmt(StringInfo str, const PLAssignStmt *node)
    1818             : {
    1819           0 :     WRITE_NODE_TYPE("PLASSIGNSTMT");
    1820             : 
    1821           0 :     WRITE_STRING_FIELD(name);
    1822           0 :     WRITE_NODE_FIELD(indirection);
    1823           0 :     WRITE_INT_FIELD(nnames);
    1824           0 :     WRITE_NODE_FIELD(val);
    1825           0 :     WRITE_LOCATION_FIELD(location);
    1826           0 : }
    1827             : 
    1828             : static void
    1829        2128 : _outCreateSchemaStmt(StringInfo str, const CreateSchemaStmt *node)
    1830             : {
    1831        2128 :     WRITE_NODE_TYPE("CREATESCHEMASTMT");
    1832             : 
    1833        2128 :     WRITE_STRING_FIELD(schemaname);
    1834        2128 :     WRITE_NODE_FIELD(authrole);
    1835        2128 :     WRITE_NODE_FIELD(schemaElts);
    1836        2128 :     WRITE_BOOL_FIELD(if_not_exists);
    1837        2128 : }
    1838             : 
    1839             : static void
    1840       65216 : _outAlterTableStmt(StringInfo str, const AlterTableStmt *node)
    1841             : {
    1842       65216 :     WRITE_NODE_TYPE("ALTERTABLESTMT");
    1843             : 
    1844       65216 :     WRITE_NODE_FIELD(relation);
    1845       65216 :     WRITE_NODE_FIELD(cmds);
    1846       65216 :     WRITE_ENUM_FIELD(objtype, ObjectType);
    1847       65216 :     WRITE_BOOL_FIELD(missing_ok);
    1848       65216 : }
    1849             : 
    1850             : static void
    1851       67232 : _outAlterTableCmd(StringInfo str, const AlterTableCmd *node)
    1852             : {
    1853       67232 :     WRITE_NODE_TYPE("ALTERTABLECMD");
    1854             : 
    1855       67232 :     WRITE_ENUM_FIELD(subtype, AlterTableType);
    1856       67232 :     WRITE_STRING_FIELD(name);
    1857       67232 :     WRITE_INT_FIELD(num);
    1858       67232 :     WRITE_NODE_FIELD(newowner);
    1859       67232 :     WRITE_NODE_FIELD(def);
    1860       67232 :     WRITE_ENUM_FIELD(behavior, DropBehavior);
    1861       67232 :     WRITE_BOOL_FIELD(missing_ok);
    1862       67232 :     WRITE_BOOL_FIELD(recurse);
    1863       67232 : }
    1864             : 
    1865             : static void
    1866         588 : _outATAlterConstraint(StringInfo str, const ATAlterConstraint *node)
    1867             : {
    1868         588 :     WRITE_NODE_TYPE("ATALTERCONSTRAINT");
    1869             : 
    1870         588 :     WRITE_STRING_FIELD(conname);
    1871         588 :     WRITE_BOOL_FIELD(alterEnforceability);
    1872         588 :     WRITE_BOOL_FIELD(is_enforced);
    1873         588 :     WRITE_BOOL_FIELD(alterDeferrability);
    1874         588 :     WRITE_BOOL_FIELD(deferrable);
    1875         588 :     WRITE_BOOL_FIELD(initdeferred);
    1876         588 :     WRITE_BOOL_FIELD(alterInheritability);
    1877         588 :     WRITE_BOOL_FIELD(noinherit);
    1878         588 : }
    1879             : 
    1880             : static void
    1881         980 : _outReplicaIdentityStmt(StringInfo str, const ReplicaIdentityStmt *node)
    1882             : {
    1883         980 :     WRITE_NODE_TYPE("REPLICAIDENTITYSTMT");
    1884             : 
    1885         980 :     WRITE_CHAR_FIELD(identity_type);
    1886         980 :     WRITE_STRING_FIELD(name);
    1887         980 : }
    1888             : 
    1889             : static void
    1890          12 : _outAlterCollationStmt(StringInfo str, const AlterCollationStmt *node)
    1891             : {
    1892          12 :     WRITE_NODE_TYPE("ALTERCOLLATIONSTMT");
    1893             : 
    1894          12 :     WRITE_NODE_FIELD(collname);
    1895          12 : }
    1896             : 
    1897             : static void
    1898         564 : _outAlterDomainStmt(StringInfo str, const AlterDomainStmt *node)
    1899             : {
    1900         564 :     WRITE_NODE_TYPE("ALTERDOMAINSTMT");
    1901             : 
    1902         564 :     WRITE_CHAR_FIELD(subtype);
    1903         564 :     WRITE_NODE_FIELD(typeName);
    1904         564 :     WRITE_STRING_FIELD(name);
    1905         564 :     WRITE_NODE_FIELD(def);
    1906         564 :     WRITE_ENUM_FIELD(behavior, DropBehavior);
    1907         564 :     WRITE_BOOL_FIELD(missing_ok);
    1908         564 : }
    1909             : 
    1910             : static void
    1911       40590 : _outGrantStmt(StringInfo str, const GrantStmt *node)
    1912             : {
    1913       40590 :     WRITE_NODE_TYPE("GRANTSTMT");
    1914             : 
    1915       40590 :     WRITE_BOOL_FIELD(is_grant);
    1916       40590 :     WRITE_ENUM_FIELD(targtype, GrantTargetType);
    1917       40590 :     WRITE_ENUM_FIELD(objtype, ObjectType);
    1918       40590 :     WRITE_NODE_FIELD(objects);
    1919       40590 :     WRITE_NODE_FIELD(privileges);
    1920       40590 :     WRITE_NODE_FIELD(grantees);
    1921       40590 :     WRITE_BOOL_FIELD(grant_option);
    1922       40590 :     WRITE_NODE_FIELD(grantor);
    1923       40590 :     WRITE_ENUM_FIELD(behavior, DropBehavior);
    1924       40590 : }
    1925             : 
    1926             : static void
    1927       39946 : _outObjectWithArgs(StringInfo str, const ObjectWithArgs *node)
    1928             : {
    1929       39946 :     WRITE_NODE_TYPE("OBJECTWITHARGS");
    1930             : 
    1931       39946 :     WRITE_NODE_FIELD(objname);
    1932       39946 :     WRITE_NODE_FIELD(objargs);
    1933       39946 :     WRITE_NODE_FIELD(objfuncargs);
    1934       39946 :     WRITE_BOOL_FIELD(args_unspecified);
    1935       39946 : }
    1936             : 
    1937             : static void
    1938       38218 : _outAccessPriv(StringInfo str, const AccessPriv *node)
    1939             : {
    1940       38218 :     WRITE_NODE_TYPE("ACCESSPRIV");
    1941             : 
    1942       38218 :     WRITE_STRING_FIELD(priv_name);
    1943       38218 :     WRITE_NODE_FIELD(cols);
    1944       38218 : }
    1945             : 
    1946             : static void
    1947        1812 : _outGrantRoleStmt(StringInfo str, const GrantRoleStmt *node)
    1948             : {
    1949        1812 :     WRITE_NODE_TYPE("GRANTROLESTMT");
    1950             : 
    1951        1812 :     WRITE_NODE_FIELD(granted_roles);
    1952        1812 :     WRITE_NODE_FIELD(grantee_roles);
    1953        1812 :     WRITE_BOOL_FIELD(is_grant);
    1954        1812 :     WRITE_NODE_FIELD(opt);
    1955        1812 :     WRITE_NODE_FIELD(grantor);
    1956        1812 :     WRITE_ENUM_FIELD(behavior, DropBehavior);
    1957        1812 : }
    1958             : 
    1959             : static void
    1960         380 : _outAlterDefaultPrivilegesStmt(StringInfo str, const AlterDefaultPrivilegesStmt *node)
    1961             : {
    1962         380 :     WRITE_NODE_TYPE("ALTERDEFAULTPRIVILEGESSTMT");
    1963             : 
    1964         380 :     WRITE_NODE_FIELD(options);
    1965         380 :     WRITE_NODE_FIELD(action);
    1966         380 : }
    1967             : 
    1968             : static void
    1969       32756 : _outCopyStmt(StringInfo str, const CopyStmt *node)
    1970             : {
    1971       32756 :     WRITE_NODE_TYPE("COPYSTMT");
    1972             : 
    1973       32756 :     WRITE_NODE_FIELD(relation);
    1974       32756 :     WRITE_NODE_FIELD(query);
    1975       32756 :     WRITE_NODE_FIELD(attlist);
    1976       32756 :     WRITE_BOOL_FIELD(is_from);
    1977       32756 :     WRITE_BOOL_FIELD(is_program);
    1978       32756 :     WRITE_STRING_FIELD(filename);
    1979       32756 :     WRITE_NODE_FIELD(options);
    1980       32756 :     WRITE_NODE_FIELD(whereClause);
    1981       32756 : }
    1982             : 
    1983             : static void
    1984       58664 : _outVariableSetStmt(StringInfo str, const VariableSetStmt *node)
    1985             : {
    1986       58664 :     WRITE_NODE_TYPE("VARIABLESETSTMT");
    1987             : 
    1988       58664 :     WRITE_ENUM_FIELD(kind, VariableSetKind);
    1989       58664 :     WRITE_STRING_FIELD(name);
    1990       58664 :     WRITE_NODE_FIELD(args);
    1991       58664 :     WRITE_BOOL_FIELD(jumble_args);
    1992       58664 :     WRITE_BOOL_FIELD(is_local);
    1993       58664 :     WRITE_LOCATION_FIELD(location);
    1994       58664 : }
    1995             : 
    1996             : static void
    1997        1752 : _outVariableShowStmt(StringInfo str, const VariableShowStmt *node)
    1998             : {
    1999        1752 :     WRITE_NODE_TYPE("VARIABLESHOWSTMT");
    2000             : 
    2001        1752 :     WRITE_STRING_FIELD(name);
    2002        1752 : }
    2003             : 
    2004             : static void
    2005       77324 : _outCreateStmt(StringInfo str, const CreateStmt *node)
    2006             : {
    2007       77324 :     WRITE_NODE_TYPE("CREATESTMT");
    2008             : 
    2009       77324 :     WRITE_NODE_FIELD(relation);
    2010       77324 :     WRITE_NODE_FIELD(tableElts);
    2011       77324 :     WRITE_NODE_FIELD(inhRelations);
    2012       77324 :     WRITE_NODE_FIELD(partbound);
    2013       77324 :     WRITE_NODE_FIELD(partspec);
    2014       77324 :     WRITE_NODE_FIELD(ofTypename);
    2015       77324 :     WRITE_NODE_FIELD(constraints);
    2016       77324 :     WRITE_NODE_FIELD(nnconstraints);
    2017       77324 :     WRITE_NODE_FIELD(options);
    2018       77324 :     WRITE_ENUM_FIELD(oncommit, OnCommitAction);
    2019       77324 :     WRITE_STRING_FIELD(tablespacename);
    2020       77324 :     WRITE_STRING_FIELD(accessMethod);
    2021       77324 :     WRITE_BOOL_FIELD(if_not_exists);
    2022       77324 : }
    2023             : 
    2024             : static void
    2025       73242 : _outConstraint(StringInfo str, const Constraint *node)
    2026             : {
    2027       73242 :     WRITE_NODE_TYPE("CONSTRAINT");
    2028             : 
    2029       73242 :     WRITE_ENUM_FIELD(contype, ConstrType);
    2030       73242 :     WRITE_STRING_FIELD(conname);
    2031       73242 :     WRITE_BOOL_FIELD(deferrable);
    2032       73242 :     WRITE_BOOL_FIELD(initdeferred);
    2033       73242 :     WRITE_BOOL_FIELD(is_enforced);
    2034       73242 :     WRITE_BOOL_FIELD(skip_validation);
    2035       73242 :     WRITE_BOOL_FIELD(initially_valid);
    2036       73242 :     WRITE_BOOL_FIELD(is_no_inherit);
    2037       73242 :     WRITE_NODE_FIELD(raw_expr);
    2038       73242 :     WRITE_STRING_FIELD(cooked_expr);
    2039       73242 :     WRITE_CHAR_FIELD(generated_when);
    2040       73242 :     WRITE_CHAR_FIELD(generated_kind);
    2041       73242 :     WRITE_BOOL_FIELD(nulls_not_distinct);
    2042       73242 :     WRITE_NODE_FIELD(keys);
    2043       73242 :     WRITE_BOOL_FIELD(without_overlaps);
    2044       73242 :     WRITE_NODE_FIELD(including);
    2045       73242 :     WRITE_NODE_FIELD(exclusions);
    2046       73242 :     WRITE_NODE_FIELD(options);
    2047       73242 :     WRITE_STRING_FIELD(indexname);
    2048       73242 :     WRITE_STRING_FIELD(indexspace);
    2049       73242 :     WRITE_BOOL_FIELD(reset_default_tblspc);
    2050       73242 :     WRITE_STRING_FIELD(access_method);
    2051       73242 :     WRITE_NODE_FIELD(where_clause);
    2052       73242 :     WRITE_NODE_FIELD(pktable);
    2053       73242 :     WRITE_NODE_FIELD(fk_attrs);
    2054       73242 :     WRITE_NODE_FIELD(pk_attrs);
    2055       73242 :     WRITE_BOOL_FIELD(fk_with_period);
    2056       73242 :     WRITE_BOOL_FIELD(pk_with_period);
    2057       73242 :     WRITE_CHAR_FIELD(fk_matchtype);
    2058       73242 :     WRITE_CHAR_FIELD(fk_upd_action);
    2059       73242 :     WRITE_CHAR_FIELD(fk_del_action);
    2060       73242 :     WRITE_NODE_FIELD(fk_del_set_cols);
    2061       73242 :     WRITE_NODE_FIELD(old_conpfeqop);
    2062       73242 :     WRITE_OID_FIELD(old_pktable_oid);
    2063       73242 :     WRITE_LOCATION_FIELD(location);
    2064       73242 : }
    2065             : 
    2066             : static void
    2067         232 : _outCreateTableSpaceStmt(StringInfo str, const CreateTableSpaceStmt *node)
    2068             : {
    2069         232 :     WRITE_NODE_TYPE("CREATETABLESPACESTMT");
    2070             : 
    2071         232 :     WRITE_STRING_FIELD(tablespacename);
    2072         232 :     WRITE_NODE_FIELD(owner);
    2073         232 :     WRITE_STRING_FIELD(location);
    2074         232 :     WRITE_NODE_FIELD(options);
    2075         232 : }
    2076             : 
    2077             : static void
    2078         128 : _outDropTableSpaceStmt(StringInfo str, const DropTableSpaceStmt *node)
    2079             : {
    2080         128 :     WRITE_NODE_TYPE("DROPTABLESPACESTMT");
    2081             : 
    2082         128 :     WRITE_STRING_FIELD(tablespacename);
    2083         128 :     WRITE_BOOL_FIELD(missing_ok);
    2084         128 : }
    2085             : 
    2086             : static void
    2087          48 : _outAlterTableSpaceOptionsStmt(StringInfo str, const AlterTableSpaceOptionsStmt *node)
    2088             : {
    2089          48 :     WRITE_NODE_TYPE("ALTERTABLESPACEOPTIONSSTMT");
    2090             : 
    2091          48 :     WRITE_STRING_FIELD(tablespacename);
    2092          48 :     WRITE_NODE_FIELD(options);
    2093          48 :     WRITE_BOOL_FIELD(isReset);
    2094          48 : }
    2095             : 
    2096             : static void
    2097          60 : _outAlterTableMoveAllStmt(StringInfo str, const AlterTableMoveAllStmt *node)
    2098             : {
    2099          60 :     WRITE_NODE_TYPE("ALTERTABLEMOVEALLSTMT");
    2100             : 
    2101          60 :     WRITE_STRING_FIELD(orig_tablespacename);
    2102          60 :     WRITE_ENUM_FIELD(objtype, ObjectType);
    2103          60 :     WRITE_NODE_FIELD(roles);
    2104          60 :     WRITE_STRING_FIELD(new_tablespacename);
    2105          60 :     WRITE_BOOL_FIELD(nowait);
    2106          60 : }
    2107             : 
    2108             : static void
    2109        1040 : _outCreateExtensionStmt(StringInfo str, const CreateExtensionStmt *node)
    2110             : {
    2111        1040 :     WRITE_NODE_TYPE("CREATEEXTENSIONSTMT");
    2112             : 
    2113        1040 :     WRITE_STRING_FIELD(extname);
    2114        1040 :     WRITE_BOOL_FIELD(if_not_exists);
    2115        1040 :     WRITE_NODE_FIELD(options);
    2116        1040 : }
    2117             : 
    2118             : static void
    2119          70 : _outAlterExtensionStmt(StringInfo str, const AlterExtensionStmt *node)
    2120             : {
    2121          70 :     WRITE_NODE_TYPE("ALTEREXTENSIONSTMT");
    2122             : 
    2123          70 :     WRITE_STRING_FIELD(extname);
    2124          70 :     WRITE_NODE_FIELD(options);
    2125          70 : }
    2126             : 
    2127             : static void
    2128         484 : _outAlterExtensionContentsStmt(StringInfo str, const AlterExtensionContentsStmt *node)
    2129             : {
    2130         484 :     WRITE_NODE_TYPE("ALTEREXTENSIONCONTENTSSTMT");
    2131             : 
    2132         484 :     WRITE_STRING_FIELD(extname);
    2133         484 :     WRITE_INT_FIELD(action);
    2134         484 :     WRITE_ENUM_FIELD(objtype, ObjectType);
    2135         484 :     WRITE_NODE_FIELD(object);
    2136         484 : }
    2137             : 
    2138             : static void
    2139         412 : _outCreateFdwStmt(StringInfo str, const CreateFdwStmt *node)
    2140             : {
    2141         412 :     WRITE_NODE_TYPE("CREATEFDWSTMT");
    2142             : 
    2143         412 :     WRITE_STRING_FIELD(fdwname);
    2144         412 :     WRITE_NODE_FIELD(func_options);
    2145         412 :     WRITE_NODE_FIELD(options);
    2146         412 : }
    2147             : 
    2148             : static void
    2149         244 : _outAlterFdwStmt(StringInfo str, const AlterFdwStmt *node)
    2150             : {
    2151         244 :     WRITE_NODE_TYPE("ALTERFDWSTMT");
    2152             : 
    2153         244 :     WRITE_STRING_FIELD(fdwname);
    2154         244 :     WRITE_NODE_FIELD(func_options);
    2155         244 :     WRITE_NODE_FIELD(options);
    2156         244 : }
    2157             : 
    2158             : static void
    2159         582 : _outCreateForeignServerStmt(StringInfo str, const CreateForeignServerStmt *node)
    2160             : {
    2161         582 :     WRITE_NODE_TYPE("CREATEFOREIGNSERVERSTMT");
    2162             : 
    2163         582 :     WRITE_STRING_FIELD(servername);
    2164         582 :     WRITE_STRING_FIELD(servertype);
    2165         582 :     WRITE_STRING_FIELD(version);
    2166         582 :     WRITE_STRING_FIELD(fdwname);
    2167         582 :     WRITE_BOOL_FIELD(if_not_exists);
    2168         582 :     WRITE_NODE_FIELD(options);
    2169         582 : }
    2170             : 
    2171             : static void
    2172         454 : _outAlterForeignServerStmt(StringInfo str, const AlterForeignServerStmt *node)
    2173             : {
    2174         454 :     WRITE_NODE_TYPE("ALTERFOREIGNSERVERSTMT");
    2175             : 
    2176         454 :     WRITE_STRING_FIELD(servername);
    2177         454 :     WRITE_STRING_FIELD(version);
    2178         454 :     WRITE_NODE_FIELD(options);
    2179         454 :     WRITE_BOOL_FIELD(has_version);
    2180         454 : }
    2181             : 
    2182             : static void
    2183         916 : _outCreateForeignTableStmt(StringInfo str, const CreateForeignTableStmt *node)
    2184             : {
    2185         916 :     WRITE_NODE_TYPE("CREATEFOREIGNTABLESTMT");
    2186             : 
    2187         916 :     WRITE_NODE_FIELD(base.relation);
    2188         916 :     WRITE_NODE_FIELD(base.tableElts);
    2189         916 :     WRITE_NODE_FIELD(base.inhRelations);
    2190         916 :     WRITE_NODE_FIELD(base.partbound);
    2191         916 :     WRITE_NODE_FIELD(base.partspec);
    2192         916 :     WRITE_NODE_FIELD(base.ofTypename);
    2193         916 :     WRITE_NODE_FIELD(base.constraints);
    2194         916 :     WRITE_NODE_FIELD(base.nnconstraints);
    2195         916 :     WRITE_NODE_FIELD(base.options);
    2196         916 :     WRITE_ENUM_FIELD(base.oncommit, OnCommitAction);
    2197         916 :     WRITE_STRING_FIELD(base.tablespacename);
    2198         916 :     WRITE_STRING_FIELD(base.accessMethod);
    2199         916 :     WRITE_BOOL_FIELD(base.if_not_exists);
    2200         916 :     WRITE_STRING_FIELD(servername);
    2201         916 :     WRITE_NODE_FIELD(options);
    2202         916 : }
    2203             : 
    2204             : static void
    2205         504 : _outCreateUserMappingStmt(StringInfo str, const CreateUserMappingStmt *node)
    2206             : {
    2207         504 :     WRITE_NODE_TYPE("CREATEUSERMAPPINGSTMT");
    2208             : 
    2209         504 :     WRITE_NODE_FIELD(user);
    2210         504 :     WRITE_STRING_FIELD(servername);
    2211         504 :     WRITE_BOOL_FIELD(if_not_exists);
    2212         504 :     WRITE_NODE_FIELD(options);
    2213         504 : }
    2214             : 
    2215             : static void
    2216         236 : _outAlterUserMappingStmt(StringInfo str, const AlterUserMappingStmt *node)
    2217             : {
    2218         236 :     WRITE_NODE_TYPE("ALTERUSERMAPPINGSTMT");
    2219             : 
    2220         236 :     WRITE_NODE_FIELD(user);
    2221         236 :     WRITE_STRING_FIELD(servername);
    2222         236 :     WRITE_NODE_FIELD(options);
    2223         236 : }
    2224             : 
    2225             : static void
    2226         252 : _outDropUserMappingStmt(StringInfo str, const DropUserMappingStmt *node)
    2227             : {
    2228         252 :     WRITE_NODE_TYPE("DROPUSERMAPPINGSTMT");
    2229             : 
    2230         252 :     WRITE_NODE_FIELD(user);
    2231         252 :     WRITE_STRING_FIELD(servername);
    2232         252 :     WRITE_BOOL_FIELD(missing_ok);
    2233         252 : }
    2234             : 
    2235             : static void
    2236          96 : _outImportForeignSchemaStmt(StringInfo str, const ImportForeignSchemaStmt *node)
    2237             : {
    2238          96 :     WRITE_NODE_TYPE("IMPORTFOREIGNSCHEMASTMT");
    2239             : 
    2240          96 :     WRITE_STRING_FIELD(server_name);
    2241          96 :     WRITE_STRING_FIELD(remote_schema);
    2242          96 :     WRITE_STRING_FIELD(local_schema);
    2243          96 :     WRITE_ENUM_FIELD(list_type, ImportForeignSchemaType);
    2244          96 :     WRITE_NODE_FIELD(table_list);
    2245          96 :     WRITE_NODE_FIELD(options);
    2246          96 : }
    2247             : 
    2248             : static void
    2249        1412 : _outCreatePolicyStmt(StringInfo str, const CreatePolicyStmt *node)
    2250             : {
    2251        1412 :     WRITE_NODE_TYPE("CREATEPOLICYSTMT");
    2252             : 
    2253        1412 :     WRITE_STRING_FIELD(policy_name);
    2254        1412 :     WRITE_NODE_FIELD(table);
    2255        1412 :     WRITE_STRING_FIELD(cmd_name);
    2256        1412 :     WRITE_BOOL_FIELD(permissive);
    2257        1412 :     WRITE_NODE_FIELD(roles);
    2258        1412 :     WRITE_NODE_FIELD(qual);
    2259        1412 :     WRITE_NODE_FIELD(with_check);
    2260        1412 : }
    2261             : 
    2262             : static void
    2263         168 : _outAlterPolicyStmt(StringInfo str, const AlterPolicyStmt *node)
    2264             : {
    2265         168 :     WRITE_NODE_TYPE("ALTERPOLICYSTMT");
    2266             : 
    2267         168 :     WRITE_STRING_FIELD(policy_name);
    2268         168 :     WRITE_NODE_FIELD(table);
    2269         168 :     WRITE_NODE_FIELD(roles);
    2270         168 :     WRITE_NODE_FIELD(qual);
    2271         168 :     WRITE_NODE_FIELD(with_check);
    2272         168 : }
    2273             : 
    2274             : static void
    2275         128 : _outCreateAmStmt(StringInfo str, const CreateAmStmt *node)
    2276             : {
    2277         128 :     WRITE_NODE_TYPE("CREATEAMSTMT");
    2278             : 
    2279         128 :     WRITE_STRING_FIELD(amname);
    2280         128 :     WRITE_NODE_FIELD(handler_name);
    2281         128 :     WRITE_CHAR_FIELD(amtype);
    2282         128 : }
    2283             : 
    2284             : static void
    2285        6644 : _outCreateTrigStmt(StringInfo str, const CreateTrigStmt *node)
    2286             : {
    2287        6644 :     WRITE_NODE_TYPE("CREATETRIGSTMT");
    2288             : 
    2289        6644 :     WRITE_BOOL_FIELD(replace);
    2290        6644 :     WRITE_BOOL_FIELD(isconstraint);
    2291        6644 :     WRITE_STRING_FIELD(trigname);
    2292        6644 :     WRITE_NODE_FIELD(relation);
    2293        6644 :     WRITE_NODE_FIELD(funcname);
    2294        6644 :     WRITE_NODE_FIELD(args);
    2295        6644 :     WRITE_BOOL_FIELD(row);
    2296        6644 :     WRITE_INT_FIELD(timing);
    2297        6644 :     WRITE_INT_FIELD(events);
    2298        6644 :     WRITE_NODE_FIELD(columns);
    2299        6644 :     WRITE_NODE_FIELD(whenClause);
    2300        6644 :     WRITE_NODE_FIELD(transitionRels);
    2301        6644 :     WRITE_BOOL_FIELD(deferrable);
    2302        6644 :     WRITE_BOOL_FIELD(initdeferred);
    2303        6644 :     WRITE_NODE_FIELD(constrrel);
    2304        6644 : }
    2305             : 
    2306             : static void
    2307         396 : _outCreateEventTrigStmt(StringInfo str, const CreateEventTrigStmt *node)
    2308             : {
    2309         396 :     WRITE_NODE_TYPE("CREATEEVENTTRIGSTMT");
    2310             : 
    2311         396 :     WRITE_STRING_FIELD(trigname);
    2312         396 :     WRITE_STRING_FIELD(eventname);
    2313         396 :     WRITE_NODE_FIELD(whenclause);
    2314         396 :     WRITE_NODE_FIELD(funcname);
    2315         396 : }
    2316             : 
    2317             : static void
    2318          96 : _outAlterEventTrigStmt(StringInfo str, const AlterEventTrigStmt *node)
    2319             : {
    2320          96 :     WRITE_NODE_TYPE("ALTEREVENTTRIGSTMT");
    2321             : 
    2322          96 :     WRITE_STRING_FIELD(trigname);
    2323          96 :     WRITE_CHAR_FIELD(tgenabled);
    2324          96 : }
    2325             : 
    2326             : static void
    2327         280 : _outCreatePLangStmt(StringInfo str, const CreatePLangStmt *node)
    2328             : {
    2329         280 :     WRITE_NODE_TYPE("CREATEPLANGSTMT");
    2330             : 
    2331         280 :     WRITE_BOOL_FIELD(replace);
    2332         280 :     WRITE_STRING_FIELD(plname);
    2333         280 :     WRITE_NODE_FIELD(plhandler);
    2334         280 :     WRITE_NODE_FIELD(plinline);
    2335         280 :     WRITE_NODE_FIELD(plvalidator);
    2336         280 :     WRITE_BOOL_FIELD(pltrusted);
    2337         280 : }
    2338             : 
    2339             : static void
    2340        3688 : _outCreateRoleStmt(StringInfo str, const CreateRoleStmt *node)
    2341             : {
    2342        3688 :     WRITE_NODE_TYPE("CREATEROLESTMT");
    2343             : 
    2344        3688 :     WRITE_ENUM_FIELD(stmt_type, RoleStmtType);
    2345        3688 :     WRITE_STRING_FIELD(role);
    2346        3688 :     WRITE_NODE_FIELD(options);
    2347        3688 : }
    2348             : 
    2349             : static void
    2350         920 : _outAlterRoleStmt(StringInfo str, const AlterRoleStmt *node)
    2351             : {
    2352         920 :     WRITE_NODE_TYPE("ALTERROLESTMT");
    2353             : 
    2354         920 :     WRITE_NODE_FIELD(role);
    2355         920 :     WRITE_NODE_FIELD(options);
    2356         920 :     WRITE_INT_FIELD(action);
    2357         920 : }
    2358             : 
    2359             : static void
    2360         164 : _outAlterRoleSetStmt(StringInfo str, const AlterRoleSetStmt *node)
    2361             : {
    2362         164 :     WRITE_NODE_TYPE("ALTERROLESETSTMT");
    2363             : 
    2364         164 :     WRITE_NODE_FIELD(role);
    2365         164 :     WRITE_STRING_FIELD(database);
    2366         164 :     WRITE_NODE_FIELD(setstmt);
    2367         164 : }
    2368             : 
    2369             : static void
    2370        3432 : _outDropRoleStmt(StringInfo str, const DropRoleStmt *node)
    2371             : {
    2372        3432 :     WRITE_NODE_TYPE("DROPROLESTMT");
    2373             : 
    2374        3432 :     WRITE_NODE_FIELD(roles);
    2375        3432 :     WRITE_BOOL_FIELD(missing_ok);
    2376        3432 : }
    2377             : 
    2378             : static void
    2379        1468 : _outCreateSeqStmt(StringInfo str, const CreateSeqStmt *node)
    2380             : {
    2381        1468 :     WRITE_NODE_TYPE("CREATESEQSTMT");
    2382             : 
    2383        1468 :     WRITE_NODE_FIELD(sequence);
    2384        1468 :     WRITE_NODE_FIELD(options);
    2385        1468 :     WRITE_OID_FIELD(ownerId);
    2386        1468 :     WRITE_BOOL_FIELD(for_identity);
    2387        1468 :     WRITE_BOOL_FIELD(if_not_exists);
    2388        1468 : }
    2389             : 
    2390             : static void
    2391         448 : _outAlterSeqStmt(StringInfo str, const AlterSeqStmt *node)
    2392             : {
    2393         448 :     WRITE_NODE_TYPE("ALTERSEQSTMT");
    2394             : 
    2395         448 :     WRITE_NODE_FIELD(sequence);
    2396         448 :     WRITE_NODE_FIELD(options);
    2397         448 :     WRITE_BOOL_FIELD(for_identity);
    2398         448 :     WRITE_BOOL_FIELD(missing_ok);
    2399         448 : }
    2400             : 
    2401             : static void
    2402       18520 : _outDefineStmt(StringInfo str, const DefineStmt *node)
    2403             : {
    2404       18520 :     WRITE_NODE_TYPE("DEFINESTMT");
    2405             : 
    2406       18520 :     WRITE_ENUM_FIELD(kind, ObjectType);
    2407       18520 :     WRITE_BOOL_FIELD(oldstyle);
    2408       18520 :     WRITE_NODE_FIELD(defnames);
    2409       18520 :     WRITE_NODE_FIELD(args);
    2410       18520 :     WRITE_NODE_FIELD(definition);
    2411       18520 :     WRITE_BOOL_FIELD(if_not_exists);
    2412       18520 :     WRITE_BOOL_FIELD(replace);
    2413       18520 : }
    2414             : 
    2415             : static void
    2416        2948 : _outCreateDomainStmt(StringInfo str, const CreateDomainStmt *node)
    2417             : {
    2418        2948 :     WRITE_NODE_TYPE("CREATEDOMAINSTMT");
    2419             : 
    2420        2948 :     WRITE_NODE_FIELD(domainname);
    2421        2948 :     WRITE_NODE_FIELD(typeName);
    2422        2948 :     WRITE_NODE_FIELD(collClause);
    2423        2948 :     WRITE_NODE_FIELD(constraints);
    2424        2948 : }
    2425             : 
    2426             : static void
    2427         788 : _outCreateOpClassStmt(StringInfo str, const CreateOpClassStmt *node)
    2428             : {
    2429         788 :     WRITE_NODE_TYPE("CREATEOPCLASSSTMT");
    2430             : 
    2431         788 :     WRITE_NODE_FIELD(opclassname);
    2432         788 :     WRITE_NODE_FIELD(opfamilyname);
    2433         788 :     WRITE_STRING_FIELD(amname);
    2434         788 :     WRITE_NODE_FIELD(datatype);
    2435         788 :     WRITE_NODE_FIELD(items);
    2436         788 :     WRITE_BOOL_FIELD(isDefault);
    2437         788 : }
    2438             : 
    2439             : static void
    2440        8180 : _outCreateOpClassItem(StringInfo str, const CreateOpClassItem *node)
    2441             : {
    2442        8180 :     WRITE_NODE_TYPE("CREATEOPCLASSITEM");
    2443             : 
    2444        8180 :     WRITE_INT_FIELD(itemtype);
    2445        8180 :     WRITE_NODE_FIELD(name);
    2446        8180 :     WRITE_INT_FIELD(number);
    2447        8180 :     WRITE_NODE_FIELD(order_family);
    2448        8180 :     WRITE_NODE_FIELD(class_args);
    2449        8180 :     WRITE_NODE_FIELD(storedtype);
    2450        8180 : }
    2451             : 
    2452             : static void
    2453         324 : _outCreateOpFamilyStmt(StringInfo str, const CreateOpFamilyStmt *node)
    2454             : {
    2455         324 :     WRITE_NODE_TYPE("CREATEOPFAMILYSTMT");
    2456             : 
    2457         324 :     WRITE_NODE_FIELD(opfamilyname);
    2458         324 :     WRITE_STRING_FIELD(amname);
    2459         324 : }
    2460             : 
    2461             : static void
    2462        1156 : _outAlterOpFamilyStmt(StringInfo str, const AlterOpFamilyStmt *node)
    2463             : {
    2464        1156 :     WRITE_NODE_TYPE("ALTEROPFAMILYSTMT");
    2465             : 
    2466        1156 :     WRITE_NODE_FIELD(opfamilyname);
    2467        1156 :     WRITE_STRING_FIELD(amname);
    2468        1156 :     WRITE_BOOL_FIELD(isDrop);
    2469        1156 :     WRITE_NODE_FIELD(items);
    2470        1156 : }
    2471             : 
    2472             : static void
    2473       50634 : _outDropStmt(StringInfo str, const DropStmt *node)
    2474             : {
    2475       50634 :     WRITE_NODE_TYPE("DROPSTMT");
    2476             : 
    2477       50634 :     WRITE_NODE_FIELD(objects);
    2478       50634 :     WRITE_ENUM_FIELD(removeType, ObjectType);
    2479       50634 :     WRITE_ENUM_FIELD(behavior, DropBehavior);
    2480       50634 :     WRITE_BOOL_FIELD(missing_ok);
    2481       50634 :     WRITE_BOOL_FIELD(concurrent);
    2482       50634 : }
    2483             : 
    2484             : static void
    2485        5850 : _outTruncateStmt(StringInfo str, const TruncateStmt *node)
    2486             : {
    2487        5850 :     WRITE_NODE_TYPE("TRUNCATESTMT");
    2488             : 
    2489        5850 :     WRITE_NODE_FIELD(relations);
    2490        5850 :     WRITE_BOOL_FIELD(restart_seqs);
    2491        5850 :     WRITE_ENUM_FIELD(behavior, DropBehavior);
    2492        5850 : }
    2493             : 
    2494             : static void
    2495       13776 : _outCommentStmt(StringInfo str, const CommentStmt *node)
    2496             : {
    2497       13776 :     WRITE_NODE_TYPE("COMMENTSTMT");
    2498             : 
    2499       13776 :     WRITE_ENUM_FIELD(objtype, ObjectType);
    2500       13776 :     WRITE_NODE_FIELD(object);
    2501       13776 :     WRITE_STRING_FIELD(comment);
    2502       13776 : }
    2503             : 
    2504             : static void
    2505         200 : _outSecLabelStmt(StringInfo str, const SecLabelStmt *node)
    2506             : {
    2507         200 :     WRITE_NODE_TYPE("SECLABELSTMT");
    2508             : 
    2509         200 :     WRITE_ENUM_FIELD(objtype, ObjectType);
    2510         200 :     WRITE_NODE_FIELD(object);
    2511         200 :     WRITE_STRING_FIELD(provider);
    2512         200 :     WRITE_STRING_FIELD(label);
    2513         200 : }
    2514             : 
    2515             : static void
    2516        7432 : _outDeclareCursorStmt(StringInfo str, const DeclareCursorStmt *node)
    2517             : {
    2518        7432 :     WRITE_NODE_TYPE("DECLARECURSORSTMT");
    2519             : 
    2520        7432 :     WRITE_STRING_FIELD(portalname);
    2521        7432 :     WRITE_INT_FIELD(options);
    2522        7432 :     WRITE_NODE_FIELD(query);
    2523        7432 : }
    2524             : 
    2525             : static void
    2526        4472 : _outClosePortalStmt(StringInfo str, const ClosePortalStmt *node)
    2527             : {
    2528        4472 :     WRITE_NODE_TYPE("CLOSEPORTALSTMT");
    2529             : 
    2530        4472 :     WRITE_STRING_FIELD(portalname);
    2531        4472 : }
    2532             : 
    2533             : static void
    2534       13390 : _outFetchStmt(StringInfo str, const FetchStmt *node)
    2535             : {
    2536       13390 :     WRITE_NODE_TYPE("FETCHSTMT");
    2537             : 
    2538       13390 :     WRITE_ENUM_FIELD(direction, FetchDirection);
    2539       13390 :     WRITE_LONG_FIELD(howMany);
    2540       13390 :     WRITE_STRING_FIELD(portalname);
    2541       13390 :     WRITE_BOOL_FIELD(ismove);
    2542       13390 : }
    2543             : 
    2544             : static void
    2545       13264 : _outIndexStmt(StringInfo str, const IndexStmt *node)
    2546             : {
    2547       13264 :     WRITE_NODE_TYPE("INDEXSTMT");
    2548             : 
    2549       13264 :     WRITE_STRING_FIELD(idxname);
    2550       13264 :     WRITE_NODE_FIELD(relation);
    2551       13264 :     WRITE_STRING_FIELD(accessMethod);
    2552       13264 :     WRITE_STRING_FIELD(tableSpace);
    2553       13264 :     WRITE_NODE_FIELD(indexParams);
    2554       13264 :     WRITE_NODE_FIELD(indexIncludingParams);
    2555       13264 :     WRITE_NODE_FIELD(options);
    2556       13264 :     WRITE_NODE_FIELD(whereClause);
    2557       13264 :     WRITE_NODE_FIELD(excludeOpNames);
    2558       13264 :     WRITE_STRING_FIELD(idxcomment);
    2559       13264 :     WRITE_OID_FIELD(indexOid);
    2560       13264 :     WRITE_OID_FIELD(oldNumber);
    2561       13264 :     WRITE_UINT_FIELD(oldCreateSubid);
    2562       13264 :     WRITE_UINT_FIELD(oldFirstRelfilelocatorSubid);
    2563       13264 :     WRITE_BOOL_FIELD(unique);
    2564       13264 :     WRITE_BOOL_FIELD(nulls_not_distinct);
    2565       13264 :     WRITE_BOOL_FIELD(primary);
    2566       13264 :     WRITE_BOOL_FIELD(isconstraint);
    2567       13264 :     WRITE_BOOL_FIELD(iswithoutoverlaps);
    2568       13264 :     WRITE_BOOL_FIELD(deferrable);
    2569       13264 :     WRITE_BOOL_FIELD(initdeferred);
    2570       13264 :     WRITE_BOOL_FIELD(transformed);
    2571       13264 :     WRITE_BOOL_FIELD(concurrent);
    2572       13264 :     WRITE_BOOL_FIELD(if_not_exists);
    2573       13264 :     WRITE_BOOL_FIELD(reset_default_tblspc);
    2574       13264 : }
    2575             : 
    2576             : static void
    2577        1310 : _outCreateStatsStmt(StringInfo str, const CreateStatsStmt *node)
    2578             : {
    2579        1310 :     WRITE_NODE_TYPE("CREATESTATSSTMT");
    2580             : 
    2581        1310 :     WRITE_NODE_FIELD(defnames);
    2582        1310 :     WRITE_NODE_FIELD(stat_types);
    2583        1310 :     WRITE_NODE_FIELD(exprs);
    2584        1310 :     WRITE_NODE_FIELD(relations);
    2585        1310 :     WRITE_STRING_FIELD(stxcomment);
    2586        1310 :     WRITE_BOOL_FIELD(transformed);
    2587        1310 :     WRITE_BOOL_FIELD(if_not_exists);
    2588        1310 : }
    2589             : 
    2590             : static void
    2591        3204 : _outStatsElem(StringInfo str, const StatsElem *node)
    2592             : {
    2593        3204 :     WRITE_NODE_TYPE("STATSELEM");
    2594             : 
    2595        3204 :     WRITE_STRING_FIELD(name);
    2596        3204 :     WRITE_NODE_FIELD(expr);
    2597        3204 : }
    2598             : 
    2599             : static void
    2600          52 : _outAlterStatsStmt(StringInfo str, const AlterStatsStmt *node)
    2601             : {
    2602          52 :     WRITE_NODE_TYPE("ALTERSTATSSTMT");
    2603             : 
    2604          52 :     WRITE_NODE_FIELD(defnames);
    2605          52 :     WRITE_NODE_FIELD(stxstattarget);
    2606          52 :     WRITE_BOOL_FIELD(missing_ok);
    2607          52 : }
    2608             : 
    2609             : static void
    2610       48992 : _outCreateFunctionStmt(StringInfo str, const CreateFunctionStmt *node)
    2611             : {
    2612       48992 :     WRITE_NODE_TYPE("CREATEFUNCTIONSTMT");
    2613             : 
    2614       48992 :     WRITE_BOOL_FIELD(is_procedure);
    2615       48992 :     WRITE_BOOL_FIELD(replace);
    2616       48992 :     WRITE_NODE_FIELD(funcname);
    2617       48992 :     WRITE_NODE_FIELD(parameters);
    2618       48992 :     WRITE_NODE_FIELD(returnType);
    2619       48992 :     WRITE_NODE_FIELD(options);
    2620       48992 :     WRITE_NODE_FIELD(sql_body);
    2621       48992 : }
    2622             : 
    2623             : static void
    2624      145970 : _outFunctionParameter(StringInfo str, const FunctionParameter *node)
    2625             : {
    2626      145970 :     WRITE_NODE_TYPE("FUNCTIONPARAMETER");
    2627             : 
    2628      145970 :     WRITE_STRING_FIELD(name);
    2629      145970 :     WRITE_NODE_FIELD(argType);
    2630      145970 :     WRITE_ENUM_FIELD(mode, FunctionParameterMode);
    2631      145970 :     WRITE_NODE_FIELD(defexpr);
    2632      145970 :     WRITE_LOCATION_FIELD(location);
    2633      145970 : }
    2634             : 
    2635             : static void
    2636        1344 : _outAlterFunctionStmt(StringInfo str, const AlterFunctionStmt *node)
    2637             : {
    2638        1344 :     WRITE_NODE_TYPE("ALTERFUNCTIONSTMT");
    2639             : 
    2640        1344 :     WRITE_ENUM_FIELD(objtype, ObjectType);
    2641        1344 :     WRITE_NODE_FIELD(func);
    2642        1344 :     WRITE_NODE_FIELD(actions);
    2643        1344 : }
    2644             : 
    2645             : static void
    2646        2200 : _outDoStmt(StringInfo str, const DoStmt *node)
    2647             : {
    2648        2200 :     WRITE_NODE_TYPE("DOSTMT");
    2649             : 
    2650        2200 :     WRITE_NODE_FIELD(args);
    2651        2200 : }
    2652             : 
    2653             : static void
    2654         898 : _outCallStmt(StringInfo str, const CallStmt *node)
    2655             : {
    2656         898 :     WRITE_NODE_TYPE("CALLSTMT");
    2657             : 
    2658         898 :     WRITE_NODE_FIELD(funccall);
    2659         898 :     WRITE_NODE_FIELD(funcexpr);
    2660         898 :     WRITE_NODE_FIELD(outargs);
    2661         898 : }
    2662             : 
    2663             : static void
    2664        2832 : _outRenameStmt(StringInfo str, const RenameStmt *node)
    2665             : {
    2666        2832 :     WRITE_NODE_TYPE("RENAMESTMT");
    2667             : 
    2668        2832 :     WRITE_ENUM_FIELD(renameType, ObjectType);
    2669        2832 :     WRITE_ENUM_FIELD(relationType, ObjectType);
    2670        2832 :     WRITE_NODE_FIELD(relation);
    2671        2832 :     WRITE_NODE_FIELD(object);
    2672        2832 :     WRITE_STRING_FIELD(subname);
    2673        2832 :     WRITE_STRING_FIELD(newname);
    2674        2832 :     WRITE_ENUM_FIELD(behavior, DropBehavior);
    2675        2832 :     WRITE_BOOL_FIELD(missing_ok);
    2676        2832 : }
    2677             : 
    2678             : static void
    2679          92 : _outAlterObjectDependsStmt(StringInfo str, const AlterObjectDependsStmt *node)
    2680             : {
    2681          92 :     WRITE_NODE_TYPE("ALTEROBJECTDEPENDSSTMT");
    2682             : 
    2683          92 :     WRITE_ENUM_FIELD(objectType, ObjectType);
    2684          92 :     WRITE_NODE_FIELD(relation);
    2685          92 :     WRITE_NODE_FIELD(object);
    2686          92 :     WRITE_NODE_FIELD(extname);
    2687          92 :     WRITE_BOOL_FIELD(remove);
    2688          92 : }
    2689             : 
    2690             : static void
    2691         796 : _outAlterObjectSchemaStmt(StringInfo str, const AlterObjectSchemaStmt *node)
    2692             : {
    2693         796 :     WRITE_NODE_TYPE("ALTEROBJECTSCHEMASTMT");
    2694             : 
    2695         796 :     WRITE_ENUM_FIELD(objectType, ObjectType);
    2696         796 :     WRITE_NODE_FIELD(relation);
    2697         796 :     WRITE_NODE_FIELD(object);
    2698         796 :     WRITE_STRING_FIELD(newschema);
    2699         796 :     WRITE_BOOL_FIELD(missing_ok);
    2700         796 : }
    2701             : 
    2702             : static void
    2703        5010 : _outAlterOwnerStmt(StringInfo str, const AlterOwnerStmt *node)
    2704             : {
    2705        5010 :     WRITE_NODE_TYPE("ALTEROWNERSTMT");
    2706             : 
    2707        5010 :     WRITE_ENUM_FIELD(objectType, ObjectType);
    2708        5010 :     WRITE_NODE_FIELD(relation);
    2709        5010 :     WRITE_NODE_FIELD(object);
    2710        5010 :     WRITE_NODE_FIELD(newowner);
    2711        5010 : }
    2712             : 
    2713             : static void
    2714        1216 : _outAlterOperatorStmt(StringInfo str, const AlterOperatorStmt *node)
    2715             : {
    2716        1216 :     WRITE_NODE_TYPE("ALTEROPERATORSTMT");
    2717             : 
    2718        1216 :     WRITE_NODE_FIELD(opername);
    2719        1216 :     WRITE_NODE_FIELD(options);
    2720        1216 : }
    2721             : 
    2722             : static void
    2723         120 : _outAlterTypeStmt(StringInfo str, const AlterTypeStmt *node)
    2724             : {
    2725         120 :     WRITE_NODE_TYPE("ALTERTYPESTMT");
    2726             : 
    2727         120 :     WRITE_NODE_FIELD(typeName);
    2728         120 :     WRITE_NODE_FIELD(options);
    2729         120 : }
    2730             : 
    2731             : static void
    2732        2332 : _outRuleStmt(StringInfo str, const RuleStmt *node)
    2733             : {
    2734        2332 :     WRITE_NODE_TYPE("RULESTMT");
    2735             : 
    2736        2332 :     WRITE_NODE_FIELD(relation);
    2737        2332 :     WRITE_STRING_FIELD(rulename);
    2738        2332 :     WRITE_NODE_FIELD(whereClause);
    2739        2332 :     WRITE_ENUM_FIELD(event, CmdType);
    2740        2332 :     WRITE_BOOL_FIELD(instead);
    2741        2332 :     WRITE_NODE_FIELD(actions);
    2742        2332 :     WRITE_BOOL_FIELD(replace);
    2743        2332 : }
    2744             : 
    2745             : static void
    2746         308 : _outNotifyStmt(StringInfo str, const NotifyStmt *node)
    2747             : {
    2748         308 :     WRITE_NODE_TYPE("NOTIFYSTMT");
    2749             : 
    2750         308 :     WRITE_STRING_FIELD(conditionname);
    2751         308 :     WRITE_STRING_FIELD(payload);
    2752         308 : }
    2753             : 
    2754             : static void
    2755         148 : _outListenStmt(StringInfo str, const ListenStmt *node)
    2756             : {
    2757         148 :     WRITE_NODE_TYPE("LISTENSTMT");
    2758             : 
    2759         148 :     WRITE_STRING_FIELD(conditionname);
    2760         148 : }
    2761             : 
    2762             : static void
    2763          76 : _outUnlistenStmt(StringInfo str, const UnlistenStmt *node)
    2764             : {
    2765          76 :     WRITE_NODE_TYPE("UNLISTENSTMT");
    2766             : 
    2767          76 :     WRITE_STRING_FIELD(conditionname);
    2768          76 : }
    2769             : 
    2770             : static void
    2771       75154 : _outTransactionStmt(StringInfo str, const TransactionStmt *node)
    2772             : {
    2773       75154 :     WRITE_NODE_TYPE("TRANSACTIONSTMT");
    2774             : 
    2775       75154 :     WRITE_ENUM_FIELD(kind, TransactionStmtKind);
    2776       75154 :     WRITE_NODE_FIELD(options);
    2777       75154 :     WRITE_STRING_FIELD(savepoint_name);
    2778       75154 :     WRITE_STRING_FIELD(gid);
    2779       75154 :     WRITE_BOOL_FIELD(chain);
    2780       75154 :     WRITE_LOCATION_FIELD(location);
    2781       75154 : }
    2782             : 
    2783             : static void
    2784        5288 : _outCompositeTypeStmt(StringInfo str, const CompositeTypeStmt *node)
    2785             : {
    2786        5288 :     WRITE_NODE_TYPE("COMPOSITETYPESTMT");
    2787             : 
    2788        5288 :     WRITE_NODE_FIELD(typevar);
    2789        5288 :     WRITE_NODE_FIELD(coldeflist);
    2790        5288 : }
    2791             : 
    2792             : static void
    2793         412 : _outCreateEnumStmt(StringInfo str, const CreateEnumStmt *node)
    2794             : {
    2795         412 :     WRITE_NODE_TYPE("CREATEENUMSTMT");
    2796             : 
    2797         412 :     WRITE_NODE_FIELD(typeName);
    2798         412 :     WRITE_NODE_FIELD(vals);
    2799         412 : }
    2800             : 
    2801             : static void
    2802         392 : _outCreateRangeStmt(StringInfo str, const CreateRangeStmt *node)
    2803             : {
    2804         392 :     WRITE_NODE_TYPE("CREATERANGESTMT");
    2805             : 
    2806         392 :     WRITE_NODE_FIELD(typeName);
    2807         392 :     WRITE_NODE_FIELD(params);
    2808         392 : }
    2809             : 
    2810             : static void
    2811         792 : _outAlterEnumStmt(StringInfo str, const AlterEnumStmt *node)
    2812             : {
    2813         792 :     WRITE_NODE_TYPE("ALTERENUMSTMT");
    2814             : 
    2815         792 :     WRITE_NODE_FIELD(typeName);
    2816         792 :     WRITE_STRING_FIELD(oldVal);
    2817         792 :     WRITE_STRING_FIELD(newVal);
    2818         792 :     WRITE_STRING_FIELD(newValNeighbor);
    2819         792 :     WRITE_BOOL_FIELD(newValIsAfter);
    2820         792 :     WRITE_BOOL_FIELD(skipIfNewValExists);
    2821         792 : }
    2822             : 
    2823             : static void
    2824       33304 : _outViewStmt(StringInfo str, const ViewStmt *node)
    2825             : {
    2826       33304 :     WRITE_NODE_TYPE("VIEWSTMT");
    2827             : 
    2828       33304 :     WRITE_NODE_FIELD(view);
    2829       33304 :     WRITE_NODE_FIELD(aliases);
    2830       33304 :     WRITE_NODE_FIELD(query);
    2831       33304 :     WRITE_BOOL_FIELD(replace);
    2832       33304 :     WRITE_NODE_FIELD(options);
    2833       33304 :     WRITE_ENUM_FIELD(withCheckOption, ViewCheckOption);
    2834       33304 : }
    2835             : 
    2836             : static void
    2837         104 : _outLoadStmt(StringInfo str, const LoadStmt *node)
    2838             : {
    2839         104 :     WRITE_NODE_TYPE("LOADSTMT");
    2840             : 
    2841         104 :     WRITE_STRING_FIELD(filename);
    2842         104 : }
    2843             : 
    2844             : static void
    2845        1564 : _outCreatedbStmt(StringInfo str, const CreatedbStmt *node)
    2846             : {
    2847        1564 :     WRITE_NODE_TYPE("CREATEDBSTMT");
    2848             : 
    2849        1564 :     WRITE_STRING_FIELD(dbname);
    2850        1564 :     WRITE_NODE_FIELD(options);
    2851        1564 : }
    2852             : 
    2853             : static void
    2854         152 : _outAlterDatabaseStmt(StringInfo str, const AlterDatabaseStmt *node)
    2855             : {
    2856         152 :     WRITE_NODE_TYPE("ALTERDATABASESTMT");
    2857             : 
    2858         152 :     WRITE_STRING_FIELD(dbname);
    2859         152 :     WRITE_NODE_FIELD(options);
    2860         152 : }
    2861             : 
    2862             : static void
    2863          12 : _outAlterDatabaseRefreshCollStmt(StringInfo str, const AlterDatabaseRefreshCollStmt *node)
    2864             : {
    2865          12 :     WRITE_NODE_TYPE("ALTERDATABASEREFRESHCOLLSTMT");
    2866             : 
    2867          12 :     WRITE_STRING_FIELD(dbname);
    2868          12 : }
    2869             : 
    2870             : static void
    2871        2388 : _outAlterDatabaseSetStmt(StringInfo str, const AlterDatabaseSetStmt *node)
    2872             : {
    2873        2388 :     WRITE_NODE_TYPE("ALTERDATABASESETSTMT");
    2874             : 
    2875        2388 :     WRITE_STRING_FIELD(dbname);
    2876        2388 :     WRITE_NODE_FIELD(setstmt);
    2877        2388 : }
    2878             : 
    2879             : static void
    2880         244 : _outDropdbStmt(StringInfo str, const DropdbStmt *node)
    2881             : {
    2882         244 :     WRITE_NODE_TYPE("DROPDBSTMT");
    2883             : 
    2884         244 :     WRITE_STRING_FIELD(dbname);
    2885         244 :     WRITE_BOOL_FIELD(missing_ok);
    2886         244 :     WRITE_NODE_FIELD(options);
    2887         244 : }
    2888             : 
    2889             : static void
    2890         364 : _outAlterSystemStmt(StringInfo str, const AlterSystemStmt *node)
    2891             : {
    2892         364 :     WRITE_NODE_TYPE("ALTERSYSTEMSTMT");
    2893             : 
    2894         364 :     WRITE_NODE_FIELD(setstmt);
    2895         364 : }
    2896             : 
    2897             : static void
    2898         456 : _outClusterStmt(StringInfo str, const ClusterStmt *node)
    2899             : {
    2900         456 :     WRITE_NODE_TYPE("CLUSTERSTMT");
    2901             : 
    2902         456 :     WRITE_NODE_FIELD(relation);
    2903         456 :     WRITE_STRING_FIELD(indexname);
    2904         456 :     WRITE_NODE_FIELD(params);
    2905         456 : }
    2906             : 
    2907             : static void
    2908       26898 : _outVacuumStmt(StringInfo str, const VacuumStmt *node)
    2909             : {
    2910       26898 :     WRITE_NODE_TYPE("VACUUMSTMT");
    2911             : 
    2912       26898 :     WRITE_NODE_FIELD(options);
    2913       26898 :     WRITE_NODE_FIELD(rels);
    2914       26898 :     WRITE_BOOL_FIELD(is_vacuumcmd);
    2915       26898 : }
    2916             : 
    2917             : static void
    2918       26446 : _outVacuumRelation(StringInfo str, const VacuumRelation *node)
    2919             : {
    2920       26446 :     WRITE_NODE_TYPE("VACUUMRELATION");
    2921             : 
    2922       26446 :     WRITE_NODE_FIELD(relation);
    2923       26446 :     WRITE_OID_FIELD(oid);
    2924       26446 :     WRITE_NODE_FIELD(va_cols);
    2925       26446 : }
    2926             : 
    2927             : static void
    2928       39392 : _outExplainStmt(StringInfo str, const ExplainStmt *node)
    2929             : {
    2930       39392 :     WRITE_NODE_TYPE("EXPLAINSTMT");
    2931             : 
    2932       39392 :     WRITE_NODE_FIELD(query);
    2933       39392 :     WRITE_NODE_FIELD(options);
    2934       39392 : }
    2935             : 
    2936             : static void
    2937        3818 : _outCreateTableAsStmt(StringInfo str, const CreateTableAsStmt *node)
    2938             : {
    2939        3818 :     WRITE_NODE_TYPE("CREATETABLEASSTMT");
    2940             : 
    2941        3818 :     WRITE_NODE_FIELD(query);
    2942        3818 :     WRITE_NODE_FIELD(into);
    2943        3818 :     WRITE_ENUM_FIELD(objtype, ObjectType);
    2944        3818 :     WRITE_BOOL_FIELD(is_select_into);
    2945        3818 :     WRITE_BOOL_FIELD(if_not_exists);
    2946        3818 : }
    2947             : 
    2948             : static void
    2949         568 : _outRefreshMatViewStmt(StringInfo str, const RefreshMatViewStmt *node)
    2950             : {
    2951         568 :     WRITE_NODE_TYPE("REFRESHMATVIEWSTMT");
    2952             : 
    2953         568 :     WRITE_BOOL_FIELD(concurrent);
    2954         568 :     WRITE_BOOL_FIELD(skipData);
    2955         568 :     WRITE_NODE_FIELD(relation);
    2956         568 : }
    2957             : 
    2958             : static void
    2959         438 : _outCheckPointStmt(StringInfo str, const CheckPointStmt *node)
    2960             : {
    2961         438 :     WRITE_NODE_TYPE("CHECKPOINTSTMT");
    2962             : 
    2963         438 : }
    2964             : 
    2965             : static void
    2966          60 : _outDiscardStmt(StringInfo str, const DiscardStmt *node)
    2967             : {
    2968          60 :     WRITE_NODE_TYPE("DISCARDSTMT");
    2969             : 
    2970          60 :     WRITE_ENUM_FIELD(target, DiscardMode);
    2971          60 : }
    2972             : 
    2973             : static void
    2974        5028 : _outLockStmt(StringInfo str, const LockStmt *node)
    2975             : {
    2976        5028 :     WRITE_NODE_TYPE("LOCKSTMT");
    2977             : 
    2978        5028 :     WRITE_NODE_FIELD(relations);
    2979        5028 :     WRITE_INT_FIELD(mode);
    2980        5028 :     WRITE_BOOL_FIELD(nowait);
    2981        5028 : }
    2982             : 
    2983             : static void
    2984         202 : _outConstraintsSetStmt(StringInfo str, const ConstraintsSetStmt *node)
    2985             : {
    2986         202 :     WRITE_NODE_TYPE("CONSTRAINTSSETSTMT");
    2987             : 
    2988         202 :     WRITE_NODE_FIELD(constraints);
    2989         202 :     WRITE_BOOL_FIELD(deferred);
    2990         202 : }
    2991             : 
    2992             : static void
    2993        2224 : _outReindexStmt(StringInfo str, const ReindexStmt *node)
    2994             : {
    2995        2224 :     WRITE_NODE_TYPE("REINDEXSTMT");
    2996             : 
    2997        2224 :     WRITE_ENUM_FIELD(kind, ReindexObjectType);
    2998        2224 :     WRITE_NODE_FIELD(relation);
    2999        2224 :     WRITE_STRING_FIELD(name);
    3000        2224 :     WRITE_NODE_FIELD(params);
    3001        2224 : }
    3002             : 
    3003             : static void
    3004         128 : _outCreateConversionStmt(StringInfo str, const CreateConversionStmt *node)
    3005             : {
    3006         128 :     WRITE_NODE_TYPE("CREATECONVERSIONSTMT");
    3007             : 
    3008         128 :     WRITE_NODE_FIELD(conversion_name);
    3009         128 :     WRITE_STRING_FIELD(for_encoding_name);
    3010         128 :     WRITE_STRING_FIELD(to_encoding_name);
    3011         128 :     WRITE_NODE_FIELD(func_name);
    3012         128 :     WRITE_BOOL_FIELD(def);
    3013         128 : }
    3014             : 
    3015             : static void
    3016         580 : _outCreateCastStmt(StringInfo str, const CreateCastStmt *node)
    3017             : {
    3018         580 :     WRITE_NODE_TYPE("CREATECASTSTMT");
    3019             : 
    3020         580 :     WRITE_NODE_FIELD(sourcetype);
    3021         580 :     WRITE_NODE_FIELD(targettype);
    3022         580 :     WRITE_NODE_FIELD(func);
    3023         580 :     WRITE_ENUM_FIELD(context, CoercionContext);
    3024         580 :     WRITE_BOOL_FIELD(inout);
    3025         580 : }
    3026             : 
    3027             : static void
    3028         104 : _outCreateTransformStmt(StringInfo str, const CreateTransformStmt *node)
    3029             : {
    3030         104 :     WRITE_NODE_TYPE("CREATETRANSFORMSTMT");
    3031             : 
    3032         104 :     WRITE_BOOL_FIELD(replace);
    3033         104 :     WRITE_NODE_FIELD(type_name);
    3034         104 :     WRITE_STRING_FIELD(lang);
    3035         104 :     WRITE_NODE_FIELD(fromsql);
    3036         104 :     WRITE_NODE_FIELD(tosql);
    3037         104 : }
    3038             : 
    3039             : static void
    3040        4276 : _outPrepareStmt(StringInfo str, const PrepareStmt *node)
    3041             : {
    3042        4276 :     WRITE_NODE_TYPE("PREPARESTMT");
    3043             : 
    3044        4276 :     WRITE_STRING_FIELD(name);
    3045        4276 :     WRITE_NODE_FIELD(argtypes);
    3046        4276 :     WRITE_NODE_FIELD(query);
    3047        4276 : }
    3048             : 
    3049             : static void
    3050       40034 : _outExecuteStmt(StringInfo str, const ExecuteStmt *node)
    3051             : {
    3052       40034 :     WRITE_NODE_TYPE("EXECUTESTMT");
    3053             : 
    3054       40034 :     WRITE_STRING_FIELD(name);
    3055       40034 :     WRITE_NODE_FIELD(params);
    3056       40034 : }
    3057             : 
    3058             : static void
    3059        8120 : _outDeallocateStmt(StringInfo str, const DeallocateStmt *node)
    3060             : {
    3061        8120 :     WRITE_NODE_TYPE("DEALLOCATESTMT");
    3062             : 
    3063        8120 :     WRITE_STRING_FIELD(name);
    3064        8120 :     WRITE_BOOL_FIELD(isall);
    3065        8120 :     WRITE_LOCATION_FIELD(location);
    3066        8120 : }
    3067             : 
    3068             : static void
    3069         308 : _outDropOwnedStmt(StringInfo str, const DropOwnedStmt *node)
    3070             : {
    3071         308 :     WRITE_NODE_TYPE("DROPOWNEDSTMT");
    3072             : 
    3073         308 :     WRITE_NODE_FIELD(roles);
    3074         308 :     WRITE_ENUM_FIELD(behavior, DropBehavior);
    3075         308 : }
    3076             : 
    3077             : static void
    3078         104 : _outReassignOwnedStmt(StringInfo str, const ReassignOwnedStmt *node)
    3079             : {
    3080         104 :     WRITE_NODE_TYPE("REASSIGNOWNEDSTMT");
    3081             : 
    3082         104 :     WRITE_NODE_FIELD(roles);
    3083         104 :     WRITE_NODE_FIELD(newrole);
    3084         104 : }
    3085             : 
    3086             : static void
    3087          80 : _outAlterTSDictionaryStmt(StringInfo str, const AlterTSDictionaryStmt *node)
    3088             : {
    3089          80 :     WRITE_NODE_TYPE("ALTERTSDICTIONARYSTMT");
    3090             : 
    3091          80 :     WRITE_NODE_FIELD(dictname);
    3092          80 :     WRITE_NODE_FIELD(options);
    3093          80 : }
    3094             : 
    3095             : static void
    3096       17140 : _outAlterTSConfigurationStmt(StringInfo str, const AlterTSConfigurationStmt *node)
    3097             : {
    3098       17140 :     WRITE_NODE_TYPE("ALTERTSCONFIGURATIONSTMT");
    3099             : 
    3100       17140 :     WRITE_ENUM_FIELD(kind, AlterTSConfigType);
    3101       17140 :     WRITE_NODE_FIELD(cfgname);
    3102       17140 :     WRITE_NODE_FIELD(tokentype);
    3103       17140 :     WRITE_NODE_FIELD(dicts);
    3104       17140 :     WRITE_BOOL_FIELD(override);
    3105       17140 :     WRITE_BOOL_FIELD(replace);
    3106       17140 :     WRITE_BOOL_FIELD(missing_ok);
    3107       17140 : }
    3108             : 
    3109             : static void
    3110        2768 : _outPublicationTable(StringInfo str, const PublicationTable *node)
    3111             : {
    3112        2768 :     WRITE_NODE_TYPE("PUBLICATIONTABLE");
    3113             : 
    3114        2768 :     WRITE_NODE_FIELD(relation);
    3115        2768 :     WRITE_NODE_FIELD(whereClause);
    3116        2768 :     WRITE_NODE_FIELD(columns);
    3117        2768 : }
    3118             : 
    3119             : static void
    3120        3480 : _outPublicationObjSpec(StringInfo str, const PublicationObjSpec *node)
    3121             : {
    3122        3480 :     WRITE_NODE_TYPE("PUBLICATIONOBJSPEC");
    3123             : 
    3124        3480 :     WRITE_ENUM_FIELD(pubobjtype, PublicationObjSpecType);
    3125        3480 :     WRITE_STRING_FIELD(name);
    3126        3480 :     WRITE_NODE_FIELD(pubtable);
    3127        3480 :     WRITE_LOCATION_FIELD(location);
    3128        3480 : }
    3129             : 
    3130             : static void
    3131        1616 : _outCreatePublicationStmt(StringInfo str, const CreatePublicationStmt *node)
    3132             : {
    3133        1616 :     WRITE_NODE_TYPE("CREATEPUBLICATIONSTMT");
    3134             : 
    3135        1616 :     WRITE_STRING_FIELD(pubname);
    3136        1616 :     WRITE_NODE_FIELD(options);
    3137        1616 :     WRITE_NODE_FIELD(pubobjects);
    3138        1616 :     WRITE_BOOL_FIELD(for_all_tables);
    3139        1616 : }
    3140             : 
    3141             : static void
    3142        2136 : _outAlterPublicationStmt(StringInfo str, const AlterPublicationStmt *node)
    3143             : {
    3144        2136 :     WRITE_NODE_TYPE("ALTERPUBLICATIONSTMT");
    3145             : 
    3146        2136 :     WRITE_STRING_FIELD(pubname);
    3147        2136 :     WRITE_NODE_FIELD(options);
    3148        2136 :     WRITE_NODE_FIELD(pubobjects);
    3149        2136 :     WRITE_BOOL_FIELD(for_all_tables);
    3150        2136 :     WRITE_ENUM_FIELD(action, AlterPublicationAction);
    3151        2136 : }
    3152             : 
    3153             : static void
    3154         896 : _outCreateSubscriptionStmt(StringInfo str, const CreateSubscriptionStmt *node)
    3155             : {
    3156         896 :     WRITE_NODE_TYPE("CREATESUBSCRIPTIONSTMT");
    3157             : 
    3158         896 :     WRITE_STRING_FIELD(subname);
    3159         896 :     WRITE_STRING_FIELD(conninfo);
    3160         896 :     WRITE_NODE_FIELD(publication);
    3161         896 :     WRITE_NODE_FIELD(options);
    3162         896 : }
    3163             : 
    3164             : static void
    3165         946 : _outAlterSubscriptionStmt(StringInfo str, const AlterSubscriptionStmt *node)
    3166             : {
    3167         946 :     WRITE_NODE_TYPE("ALTERSUBSCRIPTIONSTMT");
    3168             : 
    3169         946 :     WRITE_ENUM_FIELD(kind, AlterSubscriptionType);
    3170         946 :     WRITE_STRING_FIELD(subname);
    3171         946 :     WRITE_STRING_FIELD(conninfo);
    3172         946 :     WRITE_NODE_FIELD(publication);
    3173         946 :     WRITE_NODE_FIELD(options);
    3174         946 : }
    3175             : 
    3176             : static void
    3177         456 : _outDropSubscriptionStmt(StringInfo str, const DropSubscriptionStmt *node)
    3178             : {
    3179         456 :     WRITE_NODE_TYPE("DROPSUBSCRIPTIONSTMT");
    3180             : 
    3181         456 :     WRITE_STRING_FIELD(subname);
    3182         456 :     WRITE_BOOL_FIELD(missing_ok);
    3183         456 :     WRITE_ENUM_FIELD(behavior, DropBehavior);
    3184         456 : }
    3185             : 
    3186             : static void
    3187           0 : _outPlannerGlobal(StringInfo str, const PlannerGlobal *node)
    3188             : {
    3189           0 :     WRITE_NODE_TYPE("PLANNERGLOBAL");
    3190             : 
    3191           0 :     WRITE_NODE_FIELD(subplans);
    3192           0 :     WRITE_NODE_FIELD(subpaths);
    3193           0 :     WRITE_BITMAPSET_FIELD(rewindPlanIDs);
    3194           0 :     WRITE_NODE_FIELD(finalrtable);
    3195           0 :     WRITE_BITMAPSET_FIELD(allRelids);
    3196           0 :     WRITE_BITMAPSET_FIELD(prunableRelids);
    3197           0 :     WRITE_NODE_FIELD(finalrteperminfos);
    3198           0 :     WRITE_NODE_FIELD(finalrowmarks);
    3199           0 :     WRITE_NODE_FIELD(resultRelations);
    3200           0 :     WRITE_NODE_FIELD(appendRelations);
    3201           0 :     WRITE_NODE_FIELD(partPruneInfos);
    3202           0 :     WRITE_NODE_FIELD(relationOids);
    3203           0 :     WRITE_NODE_FIELD(invalItems);
    3204           0 :     WRITE_NODE_FIELD(paramExecTypes);
    3205           0 :     WRITE_UINT_FIELD(lastPHId);
    3206           0 :     WRITE_UINT_FIELD(lastRowMarkId);
    3207           0 :     WRITE_INT_FIELD(lastPlanNodeId);
    3208           0 :     WRITE_BOOL_FIELD(transientPlan);
    3209           0 :     WRITE_BOOL_FIELD(dependsOnRole);
    3210           0 :     WRITE_BOOL_FIELD(parallelModeOK);
    3211           0 :     WRITE_BOOL_FIELD(parallelModeNeeded);
    3212           0 :     WRITE_CHAR_FIELD(maxParallelHazard);
    3213           0 : }
    3214             : 
    3215             : static void
    3216           0 : _outPlannerInfo(StringInfo str, const PlannerInfo *node)
    3217             : {
    3218           0 :     WRITE_NODE_TYPE("PLANNERINFO");
    3219             : 
    3220           0 :     WRITE_NODE_FIELD(parse);
    3221           0 :     WRITE_NODE_FIELD(glob);
    3222           0 :     WRITE_UINT_FIELD(query_level);
    3223           0 :     WRITE_NODE_FIELD(plan_params);
    3224           0 :     WRITE_BITMAPSET_FIELD(outer_params);
    3225           0 :     WRITE_NODE_ARRAY(simple_rel_array, node->simple_rel_array_size);
    3226           0 :     WRITE_INT_FIELD(simple_rel_array_size);
    3227           0 :     WRITE_BITMAPSET_FIELD(all_baserels);
    3228           0 :     WRITE_BITMAPSET_FIELD(outer_join_rels);
    3229           0 :     WRITE_BITMAPSET_FIELD(all_query_rels);
    3230           0 :     WRITE_NODE_FIELD(join_rel_list);
    3231           0 :     WRITE_INT_FIELD(join_cur_level);
    3232           0 :     WRITE_NODE_FIELD(init_plans);
    3233           0 :     WRITE_NODE_FIELD(cte_plan_ids);
    3234           0 :     WRITE_NODE_FIELD(multiexpr_params);
    3235           0 :     WRITE_NODE_FIELD(join_domains);
    3236           0 :     WRITE_NODE_FIELD(eq_classes);
    3237           0 :     WRITE_BOOL_FIELD(ec_merging_done);
    3238           0 :     WRITE_NODE_FIELD(canon_pathkeys);
    3239           0 :     WRITE_NODE_FIELD(left_join_clauses);
    3240           0 :     WRITE_NODE_FIELD(right_join_clauses);
    3241           0 :     WRITE_NODE_FIELD(full_join_clauses);
    3242           0 :     WRITE_NODE_FIELD(join_info_list);
    3243           0 :     WRITE_INT_FIELD(last_rinfo_serial);
    3244           0 :     WRITE_BITMAPSET_FIELD(all_result_relids);
    3245           0 :     WRITE_BITMAPSET_FIELD(leaf_result_relids);
    3246           0 :     WRITE_NODE_FIELD(append_rel_list);
    3247           0 :     WRITE_NODE_FIELD(row_identity_vars);
    3248           0 :     WRITE_NODE_FIELD(rowMarks);
    3249           0 :     WRITE_NODE_FIELD(placeholder_list);
    3250           0 :     WRITE_NODE_FIELD(fkey_list);
    3251           0 :     WRITE_NODE_FIELD(query_pathkeys);
    3252           0 :     WRITE_NODE_FIELD(group_pathkeys);
    3253           0 :     WRITE_INT_FIELD(num_groupby_pathkeys);
    3254           0 :     WRITE_NODE_FIELD(window_pathkeys);
    3255           0 :     WRITE_NODE_FIELD(distinct_pathkeys);
    3256           0 :     WRITE_NODE_FIELD(sort_pathkeys);
    3257           0 :     WRITE_NODE_FIELD(setop_pathkeys);
    3258           0 :     WRITE_NODE_FIELD(processed_groupClause);
    3259           0 :     WRITE_NODE_FIELD(processed_distinctClause);
    3260           0 :     WRITE_NODE_FIELD(processed_tlist);
    3261           0 :     WRITE_NODE_FIELD(update_colnos);
    3262           0 :     WRITE_NODE_FIELD(minmax_aggs);
    3263           0 :     WRITE_FLOAT_FIELD(total_table_pages);
    3264           0 :     WRITE_FLOAT_FIELD(tuple_fraction);
    3265           0 :     WRITE_FLOAT_FIELD(limit_tuples);
    3266           0 :     WRITE_UINT_FIELD(qual_security_level);
    3267           0 :     WRITE_BOOL_FIELD(hasJoinRTEs);
    3268           0 :     WRITE_BOOL_FIELD(hasLateralRTEs);
    3269           0 :     WRITE_BOOL_FIELD(hasHavingQual);
    3270           0 :     WRITE_BOOL_FIELD(hasPseudoConstantQuals);
    3271           0 :     WRITE_BOOL_FIELD(hasAlternativeSubPlans);
    3272           0 :     WRITE_BOOL_FIELD(placeholdersFrozen);
    3273           0 :     WRITE_BOOL_FIELD(hasRecursion);
    3274           0 :     WRITE_INT_FIELD(group_rtindex);
    3275           0 :     WRITE_NODE_FIELD(agginfos);
    3276           0 :     WRITE_NODE_FIELD(aggtransinfos);
    3277           0 :     WRITE_INT_FIELD(numOrderedAggs);
    3278           0 :     WRITE_BOOL_FIELD(hasNonPartialAggs);
    3279           0 :     WRITE_BOOL_FIELD(hasNonSerialAggs);
    3280           0 :     WRITE_INT_FIELD(wt_param_id);
    3281           0 :     WRITE_NODE_FIELD(non_recursive_path);
    3282           0 :     WRITE_BITMAPSET_FIELD(curOuterRels);
    3283           0 :     WRITE_NODE_FIELD(curOuterParams);
    3284           0 :     WRITE_BOOL_FIELD(partColsUpdated);
    3285           0 :     WRITE_NODE_FIELD(partPruneInfos);
    3286           0 : }
    3287             : 
    3288             : static void
    3289           0 : _outRelOptInfo(StringInfo str, const RelOptInfo *node)
    3290             : {
    3291           0 :     WRITE_NODE_TYPE("RELOPTINFO");
    3292             : 
    3293           0 :     WRITE_ENUM_FIELD(reloptkind, RelOptKind);
    3294           0 :     WRITE_BITMAPSET_FIELD(relids);
    3295           0 :     WRITE_FLOAT_FIELD(rows);
    3296           0 :     WRITE_BOOL_FIELD(consider_startup);
    3297           0 :     WRITE_BOOL_FIELD(consider_param_startup);
    3298           0 :     WRITE_BOOL_FIELD(consider_parallel);
    3299           0 :     WRITE_NODE_FIELD(reltarget);
    3300           0 :     WRITE_NODE_FIELD(pathlist);
    3301           0 :     WRITE_NODE_FIELD(ppilist);
    3302           0 :     WRITE_NODE_FIELD(partial_pathlist);
    3303           0 :     WRITE_NODE_FIELD(cheapest_startup_path);
    3304           0 :     WRITE_NODE_FIELD(cheapest_total_path);
    3305           0 :     WRITE_NODE_FIELD(cheapest_unique_path);
    3306           0 :     WRITE_NODE_FIELD(cheapest_parameterized_paths);
    3307           0 :     WRITE_BITMAPSET_FIELD(direct_lateral_relids);
    3308           0 :     WRITE_BITMAPSET_FIELD(lateral_relids);
    3309           0 :     WRITE_UINT_FIELD(relid);
    3310           0 :     WRITE_OID_FIELD(reltablespace);
    3311           0 :     WRITE_ENUM_FIELD(rtekind, RTEKind);
    3312           0 :     WRITE_INT_FIELD(min_attr);
    3313           0 :     WRITE_INT_FIELD(max_attr);
    3314           0 :     WRITE_BITMAPSET_FIELD(notnullattnums);
    3315           0 :     WRITE_BITMAPSET_FIELD(nulling_relids);
    3316           0 :     WRITE_NODE_FIELD(lateral_vars);
    3317           0 :     WRITE_BITMAPSET_FIELD(lateral_referencers);
    3318           0 :     WRITE_NODE_FIELD(indexlist);
    3319           0 :     WRITE_NODE_FIELD(statlist);
    3320           0 :     WRITE_UINT_FIELD(pages);
    3321           0 :     WRITE_FLOAT_FIELD(tuples);
    3322           0 :     WRITE_FLOAT_FIELD(allvisfrac);
    3323           0 :     WRITE_BITMAPSET_FIELD(eclass_indexes);
    3324           0 :     WRITE_NODE_FIELD(subroot);
    3325           0 :     WRITE_NODE_FIELD(subplan_params);
    3326           0 :     WRITE_INT_FIELD(rel_parallel_workers);
    3327           0 :     WRITE_UINT_FIELD(amflags);
    3328           0 :     WRITE_OID_FIELD(serverid);
    3329           0 :     WRITE_OID_FIELD(userid);
    3330           0 :     WRITE_BOOL_FIELD(useridiscurrent);
    3331           0 :     WRITE_NODE_FIELD(unique_for_rels);
    3332           0 :     WRITE_NODE_FIELD(non_unique_for_rels);
    3333           0 :     WRITE_NODE_FIELD(baserestrictinfo);
    3334           0 :     WRITE_FLOAT_FIELD(baserestrictcost.startup);
    3335           0 :     WRITE_FLOAT_FIELD(baserestrictcost.per_tuple);
    3336           0 :     WRITE_UINT_FIELD(baserestrict_min_security);
    3337           0 :     WRITE_NODE_FIELD(joininfo);
    3338           0 :     WRITE_BOOL_FIELD(has_eclass_joins);
    3339           0 :     WRITE_BOOL_FIELD(consider_partitionwise_join);
    3340           0 :     WRITE_BITMAPSET_FIELD(top_parent_relids);
    3341           0 :     WRITE_INT_FIELD(nparts);
    3342           0 :     WRITE_BOOL_FIELD(partbounds_merged);
    3343           0 :     WRITE_NODE_FIELD(partition_qual);
    3344           0 :     WRITE_BITMAPSET_FIELD(live_parts);
    3345           0 :     WRITE_BITMAPSET_FIELD(all_partrels);
    3346           0 : }
    3347             : 
    3348             : static void
    3349           0 : _outIndexOptInfo(StringInfo str, const IndexOptInfo *node)
    3350             : {
    3351           0 :     WRITE_NODE_TYPE("INDEXOPTINFO");
    3352             : 
    3353           0 :     WRITE_OID_FIELD(indexoid);
    3354           0 :     WRITE_OID_FIELD(reltablespace);
    3355           0 :     WRITE_UINT_FIELD(pages);
    3356           0 :     WRITE_FLOAT_FIELD(tuples);
    3357           0 :     WRITE_INT_FIELD(tree_height);
    3358           0 :     WRITE_INT_FIELD(ncolumns);
    3359           0 :     WRITE_INT_FIELD(nkeycolumns);
    3360           0 :     WRITE_INT_ARRAY(indexkeys, node->ncolumns);
    3361           0 :     WRITE_OID_ARRAY(indexcollations, node->nkeycolumns);
    3362           0 :     WRITE_OID_ARRAY(opfamily, node->nkeycolumns);
    3363           0 :     WRITE_OID_ARRAY(opcintype, node->nkeycolumns);
    3364           0 :     WRITE_OID_ARRAY(sortopfamily, node->nkeycolumns);
    3365           0 :     WRITE_BOOL_ARRAY(reverse_sort, node->nkeycolumns);
    3366           0 :     WRITE_BOOL_ARRAY(nulls_first, node->nkeycolumns);
    3367           0 :     WRITE_BOOL_ARRAY(canreturn, node->ncolumns);
    3368           0 :     WRITE_OID_FIELD(relam);
    3369           0 :     WRITE_NODE_FIELD(indpred);
    3370           0 :     WRITE_NODE_FIELD(indextlist);
    3371           0 :     WRITE_NODE_FIELD(indrestrictinfo);
    3372           0 :     WRITE_BOOL_FIELD(predOK);
    3373           0 :     WRITE_BOOL_FIELD(unique);
    3374           0 :     WRITE_BOOL_FIELD(nullsnotdistinct);
    3375           0 :     WRITE_BOOL_FIELD(immediate);
    3376           0 :     WRITE_BOOL_FIELD(hypothetical);
    3377           0 :     WRITE_BOOL_FIELD(amcanorderbyop);
    3378           0 :     WRITE_BOOL_FIELD(amoptionalkey);
    3379           0 :     WRITE_BOOL_FIELD(amsearcharray);
    3380           0 :     WRITE_BOOL_FIELD(amsearchnulls);
    3381           0 :     WRITE_BOOL_FIELD(amhasgettuple);
    3382           0 :     WRITE_BOOL_FIELD(amhasgetbitmap);
    3383           0 :     WRITE_BOOL_FIELD(amcanparallel);
    3384           0 :     WRITE_BOOL_FIELD(amcanmarkpos);
    3385           0 : }
    3386             : 
    3387             : static void
    3388           0 : _outStatisticExtInfo(StringInfo str, const StatisticExtInfo *node)
    3389             : {
    3390           0 :     WRITE_NODE_TYPE("STATISTICEXTINFO");
    3391             : 
    3392           0 :     WRITE_OID_FIELD(statOid);
    3393           0 :     WRITE_BOOL_FIELD(inherit);
    3394           0 :     WRITE_CHAR_FIELD(kind);
    3395           0 :     WRITE_BITMAPSET_FIELD(keys);
    3396           0 :     WRITE_NODE_FIELD(exprs);
    3397           0 : }
    3398             : 
    3399             : static void
    3400           0 : _outJoinDomain(StringInfo str, const JoinDomain *node)
    3401             : {
    3402           0 :     WRITE_NODE_TYPE("JOINDOMAIN");
    3403             : 
    3404           0 :     WRITE_BITMAPSET_FIELD(jd_relids);
    3405           0 : }
    3406             : 
    3407             : static void
    3408           0 : _outEquivalenceMember(StringInfo str, const EquivalenceMember *node)
    3409             : {
    3410           0 :     WRITE_NODE_TYPE("EQUIVALENCEMEMBER");
    3411             : 
    3412           0 :     WRITE_NODE_FIELD(em_expr);
    3413           0 :     WRITE_BITMAPSET_FIELD(em_relids);
    3414           0 :     WRITE_BOOL_FIELD(em_is_const);
    3415           0 :     WRITE_BOOL_FIELD(em_is_child);
    3416           0 :     WRITE_OID_FIELD(em_datatype);
    3417           0 :     WRITE_NODE_FIELD(em_jdomain);
    3418           0 : }
    3419             : 
    3420             : static void
    3421           0 : _outPathKey(StringInfo str, const PathKey *node)
    3422             : {
    3423           0 :     WRITE_NODE_TYPE("PATHKEY");
    3424             : 
    3425           0 :     WRITE_NODE_FIELD(pk_eclass);
    3426           0 :     WRITE_OID_FIELD(pk_opfamily);
    3427           0 :     WRITE_ENUM_FIELD(pk_cmptype, CompareType);
    3428           0 :     WRITE_BOOL_FIELD(pk_nulls_first);
    3429           0 : }
    3430             : 
    3431             : static void
    3432           0 : _outGroupByOrdering(StringInfo str, const GroupByOrdering *node)
    3433             : {
    3434           0 :     WRITE_NODE_TYPE("GROUPBYORDERING");
    3435             : 
    3436           0 :     WRITE_NODE_FIELD(pathkeys);
    3437           0 :     WRITE_NODE_FIELD(clauses);
    3438           0 : }
    3439             : 
    3440             : static void
    3441           0 : _outPathTarget(StringInfo str, const PathTarget *node)
    3442             : {
    3443           0 :     WRITE_NODE_TYPE("PATHTARGET");
    3444             : 
    3445           0 :     WRITE_NODE_FIELD(exprs);
    3446           0 :     WRITE_INDEX_ARRAY(sortgrouprefs, list_length(node->exprs));
    3447           0 :     WRITE_FLOAT_FIELD(cost.startup);
    3448           0 :     WRITE_FLOAT_FIELD(cost.per_tuple);
    3449           0 :     WRITE_INT_FIELD(width);
    3450           0 :     WRITE_ENUM_FIELD(has_volatile_expr, VolatileFunctionStatus);
    3451           0 : }
    3452             : 
    3453             : static void
    3454           0 : _outParamPathInfo(StringInfo str, const ParamPathInfo *node)
    3455             : {
    3456           0 :     WRITE_NODE_TYPE("PARAMPATHINFO");
    3457             : 
    3458           0 :     WRITE_BITMAPSET_FIELD(ppi_req_outer);
    3459           0 :     WRITE_FLOAT_FIELD(ppi_rows);
    3460           0 :     WRITE_NODE_FIELD(ppi_clauses);
    3461           0 :     WRITE_BITMAPSET_FIELD(ppi_serials);
    3462           0 : }
    3463             : 
    3464             : static void
    3465           0 : _outPath(StringInfo str, const Path *node)
    3466             : {
    3467           0 :     WRITE_NODE_TYPE("PATH");
    3468             : 
    3469           0 :     WRITE_ENUM_FIELD(pathtype, NodeTag);
    3470           0 :     appendStringInfoString(str, " :parent_relids ");
    3471           0 :     outBitmapset(str, node->parent->relids);
    3472           0 :     if (node->pathtarget != node->parent->reltarget)
    3473           0 :         WRITE_NODE_FIELD(pathtarget);
    3474           0 :     appendStringInfoString(str, " :required_outer ");
    3475           0 :     if (node->param_info)
    3476           0 :         outBitmapset(str, node->param_info->ppi_req_outer);
    3477             :     else
    3478           0 :         outBitmapset(str, NULL);
    3479           0 :     WRITE_BOOL_FIELD(parallel_aware);
    3480           0 :     WRITE_BOOL_FIELD(parallel_safe);
    3481           0 :     WRITE_INT_FIELD(parallel_workers);
    3482           0 :     WRITE_FLOAT_FIELD(rows);
    3483           0 :     WRITE_INT_FIELD(disabled_nodes);
    3484           0 :     WRITE_FLOAT_FIELD(startup_cost);
    3485           0 :     WRITE_FLOAT_FIELD(total_cost);
    3486           0 :     WRITE_NODE_FIELD(pathkeys);
    3487           0 : }
    3488             : 
    3489             : static void
    3490           0 : _outIndexPath(StringInfo str, const IndexPath *node)
    3491             : {
    3492           0 :     WRITE_NODE_TYPE("INDEXPATH");
    3493             : 
    3494           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3495           0 :     appendStringInfoString(str, " :parent_relids ");
    3496           0 :     outBitmapset(str, node->path.parent->relids);
    3497           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3498           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3499           0 :     appendStringInfoString(str, " :required_outer ");
    3500           0 :     if (node->path.param_info)
    3501           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3502             :     else
    3503           0 :         outBitmapset(str, NULL);
    3504           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3505           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3506           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3507           0 :     WRITE_FLOAT_FIELD(path.rows);
    3508           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3509           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3510           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3511           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3512           0 :     WRITE_NODE_FIELD(indexinfo);
    3513           0 :     WRITE_NODE_FIELD(indexclauses);
    3514           0 :     WRITE_NODE_FIELD(indexorderbys);
    3515           0 :     WRITE_NODE_FIELD(indexorderbycols);
    3516           0 :     WRITE_ENUM_FIELD(indexscandir, ScanDirection);
    3517           0 :     WRITE_FLOAT_FIELD(indextotalcost);
    3518           0 :     WRITE_FLOAT_FIELD(indexselectivity);
    3519           0 : }
    3520             : 
    3521             : static void
    3522           0 : _outIndexClause(StringInfo str, const IndexClause *node)
    3523             : {
    3524           0 :     WRITE_NODE_TYPE("INDEXCLAUSE");
    3525             : 
    3526           0 :     WRITE_NODE_FIELD(rinfo);
    3527           0 :     WRITE_NODE_FIELD(indexquals);
    3528           0 :     WRITE_BOOL_FIELD(lossy);
    3529           0 :     WRITE_INT_FIELD(indexcol);
    3530           0 :     WRITE_NODE_FIELD(indexcols);
    3531           0 : }
    3532             : 
    3533             : static void
    3534           0 : _outBitmapHeapPath(StringInfo str, const BitmapHeapPath *node)
    3535             : {
    3536           0 :     WRITE_NODE_TYPE("BITMAPHEAPPATH");
    3537             : 
    3538           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3539           0 :     appendStringInfoString(str, " :parent_relids ");
    3540           0 :     outBitmapset(str, node->path.parent->relids);
    3541           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3542           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3543           0 :     appendStringInfoString(str, " :required_outer ");
    3544           0 :     if (node->path.param_info)
    3545           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3546             :     else
    3547           0 :         outBitmapset(str, NULL);
    3548           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3549           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3550           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3551           0 :     WRITE_FLOAT_FIELD(path.rows);
    3552           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3553           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3554           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3555           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3556           0 :     WRITE_NODE_FIELD(bitmapqual);
    3557           0 : }
    3558             : 
    3559             : static void
    3560           0 : _outBitmapAndPath(StringInfo str, const BitmapAndPath *node)
    3561             : {
    3562           0 :     WRITE_NODE_TYPE("BITMAPANDPATH");
    3563             : 
    3564           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3565           0 :     appendStringInfoString(str, " :parent_relids ");
    3566           0 :     outBitmapset(str, node->path.parent->relids);
    3567           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3568           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3569           0 :     appendStringInfoString(str, " :required_outer ");
    3570           0 :     if (node->path.param_info)
    3571           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3572             :     else
    3573           0 :         outBitmapset(str, NULL);
    3574           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3575           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3576           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3577           0 :     WRITE_FLOAT_FIELD(path.rows);
    3578           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3579           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3580           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3581           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3582           0 :     WRITE_NODE_FIELD(bitmapquals);
    3583           0 :     WRITE_FLOAT_FIELD(bitmapselectivity);
    3584           0 : }
    3585             : 
    3586             : static void
    3587           0 : _outBitmapOrPath(StringInfo str, const BitmapOrPath *node)
    3588             : {
    3589           0 :     WRITE_NODE_TYPE("BITMAPORPATH");
    3590             : 
    3591           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3592           0 :     appendStringInfoString(str, " :parent_relids ");
    3593           0 :     outBitmapset(str, node->path.parent->relids);
    3594           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3595           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3596           0 :     appendStringInfoString(str, " :required_outer ");
    3597           0 :     if (node->path.param_info)
    3598           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3599             :     else
    3600           0 :         outBitmapset(str, NULL);
    3601           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3602           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3603           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3604           0 :     WRITE_FLOAT_FIELD(path.rows);
    3605           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3606           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3607           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3608           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3609           0 :     WRITE_NODE_FIELD(bitmapquals);
    3610           0 :     WRITE_FLOAT_FIELD(bitmapselectivity);
    3611           0 : }
    3612             : 
    3613             : static void
    3614           0 : _outTidPath(StringInfo str, const TidPath *node)
    3615             : {
    3616           0 :     WRITE_NODE_TYPE("TIDPATH");
    3617             : 
    3618           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3619           0 :     appendStringInfoString(str, " :parent_relids ");
    3620           0 :     outBitmapset(str, node->path.parent->relids);
    3621           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3622           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3623           0 :     appendStringInfoString(str, " :required_outer ");
    3624           0 :     if (node->path.param_info)
    3625           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3626             :     else
    3627           0 :         outBitmapset(str, NULL);
    3628           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3629           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3630           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3631           0 :     WRITE_FLOAT_FIELD(path.rows);
    3632           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3633           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3634           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3635           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3636           0 :     WRITE_NODE_FIELD(tidquals);
    3637           0 : }
    3638             : 
    3639             : static void
    3640           0 : _outTidRangePath(StringInfo str, const TidRangePath *node)
    3641             : {
    3642           0 :     WRITE_NODE_TYPE("TIDRANGEPATH");
    3643             : 
    3644           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3645           0 :     appendStringInfoString(str, " :parent_relids ");
    3646           0 :     outBitmapset(str, node->path.parent->relids);
    3647           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3648           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3649           0 :     appendStringInfoString(str, " :required_outer ");
    3650           0 :     if (node->path.param_info)
    3651           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3652             :     else
    3653           0 :         outBitmapset(str, NULL);
    3654           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3655           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3656           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3657           0 :     WRITE_FLOAT_FIELD(path.rows);
    3658           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3659           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3660           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3661           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3662           0 :     WRITE_NODE_FIELD(tidrangequals);
    3663           0 : }
    3664             : 
    3665             : static void
    3666           0 : _outSubqueryScanPath(StringInfo str, const SubqueryScanPath *node)
    3667             : {
    3668           0 :     WRITE_NODE_TYPE("SUBQUERYSCANPATH");
    3669             : 
    3670           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3671           0 :     appendStringInfoString(str, " :parent_relids ");
    3672           0 :     outBitmapset(str, node->path.parent->relids);
    3673           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3674           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3675           0 :     appendStringInfoString(str, " :required_outer ");
    3676           0 :     if (node->path.param_info)
    3677           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3678             :     else
    3679           0 :         outBitmapset(str, NULL);
    3680           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3681           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3682           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3683           0 :     WRITE_FLOAT_FIELD(path.rows);
    3684           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3685           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3686           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3687           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3688           0 :     WRITE_NODE_FIELD(subpath);
    3689           0 : }
    3690             : 
    3691             : static void
    3692           0 : _outForeignPath(StringInfo str, const ForeignPath *node)
    3693             : {
    3694           0 :     WRITE_NODE_TYPE("FOREIGNPATH");
    3695             : 
    3696           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3697           0 :     appendStringInfoString(str, " :parent_relids ");
    3698           0 :     outBitmapset(str, node->path.parent->relids);
    3699           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3700           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3701           0 :     appendStringInfoString(str, " :required_outer ");
    3702           0 :     if (node->path.param_info)
    3703           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3704             :     else
    3705           0 :         outBitmapset(str, NULL);
    3706           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3707           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3708           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3709           0 :     WRITE_FLOAT_FIELD(path.rows);
    3710           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3711           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3712           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3713           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3714           0 :     WRITE_NODE_FIELD(fdw_outerpath);
    3715           0 :     WRITE_NODE_FIELD(fdw_restrictinfo);
    3716           0 :     WRITE_NODE_FIELD(fdw_private);
    3717           0 : }
    3718             : 
    3719             : static void
    3720           0 : _outCustomPath(StringInfo str, const CustomPath *node)
    3721             : {
    3722           0 :     WRITE_NODE_TYPE("CUSTOMPATH");
    3723             : 
    3724           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3725           0 :     appendStringInfoString(str, " :parent_relids ");
    3726           0 :     outBitmapset(str, node->path.parent->relids);
    3727           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3728           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3729           0 :     appendStringInfoString(str, " :required_outer ");
    3730           0 :     if (node->path.param_info)
    3731           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3732             :     else
    3733           0 :         outBitmapset(str, NULL);
    3734           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3735           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3736           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3737           0 :     WRITE_FLOAT_FIELD(path.rows);
    3738           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3739           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3740           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3741           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3742           0 :     WRITE_UINT_FIELD(flags);
    3743           0 :     WRITE_NODE_FIELD(custom_paths);
    3744           0 :     WRITE_NODE_FIELD(custom_restrictinfo);
    3745           0 :     WRITE_NODE_FIELD(custom_private);
    3746             : 
    3747             :     /* CustomName is a key to lookup CustomScanMethods */
    3748           0 :     appendStringInfoString(str, " :methods ");
    3749           0 :     outToken(str, node->methods->CustomName);
    3750           0 : }
    3751             : 
    3752             : static void
    3753           0 : _outAppendPath(StringInfo str, const AppendPath *node)
    3754             : {
    3755           0 :     WRITE_NODE_TYPE("APPENDPATH");
    3756             : 
    3757           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3758           0 :     appendStringInfoString(str, " :parent_relids ");
    3759           0 :     outBitmapset(str, node->path.parent->relids);
    3760           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3761           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3762           0 :     appendStringInfoString(str, " :required_outer ");
    3763           0 :     if (node->path.param_info)
    3764           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3765             :     else
    3766           0 :         outBitmapset(str, NULL);
    3767           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3768           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3769           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3770           0 :     WRITE_FLOAT_FIELD(path.rows);
    3771           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3772           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3773           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3774           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3775           0 :     WRITE_NODE_FIELD(subpaths);
    3776           0 :     WRITE_INT_FIELD(first_partial_path);
    3777           0 :     WRITE_FLOAT_FIELD(limit_tuples);
    3778           0 : }
    3779             : 
    3780             : static void
    3781           0 : _outMergeAppendPath(StringInfo str, const MergeAppendPath *node)
    3782             : {
    3783           0 :     WRITE_NODE_TYPE("MERGEAPPENDPATH");
    3784             : 
    3785           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3786           0 :     appendStringInfoString(str, " :parent_relids ");
    3787           0 :     outBitmapset(str, node->path.parent->relids);
    3788           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3789           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3790           0 :     appendStringInfoString(str, " :required_outer ");
    3791           0 :     if (node->path.param_info)
    3792           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3793             :     else
    3794           0 :         outBitmapset(str, NULL);
    3795           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3796           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3797           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3798           0 :     WRITE_FLOAT_FIELD(path.rows);
    3799           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3800           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3801           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3802           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3803           0 :     WRITE_NODE_FIELD(subpaths);
    3804           0 :     WRITE_FLOAT_FIELD(limit_tuples);
    3805           0 : }
    3806             : 
    3807             : static void
    3808           0 : _outGroupResultPath(StringInfo str, const GroupResultPath *node)
    3809             : {
    3810           0 :     WRITE_NODE_TYPE("GROUPRESULTPATH");
    3811             : 
    3812           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3813           0 :     appendStringInfoString(str, " :parent_relids ");
    3814           0 :     outBitmapset(str, node->path.parent->relids);
    3815           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3816           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3817           0 :     appendStringInfoString(str, " :required_outer ");
    3818           0 :     if (node->path.param_info)
    3819           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3820             :     else
    3821           0 :         outBitmapset(str, NULL);
    3822           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3823           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3824           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3825           0 :     WRITE_FLOAT_FIELD(path.rows);
    3826           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3827           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3828           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3829           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3830           0 :     WRITE_NODE_FIELD(quals);
    3831           0 : }
    3832             : 
    3833             : static void
    3834           0 : _outMaterialPath(StringInfo str, const MaterialPath *node)
    3835             : {
    3836           0 :     WRITE_NODE_TYPE("MATERIALPATH");
    3837             : 
    3838           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3839           0 :     appendStringInfoString(str, " :parent_relids ");
    3840           0 :     outBitmapset(str, node->path.parent->relids);
    3841           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3842           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3843           0 :     appendStringInfoString(str, " :required_outer ");
    3844           0 :     if (node->path.param_info)
    3845           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3846             :     else
    3847           0 :         outBitmapset(str, NULL);
    3848           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3849           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3850           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3851           0 :     WRITE_FLOAT_FIELD(path.rows);
    3852           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3853           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3854           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3855           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3856           0 :     WRITE_NODE_FIELD(subpath);
    3857           0 : }
    3858             : 
    3859             : static void
    3860           0 : _outMemoizePath(StringInfo str, const MemoizePath *node)
    3861             : {
    3862           0 :     WRITE_NODE_TYPE("MEMOIZEPATH");
    3863             : 
    3864           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3865           0 :     appendStringInfoString(str, " :parent_relids ");
    3866           0 :     outBitmapset(str, node->path.parent->relids);
    3867           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3868           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3869           0 :     appendStringInfoString(str, " :required_outer ");
    3870           0 :     if (node->path.param_info)
    3871           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3872             :     else
    3873           0 :         outBitmapset(str, NULL);
    3874           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3875           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3876           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3877           0 :     WRITE_FLOAT_FIELD(path.rows);
    3878           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3879           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3880           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3881           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3882           0 :     WRITE_NODE_FIELD(subpath);
    3883           0 :     WRITE_NODE_FIELD(hash_operators);
    3884           0 :     WRITE_NODE_FIELD(param_exprs);
    3885           0 :     WRITE_BOOL_FIELD(singlerow);
    3886           0 :     WRITE_BOOL_FIELD(binary_mode);
    3887           0 :     WRITE_FLOAT_FIELD(calls);
    3888           0 :     WRITE_UINT_FIELD(est_entries);
    3889           0 : }
    3890             : 
    3891             : static void
    3892           0 : _outUniquePath(StringInfo str, const UniquePath *node)
    3893             : {
    3894           0 :     WRITE_NODE_TYPE("UNIQUEPATH");
    3895             : 
    3896           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3897           0 :     appendStringInfoString(str, " :parent_relids ");
    3898           0 :     outBitmapset(str, node->path.parent->relids);
    3899           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3900           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3901           0 :     appendStringInfoString(str, " :required_outer ");
    3902           0 :     if (node->path.param_info)
    3903           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3904             :     else
    3905           0 :         outBitmapset(str, NULL);
    3906           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3907           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3908           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3909           0 :     WRITE_FLOAT_FIELD(path.rows);
    3910           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3911           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3912           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3913           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3914           0 :     WRITE_NODE_FIELD(subpath);
    3915           0 :     WRITE_ENUM_FIELD(umethod, UniquePathMethod);
    3916           0 :     WRITE_NODE_FIELD(in_operators);
    3917           0 :     WRITE_NODE_FIELD(uniq_exprs);
    3918           0 : }
    3919             : 
    3920             : static void
    3921           0 : _outGatherPath(StringInfo str, const GatherPath *node)
    3922             : {
    3923           0 :     WRITE_NODE_TYPE("GATHERPATH");
    3924             : 
    3925           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3926           0 :     appendStringInfoString(str, " :parent_relids ");
    3927           0 :     outBitmapset(str, node->path.parent->relids);
    3928           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3929           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3930           0 :     appendStringInfoString(str, " :required_outer ");
    3931           0 :     if (node->path.param_info)
    3932           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3933             :     else
    3934           0 :         outBitmapset(str, NULL);
    3935           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3936           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3937           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3938           0 :     WRITE_FLOAT_FIELD(path.rows);
    3939           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3940           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3941           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3942           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3943           0 :     WRITE_NODE_FIELD(subpath);
    3944           0 :     WRITE_BOOL_FIELD(single_copy);
    3945           0 :     WRITE_INT_FIELD(num_workers);
    3946           0 : }
    3947             : 
    3948             : static void
    3949           0 : _outGatherMergePath(StringInfo str, const GatherMergePath *node)
    3950             : {
    3951           0 :     WRITE_NODE_TYPE("GATHERMERGEPATH");
    3952             : 
    3953           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    3954           0 :     appendStringInfoString(str, " :parent_relids ");
    3955           0 :     outBitmapset(str, node->path.parent->relids);
    3956           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    3957           0 :         WRITE_NODE_FIELD(path.pathtarget);
    3958           0 :     appendStringInfoString(str, " :required_outer ");
    3959           0 :     if (node->path.param_info)
    3960           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    3961             :     else
    3962           0 :         outBitmapset(str, NULL);
    3963           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    3964           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    3965           0 :     WRITE_INT_FIELD(path.parallel_workers);
    3966           0 :     WRITE_FLOAT_FIELD(path.rows);
    3967           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    3968           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    3969           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    3970           0 :     WRITE_NODE_FIELD(path.pathkeys);
    3971           0 :     WRITE_NODE_FIELD(subpath);
    3972           0 :     WRITE_INT_FIELD(num_workers);
    3973           0 : }
    3974             : 
    3975             : static void
    3976           0 : _outNestPath(StringInfo str, const NestPath *node)
    3977             : {
    3978           0 :     WRITE_NODE_TYPE("NESTPATH");
    3979             : 
    3980           0 :     WRITE_ENUM_FIELD(jpath.path.pathtype, NodeTag);
    3981           0 :     appendStringInfoString(str, " :parent_relids ");
    3982           0 :     outBitmapset(str, node->jpath.path.parent->relids);
    3983           0 :     if (node->jpath.path.pathtarget != node->jpath.path.parent->reltarget)
    3984           0 :         WRITE_NODE_FIELD(jpath.path.pathtarget);
    3985           0 :     appendStringInfoString(str, " :required_outer ");
    3986           0 :     if (node->jpath.path.param_info)
    3987           0 :         outBitmapset(str, node->jpath.path.param_info->ppi_req_outer);
    3988             :     else
    3989           0 :         outBitmapset(str, NULL);
    3990           0 :     WRITE_BOOL_FIELD(jpath.path.parallel_aware);
    3991           0 :     WRITE_BOOL_FIELD(jpath.path.parallel_safe);
    3992           0 :     WRITE_INT_FIELD(jpath.path.parallel_workers);
    3993           0 :     WRITE_FLOAT_FIELD(jpath.path.rows);
    3994           0 :     WRITE_INT_FIELD(jpath.path.disabled_nodes);
    3995           0 :     WRITE_FLOAT_FIELD(jpath.path.startup_cost);
    3996           0 :     WRITE_FLOAT_FIELD(jpath.path.total_cost);
    3997           0 :     WRITE_NODE_FIELD(jpath.path.pathkeys);
    3998           0 :     WRITE_ENUM_FIELD(jpath.jointype, JoinType);
    3999           0 :     WRITE_BOOL_FIELD(jpath.inner_unique);
    4000           0 :     WRITE_NODE_FIELD(jpath.outerjoinpath);
    4001           0 :     WRITE_NODE_FIELD(jpath.innerjoinpath);
    4002           0 :     WRITE_NODE_FIELD(jpath.joinrestrictinfo);
    4003           0 : }
    4004             : 
    4005             : static void
    4006           0 : _outMergePath(StringInfo str, const MergePath *node)
    4007             : {
    4008           0 :     WRITE_NODE_TYPE("MERGEPATH");
    4009             : 
    4010           0 :     WRITE_ENUM_FIELD(jpath.path.pathtype, NodeTag);
    4011           0 :     appendStringInfoString(str, " :parent_relids ");
    4012           0 :     outBitmapset(str, node->jpath.path.parent->relids);
    4013           0 :     if (node->jpath.path.pathtarget != node->jpath.path.parent->reltarget)
    4014           0 :         WRITE_NODE_FIELD(jpath.path.pathtarget);
    4015           0 :     appendStringInfoString(str, " :required_outer ");
    4016           0 :     if (node->jpath.path.param_info)
    4017           0 :         outBitmapset(str, node->jpath.path.param_info->ppi_req_outer);
    4018             :     else
    4019           0 :         outBitmapset(str, NULL);
    4020           0 :     WRITE_BOOL_FIELD(jpath.path.parallel_aware);
    4021           0 :     WRITE_BOOL_FIELD(jpath.path.parallel_safe);
    4022           0 :     WRITE_INT_FIELD(jpath.path.parallel_workers);
    4023           0 :     WRITE_FLOAT_FIELD(jpath.path.rows);
    4024           0 :     WRITE_INT_FIELD(jpath.path.disabled_nodes);
    4025           0 :     WRITE_FLOAT_FIELD(jpath.path.startup_cost);
    4026           0 :     WRITE_FLOAT_FIELD(jpath.path.total_cost);
    4027           0 :     WRITE_NODE_FIELD(jpath.path.pathkeys);
    4028           0 :     WRITE_ENUM_FIELD(jpath.jointype, JoinType);
    4029           0 :     WRITE_BOOL_FIELD(jpath.inner_unique);
    4030           0 :     WRITE_NODE_FIELD(jpath.outerjoinpath);
    4031           0 :     WRITE_NODE_FIELD(jpath.innerjoinpath);
    4032           0 :     WRITE_NODE_FIELD(jpath.joinrestrictinfo);
    4033           0 :     WRITE_NODE_FIELD(path_mergeclauses);
    4034           0 :     WRITE_NODE_FIELD(outersortkeys);
    4035           0 :     WRITE_NODE_FIELD(innersortkeys);
    4036           0 :     WRITE_INT_FIELD(outer_presorted_keys);
    4037           0 :     WRITE_BOOL_FIELD(skip_mark_restore);
    4038           0 :     WRITE_BOOL_FIELD(materialize_inner);
    4039           0 : }
    4040             : 
    4041             : static void
    4042           0 : _outHashPath(StringInfo str, const HashPath *node)
    4043             : {
    4044           0 :     WRITE_NODE_TYPE("HASHPATH");
    4045             : 
    4046           0 :     WRITE_ENUM_FIELD(jpath.path.pathtype, NodeTag);
    4047           0 :     appendStringInfoString(str, " :parent_relids ");
    4048           0 :     outBitmapset(str, node->jpath.path.parent->relids);
    4049           0 :     if (node->jpath.path.pathtarget != node->jpath.path.parent->reltarget)
    4050           0 :         WRITE_NODE_FIELD(jpath.path.pathtarget);
    4051           0 :     appendStringInfoString(str, " :required_outer ");
    4052           0 :     if (node->jpath.path.param_info)
    4053           0 :         outBitmapset(str, node->jpath.path.param_info->ppi_req_outer);
    4054             :     else
    4055           0 :         outBitmapset(str, NULL);
    4056           0 :     WRITE_BOOL_FIELD(jpath.path.parallel_aware);
    4057           0 :     WRITE_BOOL_FIELD(jpath.path.parallel_safe);
    4058           0 :     WRITE_INT_FIELD(jpath.path.parallel_workers);
    4059           0 :     WRITE_FLOAT_FIELD(jpath.path.rows);
    4060           0 :     WRITE_INT_FIELD(jpath.path.disabled_nodes);
    4061           0 :     WRITE_FLOAT_FIELD(jpath.path.startup_cost);
    4062           0 :     WRITE_FLOAT_FIELD(jpath.path.total_cost);
    4063           0 :     WRITE_NODE_FIELD(jpath.path.pathkeys);
    4064           0 :     WRITE_ENUM_FIELD(jpath.jointype, JoinType);
    4065           0 :     WRITE_BOOL_FIELD(jpath.inner_unique);
    4066           0 :     WRITE_NODE_FIELD(jpath.outerjoinpath);
    4067           0 :     WRITE_NODE_FIELD(jpath.innerjoinpath);
    4068           0 :     WRITE_NODE_FIELD(jpath.joinrestrictinfo);
    4069           0 :     WRITE_NODE_FIELD(path_hashclauses);
    4070           0 :     WRITE_INT_FIELD(num_batches);
    4071           0 :     WRITE_FLOAT_FIELD(inner_rows_total);
    4072           0 : }
    4073             : 
    4074             : static void
    4075           0 : _outProjectionPath(StringInfo str, const ProjectionPath *node)
    4076             : {
    4077           0 :     WRITE_NODE_TYPE("PROJECTIONPATH");
    4078             : 
    4079           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4080           0 :     appendStringInfoString(str, " :parent_relids ");
    4081           0 :     outBitmapset(str, node->path.parent->relids);
    4082           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4083           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4084           0 :     appendStringInfoString(str, " :required_outer ");
    4085           0 :     if (node->path.param_info)
    4086           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4087             :     else
    4088           0 :         outBitmapset(str, NULL);
    4089           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4090           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4091           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4092           0 :     WRITE_FLOAT_FIELD(path.rows);
    4093           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4094           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4095           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4096           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4097           0 :     WRITE_NODE_FIELD(subpath);
    4098           0 :     WRITE_BOOL_FIELD(dummypp);
    4099           0 : }
    4100             : 
    4101             : static void
    4102           0 : _outProjectSetPath(StringInfo str, const ProjectSetPath *node)
    4103             : {
    4104           0 :     WRITE_NODE_TYPE("PROJECTSETPATH");
    4105             : 
    4106           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4107           0 :     appendStringInfoString(str, " :parent_relids ");
    4108           0 :     outBitmapset(str, node->path.parent->relids);
    4109           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4110           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4111           0 :     appendStringInfoString(str, " :required_outer ");
    4112           0 :     if (node->path.param_info)
    4113           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4114             :     else
    4115           0 :         outBitmapset(str, NULL);
    4116           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4117           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4118           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4119           0 :     WRITE_FLOAT_FIELD(path.rows);
    4120           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4121           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4122           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4123           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4124           0 :     WRITE_NODE_FIELD(subpath);
    4125           0 : }
    4126             : 
    4127             : static void
    4128           0 : _outSortPath(StringInfo str, const SortPath *node)
    4129             : {
    4130           0 :     WRITE_NODE_TYPE("SORTPATH");
    4131             : 
    4132           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4133           0 :     appendStringInfoString(str, " :parent_relids ");
    4134           0 :     outBitmapset(str, node->path.parent->relids);
    4135           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4136           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4137           0 :     appendStringInfoString(str, " :required_outer ");
    4138           0 :     if (node->path.param_info)
    4139           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4140             :     else
    4141           0 :         outBitmapset(str, NULL);
    4142           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4143           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4144           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4145           0 :     WRITE_FLOAT_FIELD(path.rows);
    4146           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4147           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4148           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4149           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4150           0 :     WRITE_NODE_FIELD(subpath);
    4151           0 : }
    4152             : 
    4153             : static void
    4154           0 : _outIncrementalSortPath(StringInfo str, const IncrementalSortPath *node)
    4155             : {
    4156           0 :     WRITE_NODE_TYPE("INCREMENTALSORTPATH");
    4157             : 
    4158           0 :     WRITE_ENUM_FIELD(spath.path.pathtype, NodeTag);
    4159           0 :     appendStringInfoString(str, " :parent_relids ");
    4160           0 :     outBitmapset(str, node->spath.path.parent->relids);
    4161           0 :     if (node->spath.path.pathtarget != node->spath.path.parent->reltarget)
    4162           0 :         WRITE_NODE_FIELD(spath.path.pathtarget);
    4163           0 :     appendStringInfoString(str, " :required_outer ");
    4164           0 :     if (node->spath.path.param_info)
    4165           0 :         outBitmapset(str, node->spath.path.param_info->ppi_req_outer);
    4166             :     else
    4167           0 :         outBitmapset(str, NULL);
    4168           0 :     WRITE_BOOL_FIELD(spath.path.parallel_aware);
    4169           0 :     WRITE_BOOL_FIELD(spath.path.parallel_safe);
    4170           0 :     WRITE_INT_FIELD(spath.path.parallel_workers);
    4171           0 :     WRITE_FLOAT_FIELD(spath.path.rows);
    4172           0 :     WRITE_INT_FIELD(spath.path.disabled_nodes);
    4173           0 :     WRITE_FLOAT_FIELD(spath.path.startup_cost);
    4174           0 :     WRITE_FLOAT_FIELD(spath.path.total_cost);
    4175           0 :     WRITE_NODE_FIELD(spath.path.pathkeys);
    4176           0 :     WRITE_NODE_FIELD(spath.subpath);
    4177           0 :     WRITE_INT_FIELD(nPresortedCols);
    4178           0 : }
    4179             : 
    4180             : static void
    4181           0 : _outGroupPath(StringInfo str, const GroupPath *node)
    4182             : {
    4183           0 :     WRITE_NODE_TYPE("GROUPPATH");
    4184             : 
    4185           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4186           0 :     appendStringInfoString(str, " :parent_relids ");
    4187           0 :     outBitmapset(str, node->path.parent->relids);
    4188           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4189           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4190           0 :     appendStringInfoString(str, " :required_outer ");
    4191           0 :     if (node->path.param_info)
    4192           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4193             :     else
    4194           0 :         outBitmapset(str, NULL);
    4195           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4196           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4197           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4198           0 :     WRITE_FLOAT_FIELD(path.rows);
    4199           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4200           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4201           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4202           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4203           0 :     WRITE_NODE_FIELD(subpath);
    4204           0 :     WRITE_NODE_FIELD(groupClause);
    4205           0 :     WRITE_NODE_FIELD(qual);
    4206           0 : }
    4207             : 
    4208             : static void
    4209           0 : _outUpperUniquePath(StringInfo str, const UpperUniquePath *node)
    4210             : {
    4211           0 :     WRITE_NODE_TYPE("UPPERUNIQUEPATH");
    4212             : 
    4213           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4214           0 :     appendStringInfoString(str, " :parent_relids ");
    4215           0 :     outBitmapset(str, node->path.parent->relids);
    4216           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4217           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4218           0 :     appendStringInfoString(str, " :required_outer ");
    4219           0 :     if (node->path.param_info)
    4220           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4221             :     else
    4222           0 :         outBitmapset(str, NULL);
    4223           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4224           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4225           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4226           0 :     WRITE_FLOAT_FIELD(path.rows);
    4227           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4228           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4229           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4230           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4231           0 :     WRITE_NODE_FIELD(subpath);
    4232           0 :     WRITE_INT_FIELD(numkeys);
    4233           0 : }
    4234             : 
    4235             : static void
    4236           0 : _outAggPath(StringInfo str, const AggPath *node)
    4237             : {
    4238           0 :     WRITE_NODE_TYPE("AGGPATH");
    4239             : 
    4240           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4241           0 :     appendStringInfoString(str, " :parent_relids ");
    4242           0 :     outBitmapset(str, node->path.parent->relids);
    4243           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4244           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4245           0 :     appendStringInfoString(str, " :required_outer ");
    4246           0 :     if (node->path.param_info)
    4247           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4248             :     else
    4249           0 :         outBitmapset(str, NULL);
    4250           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4251           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4252           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4253           0 :     WRITE_FLOAT_FIELD(path.rows);
    4254           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4255           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4256           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4257           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4258           0 :     WRITE_NODE_FIELD(subpath);
    4259           0 :     WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
    4260           0 :     WRITE_ENUM_FIELD(aggsplit, AggSplit);
    4261           0 :     WRITE_FLOAT_FIELD(numGroups);
    4262           0 :     WRITE_UINT64_FIELD(transitionSpace);
    4263           0 :     WRITE_NODE_FIELD(groupClause);
    4264           0 :     WRITE_NODE_FIELD(qual);
    4265           0 : }
    4266             : 
    4267             : static void
    4268           0 : _outGroupingSetData(StringInfo str, const GroupingSetData *node)
    4269             : {
    4270           0 :     WRITE_NODE_TYPE("GROUPINGSETDATA");
    4271             : 
    4272           0 :     WRITE_NODE_FIELD(set);
    4273           0 :     WRITE_FLOAT_FIELD(numGroups);
    4274           0 : }
    4275             : 
    4276             : static void
    4277           0 : _outRollupData(StringInfo str, const RollupData *node)
    4278             : {
    4279           0 :     WRITE_NODE_TYPE("ROLLUPDATA");
    4280             : 
    4281           0 :     WRITE_NODE_FIELD(groupClause);
    4282           0 :     WRITE_NODE_FIELD(gsets);
    4283           0 :     WRITE_NODE_FIELD(gsets_data);
    4284           0 :     WRITE_FLOAT_FIELD(numGroups);
    4285           0 :     WRITE_BOOL_FIELD(hashable);
    4286           0 :     WRITE_BOOL_FIELD(is_hashed);
    4287           0 : }
    4288             : 
    4289             : static void
    4290           0 : _outGroupingSetsPath(StringInfo str, const GroupingSetsPath *node)
    4291             : {
    4292           0 :     WRITE_NODE_TYPE("GROUPINGSETSPATH");
    4293             : 
    4294           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4295           0 :     appendStringInfoString(str, " :parent_relids ");
    4296           0 :     outBitmapset(str, node->path.parent->relids);
    4297           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4298           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4299           0 :     appendStringInfoString(str, " :required_outer ");
    4300           0 :     if (node->path.param_info)
    4301           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4302             :     else
    4303           0 :         outBitmapset(str, NULL);
    4304           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4305           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4306           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4307           0 :     WRITE_FLOAT_FIELD(path.rows);
    4308           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4309           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4310           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4311           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4312           0 :     WRITE_NODE_FIELD(subpath);
    4313           0 :     WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
    4314           0 :     WRITE_NODE_FIELD(rollups);
    4315           0 :     WRITE_NODE_FIELD(qual);
    4316           0 :     WRITE_UINT64_FIELD(transitionSpace);
    4317           0 : }
    4318             : 
    4319             : static void
    4320           0 : _outMinMaxAggPath(StringInfo str, const MinMaxAggPath *node)
    4321             : {
    4322           0 :     WRITE_NODE_TYPE("MINMAXAGGPATH");
    4323             : 
    4324           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4325           0 :     appendStringInfoString(str, " :parent_relids ");
    4326           0 :     outBitmapset(str, node->path.parent->relids);
    4327           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4328           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4329           0 :     appendStringInfoString(str, " :required_outer ");
    4330           0 :     if (node->path.param_info)
    4331           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4332             :     else
    4333           0 :         outBitmapset(str, NULL);
    4334           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4335           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4336           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4337           0 :     WRITE_FLOAT_FIELD(path.rows);
    4338           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4339           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4340           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4341           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4342           0 :     WRITE_NODE_FIELD(mmaggregates);
    4343           0 :     WRITE_NODE_FIELD(quals);
    4344           0 : }
    4345             : 
    4346             : static void
    4347           0 : _outWindowAggPath(StringInfo str, const WindowAggPath *node)
    4348             : {
    4349           0 :     WRITE_NODE_TYPE("WINDOWAGGPATH");
    4350             : 
    4351           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4352           0 :     appendStringInfoString(str, " :parent_relids ");
    4353           0 :     outBitmapset(str, node->path.parent->relids);
    4354           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4355           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4356           0 :     appendStringInfoString(str, " :required_outer ");
    4357           0 :     if (node->path.param_info)
    4358           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4359             :     else
    4360           0 :         outBitmapset(str, NULL);
    4361           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4362           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4363           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4364           0 :     WRITE_FLOAT_FIELD(path.rows);
    4365           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4366           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4367           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4368           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4369           0 :     WRITE_NODE_FIELD(subpath);
    4370           0 :     WRITE_NODE_FIELD(winclause);
    4371           0 :     WRITE_NODE_FIELD(qual);
    4372           0 :     WRITE_NODE_FIELD(runCondition);
    4373           0 :     WRITE_BOOL_FIELD(topwindow);
    4374           0 : }
    4375             : 
    4376             : static void
    4377           0 : _outSetOpPath(StringInfo str, const SetOpPath *node)
    4378             : {
    4379           0 :     WRITE_NODE_TYPE("SETOPPATH");
    4380             : 
    4381           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4382           0 :     appendStringInfoString(str, " :parent_relids ");
    4383           0 :     outBitmapset(str, node->path.parent->relids);
    4384           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4385           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4386           0 :     appendStringInfoString(str, " :required_outer ");
    4387           0 :     if (node->path.param_info)
    4388           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4389             :     else
    4390           0 :         outBitmapset(str, NULL);
    4391           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4392           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4393           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4394           0 :     WRITE_FLOAT_FIELD(path.rows);
    4395           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4396           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4397           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4398           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4399           0 :     WRITE_NODE_FIELD(leftpath);
    4400           0 :     WRITE_NODE_FIELD(rightpath);
    4401           0 :     WRITE_ENUM_FIELD(cmd, SetOpCmd);
    4402           0 :     WRITE_ENUM_FIELD(strategy, SetOpStrategy);
    4403           0 :     WRITE_NODE_FIELD(groupList);
    4404           0 :     WRITE_FLOAT_FIELD(numGroups);
    4405           0 : }
    4406             : 
    4407             : static void
    4408           0 : _outRecursiveUnionPath(StringInfo str, const RecursiveUnionPath *node)
    4409             : {
    4410           0 :     WRITE_NODE_TYPE("RECURSIVEUNIONPATH");
    4411             : 
    4412           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4413           0 :     appendStringInfoString(str, " :parent_relids ");
    4414           0 :     outBitmapset(str, node->path.parent->relids);
    4415           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4416           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4417           0 :     appendStringInfoString(str, " :required_outer ");
    4418           0 :     if (node->path.param_info)
    4419           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4420             :     else
    4421           0 :         outBitmapset(str, NULL);
    4422           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4423           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4424           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4425           0 :     WRITE_FLOAT_FIELD(path.rows);
    4426           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4427           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4428           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4429           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4430           0 :     WRITE_NODE_FIELD(leftpath);
    4431           0 :     WRITE_NODE_FIELD(rightpath);
    4432           0 :     WRITE_NODE_FIELD(distinctList);
    4433           0 :     WRITE_INT_FIELD(wtParam);
    4434           0 :     WRITE_FLOAT_FIELD(numGroups);
    4435           0 : }
    4436             : 
    4437             : static void
    4438           0 : _outLockRowsPath(StringInfo str, const LockRowsPath *node)
    4439             : {
    4440           0 :     WRITE_NODE_TYPE("LOCKROWSPATH");
    4441             : 
    4442           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4443           0 :     appendStringInfoString(str, " :parent_relids ");
    4444           0 :     outBitmapset(str, node->path.parent->relids);
    4445           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4446           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4447           0 :     appendStringInfoString(str, " :required_outer ");
    4448           0 :     if (node->path.param_info)
    4449           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4450             :     else
    4451           0 :         outBitmapset(str, NULL);
    4452           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4453           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4454           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4455           0 :     WRITE_FLOAT_FIELD(path.rows);
    4456           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4457           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4458           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4459           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4460           0 :     WRITE_NODE_FIELD(subpath);
    4461           0 :     WRITE_NODE_FIELD(rowMarks);
    4462           0 :     WRITE_INT_FIELD(epqParam);
    4463           0 : }
    4464             : 
    4465             : static void
    4466           0 : _outModifyTablePath(StringInfo str, const ModifyTablePath *node)
    4467             : {
    4468           0 :     WRITE_NODE_TYPE("MODIFYTABLEPATH");
    4469             : 
    4470           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4471           0 :     appendStringInfoString(str, " :parent_relids ");
    4472           0 :     outBitmapset(str, node->path.parent->relids);
    4473           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4474           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4475           0 :     appendStringInfoString(str, " :required_outer ");
    4476           0 :     if (node->path.param_info)
    4477           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4478             :     else
    4479           0 :         outBitmapset(str, NULL);
    4480           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4481           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4482           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4483           0 :     WRITE_FLOAT_FIELD(path.rows);
    4484           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4485           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4486           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4487           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4488           0 :     WRITE_NODE_FIELD(subpath);
    4489           0 :     WRITE_ENUM_FIELD(operation, CmdType);
    4490           0 :     WRITE_BOOL_FIELD(canSetTag);
    4491           0 :     WRITE_UINT_FIELD(nominalRelation);
    4492           0 :     WRITE_UINT_FIELD(rootRelation);
    4493           0 :     WRITE_BOOL_FIELD(partColsUpdated);
    4494           0 :     WRITE_NODE_FIELD(resultRelations);
    4495           0 :     WRITE_NODE_FIELD(updateColnosLists);
    4496           0 :     WRITE_NODE_FIELD(withCheckOptionLists);
    4497           0 :     WRITE_NODE_FIELD(returningLists);
    4498           0 :     WRITE_NODE_FIELD(rowMarks);
    4499           0 :     WRITE_NODE_FIELD(onconflict);
    4500           0 :     WRITE_INT_FIELD(epqParam);
    4501           0 :     WRITE_NODE_FIELD(mergeActionLists);
    4502           0 :     WRITE_NODE_FIELD(mergeJoinConditions);
    4503           0 : }
    4504             : 
    4505             : static void
    4506           0 : _outLimitPath(StringInfo str, const LimitPath *node)
    4507             : {
    4508           0 :     WRITE_NODE_TYPE("LIMITPATH");
    4509             : 
    4510           0 :     WRITE_ENUM_FIELD(path.pathtype, NodeTag);
    4511           0 :     appendStringInfoString(str, " :parent_relids ");
    4512           0 :     outBitmapset(str, node->path.parent->relids);
    4513           0 :     if (node->path.pathtarget != node->path.parent->reltarget)
    4514           0 :         WRITE_NODE_FIELD(path.pathtarget);
    4515           0 :     appendStringInfoString(str, " :required_outer ");
    4516           0 :     if (node->path.param_info)
    4517           0 :         outBitmapset(str, node->path.param_info->ppi_req_outer);
    4518             :     else
    4519           0 :         outBitmapset(str, NULL);
    4520           0 :     WRITE_BOOL_FIELD(path.parallel_aware);
    4521           0 :     WRITE_BOOL_FIELD(path.parallel_safe);
    4522           0 :     WRITE_INT_FIELD(path.parallel_workers);
    4523           0 :     WRITE_FLOAT_FIELD(path.rows);
    4524           0 :     WRITE_INT_FIELD(path.disabled_nodes);
    4525           0 :     WRITE_FLOAT_FIELD(path.startup_cost);
    4526           0 :     WRITE_FLOAT_FIELD(path.total_cost);
    4527           0 :     WRITE_NODE_FIELD(path.pathkeys);
    4528           0 :     WRITE_NODE_FIELD(subpath);
    4529           0 :     WRITE_NODE_FIELD(limitOffset);
    4530           0 :     WRITE_NODE_FIELD(limitCount);
    4531           0 :     WRITE_ENUM_FIELD(limitOption, LimitOption);
    4532           0 : }
    4533             : 
    4534             : static void
    4535           0 : _outRestrictInfo(StringInfo str, const RestrictInfo *node)
    4536             : {
    4537           0 :     WRITE_NODE_TYPE("RESTRICTINFO");
    4538             : 
    4539           0 :     WRITE_NODE_FIELD(clause);
    4540           0 :     WRITE_BOOL_FIELD(is_pushed_down);
    4541           0 :     WRITE_BOOL_FIELD(can_join);
    4542           0 :     WRITE_BOOL_FIELD(pseudoconstant);
    4543           0 :     WRITE_BOOL_FIELD(has_clone);
    4544           0 :     WRITE_BOOL_FIELD(is_clone);
    4545           0 :     WRITE_BOOL_FIELD(leakproof);
    4546           0 :     WRITE_ENUM_FIELD(has_volatile, VolatileFunctionStatus);
    4547           0 :     WRITE_UINT_FIELD(security_level);
    4548           0 :     WRITE_INT_FIELD(num_base_rels);
    4549           0 :     WRITE_BITMAPSET_FIELD(clause_relids);
    4550           0 :     WRITE_BITMAPSET_FIELD(required_relids);
    4551           0 :     WRITE_BITMAPSET_FIELD(incompatible_relids);
    4552           0 :     WRITE_BITMAPSET_FIELD(outer_relids);
    4553           0 :     WRITE_BITMAPSET_FIELD(left_relids);
    4554           0 :     WRITE_BITMAPSET_FIELD(right_relids);
    4555           0 :     WRITE_NODE_FIELD(orclause);
    4556           0 :     WRITE_INT_FIELD(rinfo_serial);
    4557           0 :     WRITE_FLOAT_FIELD(eval_cost.startup);
    4558           0 :     WRITE_FLOAT_FIELD(eval_cost.per_tuple);
    4559           0 :     WRITE_FLOAT_FIELD(norm_selec);
    4560           0 :     WRITE_FLOAT_FIELD(outer_selec);
    4561           0 :     WRITE_NODE_FIELD(mergeopfamilies);
    4562           0 :     WRITE_NODE_FIELD(left_em);
    4563           0 :     WRITE_NODE_FIELD(right_em);
    4564           0 :     WRITE_BOOL_FIELD(outer_is_left);
    4565           0 :     WRITE_OID_FIELD(hashjoinoperator);
    4566           0 :     WRITE_FLOAT_FIELD(left_bucketsize);
    4567           0 :     WRITE_FLOAT_FIELD(right_bucketsize);
    4568           0 :     WRITE_FLOAT_FIELD(left_mcvfreq);
    4569           0 :     WRITE_FLOAT_FIELD(right_mcvfreq);
    4570           0 :     WRITE_OID_FIELD(left_hasheqoperator);
    4571           0 :     WRITE_OID_FIELD(right_hasheqoperator);
    4572           0 : }
    4573             : 
    4574             : static void
    4575           0 : _outPlaceHolderVar(StringInfo str, const PlaceHolderVar *node)
    4576             : {
    4577           0 :     WRITE_NODE_TYPE("PLACEHOLDERVAR");
    4578             : 
    4579           0 :     WRITE_NODE_FIELD(phexpr);
    4580           0 :     WRITE_BITMAPSET_FIELD(phrels);
    4581           0 :     WRITE_BITMAPSET_FIELD(phnullingrels);
    4582           0 :     WRITE_UINT_FIELD(phid);
    4583           0 :     WRITE_UINT_FIELD(phlevelsup);
    4584           0 : }
    4585             : 
    4586             : static void
    4587           0 : _outSpecialJoinInfo(StringInfo str, const SpecialJoinInfo *node)
    4588             : {
    4589           0 :     WRITE_NODE_TYPE("SPECIALJOININFO");
    4590             : 
    4591           0 :     WRITE_BITMAPSET_FIELD(min_lefthand);
    4592           0 :     WRITE_BITMAPSET_FIELD(min_righthand);
    4593           0 :     WRITE_BITMAPSET_FIELD(syn_lefthand);
    4594           0 :     WRITE_BITMAPSET_FIELD(syn_righthand);
    4595           0 :     WRITE_ENUM_FIELD(jointype, JoinType);
    4596           0 :     WRITE_UINT_FIELD(ojrelid);
    4597           0 :     WRITE_BITMAPSET_FIELD(commute_above_l);
    4598           0 :     WRITE_BITMAPSET_FIELD(commute_above_r);
    4599           0 :     WRITE_BITMAPSET_FIELD(commute_below_l);
    4600           0 :     WRITE_BITMAPSET_FIELD(commute_below_r);
    4601           0 :     WRITE_BOOL_FIELD(lhs_strict);
    4602           0 :     WRITE_BOOL_FIELD(semi_can_btree);
    4603           0 :     WRITE_BOOL_FIELD(semi_can_hash);
    4604           0 :     WRITE_NODE_FIELD(semi_operators);
    4605           0 :     WRITE_NODE_FIELD(semi_rhs_exprs);
    4606           0 : }
    4607             : 
    4608             : static void
    4609           0 : _outOuterJoinClauseInfo(StringInfo str, const OuterJoinClauseInfo *node)
    4610             : {
    4611           0 :     WRITE_NODE_TYPE("OUTERJOINCLAUSEINFO");
    4612             : 
    4613           0 :     WRITE_NODE_FIELD(rinfo);
    4614           0 :     WRITE_NODE_FIELD(sjinfo);
    4615           0 : }
    4616             : 
    4617             : static void
    4618       50298 : _outAppendRelInfo(StringInfo str, const AppendRelInfo *node)
    4619             : {
    4620       50298 :     WRITE_NODE_TYPE("APPENDRELINFO");
    4621             : 
    4622       50298 :     WRITE_UINT_FIELD(parent_relid);
    4623       50298 :     WRITE_UINT_FIELD(child_relid);
    4624       50298 :     WRITE_OID_FIELD(parent_reltype);
    4625       50298 :     WRITE_OID_FIELD(child_reltype);
    4626       50298 :     WRITE_NODE_FIELD(translated_vars);
    4627       50298 :     WRITE_INT_FIELD(num_child_cols);
    4628       50298 :     WRITE_ATTRNUMBER_ARRAY(parent_colnos, node->num_child_cols);
    4629       50298 :     WRITE_OID_FIELD(parent_reloid);
    4630       50298 : }
    4631             : 
    4632             : static void
    4633           0 : _outRowIdentityVarInfo(StringInfo str, const RowIdentityVarInfo *node)
    4634             : {
    4635           0 :     WRITE_NODE_TYPE("ROWIDENTITYVARINFO");
    4636             : 
    4637           0 :     WRITE_NODE_FIELD(rowidvar);
    4638           0 :     WRITE_INT_FIELD(rowidwidth);
    4639           0 :     WRITE_STRING_FIELD(rowidname);
    4640           0 :     WRITE_BITMAPSET_FIELD(rowidrels);
    4641           0 : }
    4642             : 
    4643             : static void
    4644           0 : _outPlaceHolderInfo(StringInfo str, const PlaceHolderInfo *node)
    4645             : {
    4646           0 :     WRITE_NODE_TYPE("PLACEHOLDERINFO");
    4647             : 
    4648           0 :     WRITE_UINT_FIELD(phid);
    4649           0 :     WRITE_NODE_FIELD(ph_var);
    4650           0 :     WRITE_BITMAPSET_FIELD(ph_eval_at);
    4651           0 :     WRITE_BITMAPSET_FIELD(ph_lateral);
    4652           0 :     WRITE_BITMAPSET_FIELD(ph_needed);
    4653           0 :     WRITE_INT_FIELD(ph_width);
    4654           0 : }
    4655             : 
    4656             : static void
    4657           0 : _outMinMaxAggInfo(StringInfo str, const MinMaxAggInfo *node)
    4658             : {
    4659           0 :     WRITE_NODE_TYPE("MINMAXAGGINFO");
    4660             : 
    4661           0 :     WRITE_OID_FIELD(aggfnoid);
    4662           0 :     WRITE_OID_FIELD(aggsortop);
    4663           0 :     WRITE_NODE_FIELD(target);
    4664           0 :     WRITE_NODE_FIELD(path);
    4665           0 :     WRITE_FLOAT_FIELD(pathcost);
    4666           0 :     WRITE_NODE_FIELD(param);
    4667           0 : }
    4668             : 
    4669             : static void
    4670           0 : _outPlannerParamItem(StringInfo str, const PlannerParamItem *node)
    4671             : {
    4672           0 :     WRITE_NODE_TYPE("PLANNERPARAMITEM");
    4673             : 
    4674           0 :     WRITE_NODE_FIELD(item);
    4675           0 :     WRITE_INT_FIELD(paramId);
    4676           0 : }
    4677             : 
    4678             : static void
    4679           0 : _outAggInfo(StringInfo str, const AggInfo *node)
    4680             : {
    4681           0 :     WRITE_NODE_TYPE("AGGINFO");
    4682             : 
    4683           0 :     WRITE_NODE_FIELD(aggrefs);
    4684           0 :     WRITE_INT_FIELD(transno);
    4685           0 :     WRITE_BOOL_FIELD(shareable);
    4686           0 :     WRITE_OID_FIELD(finalfn_oid);
    4687           0 : }
    4688             : 
    4689             : static void
    4690           0 : _outAggTransInfo(StringInfo str, const AggTransInfo *node)
    4691             : {
    4692           0 :     WRITE_NODE_TYPE("AGGTRANSINFO");
    4693             : 
    4694           0 :     WRITE_NODE_FIELD(args);
    4695           0 :     WRITE_NODE_FIELD(aggfilter);
    4696           0 :     WRITE_OID_FIELD(transfn_oid);
    4697           0 :     WRITE_OID_FIELD(serialfn_oid);
    4698           0 :     WRITE_OID_FIELD(deserialfn_oid);
    4699           0 :     WRITE_OID_FIELD(combinefn_oid);
    4700           0 :     WRITE_OID_FIELD(aggtranstype);
    4701           0 :     WRITE_INT_FIELD(aggtranstypmod);
    4702           0 :     WRITE_INT_FIELD(transtypeLen);
    4703           0 :     WRITE_BOOL_FIELD(transtypeByVal);
    4704           0 :     WRITE_INT_FIELD(aggtransspace);
    4705           0 :     WRITE_BOOL_FIELD(initValueIsNull);
    4706           0 : }
    4707             : 
    4708             : static void
    4709           0 : _outUniqueRelInfo(StringInfo str, const UniqueRelInfo *node)
    4710             : {
    4711           0 :     WRITE_NODE_TYPE("UNIQUERELINFO");
    4712             : 
    4713           0 :     WRITE_BITMAPSET_FIELD(outerrelids);
    4714           0 :     WRITE_BOOL_FIELD(self_join);
    4715           0 :     WRITE_NODE_FIELD(extra_clauses);
    4716           0 : }
    4717             : 
    4718             : static void
    4719      447866 : _outPlannedStmt(StringInfo str, const PlannedStmt *node)
    4720             : {
    4721      447866 :     WRITE_NODE_TYPE("PLANNEDSTMT");
    4722             : 
    4723      447866 :     WRITE_ENUM_FIELD(commandType, CmdType);
    4724      447866 :     WRITE_INT64_FIELD(queryId);
    4725      447866 :     WRITE_INT64_FIELD(planId);
    4726      447866 :     WRITE_BOOL_FIELD(hasReturning);
    4727      447866 :     WRITE_BOOL_FIELD(hasModifyingCTE);
    4728      447866 :     WRITE_BOOL_FIELD(canSetTag);
    4729      447866 :     WRITE_BOOL_FIELD(transientPlan);
    4730      447866 :     WRITE_BOOL_FIELD(dependsOnRole);
    4731      447866 :     WRITE_BOOL_FIELD(parallelModeNeeded);
    4732      447866 :     WRITE_INT_FIELD(jitFlags);
    4733      447866 :     WRITE_NODE_FIELD(planTree);
    4734      447866 :     WRITE_NODE_FIELD(partPruneInfos);
    4735      447866 :     WRITE_NODE_FIELD(rtable);
    4736      447866 :     WRITE_BITMAPSET_FIELD(unprunableRelids);
    4737      447866 :     WRITE_NODE_FIELD(permInfos);
    4738      447866 :     WRITE_NODE_FIELD(resultRelations);
    4739      447866 :     WRITE_NODE_FIELD(appendRelations);
    4740      447866 :     WRITE_NODE_FIELD(subplans);
    4741      447866 :     WRITE_BITMAPSET_FIELD(rewindPlanIDs);
    4742      447866 :     WRITE_NODE_FIELD(rowMarks);
    4743      447866 :     WRITE_NODE_FIELD(relationOids);
    4744      447866 :     WRITE_NODE_FIELD(invalItems);
    4745      447866 :     WRITE_NODE_FIELD(paramExecTypes);
    4746      447866 :     WRITE_NODE_FIELD(utilityStmt);
    4747      447866 :     WRITE_LOCATION_FIELD(stmt_location);
    4748      447866 :     WRITE_LOCATION_FIELD(stmt_len);
    4749      447866 : }
    4750             : 
    4751             : static void
    4752      206294 : _outResult(StringInfo str, const Result *node)
    4753             : {
    4754      206294 :     WRITE_NODE_TYPE("RESULT");
    4755             : 
    4756      206294 :     WRITE_INT_FIELD(plan.disabled_nodes);
    4757      206294 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    4758      206294 :     WRITE_FLOAT_FIELD(plan.total_cost);
    4759      206294 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    4760      206294 :     WRITE_INT_FIELD(plan.plan_width);
    4761      206294 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    4762      206294 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    4763      206294 :     WRITE_BOOL_FIELD(plan.async_capable);
    4764      206294 :     WRITE_INT_FIELD(plan.plan_node_id);
    4765      206294 :     WRITE_NODE_FIELD(plan.targetlist);
    4766      206294 :     WRITE_NODE_FIELD(plan.qual);
    4767      206294 :     WRITE_NODE_FIELD(plan.lefttree);
    4768      206294 :     WRITE_NODE_FIELD(plan.righttree);
    4769      206294 :     WRITE_NODE_FIELD(plan.initPlan);
    4770      206294 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    4771      206294 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    4772      206294 :     WRITE_NODE_FIELD(resconstantqual);
    4773      206294 : }
    4774             : 
    4775             : static void
    4776       12048 : _outProjectSet(StringInfo str, const ProjectSet *node)
    4777             : {
    4778       12048 :     WRITE_NODE_TYPE("PROJECTSET");
    4779             : 
    4780       12048 :     WRITE_INT_FIELD(plan.disabled_nodes);
    4781       12048 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    4782       12048 :     WRITE_FLOAT_FIELD(plan.total_cost);
    4783       12048 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    4784       12048 :     WRITE_INT_FIELD(plan.plan_width);
    4785       12048 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    4786       12048 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    4787       12048 :     WRITE_BOOL_FIELD(plan.async_capable);
    4788       12048 :     WRITE_INT_FIELD(plan.plan_node_id);
    4789       12048 :     WRITE_NODE_FIELD(plan.targetlist);
    4790       12048 :     WRITE_NODE_FIELD(plan.qual);
    4791       12048 :     WRITE_NODE_FIELD(plan.lefttree);
    4792       12048 :     WRITE_NODE_FIELD(plan.righttree);
    4793       12048 :     WRITE_NODE_FIELD(plan.initPlan);
    4794       12048 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    4795       12048 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    4796       12048 : }
    4797             : 
    4798             : static void
    4799       86006 : _outModifyTable(StringInfo str, const ModifyTable *node)
    4800             : {
    4801       86006 :     WRITE_NODE_TYPE("MODIFYTABLE");
    4802             : 
    4803       86006 :     WRITE_INT_FIELD(plan.disabled_nodes);
    4804       86006 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    4805       86006 :     WRITE_FLOAT_FIELD(plan.total_cost);
    4806       86006 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    4807       86006 :     WRITE_INT_FIELD(plan.plan_width);
    4808       86006 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    4809       86006 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    4810       86006 :     WRITE_BOOL_FIELD(plan.async_capable);
    4811       86006 :     WRITE_INT_FIELD(plan.plan_node_id);
    4812       86006 :     WRITE_NODE_FIELD(plan.targetlist);
    4813       86006 :     WRITE_NODE_FIELD(plan.qual);
    4814       86006 :     WRITE_NODE_FIELD(plan.lefttree);
    4815       86006 :     WRITE_NODE_FIELD(plan.righttree);
    4816       86006 :     WRITE_NODE_FIELD(plan.initPlan);
    4817       86006 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    4818       86006 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    4819       86006 :     WRITE_ENUM_FIELD(operation, CmdType);
    4820       86006 :     WRITE_BOOL_FIELD(canSetTag);
    4821       86006 :     WRITE_UINT_FIELD(nominalRelation);
    4822       86006 :     WRITE_UINT_FIELD(rootRelation);
    4823       86006 :     WRITE_BOOL_FIELD(partColsUpdated);
    4824       86006 :     WRITE_NODE_FIELD(resultRelations);
    4825       86006 :     WRITE_NODE_FIELD(updateColnosLists);
    4826       86006 :     WRITE_NODE_FIELD(withCheckOptionLists);
    4827       86006 :     WRITE_STRING_FIELD(returningOldAlias);
    4828       86006 :     WRITE_STRING_FIELD(returningNewAlias);
    4829       86006 :     WRITE_NODE_FIELD(returningLists);
    4830       86006 :     WRITE_NODE_FIELD(fdwPrivLists);
    4831       86006 :     WRITE_BITMAPSET_FIELD(fdwDirectModifyPlans);
    4832       86006 :     WRITE_NODE_FIELD(rowMarks);
    4833       86006 :     WRITE_INT_FIELD(epqParam);
    4834       86006 :     WRITE_ENUM_FIELD(onConflictAction, OnConflictAction);
    4835       86006 :     WRITE_NODE_FIELD(arbiterIndexes);
    4836       86006 :     WRITE_NODE_FIELD(onConflictSet);
    4837       86006 :     WRITE_NODE_FIELD(onConflictCols);
    4838       86006 :     WRITE_NODE_FIELD(onConflictWhere);
    4839       86006 :     WRITE_UINT_FIELD(exclRelRTI);
    4840       86006 :     WRITE_NODE_FIELD(exclRelTlist);
    4841       86006 :     WRITE_NODE_FIELD(mergeActionLists);
    4842       86006 :     WRITE_NODE_FIELD(mergeJoinConditions);
    4843       86006 : }
    4844             : 
    4845             : static void
    4846       16980 : _outAppend(StringInfo str, const Append *node)
    4847             : {
    4848       16980 :     WRITE_NODE_TYPE("APPEND");
    4849             : 
    4850       16980 :     WRITE_INT_FIELD(plan.disabled_nodes);
    4851       16980 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    4852       16980 :     WRITE_FLOAT_FIELD(plan.total_cost);
    4853       16980 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    4854       16980 :     WRITE_INT_FIELD(plan.plan_width);
    4855       16980 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    4856       16980 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    4857       16980 :     WRITE_BOOL_FIELD(plan.async_capable);
    4858       16980 :     WRITE_INT_FIELD(plan.plan_node_id);
    4859       16980 :     WRITE_NODE_FIELD(plan.targetlist);
    4860       16980 :     WRITE_NODE_FIELD(plan.qual);
    4861       16980 :     WRITE_NODE_FIELD(plan.lefttree);
    4862       16980 :     WRITE_NODE_FIELD(plan.righttree);
    4863       16980 :     WRITE_NODE_FIELD(plan.initPlan);
    4864       16980 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    4865       16980 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    4866       16980 :     WRITE_BITMAPSET_FIELD(apprelids);
    4867       16980 :     WRITE_NODE_FIELD(appendplans);
    4868       16980 :     WRITE_INT_FIELD(nasyncplans);
    4869       16980 :     WRITE_INT_FIELD(first_partial_plan);
    4870       16980 :     WRITE_INT_FIELD(part_prune_index);
    4871       16980 : }
    4872             : 
    4873             : static void
    4874         526 : _outMergeAppend(StringInfo str, const MergeAppend *node)
    4875             : {
    4876         526 :     WRITE_NODE_TYPE("MERGEAPPEND");
    4877             : 
    4878         526 :     WRITE_INT_FIELD(plan.disabled_nodes);
    4879         526 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    4880         526 :     WRITE_FLOAT_FIELD(plan.total_cost);
    4881         526 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    4882         526 :     WRITE_INT_FIELD(plan.plan_width);
    4883         526 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    4884         526 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    4885         526 :     WRITE_BOOL_FIELD(plan.async_capable);
    4886         526 :     WRITE_INT_FIELD(plan.plan_node_id);
    4887         526 :     WRITE_NODE_FIELD(plan.targetlist);
    4888         526 :     WRITE_NODE_FIELD(plan.qual);
    4889         526 :     WRITE_NODE_FIELD(plan.lefttree);
    4890         526 :     WRITE_NODE_FIELD(plan.righttree);
    4891         526 :     WRITE_NODE_FIELD(plan.initPlan);
    4892         526 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    4893         526 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    4894         526 :     WRITE_BITMAPSET_FIELD(apprelids);
    4895         526 :     WRITE_NODE_FIELD(mergeplans);
    4896         526 :     WRITE_INT_FIELD(numCols);
    4897         526 :     WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
    4898         526 :     WRITE_OID_ARRAY(sortOperators, node->numCols);
    4899         526 :     WRITE_OID_ARRAY(collations, node->numCols);
    4900         526 :     WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
    4901         526 :     WRITE_INT_FIELD(part_prune_index);
    4902         526 : }
    4903             : 
    4904             : static void
    4905        1004 : _outRecursiveUnion(StringInfo str, const RecursiveUnion *node)
    4906             : {
    4907        1004 :     WRITE_NODE_TYPE("RECURSIVEUNION");
    4908             : 
    4909        1004 :     WRITE_INT_FIELD(plan.disabled_nodes);
    4910        1004 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    4911        1004 :     WRITE_FLOAT_FIELD(plan.total_cost);
    4912        1004 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    4913        1004 :     WRITE_INT_FIELD(plan.plan_width);
    4914        1004 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    4915        1004 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    4916        1004 :     WRITE_BOOL_FIELD(plan.async_capable);
    4917        1004 :     WRITE_INT_FIELD(plan.plan_node_id);
    4918        1004 :     WRITE_NODE_FIELD(plan.targetlist);
    4919        1004 :     WRITE_NODE_FIELD(plan.qual);
    4920        1004 :     WRITE_NODE_FIELD(plan.lefttree);
    4921        1004 :     WRITE_NODE_FIELD(plan.righttree);
    4922        1004 :     WRITE_NODE_FIELD(plan.initPlan);
    4923        1004 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    4924        1004 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    4925        1004 :     WRITE_INT_FIELD(wtParam);
    4926        1004 :     WRITE_INT_FIELD(numCols);
    4927        1004 :     WRITE_ATTRNUMBER_ARRAY(dupColIdx, node->numCols);
    4928        1004 :     WRITE_OID_ARRAY(dupOperators, node->numCols);
    4929        1004 :     WRITE_OID_ARRAY(dupCollations, node->numCols);
    4930        1004 :     WRITE_LONG_FIELD(numGroups);
    4931        1004 : }
    4932             : 
    4933             : static void
    4934         222 : _outBitmapAnd(StringInfo str, const BitmapAnd *node)
    4935             : {
    4936         222 :     WRITE_NODE_TYPE("BITMAPAND");
    4937             : 
    4938         222 :     WRITE_INT_FIELD(plan.disabled_nodes);
    4939         222 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    4940         222 :     WRITE_FLOAT_FIELD(plan.total_cost);
    4941         222 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    4942         222 :     WRITE_INT_FIELD(plan.plan_width);
    4943         222 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    4944         222 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    4945         222 :     WRITE_BOOL_FIELD(plan.async_capable);
    4946         222 :     WRITE_INT_FIELD(plan.plan_node_id);
    4947         222 :     WRITE_NODE_FIELD(plan.targetlist);
    4948         222 :     WRITE_NODE_FIELD(plan.qual);
    4949         222 :     WRITE_NODE_FIELD(plan.lefttree);
    4950         222 :     WRITE_NODE_FIELD(plan.righttree);
    4951         222 :     WRITE_NODE_FIELD(plan.initPlan);
    4952         222 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    4953         222 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    4954         222 :     WRITE_NODE_FIELD(bitmapplans);
    4955         222 : }
    4956             : 
    4957             : static void
    4958         392 : _outBitmapOr(StringInfo str, const BitmapOr *node)
    4959             : {
    4960         392 :     WRITE_NODE_TYPE("BITMAPOR");
    4961             : 
    4962         392 :     WRITE_INT_FIELD(plan.disabled_nodes);
    4963         392 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    4964         392 :     WRITE_FLOAT_FIELD(plan.total_cost);
    4965         392 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    4966         392 :     WRITE_INT_FIELD(plan.plan_width);
    4967         392 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    4968         392 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    4969         392 :     WRITE_BOOL_FIELD(plan.async_capable);
    4970         392 :     WRITE_INT_FIELD(plan.plan_node_id);
    4971         392 :     WRITE_NODE_FIELD(plan.targetlist);
    4972         392 :     WRITE_NODE_FIELD(plan.qual);
    4973         392 :     WRITE_NODE_FIELD(plan.lefttree);
    4974         392 :     WRITE_NODE_FIELD(plan.righttree);
    4975         392 :     WRITE_NODE_FIELD(plan.initPlan);
    4976         392 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    4977         392 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    4978         392 :     WRITE_BOOL_FIELD(isshared);
    4979         392 :     WRITE_NODE_FIELD(bitmapplans);
    4980         392 : }
    4981             : 
    4982             : static void
    4983      215952 : _outSeqScan(StringInfo str, const SeqScan *node)
    4984             : {
    4985      215952 :     WRITE_NODE_TYPE("SEQSCAN");
    4986             : 
    4987      215952 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    4988      215952 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    4989      215952 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    4990      215952 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    4991      215952 :     WRITE_INT_FIELD(scan.plan.plan_width);
    4992      215952 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    4993      215952 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    4994      215952 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    4995      215952 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    4996      215952 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    4997      215952 :     WRITE_NODE_FIELD(scan.plan.qual);
    4998      215952 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    4999      215952 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5000      215952 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5001      215952 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5002      215952 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5003      215952 :     WRITE_UINT_FIELD(scan.scanrelid);
    5004      215952 : }
    5005             : 
    5006             : static void
    5007         306 : _outSampleScan(StringInfo str, const SampleScan *node)
    5008             : {
    5009         306 :     WRITE_NODE_TYPE("SAMPLESCAN");
    5010             : 
    5011         306 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5012         306 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5013         306 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5014         306 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5015         306 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5016         306 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5017         306 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5018         306 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5019         306 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5020         306 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5021         306 :     WRITE_NODE_FIELD(scan.plan.qual);
    5022         306 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5023         306 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5024         306 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5025         306 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5026         306 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5027         306 :     WRITE_UINT_FIELD(scan.scanrelid);
    5028         306 :     WRITE_NODE_FIELD(tablesample);
    5029         306 : }
    5030             : 
    5031             : static void
    5032      142908 : _outIndexScan(StringInfo str, const IndexScan *node)
    5033             : {
    5034      142908 :     WRITE_NODE_TYPE("INDEXSCAN");
    5035             : 
    5036      142908 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5037      142908 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5038      142908 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5039      142908 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5040      142908 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5041      142908 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5042      142908 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5043      142908 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5044      142908 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5045      142908 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5046      142908 :     WRITE_NODE_FIELD(scan.plan.qual);
    5047      142908 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5048      142908 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5049      142908 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5050      142908 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5051      142908 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5052      142908 :     WRITE_UINT_FIELD(scan.scanrelid);
    5053      142908 :     WRITE_OID_FIELD(indexid);
    5054      142908 :     WRITE_NODE_FIELD(indexqual);
    5055      142908 :     WRITE_NODE_FIELD(indexqualorig);
    5056      142908 :     WRITE_NODE_FIELD(indexorderby);
    5057      142908 :     WRITE_NODE_FIELD(indexorderbyorig);
    5058      142908 :     WRITE_NODE_FIELD(indexorderbyops);
    5059      142908 :     WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
    5060      142908 : }
    5061             : 
    5062             : static void
    5063       16284 : _outIndexOnlyScan(StringInfo str, const IndexOnlyScan *node)
    5064             : {
    5065       16284 :     WRITE_NODE_TYPE("INDEXONLYSCAN");
    5066             : 
    5067       16284 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5068       16284 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5069       16284 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5070       16284 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5071       16284 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5072       16284 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5073       16284 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5074       16284 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5075       16284 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5076       16284 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5077       16284 :     WRITE_NODE_FIELD(scan.plan.qual);
    5078       16284 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5079       16284 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5080       16284 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5081       16284 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5082       16284 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5083       16284 :     WRITE_UINT_FIELD(scan.scanrelid);
    5084       16284 :     WRITE_OID_FIELD(indexid);
    5085       16284 :     WRITE_NODE_FIELD(indexqual);
    5086       16284 :     WRITE_NODE_FIELD(recheckqual);
    5087       16284 :     WRITE_NODE_FIELD(indexorderby);
    5088       16284 :     WRITE_NODE_FIELD(indextlist);
    5089       16284 :     WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
    5090       16284 : }
    5091             : 
    5092             : static void
    5093       20454 : _outBitmapIndexScan(StringInfo str, const BitmapIndexScan *node)
    5094             : {
    5095       20454 :     WRITE_NODE_TYPE("BITMAPINDEXSCAN");
    5096             : 
    5097       20454 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5098       20454 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5099       20454 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5100       20454 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5101       20454 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5102       20454 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5103       20454 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5104       20454 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5105       20454 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5106       20454 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5107       20454 :     WRITE_NODE_FIELD(scan.plan.qual);
    5108       20454 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5109       20454 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5110       20454 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5111       20454 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5112       20454 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5113       20454 :     WRITE_UINT_FIELD(scan.scanrelid);
    5114       20454 :     WRITE_OID_FIELD(indexid);
    5115       20454 :     WRITE_BOOL_FIELD(isshared);
    5116       20454 :     WRITE_NODE_FIELD(indexqual);
    5117       20454 :     WRITE_NODE_FIELD(indexqualorig);
    5118       20454 : }
    5119             : 
    5120             : static void
    5121       19834 : _outBitmapHeapScan(StringInfo str, const BitmapHeapScan *node)
    5122             : {
    5123       19834 :     WRITE_NODE_TYPE("BITMAPHEAPSCAN");
    5124             : 
    5125       19834 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5126       19834 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5127       19834 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5128       19834 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5129       19834 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5130       19834 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5131       19834 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5132       19834 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5133       19834 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5134       19834 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5135       19834 :     WRITE_NODE_FIELD(scan.plan.qual);
    5136       19834 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5137       19834 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5138       19834 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5139       19834 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5140       19834 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5141       19834 :     WRITE_UINT_FIELD(scan.scanrelid);
    5142       19834 :     WRITE_NODE_FIELD(bitmapqualorig);
    5143       19834 : }
    5144             : 
    5145             : static void
    5146         732 : _outTidScan(StringInfo str, const TidScan *node)
    5147             : {
    5148         732 :     WRITE_NODE_TYPE("TIDSCAN");
    5149             : 
    5150         732 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5151         732 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5152         732 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5153         732 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5154         732 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5155         732 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5156         732 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5157         732 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5158         732 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5159         732 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5160         732 :     WRITE_NODE_FIELD(scan.plan.qual);
    5161         732 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5162         732 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5163         732 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5164         732 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5165         732 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5166         732 :     WRITE_UINT_FIELD(scan.scanrelid);
    5167         732 :     WRITE_NODE_FIELD(tidquals);
    5168         732 : }
    5169             : 
    5170             : static void
    5171        1940 : _outTidRangeScan(StringInfo str, const TidRangeScan *node)
    5172             : {
    5173        1940 :     WRITE_NODE_TYPE("TIDRANGESCAN");
    5174             : 
    5175        1940 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5176        1940 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5177        1940 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5178        1940 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5179        1940 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5180        1940 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5181        1940 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5182        1940 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5183        1940 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5184        1940 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5185        1940 :     WRITE_NODE_FIELD(scan.plan.qual);
    5186        1940 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5187        1940 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5188        1940 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5189        1940 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5190        1940 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5191        1940 :     WRITE_UINT_FIELD(scan.scanrelid);
    5192        1940 :     WRITE_NODE_FIELD(tidrangequals);
    5193        1940 : }
    5194             : 
    5195             : static void
    5196       10874 : _outSubqueryScan(StringInfo str, const SubqueryScan *node)
    5197             : {
    5198       10874 :     WRITE_NODE_TYPE("SUBQUERYSCAN");
    5199             : 
    5200       10874 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5201       10874 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5202       10874 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5203       10874 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5204       10874 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5205       10874 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5206       10874 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5207       10874 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5208       10874 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5209       10874 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5210       10874 :     WRITE_NODE_FIELD(scan.plan.qual);
    5211       10874 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5212       10874 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5213       10874 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5214       10874 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5215       10874 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5216       10874 :     WRITE_UINT_FIELD(scan.scanrelid);
    5217       10874 :     WRITE_NODE_FIELD(subplan);
    5218       10874 :     WRITE_ENUM_FIELD(scanstatus, SubqueryScanStatus);
    5219       10874 : }
    5220             : 
    5221             : static void
    5222       51960 : _outFunctionScan(StringInfo str, const FunctionScan *node)
    5223             : {
    5224       51960 :     WRITE_NODE_TYPE("FUNCTIONSCAN");
    5225             : 
    5226       51960 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5227       51960 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5228       51960 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5229       51960 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5230       51960 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5231       51960 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5232       51960 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5233       51960 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5234       51960 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5235       51960 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5236       51960 :     WRITE_NODE_FIELD(scan.plan.qual);
    5237       51960 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5238       51960 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5239       51960 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5240       51960 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5241       51960 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5242       51960 :     WRITE_UINT_FIELD(scan.scanrelid);
    5243       51960 :     WRITE_NODE_FIELD(functions);
    5244       51960 :     WRITE_BOOL_FIELD(funcordinality);
    5245       51960 : }
    5246             : 
    5247             : static void
    5248        8258 : _outValuesScan(StringInfo str, const ValuesScan *node)
    5249             : {
    5250        8258 :     WRITE_NODE_TYPE("VALUESSCAN");
    5251             : 
    5252        8258 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5253        8258 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5254        8258 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5255        8258 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5256        8258 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5257        8258 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5258        8258 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5259        8258 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5260        8258 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5261        8258 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5262        8258 :     WRITE_NODE_FIELD(scan.plan.qual);
    5263        8258 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5264        8258 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5265        8258 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5266        8258 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5267        8258 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5268        8258 :     WRITE_UINT_FIELD(scan.scanrelid);
    5269        8258 :     WRITE_NODE_FIELD(values_lists);
    5270        8258 : }
    5271             : 
    5272             : static void
    5273         626 : _outTableFuncScan(StringInfo str, const TableFuncScan *node)
    5274             : {
    5275         626 :     WRITE_NODE_TYPE("TABLEFUNCSCAN");
    5276             : 
    5277         626 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5278         626 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5279         626 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5280         626 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5281         626 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5282         626 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5283         626 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5284         626 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5285         626 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5286         626 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5287         626 :     WRITE_NODE_FIELD(scan.plan.qual);
    5288         626 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5289         626 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5290         626 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5291         626 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5292         626 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5293         626 :     WRITE_UINT_FIELD(scan.scanrelid);
    5294         626 :     WRITE_NODE_FIELD(tablefunc);
    5295         626 : }
    5296             : 
    5297             : static void
    5298        4082 : _outCteScan(StringInfo str, const CteScan *node)
    5299             : {
    5300        4082 :     WRITE_NODE_TYPE("CTESCAN");
    5301             : 
    5302        4082 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5303        4082 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5304        4082 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5305        4082 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5306        4082 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5307        4082 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5308        4082 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5309        4082 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5310        4082 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5311        4082 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5312        4082 :     WRITE_NODE_FIELD(scan.plan.qual);
    5313        4082 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5314        4082 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5315        4082 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5316        4082 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5317        4082 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5318        4082 :     WRITE_UINT_FIELD(scan.scanrelid);
    5319        4082 :     WRITE_INT_FIELD(ctePlanId);
    5320        4082 :     WRITE_INT_FIELD(cteParam);
    5321        4082 : }
    5322             : 
    5323             : static void
    5324         466 : _outNamedTuplestoreScan(StringInfo str, const NamedTuplestoreScan *node)
    5325             : {
    5326         466 :     WRITE_NODE_TYPE("NAMEDTUPLESTORESCAN");
    5327             : 
    5328         466 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5329         466 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5330         466 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5331         466 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5332         466 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5333         466 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5334         466 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5335         466 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5336         466 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5337         466 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5338         466 :     WRITE_NODE_FIELD(scan.plan.qual);
    5339         466 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5340         466 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5341         466 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5342         466 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5343         466 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5344         466 :     WRITE_UINT_FIELD(scan.scanrelid);
    5345         466 :     WRITE_STRING_FIELD(enrname);
    5346         466 : }
    5347             : 
    5348             : static void
    5349        1004 : _outWorkTableScan(StringInfo str, const WorkTableScan *node)
    5350             : {
    5351        1004 :     WRITE_NODE_TYPE("WORKTABLESCAN");
    5352             : 
    5353        1004 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5354        1004 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5355        1004 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5356        1004 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5357        1004 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5358        1004 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5359        1004 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5360        1004 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5361        1004 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5362        1004 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5363        1004 :     WRITE_NODE_FIELD(scan.plan.qual);
    5364        1004 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5365        1004 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5366        1004 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5367        1004 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5368        1004 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5369        1004 :     WRITE_UINT_FIELD(scan.scanrelid);
    5370        1004 :     WRITE_INT_FIELD(wtParam);
    5371        1004 : }
    5372             : 
    5373             : static void
    5374        2032 : _outForeignScan(StringInfo str, const ForeignScan *node)
    5375             : {
    5376        2032 :     WRITE_NODE_TYPE("FOREIGNSCAN");
    5377             : 
    5378        2032 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5379        2032 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5380        2032 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5381        2032 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5382        2032 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5383        2032 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5384        2032 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5385        2032 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5386        2032 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5387        2032 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5388        2032 :     WRITE_NODE_FIELD(scan.plan.qual);
    5389        2032 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5390        2032 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5391        2032 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5392        2032 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5393        2032 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5394        2032 :     WRITE_UINT_FIELD(scan.scanrelid);
    5395        2032 :     WRITE_ENUM_FIELD(operation, CmdType);
    5396        2032 :     WRITE_UINT_FIELD(resultRelation);
    5397        2032 :     WRITE_OID_FIELD(checkAsUser);
    5398        2032 :     WRITE_OID_FIELD(fs_server);
    5399        2032 :     WRITE_NODE_FIELD(fdw_exprs);
    5400        2032 :     WRITE_NODE_FIELD(fdw_private);
    5401        2032 :     WRITE_NODE_FIELD(fdw_scan_tlist);
    5402        2032 :     WRITE_NODE_FIELD(fdw_recheck_quals);
    5403        2032 :     WRITE_BITMAPSET_FIELD(fs_relids);
    5404        2032 :     WRITE_BITMAPSET_FIELD(fs_base_relids);
    5405        2032 :     WRITE_BOOL_FIELD(fsSystemCol);
    5406        2032 : }
    5407             : 
    5408             : static void
    5409           0 : _outCustomScan(StringInfo str, const CustomScan *node)
    5410             : {
    5411           0 :     WRITE_NODE_TYPE("CUSTOMSCAN");
    5412             : 
    5413           0 :     WRITE_INT_FIELD(scan.plan.disabled_nodes);
    5414           0 :     WRITE_FLOAT_FIELD(scan.plan.startup_cost);
    5415           0 :     WRITE_FLOAT_FIELD(scan.plan.total_cost);
    5416           0 :     WRITE_FLOAT_FIELD(scan.plan.plan_rows);
    5417           0 :     WRITE_INT_FIELD(scan.plan.plan_width);
    5418           0 :     WRITE_BOOL_FIELD(scan.plan.parallel_aware);
    5419           0 :     WRITE_BOOL_FIELD(scan.plan.parallel_safe);
    5420           0 :     WRITE_BOOL_FIELD(scan.plan.async_capable);
    5421           0 :     WRITE_INT_FIELD(scan.plan.plan_node_id);
    5422           0 :     WRITE_NODE_FIELD(scan.plan.targetlist);
    5423           0 :     WRITE_NODE_FIELD(scan.plan.qual);
    5424           0 :     WRITE_NODE_FIELD(scan.plan.lefttree);
    5425           0 :     WRITE_NODE_FIELD(scan.plan.righttree);
    5426           0 :     WRITE_NODE_FIELD(scan.plan.initPlan);
    5427           0 :     WRITE_BITMAPSET_FIELD(scan.plan.extParam);
    5428           0 :     WRITE_BITMAPSET_FIELD(scan.plan.allParam);
    5429           0 :     WRITE_UINT_FIELD(scan.scanrelid);
    5430           0 :     WRITE_UINT_FIELD(flags);
    5431           0 :     WRITE_NODE_FIELD(custom_plans);
    5432           0 :     WRITE_NODE_FIELD(custom_exprs);
    5433           0 :     WRITE_NODE_FIELD(custom_private);
    5434           0 :     WRITE_NODE_FIELD(custom_scan_tlist);
    5435           0 :     WRITE_BITMAPSET_FIELD(custom_relids);
    5436             : 
    5437             :     /* CustomName is a key to lookup CustomScanMethods */
    5438           0 :     appendStringInfoString(str, " :methods ");
    5439           0 :     outToken(str, node->methods->CustomName);
    5440           0 : }
    5441             : 
    5442             : static void
    5443       92634 : _outNestLoop(StringInfo str, const NestLoop *node)
    5444             : {
    5445       92634 :     WRITE_NODE_TYPE("NESTLOOP");
    5446             : 
    5447       92634 :     WRITE_INT_FIELD(join.plan.disabled_nodes);
    5448       92634 :     WRITE_FLOAT_FIELD(join.plan.startup_cost);
    5449       92634 :     WRITE_FLOAT_FIELD(join.plan.total_cost);
    5450       92634 :     WRITE_FLOAT_FIELD(join.plan.plan_rows);
    5451       92634 :     WRITE_INT_FIELD(join.plan.plan_width);
    5452       92634 :     WRITE_BOOL_FIELD(join.plan.parallel_aware);
    5453       92634 :     WRITE_BOOL_FIELD(join.plan.parallel_safe);
    5454       92634 :     WRITE_BOOL_FIELD(join.plan.async_capable);
    5455       92634 :     WRITE_INT_FIELD(join.plan.plan_node_id);
    5456       92634 :     WRITE_NODE_FIELD(join.plan.targetlist);
    5457       92634 :     WRITE_NODE_FIELD(join.plan.qual);
    5458       92634 :     WRITE_NODE_FIELD(join.plan.lefttree);
    5459       92634 :     WRITE_NODE_FIELD(join.plan.righttree);
    5460       92634 :     WRITE_NODE_FIELD(join.plan.initPlan);
    5461       92634 :     WRITE_BITMAPSET_FIELD(join.plan.extParam);
    5462       92634 :     WRITE_BITMAPSET_FIELD(join.plan.allParam);
    5463       92634 :     WRITE_ENUM_FIELD(join.jointype, JoinType);
    5464       92634 :     WRITE_BOOL_FIELD(join.inner_unique);
    5465       92634 :     WRITE_NODE_FIELD(join.joinqual);
    5466       92634 :     WRITE_NODE_FIELD(nestParams);
    5467       92634 : }
    5468             : 
    5469             : static void
    5470       51558 : _outNestLoopParam(StringInfo str, const NestLoopParam *node)
    5471             : {
    5472       51558 :     WRITE_NODE_TYPE("NESTLOOPPARAM");
    5473             : 
    5474       51558 :     WRITE_INT_FIELD(paramno);
    5475       51558 :     WRITE_NODE_FIELD(paramval);
    5476       51558 : }
    5477             : 
    5478             : static void
    5479        8188 : _outMergeJoin(StringInfo str, const MergeJoin *node)
    5480             : {
    5481        8188 :     WRITE_NODE_TYPE("MERGEJOIN");
    5482             : 
    5483        8188 :     WRITE_INT_FIELD(join.plan.disabled_nodes);
    5484        8188 :     WRITE_FLOAT_FIELD(join.plan.startup_cost);
    5485        8188 :     WRITE_FLOAT_FIELD(join.plan.total_cost);
    5486        8188 :     WRITE_FLOAT_FIELD(join.plan.plan_rows);
    5487        8188 :     WRITE_INT_FIELD(join.plan.plan_width);
    5488        8188 :     WRITE_BOOL_FIELD(join.plan.parallel_aware);
    5489        8188 :     WRITE_BOOL_FIELD(join.plan.parallel_safe);
    5490        8188 :     WRITE_BOOL_FIELD(join.plan.async_capable);
    5491        8188 :     WRITE_INT_FIELD(join.plan.plan_node_id);
    5492        8188 :     WRITE_NODE_FIELD(join.plan.targetlist);
    5493        8188 :     WRITE_NODE_FIELD(join.plan.qual);
    5494        8188 :     WRITE_NODE_FIELD(join.plan.lefttree);
    5495        8188 :     WRITE_NODE_FIELD(join.plan.righttree);
    5496        8188 :     WRITE_NODE_FIELD(join.plan.initPlan);
    5497        8188 :     WRITE_BITMAPSET_FIELD(join.plan.extParam);
    5498        8188 :     WRITE_BITMAPSET_FIELD(join.plan.allParam);
    5499        8188 :     WRITE_ENUM_FIELD(join.jointype, JoinType);
    5500        8188 :     WRITE_BOOL_FIELD(join.inner_unique);
    5501        8188 :     WRITE_NODE_FIELD(join.joinqual);
    5502        8188 :     WRITE_BOOL_FIELD(skip_mark_restore);
    5503        8188 :     WRITE_NODE_FIELD(mergeclauses);
    5504        8188 :     WRITE_OID_ARRAY(mergeFamilies, list_length(node->mergeclauses));
    5505        8188 :     WRITE_OID_ARRAY(mergeCollations, list_length(node->mergeclauses));
    5506        8188 :     WRITE_BOOL_ARRAY(mergeReversals, list_length(node->mergeclauses));
    5507        8188 :     WRITE_BOOL_ARRAY(mergeNullsFirst, list_length(node->mergeclauses));
    5508        8188 : }
    5509             : 
    5510             : static void
    5511       34626 : _outHashJoin(StringInfo str, const HashJoin *node)
    5512             : {
    5513       34626 :     WRITE_NODE_TYPE("HASHJOIN");
    5514             : 
    5515       34626 :     WRITE_INT_FIELD(join.plan.disabled_nodes);
    5516       34626 :     WRITE_FLOAT_FIELD(join.plan.startup_cost);
    5517       34626 :     WRITE_FLOAT_FIELD(join.plan.total_cost);
    5518       34626 :     WRITE_FLOAT_FIELD(join.plan.plan_rows);
    5519       34626 :     WRITE_INT_FIELD(join.plan.plan_width);
    5520       34626 :     WRITE_BOOL_FIELD(join.plan.parallel_aware);
    5521       34626 :     WRITE_BOOL_FIELD(join.plan.parallel_safe);
    5522       34626 :     WRITE_BOOL_FIELD(join.plan.async_capable);
    5523       34626 :     WRITE_INT_FIELD(join.plan.plan_node_id);
    5524       34626 :     WRITE_NODE_FIELD(join.plan.targetlist);
    5525       34626 :     WRITE_NODE_FIELD(join.plan.qual);
    5526       34626 :     WRITE_NODE_FIELD(join.plan.lefttree);
    5527       34626 :     WRITE_NODE_FIELD(join.plan.righttree);
    5528       34626 :     WRITE_NODE_FIELD(join.plan.initPlan);
    5529       34626 :     WRITE_BITMAPSET_FIELD(join.plan.extParam);
    5530       34626 :     WRITE_BITMAPSET_FIELD(join.plan.allParam);
    5531       34626 :     WRITE_ENUM_FIELD(join.jointype, JoinType);
    5532       34626 :     WRITE_BOOL_FIELD(join.inner_unique);
    5533       34626 :     WRITE_NODE_FIELD(join.joinqual);
    5534       34626 :     WRITE_NODE_FIELD(hashclauses);
    5535       34626 :     WRITE_NODE_FIELD(hashoperators);
    5536       34626 :     WRITE_NODE_FIELD(hashcollations);
    5537       34626 :     WRITE_NODE_FIELD(hashkeys);
    5538       34626 : }
    5539             : 
    5540             : static void
    5541        4424 : _outMaterial(StringInfo str, const Material *node)
    5542             : {
    5543        4424 :     WRITE_NODE_TYPE("MATERIAL");
    5544             : 
    5545        4424 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5546        4424 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5547        4424 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5548        4424 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5549        4424 :     WRITE_INT_FIELD(plan.plan_width);
    5550        4424 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5551        4424 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5552        4424 :     WRITE_BOOL_FIELD(plan.async_capable);
    5553        4424 :     WRITE_INT_FIELD(plan.plan_node_id);
    5554        4424 :     WRITE_NODE_FIELD(plan.targetlist);
    5555        4424 :     WRITE_NODE_FIELD(plan.qual);
    5556        4424 :     WRITE_NODE_FIELD(plan.lefttree);
    5557        4424 :     WRITE_NODE_FIELD(plan.righttree);
    5558        4424 :     WRITE_NODE_FIELD(plan.initPlan);
    5559        4424 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5560        4424 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5561        4424 : }
    5562             : 
    5563             : static void
    5564        1606 : _outMemoize(StringInfo str, const Memoize *node)
    5565             : {
    5566        1606 :     WRITE_NODE_TYPE("MEMOIZE");
    5567             : 
    5568        1606 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5569        1606 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5570        1606 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5571        1606 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5572        1606 :     WRITE_INT_FIELD(plan.plan_width);
    5573        1606 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5574        1606 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5575        1606 :     WRITE_BOOL_FIELD(plan.async_capable);
    5576        1606 :     WRITE_INT_FIELD(plan.plan_node_id);
    5577        1606 :     WRITE_NODE_FIELD(plan.targetlist);
    5578        1606 :     WRITE_NODE_FIELD(plan.qual);
    5579        1606 :     WRITE_NODE_FIELD(plan.lefttree);
    5580        1606 :     WRITE_NODE_FIELD(plan.righttree);
    5581        1606 :     WRITE_NODE_FIELD(plan.initPlan);
    5582        1606 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5583        1606 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5584        1606 :     WRITE_INT_FIELD(numKeys);
    5585        1606 :     WRITE_OID_ARRAY(hashOperators, node->numKeys);
    5586        1606 :     WRITE_OID_ARRAY(collations, node->numKeys);
    5587        1606 :     WRITE_NODE_FIELD(param_exprs);
    5588        1606 :     WRITE_BOOL_FIELD(singlerow);
    5589        1606 :     WRITE_BOOL_FIELD(binary_mode);
    5590        1606 :     WRITE_UINT_FIELD(est_entries);
    5591        1606 :     WRITE_BITMAPSET_FIELD(keyparamids);
    5592        1606 : }
    5593             : 
    5594             : static void
    5595       80844 : _outSort(StringInfo str, const Sort *node)
    5596             : {
    5597       80844 :     WRITE_NODE_TYPE("SORT");
    5598             : 
    5599       80844 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5600       80844 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5601       80844 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5602       80844 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5603       80844 :     WRITE_INT_FIELD(plan.plan_width);
    5604       80844 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5605       80844 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5606       80844 :     WRITE_BOOL_FIELD(plan.async_capable);
    5607       80844 :     WRITE_INT_FIELD(plan.plan_node_id);
    5608       80844 :     WRITE_NODE_FIELD(plan.targetlist);
    5609       80844 :     WRITE_NODE_FIELD(plan.qual);
    5610       80844 :     WRITE_NODE_FIELD(plan.lefttree);
    5611       80844 :     WRITE_NODE_FIELD(plan.righttree);
    5612       80844 :     WRITE_NODE_FIELD(plan.initPlan);
    5613       80844 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5614       80844 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5615       80844 :     WRITE_INT_FIELD(numCols);
    5616       80844 :     WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
    5617       80844 :     WRITE_OID_ARRAY(sortOperators, node->numCols);
    5618       80844 :     WRITE_OID_ARRAY(collations, node->numCols);
    5619       80844 :     WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
    5620       80844 : }
    5621             : 
    5622             : static void
    5623         968 : _outIncrementalSort(StringInfo str, const IncrementalSort *node)
    5624             : {
    5625         968 :     WRITE_NODE_TYPE("INCREMENTALSORT");
    5626             : 
    5627         968 :     WRITE_INT_FIELD(sort.plan.disabled_nodes);
    5628         968 :     WRITE_FLOAT_FIELD(sort.plan.startup_cost);
    5629         968 :     WRITE_FLOAT_FIELD(sort.plan.total_cost);
    5630         968 :     WRITE_FLOAT_FIELD(sort.plan.plan_rows);
    5631         968 :     WRITE_INT_FIELD(sort.plan.plan_width);
    5632         968 :     WRITE_BOOL_FIELD(sort.plan.parallel_aware);
    5633         968 :     WRITE_BOOL_FIELD(sort.plan.parallel_safe);
    5634         968 :     WRITE_BOOL_FIELD(sort.plan.async_capable);
    5635         968 :     WRITE_INT_FIELD(sort.plan.plan_node_id);
    5636         968 :     WRITE_NODE_FIELD(sort.plan.targetlist);
    5637         968 :     WRITE_NODE_FIELD(sort.plan.qual);
    5638         968 :     WRITE_NODE_FIELD(sort.plan.lefttree);
    5639         968 :     WRITE_NODE_FIELD(sort.plan.righttree);
    5640         968 :     WRITE_NODE_FIELD(sort.plan.initPlan);
    5641         968 :     WRITE_BITMAPSET_FIELD(sort.plan.extParam);
    5642         968 :     WRITE_BITMAPSET_FIELD(sort.plan.allParam);
    5643         968 :     WRITE_INT_FIELD(sort.numCols);
    5644         968 :     WRITE_ATTRNUMBER_ARRAY(sort.sortColIdx, node->sort.numCols);
    5645         968 :     WRITE_OID_ARRAY(sort.sortOperators, node->sort.numCols);
    5646         968 :     WRITE_OID_ARRAY(sort.collations, node->sort.numCols);
    5647         968 :     WRITE_BOOL_ARRAY(sort.nullsFirst, node->sort.numCols);
    5648         968 :     WRITE_INT_FIELD(nPresortedCols);
    5649         968 : }
    5650             : 
    5651             : static void
    5652         246 : _outGroup(StringInfo str, const Group *node)
    5653             : {
    5654         246 :     WRITE_NODE_TYPE("GROUP");
    5655             : 
    5656         246 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5657         246 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5658         246 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5659         246 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5660         246 :     WRITE_INT_FIELD(plan.plan_width);
    5661         246 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5662         246 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5663         246 :     WRITE_BOOL_FIELD(plan.async_capable);
    5664         246 :     WRITE_INT_FIELD(plan.plan_node_id);
    5665         246 :     WRITE_NODE_FIELD(plan.targetlist);
    5666         246 :     WRITE_NODE_FIELD(plan.qual);
    5667         246 :     WRITE_NODE_FIELD(plan.lefttree);
    5668         246 :     WRITE_NODE_FIELD(plan.righttree);
    5669         246 :     WRITE_NODE_FIELD(plan.initPlan);
    5670         246 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5671         246 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5672         246 :     WRITE_INT_FIELD(numCols);
    5673         246 :     WRITE_ATTRNUMBER_ARRAY(grpColIdx, node->numCols);
    5674         246 :     WRITE_OID_ARRAY(grpOperators, node->numCols);
    5675         246 :     WRITE_OID_ARRAY(grpCollations, node->numCols);
    5676         246 : }
    5677             : 
    5678             : static void
    5679       42948 : _outAgg(StringInfo str, const Agg *node)
    5680             : {
    5681       42948 :     WRITE_NODE_TYPE("AGG");
    5682             : 
    5683       42948 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5684       42948 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5685       42948 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5686       42948 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5687       42948 :     WRITE_INT_FIELD(plan.plan_width);
    5688       42948 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5689       42948 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5690       42948 :     WRITE_BOOL_FIELD(plan.async_capable);
    5691       42948 :     WRITE_INT_FIELD(plan.plan_node_id);
    5692       42948 :     WRITE_NODE_FIELD(plan.targetlist);
    5693       42948 :     WRITE_NODE_FIELD(plan.qual);
    5694       42948 :     WRITE_NODE_FIELD(plan.lefttree);
    5695       42948 :     WRITE_NODE_FIELD(plan.righttree);
    5696       42948 :     WRITE_NODE_FIELD(plan.initPlan);
    5697       42948 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5698       42948 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5699       42948 :     WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
    5700       42948 :     WRITE_ENUM_FIELD(aggsplit, AggSplit);
    5701       42948 :     WRITE_INT_FIELD(numCols);
    5702       42948 :     WRITE_ATTRNUMBER_ARRAY(grpColIdx, node->numCols);
    5703       42948 :     WRITE_OID_ARRAY(grpOperators, node->numCols);
    5704       42948 :     WRITE_OID_ARRAY(grpCollations, node->numCols);
    5705       42948 :     WRITE_LONG_FIELD(numGroups);
    5706       42948 :     WRITE_UINT64_FIELD(transitionSpace);
    5707       42948 :     WRITE_BITMAPSET_FIELD(aggParams);
    5708       42948 :     WRITE_NODE_FIELD(groupingSets);
    5709       42948 :     WRITE_NODE_FIELD(chain);
    5710       42948 : }
    5711             : 
    5712             : static void
    5713        2546 : _outWindowAgg(StringInfo str, const WindowAgg *node)
    5714             : {
    5715        2546 :     WRITE_NODE_TYPE("WINDOWAGG");
    5716             : 
    5717        2546 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5718        2546 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5719        2546 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5720        2546 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5721        2546 :     WRITE_INT_FIELD(plan.plan_width);
    5722        2546 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5723        2546 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5724        2546 :     WRITE_BOOL_FIELD(plan.async_capable);
    5725        2546 :     WRITE_INT_FIELD(plan.plan_node_id);
    5726        2546 :     WRITE_NODE_FIELD(plan.targetlist);
    5727        2546 :     WRITE_NODE_FIELD(plan.qual);
    5728        2546 :     WRITE_NODE_FIELD(plan.lefttree);
    5729        2546 :     WRITE_NODE_FIELD(plan.righttree);
    5730        2546 :     WRITE_NODE_FIELD(plan.initPlan);
    5731        2546 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5732        2546 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5733        2546 :     WRITE_STRING_FIELD(winname);
    5734        2546 :     WRITE_UINT_FIELD(winref);
    5735        2546 :     WRITE_INT_FIELD(partNumCols);
    5736        2546 :     WRITE_ATTRNUMBER_ARRAY(partColIdx, node->partNumCols);
    5737        2546 :     WRITE_OID_ARRAY(partOperators, node->partNumCols);
    5738        2546 :     WRITE_OID_ARRAY(partCollations, node->partNumCols);
    5739        2546 :     WRITE_INT_FIELD(ordNumCols);
    5740        2546 :     WRITE_ATTRNUMBER_ARRAY(ordColIdx, node->ordNumCols);
    5741        2546 :     WRITE_OID_ARRAY(ordOperators, node->ordNumCols);
    5742        2546 :     WRITE_OID_ARRAY(ordCollations, node->ordNumCols);
    5743        2546 :     WRITE_INT_FIELD(frameOptions);
    5744        2546 :     WRITE_NODE_FIELD(startOffset);
    5745        2546 :     WRITE_NODE_FIELD(endOffset);
    5746        2546 :     WRITE_NODE_FIELD(runCondition);
    5747        2546 :     WRITE_NODE_FIELD(runConditionOrig);
    5748        2546 :     WRITE_OID_FIELD(startInRangeFunc);
    5749        2546 :     WRITE_OID_FIELD(endInRangeFunc);
    5750        2546 :     WRITE_OID_FIELD(inRangeColl);
    5751        2546 :     WRITE_BOOL_FIELD(inRangeAsc);
    5752        2546 :     WRITE_BOOL_FIELD(inRangeNullsFirst);
    5753        2546 :     WRITE_BOOL_FIELD(topWindow);
    5754        2546 : }
    5755             : 
    5756             : static void
    5757        5550 : _outUnique(StringInfo str, const Unique *node)
    5758             : {
    5759        5550 :     WRITE_NODE_TYPE("UNIQUE");
    5760             : 
    5761        5550 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5762        5550 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5763        5550 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5764        5550 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5765        5550 :     WRITE_INT_FIELD(plan.plan_width);
    5766        5550 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5767        5550 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5768        5550 :     WRITE_BOOL_FIELD(plan.async_capable);
    5769        5550 :     WRITE_INT_FIELD(plan.plan_node_id);
    5770        5550 :     WRITE_NODE_FIELD(plan.targetlist);
    5771        5550 :     WRITE_NODE_FIELD(plan.qual);
    5772        5550 :     WRITE_NODE_FIELD(plan.lefttree);
    5773        5550 :     WRITE_NODE_FIELD(plan.righttree);
    5774        5550 :     WRITE_NODE_FIELD(plan.initPlan);
    5775        5550 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5776        5550 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5777        5550 :     WRITE_INT_FIELD(numCols);
    5778        5550 :     WRITE_ATTRNUMBER_ARRAY(uniqColIdx, node->numCols);
    5779        5550 :     WRITE_OID_ARRAY(uniqOperators, node->numCols);
    5780        5550 :     WRITE_OID_ARRAY(uniqCollations, node->numCols);
    5781        5550 : }
    5782             : 
    5783             : static void
    5784        1076 : _outGather(StringInfo str, const Gather *node)
    5785             : {
    5786        1076 :     WRITE_NODE_TYPE("GATHER");
    5787             : 
    5788        1076 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5789        1076 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5790        1076 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5791        1076 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5792        1076 :     WRITE_INT_FIELD(plan.plan_width);
    5793        1076 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5794        1076 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5795        1076 :     WRITE_BOOL_FIELD(plan.async_capable);
    5796        1076 :     WRITE_INT_FIELD(plan.plan_node_id);
    5797        1076 :     WRITE_NODE_FIELD(plan.targetlist);
    5798        1076 :     WRITE_NODE_FIELD(plan.qual);
    5799        1076 :     WRITE_NODE_FIELD(plan.lefttree);
    5800        1076 :     WRITE_NODE_FIELD(plan.righttree);
    5801        1076 :     WRITE_NODE_FIELD(plan.initPlan);
    5802        1076 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5803        1076 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5804        1076 :     WRITE_INT_FIELD(num_workers);
    5805        1076 :     WRITE_INT_FIELD(rescan_param);
    5806        1076 :     WRITE_BOOL_FIELD(single_copy);
    5807        1076 :     WRITE_BOOL_FIELD(invisible);
    5808        1076 :     WRITE_BITMAPSET_FIELD(initParam);
    5809        1076 : }
    5810             : 
    5811             : static void
    5812         330 : _outGatherMerge(StringInfo str, const GatherMerge *node)
    5813             : {
    5814         330 :     WRITE_NODE_TYPE("GATHERMERGE");
    5815             : 
    5816         330 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5817         330 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5818         330 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5819         330 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5820         330 :     WRITE_INT_FIELD(plan.plan_width);
    5821         330 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5822         330 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5823         330 :     WRITE_BOOL_FIELD(plan.async_capable);
    5824         330 :     WRITE_INT_FIELD(plan.plan_node_id);
    5825         330 :     WRITE_NODE_FIELD(plan.targetlist);
    5826         330 :     WRITE_NODE_FIELD(plan.qual);
    5827         330 :     WRITE_NODE_FIELD(plan.lefttree);
    5828         330 :     WRITE_NODE_FIELD(plan.righttree);
    5829         330 :     WRITE_NODE_FIELD(plan.initPlan);
    5830         330 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5831         330 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5832         330 :     WRITE_INT_FIELD(num_workers);
    5833         330 :     WRITE_INT_FIELD(rescan_param);
    5834         330 :     WRITE_INT_FIELD(numCols);
    5835         330 :     WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
    5836         330 :     WRITE_OID_ARRAY(sortOperators, node->numCols);
    5837         330 :     WRITE_OID_ARRAY(collations, node->numCols);
    5838         330 :     WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
    5839         330 :     WRITE_BITMAPSET_FIELD(initParam);
    5840         330 : }
    5841             : 
    5842             : static void
    5843       34626 : _outHash(StringInfo str, const Hash *node)
    5844             : {
    5845       34626 :     WRITE_NODE_TYPE("HASH");
    5846             : 
    5847       34626 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5848       34626 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5849       34626 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5850       34626 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5851       34626 :     WRITE_INT_FIELD(plan.plan_width);
    5852       34626 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5853       34626 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5854       34626 :     WRITE_BOOL_FIELD(plan.async_capable);
    5855       34626 :     WRITE_INT_FIELD(plan.plan_node_id);
    5856       34626 :     WRITE_NODE_FIELD(plan.targetlist);
    5857       34626 :     WRITE_NODE_FIELD(plan.qual);
    5858       34626 :     WRITE_NODE_FIELD(plan.lefttree);
    5859       34626 :     WRITE_NODE_FIELD(plan.righttree);
    5860       34626 :     WRITE_NODE_FIELD(plan.initPlan);
    5861       34626 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5862       34626 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5863       34626 :     WRITE_NODE_FIELD(hashkeys);
    5864       34626 :     WRITE_OID_FIELD(skewTable);
    5865       34626 :     WRITE_INT_FIELD(skewColumn);
    5866       34626 :     WRITE_BOOL_FIELD(skewInherit);
    5867       34626 :     WRITE_FLOAT_FIELD(rows_total);
    5868       34626 : }
    5869             : 
    5870             : static void
    5871         662 : _outSetOp(StringInfo str, const SetOp *node)
    5872             : {
    5873         662 :     WRITE_NODE_TYPE("SETOP");
    5874             : 
    5875         662 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5876         662 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5877         662 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5878         662 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5879         662 :     WRITE_INT_FIELD(plan.plan_width);
    5880         662 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5881         662 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5882         662 :     WRITE_BOOL_FIELD(plan.async_capable);
    5883         662 :     WRITE_INT_FIELD(plan.plan_node_id);
    5884         662 :     WRITE_NODE_FIELD(plan.targetlist);
    5885         662 :     WRITE_NODE_FIELD(plan.qual);
    5886         662 :     WRITE_NODE_FIELD(plan.lefttree);
    5887         662 :     WRITE_NODE_FIELD(plan.righttree);
    5888         662 :     WRITE_NODE_FIELD(plan.initPlan);
    5889         662 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5890         662 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5891         662 :     WRITE_ENUM_FIELD(cmd, SetOpCmd);
    5892         662 :     WRITE_ENUM_FIELD(strategy, SetOpStrategy);
    5893         662 :     WRITE_INT_FIELD(numCols);
    5894         662 :     WRITE_ATTRNUMBER_ARRAY(cmpColIdx, node->numCols);
    5895         662 :     WRITE_OID_ARRAY(cmpOperators, node->numCols);
    5896         662 :     WRITE_OID_ARRAY(cmpCollations, node->numCols);
    5897         662 :     WRITE_BOOL_ARRAY(cmpNullsFirst, node->numCols);
    5898         662 :     WRITE_LONG_FIELD(numGroups);
    5899         662 : }
    5900             : 
    5901             : static void
    5902        7744 : _outLockRows(StringInfo str, const LockRows *node)
    5903             : {
    5904        7744 :     WRITE_NODE_TYPE("LOCKROWS");
    5905             : 
    5906        7744 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5907        7744 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5908        7744 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5909        7744 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5910        7744 :     WRITE_INT_FIELD(plan.plan_width);
    5911        7744 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5912        7744 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5913        7744 :     WRITE_BOOL_FIELD(plan.async_capable);
    5914        7744 :     WRITE_INT_FIELD(plan.plan_node_id);
    5915        7744 :     WRITE_NODE_FIELD(plan.targetlist);
    5916        7744 :     WRITE_NODE_FIELD(plan.qual);
    5917        7744 :     WRITE_NODE_FIELD(plan.lefttree);
    5918        7744 :     WRITE_NODE_FIELD(plan.righttree);
    5919        7744 :     WRITE_NODE_FIELD(plan.initPlan);
    5920        7744 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5921        7744 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5922        7744 :     WRITE_NODE_FIELD(rowMarks);
    5923        7744 :     WRITE_INT_FIELD(epqParam);
    5924        7744 : }
    5925             : 
    5926             : static void
    5927        4768 : _outLimit(StringInfo str, const Limit *node)
    5928             : {
    5929        4768 :     WRITE_NODE_TYPE("LIMIT");
    5930             : 
    5931        4768 :     WRITE_INT_FIELD(plan.disabled_nodes);
    5932        4768 :     WRITE_FLOAT_FIELD(plan.startup_cost);
    5933        4768 :     WRITE_FLOAT_FIELD(plan.total_cost);
    5934        4768 :     WRITE_FLOAT_FIELD(plan.plan_rows);
    5935        4768 :     WRITE_INT_FIELD(plan.plan_width);
    5936        4768 :     WRITE_BOOL_FIELD(plan.parallel_aware);
    5937        4768 :     WRITE_BOOL_FIELD(plan.parallel_safe);
    5938        4768 :     WRITE_BOOL_FIELD(plan.async_capable);
    5939        4768 :     WRITE_INT_FIELD(plan.plan_node_id);
    5940        4768 :     WRITE_NODE_FIELD(plan.targetlist);
    5941        4768 :     WRITE_NODE_FIELD(plan.qual);
    5942        4768 :     WRITE_NODE_FIELD(plan.lefttree);
    5943        4768 :     WRITE_NODE_FIELD(plan.righttree);
    5944        4768 :     WRITE_NODE_FIELD(plan.initPlan);
    5945        4768 :     WRITE_BITMAPSET_FIELD(plan.extParam);
    5946        4768 :     WRITE_BITMAPSET_FIELD(plan.allParam);
    5947        4768 :     WRITE_NODE_FIELD(limitOffset);
    5948        4768 :     WRITE_NODE_FIELD(limitCount);
    5949        4768 :     WRITE_ENUM_FIELD(limitOption, LimitOption);
    5950        4768 :     WRITE_INT_FIELD(uniqNumCols);
    5951        4768 :     WRITE_ATTRNUMBER_ARRAY(uniqColIdx, node->uniqNumCols);
    5952        4768 :     WRITE_OID_ARRAY(uniqOperators, node->uniqNumCols);
    5953        4768 :     WRITE_OID_ARRAY(uniqCollations, node->uniqNumCols);
    5954        4768 : }
    5955             : 
    5956             : static void
    5957       26004 : _outPlanRowMark(StringInfo str, const PlanRowMark *node)
    5958             : {
    5959       26004 :     WRITE_NODE_TYPE("PLANROWMARK");
    5960             : 
    5961       26004 :     WRITE_UINT_FIELD(rti);
    5962       26004 :     WRITE_UINT_FIELD(prti);
    5963       26004 :     WRITE_UINT_FIELD(rowmarkId);
    5964       26004 :     WRITE_ENUM_FIELD(markType, RowMarkType);
    5965       26004 :     WRITE_INT_FIELD(allMarkTypes);
    5966       26004 :     WRITE_ENUM_FIELD(strength, LockClauseStrength);
    5967       26004 :     WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
    5968       26004 :     WRITE_BOOL_FIELD(isParent);
    5969       26004 : }
    5970             : 
    5971             : static void
    5972         630 : _outPartitionPruneInfo(StringInfo str, const PartitionPruneInfo *node)
    5973             : {
    5974         630 :     WRITE_NODE_TYPE("PARTITIONPRUNEINFO");
    5975             : 
    5976         630 :     WRITE_BITMAPSET_FIELD(relids);
    5977         630 :     WRITE_NODE_FIELD(prune_infos);
    5978         630 :     WRITE_BITMAPSET_FIELD(other_subplans);
    5979         630 : }
    5980             : 
    5981             : static void
    5982        1224 : _outPartitionedRelPruneInfo(StringInfo str, const PartitionedRelPruneInfo *node)
    5983             : {
    5984        1224 :     WRITE_NODE_TYPE("PARTITIONEDRELPRUNEINFO");
    5985             : 
    5986        1224 :     WRITE_UINT_FIELD(rtindex);
    5987        1224 :     WRITE_BITMAPSET_FIELD(present_parts);
    5988        1224 :     WRITE_INT_FIELD(nparts);
    5989        1224 :     WRITE_INT_ARRAY(subplan_map, node->nparts);
    5990        1224 :     WRITE_INT_ARRAY(subpart_map, node->nparts);
    5991        1224 :     WRITE_INT_ARRAY(leafpart_rti_map, node->nparts);
    5992        1224 :     WRITE_OID_ARRAY(relid_map, node->nparts);
    5993        1224 :     WRITE_NODE_FIELD(initial_pruning_steps);
    5994        1224 :     WRITE_NODE_FIELD(exec_pruning_steps);
    5995        1224 :     WRITE_BITMAPSET_FIELD(execparamids);
    5996        1224 : }
    5997             : 
    5998             : static void
    5999        1046 : _outPartitionPruneStepOp(StringInfo str, const PartitionPruneStepOp *node)
    6000             : {
    6001        1046 :     WRITE_NODE_TYPE("PARTITIONPRUNESTEPOP");
    6002             : 
    6003        1046 :     WRITE_INT_FIELD(step.step_id);
    6004        1046 :     WRITE_INT_FIELD(opstrategy);
    6005        1046 :     WRITE_NODE_FIELD(exprs);
    6006        1046 :     WRITE_NODE_FIELD(cmpfns);
    6007        1046 :     WRITE_BITMAPSET_FIELD(nullkeys);
    6008        1046 : }
    6009             : 
    6010             : static void
    6011         186 : _outPartitionPruneStepCombine(StringInfo str, const PartitionPruneStepCombine *node)
    6012             : {
    6013         186 :     WRITE_NODE_TYPE("PARTITIONPRUNESTEPCOMBINE");
    6014             : 
    6015         186 :     WRITE_INT_FIELD(step.step_id);
    6016         186 :     WRITE_ENUM_FIELD(combineOp, PartitionPruneCombineOp);
    6017         186 :     WRITE_NODE_FIELD(source_stepids);
    6018         186 : }
    6019             : 
    6020             : static void
    6021       57798 : _outPlanInvalItem(StringInfo str, const PlanInvalItem *node)
    6022             : {
    6023       57798 :     WRITE_NODE_TYPE("PLANINVALITEM");
    6024             : 
    6025       57798 :     WRITE_INT_FIELD(cacheId);
    6026       57798 :     WRITE_UINT_FIELD(hashValue);
    6027       57798 : }
    6028             : 
    6029             : static void
    6030           0 : _outForeignKeyCacheInfo(StringInfo str, const ForeignKeyCacheInfo *node)
    6031             : {
    6032           0 :     WRITE_NODE_TYPE("FOREIGNKEYCACHEINFO");
    6033             : 
    6034           0 :     WRITE_OID_FIELD(conoid);
    6035           0 :     WRITE_OID_FIELD(conrelid);
    6036           0 :     WRITE_OID_FIELD(confrelid);
    6037           0 :     WRITE_INT_FIELD(nkeys);
    6038           0 :     WRITE_BOOL_FIELD(conenforced);
    6039           0 :     WRITE_ATTRNUMBER_ARRAY(conkey, node->nkeys);
    6040           0 :     WRITE_ATTRNUMBER_ARRAY(confkey, node->nkeys);
    6041           0 :     WRITE_OID_ARRAY(conpfeqop, node->nkeys);
    6042           0 : }

Generated by: LCOV version 1.16