/src/postgres/bld/src/backend/nodes/outfuncs.funcs.c

Source
/*-------------------------------------------------------------------------
 *
 * outfuncs.funcs.c
 *    Generated node infrastructure code
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * NOTES
 *  ******************************
 *  *** DO NOT EDIT THIS FILE! ***
 *  ******************************
 *
 *  It has been GENERATED by src/backend/nodes/gen_node_support.pl
 *
 *-------------------------------------------------------------------------
 */
#include "access/amapi.h"
#include "access/cmptype.h"
#include "access/sdir.h"
#include "access/tableam.h"
#include "access/tsmapi.h"
#include "commands/event_trigger.h"
#include "commands/trigger.h"
#include "executor/tuptable.h"
#include "foreign/fdwapi.h"
#include "nodes/bitmapset.h"
#include "nodes/execnodes.h"
#include "nodes/extensible.h"
#include "nodes/lockoptions.h"
#include "nodes/miscnodes.h"
#include "nodes/nodes.h"
#include "nodes/parsenodes.h"
#include "nodes/pathnodes.h"
#include "nodes/plannodes.h"
#include "nodes/primnodes.h"
#include "nodes/replnodes.h"
#include "nodes/supportnodes.h"
#include "nodes/value.h"
#include "utils/rel.h"

static void
_outAlias(StringInfo str, const Alias *node)
{
  WRITE_NODE_TYPE("ALIAS");

  WRITE_STRING_FIELD(aliasname);
  WRITE_NODE_FIELD(colnames);
}

static void
_outRangeVar(StringInfo str, const RangeVar *node)
{
  WRITE_NODE_TYPE("RANGEVAR");

  WRITE_STRING_FIELD(catalogname);
  WRITE_STRING_FIELD(schemaname);
  WRITE_STRING_FIELD(relname);
  WRITE_BOOL_FIELD(inh);
  WRITE_CHAR_FIELD(relpersistence);
  WRITE_NODE_FIELD(alias);
  WRITE_LOCATION_FIELD(location);
}

static void
_outTableFunc(StringInfo str, const TableFunc *node)
{
  WRITE_NODE_TYPE("TABLEFUNC");

  WRITE_ENUM_FIELD(functype, TableFuncType);
  WRITE_NODE_FIELD(ns_uris);
  WRITE_NODE_FIELD(ns_names);
  WRITE_NODE_FIELD(docexpr);
  WRITE_NODE_FIELD(rowexpr);
  WRITE_NODE_FIELD(colnames);
  WRITE_NODE_FIELD(coltypes);
  WRITE_NODE_FIELD(coltypmods);
  WRITE_NODE_FIELD(colcollations);
  WRITE_NODE_FIELD(colexprs);
  WRITE_NODE_FIELD(coldefexprs);
  WRITE_NODE_FIELD(colvalexprs);
  WRITE_NODE_FIELD(passingvalexprs);
  WRITE_BITMAPSET_FIELD(notnulls);
  WRITE_NODE_FIELD(plan);
  WRITE_INT_FIELD(ordinalitycol);
  WRITE_LOCATION_FIELD(location);
}

static void
_outIntoClause(StringInfo str, const IntoClause *node)
{
  WRITE_NODE_TYPE("INTOCLAUSE");

  WRITE_NODE_FIELD(rel);
  WRITE_NODE_FIELD(colNames);
  WRITE_STRING_FIELD(accessMethod);
  WRITE_NODE_FIELD(options);
  WRITE_ENUM_FIELD(onCommit, OnCommitAction);
  WRITE_STRING_FIELD(tableSpaceName);
  WRITE_NODE_FIELD(viewQuery);
  WRITE_BOOL_FIELD(skipData);
}

static void
_outVar(StringInfo str, const Var *node)
{
  WRITE_NODE_TYPE("VAR");

  WRITE_INT_FIELD(varno);
  WRITE_INT_FIELD(varattno);
  WRITE_OID_FIELD(vartype);
  WRITE_INT_FIELD(vartypmod);
  WRITE_OID_FIELD(varcollid);
  WRITE_BITMAPSET_FIELD(varnullingrels);
  WRITE_UINT_FIELD(varlevelsup);
  WRITE_ENUM_FIELD(varreturningtype, VarReturningType);
  WRITE_UINT_FIELD(varnosyn);
  WRITE_INT_FIELD(varattnosyn);
  WRITE_LOCATION_FIELD(location);
}

static void
_outParam(StringInfo str, const Param *node)
{
  WRITE_NODE_TYPE("PARAM");

  WRITE_ENUM_FIELD(paramkind, ParamKind);
  WRITE_INT_FIELD(paramid);
  WRITE_OID_FIELD(paramtype);
  WRITE_INT_FIELD(paramtypmod);
  WRITE_OID_FIELD(paramcollid);
  WRITE_LOCATION_FIELD(location);
}

static void
_outAggref(StringInfo str, const Aggref *node)
{
  WRITE_NODE_TYPE("AGGREF");

  WRITE_OID_FIELD(aggfnoid);
  WRITE_OID_FIELD(aggtype);
  WRITE_OID_FIELD(aggcollid);
  WRITE_OID_FIELD(inputcollid);
  WRITE_OID_FIELD(aggtranstype);
  WRITE_NODE_FIELD(aggargtypes);
  WRITE_NODE_FIELD(aggdirectargs);
  WRITE_NODE_FIELD(args);
  WRITE_NODE_FIELD(aggorder);
  WRITE_NODE_FIELD(aggdistinct);
  WRITE_NODE_FIELD(aggfilter);
  WRITE_BOOL_FIELD(aggstar);
  WRITE_BOOL_FIELD(aggvariadic);
  WRITE_CHAR_FIELD(aggkind);
  WRITE_BOOL_FIELD(aggpresorted);
  WRITE_UINT_FIELD(agglevelsup);
  WRITE_ENUM_FIELD(aggsplit, AggSplit);
  WRITE_INT_FIELD(aggno);
  WRITE_INT_FIELD(aggtransno);
  WRITE_LOCATION_FIELD(location);
}

static void
_outGroupingFunc(StringInfo str, const GroupingFunc *node)
{
  WRITE_NODE_TYPE("GROUPINGFUNC");

  WRITE_NODE_FIELD(args);
  WRITE_NODE_FIELD(refs);
  WRITE_NODE_FIELD(cols);
  WRITE_UINT_FIELD(agglevelsup);
  WRITE_LOCATION_FIELD(location);
}

static void
_outWindowFunc(StringInfo str, const WindowFunc *node)
{
  WRITE_NODE_TYPE("WINDOWFUNC");

  WRITE_OID_FIELD(winfnoid);
  WRITE_OID_FIELD(wintype);
  WRITE_OID_FIELD(wincollid);
  WRITE_OID_FIELD(inputcollid);
  WRITE_NODE_FIELD(args);
  WRITE_NODE_FIELD(aggfilter);
  WRITE_NODE_FIELD(runCondition);
  WRITE_UINT_FIELD(winref);
  WRITE_BOOL_FIELD(winstar);
  WRITE_BOOL_FIELD(winagg);
  WRITE_INT_FIELD(ignore_nulls);
  WRITE_LOCATION_FIELD(location);
}

static void
_outWindowFuncRunCondition(StringInfo str, const WindowFuncRunCondition *node)
{
  WRITE_NODE_TYPE("WINDOWFUNCRUNCONDITION");

  WRITE_OID_FIELD(opno);
  WRITE_OID_FIELD(inputcollid);
  WRITE_BOOL_FIELD(wfunc_left);
  WRITE_NODE_FIELD(arg);
}

static void
_outMergeSupportFunc(StringInfo str, const MergeSupportFunc *node)
{
  WRITE_NODE_TYPE("MERGESUPPORTFUNC");

  WRITE_OID_FIELD(msftype);
  WRITE_OID_FIELD(msfcollid);
  WRITE_LOCATION_FIELD(location);
}

static void
_outSubscriptingRef(StringInfo str, const SubscriptingRef *node)
{
  WRITE_NODE_TYPE("SUBSCRIPTINGREF");

  WRITE_OID_FIELD(refcontainertype);
  WRITE_OID_FIELD(refelemtype);
  WRITE_OID_FIELD(refrestype);
  WRITE_INT_FIELD(reftypmod);
  WRITE_OID_FIELD(refcollid);
  WRITE_NODE_FIELD(refupperindexpr);
  WRITE_NODE_FIELD(reflowerindexpr);
  WRITE_NODE_FIELD(refexpr);
  WRITE_NODE_FIELD(refassgnexpr);
}

static void
_outFuncExpr(StringInfo str, const FuncExpr *node)
{
  WRITE_NODE_TYPE("FUNCEXPR");

  WRITE_OID_FIELD(funcid);
  WRITE_OID_FIELD(funcresulttype);
  WRITE_BOOL_FIELD(funcretset);
  WRITE_BOOL_FIELD(funcvariadic);
  WRITE_ENUM_FIELD(funcformat, CoercionForm);
  WRITE_OID_FIELD(funccollid);
  WRITE_OID_FIELD(inputcollid);
  WRITE_NODE_FIELD(args);
  WRITE_LOCATION_FIELD(location);
}

static void
_outNamedArgExpr(StringInfo str, const NamedArgExpr *node)
{
  WRITE_NODE_TYPE("NAMEDARGEXPR");

  WRITE_NODE_FIELD(arg);
  WRITE_STRING_FIELD(name);
  WRITE_INT_FIELD(argnumber);
  WRITE_LOCATION_FIELD(location);
}

static void
_outOpExpr(StringInfo str, const OpExpr *node)
{
  WRITE_NODE_TYPE("OPEXPR");

  WRITE_OID_FIELD(opno);
  WRITE_OID_FIELD(opfuncid);
  WRITE_OID_FIELD(opresulttype);
  WRITE_BOOL_FIELD(opretset);
  WRITE_OID_FIELD(opcollid);
  WRITE_OID_FIELD(inputcollid);
  WRITE_NODE_FIELD(args);
  WRITE_LOCATION_FIELD(location);
}

static void
_outDistinctExpr(StringInfo str, const DistinctExpr *node)
{
  WRITE_NODE_TYPE("DISTINCTEXPR");

  WRITE_OID_FIELD(opno);
  WRITE_OID_FIELD(opfuncid);
  WRITE_OID_FIELD(opresulttype);
  WRITE_BOOL_FIELD(opretset);
  WRITE_OID_FIELD(opcollid);
  WRITE_OID_FIELD(inputcollid);
  WRITE_NODE_FIELD(args);
  WRITE_LOCATION_FIELD(location);
}

static void
_outNullIfExpr(StringInfo str, const NullIfExpr *node)
{
  WRITE_NODE_TYPE("NULLIFEXPR");

  WRITE_OID_FIELD(opno);
  WRITE_OID_FIELD(opfuncid);
  WRITE_OID_FIELD(opresulttype);
  WRITE_BOOL_FIELD(opretset);
  WRITE_OID_FIELD(opcollid);
  WRITE_OID_FIELD(inputcollid);
  WRITE_NODE_FIELD(args);
  WRITE_LOCATION_FIELD(location);
}

static void
_outScalarArrayOpExpr(StringInfo str, const ScalarArrayOpExpr *node)
{
  WRITE_NODE_TYPE("SCALARARRAYOPEXPR");

  WRITE_OID_FIELD(opno);
  WRITE_OID_FIELD(opfuncid);
  WRITE_OID_FIELD(hashfuncid);
  WRITE_OID_FIELD(negfuncid);
  WRITE_BOOL_FIELD(useOr);
  WRITE_OID_FIELD(inputcollid);
  WRITE_NODE_FIELD(args);
  WRITE_LOCATION_FIELD(location);
}

static void
_outSubLink(StringInfo str, const SubLink *node)
{
  WRITE_NODE_TYPE("SUBLINK");

  WRITE_ENUM_FIELD(subLinkType, SubLinkType);
  WRITE_INT_FIELD(subLinkId);
  WRITE_NODE_FIELD(testexpr);
  WRITE_NODE_FIELD(operName);
  WRITE_NODE_FIELD(subselect);
  WRITE_LOCATION_FIELD(location);
}

static void
_outSubPlan(StringInfo str, const SubPlan *node)
{
  WRITE_NODE_TYPE("SUBPLAN");

  WRITE_ENUM_FIELD(subLinkType, SubLinkType);
  WRITE_NODE_FIELD(testexpr);
  WRITE_NODE_FIELD(paramIds);
  WRITE_INT_FIELD(plan_id);
  WRITE_STRING_FIELD(plan_name);
  WRITE_OID_FIELD(firstColType);
  WRITE_INT_FIELD(firstColTypmod);
  WRITE_OID_FIELD(firstColCollation);
  WRITE_BOOL_FIELD(isInitPlan);
  WRITE_BOOL_FIELD(useHashTable);
  WRITE_BOOL_FIELD(unknownEqFalse);
  WRITE_BOOL_FIELD(parallel_safe);
  WRITE_NODE_FIELD(setParam);
  WRITE_NODE_FIELD(parParam);
  WRITE_NODE_FIELD(args);
  WRITE_FLOAT_FIELD(startup_cost);
  WRITE_FLOAT_FIELD(per_call_cost);
}

static void
_outAlternativeSubPlan(StringInfo str, const AlternativeSubPlan *node)
{
  WRITE_NODE_TYPE("ALTERNATIVESUBPLAN");

  WRITE_NODE_FIELD(subplans);
}

static void
_outFieldSelect(StringInfo str, const FieldSelect *node)
{
  WRITE_NODE_TYPE("FIELDSELECT");

  WRITE_NODE_FIELD(arg);
  WRITE_INT_FIELD(fieldnum);
  WRITE_OID_FIELD(resulttype);
  WRITE_INT_FIELD(resulttypmod);
  WRITE_OID_FIELD(resultcollid);
}

static void
_outFieldStore(StringInfo str, const FieldStore *node)
{
  WRITE_NODE_TYPE("FIELDSTORE");

  WRITE_NODE_FIELD(arg);
  WRITE_NODE_FIELD(newvals);
  WRITE_NODE_FIELD(fieldnums);
  WRITE_OID_FIELD(resulttype);
}

