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

Generated by: LCOV version 1.14