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