static void
_outRelabelType(StringInfo str, const RelabelType *node)
{
  WRITE_NODE_TYPE("RELABELTYPE");

  WRITE_NODE_FIELD(arg);
  WRITE_OID_FIELD(resulttype);
  WRITE_INT_FIELD(resulttypmod);
  WRITE_OID_FIELD(resultcollid);
  WRITE_ENUM_FIELD(relabelformat, CoercionForm);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCoerceViaIO(StringInfo str, const CoerceViaIO *node)
{
  WRITE_NODE_TYPE("COERCEVIAIO");

  WRITE_NODE_FIELD(arg);
  WRITE_OID_FIELD(resulttype);
  WRITE_OID_FIELD(resultcollid);
  WRITE_ENUM_FIELD(coerceformat, CoercionForm);
  WRITE_LOCATION_FIELD(location);
}

static void
_outArrayCoerceExpr(StringInfo str, const ArrayCoerceExpr *node)
{
  WRITE_NODE_TYPE("ARRAYCOERCEEXPR");

  WRITE_NODE_FIELD(arg);
  WRITE_NODE_FIELD(elemexpr);
  WRITE_OID_FIELD(resulttype);
  WRITE_INT_FIELD(resulttypmod);
  WRITE_OID_FIELD(resultcollid);
  WRITE_ENUM_FIELD(coerceformat, CoercionForm);
  WRITE_LOCATION_FIELD(location);
}

static void
_outConvertRowtypeExpr(StringInfo str, const ConvertRowtypeExpr *node)
{
  WRITE_NODE_TYPE("CONVERTROWTYPEEXPR");

  WRITE_NODE_FIELD(arg);
  WRITE_OID_FIELD(resulttype);
  WRITE_ENUM_FIELD(convertformat, CoercionForm);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCollateExpr(StringInfo str, const CollateExpr *node)
{
  WRITE_NODE_TYPE("COLLATEEXPR");

  WRITE_NODE_FIELD(arg);
  WRITE_OID_FIELD(collOid);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCaseExpr(StringInfo str, const CaseExpr *node)
{
  WRITE_NODE_TYPE("CASEEXPR");

  WRITE_OID_FIELD(casetype);
  WRITE_OID_FIELD(casecollid);
  WRITE_NODE_FIELD(arg);
  WRITE_NODE_FIELD(args);
  WRITE_NODE_FIELD(defresult);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCaseWhen(StringInfo str, const CaseWhen *node)
{
  WRITE_NODE_TYPE("CASEWHEN");

  WRITE_NODE_FIELD(expr);
  WRITE_NODE_FIELD(result);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCaseTestExpr(StringInfo str, const CaseTestExpr *node)
{
  WRITE_NODE_TYPE("CASETESTEXPR");

  WRITE_OID_FIELD(typeId);
  WRITE_INT_FIELD(typeMod);
  WRITE_OID_FIELD(collation);
}

static void
_outArrayExpr(StringInfo str, const ArrayExpr *node)
{
  WRITE_NODE_TYPE("ARRAYEXPR");

  WRITE_OID_FIELD(array_typeid);
  WRITE_OID_FIELD(array_collid);
  WRITE_OID_FIELD(element_typeid);
  WRITE_NODE_FIELD(elements);
  WRITE_BOOL_FIELD(multidims);
  WRITE_LOCATION_FIELD(list_start);
  WRITE_LOCATION_FIELD(list_end);
  WRITE_LOCATION_FIELD(location);
}

static void
_outRowExpr(StringInfo str, const RowExpr *node)
{
  WRITE_NODE_TYPE("ROWEXPR");

  WRITE_NODE_FIELD(args);
  WRITE_OID_FIELD(row_typeid);
  WRITE_ENUM_FIELD(row_format, CoercionForm);
  WRITE_NODE_FIELD(colnames);
  WRITE_LOCATION_FIELD(location);
}

static void
_outRowCompareExpr(StringInfo str, const RowCompareExpr *node)
{
  WRITE_NODE_TYPE("ROWCOMPAREEXPR");

  WRITE_ENUM_FIELD(cmptype, CompareType);
  WRITE_NODE_FIELD(opnos);
  WRITE_NODE_FIELD(opfamilies);
  WRITE_NODE_FIELD(inputcollids);
  WRITE_NODE_FIELD(largs);
  WRITE_NODE_FIELD(rargs);
}

static void
_outCoalesceExpr(StringInfo str, const CoalesceExpr *node)
{
  WRITE_NODE_TYPE("COALESCEEXPR");

  WRITE_OID_FIELD(coalescetype);
  WRITE_OID_FIELD(coalescecollid);
  WRITE_NODE_FIELD(args);
  WRITE_LOCATION_FIELD(location);
}

static void
_outMinMaxExpr(StringInfo str, const MinMaxExpr *node)
{
  WRITE_NODE_TYPE("MINMAXEXPR");

  WRITE_OID_FIELD(minmaxtype);
  WRITE_OID_FIELD(minmaxcollid);
  WRITE_OID_FIELD(inputcollid);
  WRITE_ENUM_FIELD(op, MinMaxOp);
  WRITE_NODE_FIELD(args);
  WRITE_LOCATION_FIELD(location);
}

static void
_outSQLValueFunction(StringInfo str, const SQLValueFunction *node)
{
  WRITE_NODE_TYPE("SQLVALUEFUNCTION");

  WRITE_ENUM_FIELD(op, SQLValueFunctionOp);
  WRITE_OID_FIELD(type);
  WRITE_INT_FIELD(typmod);
  WRITE_LOCATION_FIELD(location);
}

static void
_outXmlExpr(StringInfo str, const XmlExpr *node)
{
  WRITE_NODE_TYPE("XMLEXPR");

  WRITE_ENUM_FIELD(op, XmlExprOp);
  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(named_args);
  WRITE_NODE_FIELD(arg_names);
  WRITE_NODE_FIELD(args);
  WRITE_ENUM_FIELD(xmloption, XmlOptionType);
  WRITE_BOOL_FIELD(indent);
  WRITE_OID_FIELD(type);
  WRITE_INT_FIELD(typmod);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonFormat(StringInfo str, const JsonFormat *node)
{
  WRITE_NODE_TYPE("JSONFORMAT");

  WRITE_ENUM_FIELD(format_type, JsonFormatType);
  WRITE_ENUM_FIELD(encoding, JsonEncoding);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonReturning(StringInfo str, const JsonReturning *node)
{
  WRITE_NODE_TYPE("JSONRETURNING");

  WRITE_NODE_FIELD(format);
  WRITE_OID_FIELD(typid);
  WRITE_INT_FIELD(typmod);
}

static void
_outJsonValueExpr(StringInfo str, const JsonValueExpr *node)
{
  WRITE_NODE_TYPE("JSONVALUEEXPR");

  WRITE_NODE_FIELD(raw_expr);
  WRITE_NODE_FIELD(formatted_expr);
  WRITE_NODE_FIELD(format);
}

static void
_outJsonConstructorExpr(StringInfo str, const JsonConstructorExpr *node)
{
  WRITE_NODE_TYPE("JSONCONSTRUCTOREXPR");

  WRITE_ENUM_FIELD(type, JsonConstructorType);
  WRITE_NODE_FIELD(args);
  WRITE_NODE_FIELD(func);
  WRITE_NODE_FIELD(coercion);
  WRITE_NODE_FIELD(returning);
  WRITE_BOOL_FIELD(absent_on_null);
  WRITE_BOOL_FIELD(unique);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonIsPredicate(StringInfo str, const JsonIsPredicate *node)
{
  WRITE_NODE_TYPE("JSONISPREDICATE");

  WRITE_NODE_FIELD(expr);
  WRITE_NODE_FIELD(format);
  WRITE_ENUM_FIELD(item_type, JsonValueType);
  WRITE_BOOL_FIELD(unique_keys);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonBehavior(StringInfo str, const JsonBehavior *node)
{
  WRITE_NODE_TYPE("JSONBEHAVIOR");

  WRITE_ENUM_FIELD(btype, JsonBehaviorType);
  WRITE_NODE_FIELD(expr);
  WRITE_BOOL_FIELD(coerce);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonExpr(StringInfo str, const JsonExpr *node)
{
  WRITE_NODE_TYPE("JSONEXPR");

  WRITE_ENUM_FIELD(op, JsonExprOp);
  WRITE_STRING_FIELD(column_name);
  WRITE_NODE_FIELD(formatted_expr);
  WRITE_NODE_FIELD(format);
  WRITE_NODE_FIELD(path_spec);
  WRITE_NODE_FIELD(returning);
  WRITE_NODE_FIELD(passing_names);
  WRITE_NODE_FIELD(passing_values);
  WRITE_NODE_FIELD(on_empty);
  WRITE_NODE_FIELD(on_error);
  WRITE_BOOL_FIELD(use_io_coercion);
  WRITE_BOOL_FIELD(use_json_coercion);
  WRITE_ENUM_FIELD(wrapper, JsonWrapper);
  WRITE_BOOL_FIELD(omit_quotes);
  WRITE_OID_FIELD(collation);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonTablePath(StringInfo str, const JsonTablePath *node)
{
  WRITE_NODE_TYPE("JSONTABLEPATH");

  WRITE_NODE_FIELD(value);
  WRITE_STRING_FIELD(name);
}

static void
_outJsonTablePathScan(StringInfo str, const JsonTablePathScan *node)
{
  WRITE_NODE_TYPE("JSONTABLEPATHSCAN");

  WRITE_NODE_FIELD(path);
  WRITE_BOOL_FIELD(errorOnError);
  WRITE_NODE_FIELD(child);
  WRITE_INT_FIELD(colMin);
  WRITE_INT_FIELD(colMax);
}

static void
_outJsonTableSiblingJoin(StringInfo str, const JsonTableSiblingJoin *node)
{
  WRITE_NODE_TYPE("JSONTABLESIBLINGJOIN");

  WRITE_NODE_FIELD(lplan);
  WRITE_NODE_FIELD(rplan);
}

static void
_outNullTest(StringInfo str, const NullTest *node)
{
  WRITE_NODE_TYPE("NULLTEST");

  WRITE_NODE_FIELD(arg);
  WRITE_ENUM_FIELD(nulltesttype, NullTestType);
  WRITE_BOOL_FIELD(argisrow);
  WRITE_LOCATION_FIELD(location);
}

static void
_outBooleanTest(StringInfo str, const BooleanTest *node)
{
  WRITE_NODE_TYPE("BOOLEANTEST");

  WRITE_NODE_FIELD(arg);
  WRITE_ENUM_FIELD(booltesttype, BoolTestType);
  WRITE_LOCATION_FIELD(location);
}

static void
_outMergeAction(StringInfo str, const MergeAction *node)
{
  WRITE_NODE_TYPE("MERGEACTION");

  WRITE_ENUM_FIELD(matchKind, MergeMatchKind);
  WRITE_ENUM_FIELD(commandType, CmdType);
  WRITE_ENUM_FIELD(override, OverridingKind);
  WRITE_NODE_FIELD(qual);
  WRITE_NODE_FIELD(targetList);
  WRITE_NODE_FIELD(updateColnos);
}

static void
_outCoerceToDomain(StringInfo str, const CoerceToDomain *node)
{
  WRITE_NODE_TYPE("COERCETODOMAIN");

  WRITE_NODE_FIELD(arg);
  WRITE_OID_FIELD(resulttype);
  WRITE_INT_FIELD(resulttypmod);
  WRITE_OID_FIELD(resultcollid);
  WRITE_ENUM_FIELD(coercionformat, CoercionForm);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCoerceToDomainValue(StringInfo str, const CoerceToDomainValue *node)
{
  WRITE_NODE_TYPE("COERCETODOMAINVALUE");

  WRITE_OID_FIELD(typeId);
  WRITE_INT_FIELD(typeMod);
  WRITE_OID_FIELD(collation);
  WRITE_LOCATION_FIELD(location);
}

static void
_outSetToDefault(StringInfo str, const SetToDefault *node)
{
  WRITE_NODE_TYPE("SETTODEFAULT");

  WRITE_OID_FIELD(typeId);
  WRITE_INT_FIELD(typeMod);
  WRITE_OID_FIELD(collation);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCurrentOfExpr(StringInfo str, const CurrentOfExpr *node)
{
  WRITE_NODE_TYPE("CURRENTOFEXPR");

  WRITE_UINT_FIELD(cvarno);
  WRITE_STRING_FIELD(cursor_name);
  WRITE_INT_FIELD(cursor_param);
}

static void
_outNextValueExpr(StringInfo str, const NextValueExpr *node)
{
  WRITE_NODE_TYPE("NEXTVALUEEXPR");

  WRITE_OID_FIELD(seqid);
  WRITE_OID_FIELD(typeId);
}

static void
_outInferenceElem(StringInfo str, const InferenceElem *node)
{
  WRITE_NODE_TYPE("INFERENCEELEM");

  WRITE_NODE_FIELD(expr);
  WRITE_OID_FIELD(infercollid);
  WRITE_OID_FIELD(inferopclass);
}

static void
_outReturningExpr(StringInfo str, const ReturningExpr *node)
{
  WRITE_NODE_TYPE("RETURNINGEXPR");

  WRITE_INT_FIELD(retlevelsup);
  WRITE_BOOL_FIELD(retold);
  WRITE_NODE_FIELD(retexpr);
}

static void
_outTargetEntry(StringInfo str, const TargetEntry *node)
{
  WRITE_NODE_TYPE("TARGETENTRY");

  WRITE_NODE_FIELD(expr);
  WRITE_INT_FIELD(resno);
  WRITE_STRING_FIELD(resname);
  WRITE_UINT_FIELD(ressortgroupref);
  WRITE_OID_FIELD(resorigtbl);
  WRITE_INT_FIELD(resorigcol);
  WRITE_BOOL_FIELD(resjunk);
}

static void
_outRangeTblRef(StringInfo str, const RangeTblRef *node)
{
  WRITE_NODE_TYPE("RANGETBLREF");

  WRITE_INT_FIELD(rtindex);
}

static void
_outJoinExpr(StringInfo str, const JoinExpr *node)
{
  WRITE_NODE_TYPE("JOINEXPR");

  WRITE_ENUM_FIELD(jointype, JoinType);
  WRITE_BOOL_FIELD(isNatural);
  WRITE_NODE_FIELD(larg);
  WRITE_NODE_FIELD(rarg);
  WRITE_NODE_FIELD(usingClause);
  WRITE_NODE_FIELD(join_using_alias);
  WRITE_NODE_FIELD(quals);
  WRITE_NODE_FIELD(alias);
  WRITE_INT_FIELD(rtindex);
}

static void
_outFromExpr(StringInfo str, const FromExpr *node)
{
  WRITE_NODE_TYPE("FROMEXPR");

  WRITE_NODE_FIELD(fromlist);
  WRITE_NODE_FIELD(quals);
}

static void
_outOnConflictExpr(StringInfo str, const OnConflictExpr *node)
{
  WRITE_NODE_TYPE("ONCONFLICTEXPR");

  WRITE_ENUM_FIELD(action, OnConflictAction);
  WRITE_NODE_FIELD(arbiterElems);
  WRITE_NODE_FIELD(arbiterWhere);
  WRITE_OID_FIELD(constraint);
  WRITE_NODE_FIELD(onConflictSet);
  WRITE_NODE_FIELD(onConflictWhere);
  WRITE_INT_FIELD(exclRelIndex);
  WRITE_NODE_FIELD(exclRelTlist);
}

static void
_outQuery(StringInfo str, const Query *node)
{
  WRITE_NODE_TYPE("QUERY");

  WRITE_ENUM_FIELD(commandType, CmdType);
  WRITE_ENUM_FIELD(querySource, QuerySource);
  WRITE_BOOL_FIELD(canSetTag);
  WRITE_NODE_FIELD(utilityStmt);
  WRITE_INT_FIELD(resultRelation);
  WRITE_BOOL_FIELD(hasAggs);
  WRITE_BOOL_FIELD(hasWindowFuncs);
  WRITE_BOOL_FIELD(hasTargetSRFs);
  WRITE_BOOL_FIELD(hasSubLinks);
  WRITE_BOOL_FIELD(hasDistinctOn);
  WRITE_BOOL_FIELD(hasRecursive);
  WRITE_BOOL_FIELD(hasModifyingCTE);
  WRITE_BOOL_FIELD(hasForUpdate);
  WRITE_BOOL_FIELD(hasRowSecurity);
  WRITE_BOOL_FIELD(hasGroupRTE);
  WRITE_BOOL_FIELD(isReturn);
  WRITE_NODE_FIELD(cteList);
  WRITE_NODE_FIELD(rtable);
  WRITE_NODE_FIELD(rteperminfos);
  WRITE_NODE_FIELD(jointree);
  WRITE_NODE_FIELD(mergeActionList);
  WRITE_INT_FIELD(mergeTargetRelation);
  WRITE_NODE_FIELD(mergeJoinCondition);
  WRITE_NODE_FIELD(targetList);
  WRITE_ENUM_FIELD(override, OverridingKind);
  WRITE_NODE_FIELD(onConflict);
  WRITE_STRING_FIELD(returningOldAlias);
  WRITE_STRING_FIELD(returningNewAlias);
  WRITE_NODE_FIELD(returningList);
  WRITE_NODE_FIELD(groupClause);
  WRITE_BOOL_FIELD(groupDistinct);
  WRITE_BOOL_FIELD(groupByAll);
  WRITE_NODE_FIELD(groupingSets);
  WRITE_NODE_FIELD(havingQual);
  WRITE_NODE_FIELD(windowClause);
  WRITE_NODE_FIELD(distinctClause);
  WRITE_NODE_FIELD(sortClause);
  WRITE_NODE_FIELD(limitOffset);
  WRITE_NODE_FIELD(limitCount);
  WRITE_ENUM_FIELD(limitOption, LimitOption);
  WRITE_NODE_FIELD(rowMarks);
  WRITE_NODE_FIELD(setOperations);
  WRITE_NODE_FIELD(constraintDeps);
  WRITE_NODE_FIELD(withCheckOptions);
  WRITE_LOCATION_FIELD(stmt_location);
  WRITE_LOCATION_FIELD(stmt_len);
}

static void
_outTypeName(StringInfo str, const TypeName *node)
{
  WRITE_NODE_TYPE("TYPENAME");

  WRITE_NODE_FIELD(names);
  WRITE_OID_FIELD(typeOid);
  WRITE_BOOL_FIELD(setof);
  WRITE_BOOL_FIELD(pct_type);
  WRITE_NODE_FIELD(typmods);
  WRITE_INT_FIELD(typemod);
  WRITE_NODE_FIELD(arrayBounds);
  WRITE_LOCATION_FIELD(location);
}

static void
_outColumnRef(StringInfo str, const ColumnRef *node)
{
  WRITE_NODE_TYPE("COLUMNREF");

  WRITE_NODE_FIELD(fields);
  WRITE_LOCATION_FIELD(location);
}

static void
_outParamRef(StringInfo str, const ParamRef *node)
{
  WRITE_NODE_TYPE("PARAMREF");

  WRITE_INT_FIELD(number);
  WRITE_LOCATION_FIELD(location);
}

static void
_outTypeCast(StringInfo str, const TypeCast *node)
{
  WRITE_NODE_TYPE("TYPECAST");

  WRITE_NODE_FIELD(arg);
  WRITE_NODE_FIELD(typeName);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCollateClause(StringInfo str, const CollateClause *node)
{
  WRITE_NODE_TYPE("COLLATECLAUSE");

  WRITE_NODE_FIELD(arg);
  WRITE_NODE_FIELD(collname);
  WRITE_LOCATION_FIELD(location);
}

static void
_outRoleSpec(StringInfo str, const RoleSpec *node)
{
  WRITE_NODE_TYPE("ROLESPEC");

  WRITE_ENUM_FIELD(roletype, RoleSpecType);
  WRITE_STRING_FIELD(rolename);
  WRITE_LOCATION_FIELD(location);
}

static void
_outFuncCall(StringInfo str, const FuncCall *node)
{
  WRITE_NODE_TYPE("FUNCCALL");

  WRITE_NODE_FIELD(funcname);
  WRITE_NODE_FIELD(args);
  WRITE_NODE_FIELD(agg_order);
  WRITE_NODE_FIELD(agg_filter);
  WRITE_NODE_FIELD(over);
  WRITE_INT_FIELD(ignore_nulls);
  WRITE_BOOL_FIELD(agg_within_group);
  WRITE_BOOL_FIELD(agg_star);
  WRITE_BOOL_FIELD(agg_distinct);
  WRITE_BOOL_FIELD(func_variadic);
  WRITE_ENUM_FIELD(funcformat, CoercionForm);
  WRITE_LOCATION_FIELD(location);
}

static void
_outA_Star(StringInfo str, const A_Star *node)
{
  WRITE_NODE_TYPE("A_STAR");

}

static void
_outA_Indices(StringInfo str, const A_Indices *node)
{
  WRITE_NODE_TYPE("A_INDICES");

  WRITE_BOOL_FIELD(is_slice);
  WRITE_NODE_FIELD(lidx);
  WRITE_NODE_FIELD(uidx);
}

static void
_outA_Indirection(StringInfo str, const A_Indirection *node)
{
  WRITE_NODE_TYPE("A_INDIRECTION");

  WRITE_NODE_FIELD(arg);
  WRITE_NODE_FIELD(indirection);
}

static void
_outA_ArrayExpr(StringInfo str, const A_ArrayExpr *node)
{
  WRITE_NODE_TYPE("A_ARRAYEXPR");

  WRITE_NODE_FIELD(elements);
  WRITE_LOCATION_FIELD(list_start);
  WRITE_LOCATION_FIELD(list_end);
  WRITE_LOCATION_FIELD(location);
}

static void
_outResTarget(StringInfo str, const ResTarget *node)
{
  WRITE_NODE_TYPE("RESTARGET");

  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(indirection);
  WRITE_NODE_FIELD(val);
  WRITE_LOCATION_FIELD(location);
}

static void
_outMultiAssignRef(StringInfo str, const MultiAssignRef *node)
{
  WRITE_NODE_TYPE("MULTIASSIGNREF");

  WRITE_NODE_FIELD(source);
  WRITE_INT_FIELD(colno);
  WRITE_INT_FIELD(ncolumns);
}

static void
_outSortBy(StringInfo str, const SortBy *node)
{
  WRITE_NODE_TYPE("SORTBY");

  WRITE_NODE_FIELD(node);
  WRITE_ENUM_FIELD(sortby_dir, SortByDir);
  WRITE_ENUM_FIELD(sortby_nulls, SortByNulls);
  WRITE_NODE_FIELD(useOp);
  WRITE_LOCATION_FIELD(location);
}

static void
_outWindowDef(StringInfo str, const WindowDef *node)
{
  WRITE_NODE_TYPE("WINDOWDEF");

  WRITE_STRING_FIELD(name);
  WRITE_STRING_FIELD(refname);
  WRITE_NODE_FIELD(partitionClause);
  WRITE_NODE_FIELD(orderClause);
  WRITE_INT_FIELD(frameOptions);
  WRITE_NODE_FIELD(startOffset);
  WRITE_NODE_FIELD(endOffset);
  WRITE_LOCATION_FIELD(location);
}

static void
_outRangeSubselect(StringInfo str, const RangeSubselect *node)
{
  WRITE_NODE_TYPE("RANGESUBSELECT");

  WRITE_BOOL_FIELD(lateral);
  WRITE_NODE_FIELD(subquery);
  WRITE_NODE_FIELD(alias);
}

static void
_outRangeFunction(StringInfo str, const RangeFunction *node)
{
  WRITE_NODE_TYPE("RANGEFUNCTION");

  WRITE_BOOL_FIELD(lateral);
  WRITE_BOOL_FIELD(ordinality);
  WRITE_BOOL_FIELD(is_rowsfrom);
  WRITE_NODE_FIELD(functions);
  WRITE_NODE_FIELD(alias);
  WRITE_NODE_FIELD(coldeflist);
}

static void
_outRangeTableFunc(StringInfo str, const RangeTableFunc *node)
{
  WRITE_NODE_TYPE("RANGETABLEFUNC");

  WRITE_BOOL_FIELD(lateral);
  WRITE_NODE_FIELD(docexpr);
  WRITE_NODE_FIELD(rowexpr);
  WRITE_NODE_FIELD(namespaces);
  WRITE_NODE_FIELD(columns);
  WRITE_NODE_FIELD(alias);
  WRITE_LOCATION_FIELD(location);
}

static void
_outRangeTableFuncCol(StringInfo str, const RangeTableFuncCol *node)
{
  WRITE_NODE_TYPE("RANGETABLEFUNCCOL");

  WRITE_STRING_FIELD(colname);
  WRITE_NODE_FIELD(typeName);
  WRITE_BOOL_FIELD(for_ordinality);
  WRITE_BOOL_FIELD(is_not_null);
  WRITE_NODE_FIELD(colexpr);
  WRITE_NODE_FIELD(coldefexpr);
  WRITE_LOCATION_FIELD(location);
}

static void
_outRangeTableSample(StringInfo str, const RangeTableSample *node)
{
  WRITE_NODE_TYPE("RANGETABLESAMPLE");

  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(method);
  WRITE_NODE_FIELD(args);
  WRITE_NODE_FIELD(repeatable);
  WRITE_LOCATION_FIELD(location);
}

static void
_outColumnDef(StringInfo str, const ColumnDef *node)
{
  WRITE_NODE_TYPE("COLUMNDEF");

  WRITE_STRING_FIELD(colname);
  WRITE_NODE_FIELD(typeName);
  WRITE_STRING_FIELD(compression);
  WRITE_INT_FIELD(inhcount);
  WRITE_BOOL_FIELD(is_local);
  WRITE_BOOL_FIELD(is_not_null);
  WRITE_BOOL_FIELD(is_from_type);
  WRITE_CHAR_FIELD(storage);
  WRITE_STRING_FIELD(storage_name);
  WRITE_NODE_FIELD(raw_default);
  WRITE_NODE_FIELD(cooked_default);
  WRITE_CHAR_FIELD(identity);
  WRITE_NODE_FIELD(identitySequence);
  WRITE_CHAR_FIELD(generated);
  WRITE_NODE_FIELD(collClause);
  WRITE_OID_FIELD(collOid);
  WRITE_NODE_FIELD(constraints);
  WRITE_NODE_FIELD(fdwoptions);
  WRITE_LOCATION_FIELD(location);
}

static void
_outTableLikeClause(StringInfo str, const TableLikeClause *node)
{
  WRITE_NODE_TYPE("TABLELIKECLAUSE");

  WRITE_NODE_FIELD(relation);
  WRITE_UINT_FIELD(options);
  WRITE_OID_FIELD(relationOid);
}

static void
_outIndexElem(StringInfo str, const IndexElem *node)
{
  WRITE_NODE_TYPE("INDEXELEM");

  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(expr);
  WRITE_STRING_FIELD(indexcolname);
  WRITE_NODE_FIELD(collation);
  WRITE_NODE_FIELD(opclass);
  WRITE_NODE_FIELD(opclassopts);
  WRITE_ENUM_FIELD(ordering, SortByDir);
  WRITE_ENUM_FIELD(nulls_ordering, SortByNulls);
}

static void
_outDefElem(StringInfo str, const DefElem *node)
{
  WRITE_NODE_TYPE("DEFELEM");

  WRITE_STRING_FIELD(defnamespace);
  WRITE_STRING_FIELD(defname);
  WRITE_NODE_FIELD(arg);
  WRITE_ENUM_FIELD(defaction, DefElemAction);
  WRITE_LOCATION_FIELD(location);
}

static void
_outLockingClause(StringInfo str, const LockingClause *node)
{
  WRITE_NODE_TYPE("LOCKINGCLAUSE");

  WRITE_NODE_FIELD(lockedRels);
  WRITE_ENUM_FIELD(strength, LockClauseStrength);
  WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
}

static void
_outXmlSerialize(StringInfo str, const XmlSerialize *node)
{
  WRITE_NODE_TYPE("XMLSERIALIZE");

  WRITE_ENUM_FIELD(xmloption, XmlOptionType);
  WRITE_NODE_FIELD(expr);
  WRITE_NODE_FIELD(typeName);
  WRITE_BOOL_FIELD(indent);
  WRITE_LOCATION_FIELD(location);
}

static void
_outPartitionElem(StringInfo str, const PartitionElem *node)
{
  WRITE_NODE_TYPE("PARTITIONELEM");

  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(expr);
  WRITE_NODE_FIELD(collation);
  WRITE_NODE_FIELD(opclass);
  WRITE_LOCATION_FIELD(location);
}

static void
_outPartitionSpec(StringInfo str, const PartitionSpec *node)
{
  WRITE_NODE_TYPE("PARTITIONSPEC");

  WRITE_ENUM_FIELD(strategy, PartitionStrategy);
  WRITE_NODE_FIELD(partParams);
  WRITE_LOCATION_FIELD(location);
}

static void
_outPartitionBoundSpec(StringInfo str, const PartitionBoundSpec *node)
{
  WRITE_NODE_TYPE("PARTITIONBOUNDSPEC");

  WRITE_CHAR_FIELD(strategy);
  WRITE_BOOL_FIELD(is_default);
  WRITE_INT_FIELD(modulus);
  WRITE_INT_FIELD(remainder);
  WRITE_NODE_FIELD(listdatums);
  WRITE_NODE_FIELD(lowerdatums);
  WRITE_NODE_FIELD(upperdatums);
  WRITE_LOCATION_FIELD(location);
}

static void
_outPartitionRangeDatum(StringInfo str, const PartitionRangeDatum *node)
{
  WRITE_NODE_TYPE("PARTITIONRANGEDATUM");

  WRITE_ENUM_FIELD(kind, PartitionRangeDatumKind);
  WRITE_NODE_FIELD(value);
  WRITE_LOCATION_FIELD(location);
}

static void
_outPartitionCmd(StringInfo str, const PartitionCmd *node)
{
  WRITE_NODE_TYPE("PARTITIONCMD");

  WRITE_NODE_FIELD(name);
  WRITE_NODE_FIELD(bound);
  WRITE_BOOL_FIELD(concurrent);
}

static void
_outRTEPermissionInfo(StringInfo str, const RTEPermissionInfo *node)
{
  WRITE_NODE_TYPE("RTEPERMISSIONINFO");

  WRITE_OID_FIELD(relid);
  WRITE_BOOL_FIELD(inh);
  WRITE_UINT64_FIELD(requiredPerms);
  WRITE_OID_FIELD(checkAsUser);
  WRITE_BITMAPSET_FIELD(selectedCols);
  WRITE_BITMAPSET_FIELD(insertedCols);
  WRITE_BITMAPSET_FIELD(updatedCols);
}

static void
_outRangeTblFunction(StringInfo str, const RangeTblFunction *node)
{
  WRITE_NODE_TYPE("RANGETBLFUNCTION");

  WRITE_NODE_FIELD(funcexpr);
  WRITE_INT_FIELD(funccolcount);
  WRITE_NODE_FIELD(funccolnames);
  WRITE_NODE_FIELD(funccoltypes);
  WRITE_NODE_FIELD(funccoltypmods);
  WRITE_NODE_FIELD(funccolcollations);
  WRITE_BITMAPSET_FIELD(funcparams);
}

static void
_outTableSampleClause(StringInfo str, const TableSampleClause *node)
{
  WRITE_NODE_TYPE("TABLESAMPLECLAUSE");

  WRITE_OID_FIELD(tsmhandler);
  WRITE_NODE_FIELD(args);
  WRITE_NODE_FIELD(repeatable);
}

static void
_outWithCheckOption(StringInfo str, const WithCheckOption *node)
{
  WRITE_NODE_TYPE("WITHCHECKOPTION");

  WRITE_ENUM_FIELD(kind, WCOKind);
  WRITE_STRING_FIELD(relname);
  WRITE_STRING_FIELD(polname);
  WRITE_NODE_FIELD(qual);
  WRITE_BOOL_FIELD(cascaded);
}

static void
_outSortGroupClause(StringInfo str, const SortGroupClause *node)
{
  WRITE_NODE_TYPE("SORTGROUPCLAUSE");

  WRITE_UINT_FIELD(tleSortGroupRef);
  WRITE_OID_FIELD(eqop);
  WRITE_OID_FIELD(sortop);
  WRITE_BOOL_FIELD(reverse_sort);
  WRITE_BOOL_FIELD(nulls_first);
  WRITE_BOOL_FIELD(hashable);
}

static void
_outGroupingSet(StringInfo str, const GroupingSet *node)
{
  WRITE_NODE_TYPE("GROUPINGSET");

  WRITE_ENUM_FIELD(kind, GroupingSetKind);
  WRITE_NODE_FIELD(content);
  WRITE_LOCATION_FIELD(location);
}

static void
_outWindowClause(StringInfo str, const WindowClause *node)
{
  WRITE_NODE_TYPE("WINDOWCLAUSE");

  WRITE_STRING_FIELD(name);
  WRITE_STRING_FIELD(refname);
  WRITE_NODE_FIELD(partitionClause);
  WRITE_NODE_FIELD(orderClause);
  WRITE_INT_FIELD(frameOptions);
  WRITE_NODE_FIELD(startOffset);
  WRITE_NODE_FIELD(endOffset);
  WRITE_OID_FIELD(startInRangeFunc);
  WRITE_OID_FIELD(endInRangeFunc);
  WRITE_OID_FIELD(inRangeColl);
  WRITE_BOOL_FIELD(inRangeAsc);
  WRITE_BOOL_FIELD(inRangeNullsFirst);
  WRITE_UINT_FIELD(winref);
  WRITE_BOOL_FIELD(copiedOrder);
}

static void
_outRowMarkClause(StringInfo str, const RowMarkClause *node)
{
  WRITE_NODE_TYPE("ROWMARKCLAUSE");

  WRITE_UINT_FIELD(rti);
  WRITE_ENUM_FIELD(strength, LockClauseStrength);
  WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
  WRITE_BOOL_FIELD(pushedDown);
}

static void
_outWithClause(StringInfo str, const WithClause *node)
{
  WRITE_NODE_TYPE("WITHCLAUSE");

  WRITE_NODE_FIELD(ctes);
  WRITE_BOOL_FIELD(recursive);
  WRITE_LOCATION_FIELD(location);
}

static void
_outInferClause(StringInfo str, const InferClause *node)
{
  WRITE_NODE_TYPE("INFERCLAUSE");

  WRITE_NODE_FIELD(indexElems);
  WRITE_NODE_FIELD(whereClause);
  WRITE_STRING_FIELD(conname);
  WRITE_LOCATION_FIELD(location);
}

static void
_outOnConflictClause(StringInfo str, const OnConflictClause *node)
{
  WRITE_NODE_TYPE("ONCONFLICTCLAUSE");

  WRITE_ENUM_FIELD(action, OnConflictAction);
  WRITE_NODE_FIELD(infer);
  WRITE_NODE_FIELD(targetList);
  WRITE_NODE_FIELD(whereClause);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCTESearchClause(StringInfo str, const CTESearchClause *node)
{
  WRITE_NODE_TYPE("CTESEARCHCLAUSE");

  WRITE_NODE_FIELD(search_col_list);
  WRITE_BOOL_FIELD(search_breadth_first);
  WRITE_STRING_FIELD(search_seq_column);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCTECycleClause(StringInfo str, const CTECycleClause *node)
{
  WRITE_NODE_TYPE("CTECYCLECLAUSE");

  WRITE_NODE_FIELD(cycle_col_list);
  WRITE_STRING_FIELD(cycle_mark_column);
  WRITE_NODE_FIELD(cycle_mark_value);
  WRITE_NODE_FIELD(cycle_mark_default);
  WRITE_STRING_FIELD(cycle_path_column);
  WRITE_LOCATION_FIELD(location);
  WRITE_OID_FIELD(cycle_mark_type);
  WRITE_INT_FIELD(cycle_mark_typmod);
  WRITE_OID_FIELD(cycle_mark_collation);
  WRITE_OID_FIELD(cycle_mark_neop);
}

static void
_outCommonTableExpr(StringInfo str, const CommonTableExpr *node)
{
  WRITE_NODE_TYPE("COMMONTABLEEXPR");

  WRITE_STRING_FIELD(ctename);
  WRITE_NODE_FIELD(aliascolnames);
  WRITE_ENUM_FIELD(ctematerialized, CTEMaterialize);
  WRITE_NODE_FIELD(ctequery);
  WRITE_NODE_FIELD(search_clause);
  WRITE_NODE_FIELD(cycle_clause);
  WRITE_LOCATION_FIELD(location);
  WRITE_BOOL_FIELD(cterecursive);
  WRITE_INT_FIELD(cterefcount);
  WRITE_NODE_FIELD(ctecolnames);
  WRITE_NODE_FIELD(ctecoltypes);
  WRITE_NODE_FIELD(ctecoltypmods);
  WRITE_NODE_FIELD(ctecolcollations);
}

static void
_outMergeWhenClause(StringInfo str, const MergeWhenClause *node)
{
  WRITE_NODE_TYPE("MERGEWHENCLAUSE");

  WRITE_ENUM_FIELD(matchKind, MergeMatchKind);
  WRITE_ENUM_FIELD(commandType, CmdType);
  WRITE_ENUM_FIELD(override, OverridingKind);
  WRITE_NODE_FIELD(condition);
  WRITE_NODE_FIELD(targetList);
  WRITE_NODE_FIELD(values);
}

static void
_outReturningOption(StringInfo str, const ReturningOption *node)
{
  WRITE_NODE_TYPE("RETURNINGOPTION");

  WRITE_ENUM_FIELD(option, ReturningOptionKind);
  WRITE_STRING_FIELD(value);
  WRITE_LOCATION_FIELD(location);
}

static void
_outReturningClause(StringInfo str, const ReturningClause *node)
{
  WRITE_NODE_TYPE("RETURNINGCLAUSE");

  WRITE_NODE_FIELD(options);
  WRITE_NODE_FIELD(exprs);
}

static void
_outTriggerTransition(StringInfo str, const TriggerTransition *node)
{
  WRITE_NODE_TYPE("TRIGGERTRANSITION");

  WRITE_STRING_FIELD(name);
  WRITE_BOOL_FIELD(isNew);
  WRITE_BOOL_FIELD(isTable);
}

static void
_outJsonOutput(StringInfo str, const JsonOutput *node)
{
  WRITE_NODE_TYPE("JSONOUTPUT");

  WRITE_NODE_FIELD(typeName);
  WRITE_NODE_FIELD(returning);
}

static void
_outJsonArgument(StringInfo str, const JsonArgument *node)
{
  WRITE_NODE_TYPE("JSONARGUMENT");

  WRITE_NODE_FIELD(val);
  WRITE_STRING_FIELD(name);
}

static void
_outJsonFuncExpr(StringInfo str, const JsonFuncExpr *node)
{
  WRITE_NODE_TYPE("JSONFUNCEXPR");

  WRITE_ENUM_FIELD(op, JsonExprOp);
  WRITE_STRING_FIELD(column_name);
  WRITE_NODE_FIELD(context_item);
  WRITE_NODE_FIELD(pathspec);
  WRITE_NODE_FIELD(passing);
  WRITE_NODE_FIELD(output);
  WRITE_NODE_FIELD(on_empty);
  WRITE_NODE_FIELD(on_error);
  WRITE_ENUM_FIELD(wrapper, JsonWrapper);
  WRITE_ENUM_FIELD(quotes, JsonQuotes);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonTablePathSpec(StringInfo str, const JsonTablePathSpec *node)
{
  WRITE_NODE_TYPE("JSONTABLEPATHSPEC");

  WRITE_NODE_FIELD(string);
  WRITE_STRING_FIELD(name);
  WRITE_LOCATION_FIELD(name_location);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonTable(StringInfo str, const JsonTable *node)
{
  WRITE_NODE_TYPE("JSONTABLE");

  WRITE_NODE_FIELD(context_item);
  WRITE_NODE_FIELD(pathspec);
  WRITE_NODE_FIELD(passing);
  WRITE_NODE_FIELD(columns);
  WRITE_NODE_FIELD(on_error);
  WRITE_NODE_FIELD(alias);
  WRITE_BOOL_FIELD(lateral);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonTableColumn(StringInfo str, const JsonTableColumn *node)
{
  WRITE_NODE_TYPE("JSONTABLECOLUMN");

  WRITE_ENUM_FIELD(coltype, JsonTableColumnType);
  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(typeName);
  WRITE_NODE_FIELD(pathspec);
  WRITE_NODE_FIELD(format);
  WRITE_ENUM_FIELD(wrapper, JsonWrapper);
  WRITE_ENUM_FIELD(quotes, JsonQuotes);
  WRITE_NODE_FIELD(columns);
  WRITE_NODE_FIELD(on_empty);
  WRITE_NODE_FIELD(on_error);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonKeyValue(StringInfo str, const JsonKeyValue *node)
{
  WRITE_NODE_TYPE("JSONKEYVALUE");

  WRITE_NODE_FIELD(key);
  WRITE_NODE_FIELD(value);
}

static void
_outJsonParseExpr(StringInfo str, const JsonParseExpr *node)
{
  WRITE_NODE_TYPE("JSONPARSEEXPR");

  WRITE_NODE_FIELD(expr);
  WRITE_NODE_FIELD(output);
  WRITE_BOOL_FIELD(unique_keys);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonScalarExpr(StringInfo str, const JsonScalarExpr *node)
{
  WRITE_NODE_TYPE("JSONSCALAREXPR");

  WRITE_NODE_FIELD(expr);
  WRITE_NODE_FIELD(output);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonSerializeExpr(StringInfo str, const JsonSerializeExpr *node)
{
  WRITE_NODE_TYPE("JSONSERIALIZEEXPR");

  WRITE_NODE_FIELD(expr);
  WRITE_NODE_FIELD(output);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonObjectConstructor(StringInfo str, const JsonObjectConstructor *node)
{
  WRITE_NODE_TYPE("JSONOBJECTCONSTRUCTOR");

  WRITE_NODE_FIELD(exprs);
  WRITE_NODE_FIELD(output);
  WRITE_BOOL_FIELD(absent_on_null);
  WRITE_BOOL_FIELD(unique);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonArrayConstructor(StringInfo str, const JsonArrayConstructor *node)
{
  WRITE_NODE_TYPE("JSONARRAYCONSTRUCTOR");

  WRITE_NODE_FIELD(exprs);
  WRITE_NODE_FIELD(output);
  WRITE_BOOL_FIELD(absent_on_null);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonArrayQueryConstructor(StringInfo str, const JsonArrayQueryConstructor *node)
{
  WRITE_NODE_TYPE("JSONARRAYQUERYCONSTRUCTOR");

  WRITE_NODE_FIELD(query);
  WRITE_NODE_FIELD(output);
  WRITE_NODE_FIELD(format);
  WRITE_BOOL_FIELD(absent_on_null);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonAggConstructor(StringInfo str, const JsonAggConstructor *node)
{
  WRITE_NODE_TYPE("JSONAGGCONSTRUCTOR");

  WRITE_NODE_FIELD(output);
  WRITE_NODE_FIELD(agg_filter);
  WRITE_NODE_FIELD(agg_order);
  WRITE_NODE_FIELD(over);
  WRITE_LOCATION_FIELD(location);
}

static void
_outJsonObjectAgg(StringInfo str, const JsonObjectAgg *node)
{
  WRITE_NODE_TYPE("JSONOBJECTAGG");

  WRITE_NODE_FIELD(constructor);
  WRITE_NODE_FIELD(arg);
  WRITE_BOOL_FIELD(absent_on_null);
  WRITE_BOOL_FIELD(unique);
}

static void
_outJsonArrayAgg(StringInfo str, const JsonArrayAgg *node)
{
  WRITE_NODE_TYPE("JSONARRAYAGG");

  WRITE_NODE_FIELD(constructor);
  WRITE_NODE_FIELD(arg);
  WRITE_BOOL_FIELD(absent_on_null);
}

static void
_outRawStmt(StringInfo str, const RawStmt *node)
{
  WRITE_NODE_TYPE("RAWSTMT");

  WRITE_NODE_FIELD(stmt);
  WRITE_LOCATION_FIELD(stmt_location);
  WRITE_LOCATION_FIELD(stmt_len);
}

static void
_outInsertStmt(StringInfo str, const InsertStmt *node)
{
  WRITE_NODE_TYPE("INSERTSTMT");

  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(cols);
  WRITE_NODE_FIELD(selectStmt);
  WRITE_NODE_FIELD(onConflictClause);
  WRITE_NODE_FIELD(returningClause);
  WRITE_NODE_FIELD(withClause);
  WRITE_ENUM_FIELD(override, OverridingKind);
}

static void
_outDeleteStmt(StringInfo str, const DeleteStmt *node)
{
  WRITE_NODE_TYPE("DELETESTMT");

  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(usingClause);
  WRITE_NODE_FIELD(whereClause);
  WRITE_NODE_FIELD(returningClause);
  WRITE_NODE_FIELD(withClause);
}

static void
_outUpdateStmt(StringInfo str, const UpdateStmt *node)
{
  WRITE_NODE_TYPE("UPDATESTMT");

  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(targetList);
  WRITE_NODE_FIELD(whereClause);
  WRITE_NODE_FIELD(fromClause);
  WRITE_NODE_FIELD(returningClause);
  WRITE_NODE_FIELD(withClause);
}

static void
_outMergeStmt(StringInfo str, const MergeStmt *node)
{
  WRITE_NODE_TYPE("MERGESTMT");

  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(sourceRelation);
  WRITE_NODE_FIELD(joinCondition);
  WRITE_NODE_FIELD(mergeWhenClauses);
  WRITE_NODE_FIELD(returningClause);
  WRITE_NODE_FIELD(withClause);
}

static void
_outSelectStmt(StringInfo str, const SelectStmt *node)
{
  WRITE_NODE_TYPE("SELECTSTMT");

  WRITE_NODE_FIELD(distinctClause);
  WRITE_NODE_FIELD(intoClause);
  WRITE_NODE_FIELD(targetList);
  WRITE_NODE_FIELD(fromClause);
  WRITE_NODE_FIELD(whereClause);
  WRITE_NODE_FIELD(groupClause);
  WRITE_BOOL_FIELD(groupDistinct);
  WRITE_BOOL_FIELD(groupByAll);
  WRITE_NODE_FIELD(havingClause);
  WRITE_NODE_FIELD(windowClause);
  WRITE_NODE_FIELD(valuesLists);
  WRITE_NODE_FIELD(sortClause);
  WRITE_NODE_FIELD(limitOffset);
  WRITE_NODE_FIELD(limitCount);
  WRITE_ENUM_FIELD(limitOption, LimitOption);
  WRITE_NODE_FIELD(lockingClause);
  WRITE_NODE_FIELD(withClause);
  WRITE_ENUM_FIELD(op, SetOperation);
  WRITE_BOOL_FIELD(all);
  WRITE_NODE_FIELD(larg);
  WRITE_NODE_FIELD(rarg);
}

static void
_outSetOperationStmt(StringInfo str, const SetOperationStmt *node)
{
  WRITE_NODE_TYPE("SETOPERATIONSTMT");

  WRITE_ENUM_FIELD(op, SetOperation);
  WRITE_BOOL_FIELD(all);
  WRITE_NODE_FIELD(larg);
  WRITE_NODE_FIELD(rarg);
  WRITE_NODE_FIELD(colTypes);
  WRITE_NODE_FIELD(colTypmods);
  WRITE_NODE_FIELD(colCollations);
  WRITE_NODE_FIELD(groupClauses);
}

static void
_outReturnStmt(StringInfo str, const ReturnStmt *node)
{
  WRITE_NODE_TYPE("RETURNSTMT");

  WRITE_NODE_FIELD(returnval);
}

static void
_outPLAssignStmt(StringInfo str, const PLAssignStmt *node)
{
  WRITE_NODE_TYPE("PLASSIGNSTMT");

  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(indirection);
  WRITE_INT_FIELD(nnames);
  WRITE_NODE_FIELD(val);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCreateSchemaStmt(StringInfo str, const CreateSchemaStmt *node)
{
  WRITE_NODE_TYPE("CREATESCHEMASTMT");

  WRITE_STRING_FIELD(schemaname);
  WRITE_NODE_FIELD(authrole);
  WRITE_NODE_FIELD(schemaElts);
  WRITE_BOOL_FIELD(if_not_exists);
}

static void
_outAlterTableStmt(StringInfo str, const AlterTableStmt *node)
{
  WRITE_NODE_TYPE("ALTERTABLESTMT");

  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(cmds);
  WRITE_ENUM_FIELD(objtype, ObjectType);
  WRITE_BOOL_FIELD(missing_ok);
}

static void
_outAlterTableCmd(StringInfo str, const AlterTableCmd *node)
{
  WRITE_NODE_TYPE("ALTERTABLECMD");

  WRITE_ENUM_FIELD(subtype, AlterTableType);
  WRITE_STRING_FIELD(name);
  WRITE_INT_FIELD(num);
  WRITE_NODE_FIELD(newowner);
  WRITE_NODE_FIELD(def);
  WRITE_ENUM_FIELD(behavior, DropBehavior);
  WRITE_BOOL_FIELD(missing_ok);
  WRITE_BOOL_FIELD(recurse);
}

static void
_outATAlterConstraint(StringInfo str, const ATAlterConstraint *node)
{
  WRITE_NODE_TYPE("ATALTERCONSTRAINT");

  WRITE_STRING_FIELD(conname);
  WRITE_BOOL_FIELD(alterEnforceability);
  WRITE_BOOL_FIELD(is_enforced);
  WRITE_BOOL_FIELD(alterDeferrability);
  WRITE_BOOL_FIELD(deferrable);
  WRITE_BOOL_FIELD(initdeferred);
  WRITE_BOOL_FIELD(alterInheritability);
  WRITE_BOOL_FIELD(noinherit);
}

static void
_outReplicaIdentityStmt(StringInfo str, const ReplicaIdentityStmt *node)
{
  WRITE_NODE_TYPE("REPLICAIDENTITYSTMT");

  WRITE_CHAR_FIELD(identity_type);
  WRITE_STRING_FIELD(name);
}

static void
_outAlterCollationStmt(StringInfo str, const AlterCollationStmt *node)
{
  WRITE_NODE_TYPE("ALTERCOLLATIONSTMT");

  WRITE_NODE_FIELD(collname);
}

static void
_outAlterDomainStmt(StringInfo str, const AlterDomainStmt *node)
{
  WRITE_NODE_TYPE("ALTERDOMAINSTMT");

  WRITE_ENUM_FIELD(subtype, AlterDomainType);
  WRITE_NODE_FIELD(typeName);
  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(def);
  WRITE_ENUM_FIELD(behavior, DropBehavior);
  WRITE_BOOL_FIELD(missing_ok);
}

static void
_outGrantStmt(StringInfo str, const GrantStmt *node)
{
  WRITE_NODE_TYPE("GRANTSTMT");

  WRITE_BOOL_FIELD(is_grant);
  WRITE_ENUM_FIELD(targtype, GrantTargetType);
  WRITE_ENUM_FIELD(objtype, ObjectType);
  WRITE_NODE_FIELD(objects);
  WRITE_NODE_FIELD(privileges);
  WRITE_NODE_FIELD(grantees);
  WRITE_BOOL_FIELD(grant_option);
  WRITE_NODE_FIELD(grantor);
  WRITE_ENUM_FIELD(behavior, DropBehavior);
}

static void
_outObjectWithArgs(StringInfo str, const ObjectWithArgs *node)
{
  WRITE_NODE_TYPE("OBJECTWITHARGS");

  WRITE_NODE_FIELD(objname);
  WRITE_NODE_FIELD(objargs);
  WRITE_NODE_FIELD(objfuncargs);
  WRITE_BOOL_FIELD(args_unspecified);
}

static void
_outAccessPriv(StringInfo str, const AccessPriv *node)
{
  WRITE_NODE_TYPE("ACCESSPRIV");

  WRITE_STRING_FIELD(priv_name);
  WRITE_NODE_FIELD(cols);
}

static void
_outGrantRoleStmt(StringInfo str, const GrantRoleStmt *node)
{
  WRITE_NODE_TYPE("GRANTROLESTMT");

  WRITE_NODE_FIELD(granted_roles);
  WRITE_NODE_FIELD(grantee_roles);
  WRITE_BOOL_FIELD(is_grant);
  WRITE_NODE_FIELD(opt);
  WRITE_NODE_FIELD(grantor);
  WRITE_ENUM_FIELD(behavior, DropBehavior);
}

static void
_outAlterDefaultPrivilegesStmt(StringInfo str, const AlterDefaultPrivilegesStmt *node)
{
  WRITE_NODE_TYPE("ALTERDEFAULTPRIVILEGESSTMT");

  WRITE_NODE_FIELD(options);
  WRITE_NODE_FIELD(action);
}

static void
_outCopyStmt(StringInfo str, const CopyStmt *node)
{
  WRITE_NODE_TYPE("COPYSTMT");

  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(query);
  WRITE_NODE_FIELD(attlist);
  WRITE_BOOL_FIELD(is_from);
  WRITE_BOOL_FIELD(is_program);
  WRITE_STRING_FIELD(filename);
  WRITE_NODE_FIELD(options);
  WRITE_NODE_FIELD(whereClause);
}

static void
_outVariableSetStmt(StringInfo str, const VariableSetStmt *node)
{
  WRITE_NODE_TYPE("VARIABLESETSTMT");

  WRITE_ENUM_FIELD(kind, VariableSetKind);
  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(args);
  WRITE_BOOL_FIELD(jumble_args);
  WRITE_BOOL_FIELD(is_local);
  WRITE_LOCATION_FIELD(location);
}

static void
_outVariableShowStmt(StringInfo str, const VariableShowStmt *node)
{
  WRITE_NODE_TYPE("VARIABLESHOWSTMT");

  WRITE_STRING_FIELD(name);
}

static void
_outCreateStmt(StringInfo str, const CreateStmt *node)
{
  WRITE_NODE_TYPE("CREATESTMT");

  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(tableElts);
  WRITE_NODE_FIELD(inhRelations);
  WRITE_NODE_FIELD(partbound);
  WRITE_NODE_FIELD(partspec);
  WRITE_NODE_FIELD(ofTypename);
  WRITE_NODE_FIELD(constraints);
  WRITE_NODE_FIELD(nnconstraints);
  WRITE_NODE_FIELD(options);
  WRITE_ENUM_FIELD(oncommit, OnCommitAction);
  WRITE_STRING_FIELD(tablespacename);
  WRITE_STRING_FIELD(accessMethod);
  WRITE_BOOL_FIELD(if_not_exists);
}

static void
_outConstraint(StringInfo str, const Constraint *node)
{
  WRITE_NODE_TYPE("CONSTRAINT");

  WRITE_ENUM_FIELD(contype, ConstrType);
  WRITE_STRING_FIELD(conname);
  WRITE_BOOL_FIELD(deferrable);
  WRITE_BOOL_FIELD(initdeferred);
  WRITE_BOOL_FIELD(is_enforced);
  WRITE_BOOL_FIELD(skip_validation);
  WRITE_BOOL_FIELD(initially_valid);
  WRITE_BOOL_FIELD(is_no_inherit);
  WRITE_NODE_FIELD(raw_expr);
  WRITE_STRING_FIELD(cooked_expr);
  WRITE_CHAR_FIELD(generated_when);
  WRITE_CHAR_FIELD(generated_kind);
  WRITE_BOOL_FIELD(nulls_not_distinct);
  WRITE_NODE_FIELD(keys);
  WRITE_BOOL_FIELD(without_overlaps);
  WRITE_NODE_FIELD(including);
  WRITE_NODE_FIELD(exclusions);
  WRITE_NODE_FIELD(options);
  WRITE_STRING_FIELD(indexname);
  WRITE_STRING_FIELD(indexspace);
  WRITE_BOOL_FIELD(reset_default_tblspc);
  WRITE_STRING_FIELD(access_method);
  WRITE_NODE_FIELD(where_clause);
  WRITE_NODE_FIELD(pktable);
  WRITE_NODE_FIELD(fk_attrs);
  WRITE_NODE_FIELD(pk_attrs);
  WRITE_BOOL_FIELD(fk_with_period);
  WRITE_BOOL_FIELD(pk_with_period);
  WRITE_CHAR_FIELD(fk_matchtype);
  WRITE_CHAR_FIELD(fk_upd_action);
  WRITE_CHAR_FIELD(fk_del_action);
  WRITE_NODE_FIELD(fk_del_set_cols);
  WRITE_NODE_FIELD(old_conpfeqop);
  WRITE_OID_FIELD(old_pktable_oid);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCreateTableSpaceStmt(StringInfo str, const CreateTableSpaceStmt *node)
{
  WRITE_NODE_TYPE("CREATETABLESPACESTMT");

  WRITE_STRING_FIELD(tablespacename);
  WRITE_NODE_FIELD(owner);
  WRITE_STRING_FIELD(location);
  WRITE_NODE_FIELD(options);
}

static void
_outDropTableSpaceStmt(StringInfo str, const DropTableSpaceStmt *node)
{
  WRITE_NODE_TYPE("DROPTABLESPACESTMT");

  WRITE_STRING_FIELD(tablespacename);
  WRITE_BOOL_FIELD(missing_ok);
}

static void
_outAlterTableSpaceOptionsStmt(StringInfo str, const AlterTableSpaceOptionsStmt *node)
{
  WRITE_NODE_TYPE("ALTERTABLESPACEOPTIONSSTMT");

  WRITE_STRING_FIELD(tablespacename);
  WRITE_NODE_FIELD(options);
  WRITE_BOOL_FIELD(isReset);
}

static void
_outAlterTableMoveAllStmt(StringInfo str, const AlterTableMoveAllStmt *node)
{
  WRITE_NODE_TYPE("ALTERTABLEMOVEALLSTMT");

  WRITE_STRING_FIELD(orig_tablespacename);
  WRITE_ENUM_FIELD(objtype, ObjectType);
  WRITE_NODE_FIELD(roles);
  WRITE_STRING_FIELD(new_tablespacename);
  WRITE_BOOL_FIELD(nowait);
}

static void
_outCreateExtensionStmt(StringInfo str, const CreateExtensionStmt *node)
{
  WRITE_NODE_TYPE("CREATEEXTENSIONSTMT");

  WRITE_STRING_FIELD(extname);
  WRITE_BOOL_FIELD(if_not_exists);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterExtensionStmt(StringInfo str, const AlterExtensionStmt *node)
{
  WRITE_NODE_TYPE("ALTEREXTENSIONSTMT");

  WRITE_STRING_FIELD(extname);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterExtensionContentsStmt(StringInfo str, const AlterExtensionContentsStmt *node)
{
  WRITE_NODE_TYPE("ALTEREXTENSIONCONTENTSSTMT");

  WRITE_STRING_FIELD(extname);
  WRITE_INT_FIELD(action);
  WRITE_ENUM_FIELD(objtype, ObjectType);
  WRITE_NODE_FIELD(object);
}

static void
_outCreateFdwStmt(StringInfo str, const CreateFdwStmt *node)
{
  WRITE_NODE_TYPE("CREATEFDWSTMT");

  WRITE_STRING_FIELD(fdwname);
  WRITE_NODE_FIELD(func_options);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterFdwStmt(StringInfo str, const AlterFdwStmt *node)
{
  WRITE_NODE_TYPE("ALTERFDWSTMT");

  WRITE_STRING_FIELD(fdwname);
  WRITE_NODE_FIELD(func_options);
  WRITE_NODE_FIELD(options);
}

static void
_outCreateForeignServerStmt(StringInfo str, const CreateForeignServerStmt *node)
{
  WRITE_NODE_TYPE("CREATEFOREIGNSERVERSTMT");

  WRITE_STRING_FIELD(servername);
  WRITE_STRING_FIELD(servertype);
  WRITE_STRING_FIELD(version);
  WRITE_STRING_FIELD(fdwname);
  WRITE_BOOL_FIELD(if_not_exists);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterForeignServerStmt(StringInfo str, const AlterForeignServerStmt *node)
{
  WRITE_NODE_TYPE("ALTERFOREIGNSERVERSTMT");

  WRITE_STRING_FIELD(servername);
  WRITE_STRING_FIELD(version);
  WRITE_NODE_FIELD(options);
  WRITE_BOOL_FIELD(has_version);
}

static void
_outCreateForeignTableStmt(StringInfo str, const CreateForeignTableStmt *node)
{
  WRITE_NODE_TYPE("CREATEFOREIGNTABLESTMT");

  WRITE_NODE_FIELD(base.relation);
  WRITE_NODE_FIELD(base.tableElts);
  WRITE_NODE_FIELD(base.inhRelations);
  WRITE_NODE_FIELD(base.partbound);
  WRITE_NODE_FIELD(base.partspec);
  WRITE_NODE_FIELD(base.ofTypename);
  WRITE_NODE_FIELD(base.constraints);
  WRITE_NODE_FIELD(base.nnconstraints);
  WRITE_NODE_FIELD(base.options);
  WRITE_ENUM_FIELD(base.oncommit, OnCommitAction);
  WRITE_STRING_FIELD(base.tablespacename);
  WRITE_STRING_FIELD(base.accessMethod);
  WRITE_BOOL_FIELD(base.if_not_exists);
  WRITE_STRING_FIELD(servername);
  WRITE_NODE_FIELD(options);
}

static void
_outCreateUserMappingStmt(StringInfo str, const CreateUserMappingStmt *node)
{
  WRITE_NODE_TYPE("CREATEUSERMAPPINGSTMT");

  WRITE_NODE_FIELD(user);
  WRITE_STRING_FIELD(servername);
  WRITE_BOOL_FIELD(if_not_exists);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterUserMappingStmt(StringInfo str, const AlterUserMappingStmt *node)
{
  WRITE_NODE_TYPE("ALTERUSERMAPPINGSTMT");

  WRITE_NODE_FIELD(user);
  WRITE_STRING_FIELD(servername);
  WRITE_NODE_FIELD(options);
}

static void
_outDropUserMappingStmt(StringInfo str, const DropUserMappingStmt *node)
{
  WRITE_NODE_TYPE("DROPUSERMAPPINGSTMT");

  WRITE_NODE_FIELD(user);
  WRITE_STRING_FIELD(servername);
  WRITE_BOOL_FIELD(missing_ok);
}

static void
_outImportForeignSchemaStmt(StringInfo str, const ImportForeignSchemaStmt *node)
{
  WRITE_NODE_TYPE("IMPORTFOREIGNSCHEMASTMT");

  WRITE_STRING_FIELD(server_name);
  WRITE_STRING_FIELD(remote_schema);
  WRITE_STRING_FIELD(local_schema);
  WRITE_ENUM_FIELD(list_type, ImportForeignSchemaType);
  WRITE_NODE_FIELD(table_list);
  WRITE_NODE_FIELD(options);
}

static void
_outCreatePolicyStmt(StringInfo str, const CreatePolicyStmt *node)
{
  WRITE_NODE_TYPE("CREATEPOLICYSTMT");

  WRITE_STRING_FIELD(policy_name);
  WRITE_NODE_FIELD(table);
  WRITE_STRING_FIELD(cmd_name);
  WRITE_BOOL_FIELD(permissive);
  WRITE_NODE_FIELD(roles);
  WRITE_NODE_FIELD(qual);
  WRITE_NODE_FIELD(with_check);
}

static void
_outAlterPolicyStmt(StringInfo str, const AlterPolicyStmt *node)
{
  WRITE_NODE_TYPE("ALTERPOLICYSTMT");

  WRITE_STRING_FIELD(policy_name);
  WRITE_NODE_FIELD(table);
  WRITE_NODE_FIELD(roles);
  WRITE_NODE_FIELD(qual);
  WRITE_NODE_FIELD(with_check);
}

static void
_outCreateAmStmt(StringInfo str, const CreateAmStmt *node)
{
  WRITE_NODE_TYPE("CREATEAMSTMT");

  WRITE_STRING_FIELD(amname);
  WRITE_NODE_FIELD(handler_name);
  WRITE_CHAR_FIELD(amtype);
}

static void
_outCreateTrigStmt(StringInfo str, const CreateTrigStmt *node)
{
  WRITE_NODE_TYPE("CREATETRIGSTMT");

  WRITE_BOOL_FIELD(replace);
  WRITE_BOOL_FIELD(isconstraint);
  WRITE_STRING_FIELD(trigname);
  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(funcname);
  WRITE_NODE_FIELD(args);
  WRITE_BOOL_FIELD(row);
  WRITE_INT_FIELD(timing);
  WRITE_INT_FIELD(events);
  WRITE_NODE_FIELD(columns);
  WRITE_NODE_FIELD(whenClause);
  WRITE_NODE_FIELD(transitionRels);
  WRITE_BOOL_FIELD(deferrable);
  WRITE_BOOL_FIELD(initdeferred);
  WRITE_NODE_FIELD(constrrel);
}

static void
_outCreateEventTrigStmt(StringInfo str, const CreateEventTrigStmt *node)
{
  WRITE_NODE_TYPE("CREATEEVENTTRIGSTMT");

  WRITE_STRING_FIELD(trigname);
  WRITE_STRING_FIELD(eventname);
  WRITE_NODE_FIELD(whenclause);
  WRITE_NODE_FIELD(funcname);
}

static void
_outAlterEventTrigStmt(StringInfo str, const AlterEventTrigStmt *node)
{
  WRITE_NODE_TYPE("ALTEREVENTTRIGSTMT");

  WRITE_STRING_FIELD(trigname);
  WRITE_CHAR_FIELD(tgenabled);
}

static void
_outCreatePLangStmt(StringInfo str, const CreatePLangStmt *node)
{
  WRITE_NODE_TYPE("CREATEPLANGSTMT");

  WRITE_BOOL_FIELD(replace);
  WRITE_STRING_FIELD(plname);
  WRITE_NODE_FIELD(plhandler);
  WRITE_NODE_FIELD(plinline);
  WRITE_NODE_FIELD(plvalidator);
  WRITE_BOOL_FIELD(pltrusted);
}

static void
_outCreateRoleStmt(StringInfo str, const CreateRoleStmt *node)
{
  WRITE_NODE_TYPE("CREATEROLESTMT");

  WRITE_ENUM_FIELD(stmt_type, RoleStmtType);
  WRITE_STRING_FIELD(role);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterRoleStmt(StringInfo str, const AlterRoleStmt *node)
{
  WRITE_NODE_TYPE("ALTERROLESTMT");

  WRITE_NODE_FIELD(role);
  WRITE_NODE_FIELD(options);
  WRITE_INT_FIELD(action);
}

static void
_outAlterRoleSetStmt(StringInfo str, const AlterRoleSetStmt *node)
{
  WRITE_NODE_TYPE("ALTERROLESETSTMT");

  WRITE_NODE_FIELD(role);
  WRITE_STRING_FIELD(database);
  WRITE_NODE_FIELD(setstmt);
}

static void
_outDropRoleStmt(StringInfo str, const DropRoleStmt *node)
{
  WRITE_NODE_TYPE("DROPROLESTMT");

  WRITE_NODE_FIELD(roles);
  WRITE_BOOL_FIELD(missing_ok);
}

static void
_outCreateSeqStmt(StringInfo str, const CreateSeqStmt *node)
{
  WRITE_NODE_TYPE("CREATESEQSTMT");

  WRITE_NODE_FIELD(sequence);
  WRITE_NODE_FIELD(options);
  WRITE_OID_FIELD(ownerId);
  WRITE_BOOL_FIELD(for_identity);
  WRITE_BOOL_FIELD(if_not_exists);
}

static void
_outAlterSeqStmt(StringInfo str, const AlterSeqStmt *node)
{
  WRITE_NODE_TYPE("ALTERSEQSTMT");

  WRITE_NODE_FIELD(sequence);
  WRITE_NODE_FIELD(options);
  WRITE_BOOL_FIELD(for_identity);
  WRITE_BOOL_FIELD(missing_ok);
}

static void
_outDefineStmt(StringInfo str, const DefineStmt *node)
{
  WRITE_NODE_TYPE("DEFINESTMT");

  WRITE_ENUM_FIELD(kind, ObjectType);
  WRITE_BOOL_FIELD(oldstyle);
  WRITE_NODE_FIELD(defnames);
  WRITE_NODE_FIELD(args);
  WRITE_NODE_FIELD(definition);
  WRITE_BOOL_FIELD(if_not_exists);
  WRITE_BOOL_FIELD(replace);
}

static void
_outCreateDomainStmt(StringInfo str, const CreateDomainStmt *node)
{
  WRITE_NODE_TYPE("CREATEDOMAINSTMT");

  WRITE_NODE_FIELD(domainname);
  WRITE_NODE_FIELD(typeName);
  WRITE_NODE_FIELD(collClause);
  WRITE_NODE_FIELD(constraints);
}

static void
_outCreateOpClassStmt(StringInfo str, const CreateOpClassStmt *node)
{
  WRITE_NODE_TYPE("CREATEOPCLASSSTMT");

  WRITE_NODE_FIELD(opclassname);
  WRITE_NODE_FIELD(opfamilyname);
  WRITE_STRING_FIELD(amname);
  WRITE_NODE_FIELD(datatype);
  WRITE_NODE_FIELD(items);
  WRITE_BOOL_FIELD(isDefault);
}

static void
_outCreateOpClassItem(StringInfo str, const CreateOpClassItem *node)
{
  WRITE_NODE_TYPE("CREATEOPCLASSITEM");

  WRITE_INT_FIELD(itemtype);
  WRITE_NODE_FIELD(name);
  WRITE_INT_FIELD(number);
  WRITE_NODE_FIELD(order_family);
  WRITE_NODE_FIELD(class_args);
  WRITE_NODE_FIELD(storedtype);
}

static void
_outCreateOpFamilyStmt(StringInfo str, const CreateOpFamilyStmt *node)
{
  WRITE_NODE_TYPE("CREATEOPFAMILYSTMT");

  WRITE_NODE_FIELD(opfamilyname);
  WRITE_STRING_FIELD(amname);
}

static void
_outAlterOpFamilyStmt(StringInfo str, const AlterOpFamilyStmt *node)
{
  WRITE_NODE_TYPE("ALTEROPFAMILYSTMT");

  WRITE_NODE_FIELD(opfamilyname);
  WRITE_STRING_FIELD(amname);
  WRITE_BOOL_FIELD(isDrop);
  WRITE_NODE_FIELD(items);
}

static void
_outDropStmt(StringInfo str, const DropStmt *node)
{
  WRITE_NODE_TYPE("DROPSTMT");

  WRITE_NODE_FIELD(objects);
  WRITE_ENUM_FIELD(removeType, ObjectType);
  WRITE_ENUM_FIELD(behavior, DropBehavior);
  WRITE_BOOL_FIELD(missing_ok);
  WRITE_BOOL_FIELD(concurrent);
}

static void
_outTruncateStmt(StringInfo str, const TruncateStmt *node)
{
  WRITE_NODE_TYPE("TRUNCATESTMT");

  WRITE_NODE_FIELD(relations);
  WRITE_BOOL_FIELD(restart_seqs);
  WRITE_ENUM_FIELD(behavior, DropBehavior);
}

static void
_outCommentStmt(StringInfo str, const CommentStmt *node)
{
  WRITE_NODE_TYPE("COMMENTSTMT");

  WRITE_ENUM_FIELD(objtype, ObjectType);
  WRITE_NODE_FIELD(object);
  WRITE_STRING_FIELD(comment);
}

static void
_outSecLabelStmt(StringInfo str, const SecLabelStmt *node)
{
  WRITE_NODE_TYPE("SECLABELSTMT");

  WRITE_ENUM_FIELD(objtype, ObjectType);
  WRITE_NODE_FIELD(object);
  WRITE_STRING_FIELD(provider);
  WRITE_STRING_FIELD(label);
}

static void
_outDeclareCursorStmt(StringInfo str, const DeclareCursorStmt *node)
{
  WRITE_NODE_TYPE("DECLARECURSORSTMT");

  WRITE_STRING_FIELD(portalname);
  WRITE_INT_FIELD(options);
  WRITE_NODE_FIELD(query);
}

static void
_outClosePortalStmt(StringInfo str, const ClosePortalStmt *node)
{
  WRITE_NODE_TYPE("CLOSEPORTALSTMT");

  WRITE_STRING_FIELD(portalname);
}

static void
_outFetchStmt(StringInfo str, const FetchStmt *node)
{
  WRITE_NODE_TYPE("FETCHSTMT");

  WRITE_ENUM_FIELD(direction, FetchDirection);
  WRITE_LONG_FIELD(howMany);
  WRITE_STRING_FIELD(portalname);
  WRITE_BOOL_FIELD(ismove);
  WRITE_ENUM_FIELD(direction_keyword, FetchDirectionKeywords);
  WRITE_LOCATION_FIELD(location);
}

static void
_outIndexStmt(StringInfo str, const IndexStmt *node)
{
  WRITE_NODE_TYPE("INDEXSTMT");

  WRITE_STRING_FIELD(idxname);
  WRITE_NODE_FIELD(relation);
  WRITE_STRING_FIELD(accessMethod);
  WRITE_STRING_FIELD(tableSpace);
  WRITE_NODE_FIELD(indexParams);
  WRITE_NODE_FIELD(indexIncludingParams);
  WRITE_NODE_FIELD(options);
  WRITE_NODE_FIELD(whereClause);
  WRITE_NODE_FIELD(excludeOpNames);
  WRITE_STRING_FIELD(idxcomment);
  WRITE_OID_FIELD(indexOid);
  WRITE_OID_FIELD(oldNumber);
  WRITE_UINT_FIELD(oldCreateSubid);
  WRITE_UINT_FIELD(oldFirstRelfilelocatorSubid);
  WRITE_BOOL_FIELD(unique);
  WRITE_BOOL_FIELD(nulls_not_distinct);
  WRITE_BOOL_FIELD(primary);
  WRITE_BOOL_FIELD(isconstraint);
  WRITE_BOOL_FIELD(iswithoutoverlaps);
  WRITE_BOOL_FIELD(deferrable);
  WRITE_BOOL_FIELD(initdeferred);
  WRITE_BOOL_FIELD(transformed);
  WRITE_BOOL_FIELD(concurrent);
  WRITE_BOOL_FIELD(if_not_exists);
  WRITE_BOOL_FIELD(reset_default_tblspc);
}

static void
_outCreateStatsStmt(StringInfo str, const CreateStatsStmt *node)
{
  WRITE_NODE_TYPE("CREATESTATSSTMT");

  WRITE_NODE_FIELD(defnames);
  WRITE_NODE_FIELD(stat_types);
  WRITE_NODE_FIELD(exprs);
  WRITE_NODE_FIELD(relations);
  WRITE_STRING_FIELD(stxcomment);
  WRITE_BOOL_FIELD(transformed);
  WRITE_BOOL_FIELD(if_not_exists);
}

static void
_outStatsElem(StringInfo str, const StatsElem *node)
{
  WRITE_NODE_TYPE("STATSELEM");

  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(expr);
}

static void
_outAlterStatsStmt(StringInfo str, const AlterStatsStmt *node)
{
  WRITE_NODE_TYPE("ALTERSTATSSTMT");

  WRITE_NODE_FIELD(defnames);
  WRITE_NODE_FIELD(stxstattarget);
  WRITE_BOOL_FIELD(missing_ok);
}

static void
_outCreateFunctionStmt(StringInfo str, const CreateFunctionStmt *node)
{
  WRITE_NODE_TYPE("CREATEFUNCTIONSTMT");

  WRITE_BOOL_FIELD(is_procedure);
  WRITE_BOOL_FIELD(replace);
  WRITE_NODE_FIELD(funcname);
  WRITE_NODE_FIELD(parameters);
  WRITE_NODE_FIELD(returnType);
  WRITE_NODE_FIELD(options);
  WRITE_NODE_FIELD(sql_body);
}

static void
_outFunctionParameter(StringInfo str, const FunctionParameter *node)
{
  WRITE_NODE_TYPE("FUNCTIONPARAMETER");

  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(argType);
  WRITE_ENUM_FIELD(mode, FunctionParameterMode);
  WRITE_NODE_FIELD(defexpr);
  WRITE_LOCATION_FIELD(location);
}

static void
_outAlterFunctionStmt(StringInfo str, const AlterFunctionStmt *node)
{
  WRITE_NODE_TYPE("ALTERFUNCTIONSTMT");

  WRITE_ENUM_FIELD(objtype, ObjectType);
  WRITE_NODE_FIELD(func);
  WRITE_NODE_FIELD(actions);
}

static void
_outDoStmt(StringInfo str, const DoStmt *node)
{
  WRITE_NODE_TYPE("DOSTMT");

  WRITE_NODE_FIELD(args);
}

static void
_outCallStmt(StringInfo str, const CallStmt *node)
{
  WRITE_NODE_TYPE("CALLSTMT");

  WRITE_NODE_FIELD(funccall);
  WRITE_NODE_FIELD(funcexpr);
  WRITE_NODE_FIELD(outargs);
}

static void
_outRenameStmt(StringInfo str, const RenameStmt *node)
{
  WRITE_NODE_TYPE("RENAMESTMT");

  WRITE_ENUM_FIELD(renameType, ObjectType);
  WRITE_ENUM_FIELD(relationType, ObjectType);
  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(object);
  WRITE_STRING_FIELD(subname);
  WRITE_STRING_FIELD(newname);
  WRITE_ENUM_FIELD(behavior, DropBehavior);
  WRITE_BOOL_FIELD(missing_ok);
}

static void
_outAlterObjectDependsStmt(StringInfo str, const AlterObjectDependsStmt *node)
{
  WRITE_NODE_TYPE("ALTEROBJECTDEPENDSSTMT");

  WRITE_ENUM_FIELD(objectType, ObjectType);
  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(object);
  WRITE_NODE_FIELD(extname);
  WRITE_BOOL_FIELD(remove);
}

static void
_outAlterObjectSchemaStmt(StringInfo str, const AlterObjectSchemaStmt *node)
{
  WRITE_NODE_TYPE("ALTEROBJECTSCHEMASTMT");

  WRITE_ENUM_FIELD(objectType, ObjectType);
  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(object);
  WRITE_STRING_FIELD(newschema);
  WRITE_BOOL_FIELD(missing_ok);
}

static void
_outAlterOwnerStmt(StringInfo str, const AlterOwnerStmt *node)
{
  WRITE_NODE_TYPE("ALTEROWNERSTMT");

  WRITE_ENUM_FIELD(objectType, ObjectType);
  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(object);
  WRITE_NODE_FIELD(newowner);
}

static void
_outAlterOperatorStmt(StringInfo str, const AlterOperatorStmt *node)
{
  WRITE_NODE_TYPE("ALTEROPERATORSTMT");

  WRITE_NODE_FIELD(opername);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterTypeStmt(StringInfo str, const AlterTypeStmt *node)
{
  WRITE_NODE_TYPE("ALTERTYPESTMT");

  WRITE_NODE_FIELD(typeName);
  WRITE_NODE_FIELD(options);
}

static void
_outRuleStmt(StringInfo str, const RuleStmt *node)
{
  WRITE_NODE_TYPE("RULESTMT");

  WRITE_NODE_FIELD(relation);
  WRITE_STRING_FIELD(rulename);
  WRITE_NODE_FIELD(whereClause);
  WRITE_ENUM_FIELD(event, CmdType);
  WRITE_BOOL_FIELD(instead);
  WRITE_NODE_FIELD(actions);
  WRITE_BOOL_FIELD(replace);
}

static void
_outNotifyStmt(StringInfo str, const NotifyStmt *node)
{
  WRITE_NODE_TYPE("NOTIFYSTMT");

  WRITE_STRING_FIELD(conditionname);
  WRITE_STRING_FIELD(payload);
}

static void
_outListenStmt(StringInfo str, const ListenStmt *node)
{
  WRITE_NODE_TYPE("LISTENSTMT");

  WRITE_STRING_FIELD(conditionname);
}

static void
_outUnlistenStmt(StringInfo str, const UnlistenStmt *node)
{
  WRITE_NODE_TYPE("UNLISTENSTMT");

  WRITE_STRING_FIELD(conditionname);
}

static void
_outTransactionStmt(StringInfo str, const TransactionStmt *node)
{
  WRITE_NODE_TYPE("TRANSACTIONSTMT");

  WRITE_ENUM_FIELD(kind, TransactionStmtKind);
  WRITE_NODE_FIELD(options);
  WRITE_STRING_FIELD(savepoint_name);
  WRITE_STRING_FIELD(gid);
  WRITE_BOOL_FIELD(chain);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCompositeTypeStmt(StringInfo str, const CompositeTypeStmt *node)
{
  WRITE_NODE_TYPE("COMPOSITETYPESTMT");

  WRITE_NODE_FIELD(typevar);
  WRITE_NODE_FIELD(coldeflist);
}

static void
_outCreateEnumStmt(StringInfo str, const CreateEnumStmt *node)
{
  WRITE_NODE_TYPE("CREATEENUMSTMT");

  WRITE_NODE_FIELD(typeName);
  WRITE_NODE_FIELD(vals);
}

static void
_outCreateRangeStmt(StringInfo str, const CreateRangeStmt *node)
{
  WRITE_NODE_TYPE("CREATERANGESTMT");

  WRITE_NODE_FIELD(typeName);
  WRITE_NODE_FIELD(params);
}

static void
_outAlterEnumStmt(StringInfo str, const AlterEnumStmt *node)
{
  WRITE_NODE_TYPE("ALTERENUMSTMT");

  WRITE_NODE_FIELD(typeName);
  WRITE_STRING_FIELD(oldVal);
  WRITE_STRING_FIELD(newVal);
  WRITE_STRING_FIELD(newValNeighbor);
  WRITE_BOOL_FIELD(newValIsAfter);
  WRITE_BOOL_FIELD(skipIfNewValExists);
}

static void
_outViewStmt(StringInfo str, const ViewStmt *node)
{
  WRITE_NODE_TYPE("VIEWSTMT");

  WRITE_NODE_FIELD(view);
  WRITE_NODE_FIELD(aliases);
  WRITE_NODE_FIELD(query);
  WRITE_BOOL_FIELD(replace);
  WRITE_NODE_FIELD(options);
  WRITE_ENUM_FIELD(withCheckOption, ViewCheckOption);
}

static void
_outLoadStmt(StringInfo str, const LoadStmt *node)
{
  WRITE_NODE_TYPE("LOADSTMT");

  WRITE_STRING_FIELD(filename);
}

static void
_outCreatedbStmt(StringInfo str, const CreatedbStmt *node)
{
  WRITE_NODE_TYPE("CREATEDBSTMT");

  WRITE_STRING_FIELD(dbname);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterDatabaseStmt(StringInfo str, const AlterDatabaseStmt *node)
{
  WRITE_NODE_TYPE("ALTERDATABASESTMT");

  WRITE_STRING_FIELD(dbname);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterDatabaseRefreshCollStmt(StringInfo str, const AlterDatabaseRefreshCollStmt *node)
{
  WRITE_NODE_TYPE("ALTERDATABASEREFRESHCOLLSTMT");

  WRITE_STRING_FIELD(dbname);
}

static void
_outAlterDatabaseSetStmt(StringInfo str, const AlterDatabaseSetStmt *node)
{
  WRITE_NODE_TYPE("ALTERDATABASESETSTMT");

  WRITE_STRING_FIELD(dbname);
  WRITE_NODE_FIELD(setstmt);
}

static void
_outDropdbStmt(StringInfo str, const DropdbStmt *node)
{
  WRITE_NODE_TYPE("DROPDBSTMT");

  WRITE_STRING_FIELD(dbname);
  WRITE_BOOL_FIELD(missing_ok);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterSystemStmt(StringInfo str, const AlterSystemStmt *node)
{
  WRITE_NODE_TYPE("ALTERSYSTEMSTMT");

  WRITE_NODE_FIELD(setstmt);
}

static void
_outClusterStmt(StringInfo str, const ClusterStmt *node)
{
  WRITE_NODE_TYPE("CLUSTERSTMT");

  WRITE_NODE_FIELD(relation);
  WRITE_STRING_FIELD(indexname);
  WRITE_NODE_FIELD(params);
}

static void
_outVacuumStmt(StringInfo str, const VacuumStmt *node)
{
  WRITE_NODE_TYPE("VACUUMSTMT");

  WRITE_NODE_FIELD(options);
  WRITE_NODE_FIELD(rels);
  WRITE_BOOL_FIELD(is_vacuumcmd);
}

static void
_outVacuumRelation(StringInfo str, const VacuumRelation *node)
{
  WRITE_NODE_TYPE("VACUUMRELATION");

  WRITE_NODE_FIELD(relation);
  WRITE_OID_FIELD(oid);
  WRITE_NODE_FIELD(va_cols);
}

static void
_outExplainStmt(StringInfo str, const ExplainStmt *node)
{
  WRITE_NODE_TYPE("EXPLAINSTMT");

  WRITE_NODE_FIELD(query);
  WRITE_NODE_FIELD(options);
}

static void
_outCreateTableAsStmt(StringInfo str, const CreateTableAsStmt *node)
{
  WRITE_NODE_TYPE("CREATETABLEASSTMT");

  WRITE_NODE_FIELD(query);
  WRITE_NODE_FIELD(into);
  WRITE_ENUM_FIELD(objtype, ObjectType);
  WRITE_BOOL_FIELD(is_select_into);
  WRITE_BOOL_FIELD(if_not_exists);
}

static void
_outRefreshMatViewStmt(StringInfo str, const RefreshMatViewStmt *node)
{
  WRITE_NODE_TYPE("REFRESHMATVIEWSTMT");

  WRITE_BOOL_FIELD(concurrent);
  WRITE_BOOL_FIELD(skipData);
  WRITE_NODE_FIELD(relation);
}

static void
_outCheckPointStmt(StringInfo str, const CheckPointStmt *node)
{
  WRITE_NODE_TYPE("CHECKPOINTSTMT");

  WRITE_NODE_FIELD(options);
}

static void
_outDiscardStmt(StringInfo str, const DiscardStmt *node)
{
  WRITE_NODE_TYPE("DISCARDSTMT");

  WRITE_ENUM_FIELD(target, DiscardMode);
}

static void
_outLockStmt(StringInfo str, const LockStmt *node)
{
  WRITE_NODE_TYPE("LOCKSTMT");

  WRITE_NODE_FIELD(relations);
  WRITE_INT_FIELD(mode);
  WRITE_BOOL_FIELD(nowait);
}

static void
_outConstraintsSetStmt(StringInfo str, const ConstraintsSetStmt *node)
{
  WRITE_NODE_TYPE("CONSTRAINTSSETSTMT");

  WRITE_NODE_FIELD(constraints);
  WRITE_BOOL_FIELD(deferred);
}

static void
_outReindexStmt(StringInfo str, const ReindexStmt *node)
{
  WRITE_NODE_TYPE("REINDEXSTMT");

  WRITE_ENUM_FIELD(kind, ReindexObjectType);
  WRITE_NODE_FIELD(relation);
  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(params);
}

static void
_outCreateConversionStmt(StringInfo str, const CreateConversionStmt *node)
{
  WRITE_NODE_TYPE("CREATECONVERSIONSTMT");

  WRITE_NODE_FIELD(conversion_name);
  WRITE_STRING_FIELD(for_encoding_name);
  WRITE_STRING_FIELD(to_encoding_name);
  WRITE_NODE_FIELD(func_name);
  WRITE_BOOL_FIELD(def);
}

static void
_outCreateCastStmt(StringInfo str, const CreateCastStmt *node)
{
  WRITE_NODE_TYPE("CREATECASTSTMT");

  WRITE_NODE_FIELD(sourcetype);
  WRITE_NODE_FIELD(targettype);
  WRITE_NODE_FIELD(func);
  WRITE_ENUM_FIELD(context, CoercionContext);
  WRITE_BOOL_FIELD(inout);
}

static void
_outCreateTransformStmt(StringInfo str, const CreateTransformStmt *node)
{
  WRITE_NODE_TYPE("CREATETRANSFORMSTMT");

  WRITE_BOOL_FIELD(replace);
  WRITE_NODE_FIELD(type_name);
  WRITE_STRING_FIELD(lang);
  WRITE_NODE_FIELD(fromsql);
  WRITE_NODE_FIELD(tosql);
}

static void
_outPrepareStmt(StringInfo str, const PrepareStmt *node)
{
  WRITE_NODE_TYPE("PREPARESTMT");

  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(argtypes);
  WRITE_NODE_FIELD(query);
}

static void
_outExecuteStmt(StringInfo str, const ExecuteStmt *node)
{
  WRITE_NODE_TYPE("EXECUTESTMT");

  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(params);
}

static void
_outDeallocateStmt(StringInfo str, const DeallocateStmt *node)
{
  WRITE_NODE_TYPE("DEALLOCATESTMT");

  WRITE_STRING_FIELD(name);
  WRITE_BOOL_FIELD(isall);
  WRITE_LOCATION_FIELD(location);
}

static void
_outDropOwnedStmt(StringInfo str, const DropOwnedStmt *node)
{
  WRITE_NODE_TYPE("DROPOWNEDSTMT");

  WRITE_NODE_FIELD(roles);
  WRITE_ENUM_FIELD(behavior, DropBehavior);
}

static void
_outReassignOwnedStmt(StringInfo str, const ReassignOwnedStmt *node)
{
  WRITE_NODE_TYPE("REASSIGNOWNEDSTMT");

  WRITE_NODE_FIELD(roles);
  WRITE_NODE_FIELD(newrole);
}

static void
_outAlterTSDictionaryStmt(StringInfo str, const AlterTSDictionaryStmt *node)
{
  WRITE_NODE_TYPE("ALTERTSDICTIONARYSTMT");

  WRITE_NODE_FIELD(dictname);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterTSConfigurationStmt(StringInfo str, const AlterTSConfigurationStmt *node)
{
  WRITE_NODE_TYPE("ALTERTSCONFIGURATIONSTMT");

  WRITE_ENUM_FIELD(kind, AlterTSConfigType);
  WRITE_NODE_FIELD(cfgname);
  WRITE_NODE_FIELD(tokentype);
  WRITE_NODE_FIELD(dicts);
  WRITE_BOOL_FIELD(override);
  WRITE_BOOL_FIELD(replace);
  WRITE_BOOL_FIELD(missing_ok);
}

static void
_outPublicationTable(StringInfo str, const PublicationTable *node)
{
  WRITE_NODE_TYPE("PUBLICATIONTABLE");

  WRITE_NODE_FIELD(relation);
  WRITE_NODE_FIELD(whereClause);
  WRITE_NODE_FIELD(columns);
}

static void
_outPublicationObjSpec(StringInfo str, const PublicationObjSpec *node)
{
  WRITE_NODE_TYPE("PUBLICATIONOBJSPEC");

  WRITE_ENUM_FIELD(pubobjtype, PublicationObjSpecType);
  WRITE_STRING_FIELD(name);
  WRITE_NODE_FIELD(pubtable);
  WRITE_LOCATION_FIELD(location);
}

static void
_outPublicationAllObjSpec(StringInfo str, const PublicationAllObjSpec *node)
{
  WRITE_NODE_TYPE("PUBLICATIONALLOBJSPEC");

  WRITE_ENUM_FIELD(pubobjtype, PublicationAllObjType);
  WRITE_LOCATION_FIELD(location);
}

static void
_outCreatePublicationStmt(StringInfo str, const CreatePublicationStmt *node)
{
  WRITE_NODE_TYPE("CREATEPUBLICATIONSTMT");

  WRITE_STRING_FIELD(pubname);
  WRITE_NODE_FIELD(options);
  WRITE_NODE_FIELD(pubobjects);
  WRITE_BOOL_FIELD(for_all_tables);
  WRITE_BOOL_FIELD(for_all_sequences);
}

static void
_outAlterPublicationStmt(StringInfo str, const AlterPublicationStmt *node)
{
  WRITE_NODE_TYPE("ALTERPUBLICATIONSTMT");

  WRITE_STRING_FIELD(pubname);
  WRITE_NODE_FIELD(options);
  WRITE_NODE_FIELD(pubobjects);
  WRITE_ENUM_FIELD(action, AlterPublicationAction);
}

static void
_outCreateSubscriptionStmt(StringInfo str, const CreateSubscriptionStmt *node)
{
  WRITE_NODE_TYPE("CREATESUBSCRIPTIONSTMT");

  WRITE_STRING_FIELD(subname);
  WRITE_STRING_FIELD(conninfo);
  WRITE_NODE_FIELD(publication);
  WRITE_NODE_FIELD(options);
}

static void
_outAlterSubscriptionStmt(StringInfo str, const AlterSubscriptionStmt *node)
{
  WRITE_NODE_TYPE("ALTERSUBSCRIPTIONSTMT");

  WRITE_ENUM_FIELD(kind, AlterSubscriptionType);
  WRITE_STRING_FIELD(subname);
  WRITE_STRING_FIELD(conninfo);
  WRITE_NODE_FIELD(publication);
  WRITE_NODE_FIELD(options);
}

static void
_outDropSubscriptionStmt(StringInfo str, const DropSubscriptionStmt *node)
{
  WRITE_NODE_TYPE("DROPSUBSCRIPTIONSTMT");

  WRITE_STRING_FIELD(subname);
  WRITE_BOOL_FIELD(missing_ok);
  WRITE_ENUM_FIELD(behavior, DropBehavior);
}

static void
_outPlannerGlobal(StringInfo str, const PlannerGlobal *node)
{
  WRITE_NODE_TYPE("PLANNERGLOBAL");

  WRITE_NODE_FIELD(subplans);
  WRITE_NODE_FIELD(subpaths);
  WRITE_BITMAPSET_FIELD(rewindPlanIDs);
  WRITE_NODE_FIELD(finalrtable);
  WRITE_BITMAPSET_FIELD(allRelids);
  WRITE_BITMAPSET_FIELD(prunableRelids);
  WRITE_NODE_FIELD(finalrteperminfos);
  WRITE_NODE_FIELD(finalrowmarks);
  WRITE_NODE_FIELD(resultRelations);
  WRITE_NODE_FIELD(appendRelations);
  WRITE_NODE_FIELD(partPruneInfos);
  WRITE_NODE_FIELD(relationOids);
  WRITE_NODE_FIELD(invalItems);
  WRITE_NODE_FIELD(paramExecTypes);
  WRITE_UINT_FIELD(lastPHId);
  WRITE_UINT_FIELD(lastRowMarkId);
  WRITE_INT_FIELD(lastPlanNodeId);
  WRITE_BOOL_FIELD(transientPlan);
  WRITE_BOOL_FIELD(dependsOnRole);
  WRITE_BOOL_FIELD(parallelModeOK);
  WRITE_BOOL_FIELD(parallelModeNeeded);
  WRITE_CHAR_FIELD(maxParallelHazard);
  WRITE_INT_FIELD(extension_state_allocated);
}

static void
_outPlannerInfo(StringInfo str, const PlannerInfo *node)
{
  WRITE_NODE_TYPE("PLANNERINFO");

  WRITE_NODE_FIELD(parse);
  WRITE_NODE_FIELD(glob);
  WRITE_UINT_FIELD(query_level);
  WRITE_STRING_FIELD(plan_name);
  WRITE_NODE_FIELD(plan_params);
  WRITE_BITMAPSET_FIELD(outer_params);
  WRITE_NODE_ARRAY(simple_rel_array, node->simple_rel_array_size);
  WRITE_INT_FIELD(simple_rel_array_size);
  WRITE_BITMAPSET_FIELD(all_baserels);
  WRITE_BITMAPSET_FIELD(outer_join_rels);
  WRITE_BITMAPSET_FIELD(all_query_rels);
  WRITE_NODE_FIELD(join_rel_list);
  WRITE_INT_FIELD(join_cur_level);
  WRITE_NODE_FIELD(init_plans);
  WRITE_NODE_FIELD(cte_plan_ids);
  WRITE_NODE_FIELD(multiexpr_params);
  WRITE_NODE_FIELD(join_domains);
  WRITE_NODE_FIELD(eq_classes);
  WRITE_BOOL_FIELD(ec_merging_done);
  WRITE_NODE_FIELD(canon_pathkeys);
  WRITE_NODE_FIELD(left_join_clauses);
  WRITE_NODE_FIELD(right_join_clauses);
  WRITE_NODE_FIELD(full_join_clauses);
  WRITE_NODE_FIELD(join_info_list);
  WRITE_INT_FIELD(last_rinfo_serial);
  WRITE_BITMAPSET_FIELD(all_result_relids);
  WRITE_BITMAPSET_FIELD(leaf_result_relids);
  WRITE_NODE_FIELD(append_rel_list);
  WRITE_NODE_FIELD(row_identity_vars);
  WRITE_NODE_FIELD(rowMarks);
  WRITE_NODE_FIELD(placeholder_list);
  WRITE_NODE_FIELD(agg_clause_list);
  WRITE_NODE_FIELD(group_expr_list);
  WRITE_NODE_FIELD(tlist_vars);
  WRITE_NODE_FIELD(fkey_list);
  WRITE_NODE_FIELD(query_pathkeys);
  WRITE_NODE_FIELD(group_pathkeys);
  WRITE_INT_FIELD(num_groupby_pathkeys);
  WRITE_NODE_FIELD(window_pathkeys);
  WRITE_NODE_FIELD(distinct_pathkeys);
  WRITE_NODE_FIELD(sort_pathkeys);
  WRITE_NODE_FIELD(setop_pathkeys);
  WRITE_NODE_FIELD(processed_groupClause);
  WRITE_NODE_FIELD(processed_distinctClause);
  WRITE_NODE_FIELD(processed_tlist);
  WRITE_NODE_FIELD(update_colnos);
  WRITE_NODE_FIELD(minmax_aggs);
  WRITE_FLOAT_FIELD(total_table_pages);
  WRITE_FLOAT_FIELD(tuple_fraction);
  WRITE_FLOAT_FIELD(limit_tuples);
  WRITE_UINT_FIELD(qual_security_level);
  WRITE_BOOL_FIELD(hasJoinRTEs);
  WRITE_BOOL_FIELD(hasLateralRTEs);
  WRITE_BOOL_FIELD(hasHavingQual);
  WRITE_BOOL_FIELD(hasPseudoConstantQuals);
  WRITE_BOOL_FIELD(hasAlternativeSubPlans);
  WRITE_BOOL_FIELD(placeholdersFrozen);
  WRITE_BOOL_FIELD(hasRecursion);
  WRITE_BOOL_FIELD(assumeReplanning);
  WRITE_INT_FIELD(group_rtindex);
  WRITE_NODE_FIELD(agginfos);
  WRITE_NODE_FIELD(aggtransinfos);
  WRITE_INT_FIELD(numOrderedAggs);
  WRITE_BOOL_FIELD(hasNonPartialAggs);
  WRITE_BOOL_FIELD(hasNonSerialAggs);
  WRITE_INT_FIELD(wt_param_id);
  WRITE_NODE_FIELD(non_recursive_path);
  WRITE_BITMAPSET_FIELD(curOuterRels);
  WRITE_NODE_FIELD(curOuterParams);
  WRITE_BOOL_FIELD(partColsUpdated);
  WRITE_NODE_FIELD(partPruneInfos);
  WRITE_INT_FIELD(extension_state_allocated);
}

static void
_outRelOptInfo(StringInfo str, const RelOptInfo *node)
{
  WRITE_NODE_TYPE("RELOPTINFO");

  WRITE_ENUM_FIELD(reloptkind, RelOptKind);
  WRITE_BITMAPSET_FIELD(relids);
  WRITE_FLOAT_FIELD(rows);
  WRITE_BOOL_FIELD(consider_startup);
  WRITE_BOOL_FIELD(consider_param_startup);
  WRITE_BOOL_FIELD(consider_parallel);
  WRITE_NODE_FIELD(reltarget);
  WRITE_NODE_FIELD(pathlist);
  WRITE_NODE_FIELD(ppilist);
  WRITE_NODE_FIELD(partial_pathlist);
  WRITE_NODE_FIELD(cheapest_startup_path);
  WRITE_NODE_FIELD(cheapest_total_path);
  WRITE_NODE_FIELD(cheapest_parameterized_paths);
  WRITE_BITMAPSET_FIELD(direct_lateral_relids);
  WRITE_BITMAPSET_FIELD(lateral_relids);
  WRITE_UINT_FIELD(relid);
  WRITE_OID_FIELD(reltablespace);
  WRITE_ENUM_FIELD(rtekind, RTEKind);
  WRITE_INT_FIELD(min_attr);
  WRITE_INT_FIELD(max_attr);
  WRITE_BITMAPSET_FIELD(notnullattnums);
  WRITE_BITMAPSET_FIELD(nulling_relids);
  WRITE_NODE_FIELD(lateral_vars);
  WRITE_BITMAPSET_FIELD(lateral_referencers);
  WRITE_NODE_FIELD(indexlist);
  WRITE_NODE_FIELD(statlist);
  WRITE_UINT_FIELD(pages);
  WRITE_FLOAT_FIELD(tuples);
  WRITE_FLOAT_FIELD(allvisfrac);
  WRITE_BITMAPSET_FIELD(eclass_indexes);
  WRITE_NODE_FIELD(subroot);
  WRITE_NODE_FIELD(subplan_params);
  WRITE_INT_FIELD(rel_parallel_workers);
  WRITE_UINT_FIELD(amflags);
  WRITE_OID_FIELD(serverid);
  WRITE_OID_FIELD(userid);
  WRITE_BOOL_FIELD(useridiscurrent);
  WRITE_NODE_FIELD(unique_for_rels);
  WRITE_NODE_FIELD(non_unique_for_rels);
  WRITE_NODE_FIELD(unique_rel);
  WRITE_NODE_FIELD(unique_pathkeys);
  WRITE_NODE_FIELD(unique_groupclause);
  WRITE_NODE_FIELD(baserestrictinfo);
  WRITE_FLOAT_FIELD(baserestrictcost.startup);
  WRITE_FLOAT_FIELD(baserestrictcost.per_tuple);
  WRITE_UINT_FIELD(baserestrict_min_security);
  WRITE_NODE_FIELD(joininfo);
  WRITE_BOOL_FIELD(has_eclass_joins);
  WRITE_BOOL_FIELD(consider_partitionwise_join);
  WRITE_NODE_FIELD(agg_info);
  WRITE_NODE_FIELD(grouped_rel);
  WRITE_BITMAPSET_FIELD(top_parent_relids);
  WRITE_INT_FIELD(nparts);
  WRITE_BOOL_FIELD(partbounds_merged);
  WRITE_NODE_FIELD(partition_qual);
  WRITE_BITMAPSET_FIELD(live_parts);
  WRITE_BITMAPSET_FIELD(all_partrels);
  WRITE_INT_FIELD(extension_state_allocated);
}

static void
_outRelAggInfo(StringInfo str, const RelAggInfo *node)
{
  WRITE_NODE_TYPE("RELAGGINFO");

  WRITE_NODE_FIELD(target);
  WRITE_NODE_FIELD(agg_input);
  WRITE_NODE_FIELD(group_clauses);
  WRITE_NODE_FIELD(group_exprs);
  WRITE_BITMAPSET_FIELD(apply_at);
  WRITE_FLOAT_FIELD(grouped_rows);
  WRITE_BOOL_FIELD(agg_useful);
}

static void
_outIndexOptInfo(StringInfo str, const IndexOptInfo *node)
{
  WRITE_NODE_TYPE("INDEXOPTINFO");

  WRITE_OID_FIELD(indexoid);
  WRITE_OID_FIELD(reltablespace);
  WRITE_UINT_FIELD(pages);
  WRITE_FLOAT_FIELD(tuples);
  WRITE_INT_FIELD(tree_height);
  WRITE_INT_FIELD(ncolumns);
  WRITE_INT_FIELD(nkeycolumns);
  WRITE_INT_ARRAY(indexkeys, node->ncolumns);
  WRITE_OID_ARRAY(indexcollations, node->nkeycolumns);
  WRITE_OID_ARRAY(opfamily, node->nkeycolumns);
  WRITE_OID_ARRAY(opcintype, node->nkeycolumns);
  WRITE_OID_ARRAY(sortopfamily, node->nkeycolumns);
  WRITE_BOOL_ARRAY(reverse_sort, node->nkeycolumns);
  WRITE_BOOL_ARRAY(nulls_first, node->nkeycolumns);
  WRITE_BOOL_ARRAY(canreturn, node->ncolumns);
  WRITE_OID_FIELD(relam);
  WRITE_NODE_FIELD(indpred);
  WRITE_NODE_FIELD(indextlist);
  WRITE_NODE_FIELD(indrestrictinfo);
  WRITE_BOOL_FIELD(predOK);
  WRITE_BOOL_FIELD(unique);
  WRITE_BOOL_FIELD(nullsnotdistinct);
  WRITE_BOOL_FIELD(immediate);
  WRITE_BOOL_FIELD(hypothetical);
  WRITE_BOOL_FIELD(amcanorderbyop);
  WRITE_BOOL_FIELD(amoptionalkey);
  WRITE_BOOL_FIELD(amsearcharray);
  WRITE_BOOL_FIELD(amsearchnulls);
  WRITE_BOOL_FIELD(amhasgettuple);
  WRITE_BOOL_FIELD(amhasgetbitmap);
  WRITE_BOOL_FIELD(amcanparallel);
  WRITE_BOOL_FIELD(amcanmarkpos);
}

static void
_outStatisticExtInfo(StringInfo str, const StatisticExtInfo *node)
{
  WRITE_NODE_TYPE("STATISTICEXTINFO");

  WRITE_OID_FIELD(statOid);
  WRITE_BOOL_FIELD(inherit);
  WRITE_CHAR_FIELD(kind);
  WRITE_BITMAPSET_FIELD(keys);
  WRITE_NODE_FIELD(exprs);
}

static void
_outJoinDomain(StringInfo str, const JoinDomain *node)
{
  WRITE_NODE_TYPE("JOINDOMAIN");

  WRITE_BITMAPSET_FIELD(jd_relids);
}

static void
_outEquivalenceMember(StringInfo str, const EquivalenceMember *node)
{
  WRITE_NODE_TYPE("EQUIVALENCEMEMBER");

  WRITE_NODE_FIELD(em_expr);
  WRITE_BITMAPSET_FIELD(em_relids);
  WRITE_BOOL_FIELD(em_is_const);
  WRITE_BOOL_FIELD(em_is_child);
  WRITE_OID_FIELD(em_datatype);
  WRITE_NODE_FIELD(em_jdomain);
}

static void
_outPathKey(StringInfo str, const PathKey *node)
{
  WRITE_NODE_TYPE("PATHKEY");

  WRITE_NODE_FIELD(pk_eclass);
  WRITE_OID_FIELD(pk_opfamily);
  WRITE_ENUM_FIELD(pk_cmptype, CompareType);
  WRITE_BOOL_FIELD(pk_nulls_first);
}

static void
_outGroupByOrdering(StringInfo str, const GroupByOrdering *node)
{
  WRITE_NODE_TYPE("GROUPBYORDERING");

  WRITE_NODE_FIELD(pathkeys);
  WRITE_NODE_FIELD(clauses);
}

static void
_outPathTarget(StringInfo str, const PathTarget *node)
{
  WRITE_NODE_TYPE("PATHTARGET");

  WRITE_NODE_FIELD(exprs);
  WRITE_INDEX_ARRAY(sortgrouprefs, list_length(node->exprs));
  WRITE_FLOAT_FIELD(cost.startup);
  WRITE_FLOAT_FIELD(cost.per_tuple);
  WRITE_INT_FIELD(width);
  WRITE_ENUM_FIELD(has_volatile_expr, VolatileFunctionStatus);
}

static void
_outParamPathInfo(StringInfo str, const ParamPathInfo *node)
{
  WRITE_NODE_TYPE("PARAMPATHINFO");

  WRITE_BITMAPSET_FIELD(ppi_req_outer);
  WRITE_FLOAT_FIELD(ppi_rows);
  WRITE_NODE_FIELD(ppi_clauses);
  WRITE_BITMAPSET_FIELD(ppi_serials);
}

static void
_outPath(StringInfo str, const Path *node)
{
  WRITE_NODE_TYPE("PATH");

  WRITE_ENUM_FIELD(pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->parent->relids);
  if (node->pathtarget != node->parent->reltarget)
    WRITE_NODE_FIELD(pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->param_info)
    outBitmapset(str, node->param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(parallel_aware);
  WRITE_BOOL_FIELD(parallel_safe);
  WRITE_INT_FIELD(parallel_workers);
  WRITE_FLOAT_FIELD(rows);
  WRITE_INT_FIELD(disabled_nodes);
  WRITE_FLOAT_FIELD(startup_cost);
  WRITE_FLOAT_FIELD(total_cost);
  WRITE_NODE_FIELD(pathkeys);
}

static void
_outIndexPath(StringInfo str, const IndexPath *node)
{
  WRITE_NODE_TYPE("INDEXPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(indexinfo);
  WRITE_NODE_FIELD(indexclauses);
  WRITE_NODE_FIELD(indexorderbys);
  WRITE_NODE_FIELD(indexorderbycols);
  WRITE_ENUM_FIELD(indexscandir, ScanDirection);
  WRITE_FLOAT_FIELD(indextotalcost);
  WRITE_FLOAT_FIELD(indexselectivity);
}

static void
_outIndexClause(StringInfo str, const IndexClause *node)
{
  WRITE_NODE_TYPE("INDEXCLAUSE");

  WRITE_NODE_FIELD(rinfo);
  WRITE_NODE_FIELD(indexquals);
  WRITE_BOOL_FIELD(lossy);
  WRITE_INT_FIELD(indexcol);
  WRITE_NODE_FIELD(indexcols);
}

static void
_outBitmapHeapPath(StringInfo str, const BitmapHeapPath *node)
{
  WRITE_NODE_TYPE("BITMAPHEAPPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(bitmapqual);
}

static void
_outBitmapAndPath(StringInfo str, const BitmapAndPath *node)
{
  WRITE_NODE_TYPE("BITMAPANDPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(bitmapquals);
  WRITE_FLOAT_FIELD(bitmapselectivity);
}

static void
_outBitmapOrPath(StringInfo str, const BitmapOrPath *node)
{
  WRITE_NODE_TYPE("BITMAPORPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(bitmapquals);
  WRITE_FLOAT_FIELD(bitmapselectivity);
}

static void
_outTidPath(StringInfo str, const TidPath *node)
{
  WRITE_NODE_TYPE("TIDPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(tidquals);
}

static void
_outTidRangePath(StringInfo str, const TidRangePath *node)
{
  WRITE_NODE_TYPE("TIDRANGEPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(tidrangequals);
}

static void
_outSubqueryScanPath(StringInfo str, const SubqueryScanPath *node)
{
  WRITE_NODE_TYPE("SUBQUERYSCANPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
}

static void
_outForeignPath(StringInfo str, const ForeignPath *node)
{
  WRITE_NODE_TYPE("FOREIGNPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(fdw_outerpath);
  WRITE_NODE_FIELD(fdw_restrictinfo);
  WRITE_NODE_FIELD(fdw_private);
}

static void
_outCustomPath(StringInfo str, const CustomPath *node)
{
  WRITE_NODE_TYPE("CUSTOMPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_UINT_FIELD(flags);
  WRITE_NODE_FIELD(custom_paths);
  WRITE_NODE_FIELD(custom_restrictinfo);
  WRITE_NODE_FIELD(custom_private);

  /* CustomName is a key to lookup CustomScanMethods */
  appendStringInfoString(str, " :methods ");
  outToken(str, node->methods->CustomName);
}

static void
_outAppendPath(StringInfo str, const AppendPath *node)
{
  WRITE_NODE_TYPE("APPENDPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpaths);
  WRITE_INT_FIELD(first_partial_path);
  WRITE_FLOAT_FIELD(limit_tuples);
}

static void
_outMergeAppendPath(StringInfo str, const MergeAppendPath *node)
{
  WRITE_NODE_TYPE("MERGEAPPENDPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpaths);
  WRITE_FLOAT_FIELD(limit_tuples);
}

static void
_outGroupResultPath(StringInfo str, const GroupResultPath *node)
{
  WRITE_NODE_TYPE("GROUPRESULTPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(quals);
}

static void
_outMaterialPath(StringInfo str, const MaterialPath *node)
{
  WRITE_NODE_TYPE("MATERIALPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
}

static void
_outMemoizePath(StringInfo str, const MemoizePath *node)
{
  WRITE_NODE_TYPE("MEMOIZEPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_NODE_FIELD(hash_operators);
  WRITE_NODE_FIELD(param_exprs);
  WRITE_BOOL_FIELD(singlerow);
  WRITE_BOOL_FIELD(binary_mode);
  WRITE_UINT_FIELD(est_entries);
  WRITE_FLOAT_FIELD(est_calls);
  WRITE_FLOAT_FIELD(est_unique_keys);
  WRITE_FLOAT_FIELD(est_hit_ratio);
}

static void
_outGatherPath(StringInfo str, const GatherPath *node)
{
  WRITE_NODE_TYPE("GATHERPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_BOOL_FIELD(single_copy);
  WRITE_INT_FIELD(num_workers);
}

static void
_outGatherMergePath(StringInfo str, const GatherMergePath *node)
{
  WRITE_NODE_TYPE("GATHERMERGEPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_INT_FIELD(num_workers);
}

static void
_outNestPath(StringInfo str, const NestPath *node)
{
  WRITE_NODE_TYPE("NESTPATH");

  WRITE_ENUM_FIELD(jpath.path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->jpath.path.parent->relids);
  if (node->jpath.path.pathtarget != node->jpath.path.parent->reltarget)
    WRITE_NODE_FIELD(jpath.path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->jpath.path.param_info)
    outBitmapset(str, node->jpath.path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(jpath.path.parallel_aware);
  WRITE_BOOL_FIELD(jpath.path.parallel_safe);
  WRITE_INT_FIELD(jpath.path.parallel_workers);
  WRITE_FLOAT_FIELD(jpath.path.rows);
  WRITE_INT_FIELD(jpath.path.disabled_nodes);
  WRITE_FLOAT_FIELD(jpath.path.startup_cost);
  WRITE_FLOAT_FIELD(jpath.path.total_cost);
  WRITE_NODE_FIELD(jpath.path.pathkeys);
  WRITE_ENUM_FIELD(jpath.jointype, JoinType);
  WRITE_BOOL_FIELD(jpath.inner_unique);
  WRITE_NODE_FIELD(jpath.outerjoinpath);
  WRITE_NODE_FIELD(jpath.innerjoinpath);
  WRITE_NODE_FIELD(jpath.joinrestrictinfo);
}

static void
_outMergePath(StringInfo str, const MergePath *node)
{
  WRITE_NODE_TYPE("MERGEPATH");

  WRITE_ENUM_FIELD(jpath.path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->jpath.path.parent->relids);
  if (node->jpath.path.pathtarget != node->jpath.path.parent->reltarget)
    WRITE_NODE_FIELD(jpath.path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->jpath.path.param_info)
    outBitmapset(str, node->jpath.path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(jpath.path.parallel_aware);
  WRITE_BOOL_FIELD(jpath.path.parallel_safe);
  WRITE_INT_FIELD(jpath.path.parallel_workers);
  WRITE_FLOAT_FIELD(jpath.path.rows);
  WRITE_INT_FIELD(jpath.path.disabled_nodes);
  WRITE_FLOAT_FIELD(jpath.path.startup_cost);
  WRITE_FLOAT_FIELD(jpath.path.total_cost);
  WRITE_NODE_FIELD(jpath.path.pathkeys);
  WRITE_ENUM_FIELD(jpath.jointype, JoinType);
  WRITE_BOOL_FIELD(jpath.inner_unique);
  WRITE_NODE_FIELD(jpath.outerjoinpath);
  WRITE_NODE_FIELD(jpath.innerjoinpath);
  WRITE_NODE_FIELD(jpath.joinrestrictinfo);
  WRITE_NODE_FIELD(path_mergeclauses);
  WRITE_NODE_FIELD(outersortkeys);
  WRITE_NODE_FIELD(innersortkeys);
  WRITE_INT_FIELD(outer_presorted_keys);
  WRITE_BOOL_FIELD(skip_mark_restore);
  WRITE_BOOL_FIELD(materialize_inner);
}

static void
_outHashPath(StringInfo str, const HashPath *node)
{
  WRITE_NODE_TYPE("HASHPATH");

  WRITE_ENUM_FIELD(jpath.path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->jpath.path.parent->relids);
  if (node->jpath.path.pathtarget != node->jpath.path.parent->reltarget)
    WRITE_NODE_FIELD(jpath.path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->jpath.path.param_info)
    outBitmapset(str, node->jpath.path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(jpath.path.parallel_aware);
  WRITE_BOOL_FIELD(jpath.path.parallel_safe);
  WRITE_INT_FIELD(jpath.path.parallel_workers);
  WRITE_FLOAT_FIELD(jpath.path.rows);
  WRITE_INT_FIELD(jpath.path.disabled_nodes);
  WRITE_FLOAT_FIELD(jpath.path.startup_cost);
  WRITE_FLOAT_FIELD(jpath.path.total_cost);
  WRITE_NODE_FIELD(jpath.path.pathkeys);
  WRITE_ENUM_FIELD(jpath.jointype, JoinType);
  WRITE_BOOL_FIELD(jpath.inner_unique);
  WRITE_NODE_FIELD(jpath.outerjoinpath);
  WRITE_NODE_FIELD(jpath.innerjoinpath);
  WRITE_NODE_FIELD(jpath.joinrestrictinfo);
  WRITE_NODE_FIELD(path_hashclauses);
  WRITE_INT_FIELD(num_batches);
  WRITE_FLOAT_FIELD(inner_rows_total);
}

static void
_outProjectionPath(StringInfo str, const ProjectionPath *node)
{
  WRITE_NODE_TYPE("PROJECTIONPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_BOOL_FIELD(dummypp);
}

static void
_outProjectSetPath(StringInfo str, const ProjectSetPath *node)
{
  WRITE_NODE_TYPE("PROJECTSETPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
}

static void
_outSortPath(StringInfo str, const SortPath *node)
{
  WRITE_NODE_TYPE("SORTPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
}

static void
_outIncrementalSortPath(StringInfo str, const IncrementalSortPath *node)
{
  WRITE_NODE_TYPE("INCREMENTALSORTPATH");

  WRITE_ENUM_FIELD(spath.path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->spath.path.parent->relids);
  if (node->spath.path.pathtarget != node->spath.path.parent->reltarget)
    WRITE_NODE_FIELD(spath.path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->spath.path.param_info)
    outBitmapset(str, node->spath.path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(spath.path.parallel_aware);
  WRITE_BOOL_FIELD(spath.path.parallel_safe);
  WRITE_INT_FIELD(spath.path.parallel_workers);
  WRITE_FLOAT_FIELD(spath.path.rows);
  WRITE_INT_FIELD(spath.path.disabled_nodes);
  WRITE_FLOAT_FIELD(spath.path.startup_cost);
  WRITE_FLOAT_FIELD(spath.path.total_cost);
  WRITE_NODE_FIELD(spath.path.pathkeys);
  WRITE_NODE_FIELD(spath.subpath);
  WRITE_INT_FIELD(nPresortedCols);
}

static void
_outGroupPath(StringInfo str, const GroupPath *node)
{
  WRITE_NODE_TYPE("GROUPPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_NODE_FIELD(groupClause);
  WRITE_NODE_FIELD(qual);
}

static void
_outUniquePath(StringInfo str, const UniquePath *node)
{
  WRITE_NODE_TYPE("UNIQUEPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_INT_FIELD(numkeys);
}

static void
_outAggPath(StringInfo str, const AggPath *node)
{
  WRITE_NODE_TYPE("AGGPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
  WRITE_ENUM_FIELD(aggsplit, AggSplit);
  WRITE_FLOAT_FIELD(numGroups);
  WRITE_UINT64_FIELD(transitionSpace);
  WRITE_NODE_FIELD(groupClause);
  WRITE_NODE_FIELD(qual);
}

static void
_outGroupingSetData(StringInfo str, const GroupingSetData *node)
{
  WRITE_NODE_TYPE("GROUPINGSETDATA");

  WRITE_NODE_FIELD(set);
  WRITE_FLOAT_FIELD(numGroups);
}

static void
_outRollupData(StringInfo str, const RollupData *node)
{
  WRITE_NODE_TYPE("ROLLUPDATA");

  WRITE_NODE_FIELD(groupClause);
  WRITE_NODE_FIELD(gsets);
  WRITE_NODE_FIELD(gsets_data);
  WRITE_FLOAT_FIELD(numGroups);
  WRITE_BOOL_FIELD(hashable);
  WRITE_BOOL_FIELD(is_hashed);
}

static void
_outGroupingSetsPath(StringInfo str, const GroupingSetsPath *node)
{
  WRITE_NODE_TYPE("GROUPINGSETSPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
  WRITE_NODE_FIELD(rollups);
  WRITE_NODE_FIELD(qual);
  WRITE_UINT64_FIELD(transitionSpace);
}

static void
_outMinMaxAggPath(StringInfo str, const MinMaxAggPath *node)
{
  WRITE_NODE_TYPE("MINMAXAGGPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(mmaggregates);
  WRITE_NODE_FIELD(quals);
}

static void
_outWindowAggPath(StringInfo str, const WindowAggPath *node)
{
  WRITE_NODE_TYPE("WINDOWAGGPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_NODE_FIELD(winclause);
  WRITE_NODE_FIELD(qual);
  WRITE_NODE_FIELD(runCondition);
  WRITE_BOOL_FIELD(topwindow);
}

static void
_outSetOpPath(StringInfo str, const SetOpPath *node)
{
  WRITE_NODE_TYPE("SETOPPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(leftpath);
  WRITE_NODE_FIELD(rightpath);
  WRITE_ENUM_FIELD(cmd, SetOpCmd);
  WRITE_ENUM_FIELD(strategy, SetOpStrategy);
  WRITE_NODE_FIELD(groupList);
  WRITE_FLOAT_FIELD(numGroups);
}

static void
_outRecursiveUnionPath(StringInfo str, const RecursiveUnionPath *node)
{
  WRITE_NODE_TYPE("RECURSIVEUNIONPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(leftpath);
  WRITE_NODE_FIELD(rightpath);
  WRITE_NODE_FIELD(distinctList);
  WRITE_INT_FIELD(wtParam);
  WRITE_FLOAT_FIELD(numGroups);
}

static void
_outLockRowsPath(StringInfo str, const LockRowsPath *node)
{
  WRITE_NODE_TYPE("LOCKROWSPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_NODE_FIELD(rowMarks);
  WRITE_INT_FIELD(epqParam);
}

static void
_outModifyTablePath(StringInfo str, const ModifyTablePath *node)
{
  WRITE_NODE_TYPE("MODIFYTABLEPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_ENUM_FIELD(operation, CmdType);
  WRITE_BOOL_FIELD(canSetTag);
  WRITE_UINT_FIELD(nominalRelation);
  WRITE_UINT_FIELD(rootRelation);
  WRITE_BOOL_FIELD(partColsUpdated);
  WRITE_NODE_FIELD(resultRelations);
  WRITE_NODE_FIELD(updateColnosLists);
  WRITE_NODE_FIELD(withCheckOptionLists);
  WRITE_NODE_FIELD(returningLists);
  WRITE_NODE_FIELD(rowMarks);
  WRITE_NODE_FIELD(onconflict);
  WRITE_INT_FIELD(epqParam);
  WRITE_NODE_FIELD(mergeActionLists);
  WRITE_NODE_FIELD(mergeJoinConditions);
}

static void
_outLimitPath(StringInfo str, const LimitPath *node)
{
  WRITE_NODE_TYPE("LIMITPATH");

  WRITE_ENUM_FIELD(path.pathtype, NodeTag);
  appendStringInfoString(str, " :parent_relids ");
  outBitmapset(str, node->path.parent->relids);
  if (node->path.pathtarget != node->path.parent->reltarget)
    WRITE_NODE_FIELD(path.pathtarget);
  appendStringInfoString(str, " :required_outer ");
  if (node->path.param_info)
    outBitmapset(str, node->path.param_info->ppi_req_outer);
  else
    outBitmapset(str, NULL);
  WRITE_BOOL_FIELD(path.parallel_aware);
  WRITE_BOOL_FIELD(path.parallel_safe);
  WRITE_INT_FIELD(path.parallel_workers);
  WRITE_FLOAT_FIELD(path.rows);
  WRITE_INT_FIELD(path.disabled_nodes);
  WRITE_FLOAT_FIELD(path.startup_cost);
  WRITE_FLOAT_FIELD(path.total_cost);
  WRITE_NODE_FIELD(path.pathkeys);
  WRITE_NODE_FIELD(subpath);
  WRITE_NODE_FIELD(limitOffset);
  WRITE_NODE_FIELD(limitCount);
  WRITE_ENUM_FIELD(limitOption, LimitOption);
}

static void
_outRestrictInfo(StringInfo str, const RestrictInfo *node)
{
  WRITE_NODE_TYPE("RESTRICTINFO");

  WRITE_NODE_FIELD(clause);
  WRITE_BOOL_FIELD(is_pushed_down);
  WRITE_BOOL_FIELD(can_join);
  WRITE_BOOL_FIELD(pseudoconstant);
  WRITE_BOOL_FIELD(has_clone);
  WRITE_BOOL_FIELD(is_clone);
  WRITE_BOOL_FIELD(leakproof);
  WRITE_ENUM_FIELD(has_volatile, VolatileFunctionStatus);
  WRITE_UINT_FIELD(security_level);
  WRITE_INT_FIELD(num_base_rels);
  WRITE_BITMAPSET_FIELD(clause_relids);
  WRITE_BITMAPSET_FIELD(required_relids);
  WRITE_BITMAPSET_FIELD(incompatible_relids);
  WRITE_BITMAPSET_FIELD(outer_relids);
  WRITE_BITMAPSET_FIELD(left_relids);
  WRITE_BITMAPSET_FIELD(right_relids);
  WRITE_NODE_FIELD(orclause);
  WRITE_INT_FIELD(rinfo_serial);
  WRITE_FLOAT_FIELD(eval_cost.startup);
  WRITE_FLOAT_FIELD(eval_cost.per_tuple);
  WRITE_FLOAT_FIELD(norm_selec);
  WRITE_FLOAT_FIELD(outer_selec);
  WRITE_NODE_FIELD(mergeopfamilies);
  WRITE_NODE_FIELD(left_em);
  WRITE_NODE_FIELD(right_em);
  WRITE_BOOL_FIELD(outer_is_left);
  WRITE_OID_FIELD(hashjoinoperator);
  WRITE_FLOAT_FIELD(left_bucketsize);
  WRITE_FLOAT_FIELD(right_bucketsize);
  WRITE_FLOAT_FIELD(left_mcvfreq);
  WRITE_FLOAT_FIELD(right_mcvfreq);
  WRITE_OID_FIELD(left_hasheqoperator);
  WRITE_OID_FIELD(right_hasheqoperator);
}

static void
_outPlaceHolderVar(StringInfo str, const PlaceHolderVar *node)
{
  WRITE_NODE_TYPE("PLACEHOLDERVAR");

  WRITE_NODE_FIELD(phexpr);
  WRITE_BITMAPSET_FIELD(phrels);
  WRITE_BITMAPSET_FIELD(phnullingrels);
  WRITE_UINT_FIELD(phid);
  WRITE_UINT_FIELD(phlevelsup);
}

static void
_outSpecialJoinInfo(StringInfo str, const SpecialJoinInfo *node)
{
  WRITE_NODE_TYPE("SPECIALJOININFO");

  WRITE_BITMAPSET_FIELD(min_lefthand);
  WRITE_BITMAPSET_FIELD(min_righthand);
  WRITE_BITMAPSET_FIELD(syn_lefthand);
  WRITE_BITMAPSET_FIELD(syn_righthand);
  WRITE_ENUM_FIELD(jointype, JoinType);
  WRITE_UINT_FIELD(ojrelid);
  WRITE_BITMAPSET_FIELD(commute_above_l);
  WRITE_BITMAPSET_FIELD(commute_above_r);
  WRITE_BITMAPSET_FIELD(commute_below_l);
  WRITE_BITMAPSET_FIELD(commute_below_r);
  WRITE_BOOL_FIELD(lhs_strict);
  WRITE_BOOL_FIELD(semi_can_btree);
  WRITE_BOOL_FIELD(semi_can_hash);
  WRITE_NODE_FIELD(semi_operators);
  WRITE_NODE_FIELD(semi_rhs_exprs);
}

static void
_outOuterJoinClauseInfo(StringInfo str, const OuterJoinClauseInfo *node)
{
  WRITE_NODE_TYPE("OUTERJOINCLAUSEINFO");

  WRITE_NODE_FIELD(rinfo);
  WRITE_NODE_FIELD(sjinfo);
}

static void
_outAppendRelInfo(StringInfo str, const AppendRelInfo *node)
{
  WRITE_NODE_TYPE("APPENDRELINFO");

  WRITE_UINT_FIELD(parent_relid);
  WRITE_UINT_FIELD(child_relid);
  WRITE_OID_FIELD(parent_reltype);
  WRITE_OID_FIELD(child_reltype);
  WRITE_NODE_FIELD(translated_vars);
  WRITE_INT_FIELD(num_child_cols);
  WRITE_ATTRNUMBER_ARRAY(parent_colnos, node->num_child_cols);
  WRITE_OID_FIELD(parent_reloid);
}

static void
_outRowIdentityVarInfo(StringInfo str, const RowIdentityVarInfo *node)
{
  WRITE_NODE_TYPE("ROWIDENTITYVARINFO");

  WRITE_NODE_FIELD(rowidvar);
  WRITE_INT_FIELD(rowidwidth);
  WRITE_STRING_FIELD(rowidname);
  WRITE_BITMAPSET_FIELD(rowidrels);
}

static void
_outPlaceHolderInfo(StringInfo str, const PlaceHolderInfo *node)
{
  WRITE_NODE_TYPE("PLACEHOLDERINFO");

  WRITE_UINT_FIELD(phid);
  WRITE_NODE_FIELD(ph_var);
  WRITE_BITMAPSET_FIELD(ph_eval_at);
  WRITE_BITMAPSET_FIELD(ph_lateral);
  WRITE_BITMAPSET_FIELD(ph_needed);
  WRITE_INT_FIELD(ph_width);
}

static void
_outMinMaxAggInfo(StringInfo str, const MinMaxAggInfo *node)
{
  WRITE_NODE_TYPE("MINMAXAGGINFO");

  WRITE_OID_FIELD(aggfnoid);
  WRITE_OID_FIELD(aggsortop);
  WRITE_NODE_FIELD(target);
  WRITE_NODE_FIELD(path);
  WRITE_FLOAT_FIELD(pathcost);
  WRITE_NODE_FIELD(param);
}

static void
_outAggClauseInfo(StringInfo str, const AggClauseInfo *node)
{
  WRITE_NODE_TYPE("AGGCLAUSEINFO");

  WRITE_NODE_FIELD(aggref);
  WRITE_BITMAPSET_FIELD(agg_eval_at);
}

static void
_outGroupingExprInfo(StringInfo str, const GroupingExprInfo *node)
{
  WRITE_NODE_TYPE("GROUPINGEXPRINFO");

  WRITE_NODE_FIELD(expr);
  WRITE_UINT_FIELD(sortgroupref);
  WRITE_NODE_FIELD(ec);
}

static void
_outPlannerParamItem(StringInfo str, const PlannerParamItem *node)
{
  WRITE_NODE_TYPE("PLANNERPARAMITEM");

  WRITE_NODE_FIELD(item);
  WRITE_INT_FIELD(paramId);
}

static void
_outAggInfo(StringInfo str, const AggInfo *node)
{
  WRITE_NODE_TYPE("AGGINFO");

  WRITE_NODE_FIELD(aggrefs);
  WRITE_INT_FIELD(transno);
  WRITE_BOOL_FIELD(shareable);
  WRITE_OID_FIELD(finalfn_oid);
}

static void
_outAggTransInfo(StringInfo str, const AggTransInfo *node)
{
  WRITE_NODE_TYPE("AGGTRANSINFO");

  WRITE_NODE_FIELD(args);
  WRITE_NODE_FIELD(aggfilter);
  WRITE_OID_FIELD(transfn_oid);
  WRITE_OID_FIELD(serialfn_oid);
  WRITE_OID_FIELD(deserialfn_oid);
  WRITE_OID_FIELD(combinefn_oid);
  WRITE_OID_FIELD(aggtranstype);
  WRITE_INT_FIELD(aggtranstypmod);
  WRITE_INT_FIELD(transtypeLen);
  WRITE_BOOL_FIELD(transtypeByVal);
  WRITE_INT_FIELD(aggtransspace);
  WRITE_BOOL_FIELD(initValueIsNull);
}

static void
_outUniqueRelInfo(StringInfo str, const UniqueRelInfo *node)
{
  WRITE_NODE_TYPE("UNIQUERELINFO");

  WRITE_BITMAPSET_FIELD(outerrelids);
  WRITE_BOOL_FIELD(self_join);
  WRITE_NODE_FIELD(extra_clauses);
}

static void
_outPlannedStmt(StringInfo str, const PlannedStmt *node)
{
  WRITE_NODE_TYPE("PLANNEDSTMT");

  WRITE_ENUM_FIELD(commandType, CmdType);
  WRITE_INT64_FIELD(queryId);
  WRITE_INT64_FIELD(planId);
  WRITE_ENUM_FIELD(planOrigin, PlannedStmtOrigin);
  WRITE_BOOL_FIELD(hasReturning);
  WRITE_BOOL_FIELD(hasModifyingCTE);
  WRITE_BOOL_FIELD(canSetTag);
  WRITE_BOOL_FIELD(transientPlan);
  WRITE_BOOL_FIELD(dependsOnRole);
  WRITE_BOOL_FIELD(parallelModeNeeded);
  WRITE_INT_FIELD(jitFlags);
  WRITE_NODE_FIELD(planTree);
  WRITE_NODE_FIELD(partPruneInfos);
  WRITE_NODE_FIELD(rtable);
  WRITE_BITMAPSET_FIELD(unprunableRelids);
  WRITE_NODE_FIELD(permInfos);
  WRITE_NODE_FIELD(resultRelations);
  WRITE_NODE_FIELD(appendRelations);
  WRITE_NODE_FIELD(subplans);
  WRITE_BITMAPSET_FIELD(rewindPlanIDs);
  WRITE_NODE_FIELD(rowMarks);
  WRITE_NODE_FIELD(relationOids);
  WRITE_NODE_FIELD(invalItems);
  WRITE_NODE_FIELD(paramExecTypes);
  WRITE_NODE_FIELD(utilityStmt);
  WRITE_NODE_FIELD(extension_state);
  WRITE_LOCATION_FIELD(stmt_location);
  WRITE_LOCATION_FIELD(stmt_len);
}

static void
_outResult(StringInfo str, const Result *node)
{
  WRITE_NODE_TYPE("RESULT");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_ENUM_FIELD(result_type, ResultType);
  WRITE_NODE_FIELD(resconstantqual);
  WRITE_BITMAPSET_FIELD(relids);
}

static void
_outProjectSet(StringInfo str, const ProjectSet *node)
{
  WRITE_NODE_TYPE("PROJECTSET");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
}

static void
_outModifyTable(StringInfo str, const ModifyTable *node)
{
  WRITE_NODE_TYPE("MODIFYTABLE");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_ENUM_FIELD(operation, CmdType);
  WRITE_BOOL_FIELD(canSetTag);
  WRITE_UINT_FIELD(nominalRelation);
  WRITE_UINT_FIELD(rootRelation);
  WRITE_BOOL_FIELD(partColsUpdated);
  WRITE_NODE_FIELD(resultRelations);
  WRITE_NODE_FIELD(updateColnosLists);
  WRITE_NODE_FIELD(withCheckOptionLists);
  WRITE_STRING_FIELD(returningOldAlias);
  WRITE_STRING_FIELD(returningNewAlias);
  WRITE_NODE_FIELD(returningLists);
  WRITE_NODE_FIELD(fdwPrivLists);
  WRITE_BITMAPSET_FIELD(fdwDirectModifyPlans);
  WRITE_NODE_FIELD(rowMarks);
  WRITE_INT_FIELD(epqParam);
  WRITE_ENUM_FIELD(onConflictAction, OnConflictAction);
  WRITE_NODE_FIELD(arbiterIndexes);
  WRITE_NODE_FIELD(onConflictSet);
  WRITE_NODE_FIELD(onConflictCols);
  WRITE_NODE_FIELD(onConflictWhere);
  WRITE_UINT_FIELD(exclRelRTI);
  WRITE_NODE_FIELD(exclRelTlist);
  WRITE_NODE_FIELD(mergeActionLists);
  WRITE_NODE_FIELD(mergeJoinConditions);
}

static void
_outAppend(StringInfo str, const Append *node)
{
  WRITE_NODE_TYPE("APPEND");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_BITMAPSET_FIELD(apprelids);
  WRITE_NODE_FIELD(appendplans);
  WRITE_INT_FIELD(nasyncplans);
  WRITE_INT_FIELD(first_partial_plan);
  WRITE_INT_FIELD(part_prune_index);
}

static void
_outMergeAppend(StringInfo str, const MergeAppend *node)
{
  WRITE_NODE_TYPE("MERGEAPPEND");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_BITMAPSET_FIELD(apprelids);
  WRITE_NODE_FIELD(mergeplans);
  WRITE_INT_FIELD(numCols);
  WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
  WRITE_OID_ARRAY(sortOperators, node->numCols);
  WRITE_OID_ARRAY(collations, node->numCols);
  WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
  WRITE_INT_FIELD(part_prune_index);
}

static void
_outRecursiveUnion(StringInfo str, const RecursiveUnion *node)
{
  WRITE_NODE_TYPE("RECURSIVEUNION");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_INT_FIELD(wtParam);
  WRITE_INT_FIELD(numCols);
  WRITE_ATTRNUMBER_ARRAY(dupColIdx, node->numCols);
  WRITE_OID_ARRAY(dupOperators, node->numCols);
  WRITE_OID_ARRAY(dupCollations, node->numCols);
  WRITE_LONG_FIELD(numGroups);
}

static void
_outBitmapAnd(StringInfo str, const BitmapAnd *node)
{
  WRITE_NODE_TYPE("BITMAPAND");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_NODE_FIELD(bitmapplans);
}

static void
_outBitmapOr(StringInfo str, const BitmapOr *node)
{
  WRITE_NODE_TYPE("BITMAPOR");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_BOOL_FIELD(isshared);
  WRITE_NODE_FIELD(bitmapplans);
}

static void
_outSeqScan(StringInfo str, const SeqScan *node)
{
  WRITE_NODE_TYPE("SEQSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
}

static void
_outSampleScan(StringInfo str, const SampleScan *node)
{
  WRITE_NODE_TYPE("SAMPLESCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_NODE_FIELD(tablesample);
}

static void
_outIndexScan(StringInfo str, const IndexScan *node)
{
  WRITE_NODE_TYPE("INDEXSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_OID_FIELD(indexid);
  WRITE_NODE_FIELD(indexqual);
  WRITE_NODE_FIELD(indexqualorig);
  WRITE_NODE_FIELD(indexorderby);
  WRITE_NODE_FIELD(indexorderbyorig);
  WRITE_NODE_FIELD(indexorderbyops);
  WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
}

static void
_outIndexOnlyScan(StringInfo str, const IndexOnlyScan *node)
{
  WRITE_NODE_TYPE("INDEXONLYSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_OID_FIELD(indexid);
  WRITE_NODE_FIELD(indexqual);
  WRITE_NODE_FIELD(recheckqual);
  WRITE_NODE_FIELD(indexorderby);
  WRITE_NODE_FIELD(indextlist);
  WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
}

static void
_outBitmapIndexScan(StringInfo str, const BitmapIndexScan *node)
{
  WRITE_NODE_TYPE("BITMAPINDEXSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_OID_FIELD(indexid);
  WRITE_BOOL_FIELD(isshared);
  WRITE_NODE_FIELD(indexqual);
  WRITE_NODE_FIELD(indexqualorig);
}

static void
_outBitmapHeapScan(StringInfo str, const BitmapHeapScan *node)
{
  WRITE_NODE_TYPE("BITMAPHEAPSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_NODE_FIELD(bitmapqualorig);
}

static void
_outTidScan(StringInfo str, const TidScan *node)
{
  WRITE_NODE_TYPE("TIDSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_NODE_FIELD(tidquals);
}

static void
_outTidRangeScan(StringInfo str, const TidRangeScan *node)
{
  WRITE_NODE_TYPE("TIDRANGESCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_NODE_FIELD(tidrangequals);
}

static void
_outSubqueryScan(StringInfo str, const SubqueryScan *node)
{
  WRITE_NODE_TYPE("SUBQUERYSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_NODE_FIELD(subplan);
  WRITE_ENUM_FIELD(scanstatus, SubqueryScanStatus);
}

static void
_outFunctionScan(StringInfo str, const FunctionScan *node)
{
  WRITE_NODE_TYPE("FUNCTIONSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_NODE_FIELD(functions);
  WRITE_BOOL_FIELD(funcordinality);
}

static void
_outValuesScan(StringInfo str, const ValuesScan *node)
{
  WRITE_NODE_TYPE("VALUESSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_NODE_FIELD(values_lists);
}

static void
_outTableFuncScan(StringInfo str, const TableFuncScan *node)
{
  WRITE_NODE_TYPE("TABLEFUNCSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_NODE_FIELD(tablefunc);
}

static void
_outCteScan(StringInfo str, const CteScan *node)
{
  WRITE_NODE_TYPE("CTESCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_INT_FIELD(ctePlanId);
  WRITE_INT_FIELD(cteParam);
}

static void
_outNamedTuplestoreScan(StringInfo str, const NamedTuplestoreScan *node)
{
  WRITE_NODE_TYPE("NAMEDTUPLESTORESCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_STRING_FIELD(enrname);
}

static void
_outWorkTableScan(StringInfo str, const WorkTableScan *node)
{
  WRITE_NODE_TYPE("WORKTABLESCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_INT_FIELD(wtParam);
}

static void
_outForeignScan(StringInfo str, const ForeignScan *node)
{
  WRITE_NODE_TYPE("FOREIGNSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_ENUM_FIELD(operation, CmdType);
  WRITE_UINT_FIELD(resultRelation);
  WRITE_OID_FIELD(checkAsUser);
  WRITE_OID_FIELD(fs_server);
  WRITE_NODE_FIELD(fdw_exprs);
  WRITE_NODE_FIELD(fdw_private);
  WRITE_NODE_FIELD(fdw_scan_tlist);
  WRITE_NODE_FIELD(fdw_recheck_quals);
  WRITE_BITMAPSET_FIELD(fs_relids);
  WRITE_BITMAPSET_FIELD(fs_base_relids);
  WRITE_BOOL_FIELD(fsSystemCol);
}

static void
_outCustomScan(StringInfo str, const CustomScan *node)
{
  WRITE_NODE_TYPE("CUSTOMSCAN");

  WRITE_INT_FIELD(scan.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(scan.plan.startup_cost);
  WRITE_FLOAT_FIELD(scan.plan.total_cost);
  WRITE_FLOAT_FIELD(scan.plan.plan_rows);
  WRITE_INT_FIELD(scan.plan.plan_width);
  WRITE_BOOL_FIELD(scan.plan.parallel_aware);
  WRITE_BOOL_FIELD(scan.plan.parallel_safe);
  WRITE_BOOL_FIELD(scan.plan.async_capable);
  WRITE_INT_FIELD(scan.plan.plan_node_id);
  WRITE_NODE_FIELD(scan.plan.targetlist);
  WRITE_NODE_FIELD(scan.plan.qual);
  WRITE_NODE_FIELD(scan.plan.lefttree);
  WRITE_NODE_FIELD(scan.plan.righttree);
  WRITE_NODE_FIELD(scan.plan.initPlan);
  WRITE_BITMAPSET_FIELD(scan.plan.extParam);
  WRITE_BITMAPSET_FIELD(scan.plan.allParam);
  WRITE_UINT_FIELD(scan.scanrelid);
  WRITE_UINT_FIELD(flags);
  WRITE_NODE_FIELD(custom_plans);
  WRITE_NODE_FIELD(custom_exprs);
  WRITE_NODE_FIELD(custom_private);
  WRITE_NODE_FIELD(custom_scan_tlist);
  WRITE_BITMAPSET_FIELD(custom_relids);

  /* CustomName is a key to lookup CustomScanMethods */
  appendStringInfoString(str, " :methods ");
  outToken(str, node->methods->CustomName);
}

static void
_outNestLoop(StringInfo str, const NestLoop *node)
{
  WRITE_NODE_TYPE("NESTLOOP");

  WRITE_INT_FIELD(join.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(join.plan.startup_cost);
  WRITE_FLOAT_FIELD(join.plan.total_cost);
  WRITE_FLOAT_FIELD(join.plan.plan_rows);
  WRITE_INT_FIELD(join.plan.plan_width);
  WRITE_BOOL_FIELD(join.plan.parallel_aware);
  WRITE_BOOL_FIELD(join.plan.parallel_safe);
  WRITE_BOOL_FIELD(join.plan.async_capable);
  WRITE_INT_FIELD(join.plan.plan_node_id);
  WRITE_NODE_FIELD(join.plan.targetlist);
  WRITE_NODE_FIELD(join.plan.qual);
  WRITE_NODE_FIELD(join.plan.lefttree);
  WRITE_NODE_FIELD(join.plan.righttree);
  WRITE_NODE_FIELD(join.plan.initPlan);
  WRITE_BITMAPSET_FIELD(join.plan.extParam);
  WRITE_BITMAPSET_FIELD(join.plan.allParam);
  WRITE_ENUM_FIELD(join.jointype, JoinType);
  WRITE_BOOL_FIELD(join.inner_unique);
  WRITE_NODE_FIELD(join.joinqual);
  WRITE_NODE_FIELD(nestParams);
}

static void
_outNestLoopParam(StringInfo str, const NestLoopParam *node)
{
  WRITE_NODE_TYPE("NESTLOOPPARAM");

  WRITE_INT_FIELD(paramno);
  WRITE_NODE_FIELD(paramval);
}

static void
_outMergeJoin(StringInfo str, const MergeJoin *node)
{
  WRITE_NODE_TYPE("MERGEJOIN");

  WRITE_INT_FIELD(join.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(join.plan.startup_cost);
  WRITE_FLOAT_FIELD(join.plan.total_cost);
  WRITE_FLOAT_FIELD(join.plan.plan_rows);
  WRITE_INT_FIELD(join.plan.plan_width);
  WRITE_BOOL_FIELD(join.plan.parallel_aware);
  WRITE_BOOL_FIELD(join.plan.parallel_safe);
  WRITE_BOOL_FIELD(join.plan.async_capable);
  WRITE_INT_FIELD(join.plan.plan_node_id);
  WRITE_NODE_FIELD(join.plan.targetlist);
  WRITE_NODE_FIELD(join.plan.qual);
  WRITE_NODE_FIELD(join.plan.lefttree);
  WRITE_NODE_FIELD(join.plan.righttree);
  WRITE_NODE_FIELD(join.plan.initPlan);
  WRITE_BITMAPSET_FIELD(join.plan.extParam);
  WRITE_BITMAPSET_FIELD(join.plan.allParam);
  WRITE_ENUM_FIELD(join.jointype, JoinType);
  WRITE_BOOL_FIELD(join.inner_unique);
  WRITE_NODE_FIELD(join.joinqual);
  WRITE_BOOL_FIELD(skip_mark_restore);
  WRITE_NODE_FIELD(mergeclauses);
  WRITE_OID_ARRAY(mergeFamilies, list_length(node->mergeclauses));
  WRITE_OID_ARRAY(mergeCollations, list_length(node->mergeclauses));
  WRITE_BOOL_ARRAY(mergeReversals, list_length(node->mergeclauses));
  WRITE_BOOL_ARRAY(mergeNullsFirst, list_length(node->mergeclauses));
}

static void
_outHashJoin(StringInfo str, const HashJoin *node)
{
  WRITE_NODE_TYPE("HASHJOIN");

  WRITE_INT_FIELD(join.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(join.plan.startup_cost);
  WRITE_FLOAT_FIELD(join.plan.total_cost);
  WRITE_FLOAT_FIELD(join.plan.plan_rows);
  WRITE_INT_FIELD(join.plan.plan_width);
  WRITE_BOOL_FIELD(join.plan.parallel_aware);
  WRITE_BOOL_FIELD(join.plan.parallel_safe);
  WRITE_BOOL_FIELD(join.plan.async_capable);
  WRITE_INT_FIELD(join.plan.plan_node_id);
  WRITE_NODE_FIELD(join.plan.targetlist);
  WRITE_NODE_FIELD(join.plan.qual);
  WRITE_NODE_FIELD(join.plan.lefttree);
  WRITE_NODE_FIELD(join.plan.righttree);
  WRITE_NODE_FIELD(join.plan.initPlan);
  WRITE_BITMAPSET_FIELD(join.plan.extParam);
  WRITE_BITMAPSET_FIELD(join.plan.allParam);
  WRITE_ENUM_FIELD(join.jointype, JoinType);
  WRITE_BOOL_FIELD(join.inner_unique);
  WRITE_NODE_FIELD(join.joinqual);
  WRITE_NODE_FIELD(hashclauses);
  WRITE_NODE_FIELD(hashoperators);
  WRITE_NODE_FIELD(hashcollations);
  WRITE_NODE_FIELD(hashkeys);
}

static void
_outMaterial(StringInfo str, const Material *node)
{
  WRITE_NODE_TYPE("MATERIAL");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
}

static void
_outMemoize(StringInfo str, const Memoize *node)
{
  WRITE_NODE_TYPE("MEMOIZE");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_INT_FIELD(numKeys);
  WRITE_OID_ARRAY(hashOperators, node->numKeys);
  WRITE_OID_ARRAY(collations, node->numKeys);
  WRITE_NODE_FIELD(param_exprs);
  WRITE_BOOL_FIELD(singlerow);
  WRITE_BOOL_FIELD(binary_mode);
  WRITE_UINT_FIELD(est_entries);
  WRITE_BITMAPSET_FIELD(keyparamids);
  WRITE_FLOAT_FIELD(est_calls);
  WRITE_FLOAT_FIELD(est_unique_keys);
  WRITE_FLOAT_FIELD(est_hit_ratio);
}

static void
_outSort(StringInfo str, const Sort *node)
{
  WRITE_NODE_TYPE("SORT");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_INT_FIELD(numCols);
  WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
  WRITE_OID_ARRAY(sortOperators, node->numCols);
  WRITE_OID_ARRAY(collations, node->numCols);
  WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
}

static void
_outIncrementalSort(StringInfo str, const IncrementalSort *node)
{
  WRITE_NODE_TYPE("INCREMENTALSORT");

  WRITE_INT_FIELD(sort.plan.disabled_nodes);
  WRITE_FLOAT_FIELD(sort.plan.startup_cost);
  WRITE_FLOAT_FIELD(sort.plan.total_cost);
  WRITE_FLOAT_FIELD(sort.plan.plan_rows);
  WRITE_INT_FIELD(sort.plan.plan_width);
  WRITE_BOOL_FIELD(sort.plan.parallel_aware);
  WRITE_BOOL_FIELD(sort.plan.parallel_safe);
  WRITE_BOOL_FIELD(sort.plan.async_capable);
  WRITE_INT_FIELD(sort.plan.plan_node_id);
  WRITE_NODE_FIELD(sort.plan.targetlist);
  WRITE_NODE_FIELD(sort.plan.qual);
  WRITE_NODE_FIELD(sort.plan.lefttree);
  WRITE_NODE_FIELD(sort.plan.righttree);
  WRITE_NODE_FIELD(sort.plan.initPlan);
  WRITE_BITMAPSET_FIELD(sort.plan.extParam);
  WRITE_BITMAPSET_FIELD(sort.plan.allParam);
  WRITE_INT_FIELD(sort.numCols);
  WRITE_ATTRNUMBER_ARRAY(sort.sortColIdx, node->sort.numCols);
  WRITE_OID_ARRAY(sort.sortOperators, node->sort.numCols);
  WRITE_OID_ARRAY(sort.collations, node->sort.numCols);
  WRITE_BOOL_ARRAY(sort.nullsFirst, node->sort.numCols);
  WRITE_INT_FIELD(nPresortedCols);
}

static void
_outGroup(StringInfo str, const Group *node)
{
  WRITE_NODE_TYPE("GROUP");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_INT_FIELD(numCols);
  WRITE_ATTRNUMBER_ARRAY(grpColIdx, node->numCols);
  WRITE_OID_ARRAY(grpOperators, node->numCols);
  WRITE_OID_ARRAY(grpCollations, node->numCols);
}

static void
_outAgg(StringInfo str, const Agg *node)
{
  WRITE_NODE_TYPE("AGG");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
  WRITE_ENUM_FIELD(aggsplit, AggSplit);
  WRITE_INT_FIELD(numCols);
  WRITE_ATTRNUMBER_ARRAY(grpColIdx, node->numCols);
  WRITE_OID_ARRAY(grpOperators, node->numCols);
  WRITE_OID_ARRAY(grpCollations, node->numCols);
  WRITE_LONG_FIELD(numGroups);
  WRITE_UINT64_FIELD(transitionSpace);
  WRITE_BITMAPSET_FIELD(aggParams);
  WRITE_NODE_FIELD(groupingSets);
  WRITE_NODE_FIELD(chain);
}

static void
_outWindowAgg(StringInfo str, const WindowAgg *node)
{
  WRITE_NODE_TYPE("WINDOWAGG");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_STRING_FIELD(winname);
  WRITE_UINT_FIELD(winref);
  WRITE_INT_FIELD(partNumCols);
  WRITE_ATTRNUMBER_ARRAY(partColIdx, node->partNumCols);
  WRITE_OID_ARRAY(partOperators, node->partNumCols);
  WRITE_OID_ARRAY(partCollations, node->partNumCols);
  WRITE_INT_FIELD(ordNumCols);
  WRITE_ATTRNUMBER_ARRAY(ordColIdx, node->ordNumCols);
  WRITE_OID_ARRAY(ordOperators, node->ordNumCols);
  WRITE_OID_ARRAY(ordCollations, node->ordNumCols);
  WRITE_INT_FIELD(frameOptions);
  WRITE_NODE_FIELD(startOffset);
  WRITE_NODE_FIELD(endOffset);
  WRITE_NODE_FIELD(runCondition);
  WRITE_NODE_FIELD(runConditionOrig);
  WRITE_OID_FIELD(startInRangeFunc);
  WRITE_OID_FIELD(endInRangeFunc);
  WRITE_OID_FIELD(inRangeColl);
  WRITE_BOOL_FIELD(inRangeAsc);
  WRITE_BOOL_FIELD(inRangeNullsFirst);
  WRITE_BOOL_FIELD(topWindow);
}

static void
_outUnique(StringInfo str, const Unique *node)
{
  WRITE_NODE_TYPE("UNIQUE");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_INT_FIELD(numCols);
  WRITE_ATTRNUMBER_ARRAY(uniqColIdx, node->numCols);
  WRITE_OID_ARRAY(uniqOperators, node->numCols);
  WRITE_OID_ARRAY(uniqCollations, node->numCols);
}

static void
_outGather(StringInfo str, const Gather *node)
{
  WRITE_NODE_TYPE("GATHER");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_INT_FIELD(num_workers);
  WRITE_INT_FIELD(rescan_param);
  WRITE_BOOL_FIELD(single_copy);
  WRITE_BOOL_FIELD(invisible);
  WRITE_BITMAPSET_FIELD(initParam);
}

static void
_outGatherMerge(StringInfo str, const GatherMerge *node)
{
  WRITE_NODE_TYPE("GATHERMERGE");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_INT_FIELD(num_workers);
  WRITE_INT_FIELD(rescan_param);
  WRITE_INT_FIELD(numCols);
  WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
  WRITE_OID_ARRAY(sortOperators, node->numCols);
  WRITE_OID_ARRAY(collations, node->numCols);
  WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
  WRITE_BITMAPSET_FIELD(initParam);
}

static void
_outHash(StringInfo str, const Hash *node)
{
  WRITE_NODE_TYPE("HASH");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_NODE_FIELD(hashkeys);
  WRITE_OID_FIELD(skewTable);
  WRITE_INT_FIELD(skewColumn);
  WRITE_BOOL_FIELD(skewInherit);
  WRITE_FLOAT_FIELD(rows_total);
}

static void
_outSetOp(StringInfo str, const SetOp *node)
{
  WRITE_NODE_TYPE("SETOP");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_ENUM_FIELD(cmd, SetOpCmd);
  WRITE_ENUM_FIELD(strategy, SetOpStrategy);
  WRITE_INT_FIELD(numCols);
  WRITE_ATTRNUMBER_ARRAY(cmpColIdx, node->numCols);
  WRITE_OID_ARRAY(cmpOperators, node->numCols);
  WRITE_OID_ARRAY(cmpCollations, node->numCols);
  WRITE_BOOL_ARRAY(cmpNullsFirst, node->numCols);
  WRITE_LONG_FIELD(numGroups);
}

static void
_outLockRows(StringInfo str, const LockRows *node)
{
  WRITE_NODE_TYPE("LOCKROWS");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_NODE_FIELD(rowMarks);
  WRITE_INT_FIELD(epqParam);
}

static void
_outLimit(StringInfo str, const Limit *node)
{
  WRITE_NODE_TYPE("LIMIT");

  WRITE_INT_FIELD(plan.disabled_nodes);
  WRITE_FLOAT_FIELD(plan.startup_cost);
  WRITE_FLOAT_FIELD(plan.total_cost);
  WRITE_FLOAT_FIELD(plan.plan_rows);
  WRITE_INT_FIELD(plan.plan_width);
  WRITE_BOOL_FIELD(plan.parallel_aware);
  WRITE_BOOL_FIELD(plan.parallel_safe);
  WRITE_BOOL_FIELD(plan.async_capable);
  WRITE_INT_FIELD(plan.plan_node_id);
  WRITE_NODE_FIELD(plan.targetlist);
  WRITE_NODE_FIELD(plan.qual);
  WRITE_NODE_FIELD(plan.lefttree);
  WRITE_NODE_FIELD(plan.righttree);
  WRITE_NODE_FIELD(plan.initPlan);
  WRITE_BITMAPSET_FIELD(plan.extParam);
  WRITE_BITMAPSET_FIELD(plan.allParam);
  WRITE_NODE_FIELD(limitOffset);
  WRITE_NODE_FIELD(limitCount);
  WRITE_ENUM_FIELD(limitOption, LimitOption);
  WRITE_INT_FIELD(uniqNumCols);
  WRITE_ATTRNUMBER_ARRAY(uniqColIdx, node->uniqNumCols);
  WRITE_OID_ARRAY(uniqOperators, node->uniqNumCols);
  WRITE_OID_ARRAY(uniqCollations, node->uniqNumCols);
}

static void
_outPlanRowMark(StringInfo str, const PlanRowMark *node)
{
  WRITE_NODE_TYPE("PLANROWMARK");

  WRITE_UINT_FIELD(rti);
  WRITE_UINT_FIELD(prti);
  WRITE_UINT_FIELD(rowmarkId);
  WRITE_ENUM_FIELD(markType, RowMarkType);
  WRITE_INT_FIELD(allMarkTypes);
  WRITE_ENUM_FIELD(strength, LockClauseStrength);
  WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
  WRITE_BOOL_FIELD(isParent);
}

static void
_outPartitionPruneInfo(StringInfo str, const PartitionPruneInfo *node)
{
  WRITE_NODE_TYPE("PARTITIONPRUNEINFO");

  WRITE_BITMAPSET_FIELD(relids);
  WRITE_NODE_FIELD(prune_infos);
  WRITE_BITMAPSET_FIELD(other_subplans);
}

static void
_outPartitionedRelPruneInfo(StringInfo str, const PartitionedRelPruneInfo *node)
{
  WRITE_NODE_TYPE("PARTITIONEDRELPRUNEINFO");

  WRITE_UINT_FIELD(rtindex);
  WRITE_BITMAPSET_FIELD(present_parts);
  WRITE_INT_FIELD(nparts);
  WRITE_INT_ARRAY(subplan_map, node->nparts);
  WRITE_INT_ARRAY(subpart_map, node->nparts);
  WRITE_INT_ARRAY(leafpart_rti_map, node->nparts);
  WRITE_OID_ARRAY(relid_map, node->nparts);
  WRITE_NODE_FIELD(initial_pruning_steps);
  WRITE_NODE_FIELD(exec_pruning_steps);
  WRITE_BITMAPSET_FIELD(execparamids);
}

static void
_outPartitionPruneStepOp(StringInfo str, const PartitionPruneStepOp *node)
{
  WRITE_NODE_TYPE("PARTITIONPRUNESTEPOP");

  WRITE_INT_FIELD(step.step_id);
  WRITE_INT_FIELD(opstrategy);
  WRITE_NODE_FIELD(exprs);
  WRITE_NODE_FIELD(cmpfns);
  WRITE_BITMAPSET_FIELD(nullkeys);
}

static void
_outPartitionPruneStepCombine(StringInfo str, const PartitionPruneStepCombine *node)
{
  WRITE_NODE_TYPE("PARTITIONPRUNESTEPCOMBINE");

  WRITE_INT_FIELD(step.step_id);
  WRITE_ENUM_FIELD(combineOp, PartitionPruneCombineOp);
  WRITE_NODE_FIELD(source_stepids);
}

static void
_outPlanInvalItem(StringInfo str, const PlanInvalItem *node)
{
  WRITE_NODE_TYPE("PLANINVALITEM");

  WRITE_INT_FIELD(cacheId);
  WRITE_UINT_FIELD(hashValue);
}

static void
_outForeignKeyCacheInfo(StringInfo str, const ForeignKeyCacheInfo *node)
{
  WRITE_NODE_TYPE("FOREIGNKEYCACHEINFO");

  WRITE_OID_FIELD(conoid);
  WRITE_OID_FIELD(conrelid);
  WRITE_OID_FIELD(confrelid);
  WRITE_INT_FIELD(nkeys);
  WRITE_BOOL_FIELD(conenforced);
  WRITE_ATTRNUMBER_ARRAY(conkey, node->nkeys);
  WRITE_ATTRNUMBER_ARRAY(confkey, node->nkeys);
  WRITE_OID_ARRAY(conpfeqop, node->nkeys);
}

Coverage Report

Created: 2025-10-09 06:07