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

Generated by: LCOV version 1.14