/*-------------------------------------------------------------------------
 *
 * queryjumblefuncs.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
_jumbleAlias(JumbleState *jstate, Node *node)
{
	Alias *expr = (Alias *) node;

	JUMBLE_STRING(aliasname);
	JUMBLE_NODE(colnames);
}

static void
_jumbleRangeVar(JumbleState *jstate, Node *node)
{
	RangeVar *expr = (RangeVar *) node;

	JUMBLE_STRING(catalogname);
	JUMBLE_STRING(schemaname);
	JUMBLE_STRING(relname);
	JUMBLE_FIELD(inh);
	JUMBLE_FIELD(relpersistence);
	JUMBLE_NODE(alias);
}

static void
_jumbleTableFunc(JumbleState *jstate, Node *node)
{
	TableFunc *expr = (TableFunc *) node;

	JUMBLE_FIELD(functype);
	JUMBLE_NODE(docexpr);
	JUMBLE_NODE(rowexpr);
	JUMBLE_NODE(colexprs);
}

static void
_jumbleIntoClause(JumbleState *jstate, Node *node)
{
	IntoClause *expr = (IntoClause *) node;

	JUMBLE_NODE(rel);
	JUMBLE_NODE(colNames);
	JUMBLE_STRING(accessMethod);
	JUMBLE_NODE(options);
	JUMBLE_FIELD(onCommit);
	JUMBLE_STRING(tableSpaceName);
	JUMBLE_FIELD(skipData);
}

static void
_jumbleVar(JumbleState *jstate, Node *node)
{
	Var *expr = (Var *) node;

	JUMBLE_FIELD(varno);
	JUMBLE_FIELD(varattno);
	JUMBLE_FIELD(varlevelsup);
	JUMBLE_FIELD(varreturningtype);
}

static void
_jumbleConst(JumbleState *jstate, Node *node)
{
	Const *expr = (Const *) node;

	JUMBLE_FIELD(consttype);
	JUMBLE_LOCATION(location);
}

static void
_jumbleAggref(JumbleState *jstate, Node *node)
{
	Aggref *expr = (Aggref *) node;

	JUMBLE_FIELD(aggfnoid);
	JUMBLE_NODE(aggdirectargs);
	JUMBLE_NODE(args);
	JUMBLE_NODE(aggorder);
	JUMBLE_NODE(aggdistinct);
	JUMBLE_NODE(aggfilter);
}

static void
_jumbleGroupingFunc(JumbleState *jstate, Node *node)
{
	GroupingFunc *expr = (GroupingFunc *) node;

	JUMBLE_NODE(refs);
	JUMBLE_FIELD(agglevelsup);
}

static void
_jumbleWindowFunc(JumbleState *jstate, Node *node)
{
	WindowFunc *expr = (WindowFunc *) node;

	JUMBLE_FIELD(winfnoid);
	JUMBLE_NODE(args);
	JUMBLE_NODE(aggfilter);
	JUMBLE_FIELD(winref);
}

static void
_jumbleWindowFuncRunCondition(JumbleState *jstate, Node *node)
{
	WindowFuncRunCondition *expr = (WindowFuncRunCondition *) node;

	JUMBLE_FIELD(opno);
	JUMBLE_FIELD(wfunc_left);
	JUMBLE_NODE(arg);
}

static void
_jumbleMergeSupportFunc(JumbleState *jstate, Node *node)
{
	MergeSupportFunc *expr = (MergeSupportFunc *) node;

	JUMBLE_FIELD(msftype);
	JUMBLE_FIELD(msfcollid);
}

static void
_jumbleSubscriptingRef(JumbleState *jstate, Node *node)
{
	SubscriptingRef *expr = (SubscriptingRef *) node;

	JUMBLE_NODE(refupperindexpr);
	JUMBLE_NODE(reflowerindexpr);
	JUMBLE_NODE(refexpr);
	JUMBLE_NODE(refassgnexpr);
}

static void
_jumbleFuncExpr(JumbleState *jstate, Node *node)
{
	FuncExpr *expr = (FuncExpr *) node;

	JUMBLE_FIELD(funcid);
	JUMBLE_NODE(args);
}

static void
_jumbleNamedArgExpr(JumbleState *jstate, Node *node)
{
	NamedArgExpr *expr = (NamedArgExpr *) node;

	JUMBLE_NODE(arg);
	JUMBLE_FIELD(argnumber);
}

static void
_jumbleOpExpr(JumbleState *jstate, Node *node)
{
	OpExpr *expr = (OpExpr *) node;

	JUMBLE_FIELD(opno);
	JUMBLE_NODE(args);
}

static void
_jumbleDistinctExpr(JumbleState *jstate, Node *node)
{
	DistinctExpr *expr = (DistinctExpr *) node;

	JUMBLE_FIELD(opno);
	JUMBLE_NODE(args);
}

static void
_jumbleNullIfExpr(JumbleState *jstate, Node *node)
{
	NullIfExpr *expr = (NullIfExpr *) node;

	JUMBLE_FIELD(opno);
	JUMBLE_NODE(args);
}

static void
_jumbleScalarArrayOpExpr(JumbleState *jstate, Node *node)
{
	ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;

	JUMBLE_FIELD(opno);
	JUMBLE_FIELD(useOr);
	JUMBLE_NODE(args);
}

static void
_jumbleBoolExpr(JumbleState *jstate, Node *node)
{
	BoolExpr *expr = (BoolExpr *) node;

	JUMBLE_FIELD(boolop);
	JUMBLE_NODE(args);
}

static void
_jumbleSubLink(JumbleState *jstate, Node *node)
{
	SubLink *expr = (SubLink *) node;

	JUMBLE_FIELD(subLinkType);
	JUMBLE_FIELD(subLinkId);
	JUMBLE_NODE(testexpr);
	JUMBLE_NODE(subselect);
}

static void
_jumbleFieldSelect(JumbleState *jstate, Node *node)
{
	FieldSelect *expr = (FieldSelect *) node;

	JUMBLE_NODE(arg);
	JUMBLE_FIELD(fieldnum);
}

static void
_jumbleFieldStore(JumbleState *jstate, Node *node)
{
	FieldStore *expr = (FieldStore *) node;

	JUMBLE_NODE(arg);
	JUMBLE_NODE(newvals);
}

static void
_jumbleRelabelType(JumbleState *jstate, Node *node)
{
	RelabelType *expr = (RelabelType *) node;

	JUMBLE_NODE(arg);
	JUMBLE_FIELD(resulttype);
}

static void
_jumbleCoerceViaIO(JumbleState *jstate, Node *node)
{
	CoerceViaIO *expr = (CoerceViaIO *) node;

	JUMBLE_NODE(arg);
	JUMBLE_FIELD(resulttype);
}

static void
_jumbleArrayCoerceExpr(JumbleState *jstate, Node *node)
{
	ArrayCoerceExpr *expr = (ArrayCoerceExpr *) node;

	JUMBLE_NODE(arg);
	JUMBLE_NODE(elemexpr);
	JUMBLE_FIELD(resulttype);
}

static void
_jumbleConvertRowtypeExpr(JumbleState *jstate, Node *node)
{
	ConvertRowtypeExpr *expr = (ConvertRowtypeExpr *) node;

	JUMBLE_NODE(arg);
	JUMBLE_FIELD(resulttype);
}

static void
_jumbleCollateExpr(JumbleState *jstate, Node *node)
{
	CollateExpr *expr = (CollateExpr *) node;

	JUMBLE_NODE(arg);
	JUMBLE_FIELD(collOid);
}

static void
_jumbleCaseExpr(JumbleState *jstate, Node *node)
{
	CaseExpr *expr = (CaseExpr *) node;

	JUMBLE_NODE(arg);
	JUMBLE_NODE(args);
	JUMBLE_NODE(defresult);
}

static void
_jumbleCaseWhen(JumbleState *jstate, Node *node)
{
	CaseWhen *expr = (CaseWhen *) node;

	JUMBLE_NODE(expr);
	JUMBLE_NODE(result);
}

static void
_jumbleCaseTestExpr(JumbleState *jstate, Node *node)
{
	CaseTestExpr *expr = (CaseTestExpr *) node;

	JUMBLE_FIELD(typeId);
}

static void
_jumbleArrayExpr(JumbleState *jstate, Node *node)
{
	ArrayExpr *expr = (ArrayExpr *) node;

	JUMBLE_ELEMENTS(elements, node);
}

static void
_jumbleRowExpr(JumbleState *jstate, Node *node)
{
	RowExpr *expr = (RowExpr *) node;

	JUMBLE_NODE(args);
}

static void
_jumbleRowCompareExpr(JumbleState *jstate, Node *node)
{
	RowCompareExpr *expr = (RowCompareExpr *) node;

	JUMBLE_FIELD(cmptype);
	JUMBLE_NODE(largs);
	JUMBLE_NODE(rargs);
}

static void
_jumbleCoalesceExpr(JumbleState *jstate, Node *node)
{
	CoalesceExpr *expr = (CoalesceExpr *) node;

	JUMBLE_NODE(args);
}

static void
_jumbleMinMaxExpr(JumbleState *jstate, Node *node)
{
	MinMaxExpr *expr = (MinMaxExpr *) node;

	JUMBLE_FIELD(op);
	JUMBLE_NODE(args);
}

static void
_jumbleSQLValueFunction(JumbleState *jstate, Node *node)
{
	SQLValueFunction *expr = (SQLValueFunction *) node;

	JUMBLE_FIELD(op);
	JUMBLE_FIELD(typmod);
}

static void
_jumbleXmlExpr(JumbleState *jstate, Node *node)
{
	XmlExpr *expr = (XmlExpr *) node;

	JUMBLE_FIELD(op);
	JUMBLE_NODE(named_args);
	JUMBLE_NODE(args);
	JUMBLE_FIELD(indent);
}

static void
_jumbleJsonFormat(JumbleState *jstate, Node *node)
{
	JsonFormat *expr = (JsonFormat *) node;

	JUMBLE_FIELD(format_type);
	JUMBLE_FIELD(encoding);
}

static void
_jumbleJsonReturning(JumbleState *jstate, Node *node)
{
	JsonReturning *expr = (JsonReturning *) node;

	JUMBLE_NODE(format);
	JUMBLE_FIELD(typid);
	JUMBLE_FIELD(typmod);
}

static void
_jumbleJsonValueExpr(JumbleState *jstate, Node *node)
{
	JsonValueExpr *expr = (JsonValueExpr *) node;

	JUMBLE_NODE(raw_expr);
	JUMBLE_NODE(formatted_expr);
	JUMBLE_NODE(format);
}

static void
_jumbleJsonConstructorExpr(JumbleState *jstate, Node *node)
{
	JsonConstructorExpr *expr = (JsonConstructorExpr *) node;

	JUMBLE_FIELD(type);
	JUMBLE_NODE(args);
	JUMBLE_NODE(func);
	JUMBLE_NODE(coercion);
	JUMBLE_NODE(returning);
	JUMBLE_FIELD(absent_on_null);
	JUMBLE_FIELD(unique);
}

static void
_jumbleJsonIsPredicate(JumbleState *jstate, Node *node)
{
	JsonIsPredicate *expr = (JsonIsPredicate *) node;

	JUMBLE_NODE(expr);
	JUMBLE_NODE(format);
	JUMBLE_FIELD(item_type);
	JUMBLE_FIELD(unique_keys);
}

static void
_jumbleJsonBehavior(JumbleState *jstate, Node *node)
{
	JsonBehavior *expr = (JsonBehavior *) node;

	JUMBLE_FIELD(btype);
	JUMBLE_NODE(expr);
	JUMBLE_FIELD(coerce);
}

static void
_jumbleJsonExpr(JumbleState *jstate, Node *node)
{
	JsonExpr *expr = (JsonExpr *) node;

	JUMBLE_FIELD(op);
	JUMBLE_STRING(column_name);
	JUMBLE_NODE(formatted_expr);
	JUMBLE_NODE(format);
	JUMBLE_NODE(path_spec);
	JUMBLE_NODE(returning);
	JUMBLE_NODE(passing_names);
	JUMBLE_NODE(passing_values);
	JUMBLE_NODE(on_empty);
	JUMBLE_NODE(on_error);
	JUMBLE_FIELD(use_io_coercion);
	JUMBLE_FIELD(use_json_coercion);
	JUMBLE_FIELD(wrapper);
	JUMBLE_FIELD(omit_quotes);
	JUMBLE_FIELD(collation);
}

static void
_jumbleJsonTablePath(JumbleState *jstate, Node *node)
{
	JsonTablePath *expr = (JsonTablePath *) node;

	JUMBLE_NODE(value);
	JUMBLE_STRING(name);
}

static void
_jumbleJsonTablePathScan(JumbleState *jstate, Node *node)
{
	JsonTablePathScan *expr = (JsonTablePathScan *) node;

	JUMBLE_NODE(path);
	JUMBLE_FIELD(errorOnError);
	JUMBLE_NODE(child);
	JUMBLE_FIELD(colMin);
	JUMBLE_FIELD(colMax);
}

static void
_jumbleJsonTableSiblingJoin(JumbleState *jstate, Node *node)
{
	JsonTableSiblingJoin *expr = (JsonTableSiblingJoin *) node;

	JUMBLE_NODE(lplan);
	JUMBLE_NODE(rplan);
}

static void
_jumbleNullTest(JumbleState *jstate, Node *node)
{
	NullTest *expr = (NullTest *) node;

	JUMBLE_NODE(arg);
	JUMBLE_FIELD(nulltesttype);
}

static void
_jumbleBooleanTest(JumbleState *jstate, Node *node)
{
	BooleanTest *expr = (BooleanTest *) node;

	JUMBLE_NODE(arg);
	JUMBLE_FIELD(booltesttype);
}

static void
_jumbleMergeAction(JumbleState *jstate, Node *node)
{
	MergeAction *expr = (MergeAction *) node;

	JUMBLE_FIELD(matchKind);
	JUMBLE_FIELD(commandType);
	JUMBLE_NODE(qual);
	JUMBLE_NODE(targetList);
}

static void
_jumbleCoerceToDomain(JumbleState *jstate, Node *node)
{
	CoerceToDomain *expr = (CoerceToDomain *) node;

	JUMBLE_NODE(arg);
	JUMBLE_FIELD(resulttype);
}

static void
_jumbleCoerceToDomainValue(JumbleState *jstate, Node *node)
{
	CoerceToDomainValue *expr = (CoerceToDomainValue *) node;

	JUMBLE_FIELD(typeId);
}

static void
_jumbleSetToDefault(JumbleState *jstate, Node *node)
{
	SetToDefault *expr = (SetToDefault *) node;

	JUMBLE_FIELD(typeId);
}

static void
_jumbleCurrentOfExpr(JumbleState *jstate, Node *node)
{
	CurrentOfExpr *expr = (CurrentOfExpr *) node;

	JUMBLE_FIELD(cvarno);
	JUMBLE_STRING(cursor_name);
	JUMBLE_FIELD(cursor_param);
}

static void
_jumbleNextValueExpr(JumbleState *jstate, Node *node)
{
	NextValueExpr *expr = (NextValueExpr *) node;

	JUMBLE_FIELD(seqid);
	JUMBLE_FIELD(typeId);
}

static void
_jumbleInferenceElem(JumbleState *jstate, Node *node)
{
	InferenceElem *expr = (InferenceElem *) node;

	JUMBLE_NODE(expr);
	JUMBLE_FIELD(infercollid);
	JUMBLE_FIELD(inferopclass);
}

static void
_jumbleReturningExpr(JumbleState *jstate, Node *node)
{
	ReturningExpr *expr = (ReturningExpr *) node;

	JUMBLE_FIELD(retlevelsup);
	JUMBLE_FIELD(retold);
	JUMBLE_NODE(retexpr);
}

static void
_jumbleTargetEntry(JumbleState *jstate, Node *node)
{
	TargetEntry *expr = (TargetEntry *) node;

	JUMBLE_NODE(expr);
	JUMBLE_FIELD(resno);
	JUMBLE_FIELD(ressortgroupref);
}

static void
_jumbleRangeTblRef(JumbleState *jstate, Node *node)
{
	RangeTblRef *expr = (RangeTblRef *) node;

	JUMBLE_FIELD(rtindex);
}

static void
_jumbleJoinExpr(JumbleState *jstate, Node *node)
{
	JoinExpr *expr = (JoinExpr *) node;

	JUMBLE_FIELD(jointype);
	JUMBLE_FIELD(isNatural);
	JUMBLE_NODE(larg);
	JUMBLE_NODE(rarg);
	JUMBLE_NODE(quals);
	JUMBLE_FIELD(rtindex);
}

static void
_jumbleFromExpr(JumbleState *jstate, Node *node)
{
	FromExpr *expr = (FromExpr *) node;

	JUMBLE_NODE(fromlist);
	JUMBLE_NODE(quals);
}

static void
_jumbleOnConflictExpr(JumbleState *jstate, Node *node)
{
	OnConflictExpr *expr = (OnConflictExpr *) node;

	JUMBLE_FIELD(action);
	JUMBLE_NODE(arbiterElems);
	JUMBLE_NODE(arbiterWhere);
	JUMBLE_FIELD(constraint);
	JUMBLE_NODE(onConflictSet);
	JUMBLE_NODE(onConflictWhere);
	JUMBLE_FIELD(exclRelIndex);
	JUMBLE_NODE(exclRelTlist);
}

static void
_jumbleQuery(JumbleState *jstate, Node *node)
{
	Query *expr = (Query *) node;

	JUMBLE_FIELD(commandType);
	JUMBLE_NODE(utilityStmt);
	JUMBLE_NODE(cteList);
	JUMBLE_NODE(rtable);
	JUMBLE_NODE(jointree);
	JUMBLE_NODE(mergeActionList);
	JUMBLE_NODE(mergeJoinCondition);
	JUMBLE_NODE(targetList);
	JUMBLE_NODE(onConflict);
	JUMBLE_NODE(returningList);
	JUMBLE_NODE(groupClause);
	JUMBLE_FIELD(groupDistinct);
	JUMBLE_NODE(groupingSets);
	JUMBLE_NODE(havingQual);
	JUMBLE_NODE(windowClause);
	JUMBLE_NODE(distinctClause);
	JUMBLE_NODE(sortClause);
	JUMBLE_NODE(limitOffset);
	JUMBLE_NODE(limitCount);
	JUMBLE_FIELD(limitOption);
	JUMBLE_NODE(rowMarks);
	JUMBLE_NODE(setOperations);
}

static void
_jumbleTypeName(JumbleState *jstate, Node *node)
{
	TypeName *expr = (TypeName *) node;

	JUMBLE_NODE(names);
	JUMBLE_FIELD(typeOid);
	JUMBLE_FIELD(setof);
	JUMBLE_FIELD(pct_type);
	JUMBLE_NODE(typmods);
	JUMBLE_FIELD(typemod);
	JUMBLE_NODE(arrayBounds);
}

static void
_jumbleColumnRef(JumbleState *jstate, Node *node)
{
	ColumnRef *expr = (ColumnRef *) node;

	JUMBLE_NODE(fields);
}

static void
_jumbleParamRef(JumbleState *jstate, Node *node)
{
	ParamRef *expr = (ParamRef *) node;

	JUMBLE_FIELD(number);
}

static void
_jumbleA_Expr(JumbleState *jstate, Node *node)
{
	A_Expr *expr = (A_Expr *) node;

	JUMBLE_FIELD(kind);
	JUMBLE_NODE(name);
	JUMBLE_NODE(lexpr);
	JUMBLE_NODE(rexpr);
}

static void
_jumbleTypeCast(JumbleState *jstate, Node *node)
{
	TypeCast *expr = (TypeCast *) node;

	JUMBLE_NODE(arg);
	JUMBLE_NODE(typeName);
}

static void
_jumbleCollateClause(JumbleState *jstate, Node *node)
{
	CollateClause *expr = (CollateClause *) node;

	JUMBLE_NODE(arg);
	JUMBLE_NODE(collname);
}

static void
_jumbleRoleSpec(JumbleState *jstate, Node *node)
{
	RoleSpec *expr = (RoleSpec *) node;

	JUMBLE_FIELD(roletype);
	JUMBLE_STRING(rolename);
}

static void
_jumbleFuncCall(JumbleState *jstate, Node *node)
{
	FuncCall *expr = (FuncCall *) node;

	JUMBLE_NODE(funcname);
	JUMBLE_NODE(args);
	JUMBLE_NODE(agg_order);
	JUMBLE_NODE(agg_filter);
	JUMBLE_NODE(over);
	JUMBLE_FIELD(agg_within_group);
	JUMBLE_FIELD(agg_star);
	JUMBLE_FIELD(agg_distinct);
	JUMBLE_FIELD(func_variadic);
	JUMBLE_FIELD(funcformat);
}

static void
_jumbleA_Star(JumbleState *jstate, Node *node)
{
	A_Star *expr = (A_Star *) node;

	(void) expr;
}

static void
_jumbleA_Indices(JumbleState *jstate, Node *node)
{
	A_Indices *expr = (A_Indices *) node;

	JUMBLE_FIELD(is_slice);
	JUMBLE_NODE(lidx);
	JUMBLE_NODE(uidx);
}

static void
_jumbleA_Indirection(JumbleState *jstate, Node *node)
{
	A_Indirection *expr = (A_Indirection *) node;

	JUMBLE_NODE(arg);
	JUMBLE_NODE(indirection);
}

static void
_jumbleA_ArrayExpr(JumbleState *jstate, Node *node)
{
	A_ArrayExpr *expr = (A_ArrayExpr *) node;

	JUMBLE_NODE(elements);
}

static void
_jumbleResTarget(JumbleState *jstate, Node *node)
{
	ResTarget *expr = (ResTarget *) node;

	JUMBLE_STRING(name);
	JUMBLE_NODE(indirection);
	JUMBLE_NODE(val);
}

static void
_jumbleMultiAssignRef(JumbleState *jstate, Node *node)
{
	MultiAssignRef *expr = (MultiAssignRef *) node;

	JUMBLE_NODE(source);
	JUMBLE_FIELD(colno);
	JUMBLE_FIELD(ncolumns);
}

static void
_jumbleSortBy(JumbleState *jstate, Node *node)
{
	SortBy *expr = (SortBy *) node;

	JUMBLE_NODE(node);
	JUMBLE_FIELD(sortby_dir);
	JUMBLE_FIELD(sortby_nulls);
	JUMBLE_NODE(useOp);
}

static void
_jumbleWindowDef(JumbleState *jstate, Node *node)
{
	WindowDef *expr = (WindowDef *) node;

	JUMBLE_STRING(name);
	JUMBLE_STRING(refname);
	JUMBLE_NODE(partitionClause);
	JUMBLE_NODE(orderClause);
	JUMBLE_FIELD(frameOptions);
	JUMBLE_NODE(startOffset);
	JUMBLE_NODE(endOffset);
}

static void
_jumbleRangeSubselect(JumbleState *jstate, Node *node)
{
	RangeSubselect *expr = (RangeSubselect *) node;

	JUMBLE_FIELD(lateral);
	JUMBLE_NODE(subquery);
	JUMBLE_NODE(alias);
}

static void
_jumbleRangeFunction(JumbleState *jstate, Node *node)
{
	RangeFunction *expr = (RangeFunction *) node;

	JUMBLE_FIELD(lateral);
	JUMBLE_FIELD(ordinality);
	JUMBLE_FIELD(is_rowsfrom);
	JUMBLE_NODE(functions);
	JUMBLE_NODE(alias);
	JUMBLE_NODE(coldeflist);
}

static void
_jumbleRangeTableFunc(JumbleState *jstate, Node *node)
{
	RangeTableFunc *expr = (RangeTableFunc *) node;

	JUMBLE_FIELD(lateral);
	JUMBLE_NODE(docexpr);
	JUMBLE_NODE(rowexpr);
	JUMBLE_NODE(namespaces);
	JUMBLE_NODE(columns);
	JUMBLE_NODE(alias);
}

static void
_jumbleRangeTableFuncCol(JumbleState *jstate, Node *node)
{
	RangeTableFuncCol *expr = (RangeTableFuncCol *) node;

	JUMBLE_STRING(colname);
	JUMBLE_NODE(typeName);
	JUMBLE_FIELD(for_ordinality);
	JUMBLE_FIELD(is_not_null);
	JUMBLE_NODE(colexpr);
	JUMBLE_NODE(coldefexpr);
}

static void
_jumbleRangeTableSample(JumbleState *jstate, Node *node)
{
	RangeTableSample *expr = (RangeTableSample *) node;

	JUMBLE_NODE(relation);
	JUMBLE_NODE(method);
	JUMBLE_NODE(args);
	JUMBLE_NODE(repeatable);
}

static void
_jumbleColumnDef(JumbleState *jstate, Node *node)
{
	ColumnDef *expr = (ColumnDef *) node;

	JUMBLE_STRING(colname);
	JUMBLE_NODE(typeName);
	JUMBLE_STRING(compression);
	JUMBLE_FIELD(inhcount);
	JUMBLE_FIELD(is_local);
	JUMBLE_FIELD(is_not_null);
	JUMBLE_FIELD(is_from_type);
	JUMBLE_FIELD(storage);
	JUMBLE_STRING(storage_name);
	JUMBLE_NODE(raw_default);
	JUMBLE_NODE(cooked_default);
	JUMBLE_FIELD(identity);
	JUMBLE_NODE(identitySequence);
	JUMBLE_FIELD(generated);
	JUMBLE_NODE(collClause);
	JUMBLE_FIELD(collOid);
	JUMBLE_NODE(constraints);
	JUMBLE_NODE(fdwoptions);
}

static void
_jumbleTableLikeClause(JumbleState *jstate, Node *node)
{
	TableLikeClause *expr = (TableLikeClause *) node;

	JUMBLE_NODE(relation);
	JUMBLE_FIELD(options);
	JUMBLE_FIELD(relationOid);
}

static void
_jumbleIndexElem(JumbleState *jstate, Node *node)
{
	IndexElem *expr = (IndexElem *) node;

	JUMBLE_STRING(name);
	JUMBLE_NODE(expr);
	JUMBLE_STRING(indexcolname);
	JUMBLE_NODE(collation);
	JUMBLE_NODE(opclass);
	JUMBLE_NODE(opclassopts);
	JUMBLE_FIELD(ordering);
	JUMBLE_FIELD(nulls_ordering);
}

static void
_jumbleDefElem(JumbleState *jstate, Node *node)
{
	DefElem *expr = (DefElem *) node;

	JUMBLE_STRING(defnamespace);
	JUMBLE_STRING(defname);
	JUMBLE_NODE(arg);
	JUMBLE_FIELD(defaction);
}

static void
_jumbleLockingClause(JumbleState *jstate, Node *node)
{
	LockingClause *expr = (LockingClause *) node;

	JUMBLE_NODE(lockedRels);
	JUMBLE_FIELD(strength);
	JUMBLE_FIELD(waitPolicy);
}

static void
_jumbleXmlSerialize(JumbleState *jstate, Node *node)
{
	XmlSerialize *expr = (XmlSerialize *) node;

	JUMBLE_FIELD(xmloption);
	JUMBLE_NODE(expr);
	JUMBLE_NODE(typeName);
	JUMBLE_FIELD(indent);
}

static void
_jumblePartitionElem(JumbleState *jstate, Node *node)
{
	PartitionElem *expr = (PartitionElem *) node;

	JUMBLE_STRING(name);
	JUMBLE_NODE(expr);
	JUMBLE_NODE(collation);
	JUMBLE_NODE(opclass);
}

static void
_jumblePartitionSpec(JumbleState *jstate, Node *node)
{
	PartitionSpec *expr = (PartitionSpec *) node;

	JUMBLE_FIELD(strategy);
	JUMBLE_NODE(partParams);
}

static void
_jumblePartitionBoundSpec(JumbleState *jstate, Node *node)
{
	PartitionBoundSpec *expr = (PartitionBoundSpec *) node;

	JUMBLE_FIELD(strategy);
	JUMBLE_FIELD(is_default);
	JUMBLE_FIELD(modulus);
	JUMBLE_FIELD(remainder);
	JUMBLE_NODE(listdatums);
	JUMBLE_NODE(lowerdatums);
	JUMBLE_NODE(upperdatums);
}

static void
_jumblePartitionRangeDatum(JumbleState *jstate, Node *node)
{
	PartitionRangeDatum *expr = (PartitionRangeDatum *) node;

	JUMBLE_FIELD(kind);
	JUMBLE_NODE(value);
}

static void
_jumblePartitionCmd(JumbleState *jstate, Node *node)
{
	PartitionCmd *expr = (PartitionCmd *) node;

	JUMBLE_NODE(name);
	JUMBLE_NODE(bound);
	JUMBLE_FIELD(concurrent);
}

static void
_jumbleRangeTblEntry(JumbleState *jstate, Node *node)
{
	RangeTblEntry *expr = (RangeTblEntry *) node;

	JUMBLE_CUSTOM(RangeTblEntry, eref);
	JUMBLE_FIELD(rtekind);
	JUMBLE_FIELD(inh);
	JUMBLE_NODE(tablesample);
	JUMBLE_NODE(subquery);
	JUMBLE_FIELD(jointype);
	JUMBLE_NODE(functions);
	JUMBLE_FIELD(funcordinality);
	JUMBLE_NODE(tablefunc);
	JUMBLE_NODE(values_lists);
	JUMBLE_STRING(ctename);
	JUMBLE_FIELD(ctelevelsup);
	JUMBLE_STRING(enrname);
	JUMBLE_NODE(groupexprs);
}

static void
_jumbleRTEPermissionInfo(JumbleState *jstate, Node *node)
{
	RTEPermissionInfo *expr = (RTEPermissionInfo *) node;

	JUMBLE_FIELD(relid);
	JUMBLE_FIELD(inh);
	JUMBLE_FIELD(requiredPerms);
	JUMBLE_FIELD(checkAsUser);
	JUMBLE_NODE(selectedCols);
	JUMBLE_NODE(insertedCols);
	JUMBLE_NODE(updatedCols);
}

static void
_jumbleRangeTblFunction(JumbleState *jstate, Node *node)
{
	RangeTblFunction *expr = (RangeTblFunction *) node;

	JUMBLE_NODE(funcexpr);
}

static void
_jumbleTableSampleClause(JumbleState *jstate, Node *node)
{
	TableSampleClause *expr = (TableSampleClause *) node;

	JUMBLE_FIELD(tsmhandler);
	JUMBLE_NODE(args);
	JUMBLE_NODE(repeatable);
}

static void
_jumbleWithCheckOption(JumbleState *jstate, Node *node)
{
	WithCheckOption *expr = (WithCheckOption *) node;

	JUMBLE_FIELD(kind);
	JUMBLE_STRING(relname);
	JUMBLE_STRING(polname);
	JUMBLE_NODE(qual);
	JUMBLE_FIELD(cascaded);
}

static void
_jumbleSortGroupClause(JumbleState *jstate, Node *node)
{
	SortGroupClause *expr = (SortGroupClause *) node;

	JUMBLE_FIELD(tleSortGroupRef);
	JUMBLE_FIELD(eqop);
	JUMBLE_FIELD(sortop);
	JUMBLE_FIELD(reverse_sort);
	JUMBLE_FIELD(nulls_first);
}

static void
_jumbleGroupingSet(JumbleState *jstate, Node *node)
{
	GroupingSet *expr = (GroupingSet *) node;

	JUMBLE_NODE(content);
}

static void
_jumbleWindowClause(JumbleState *jstate, Node *node)
{
	WindowClause *expr = (WindowClause *) node;

	JUMBLE_NODE(partitionClause);
	JUMBLE_NODE(orderClause);
	JUMBLE_FIELD(frameOptions);
	JUMBLE_NODE(startOffset);
	JUMBLE_NODE(endOffset);
	JUMBLE_FIELD(winref);
}

static void
_jumbleRowMarkClause(JumbleState *jstate, Node *node)
{
	RowMarkClause *expr = (RowMarkClause *) node;

	JUMBLE_FIELD(rti);
	JUMBLE_FIELD(strength);
	JUMBLE_FIELD(waitPolicy);
	JUMBLE_FIELD(pushedDown);
}

static void
_jumbleWithClause(JumbleState *jstate, Node *node)
{
	WithClause *expr = (WithClause *) node;

	JUMBLE_NODE(ctes);
	JUMBLE_FIELD(recursive);
}

static void
_jumbleInferClause(JumbleState *jstate, Node *node)
{
	InferClause *expr = (InferClause *) node;

	JUMBLE_NODE(indexElems);
	JUMBLE_NODE(whereClause);
	JUMBLE_STRING(conname);
}

static void
_jumbleOnConflictClause(JumbleState *jstate, Node *node)
{
	OnConflictClause *expr = (OnConflictClause *) node;

	JUMBLE_FIELD(action);
	JUMBLE_NODE(infer);
	JUMBLE_NODE(targetList);
	JUMBLE_NODE(whereClause);
}

static void
_jumbleCTESearchClause(JumbleState *jstate, Node *node)
{
	CTESearchClause *expr = (CTESearchClause *) node;

	JUMBLE_NODE(search_col_list);
	JUMBLE_FIELD(search_breadth_first);
	JUMBLE_STRING(search_seq_column);
}

static void
_jumbleCTECycleClause(JumbleState *jstate, Node *node)
{
	CTECycleClause *expr = (CTECycleClause *) node;

	JUMBLE_NODE(cycle_col_list);
	JUMBLE_STRING(cycle_mark_column);
	JUMBLE_NODE(cycle_mark_value);
	JUMBLE_NODE(cycle_mark_default);
	JUMBLE_STRING(cycle_path_column);
	JUMBLE_FIELD(cycle_mark_type);
	JUMBLE_FIELD(cycle_mark_typmod);
	JUMBLE_FIELD(cycle_mark_collation);
	JUMBLE_FIELD(cycle_mark_neop);
}

static void
_jumbleCommonTableExpr(JumbleState *jstate, Node *node)
{
	CommonTableExpr *expr = (CommonTableExpr *) node;

	JUMBLE_STRING(ctename);
	JUMBLE_FIELD(ctematerialized);
	JUMBLE_NODE(ctequery);
}

static void
_jumbleMergeWhenClause(JumbleState *jstate, Node *node)
{
	MergeWhenClause *expr = (MergeWhenClause *) node;

	JUMBLE_FIELD(matchKind);
	JUMBLE_FIELD(commandType);
	JUMBLE_FIELD(override);
	JUMBLE_NODE(condition);
	JUMBLE_NODE(targetList);
	JUMBLE_NODE(values);
}

static void
_jumbleReturningOption(JumbleState *jstate, Node *node)
{
	ReturningOption *expr = (ReturningOption *) node;

	JUMBLE_FIELD(option);
	JUMBLE_STRING(value);
}

static void
_jumbleReturningClause(JumbleState *jstate, Node *node)
{
	ReturningClause *expr = (ReturningClause *) node;

	JUMBLE_NODE(options);
	JUMBLE_NODE(exprs);
}

static void
_jumbleTriggerTransition(JumbleState *jstate, Node *node)
{
	TriggerTransition *expr = (TriggerTransition *) node;

	JUMBLE_STRING(name);
	JUMBLE_FIELD(isNew);
	JUMBLE_FIELD(isTable);
}

static void
_jumbleJsonOutput(JumbleState *jstate, Node *node)
{
	JsonOutput *expr = (JsonOutput *) node;

	JUMBLE_NODE(typeName);
	JUMBLE_NODE(returning);
}

static void
_jumbleJsonArgument(JumbleState *jstate, Node *node)
{
	JsonArgument *expr = (JsonArgument *) node;

	JUMBLE_NODE(val);
	JUMBLE_STRING(name);
}

static void
_jumbleJsonFuncExpr(JumbleState *jstate, Node *node)
{
	JsonFuncExpr *expr = (JsonFuncExpr *) node;

	JUMBLE_FIELD(op);
	JUMBLE_STRING(column_name);
	JUMBLE_NODE(context_item);
	JUMBLE_NODE(pathspec);
	JUMBLE_NODE(passing);
	JUMBLE_NODE(output);
	JUMBLE_NODE(on_empty);
	JUMBLE_NODE(on_error);
	JUMBLE_FIELD(wrapper);
	JUMBLE_FIELD(quotes);
}

static void
_jumbleJsonTablePathSpec(JumbleState *jstate, Node *node)
{
	JsonTablePathSpec *expr = (JsonTablePathSpec *) node;

	JUMBLE_NODE(string);
	JUMBLE_STRING(name);
}

static void
_jumbleJsonTable(JumbleState *jstate, Node *node)
{
	JsonTable *expr = (JsonTable *) node;

	JUMBLE_NODE(context_item);
	JUMBLE_NODE(pathspec);
	JUMBLE_NODE(passing);
	JUMBLE_NODE(columns);
	JUMBLE_NODE(on_error);
	JUMBLE_NODE(alias);
	JUMBLE_FIELD(lateral);
}

static void
_jumbleJsonTableColumn(JumbleState *jstate, Node *node)
{
	JsonTableColumn *expr = (JsonTableColumn *) node;

	JUMBLE_FIELD(coltype);
	JUMBLE_STRING(name);
	JUMBLE_NODE(typeName);
	JUMBLE_NODE(pathspec);
	JUMBLE_NODE(format);
	JUMBLE_FIELD(wrapper);
	JUMBLE_FIELD(quotes);
	JUMBLE_NODE(columns);
	JUMBLE_NODE(on_empty);
	JUMBLE_NODE(on_error);
}

static void
_jumbleJsonKeyValue(JumbleState *jstate, Node *node)
{
	JsonKeyValue *expr = (JsonKeyValue *) node;

	JUMBLE_NODE(key);
	JUMBLE_NODE(value);
}

static void
_jumbleJsonParseExpr(JumbleState *jstate, Node *node)
{
	JsonParseExpr *expr = (JsonParseExpr *) node;

	JUMBLE_NODE(expr);
	JUMBLE_NODE(output);
	JUMBLE_FIELD(unique_keys);
}

static void
_jumbleJsonScalarExpr(JumbleState *jstate, Node *node)
{
	JsonScalarExpr *expr = (JsonScalarExpr *) node;

	JUMBLE_NODE(expr);
	JUMBLE_NODE(output);
}

static void
_jumbleJsonSerializeExpr(JumbleState *jstate, Node *node)
{
	JsonSerializeExpr *expr = (JsonSerializeExpr *) node;

	JUMBLE_NODE(expr);
	JUMBLE_NODE(output);
}

static void
_jumbleJsonObjectConstructor(JumbleState *jstate, Node *node)
{
	JsonObjectConstructor *expr = (JsonObjectConstructor *) node;

	JUMBLE_NODE(exprs);
	JUMBLE_NODE(output);
	JUMBLE_FIELD(absent_on_null);
	JUMBLE_FIELD(unique);
}

static void
_jumbleJsonArrayConstructor(JumbleState *jstate, Node *node)
{
	JsonArrayConstructor *expr = (JsonArrayConstructor *) node;

	JUMBLE_NODE(exprs);
	JUMBLE_NODE(output);
	JUMBLE_FIELD(absent_on_null);
}

static void
_jumbleJsonArrayQueryConstructor(JumbleState *jstate, Node *node)
{
	JsonArrayQueryConstructor *expr = (JsonArrayQueryConstructor *) node;

	JUMBLE_NODE(query);
	JUMBLE_NODE(output);
	JUMBLE_NODE(format);
	JUMBLE_FIELD(absent_on_null);
}

static void
_jumbleJsonAggConstructor(JumbleState *jstate, Node *node)
{
	JsonAggConstructor *expr = (JsonAggConstructor *) node;

	JUMBLE_NODE(output);
	JUMBLE_NODE(agg_filter);
	JUMBLE_NODE(agg_order);
	JUMBLE_NODE(over);
}

static void
_jumbleJsonObjectAgg(JumbleState *jstate, Node *node)
{
	JsonObjectAgg *expr = (JsonObjectAgg *) node;

	JUMBLE_NODE(constructor);
	JUMBLE_NODE(arg);
	JUMBLE_FIELD(absent_on_null);
	JUMBLE_FIELD(unique);
}

static void
_jumbleJsonArrayAgg(JumbleState *jstate, Node *node)
{
	JsonArrayAgg *expr = (JsonArrayAgg *) node;

	JUMBLE_NODE(constructor);
	JUMBLE_NODE(arg);
	JUMBLE_FIELD(absent_on_null);
}

static void
_jumbleInsertStmt(JumbleState *jstate, Node *node)
{
	InsertStmt *expr = (InsertStmt *) node;

	JUMBLE_NODE(relation);
	JUMBLE_NODE(cols);
	JUMBLE_NODE(selectStmt);
	JUMBLE_NODE(onConflictClause);
	JUMBLE_NODE(returningClause);
	JUMBLE_NODE(withClause);
	JUMBLE_FIELD(override);
}

static void
_jumbleDeleteStmt(JumbleState *jstate, Node *node)
{
	DeleteStmt *expr = (DeleteStmt *) node;

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

static void
_jumbleUpdateStmt(JumbleState *jstate, Node *node)
{
	UpdateStmt *expr = (UpdateStmt *) node;

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

static void
_jumbleMergeStmt(JumbleState *jstate, Node *node)
{
	MergeStmt *expr = (MergeStmt *) node;

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

static void
_jumbleSelectStmt(JumbleState *jstate, Node *node)
{
	SelectStmt *expr = (SelectStmt *) node;

	JUMBLE_NODE(distinctClause);
	JUMBLE_NODE(intoClause);
	JUMBLE_NODE(targetList);
	JUMBLE_NODE(fromClause);
	JUMBLE_NODE(whereClause);
	JUMBLE_NODE(groupClause);
	JUMBLE_FIELD(groupDistinct);
	JUMBLE_NODE(havingClause);
	JUMBLE_NODE(windowClause);
	JUMBLE_NODE(valuesLists);
	JUMBLE_NODE(sortClause);
	JUMBLE_NODE(limitOffset);
	JUMBLE_NODE(limitCount);
	JUMBLE_FIELD(limitOption);
	JUMBLE_NODE(lockingClause);
	JUMBLE_NODE(withClause);
	JUMBLE_FIELD(op);
	JUMBLE_FIELD(all);
	JUMBLE_NODE(larg);
	JUMBLE_NODE(rarg);
}

static void
_jumbleSetOperationStmt(JumbleState *jstate, Node *node)
{
	SetOperationStmt *expr = (SetOperationStmt *) node;

	JUMBLE_FIELD(op);
	JUMBLE_FIELD(all);
	JUMBLE_NODE(larg);
	JUMBLE_NODE(rarg);
}

static void
_jumbleReturnStmt(JumbleState *jstate, Node *node)
{
	ReturnStmt *expr = (ReturnStmt *) node;

	JUMBLE_NODE(returnval);
}

static void
_jumblePLAssignStmt(JumbleState *jstate, Node *node)
{
	PLAssignStmt *expr = (PLAssignStmt *) node;

	JUMBLE_STRING(name);
	JUMBLE_NODE(indirection);
	JUMBLE_FIELD(nnames);
	JUMBLE_NODE(val);
}

static void
_jumbleCreateSchemaStmt(JumbleState *jstate, Node *node)
{
	CreateSchemaStmt *expr = (CreateSchemaStmt *) node;

	JUMBLE_STRING(schemaname);
	JUMBLE_NODE(authrole);
	JUMBLE_NODE(schemaElts);
	JUMBLE_FIELD(if_not_exists);
}

static void
_jumbleAlterTableStmt(JumbleState *jstate, Node *node)
{
	AlterTableStmt *expr = (AlterTableStmt *) node;

	JUMBLE_NODE(relation);
	JUMBLE_NODE(cmds);
	JUMBLE_FIELD(objtype);
	JUMBLE_FIELD(missing_ok);
}

static void
_jumbleAlterTableCmd(JumbleState *jstate, Node *node)
{
	AlterTableCmd *expr = (AlterTableCmd *) node;

	JUMBLE_FIELD(subtype);
	JUMBLE_STRING(name);
	JUMBLE_FIELD(num);
	JUMBLE_NODE(newowner);
	JUMBLE_NODE(def);
	JUMBLE_FIELD(behavior);
	JUMBLE_FIELD(missing_ok);
	JUMBLE_FIELD(recurse);
}

static void
_jumbleATAlterConstraint(JumbleState *jstate, Node *node)
{
	ATAlterConstraint *expr = (ATAlterConstraint *) node;

	JUMBLE_STRING(conname);
	JUMBLE_FIELD(alterEnforceability);
	JUMBLE_FIELD(is_enforced);
	JUMBLE_FIELD(alterDeferrability);
	JUMBLE_FIELD(deferrable);
	JUMBLE_FIELD(initdeferred);
	JUMBLE_FIELD(alterInheritability);
	JUMBLE_FIELD(noinherit);
}

static void
_jumbleReplicaIdentityStmt(JumbleState *jstate, Node *node)
{
	ReplicaIdentityStmt *expr = (ReplicaIdentityStmt *) node;

	JUMBLE_FIELD(identity_type);
	JUMBLE_STRING(name);
}

static void
_jumbleAlterCollationStmt(JumbleState *jstate, Node *node)
{
	AlterCollationStmt *expr = (AlterCollationStmt *) node;

	JUMBLE_NODE(collname);
}

static void
_jumbleAlterDomainStmt(JumbleState *jstate, Node *node)
{
	AlterDomainStmt *expr = (AlterDomainStmt *) node;

	JUMBLE_FIELD(subtype);
	JUMBLE_NODE(typeName);
	JUMBLE_STRING(name);
	JUMBLE_NODE(def);
	JUMBLE_FIELD(behavior);
	JUMBLE_FIELD(missing_ok);
}

static void
_jumbleGrantStmt(JumbleState *jstate, Node *node)
{
	GrantStmt *expr = (GrantStmt *) node;

	JUMBLE_FIELD(is_grant);
	JUMBLE_FIELD(targtype);
	JUMBLE_FIELD(objtype);
	JUMBLE_NODE(objects);
	JUMBLE_NODE(privileges);
	JUMBLE_NODE(grantees);
	JUMBLE_FIELD(grant_option);
	JUMBLE_NODE(grantor);
	JUMBLE_FIELD(behavior);
}

static void
_jumbleObjectWithArgs(JumbleState *jstate, Node *node)
{
	ObjectWithArgs *expr = (ObjectWithArgs *) node;

	JUMBLE_NODE(objname);
	JUMBLE_NODE(objargs);
	JUMBLE_NODE(objfuncargs);
	JUMBLE_FIELD(args_unspecified);
}

static void
_jumbleAccessPriv(JumbleState *jstate, Node *node)
{
	AccessPriv *expr = (AccessPriv *) node;

	JUMBLE_STRING(priv_name);
	JUMBLE_NODE(cols);
}

static void
_jumbleGrantRoleStmt(JumbleState *jstate, Node *node)
{
	GrantRoleStmt *expr = (GrantRoleStmt *) node;

	JUMBLE_NODE(granted_roles);
	JUMBLE_NODE(grantee_roles);
	JUMBLE_FIELD(is_grant);
	JUMBLE_NODE(opt);
	JUMBLE_NODE(grantor);
	JUMBLE_FIELD(behavior);
}

static void
_jumbleAlterDefaultPrivilegesStmt(JumbleState *jstate, Node *node)
{
	AlterDefaultPrivilegesStmt *expr = (AlterDefaultPrivilegesStmt *) node;

	JUMBLE_NODE(options);
	JUMBLE_NODE(action);
}

static void
_jumbleCopyStmt(JumbleState *jstate, Node *node)
{
	CopyStmt *expr = (CopyStmt *) node;

	JUMBLE_NODE(relation);
	JUMBLE_NODE(query);
	JUMBLE_NODE(attlist);
	JUMBLE_FIELD(is_from);
	JUMBLE_FIELD(is_program);
	JUMBLE_STRING(filename);
	JUMBLE_NODE(options);
	JUMBLE_NODE(whereClause);
}

static void
_jumbleVariableShowStmt(JumbleState *jstate, Node *node)
{
	VariableShowStmt *expr = (VariableShowStmt *) node;

	JUMBLE_STRING(name);
}

static void
_jumbleCreateStmt(JumbleState *jstate, Node *node)
{
	CreateStmt *expr = (CreateStmt *) node;

	JUMBLE_NODE(relation);
	JUMBLE_NODE(tableElts);
	JUMBLE_NODE(inhRelations);
	JUMBLE_NODE(partbound);
	JUMBLE_NODE(partspec);
	JUMBLE_NODE(ofTypename);
	JUMBLE_NODE(constraints);
	JUMBLE_NODE(nnconstraints);
	JUMBLE_NODE(options);
	JUMBLE_FIELD(oncommit);
	JUMBLE_STRING(tablespacename);
	JUMBLE_STRING(accessMethod);
	JUMBLE_FIELD(if_not_exists);
}

static void
_jumbleConstraint(JumbleState *jstate, Node *node)
{
	Constraint *expr = (Constraint *) node;

	JUMBLE_FIELD(contype);
	JUMBLE_STRING(conname);
	JUMBLE_FIELD(deferrable);
	JUMBLE_FIELD(initdeferred);
	JUMBLE_FIELD(is_enforced);
	JUMBLE_FIELD(skip_validation);
	JUMBLE_FIELD(initially_valid);
	JUMBLE_FIELD(is_no_inherit);
	JUMBLE_NODE(raw_expr);
	JUMBLE_STRING(cooked_expr);
	JUMBLE_FIELD(generated_when);
	JUMBLE_FIELD(generated_kind);
	JUMBLE_FIELD(nulls_not_distinct);
	JUMBLE_NODE(keys);
	JUMBLE_FIELD(without_overlaps);
	JUMBLE_NODE(including);
	JUMBLE_NODE(exclusions);
	JUMBLE_NODE(options);
	JUMBLE_STRING(indexname);
	JUMBLE_STRING(indexspace);
	JUMBLE_FIELD(reset_default_tblspc);
	JUMBLE_STRING(access_method);
	JUMBLE_NODE(where_clause);
	JUMBLE_NODE(pktable);
	JUMBLE_NODE(fk_attrs);
	JUMBLE_NODE(pk_attrs);
	JUMBLE_FIELD(fk_with_period);
	JUMBLE_FIELD(pk_with_period);
	JUMBLE_FIELD(fk_matchtype);
	JUMBLE_FIELD(fk_upd_action);
	JUMBLE_FIELD(fk_del_action);
	JUMBLE_NODE(fk_del_set_cols);
	JUMBLE_NODE(old_conpfeqop);
	JUMBLE_FIELD(old_pktable_oid);
}

static void
_jumbleCreateTableSpaceStmt(JumbleState *jstate, Node *node)
{
	CreateTableSpaceStmt *expr = (CreateTableSpaceStmt *) node;

	JUMBLE_STRING(tablespacename);
	JUMBLE_NODE(owner);
	JUMBLE_STRING(location);
	JUMBLE_NODE(options);
}

static void
_jumbleDropTableSpaceStmt(JumbleState *jstate, Node *node)
{
	DropTableSpaceStmt *expr = (DropTableSpaceStmt *) node;

	JUMBLE_STRING(tablespacename);
	JUMBLE_FIELD(missing_ok);
}

static void
_jumbleAlterTableSpaceOptionsStmt(JumbleState *jstate, Node *node)
{
	AlterTableSpaceOptionsStmt *expr = (AlterTableSpaceOptionsStmt *) node;

	JUMBLE_STRING(tablespacename);
	JUMBLE_NODE(options);
	JUMBLE_FIELD(isReset);
}

static void
_jumbleAlterTableMoveAllStmt(JumbleState *jstate, Node *node)
{
	AlterTableMoveAllStmt *expr = (AlterTableMoveAllStmt *) node;

	JUMBLE_STRING(orig_tablespacename);
	JUMBLE_FIELD(objtype);
	JUMBLE_NODE(roles);
	JUMBLE_STRING(new_tablespacename);
	JUMBLE_FIELD(nowait);
}

static void
_jumbleCreateExtensionStmt(JumbleState *jstate, Node *node)
{
	CreateExtensionStmt *expr = (CreateExtensionStmt *) node;

	JUMBLE_STRING(extname);
	JUMBLE_FIELD(if_not_exists);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterExtensionStmt(JumbleState *jstate, Node *node)
{
	AlterExtensionStmt *expr = (AlterExtensionStmt *) node;

	JUMBLE_STRING(extname);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterExtensionContentsStmt(JumbleState *jstate, Node *node)
{
	AlterExtensionContentsStmt *expr = (AlterExtensionContentsStmt *) node;

	JUMBLE_STRING(extname);
	JUMBLE_FIELD(action);
	JUMBLE_FIELD(objtype);
	JUMBLE_NODE(object);
}

static void
_jumbleCreateFdwStmt(JumbleState *jstate, Node *node)
{
	CreateFdwStmt *expr = (CreateFdwStmt *) node;

	JUMBLE_STRING(fdwname);
	JUMBLE_NODE(func_options);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterFdwStmt(JumbleState *jstate, Node *node)
{
	AlterFdwStmt *expr = (AlterFdwStmt *) node;

	JUMBLE_STRING(fdwname);
	JUMBLE_NODE(func_options);
	JUMBLE_NODE(options);
}

static void
_jumbleCreateForeignServerStmt(JumbleState *jstate, Node *node)
{
	CreateForeignServerStmt *expr = (CreateForeignServerStmt *) node;

	JUMBLE_STRING(servername);
	JUMBLE_STRING(servertype);
	JUMBLE_STRING(version);
	JUMBLE_STRING(fdwname);
	JUMBLE_FIELD(if_not_exists);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterForeignServerStmt(JumbleState *jstate, Node *node)
{
	AlterForeignServerStmt *expr = (AlterForeignServerStmt *) node;

	JUMBLE_STRING(servername);
	JUMBLE_STRING(version);
	JUMBLE_NODE(options);
	JUMBLE_FIELD(has_version);
}

static void
_jumbleCreateForeignTableStmt(JumbleState *jstate, Node *node)
{
	CreateForeignTableStmt *expr = (CreateForeignTableStmt *) node;

	JUMBLE_NODE(base.relation);
	JUMBLE_NODE(base.tableElts);
	JUMBLE_NODE(base.inhRelations);
	JUMBLE_NODE(base.partbound);
	JUMBLE_NODE(base.partspec);
	JUMBLE_NODE(base.ofTypename);
	JUMBLE_NODE(base.constraints);
	JUMBLE_NODE(base.nnconstraints);
	JUMBLE_NODE(base.options);
	JUMBLE_FIELD(base.oncommit);
	JUMBLE_STRING(base.tablespacename);
	JUMBLE_STRING(base.accessMethod);
	JUMBLE_FIELD(base.if_not_exists);
	JUMBLE_STRING(servername);
	JUMBLE_NODE(options);
}

static void
_jumbleCreateUserMappingStmt(JumbleState *jstate, Node *node)
{
	CreateUserMappingStmt *expr = (CreateUserMappingStmt *) node;

	JUMBLE_NODE(user);
	JUMBLE_STRING(servername);
	JUMBLE_FIELD(if_not_exists);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterUserMappingStmt(JumbleState *jstate, Node *node)
{
	AlterUserMappingStmt *expr = (AlterUserMappingStmt *) node;

	JUMBLE_NODE(user);
	JUMBLE_STRING(servername);
	JUMBLE_NODE(options);
}

static void
_jumbleDropUserMappingStmt(JumbleState *jstate, Node *node)
{
	DropUserMappingStmt *expr = (DropUserMappingStmt *) node;

	JUMBLE_NODE(user);
	JUMBLE_STRING(servername);
	JUMBLE_FIELD(missing_ok);
}

static void
_jumbleImportForeignSchemaStmt(JumbleState *jstate, Node *node)
{
	ImportForeignSchemaStmt *expr = (ImportForeignSchemaStmt *) node;

	JUMBLE_STRING(server_name);
	JUMBLE_STRING(remote_schema);
	JUMBLE_STRING(local_schema);
	JUMBLE_FIELD(list_type);
	JUMBLE_NODE(table_list);
	JUMBLE_NODE(options);
}

static void
_jumbleCreatePolicyStmt(JumbleState *jstate, Node *node)
{
	CreatePolicyStmt *expr = (CreatePolicyStmt *) node;

	JUMBLE_STRING(policy_name);
	JUMBLE_NODE(table);
	JUMBLE_STRING(cmd_name);
	JUMBLE_FIELD(permissive);
	JUMBLE_NODE(roles);
	JUMBLE_NODE(qual);
	JUMBLE_NODE(with_check);
}

static void
_jumbleAlterPolicyStmt(JumbleState *jstate, Node *node)
{
	AlterPolicyStmt *expr = (AlterPolicyStmt *) node;

	JUMBLE_STRING(policy_name);
	JUMBLE_NODE(table);
	JUMBLE_NODE(roles);
	JUMBLE_NODE(qual);
	JUMBLE_NODE(with_check);
}

static void
_jumbleCreateAmStmt(JumbleState *jstate, Node *node)
{
	CreateAmStmt *expr = (CreateAmStmt *) node;

	JUMBLE_STRING(amname);
	JUMBLE_NODE(handler_name);
	JUMBLE_FIELD(amtype);
}

static void
_jumbleCreateTrigStmt(JumbleState *jstate, Node *node)
{
	CreateTrigStmt *expr = (CreateTrigStmt *) node;

	JUMBLE_FIELD(replace);
	JUMBLE_FIELD(isconstraint);
	JUMBLE_STRING(trigname);
	JUMBLE_NODE(relation);
	JUMBLE_NODE(funcname);
	JUMBLE_NODE(args);
	JUMBLE_FIELD(row);
	JUMBLE_FIELD(timing);
	JUMBLE_FIELD(events);
	JUMBLE_NODE(columns);
	JUMBLE_NODE(whenClause);
	JUMBLE_NODE(transitionRels);
	JUMBLE_FIELD(deferrable);
	JUMBLE_FIELD(initdeferred);
	JUMBLE_NODE(constrrel);
}

static void
_jumbleCreateEventTrigStmt(JumbleState *jstate, Node *node)
{
	CreateEventTrigStmt *expr = (CreateEventTrigStmt *) node;

	JUMBLE_STRING(trigname);
	JUMBLE_STRING(eventname);
	JUMBLE_NODE(whenclause);
	JUMBLE_NODE(funcname);
}

static void
_jumbleAlterEventTrigStmt(JumbleState *jstate, Node *node)
{
	AlterEventTrigStmt *expr = (AlterEventTrigStmt *) node;

	JUMBLE_STRING(trigname);
	JUMBLE_FIELD(tgenabled);
}

static void
_jumbleCreatePLangStmt(JumbleState *jstate, Node *node)
{
	CreatePLangStmt *expr = (CreatePLangStmt *) node;

	JUMBLE_FIELD(replace);
	JUMBLE_STRING(plname);
	JUMBLE_NODE(plhandler);
	JUMBLE_NODE(plinline);
	JUMBLE_NODE(plvalidator);
	JUMBLE_FIELD(pltrusted);
}

static void
_jumbleCreateRoleStmt(JumbleState *jstate, Node *node)
{
	CreateRoleStmt *expr = (CreateRoleStmt *) node;

	JUMBLE_FIELD(stmt_type);
	JUMBLE_STRING(role);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterRoleStmt(JumbleState *jstate, Node *node)
{
	AlterRoleStmt *expr = (AlterRoleStmt *) node;

	JUMBLE_NODE(role);
	JUMBLE_NODE(options);
	JUMBLE_FIELD(action);
}

static void
_jumbleAlterRoleSetStmt(JumbleState *jstate, Node *node)
{
	AlterRoleSetStmt *expr = (AlterRoleSetStmt *) node;

	JUMBLE_NODE(role);
	JUMBLE_STRING(database);
	JUMBLE_NODE(setstmt);
}

static void
_jumbleDropRoleStmt(JumbleState *jstate, Node *node)
{
	DropRoleStmt *expr = (DropRoleStmt *) node;

	JUMBLE_NODE(roles);
	JUMBLE_FIELD(missing_ok);
}

static void
_jumbleCreateSeqStmt(JumbleState *jstate, Node *node)
{
	CreateSeqStmt *expr = (CreateSeqStmt *) node;

	JUMBLE_NODE(sequence);
	JUMBLE_NODE(options);
	JUMBLE_FIELD(ownerId);
	JUMBLE_FIELD(for_identity);
	JUMBLE_FIELD(if_not_exists);
}

static void
_jumbleAlterSeqStmt(JumbleState *jstate, Node *node)
{
	AlterSeqStmt *expr = (AlterSeqStmt *) node;

	JUMBLE_NODE(sequence);
	JUMBLE_NODE(options);
	JUMBLE_FIELD(for_identity);
	JUMBLE_FIELD(missing_ok);
}

static void
_jumbleDefineStmt(JumbleState *jstate, Node *node)
{
	DefineStmt *expr = (DefineStmt *) node;

	JUMBLE_FIELD(kind);
	JUMBLE_FIELD(oldstyle);
	JUMBLE_NODE(defnames);
	JUMBLE_NODE(args);
	JUMBLE_NODE(definition);
	JUMBLE_FIELD(if_not_exists);
	JUMBLE_FIELD(replace);
}

static void
_jumbleCreateDomainStmt(JumbleState *jstate, Node *node)
{
	CreateDomainStmt *expr = (CreateDomainStmt *) node;

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

static void
_jumbleCreateOpClassStmt(JumbleState *jstate, Node *node)
{
	CreateOpClassStmt *expr = (CreateOpClassStmt *) node;

	JUMBLE_NODE(opclassname);
	JUMBLE_NODE(opfamilyname);
	JUMBLE_STRING(amname);
	JUMBLE_NODE(datatype);
	JUMBLE_NODE(items);
	JUMBLE_FIELD(isDefault);
}

static void
_jumbleCreateOpClassItem(JumbleState *jstate, Node *node)
{
	CreateOpClassItem *expr = (CreateOpClassItem *) node;

	JUMBLE_FIELD(itemtype);
	JUMBLE_NODE(name);
	JUMBLE_FIELD(number);
	JUMBLE_NODE(order_family);
	JUMBLE_NODE(class_args);
	JUMBLE_NODE(storedtype);
}

static void
_jumbleCreateOpFamilyStmt(JumbleState *jstate, Node *node)
{
	CreateOpFamilyStmt *expr = (CreateOpFamilyStmt *) node;

	JUMBLE_NODE(opfamilyname);
	JUMBLE_STRING(amname);
}

static void
_jumbleAlterOpFamilyStmt(JumbleState *jstate, Node *node)
{
	AlterOpFamilyStmt *expr = (AlterOpFamilyStmt *) node;

	JUMBLE_NODE(opfamilyname);
	JUMBLE_STRING(amname);
	JUMBLE_FIELD(isDrop);
	JUMBLE_NODE(items);
}

static void
_jumbleDropStmt(JumbleState *jstate, Node *node)
{
	DropStmt *expr = (DropStmt *) node;

	JUMBLE_NODE(objects);
	JUMBLE_FIELD(removeType);
	JUMBLE_FIELD(behavior);
	JUMBLE_FIELD(missing_ok);
	JUMBLE_FIELD(concurrent);
}

static void
_jumbleTruncateStmt(JumbleState *jstate, Node *node)
{
	TruncateStmt *expr = (TruncateStmt *) node;

	JUMBLE_NODE(relations);
	JUMBLE_FIELD(restart_seqs);
	JUMBLE_FIELD(behavior);
}

static void
_jumbleCommentStmt(JumbleState *jstate, Node *node)
{
	CommentStmt *expr = (CommentStmt *) node;

	JUMBLE_FIELD(objtype);
	JUMBLE_NODE(object);
	JUMBLE_STRING(comment);
}

static void
_jumbleSecLabelStmt(JumbleState *jstate, Node *node)
{
	SecLabelStmt *expr = (SecLabelStmt *) node;

	JUMBLE_FIELD(objtype);
	JUMBLE_NODE(object);
	JUMBLE_STRING(provider);
	JUMBLE_STRING(label);
}

static void
_jumbleDeclareCursorStmt(JumbleState *jstate, Node *node)
{
	DeclareCursorStmt *expr = (DeclareCursorStmt *) node;

	JUMBLE_STRING(portalname);
	JUMBLE_FIELD(options);
	JUMBLE_NODE(query);
}

static void
_jumbleClosePortalStmt(JumbleState *jstate, Node *node)
{
	ClosePortalStmt *expr = (ClosePortalStmt *) node;

	JUMBLE_STRING(portalname);
}

static void
_jumbleFetchStmt(JumbleState *jstate, Node *node)
{
	FetchStmt *expr = (FetchStmt *) node;

	JUMBLE_FIELD(direction);
	JUMBLE_FIELD(howMany);
	JUMBLE_STRING(portalname);
	JUMBLE_FIELD(ismove);
}

static void
_jumbleIndexStmt(JumbleState *jstate, Node *node)
{
	IndexStmt *expr = (IndexStmt *) node;

	JUMBLE_STRING(idxname);
	JUMBLE_NODE(relation);
	JUMBLE_STRING(accessMethod);
	JUMBLE_STRING(tableSpace);
	JUMBLE_NODE(indexParams);
	JUMBLE_NODE(indexIncludingParams);
	JUMBLE_NODE(options);
	JUMBLE_NODE(whereClause);
	JUMBLE_NODE(excludeOpNames);
	JUMBLE_STRING(idxcomment);
	JUMBLE_FIELD(indexOid);
	JUMBLE_FIELD(oldNumber);
	JUMBLE_FIELD(oldCreateSubid);
	JUMBLE_FIELD(oldFirstRelfilelocatorSubid);
	JUMBLE_FIELD(unique);
	JUMBLE_FIELD(nulls_not_distinct);
	JUMBLE_FIELD(primary);
	JUMBLE_FIELD(isconstraint);
	JUMBLE_FIELD(iswithoutoverlaps);
	JUMBLE_FIELD(deferrable);
	JUMBLE_FIELD(initdeferred);
	JUMBLE_FIELD(transformed);
	JUMBLE_FIELD(concurrent);
	JUMBLE_FIELD(if_not_exists);
	JUMBLE_FIELD(reset_default_tblspc);
}

static void
_jumbleCreateStatsStmt(JumbleState *jstate, Node *node)
{
	CreateStatsStmt *expr = (CreateStatsStmt *) node;

	JUMBLE_NODE(defnames);
	JUMBLE_NODE(stat_types);
	JUMBLE_NODE(exprs);
	JUMBLE_NODE(relations);
	JUMBLE_STRING(stxcomment);
	JUMBLE_FIELD(transformed);
	JUMBLE_FIELD(if_not_exists);
	JUMBLE_FIELD(owner);
}

static void
_jumbleStatsElem(JumbleState *jstate, Node *node)
{
	StatsElem *expr = (StatsElem *) node;

	JUMBLE_STRING(name);
	JUMBLE_NODE(expr);
}

static void
_jumbleAlterStatsStmt(JumbleState *jstate, Node *node)
{
	AlterStatsStmt *expr = (AlterStatsStmt *) node;

	JUMBLE_NODE(defnames);
	JUMBLE_NODE(stxstattarget);
	JUMBLE_FIELD(missing_ok);
}

static void
_jumbleCreateFunctionStmt(JumbleState *jstate, Node *node)
{
	CreateFunctionStmt *expr = (CreateFunctionStmt *) node;

	JUMBLE_FIELD(is_procedure);
	JUMBLE_FIELD(replace);
	JUMBLE_NODE(funcname);
	JUMBLE_NODE(parameters);
	JUMBLE_NODE(returnType);
	JUMBLE_NODE(options);
	JUMBLE_NODE(sql_body);
}

static void
_jumbleFunctionParameter(JumbleState *jstate, Node *node)
{
	FunctionParameter *expr = (FunctionParameter *) node;

	JUMBLE_STRING(name);
	JUMBLE_NODE(argType);
	JUMBLE_FIELD(mode);
	JUMBLE_NODE(defexpr);
}

static void
_jumbleAlterFunctionStmt(JumbleState *jstate, Node *node)
{
	AlterFunctionStmt *expr = (AlterFunctionStmt *) node;

	JUMBLE_FIELD(objtype);
	JUMBLE_NODE(func);
	JUMBLE_NODE(actions);
}

static void
_jumbleDoStmt(JumbleState *jstate, Node *node)
{
	DoStmt *expr = (DoStmt *) node;

	JUMBLE_NODE(args);
}

static void
_jumbleCallStmt(JumbleState *jstate, Node *node)
{
	CallStmt *expr = (CallStmt *) node;

	JUMBLE_NODE(funcexpr);
	JUMBLE_NODE(outargs);
}

static void
_jumbleRenameStmt(JumbleState *jstate, Node *node)
{
	RenameStmt *expr = (RenameStmt *) node;

	JUMBLE_FIELD(renameType);
	JUMBLE_FIELD(relationType);
	JUMBLE_NODE(relation);
	JUMBLE_NODE(object);
	JUMBLE_STRING(subname);
	JUMBLE_STRING(newname);
	JUMBLE_FIELD(behavior);
	JUMBLE_FIELD(missing_ok);
}

static void
_jumbleAlterObjectDependsStmt(JumbleState *jstate, Node *node)
{
	AlterObjectDependsStmt *expr = (AlterObjectDependsStmt *) node;

	JUMBLE_FIELD(objectType);
	JUMBLE_NODE(relation);
	JUMBLE_NODE(object);
	JUMBLE_NODE(extname);
	JUMBLE_FIELD(remove);
}

static void
_jumbleAlterObjectSchemaStmt(JumbleState *jstate, Node *node)
{
	AlterObjectSchemaStmt *expr = (AlterObjectSchemaStmt *) node;

	JUMBLE_FIELD(objectType);
	JUMBLE_NODE(relation);
	JUMBLE_NODE(object);
	JUMBLE_STRING(newschema);
	JUMBLE_FIELD(missing_ok);
}

static void
_jumbleAlterOwnerStmt(JumbleState *jstate, Node *node)
{
	AlterOwnerStmt *expr = (AlterOwnerStmt *) node;

	JUMBLE_FIELD(objectType);
	JUMBLE_NODE(relation);
	JUMBLE_NODE(object);
	JUMBLE_NODE(newowner);
}

static void
_jumbleAlterOperatorStmt(JumbleState *jstate, Node *node)
{
	AlterOperatorStmt *expr = (AlterOperatorStmt *) node;

	JUMBLE_NODE(opername);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterTypeStmt(JumbleState *jstate, Node *node)
{
	AlterTypeStmt *expr = (AlterTypeStmt *) node;

	JUMBLE_NODE(typeName);
	JUMBLE_NODE(options);
}

static void
_jumbleRuleStmt(JumbleState *jstate, Node *node)
{
	RuleStmt *expr = (RuleStmt *) node;

	JUMBLE_NODE(relation);
	JUMBLE_STRING(rulename);
	JUMBLE_NODE(whereClause);
	JUMBLE_FIELD(event);
	JUMBLE_FIELD(instead);
	JUMBLE_NODE(actions);
	JUMBLE_FIELD(replace);
}

static void
_jumbleNotifyStmt(JumbleState *jstate, Node *node)
{
	NotifyStmt *expr = (NotifyStmt *) node;

	JUMBLE_STRING(conditionname);
	JUMBLE_STRING(payload);
}

static void
_jumbleListenStmt(JumbleState *jstate, Node *node)
{
	ListenStmt *expr = (ListenStmt *) node;

	JUMBLE_STRING(conditionname);
}

static void
_jumbleUnlistenStmt(JumbleState *jstate, Node *node)
{
	UnlistenStmt *expr = (UnlistenStmt *) node;

	JUMBLE_STRING(conditionname);
}

static void
_jumbleTransactionStmt(JumbleState *jstate, Node *node)
{
	TransactionStmt *expr = (TransactionStmt *) node;

	JUMBLE_FIELD(kind);
	JUMBLE_NODE(options);
	JUMBLE_FIELD(chain);
	JUMBLE_LOCATION(location);
}

static void
_jumbleCompositeTypeStmt(JumbleState *jstate, Node *node)
{
	CompositeTypeStmt *expr = (CompositeTypeStmt *) node;

	JUMBLE_NODE(typevar);
	JUMBLE_NODE(coldeflist);
}

static void
_jumbleCreateEnumStmt(JumbleState *jstate, Node *node)
{
	CreateEnumStmt *expr = (CreateEnumStmt *) node;

	JUMBLE_NODE(typeName);
	JUMBLE_NODE(vals);
}

static void
_jumbleCreateRangeStmt(JumbleState *jstate, Node *node)
{
	CreateRangeStmt *expr = (CreateRangeStmt *) node;

	JUMBLE_NODE(typeName);
	JUMBLE_NODE(params);
}

static void
_jumbleAlterEnumStmt(JumbleState *jstate, Node *node)
{
	AlterEnumStmt *expr = (AlterEnumStmt *) node;

	JUMBLE_NODE(typeName);
	JUMBLE_STRING(oldVal);
	JUMBLE_STRING(newVal);
	JUMBLE_STRING(newValNeighbor);
	JUMBLE_FIELD(newValIsAfter);
	JUMBLE_FIELD(skipIfNewValExists);
}

static void
_jumbleViewStmt(JumbleState *jstate, Node *node)
{
	ViewStmt *expr = (ViewStmt *) node;

	JUMBLE_NODE(view);
	JUMBLE_NODE(aliases);
	JUMBLE_NODE(query);
	JUMBLE_FIELD(replace);
	JUMBLE_NODE(options);
	JUMBLE_FIELD(withCheckOption);
}

static void
_jumbleLoadStmt(JumbleState *jstate, Node *node)
{
	LoadStmt *expr = (LoadStmt *) node;

	JUMBLE_STRING(filename);
}

static void
_jumbleCreatedbStmt(JumbleState *jstate, Node *node)
{
	CreatedbStmt *expr = (CreatedbStmt *) node;

	JUMBLE_STRING(dbname);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterDatabaseStmt(JumbleState *jstate, Node *node)
{
	AlterDatabaseStmt *expr = (AlterDatabaseStmt *) node;

	JUMBLE_STRING(dbname);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterDatabaseRefreshCollStmt(JumbleState *jstate, Node *node)
{
	AlterDatabaseRefreshCollStmt *expr = (AlterDatabaseRefreshCollStmt *) node;

	JUMBLE_STRING(dbname);
}

static void
_jumbleAlterDatabaseSetStmt(JumbleState *jstate, Node *node)
{
	AlterDatabaseSetStmt *expr = (AlterDatabaseSetStmt *) node;

	JUMBLE_STRING(dbname);
	JUMBLE_NODE(setstmt);
}

static void
_jumbleDropdbStmt(JumbleState *jstate, Node *node)
{
	DropdbStmt *expr = (DropdbStmt *) node;

	JUMBLE_STRING(dbname);
	JUMBLE_FIELD(missing_ok);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterSystemStmt(JumbleState *jstate, Node *node)
{
	AlterSystemStmt *expr = (AlterSystemStmt *) node;

	JUMBLE_NODE(setstmt);
}

static void
_jumbleClusterStmt(JumbleState *jstate, Node *node)
{
	ClusterStmt *expr = (ClusterStmt *) node;

	JUMBLE_NODE(relation);
	JUMBLE_STRING(indexname);
	JUMBLE_NODE(params);
}

static void
_jumbleVacuumStmt(JumbleState *jstate, Node *node)
{
	VacuumStmt *expr = (VacuumStmt *) node;

	JUMBLE_NODE(options);
	JUMBLE_NODE(rels);
	JUMBLE_FIELD(is_vacuumcmd);
}

static void
_jumbleVacuumRelation(JumbleState *jstate, Node *node)
{
	VacuumRelation *expr = (VacuumRelation *) node;

	JUMBLE_NODE(relation);
	JUMBLE_FIELD(oid);
	JUMBLE_NODE(va_cols);
}

static void
_jumbleExplainStmt(JumbleState *jstate, Node *node)
{
	ExplainStmt *expr = (ExplainStmt *) node;

	JUMBLE_NODE(query);
	JUMBLE_NODE(options);
}

static void
_jumbleCreateTableAsStmt(JumbleState *jstate, Node *node)
{
	CreateTableAsStmt *expr = (CreateTableAsStmt *) node;

	JUMBLE_NODE(query);
	JUMBLE_NODE(into);
	JUMBLE_FIELD(objtype);
	JUMBLE_FIELD(is_select_into);
	JUMBLE_FIELD(if_not_exists);
}

static void
_jumbleRefreshMatViewStmt(JumbleState *jstate, Node *node)
{
	RefreshMatViewStmt *expr = (RefreshMatViewStmt *) node;

	JUMBLE_FIELD(concurrent);
	JUMBLE_FIELD(skipData);
	JUMBLE_NODE(relation);
}

static void
_jumbleCheckPointStmt(JumbleState *jstate, Node *node)
{
	CheckPointStmt *expr = (CheckPointStmt *) node;

	(void) expr;
}

static void
_jumbleDiscardStmt(JumbleState *jstate, Node *node)
{
	DiscardStmt *expr = (DiscardStmt *) node;

	JUMBLE_FIELD(target);
}

static void
_jumbleLockStmt(JumbleState *jstate, Node *node)
{
	LockStmt *expr = (LockStmt *) node;

	JUMBLE_NODE(relations);
	JUMBLE_FIELD(mode);
	JUMBLE_FIELD(nowait);
}

static void
_jumbleConstraintsSetStmt(JumbleState *jstate, Node *node)
{
	ConstraintsSetStmt *expr = (ConstraintsSetStmt *) node;

	JUMBLE_NODE(constraints);
	JUMBLE_FIELD(deferred);
}

static void
_jumbleReindexStmt(JumbleState *jstate, Node *node)
{
	ReindexStmt *expr = (ReindexStmt *) node;

	JUMBLE_FIELD(kind);
	JUMBLE_NODE(relation);
	JUMBLE_STRING(name);
	JUMBLE_NODE(params);
}

static void
_jumbleCreateConversionStmt(JumbleState *jstate, Node *node)
{
	CreateConversionStmt *expr = (CreateConversionStmt *) node;

	JUMBLE_NODE(conversion_name);
	JUMBLE_STRING(for_encoding_name);
	JUMBLE_STRING(to_encoding_name);
	JUMBLE_NODE(func_name);
	JUMBLE_FIELD(def);
}

static void
_jumbleCreateCastStmt(JumbleState *jstate, Node *node)
{
	CreateCastStmt *expr = (CreateCastStmt *) node;

	JUMBLE_NODE(sourcetype);
	JUMBLE_NODE(targettype);
	JUMBLE_NODE(func);
	JUMBLE_FIELD(context);
	JUMBLE_FIELD(inout);
}

static void
_jumbleCreateTransformStmt(JumbleState *jstate, Node *node)
{
	CreateTransformStmt *expr = (CreateTransformStmt *) node;

	JUMBLE_FIELD(replace);
	JUMBLE_NODE(type_name);
	JUMBLE_STRING(lang);
	JUMBLE_NODE(fromsql);
	JUMBLE_NODE(tosql);
}

static void
_jumblePrepareStmt(JumbleState *jstate, Node *node)
{
	PrepareStmt *expr = (PrepareStmt *) node;

	JUMBLE_STRING(name);
	JUMBLE_NODE(argtypes);
	JUMBLE_NODE(query);
}

static void
_jumbleExecuteStmt(JumbleState *jstate, Node *node)
{
	ExecuteStmt *expr = (ExecuteStmt *) node;

	JUMBLE_STRING(name);
	JUMBLE_NODE(params);
}

static void
_jumbleDeallocateStmt(JumbleState *jstate, Node *node)
{
	DeallocateStmt *expr = (DeallocateStmt *) node;

	JUMBLE_FIELD(isall);
	JUMBLE_LOCATION(location);
}

static void
_jumbleDropOwnedStmt(JumbleState *jstate, Node *node)
{
	DropOwnedStmt *expr = (DropOwnedStmt *) node;

	JUMBLE_NODE(roles);
	JUMBLE_FIELD(behavior);
}

static void
_jumbleReassignOwnedStmt(JumbleState *jstate, Node *node)
{
	ReassignOwnedStmt *expr = (ReassignOwnedStmt *) node;

	JUMBLE_NODE(roles);
	JUMBLE_NODE(newrole);
}

static void
_jumbleAlterTSDictionaryStmt(JumbleState *jstate, Node *node)
{
	AlterTSDictionaryStmt *expr = (AlterTSDictionaryStmt *) node;

	JUMBLE_NODE(dictname);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterTSConfigurationStmt(JumbleState *jstate, Node *node)
{
	AlterTSConfigurationStmt *expr = (AlterTSConfigurationStmt *) node;

	JUMBLE_FIELD(kind);
	JUMBLE_NODE(cfgname);
	JUMBLE_NODE(tokentype);
	JUMBLE_NODE(dicts);
	JUMBLE_FIELD(override);
	JUMBLE_FIELD(replace);
	JUMBLE_FIELD(missing_ok);
}

static void
_jumblePublicationTable(JumbleState *jstate, Node *node)
{
	PublicationTable *expr = (PublicationTable *) node;

	JUMBLE_NODE(relation);
	JUMBLE_NODE(whereClause);
	JUMBLE_NODE(columns);
}

static void
_jumblePublicationObjSpec(JumbleState *jstate, Node *node)
{
	PublicationObjSpec *expr = (PublicationObjSpec *) node;

	JUMBLE_FIELD(pubobjtype);
	JUMBLE_STRING(name);
	JUMBLE_NODE(pubtable);
}

static void
_jumbleCreatePublicationStmt(JumbleState *jstate, Node *node)
{
	CreatePublicationStmt *expr = (CreatePublicationStmt *) node;

	JUMBLE_STRING(pubname);
	JUMBLE_NODE(options);
	JUMBLE_NODE(pubobjects);
	JUMBLE_FIELD(for_all_tables);
}

static void
_jumbleAlterPublicationStmt(JumbleState *jstate, Node *node)
{
	AlterPublicationStmt *expr = (AlterPublicationStmt *) node;

	JUMBLE_STRING(pubname);
	JUMBLE_NODE(options);
	JUMBLE_NODE(pubobjects);
	JUMBLE_FIELD(for_all_tables);
	JUMBLE_FIELD(action);
}

static void
_jumbleCreateSubscriptionStmt(JumbleState *jstate, Node *node)
{
	CreateSubscriptionStmt *expr = (CreateSubscriptionStmt *) node;

	JUMBLE_STRING(subname);
	JUMBLE_STRING(conninfo);
	JUMBLE_NODE(publication);
	JUMBLE_NODE(options);
}

static void
_jumbleAlterSubscriptionStmt(JumbleState *jstate, Node *node)
{
	AlterSubscriptionStmt *expr = (AlterSubscriptionStmt *) node;

	JUMBLE_FIELD(kind);
	JUMBLE_STRING(subname);
	JUMBLE_STRING(conninfo);
	JUMBLE_NODE(publication);
	JUMBLE_NODE(options);
}

static void
_jumbleDropSubscriptionStmt(JumbleState *jstate, Node *node)
{
	DropSubscriptionStmt *expr = (DropSubscriptionStmt *) node;

	JUMBLE_STRING(subname);
	JUMBLE_FIELD(missing_ok);
	JUMBLE_FIELD(behavior);
}

static void
_jumbleGroupByOrdering(JumbleState *jstate, Node *node)
{
	GroupByOrdering *expr = (GroupByOrdering *) node;

	JUMBLE_NODE(pathkeys);
	JUMBLE_NODE(clauses);
}

static void
_jumbleExtensibleNode(JumbleState *jstate, Node *node)
{
	ExtensibleNode *expr = (ExtensibleNode *) node;

	JUMBLE_STRING(extnodename);
}

static void
_jumbleInteger(JumbleState *jstate, Node *node)
{
	Integer *expr = (Integer *) node;

	JUMBLE_FIELD(ival);
}

static void
_jumbleFloat(JumbleState *jstate, Node *node)
{
	Float *expr = (Float *) node;

	JUMBLE_STRING(fval);
}

static void
_jumbleBoolean(JumbleState *jstate, Node *node)
{
	Boolean *expr = (Boolean *) node;

	JUMBLE_FIELD(boolval);
}

static void
_jumbleString(JumbleState *jstate, Node *node)
{
	String *expr = (String *) node;

	JUMBLE_STRING(sval);
}

static void
_jumbleBitString(JumbleState *jstate, Node *node)
{
	BitString *expr = (BitString *) node;

	JUMBLE_STRING(bsval);
}
