LCOV - code coverage report
Current view: top level - src/backend/nodes - queryjumblefuncs.funcs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 1730 1858 93.1 %
Date: 2025-04-01 15:15:16 Functions: 243 264 92.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * queryjumblefuncs.funcs.c
       4             :  *    Generated node infrastructure code
       5             :  *
       6             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * NOTES
      10             :  *  ******************************
      11             :  *  *** DO NOT EDIT THIS FILE! ***
      12             :  *  ******************************
      13             :  *
      14             :  *  It has been GENERATED by src/backend/nodes/gen_node_support.pl
      15             :  *
      16             :  *-------------------------------------------------------------------------
      17             :  */
      18             : #include "access/amapi.h"
      19             : #include "access/cmptype.h"
      20             : #include "access/sdir.h"
      21             : #include "access/tableam.h"
      22             : #include "access/tsmapi.h"
      23             : #include "commands/event_trigger.h"
      24             : #include "commands/trigger.h"
      25             : #include "executor/tuptable.h"
      26             : #include "foreign/fdwapi.h"
      27             : #include "nodes/bitmapset.h"
      28             : #include "nodes/execnodes.h"
      29             : #include "nodes/extensible.h"
      30             : #include "nodes/lockoptions.h"
      31             : #include "nodes/miscnodes.h"
      32             : #include "nodes/nodes.h"
      33             : #include "nodes/parsenodes.h"
      34             : #include "nodes/pathnodes.h"
      35             : #include "nodes/plannodes.h"
      36             : #include "nodes/primnodes.h"
      37             : #include "nodes/replnodes.h"
      38             : #include "nodes/supportnodes.h"
      39             : #include "nodes/value.h"
      40             : #include "utils/rel.h"
      41             : 
      42             : static void
      43         510 : _jumbleAlias(JumbleState *jstate, Node *node)
      44             : {
      45         510 :     Alias *expr = (Alias *) node;
      46             : 
      47         510 :     JUMBLE_STRING(aliasname);
      48         510 :     JUMBLE_NODE(colnames);
      49         510 : }
      50             : 
      51             : static void
      52       33616 : _jumbleRangeVar(JumbleState *jstate, Node *node)
      53             : {
      54       33616 :     RangeVar *expr = (RangeVar *) node;
      55             : 
      56       33616 :     JUMBLE_STRING(catalogname);
      57       33616 :     JUMBLE_STRING(schemaname);
      58       33616 :     JUMBLE_STRING(relname);
      59       33616 :     JUMBLE_FIELD(inh);
      60       33616 :     JUMBLE_FIELD(relpersistence);
      61       33616 :     JUMBLE_NODE(alias);
      62       33616 : }
      63             : 
      64             : static void
      65         226 : _jumbleTableFunc(JumbleState *jstate, Node *node)
      66             : {
      67         226 :     TableFunc *expr = (TableFunc *) node;
      68             : 
      69         226 :     JUMBLE_FIELD(functype);
      70         226 :     JUMBLE_NODE(docexpr);
      71         226 :     JUMBLE_NODE(rowexpr);
      72         226 :     JUMBLE_NODE(colexprs);
      73         226 : }
      74             : 
      75             : static void
      76         614 : _jumbleIntoClause(JumbleState *jstate, Node *node)
      77             : {
      78         614 :     IntoClause *expr = (IntoClause *) node;
      79             : 
      80         614 :     JUMBLE_NODE(rel);
      81         614 :     JUMBLE_NODE(colNames);
      82         614 :     JUMBLE_STRING(accessMethod);
      83         614 :     JUMBLE_NODE(options);
      84         614 :     JUMBLE_FIELD(onCommit);
      85         614 :     JUMBLE_STRING(tableSpaceName);
      86         614 :     JUMBLE_FIELD(skipData);
      87         614 : }
      88             : 
      89             : static void
      90      428414 : _jumbleVar(JumbleState *jstate, Node *node)
      91             : {
      92      428414 :     Var *expr = (Var *) node;
      93             : 
      94      428414 :     JUMBLE_FIELD(varno);
      95      428414 :     JUMBLE_FIELD(varattno);
      96      428414 :     JUMBLE_FIELD(varlevelsup);
      97      428414 :     JUMBLE_FIELD(varreturningtype);
      98      428414 : }
      99             : 
     100             : static void
     101      213734 : _jumbleConst(JumbleState *jstate, Node *node)
     102             : {
     103      213734 :     Const *expr = (Const *) node;
     104             : 
     105      213734 :     JUMBLE_FIELD(consttype);
     106      213734 :     JUMBLE_LOCATION(location);
     107      213734 : }
     108             : 
     109             : static void
     110       10558 : _jumbleParam(JumbleState *jstate, Node *node)
     111             : {
     112       10558 :     Param *expr = (Param *) node;
     113             : 
     114       10558 :     JUMBLE_FIELD(paramkind);
     115       10558 :     JUMBLE_FIELD(paramid);
     116       10558 :     JUMBLE_FIELD(paramtype);
     117       10558 : }
     118             : 
     119             : static void
     120       13744 : _jumbleAggref(JumbleState *jstate, Node *node)
     121             : {
     122       13744 :     Aggref *expr = (Aggref *) node;
     123             : 
     124       13744 :     JUMBLE_FIELD(aggfnoid);
     125       13744 :     JUMBLE_NODE(aggdirectargs);
     126       13744 :     JUMBLE_NODE(args);
     127       13744 :     JUMBLE_NODE(aggorder);
     128       13744 :     JUMBLE_NODE(aggdistinct);
     129       13744 :     JUMBLE_NODE(aggfilter);
     130       13744 : }
     131             : 
     132             : static void
     133         152 : _jumbleGroupingFunc(JumbleState *jstate, Node *node)
     134             : {
     135         152 :     GroupingFunc *expr = (GroupingFunc *) node;
     136             : 
     137         152 :     JUMBLE_NODE(refs);
     138         152 :     JUMBLE_FIELD(agglevelsup);
     139         152 : }
     140             : 
     141             : static void
     142        1310 : _jumbleWindowFunc(JumbleState *jstate, Node *node)
     143             : {
     144        1310 :     WindowFunc *expr = (WindowFunc *) node;
     145             : 
     146        1310 :     JUMBLE_FIELD(winfnoid);
     147        1310 :     JUMBLE_NODE(args);
     148        1310 :     JUMBLE_NODE(aggfilter);
     149        1310 :     JUMBLE_FIELD(winref);
     150        1310 : }
     151             : 
     152             : static void
     153           0 : _jumbleWindowFuncRunCondition(JumbleState *jstate, Node *node)
     154             : {
     155           0 :     WindowFuncRunCondition *expr = (WindowFuncRunCondition *) node;
     156             : 
     157           0 :     JUMBLE_FIELD(opno);
     158           0 :     JUMBLE_FIELD(wfunc_left);
     159           0 :     JUMBLE_NODE(arg);
     160           0 : }
     161             : 
     162             : static void
     163          60 : _jumbleMergeSupportFunc(JumbleState *jstate, Node *node)
     164             : {
     165          60 :     MergeSupportFunc *expr = (MergeSupportFunc *) node;
     166             : 
     167          60 :     JUMBLE_FIELD(msftype);
     168          60 :     JUMBLE_FIELD(msfcollid);
     169          60 : }
     170             : 
     171             : static void
     172        2910 : _jumbleSubscriptingRef(JumbleState *jstate, Node *node)
     173             : {
     174        2910 :     SubscriptingRef *expr = (SubscriptingRef *) node;
     175             : 
     176        2910 :     JUMBLE_NODE(refupperindexpr);
     177        2910 :     JUMBLE_NODE(reflowerindexpr);
     178        2910 :     JUMBLE_NODE(refexpr);
     179        2910 :     JUMBLE_NODE(refassgnexpr);
     180        2910 : }
     181             : 
     182             : static void
     183       71652 : _jumbleFuncExpr(JumbleState *jstate, Node *node)
     184             : {
     185       71652 :     FuncExpr *expr = (FuncExpr *) node;
     186             : 
     187       71652 :     JUMBLE_FIELD(funcid);
     188       71652 :     JUMBLE_NODE(args);
     189       71652 : }
     190             : 
     191             : static void
     192         466 : _jumbleNamedArgExpr(JumbleState *jstate, Node *node)
     193             : {
     194         466 :     NamedArgExpr *expr = (NamedArgExpr *) node;
     195             : 
     196         466 :     JUMBLE_NODE(arg);
     197         466 :     JUMBLE_FIELD(argnumber);
     198         466 : }
     199             : 
     200             : static void
     201      127420 : _jumbleOpExpr(JumbleState *jstate, Node *node)
     202             : {
     203      127420 :     OpExpr *expr = (OpExpr *) node;
     204             : 
     205      127420 :     JUMBLE_FIELD(opno);
     206      127420 :     JUMBLE_NODE(args);
     207      127420 : }
     208             : 
     209             : static void
     210         122 : _jumbleDistinctExpr(JumbleState *jstate, Node *node)
     211             : {
     212         122 :     DistinctExpr *expr = (DistinctExpr *) node;
     213             : 
     214         122 :     JUMBLE_FIELD(opno);
     215         122 :     JUMBLE_NODE(args);
     216         122 : }
     217             : 
     218             : static void
     219          52 : _jumbleNullIfExpr(JumbleState *jstate, Node *node)
     220             : {
     221          52 :     NullIfExpr *expr = (NullIfExpr *) node;
     222             : 
     223          52 :     JUMBLE_FIELD(opno);
     224          52 :     JUMBLE_NODE(args);
     225          52 : }
     226             : 
     227             : static void
     228        7004 : _jumbleScalarArrayOpExpr(JumbleState *jstate, Node *node)
     229             : {
     230        7004 :     ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
     231             : 
     232        7004 :     JUMBLE_FIELD(opno);
     233        7004 :     JUMBLE_FIELD(useOr);
     234        7004 :     JUMBLE_NODE(args);
     235        7004 : }
     236             : 
     237             : static void
     238       30012 : _jumbleBoolExpr(JumbleState *jstate, Node *node)
     239             : {
     240       30012 :     BoolExpr *expr = (BoolExpr *) node;
     241             : 
     242       30012 :     JUMBLE_FIELD(boolop);
     243       30012 :     JUMBLE_NODE(args);
     244       30012 : }
     245             : 
     246             : static void
     247       10440 : _jumbleSubLink(JumbleState *jstate, Node *node)
     248             : {
     249       10440 :     SubLink *expr = (SubLink *) node;
     250             : 
     251       10440 :     JUMBLE_FIELD(subLinkType);
     252       10440 :     JUMBLE_FIELD(subLinkId);
     253       10440 :     JUMBLE_NODE(testexpr);
     254       10440 :     JUMBLE_NODE(subselect);
     255       10440 : }
     256             : 
     257             : static void
     258         748 : _jumbleFieldSelect(JumbleState *jstate, Node *node)
     259             : {
     260         748 :     FieldSelect *expr = (FieldSelect *) node;
     261             : 
     262         748 :     JUMBLE_NODE(arg);
     263         748 :     JUMBLE_FIELD(fieldnum);
     264         748 : }
     265             : 
     266             : static void
     267         174 : _jumbleFieldStore(JumbleState *jstate, Node *node)
     268             : {
     269         174 :     FieldStore *expr = (FieldStore *) node;
     270             : 
     271         174 :     JUMBLE_NODE(arg);
     272         174 :     JUMBLE_NODE(newvals);
     273         174 : }
     274             : 
     275             : static void
     276       29410 : _jumbleRelabelType(JumbleState *jstate, Node *node)
     277             : {
     278       29410 :     RelabelType *expr = (RelabelType *) node;
     279             : 
     280       29410 :     JUMBLE_NODE(arg);
     281       29410 :     JUMBLE_FIELD(resulttype);
     282       29410 : }
     283             : 
     284             : static void
     285        5496 : _jumbleCoerceViaIO(JumbleState *jstate, Node *node)
     286             : {
     287        5496 :     CoerceViaIO *expr = (CoerceViaIO *) node;
     288             : 
     289        5496 :     JUMBLE_NODE(arg);
     290        5496 :     JUMBLE_FIELD(resulttype);
     291        5496 : }
     292             : 
     293             : static void
     294        1358 : _jumbleArrayCoerceExpr(JumbleState *jstate, Node *node)
     295             : {
     296        1358 :     ArrayCoerceExpr *expr = (ArrayCoerceExpr *) node;
     297             : 
     298        1358 :     JUMBLE_NODE(arg);
     299        1358 :     JUMBLE_NODE(elemexpr);
     300        1358 :     JUMBLE_FIELD(resulttype);
     301        1358 : }
     302             : 
     303             : static void
     304          28 : _jumbleConvertRowtypeExpr(JumbleState *jstate, Node *node)
     305             : {
     306          28 :     ConvertRowtypeExpr *expr = (ConvertRowtypeExpr *) node;
     307             : 
     308          28 :     JUMBLE_NODE(arg);
     309          28 :     JUMBLE_FIELD(resulttype);
     310          28 : }
     311             : 
     312             : static void
     313        2908 : _jumbleCollateExpr(JumbleState *jstate, Node *node)
     314             : {
     315        2908 :     CollateExpr *expr = (CollateExpr *) node;
     316             : 
     317        2908 :     JUMBLE_NODE(arg);
     318        2908 :     JUMBLE_FIELD(collOid);
     319        2908 : }
     320             : 
     321             : static void
     322        6574 : _jumbleCaseExpr(JumbleState *jstate, Node *node)
     323             : {
     324        6574 :     CaseExpr *expr = (CaseExpr *) node;
     325             : 
     326        6574 :     JUMBLE_NODE(arg);
     327        6574 :     JUMBLE_NODE(args);
     328        6574 :     JUMBLE_NODE(defresult);
     329        6574 : }
     330             : 
     331             : static void
     332       10716 : _jumbleCaseWhen(JumbleState *jstate, Node *node)
     333             : {
     334       10716 :     CaseWhen *expr = (CaseWhen *) node;
     335             : 
     336       10716 :     JUMBLE_NODE(expr);
     337       10716 :     JUMBLE_NODE(result);
     338       10716 : }
     339             : 
     340             : static void
     341        7004 : _jumbleCaseTestExpr(JumbleState *jstate, Node *node)
     342             : {
     343        7004 :     CaseTestExpr *expr = (CaseTestExpr *) node;
     344             : 
     345        7004 :     JUMBLE_FIELD(typeId);
     346        7004 : }
     347             : 
     348             : static void
     349        4656 : _jumbleArrayExpr(JumbleState *jstate, Node *node)
     350             : {
     351        4656 :     ArrayExpr *expr = (ArrayExpr *) node;
     352             : 
     353        4656 :     JUMBLE_ELEMENTS(elements);
     354        4656 : }
     355             : 
     356             : static void
     357        1140 : _jumbleRowExpr(JumbleState *jstate, Node *node)
     358             : {
     359        1140 :     RowExpr *expr = (RowExpr *) node;
     360             : 
     361        1140 :     JUMBLE_NODE(args);
     362        1140 : }
     363             : 
     364             : static void
     365          98 : _jumbleRowCompareExpr(JumbleState *jstate, Node *node)
     366             : {
     367          98 :     RowCompareExpr *expr = (RowCompareExpr *) node;
     368             : 
     369          98 :     JUMBLE_FIELD(cmptype);
     370          98 :     JUMBLE_NODE(largs);
     371          98 :     JUMBLE_NODE(rargs);
     372          98 : }
     373             : 
     374             : static void
     375         458 : _jumbleCoalesceExpr(JumbleState *jstate, Node *node)
     376             : {
     377         458 :     CoalesceExpr *expr = (CoalesceExpr *) node;
     378             : 
     379         458 :     JUMBLE_NODE(args);
     380         458 : }
     381             : 
     382             : static void
     383          88 : _jumbleMinMaxExpr(JumbleState *jstate, Node *node)
     384             : {
     385          88 :     MinMaxExpr *expr = (MinMaxExpr *) node;
     386             : 
     387          88 :     JUMBLE_FIELD(op);
     388          88 :     JUMBLE_NODE(args);
     389          88 : }
     390             : 
     391             : static void
     392         506 : _jumbleSQLValueFunction(JumbleState *jstate, Node *node)
     393             : {
     394         506 :     SQLValueFunction *expr = (SQLValueFunction *) node;
     395             : 
     396         506 :     JUMBLE_FIELD(op);
     397         506 :     JUMBLE_FIELD(typmod);
     398         506 : }
     399             : 
     400             : static void
     401         270 : _jumbleXmlExpr(JumbleState *jstate, Node *node)
     402             : {
     403         270 :     XmlExpr *expr = (XmlExpr *) node;
     404             : 
     405         270 :     JUMBLE_FIELD(op);
     406         270 :     JUMBLE_NODE(named_args);
     407         270 :     JUMBLE_NODE(args);
     408         270 :     JUMBLE_FIELD(indent);
     409         270 : }
     410             : 
     411             : static void
     412        2168 : _jumbleJsonFormat(JumbleState *jstate, Node *node)
     413             : {
     414        2168 :     JsonFormat *expr = (JsonFormat *) node;
     415             : 
     416        2168 :     JUMBLE_FIELD(format_type);
     417        2168 :     JUMBLE_FIELD(encoding);
     418        2168 : }
     419             : 
     420             : static void
     421        1092 : _jumbleJsonReturning(JumbleState *jstate, Node *node)
     422             : {
     423        1092 :     JsonReturning *expr = (JsonReturning *) node;
     424             : 
     425        1092 :     JUMBLE_NODE(format);
     426        1092 :     JUMBLE_FIELD(typid);
     427        1092 :     JUMBLE_FIELD(typmod);
     428        1092 : }
     429             : 
     430             : static void
     431         390 : _jumbleJsonValueExpr(JumbleState *jstate, Node *node)
     432             : {
     433         390 :     JsonValueExpr *expr = (JsonValueExpr *) node;
     434             : 
     435         390 :     JUMBLE_NODE(raw_expr);
     436         390 :     JUMBLE_NODE(formatted_expr);
     437         390 :     JUMBLE_NODE(format);
     438         390 : }
     439             : 
     440             : static void
     441         480 : _jumbleJsonConstructorExpr(JumbleState *jstate, Node *node)
     442             : {
     443         480 :     JsonConstructorExpr *expr = (JsonConstructorExpr *) node;
     444             : 
     445         480 :     JUMBLE_FIELD(type);
     446         480 :     JUMBLE_NODE(args);
     447         480 :     JUMBLE_NODE(func);
     448         480 :     JUMBLE_NODE(coercion);
     449         480 :     JUMBLE_NODE(returning);
     450         480 :     JUMBLE_FIELD(absent_on_null);
     451         480 :     JUMBLE_FIELD(unique);
     452         480 : }
     453             : 
     454             : static void
     455         120 : _jumbleJsonIsPredicate(JumbleState *jstate, Node *node)
     456             : {
     457         120 :     JsonIsPredicate *expr = (JsonIsPredicate *) node;
     458             : 
     459         120 :     JUMBLE_NODE(expr);
     460         120 :     JUMBLE_NODE(format);
     461         120 :     JUMBLE_FIELD(item_type);
     462         120 :     JUMBLE_FIELD(unique_keys);
     463         120 : }
     464             : 
     465             : static void
     466        1018 : _jumbleJsonBehavior(JumbleState *jstate, Node *node)
     467             : {
     468        1018 :     JsonBehavior *expr = (JsonBehavior *) node;
     469             : 
     470        1018 :     JUMBLE_FIELD(btype);
     471        1018 :     JUMBLE_NODE(expr);
     472        1018 :     JUMBLE_FIELD(coerce);
     473        1018 : }
     474             : 
     475             : static void
     476         598 : _jumbleJsonExpr(JumbleState *jstate, Node *node)
     477             : {
     478         598 :     JsonExpr *expr = (JsonExpr *) node;
     479             : 
     480         598 :     JUMBLE_FIELD(op);
     481         598 :     JUMBLE_STRING(column_name);
     482         598 :     JUMBLE_NODE(formatted_expr);
     483         598 :     JUMBLE_NODE(format);
     484         598 :     JUMBLE_NODE(path_spec);
     485         598 :     JUMBLE_NODE(returning);
     486         598 :     JUMBLE_NODE(passing_names);
     487         598 :     JUMBLE_NODE(passing_values);
     488         598 :     JUMBLE_NODE(on_empty);
     489         598 :     JUMBLE_NODE(on_error);
     490         598 :     JUMBLE_FIELD(use_io_coercion);
     491         598 :     JUMBLE_FIELD(use_json_coercion);
     492         598 :     JUMBLE_FIELD(wrapper);
     493         598 :     JUMBLE_FIELD(omit_quotes);
     494         598 :     JUMBLE_FIELD(collation);
     495         598 : }
     496             : 
     497             : static void
     498           0 : _jumbleJsonTablePath(JumbleState *jstate, Node *node)
     499             : {
     500           0 :     JsonTablePath *expr = (JsonTablePath *) node;
     501             : 
     502           0 :     JUMBLE_NODE(value);
     503           0 :     JUMBLE_STRING(name);
     504           0 : }
     505             : 
     506             : static void
     507           0 : _jumbleJsonTablePathScan(JumbleState *jstate, Node *node)
     508             : {
     509           0 :     JsonTablePathScan *expr = (JsonTablePathScan *) node;
     510             : 
     511           0 :     JUMBLE_NODE(path);
     512           0 :     JUMBLE_FIELD(errorOnError);
     513           0 :     JUMBLE_NODE(child);
     514           0 :     JUMBLE_FIELD(colMin);
     515           0 :     JUMBLE_FIELD(colMax);
     516           0 : }
     517             : 
     518             : static void
     519           0 : _jumbleJsonTableSiblingJoin(JumbleState *jstate, Node *node)
     520             : {
     521           0 :     JsonTableSiblingJoin *expr = (JsonTableSiblingJoin *) node;
     522             : 
     523           0 :     JUMBLE_NODE(lplan);
     524           0 :     JUMBLE_NODE(rplan);
     525           0 : }
     526             : 
     527             : static void
     528        3844 : _jumbleNullTest(JumbleState *jstate, Node *node)
     529             : {
     530        3844 :     NullTest *expr = (NullTest *) node;
     531             : 
     532        3844 :     JUMBLE_NODE(arg);
     533        3844 :     JUMBLE_FIELD(nulltesttype);
     534        3844 : }
     535             : 
     536             : static void
     537         214 : _jumbleBooleanTest(JumbleState *jstate, Node *node)
     538             : {
     539         214 :     BooleanTest *expr = (BooleanTest *) node;
     540             : 
     541         214 :     JUMBLE_NODE(arg);
     542         214 :     JUMBLE_FIELD(booltesttype);
     543         214 : }
     544             : 
     545             : static void
     546         990 : _jumbleMergeAction(JumbleState *jstate, Node *node)
     547             : {
     548         990 :     MergeAction *expr = (MergeAction *) node;
     549             : 
     550         990 :     JUMBLE_FIELD(matchKind);
     551         990 :     JUMBLE_FIELD(commandType);
     552         990 :     JUMBLE_NODE(qual);
     553         990 :     JUMBLE_NODE(targetList);
     554         990 : }
     555             : 
     556             : static void
     557         710 : _jumbleCoerceToDomain(JumbleState *jstate, Node *node)
     558             : {
     559         710 :     CoerceToDomain *expr = (CoerceToDomain *) node;
     560             : 
     561         710 :     JUMBLE_NODE(arg);
     562         710 :     JUMBLE_FIELD(resulttype);
     563         710 : }
     564             : 
     565             : static void
     566           0 : _jumbleCoerceToDomainValue(JumbleState *jstate, Node *node)
     567             : {
     568           0 :     CoerceToDomainValue *expr = (CoerceToDomainValue *) node;
     569             : 
     570           0 :     JUMBLE_FIELD(typeId);
     571           0 : }
     572             : 
     573             : static void
     574         440 : _jumbleSetToDefault(JumbleState *jstate, Node *node)
     575             : {
     576         440 :     SetToDefault *expr = (SetToDefault *) node;
     577             : 
     578         440 :     JUMBLE_FIELD(typeId);
     579         440 : }
     580             : 
     581             : static void
     582          92 : _jumbleCurrentOfExpr(JumbleState *jstate, Node *node)
     583             : {
     584          92 :     CurrentOfExpr *expr = (CurrentOfExpr *) node;
     585             : 
     586          92 :     JUMBLE_FIELD(cvarno);
     587          92 :     JUMBLE_STRING(cursor_name);
     588          92 :     JUMBLE_FIELD(cursor_param);
     589          92 : }
     590             : 
     591             : static void
     592           0 : _jumbleNextValueExpr(JumbleState *jstate, Node *node)
     593             : {
     594           0 :     NextValueExpr *expr = (NextValueExpr *) node;
     595             : 
     596           0 :     JUMBLE_FIELD(seqid);
     597           0 :     JUMBLE_FIELD(typeId);
     598           0 : }
     599             : 
     600             : static void
     601         688 : _jumbleInferenceElem(JumbleState *jstate, Node *node)
     602             : {
     603         688 :     InferenceElem *expr = (InferenceElem *) node;
     604             : 
     605         688 :     JUMBLE_NODE(expr);
     606         688 :     JUMBLE_FIELD(infercollid);
     607         688 :     JUMBLE_FIELD(inferopclass);
     608         688 : }
     609             : 
     610             : static void
     611           0 : _jumbleReturningExpr(JumbleState *jstate, Node *node)
     612             : {
     613           0 :     ReturningExpr *expr = (ReturningExpr *) node;
     614             : 
     615           0 :     JUMBLE_FIELD(retlevelsup);
     616           0 :     JUMBLE_FIELD(retold);
     617           0 :     JUMBLE_NODE(retexpr);
     618           0 : }
     619             : 
     620             : static void
     621      334126 : _jumbleTargetEntry(JumbleState *jstate, Node *node)
     622             : {
     623      334126 :     TargetEntry *expr = (TargetEntry *) node;
     624             : 
     625      334126 :     JUMBLE_NODE(expr);
     626      334126 :     JUMBLE_FIELD(resno);
     627      334126 :     JUMBLE_FIELD(ressortgroupref);
     628      334126 : }
     629             : 
     630             : static void
     631      118012 : _jumbleRangeTblRef(JumbleState *jstate, Node *node)
     632             : {
     633      118012 :     RangeTblRef *expr = (RangeTblRef *) node;
     634             : 
     635      118012 :     JUMBLE_FIELD(rtindex);
     636      118012 : }
     637             : 
     638             : static void
     639       20426 : _jumbleJoinExpr(JumbleState *jstate, Node *node)
     640             : {
     641       20426 :     JoinExpr *expr = (JoinExpr *) node;
     642             : 
     643       20426 :     JUMBLE_FIELD(jointype);
     644       20426 :     JUMBLE_FIELD(isNatural);
     645       20426 :     JUMBLE_NODE(larg);
     646       20426 :     JUMBLE_NODE(rarg);
     647       20426 :     JUMBLE_NODE(quals);
     648       20426 :     JUMBLE_FIELD(rtindex);
     649       20426 : }
     650             : 
     651             : static void
     652      122540 : _jumbleFromExpr(JumbleState *jstate, Node *node)
     653             : {
     654      122540 :     FromExpr *expr = (FromExpr *) node;
     655             : 
     656      122540 :     JUMBLE_NODE(fromlist);
     657      122540 :     JUMBLE_NODE(quals);
     658      122540 : }
     659             : 
     660             : static void
     661         592 : _jumbleOnConflictExpr(JumbleState *jstate, Node *node)
     662             : {
     663         592 :     OnConflictExpr *expr = (OnConflictExpr *) node;
     664             : 
     665         592 :     JUMBLE_FIELD(action);
     666         592 :     JUMBLE_NODE(arbiterElems);
     667         592 :     JUMBLE_NODE(arbiterWhere);
     668         592 :     JUMBLE_FIELD(constraint);
     669         592 :     JUMBLE_NODE(onConflictSet);
     670         592 :     JUMBLE_NODE(onConflictWhere);
     671         592 :     JUMBLE_FIELD(exclRelIndex);
     672         592 :     JUMBLE_NODE(exclRelTlist);
     673         592 : }
     674             : 
     675             : static void
     676      185420 : _jumbleQuery(JumbleState *jstate, Node *node)
     677             : {
     678      185420 :     Query *expr = (Query *) node;
     679             : 
     680      185420 :     JUMBLE_FIELD(commandType);
     681      185420 :     JUMBLE_NODE(utilityStmt);
     682      185420 :     JUMBLE_NODE(cteList);
     683      185420 :     JUMBLE_NODE(rtable);
     684      185420 :     JUMBLE_NODE(jointree);
     685      185420 :     JUMBLE_NODE(mergeActionList);
     686      185420 :     JUMBLE_NODE(mergeJoinCondition);
     687      185420 :     JUMBLE_NODE(targetList);
     688      185420 :     JUMBLE_NODE(onConflict);
     689      185420 :     JUMBLE_NODE(returningList);
     690      185420 :     JUMBLE_NODE(groupClause);
     691      185420 :     JUMBLE_FIELD(groupDistinct);
     692      185420 :     JUMBLE_NODE(groupingSets);
     693      185420 :     JUMBLE_NODE(havingQual);
     694      185420 :     JUMBLE_NODE(windowClause);
     695      185420 :     JUMBLE_NODE(distinctClause);
     696      185420 :     JUMBLE_NODE(sortClause);
     697      185420 :     JUMBLE_NODE(limitOffset);
     698      185420 :     JUMBLE_NODE(limitCount);
     699      185420 :     JUMBLE_FIELD(limitOption);
     700      185420 :     JUMBLE_NODE(rowMarks);
     701      185420 :     JUMBLE_NODE(setOperations);
     702      185420 : }
     703             : 
     704             : static void
     705       27686 : _jumbleTypeName(JumbleState *jstate, Node *node)
     706             : {
     707       27686 :     TypeName *expr = (TypeName *) node;
     708             : 
     709       27686 :     JUMBLE_NODE(names);
     710       27686 :     JUMBLE_FIELD(typeOid);
     711       27686 :     JUMBLE_FIELD(setof);
     712       27686 :     JUMBLE_FIELD(pct_type);
     713       27686 :     JUMBLE_NODE(typmods);
     714       27686 :     JUMBLE_FIELD(typemod);
     715       27686 :     JUMBLE_NODE(arrayBounds);
     716       27686 : }
     717             : 
     718             : static void
     719        7496 : _jumbleColumnRef(JumbleState *jstate, Node *node)
     720             : {
     721        7496 :     ColumnRef *expr = (ColumnRef *) node;
     722             : 
     723        7496 :     JUMBLE_NODE(fields);
     724        7496 : }
     725             : 
     726             : static void
     727         218 : _jumbleParamRef(JumbleState *jstate, Node *node)
     728             : {
     729         218 :     ParamRef *expr = (ParamRef *) node;
     730             : 
     731         218 :     JUMBLE_FIELD(number);
     732         218 : }
     733             : 
     734             : static void
     735        3088 : _jumbleA_Expr(JumbleState *jstate, Node *node)
     736             : {
     737        3088 :     A_Expr *expr = (A_Expr *) node;
     738             : 
     739        3088 :     JUMBLE_FIELD(kind);
     740        3088 :     JUMBLE_NODE(name);
     741        3088 :     JUMBLE_NODE(lexpr);
     742        3088 :     JUMBLE_NODE(rexpr);
     743        3088 : }
     744             : 
     745             : static void
     746         522 : _jumbleTypeCast(JumbleState *jstate, Node *node)
     747             : {
     748         522 :     TypeCast *expr = (TypeCast *) node;
     749             : 
     750         522 :     JUMBLE_NODE(arg);
     751         522 :     JUMBLE_NODE(typeName);
     752         522 : }
     753             : 
     754             : static void
     755         226 : _jumbleCollateClause(JumbleState *jstate, Node *node)
     756             : {
     757         226 :     CollateClause *expr = (CollateClause *) node;
     758             : 
     759         226 :     JUMBLE_NODE(arg);
     760         226 :     JUMBLE_NODE(collname);
     761         226 : }
     762             : 
     763             : static void
     764        2682 : _jumbleRoleSpec(JumbleState *jstate, Node *node)
     765             : {
     766        2682 :     RoleSpec *expr = (RoleSpec *) node;
     767             : 
     768        2682 :     JUMBLE_FIELD(roletype);
     769        2682 :     JUMBLE_STRING(rolename);
     770        2682 : }
     771             : 
     772             : static void
     773        1102 : _jumbleFuncCall(JumbleState *jstate, Node *node)
     774             : {
     775        1102 :     FuncCall *expr = (FuncCall *) node;
     776             : 
     777        1102 :     JUMBLE_NODE(funcname);
     778        1102 :     JUMBLE_NODE(args);
     779        1102 :     JUMBLE_NODE(agg_order);
     780        1102 :     JUMBLE_NODE(agg_filter);
     781        1102 :     JUMBLE_NODE(over);
     782        1102 :     JUMBLE_FIELD(agg_within_group);
     783        1102 :     JUMBLE_FIELD(agg_star);
     784        1102 :     JUMBLE_FIELD(agg_distinct);
     785        1102 :     JUMBLE_FIELD(func_variadic);
     786        1102 :     JUMBLE_FIELD(funcformat);
     787        1102 : }
     788             : 
     789             : static void
     790         914 : _jumbleA_Star(JumbleState *jstate, Node *node)
     791             : {
     792         914 :     A_Star *expr = (A_Star *) node;
     793             : 
     794             :     (void) expr;
     795         914 : }
     796             : 
     797             : static void
     798          76 : _jumbleA_Indices(JumbleState *jstate, Node *node)
     799             : {
     800          76 :     A_Indices *expr = (A_Indices *) node;
     801             : 
     802          76 :     JUMBLE_FIELD(is_slice);
     803          76 :     JUMBLE_NODE(lidx);
     804          76 :     JUMBLE_NODE(uidx);
     805          76 : }
     806             : 
     807             : static void
     808          82 : _jumbleA_Indirection(JumbleState *jstate, Node *node)
     809             : {
     810          82 :     A_Indirection *expr = (A_Indirection *) node;
     811             : 
     812          82 :     JUMBLE_NODE(arg);
     813          82 :     JUMBLE_NODE(indirection);
     814          82 : }
     815             : 
     816             : static void
     817          34 : _jumbleA_ArrayExpr(JumbleState *jstate, Node *node)
     818             : {
     819          34 :     A_ArrayExpr *expr = (A_ArrayExpr *) node;
     820             : 
     821          34 :     JUMBLE_NODE(elements);
     822          34 : }
     823             : 
     824             : static void
     825        3564 : _jumbleResTarget(JumbleState *jstate, Node *node)
     826             : {
     827        3564 :     ResTarget *expr = (ResTarget *) node;
     828             : 
     829        3564 :     JUMBLE_STRING(name);
     830        3564 :     JUMBLE_NODE(indirection);
     831        3564 :     JUMBLE_NODE(val);
     832        3564 : }
     833             : 
     834             : static void
     835           6 : _jumbleMultiAssignRef(JumbleState *jstate, Node *node)
     836             : {
     837           6 :     MultiAssignRef *expr = (MultiAssignRef *) node;
     838             : 
     839           6 :     JUMBLE_NODE(source);
     840           6 :     JUMBLE_FIELD(colno);
     841           6 :     JUMBLE_FIELD(ncolumns);
     842           6 : }
     843             : 
     844             : static void
     845         150 : _jumbleSortBy(JumbleState *jstate, Node *node)
     846             : {
     847         150 :     SortBy *expr = (SortBy *) node;
     848             : 
     849         150 :     JUMBLE_NODE(node);
     850         150 :     JUMBLE_FIELD(sortby_dir);
     851         150 :     JUMBLE_FIELD(sortby_nulls);
     852         150 :     JUMBLE_NODE(useOp);
     853         150 : }
     854             : 
     855             : static void
     856          28 : _jumbleWindowDef(JumbleState *jstate, Node *node)
     857             : {
     858          28 :     WindowDef *expr = (WindowDef *) node;
     859             : 
     860          28 :     JUMBLE_STRING(name);
     861          28 :     JUMBLE_STRING(refname);
     862          28 :     JUMBLE_NODE(partitionClause);
     863          28 :     JUMBLE_NODE(orderClause);
     864          28 :     JUMBLE_FIELD(frameOptions);
     865          28 :     JUMBLE_NODE(startOffset);
     866          28 :     JUMBLE_NODE(endOffset);
     867          28 : }
     868             : 
     869             : static void
     870          96 : _jumbleRangeSubselect(JumbleState *jstate, Node *node)
     871             : {
     872          96 :     RangeSubselect *expr = (RangeSubselect *) node;
     873             : 
     874          96 :     JUMBLE_FIELD(lateral);
     875          96 :     JUMBLE_NODE(subquery);
     876          96 :     JUMBLE_NODE(alias);
     877          96 : }
     878             : 
     879             : static void
     880         230 : _jumbleRangeFunction(JumbleState *jstate, Node *node)
     881             : {
     882         230 :     RangeFunction *expr = (RangeFunction *) node;
     883             : 
     884         230 :     JUMBLE_FIELD(lateral);
     885         230 :     JUMBLE_FIELD(ordinality);
     886         230 :     JUMBLE_FIELD(is_rowsfrom);
     887         230 :     JUMBLE_NODE(functions);
     888         230 :     JUMBLE_NODE(alias);
     889         230 :     JUMBLE_NODE(coldeflist);
     890         230 : }
     891             : 
     892             : static void
     893           6 : _jumbleRangeTableFunc(JumbleState *jstate, Node *node)
     894             : {
     895           6 :     RangeTableFunc *expr = (RangeTableFunc *) node;
     896             : 
     897           6 :     JUMBLE_FIELD(lateral);
     898           6 :     JUMBLE_NODE(docexpr);
     899           6 :     JUMBLE_NODE(rowexpr);
     900           6 :     JUMBLE_NODE(namespaces);
     901           6 :     JUMBLE_NODE(columns);
     902           6 :     JUMBLE_NODE(alias);
     903           6 : }
     904             : 
     905             : static void
     906          34 : _jumbleRangeTableFuncCol(JumbleState *jstate, Node *node)
     907             : {
     908          34 :     RangeTableFuncCol *expr = (RangeTableFuncCol *) node;
     909             : 
     910          34 :     JUMBLE_STRING(colname);
     911          34 :     JUMBLE_NODE(typeName);
     912          34 :     JUMBLE_FIELD(for_ordinality);
     913          34 :     JUMBLE_FIELD(is_not_null);
     914          34 :     JUMBLE_NODE(colexpr);
     915          34 :     JUMBLE_NODE(coldefexpr);
     916          34 : }
     917             : 
     918             : static void
     919           4 : _jumbleRangeTableSample(JumbleState *jstate, Node *node)
     920             : {
     921           4 :     RangeTableSample *expr = (RangeTableSample *) node;
     922             : 
     923           4 :     JUMBLE_NODE(relation);
     924           4 :     JUMBLE_NODE(method);
     925           4 :     JUMBLE_NODE(args);
     926           4 :     JUMBLE_NODE(repeatable);
     927           4 : }
     928             : 
     929             : static void
     930       14608 : _jumbleColumnDef(JumbleState *jstate, Node *node)
     931             : {
     932       14608 :     ColumnDef *expr = (ColumnDef *) node;
     933             : 
     934       14608 :     JUMBLE_STRING(colname);
     935       14608 :     JUMBLE_NODE(typeName);
     936       14608 :     JUMBLE_STRING(compression);
     937       14608 :     JUMBLE_FIELD(inhcount);
     938       14608 :     JUMBLE_FIELD(is_local);
     939       14608 :     JUMBLE_FIELD(is_not_null);
     940       14608 :     JUMBLE_FIELD(is_from_type);
     941       14608 :     JUMBLE_FIELD(storage);
     942       14608 :     JUMBLE_STRING(storage_name);
     943       14608 :     JUMBLE_NODE(raw_default);
     944       14608 :     JUMBLE_NODE(cooked_default);
     945       14608 :     JUMBLE_FIELD(identity);
     946       14608 :     JUMBLE_NODE(identitySequence);
     947       14608 :     JUMBLE_FIELD(generated);
     948       14608 :     JUMBLE_NODE(collClause);
     949       14608 :     JUMBLE_FIELD(collOid);
     950       14608 :     JUMBLE_NODE(constraints);
     951       14608 :     JUMBLE_NODE(fdwoptions);
     952       14608 : }
     953             : 
     954             : static void
     955         232 : _jumbleTableLikeClause(JumbleState *jstate, Node *node)
     956             : {
     957         232 :     TableLikeClause *expr = (TableLikeClause *) node;
     958             : 
     959         232 :     JUMBLE_NODE(relation);
     960         232 :     JUMBLE_FIELD(options);
     961         232 :     JUMBLE_FIELD(relationOid);
     962         232 : }
     963             : 
     964             : static void
     965        2210 : _jumbleIndexElem(JumbleState *jstate, Node *node)
     966             : {
     967        2210 :     IndexElem *expr = (IndexElem *) node;
     968             : 
     969        2210 :     JUMBLE_STRING(name);
     970        2210 :     JUMBLE_NODE(expr);
     971        2210 :     JUMBLE_STRING(indexcolname);
     972        2210 :     JUMBLE_NODE(collation);
     973        2210 :     JUMBLE_NODE(opclass);
     974        2210 :     JUMBLE_NODE(opclassopts);
     975        2210 :     JUMBLE_FIELD(ordering);
     976        2210 :     JUMBLE_FIELD(nulls_ordering);
     977        2210 : }
     978             : 
     979             : static void
     980       17612 : _jumbleDefElem(JumbleState *jstate, Node *node)
     981             : {
     982       17612 :     DefElem *expr = (DefElem *) node;
     983             : 
     984       17612 :     JUMBLE_STRING(defnamespace);
     985       17612 :     JUMBLE_STRING(defname);
     986       17612 :     JUMBLE_NODE(arg);
     987       17612 :     JUMBLE_FIELD(defaction);
     988       17612 : }
     989             : 
     990             : static void
     991          10 : _jumbleLockingClause(JumbleState *jstate, Node *node)
     992             : {
     993          10 :     LockingClause *expr = (LockingClause *) node;
     994             : 
     995          10 :     JUMBLE_NODE(lockedRels);
     996          10 :     JUMBLE_FIELD(strength);
     997          10 :     JUMBLE_FIELD(waitPolicy);
     998          10 : }
     999             : 
    1000             : static void
    1001           8 : _jumbleXmlSerialize(JumbleState *jstate, Node *node)
    1002             : {
    1003           8 :     XmlSerialize *expr = (XmlSerialize *) node;
    1004             : 
    1005           8 :     JUMBLE_FIELD(xmloption);
    1006           8 :     JUMBLE_NODE(expr);
    1007           8 :     JUMBLE_NODE(typeName);
    1008           8 :     JUMBLE_FIELD(indent);
    1009           8 : }
    1010             : 
    1011             : static void
    1012        1414 : _jumblePartitionElem(JumbleState *jstate, Node *node)
    1013             : {
    1014        1414 :     PartitionElem *expr = (PartitionElem *) node;
    1015             : 
    1016        1414 :     JUMBLE_STRING(name);
    1017        1414 :     JUMBLE_NODE(expr);
    1018        1414 :     JUMBLE_NODE(collation);
    1019        1414 :     JUMBLE_NODE(opclass);
    1020        1414 : }
    1021             : 
    1022             : static void
    1023        1266 : _jumblePartitionSpec(JumbleState *jstate, Node *node)
    1024             : {
    1025        1266 :     PartitionSpec *expr = (PartitionSpec *) node;
    1026             : 
    1027        1266 :     JUMBLE_FIELD(strategy);
    1028        1266 :     JUMBLE_NODE(partParams);
    1029        1266 : }
    1030             : 
    1031             : static void
    1032        2678 : _jumblePartitionBoundSpec(JumbleState *jstate, Node *node)
    1033             : {
    1034        2678 :     PartitionBoundSpec *expr = (PartitionBoundSpec *) node;
    1035             : 
    1036        2678 :     JUMBLE_FIELD(strategy);
    1037        2678 :     JUMBLE_FIELD(is_default);
    1038        2678 :     JUMBLE_FIELD(modulus);
    1039        2678 :     JUMBLE_FIELD(remainder);
    1040        2678 :     JUMBLE_NODE(listdatums);
    1041        2678 :     JUMBLE_NODE(lowerdatums);
    1042        2678 :     JUMBLE_NODE(upperdatums);
    1043        2678 : }
    1044             : 
    1045             : static void
    1046           0 : _jumblePartitionRangeDatum(JumbleState *jstate, Node *node)
    1047             : {
    1048           0 :     PartitionRangeDatum *expr = (PartitionRangeDatum *) node;
    1049             : 
    1050           0 :     JUMBLE_FIELD(kind);
    1051           0 :     JUMBLE_NODE(value);
    1052           0 : }
    1053             : 
    1054             : static void
    1055         808 : _jumblePartitionCmd(JumbleState *jstate, Node *node)
    1056             : {
    1057         808 :     PartitionCmd *expr = (PartitionCmd *) node;
    1058             : 
    1059         808 :     JUMBLE_NODE(name);
    1060         808 :     JUMBLE_NODE(bound);
    1061         808 :     JUMBLE_FIELD(concurrent);
    1062         808 : }
    1063             : 
    1064             : static void
    1065      151456 : _jumbleRangeTblEntry(JumbleState *jstate, Node *node)
    1066             : {
    1067      151456 :     RangeTblEntry *expr = (RangeTblEntry *) node;
    1068             : 
    1069      151456 :     JUMBLE_CUSTOM(RangeTblEntry, eref);
    1070      151456 :     JUMBLE_FIELD(rtekind);
    1071      151456 :     JUMBLE_FIELD(inh);
    1072      151456 :     JUMBLE_NODE(tablesample);
    1073      151456 :     JUMBLE_NODE(subquery);
    1074      151456 :     JUMBLE_FIELD(jointype);
    1075      151456 :     JUMBLE_NODE(functions);
    1076      151456 :     JUMBLE_FIELD(funcordinality);
    1077      151456 :     JUMBLE_NODE(tablefunc);
    1078      151456 :     JUMBLE_NODE(values_lists);
    1079      151456 :     JUMBLE_STRING(ctename);
    1080      151456 :     JUMBLE_FIELD(ctelevelsup);
    1081      151456 :     JUMBLE_STRING(enrname);
    1082      151456 : }
    1083             : 
    1084             : static void
    1085           0 : _jumbleRTEPermissionInfo(JumbleState *jstate, Node *node)
    1086             : {
    1087           0 :     RTEPermissionInfo *expr = (RTEPermissionInfo *) node;
    1088             : 
    1089           0 :     JUMBLE_FIELD(relid);
    1090           0 :     JUMBLE_FIELD(inh);
    1091           0 :     JUMBLE_FIELD(requiredPerms);
    1092           0 :     JUMBLE_FIELD(checkAsUser);
    1093           0 :     JUMBLE_NODE(selectedCols);
    1094           0 :     JUMBLE_NODE(insertedCols);
    1095           0 :     JUMBLE_NODE(updatedCols);
    1096           0 : }
    1097             : 
    1098             : static void
    1099        7188 : _jumbleRangeTblFunction(JumbleState *jstate, Node *node)
    1100             : {
    1101        7188 :     RangeTblFunction *expr = (RangeTblFunction *) node;
    1102             : 
    1103        7188 :     JUMBLE_NODE(funcexpr);
    1104        7188 : }
    1105             : 
    1106             : static void
    1107          82 : _jumbleTableSampleClause(JumbleState *jstate, Node *node)
    1108             : {
    1109          82 :     TableSampleClause *expr = (TableSampleClause *) node;
    1110             : 
    1111          82 :     JUMBLE_FIELD(tsmhandler);
    1112          82 :     JUMBLE_NODE(args);
    1113          82 :     JUMBLE_NODE(repeatable);
    1114          82 : }
    1115             : 
    1116             : static void
    1117           0 : _jumbleWithCheckOption(JumbleState *jstate, Node *node)
    1118             : {
    1119           0 :     WithCheckOption *expr = (WithCheckOption *) node;
    1120             : 
    1121           0 :     JUMBLE_FIELD(kind);
    1122           0 :     JUMBLE_STRING(relname);
    1123           0 :     JUMBLE_STRING(polname);
    1124           0 :     JUMBLE_NODE(qual);
    1125           0 :     JUMBLE_FIELD(cascaded);
    1126           0 : }
    1127             : 
    1128             : static void
    1129       33426 : _jumbleSortGroupClause(JumbleState *jstate, Node *node)
    1130             : {
    1131       33426 :     SortGroupClause *expr = (SortGroupClause *) node;
    1132             : 
    1133       33426 :     JUMBLE_FIELD(tleSortGroupRef);
    1134       33426 :     JUMBLE_FIELD(eqop);
    1135       33426 :     JUMBLE_FIELD(sortop);
    1136       33426 :     JUMBLE_FIELD(reverse_sort);
    1137       33426 :     JUMBLE_FIELD(nulls_first);
    1138       33426 : }
    1139             : 
    1140             : static void
    1141        1276 : _jumbleGroupingSet(JumbleState *jstate, Node *node)
    1142             : {
    1143        1276 :     GroupingSet *expr = (GroupingSet *) node;
    1144             : 
    1145        1276 :     JUMBLE_NODE(content);
    1146        1276 : }
    1147             : 
    1148             : static void
    1149        1080 : _jumbleWindowClause(JumbleState *jstate, Node *node)
    1150             : {
    1151        1080 :     WindowClause *expr = (WindowClause *) node;
    1152             : 
    1153        1080 :     JUMBLE_NODE(partitionClause);
    1154        1080 :     JUMBLE_NODE(orderClause);
    1155        1080 :     JUMBLE_FIELD(frameOptions);
    1156        1080 :     JUMBLE_NODE(startOffset);
    1157        1080 :     JUMBLE_NODE(endOffset);
    1158        1080 :     JUMBLE_FIELD(winref);
    1159        1080 : }
    1160             : 
    1161             : static void
    1162         642 : _jumbleRowMarkClause(JumbleState *jstate, Node *node)
    1163             : {
    1164         642 :     RowMarkClause *expr = (RowMarkClause *) node;
    1165             : 
    1166         642 :     JUMBLE_FIELD(rti);
    1167         642 :     JUMBLE_FIELD(strength);
    1168         642 :     JUMBLE_FIELD(waitPolicy);
    1169         642 :     JUMBLE_FIELD(pushedDown);
    1170         642 : }
    1171             : 
    1172             : static void
    1173          32 : _jumbleWithClause(JumbleState *jstate, Node *node)
    1174             : {
    1175          32 :     WithClause *expr = (WithClause *) node;
    1176             : 
    1177          32 :     JUMBLE_NODE(ctes);
    1178          32 :     JUMBLE_FIELD(recursive);
    1179          32 : }
    1180             : 
    1181             : static void
    1182           4 : _jumbleInferClause(JumbleState *jstate, Node *node)
    1183             : {
    1184           4 :     InferClause *expr = (InferClause *) node;
    1185             : 
    1186           4 :     JUMBLE_NODE(indexElems);
    1187           4 :     JUMBLE_NODE(whereClause);
    1188           4 :     JUMBLE_STRING(conname);
    1189           4 : }
    1190             : 
    1191             : static void
    1192           6 : _jumbleOnConflictClause(JumbleState *jstate, Node *node)
    1193             : {
    1194           6 :     OnConflictClause *expr = (OnConflictClause *) node;
    1195             : 
    1196           6 :     JUMBLE_FIELD(action);
    1197           6 :     JUMBLE_NODE(infer);
    1198           6 :     JUMBLE_NODE(targetList);
    1199           6 :     JUMBLE_NODE(whereClause);
    1200           6 : }
    1201             : 
    1202             : static void
    1203           0 : _jumbleCTESearchClause(JumbleState *jstate, Node *node)
    1204             : {
    1205           0 :     CTESearchClause *expr = (CTESearchClause *) node;
    1206             : 
    1207           0 :     JUMBLE_NODE(search_col_list);
    1208           0 :     JUMBLE_FIELD(search_breadth_first);
    1209           0 :     JUMBLE_STRING(search_seq_column);
    1210           0 : }
    1211             : 
    1212             : static void
    1213           0 : _jumbleCTECycleClause(JumbleState *jstate, Node *node)
    1214             : {
    1215           0 :     CTECycleClause *expr = (CTECycleClause *) node;
    1216             : 
    1217           0 :     JUMBLE_NODE(cycle_col_list);
    1218           0 :     JUMBLE_STRING(cycle_mark_column);
    1219           0 :     JUMBLE_NODE(cycle_mark_value);
    1220           0 :     JUMBLE_NODE(cycle_mark_default);
    1221           0 :     JUMBLE_STRING(cycle_path_column);
    1222           0 :     JUMBLE_FIELD(cycle_mark_type);
    1223           0 :     JUMBLE_FIELD(cycle_mark_typmod);
    1224           0 :     JUMBLE_FIELD(cycle_mark_collation);
    1225           0 :     JUMBLE_FIELD(cycle_mark_neop);
    1226           0 : }
    1227             : 
    1228             : static void
    1229         858 : _jumbleCommonTableExpr(JumbleState *jstate, Node *node)
    1230             : {
    1231         858 :     CommonTableExpr *expr = (CommonTableExpr *) node;
    1232             : 
    1233         858 :     JUMBLE_STRING(ctename);
    1234         858 :     JUMBLE_FIELD(ctematerialized);
    1235         858 :     JUMBLE_NODE(ctequery);
    1236         858 : }
    1237             : 
    1238             : static void
    1239          46 : _jumbleMergeWhenClause(JumbleState *jstate, Node *node)
    1240             : {
    1241          46 :     MergeWhenClause *expr = (MergeWhenClause *) node;
    1242             : 
    1243          46 :     JUMBLE_FIELD(matchKind);
    1244          46 :     JUMBLE_FIELD(commandType);
    1245          46 :     JUMBLE_FIELD(override);
    1246          46 :     JUMBLE_NODE(condition);
    1247          46 :     JUMBLE_NODE(targetList);
    1248          46 :     JUMBLE_NODE(values);
    1249          46 : }
    1250             : 
    1251             : static void
    1252          12 : _jumbleReturningOption(JumbleState *jstate, Node *node)
    1253             : {
    1254          12 :     ReturningOption *expr = (ReturningOption *) node;
    1255             : 
    1256          12 :     JUMBLE_FIELD(option);
    1257          12 :     JUMBLE_STRING(value);
    1258          12 : }
    1259             : 
    1260             : static void
    1261         104 : _jumbleReturningClause(JumbleState *jstate, Node *node)
    1262             : {
    1263         104 :     ReturningClause *expr = (ReturningClause *) node;
    1264             : 
    1265         104 :     JUMBLE_NODE(options);
    1266         104 :     JUMBLE_NODE(exprs);
    1267         104 : }
    1268             : 
    1269             : static void
    1270         186 : _jumbleTriggerTransition(JumbleState *jstate, Node *node)
    1271             : {
    1272         186 :     TriggerTransition *expr = (TriggerTransition *) node;
    1273             : 
    1274         186 :     JUMBLE_STRING(name);
    1275         186 :     JUMBLE_FIELD(isNew);
    1276         186 :     JUMBLE_FIELD(isTable);
    1277         186 : }
    1278             : 
    1279             : static void
    1280          14 : _jumbleJsonOutput(JumbleState *jstate, Node *node)
    1281             : {
    1282          14 :     JsonOutput *expr = (JsonOutput *) node;
    1283             : 
    1284          14 :     JUMBLE_NODE(typeName);
    1285          14 :     JUMBLE_NODE(returning);
    1286          14 : }
    1287             : 
    1288             : static void
    1289          56 : _jumbleJsonArgument(JumbleState *jstate, Node *node)
    1290             : {
    1291          56 :     JsonArgument *expr = (JsonArgument *) node;
    1292             : 
    1293          56 :     JUMBLE_NODE(val);
    1294          56 :     JUMBLE_STRING(name);
    1295          56 : }
    1296             : 
    1297             : static void
    1298          88 : _jumbleJsonFuncExpr(JumbleState *jstate, Node *node)
    1299             : {
    1300          88 :     JsonFuncExpr *expr = (JsonFuncExpr *) node;
    1301             : 
    1302          88 :     JUMBLE_FIELD(op);
    1303          88 :     JUMBLE_STRING(column_name);
    1304          88 :     JUMBLE_NODE(context_item);
    1305          88 :     JUMBLE_NODE(pathspec);
    1306          88 :     JUMBLE_NODE(passing);
    1307          88 :     JUMBLE_NODE(output);
    1308          88 :     JUMBLE_NODE(on_empty);
    1309          88 :     JUMBLE_NODE(on_error);
    1310          88 :     JUMBLE_FIELD(wrapper);
    1311          88 :     JUMBLE_FIELD(quotes);
    1312          88 : }
    1313             : 
    1314             : static void
    1315         110 : _jumbleJsonTablePathSpec(JumbleState *jstate, Node *node)
    1316             : {
    1317         110 :     JsonTablePathSpec *expr = (JsonTablePathSpec *) node;
    1318             : 
    1319         110 :     JUMBLE_NODE(string);
    1320         110 :     JUMBLE_STRING(name);
    1321         110 : }
    1322             : 
    1323             : static void
    1324          22 : _jumbleJsonTable(JumbleState *jstate, Node *node)
    1325             : {
    1326          22 :     JsonTable *expr = (JsonTable *) node;
    1327             : 
    1328          22 :     JUMBLE_NODE(context_item);
    1329          22 :     JUMBLE_NODE(pathspec);
    1330          22 :     JUMBLE_NODE(passing);
    1331          22 :     JUMBLE_NODE(columns);
    1332          22 :     JUMBLE_NODE(on_error);
    1333          22 :     JUMBLE_NODE(alias);
    1334          22 :     JUMBLE_FIELD(lateral);
    1335          22 : }
    1336             : 
    1337             : static void
    1338         102 : _jumbleJsonTableColumn(JumbleState *jstate, Node *node)
    1339             : {
    1340         102 :     JsonTableColumn *expr = (JsonTableColumn *) node;
    1341             : 
    1342         102 :     JUMBLE_FIELD(coltype);
    1343         102 :     JUMBLE_STRING(name);
    1344         102 :     JUMBLE_NODE(typeName);
    1345         102 :     JUMBLE_NODE(pathspec);
    1346         102 :     JUMBLE_NODE(format);
    1347         102 :     JUMBLE_FIELD(wrapper);
    1348         102 :     JUMBLE_FIELD(quotes);
    1349         102 :     JUMBLE_NODE(columns);
    1350         102 :     JUMBLE_NODE(on_empty);
    1351         102 :     JUMBLE_NODE(on_error);
    1352         102 : }
    1353             : 
    1354             : static void
    1355           6 : _jumbleJsonKeyValue(JumbleState *jstate, Node *node)
    1356             : {
    1357           6 :     JsonKeyValue *expr = (JsonKeyValue *) node;
    1358             : 
    1359           6 :     JUMBLE_NODE(key);
    1360           6 :     JUMBLE_NODE(value);
    1361           6 : }
    1362             : 
    1363             : static void
    1364           0 : _jumbleJsonParseExpr(JumbleState *jstate, Node *node)
    1365             : {
    1366           0 :     JsonParseExpr *expr = (JsonParseExpr *) node;
    1367             : 
    1368           0 :     JUMBLE_NODE(expr);
    1369           0 :     JUMBLE_NODE(output);
    1370           0 :     JUMBLE_FIELD(unique_keys);
    1371           0 : }
    1372             : 
    1373             : static void
    1374           0 : _jumbleJsonScalarExpr(JumbleState *jstate, Node *node)
    1375             : {
    1376           0 :     JsonScalarExpr *expr = (JsonScalarExpr *) node;
    1377             : 
    1378           0 :     JUMBLE_NODE(expr);
    1379           0 :     JUMBLE_NODE(output);
    1380           0 : }
    1381             : 
    1382             : static void
    1383           0 : _jumbleJsonSerializeExpr(JumbleState *jstate, Node *node)
    1384             : {
    1385           0 :     JsonSerializeExpr *expr = (JsonSerializeExpr *) node;
    1386             : 
    1387           0 :     JUMBLE_NODE(expr);
    1388           0 :     JUMBLE_NODE(output);
    1389           0 : }
    1390             : 
    1391             : static void
    1392           2 : _jumbleJsonObjectConstructor(JumbleState *jstate, Node *node)
    1393             : {
    1394           2 :     JsonObjectConstructor *expr = (JsonObjectConstructor *) node;
    1395             : 
    1396           2 :     JUMBLE_NODE(exprs);
    1397           2 :     JUMBLE_NODE(output);
    1398           2 :     JUMBLE_FIELD(absent_on_null);
    1399           2 :     JUMBLE_FIELD(unique);
    1400           2 : }
    1401             : 
    1402             : static void
    1403           2 : _jumbleJsonArrayConstructor(JumbleState *jstate, Node *node)
    1404             : {
    1405           2 :     JsonArrayConstructor *expr = (JsonArrayConstructor *) node;
    1406             : 
    1407           2 :     JUMBLE_NODE(exprs);
    1408           2 :     JUMBLE_NODE(output);
    1409           2 :     JUMBLE_FIELD(absent_on_null);
    1410           2 : }
    1411             : 
    1412             : static void
    1413           2 : _jumbleJsonArrayQueryConstructor(JumbleState *jstate, Node *node)
    1414             : {
    1415           2 :     JsonArrayQueryConstructor *expr = (JsonArrayQueryConstructor *) node;
    1416             : 
    1417           2 :     JUMBLE_NODE(query);
    1418           2 :     JUMBLE_NODE(output);
    1419           2 :     JUMBLE_NODE(format);
    1420           2 :     JUMBLE_FIELD(absent_on_null);
    1421           2 : }
    1422             : 
    1423             : static void
    1424           4 : _jumbleJsonAggConstructor(JumbleState *jstate, Node *node)
    1425             : {
    1426           4 :     JsonAggConstructor *expr = (JsonAggConstructor *) node;
    1427             : 
    1428           4 :     JUMBLE_NODE(output);
    1429           4 :     JUMBLE_NODE(agg_filter);
    1430           4 :     JUMBLE_NODE(agg_order);
    1431           4 :     JUMBLE_NODE(over);
    1432           4 : }
    1433             : 
    1434             : static void
    1435           2 : _jumbleJsonObjectAgg(JumbleState *jstate, Node *node)
    1436             : {
    1437           2 :     JsonObjectAgg *expr = (JsonObjectAgg *) node;
    1438             : 
    1439           2 :     JUMBLE_NODE(constructor);
    1440           2 :     JUMBLE_NODE(arg);
    1441           2 :     JUMBLE_FIELD(absent_on_null);
    1442           2 :     JUMBLE_FIELD(unique);
    1443           2 : }
    1444             : 
    1445             : static void
    1446           2 : _jumbleJsonArrayAgg(JumbleState *jstate, Node *node)
    1447             : {
    1448           2 :     JsonArrayAgg *expr = (JsonArrayAgg *) node;
    1449             : 
    1450           2 :     JUMBLE_NODE(constructor);
    1451           2 :     JUMBLE_NODE(arg);
    1452           2 :     JUMBLE_FIELD(absent_on_null);
    1453           2 : }
    1454             : 
    1455             : static void
    1456         172 : _jumbleInsertStmt(JumbleState *jstate, Node *node)
    1457             : {
    1458         172 :     InsertStmt *expr = (InsertStmt *) node;
    1459             : 
    1460         172 :     JUMBLE_NODE(relation);
    1461         172 :     JUMBLE_NODE(cols);
    1462         172 :     JUMBLE_NODE(selectStmt);
    1463         172 :     JUMBLE_NODE(onConflictClause);
    1464         172 :     JUMBLE_NODE(returningClause);
    1465         172 :     JUMBLE_NODE(withClause);
    1466         172 :     JUMBLE_FIELD(override);
    1467         172 : }
    1468             : 
    1469             : static void
    1470          66 : _jumbleDeleteStmt(JumbleState *jstate, Node *node)
    1471             : {
    1472          66 :     DeleteStmt *expr = (DeleteStmt *) node;
    1473             : 
    1474          66 :     JUMBLE_NODE(relation);
    1475          66 :     JUMBLE_NODE(usingClause);
    1476          66 :     JUMBLE_NODE(whereClause);
    1477          66 :     JUMBLE_NODE(returningClause);
    1478          66 :     JUMBLE_NODE(withClause);
    1479          66 : }
    1480             : 
    1481             : static void
    1482         102 : _jumbleUpdateStmt(JumbleState *jstate, Node *node)
    1483             : {
    1484         102 :     UpdateStmt *expr = (UpdateStmt *) node;
    1485             : 
    1486         102 :     JUMBLE_NODE(relation);
    1487         102 :     JUMBLE_NODE(targetList);
    1488         102 :     JUMBLE_NODE(whereClause);
    1489         102 :     JUMBLE_NODE(fromClause);
    1490         102 :     JUMBLE_NODE(returningClause);
    1491         102 :     JUMBLE_NODE(withClause);
    1492         102 : }
    1493             : 
    1494             : static void
    1495          16 : _jumbleMergeStmt(JumbleState *jstate, Node *node)
    1496             : {
    1497          16 :     MergeStmt *expr = (MergeStmt *) node;
    1498             : 
    1499          16 :     JUMBLE_NODE(relation);
    1500          16 :     JUMBLE_NODE(sourceRelation);
    1501          16 :     JUMBLE_NODE(joinCondition);
    1502          16 :     JUMBLE_NODE(mergeWhenClauses);
    1503          16 :     JUMBLE_NODE(returningClause);
    1504          16 :     JUMBLE_NODE(withClause);
    1505          16 : }
    1506             : 
    1507             : static void
    1508        1918 : _jumbleSelectStmt(JumbleState *jstate, Node *node)
    1509             : {
    1510        1918 :     SelectStmt *expr = (SelectStmt *) node;
    1511             : 
    1512        1918 :     JUMBLE_NODE(distinctClause);
    1513        1918 :     JUMBLE_NODE(intoClause);
    1514        1918 :     JUMBLE_NODE(targetList);
    1515        1918 :     JUMBLE_NODE(fromClause);
    1516        1918 :     JUMBLE_NODE(whereClause);
    1517        1918 :     JUMBLE_NODE(groupClause);
    1518        1918 :     JUMBLE_FIELD(groupDistinct);
    1519        1918 :     JUMBLE_NODE(havingClause);
    1520        1918 :     JUMBLE_NODE(windowClause);
    1521        1918 :     JUMBLE_NODE(valuesLists);
    1522        1918 :     JUMBLE_NODE(sortClause);
    1523        1918 :     JUMBLE_NODE(limitOffset);
    1524        1918 :     JUMBLE_NODE(limitCount);
    1525        1918 :     JUMBLE_FIELD(limitOption);
    1526        1918 :     JUMBLE_NODE(lockingClause);
    1527        1918 :     JUMBLE_NODE(withClause);
    1528        1918 :     JUMBLE_FIELD(op);
    1529        1918 :     JUMBLE_FIELD(all);
    1530        1918 :     JUMBLE_NODE(larg);
    1531        1918 :     JUMBLE_NODE(rarg);
    1532        1918 : }
    1533             : 
    1534             : static void
    1535        3440 : _jumbleSetOperationStmt(JumbleState *jstate, Node *node)
    1536             : {
    1537        3440 :     SetOperationStmt *expr = (SetOperationStmt *) node;
    1538             : 
    1539        3440 :     JUMBLE_FIELD(op);
    1540        3440 :     JUMBLE_FIELD(all);
    1541        3440 :     JUMBLE_NODE(larg);
    1542        3440 :     JUMBLE_NODE(rarg);
    1543        3440 : }
    1544             : 
    1545             : static void
    1546          30 : _jumbleReturnStmt(JumbleState *jstate, Node *node)
    1547             : {
    1548          30 :     ReturnStmt *expr = (ReturnStmt *) node;
    1549             : 
    1550          30 :     JUMBLE_NODE(returnval);
    1551          30 : }
    1552             : 
    1553             : static void
    1554           0 : _jumblePLAssignStmt(JumbleState *jstate, Node *node)
    1555             : {
    1556           0 :     PLAssignStmt *expr = (PLAssignStmt *) node;
    1557             : 
    1558           0 :     JUMBLE_STRING(name);
    1559           0 :     JUMBLE_NODE(indirection);
    1560           0 :     JUMBLE_FIELD(nnames);
    1561           0 :     JUMBLE_NODE(val);
    1562           0 : }
    1563             : 
    1564             : static void
    1565         226 : _jumbleCreateSchemaStmt(JumbleState *jstate, Node *node)
    1566             : {
    1567         226 :     CreateSchemaStmt *expr = (CreateSchemaStmt *) node;
    1568             : 
    1569         226 :     JUMBLE_STRING(schemaname);
    1570         226 :     JUMBLE_NODE(authrole);
    1571         226 :     JUMBLE_NODE(schemaElts);
    1572         226 :     JUMBLE_FIELD(if_not_exists);
    1573         226 : }
    1574             : 
    1575             : static void
    1576        4490 : _jumbleAlterTableStmt(JumbleState *jstate, Node *node)
    1577             : {
    1578        4490 :     AlterTableStmt *expr = (AlterTableStmt *) node;
    1579             : 
    1580        4490 :     JUMBLE_NODE(relation);
    1581        4490 :     JUMBLE_NODE(cmds);
    1582        4490 :     JUMBLE_FIELD(objtype);
    1583        4490 :     JUMBLE_FIELD(missing_ok);
    1584        4490 : }
    1585             : 
    1586             : static void
    1587        4822 : _jumbleAlterTableCmd(JumbleState *jstate, Node *node)
    1588             : {
    1589        4822 :     AlterTableCmd *expr = (AlterTableCmd *) node;
    1590             : 
    1591        4822 :     JUMBLE_FIELD(subtype);
    1592        4822 :     JUMBLE_STRING(name);
    1593        4822 :     JUMBLE_FIELD(num);
    1594        4822 :     JUMBLE_NODE(newowner);
    1595        4822 :     JUMBLE_NODE(def);
    1596        4822 :     JUMBLE_FIELD(behavior);
    1597        4822 :     JUMBLE_FIELD(missing_ok);
    1598        4822 :     JUMBLE_FIELD(recurse);
    1599        4822 : }
    1600             : 
    1601             : static void
    1602          64 : _jumbleATAlterConstraint(JumbleState *jstate, Node *node)
    1603             : {
    1604          64 :     ATAlterConstraint *expr = (ATAlterConstraint *) node;
    1605             : 
    1606          64 :     JUMBLE_STRING(conname);
    1607          64 :     JUMBLE_FIELD(alterDeferrability);
    1608          64 :     JUMBLE_FIELD(deferrable);
    1609          64 :     JUMBLE_FIELD(initdeferred);
    1610          64 :     JUMBLE_FIELD(alterInheritability);
    1611          64 :     JUMBLE_FIELD(noinherit);
    1612          64 : }
    1613             : 
    1614             : static void
    1615         108 : _jumbleReplicaIdentityStmt(JumbleState *jstate, Node *node)
    1616             : {
    1617         108 :     ReplicaIdentityStmt *expr = (ReplicaIdentityStmt *) node;
    1618             : 
    1619         108 :     JUMBLE_FIELD(identity_type);
    1620         108 :     JUMBLE_STRING(name);
    1621         108 : }
    1622             : 
    1623             : static void
    1624           2 : _jumbleAlterCollationStmt(JumbleState *jstate, Node *node)
    1625             : {
    1626           2 :     AlterCollationStmt *expr = (AlterCollationStmt *) node;
    1627             : 
    1628           2 :     JUMBLE_NODE(collname);
    1629           2 : }
    1630             : 
    1631             : static void
    1632          96 : _jumbleAlterDomainStmt(JumbleState *jstate, Node *node)
    1633             : {
    1634          96 :     AlterDomainStmt *expr = (AlterDomainStmt *) node;
    1635             : 
    1636          96 :     JUMBLE_FIELD(subtype);
    1637          96 :     JUMBLE_NODE(typeName);
    1638          96 :     JUMBLE_STRING(name);
    1639          96 :     JUMBLE_NODE(def);
    1640          96 :     JUMBLE_FIELD(behavior);
    1641          96 :     JUMBLE_FIELD(missing_ok);
    1642          96 : }
    1643             : 
    1644             : static void
    1645         932 : _jumbleGrantStmt(JumbleState *jstate, Node *node)
    1646             : {
    1647         932 :     GrantStmt *expr = (GrantStmt *) node;
    1648             : 
    1649         932 :     JUMBLE_FIELD(is_grant);
    1650         932 :     JUMBLE_FIELD(targtype);
    1651         932 :     JUMBLE_FIELD(objtype);
    1652         932 :     JUMBLE_NODE(objects);
    1653         932 :     JUMBLE_NODE(privileges);
    1654         932 :     JUMBLE_NODE(grantees);
    1655         932 :     JUMBLE_FIELD(grant_option);
    1656         932 :     JUMBLE_NODE(grantor);
    1657         932 :     JUMBLE_FIELD(behavior);
    1658         932 : }
    1659             : 
    1660             : static void
    1661        1564 : _jumbleObjectWithArgs(JumbleState *jstate, Node *node)
    1662             : {
    1663        1564 :     ObjectWithArgs *expr = (ObjectWithArgs *) node;
    1664             : 
    1665        1564 :     JUMBLE_NODE(objname);
    1666        1564 :     JUMBLE_NODE(objargs);
    1667        1564 :     JUMBLE_NODE(objfuncargs);
    1668        1564 :     JUMBLE_FIELD(args_unspecified);
    1669        1564 : }
    1670             : 
    1671             : static void
    1672         960 : _jumbleAccessPriv(JumbleState *jstate, Node *node)
    1673             : {
    1674         960 :     AccessPriv *expr = (AccessPriv *) node;
    1675             : 
    1676         960 :     JUMBLE_STRING(priv_name);
    1677         960 :     JUMBLE_NODE(cols);
    1678         960 : }
    1679             : 
    1680             : static void
    1681         202 : _jumbleGrantRoleStmt(JumbleState *jstate, Node *node)
    1682             : {
    1683         202 :     GrantRoleStmt *expr = (GrantRoleStmt *) node;
    1684             : 
    1685         202 :     JUMBLE_NODE(granted_roles);
    1686         202 :     JUMBLE_NODE(grantee_roles);
    1687         202 :     JUMBLE_FIELD(is_grant);
    1688         202 :     JUMBLE_NODE(opt);
    1689         202 :     JUMBLE_NODE(grantor);
    1690         202 :     JUMBLE_FIELD(behavior);
    1691         202 : }
    1692             : 
    1693             : static void
    1694          50 : _jumbleAlterDefaultPrivilegesStmt(JumbleState *jstate, Node *node)
    1695             : {
    1696          50 :     AlterDefaultPrivilegesStmt *expr = (AlterDefaultPrivilegesStmt *) node;
    1697             : 
    1698          50 :     JUMBLE_NODE(options);
    1699          50 :     JUMBLE_NODE(action);
    1700          50 : }
    1701             : 
    1702             : static void
    1703        3512 : _jumbleCopyStmt(JumbleState *jstate, Node *node)
    1704             : {
    1705        3512 :     CopyStmt *expr = (CopyStmt *) node;
    1706             : 
    1707        3512 :     JUMBLE_NODE(relation);
    1708        3512 :     JUMBLE_NODE(query);
    1709        3512 :     JUMBLE_NODE(attlist);
    1710        3512 :     JUMBLE_FIELD(is_from);
    1711        3512 :     JUMBLE_FIELD(is_program);
    1712        3512 :     JUMBLE_STRING(filename);
    1713        3512 :     JUMBLE_NODE(options);
    1714        3512 :     JUMBLE_NODE(whereClause);
    1715        3512 : }
    1716             : 
    1717             : static void
    1718         260 : _jumbleVariableShowStmt(JumbleState *jstate, Node *node)
    1719             : {
    1720         260 :     VariableShowStmt *expr = (VariableShowStmt *) node;
    1721             : 
    1722         260 :     JUMBLE_STRING(name);
    1723         260 : }
    1724             : 
    1725             : static void
    1726        8184 : _jumbleCreateStmt(JumbleState *jstate, Node *node)
    1727             : {
    1728        8184 :     CreateStmt *expr = (CreateStmt *) node;
    1729             : 
    1730        8184 :     JUMBLE_NODE(relation);
    1731        8184 :     JUMBLE_NODE(tableElts);
    1732        8184 :     JUMBLE_NODE(inhRelations);
    1733        8184 :     JUMBLE_NODE(partbound);
    1734        8184 :     JUMBLE_NODE(partspec);
    1735        8184 :     JUMBLE_NODE(ofTypename);
    1736        8184 :     JUMBLE_NODE(constraints);
    1737        8184 :     JUMBLE_NODE(nnconstraints);
    1738        8184 :     JUMBLE_NODE(options);
    1739        8184 :     JUMBLE_FIELD(oncommit);
    1740        8184 :     JUMBLE_STRING(tablespacename);
    1741        8184 :     JUMBLE_STRING(accessMethod);
    1742        8184 :     JUMBLE_FIELD(if_not_exists);
    1743        8184 : }
    1744             : 
    1745             : static void
    1746        4656 : _jumbleConstraint(JumbleState *jstate, Node *node)
    1747             : {
    1748        4656 :     Constraint *expr = (Constraint *) node;
    1749             : 
    1750        4656 :     JUMBLE_FIELD(contype);
    1751        4656 :     JUMBLE_STRING(conname);
    1752        4656 :     JUMBLE_FIELD(deferrable);
    1753        4656 :     JUMBLE_FIELD(initdeferred);
    1754        4656 :     JUMBLE_FIELD(is_enforced);
    1755        4656 :     JUMBLE_FIELD(skip_validation);
    1756        4656 :     JUMBLE_FIELD(initially_valid);
    1757        4656 :     JUMBLE_FIELD(is_no_inherit);
    1758        4656 :     JUMBLE_NODE(raw_expr);
    1759        4656 :     JUMBLE_STRING(cooked_expr);
    1760        4656 :     JUMBLE_FIELD(generated_when);
    1761        4656 :     JUMBLE_FIELD(generated_kind);
    1762        4656 :     JUMBLE_FIELD(nulls_not_distinct);
    1763        4656 :     JUMBLE_NODE(keys);
    1764        4656 :     JUMBLE_FIELD(without_overlaps);
    1765        4656 :     JUMBLE_NODE(including);
    1766        4656 :     JUMBLE_NODE(exclusions);
    1767        4656 :     JUMBLE_NODE(options);
    1768        4656 :     JUMBLE_STRING(indexname);
    1769        4656 :     JUMBLE_STRING(indexspace);
    1770        4656 :     JUMBLE_FIELD(reset_default_tblspc);
    1771        4656 :     JUMBLE_STRING(access_method);
    1772        4656 :     JUMBLE_NODE(where_clause);
    1773        4656 :     JUMBLE_NODE(pktable);
    1774        4656 :     JUMBLE_NODE(fk_attrs);
    1775        4656 :     JUMBLE_NODE(pk_attrs);
    1776        4656 :     JUMBLE_FIELD(fk_with_period);
    1777        4656 :     JUMBLE_FIELD(pk_with_period);
    1778        4656 :     JUMBLE_FIELD(fk_matchtype);
    1779        4656 :     JUMBLE_FIELD(fk_upd_action);
    1780        4656 :     JUMBLE_FIELD(fk_del_action);
    1781        4656 :     JUMBLE_NODE(fk_del_set_cols);
    1782        4656 :     JUMBLE_NODE(old_conpfeqop);
    1783        4656 :     JUMBLE_FIELD(old_pktable_oid);
    1784        4656 : }
    1785             : 
    1786             : static void
    1787          12 : _jumbleCreateTableSpaceStmt(JumbleState *jstate, Node *node)
    1788             : {
    1789          12 :     CreateTableSpaceStmt *expr = (CreateTableSpaceStmt *) node;
    1790             : 
    1791          12 :     JUMBLE_STRING(tablespacename);
    1792          12 :     JUMBLE_NODE(owner);
    1793          12 :     JUMBLE_STRING(location);
    1794          12 :     JUMBLE_NODE(options);
    1795          12 : }
    1796             : 
    1797             : static void
    1798           8 : _jumbleDropTableSpaceStmt(JumbleState *jstate, Node *node)
    1799             : {
    1800           8 :     DropTableSpaceStmt *expr = (DropTableSpaceStmt *) node;
    1801             : 
    1802           8 :     JUMBLE_STRING(tablespacename);
    1803           8 :     JUMBLE_FIELD(missing_ok);
    1804           8 : }
    1805             : 
    1806             : static void
    1807           8 : _jumbleAlterTableSpaceOptionsStmt(JumbleState *jstate, Node *node)
    1808             : {
    1809           8 :     AlterTableSpaceOptionsStmt *expr = (AlterTableSpaceOptionsStmt *) node;
    1810             : 
    1811           8 :     JUMBLE_STRING(tablespacename);
    1812           8 :     JUMBLE_NODE(options);
    1813           8 :     JUMBLE_FIELD(isReset);
    1814           8 : }
    1815             : 
    1816             : static void
    1817          10 : _jumbleAlterTableMoveAllStmt(JumbleState *jstate, Node *node)
    1818             : {
    1819          10 :     AlterTableMoveAllStmt *expr = (AlterTableMoveAllStmt *) node;
    1820             : 
    1821          10 :     JUMBLE_STRING(orig_tablespacename);
    1822          10 :     JUMBLE_FIELD(objtype);
    1823          10 :     JUMBLE_NODE(roles);
    1824          10 :     JUMBLE_STRING(new_tablespacename);
    1825          10 :     JUMBLE_FIELD(nowait);
    1826          10 : }
    1827             : 
    1828             : static void
    1829          10 : _jumbleCreateExtensionStmt(JumbleState *jstate, Node *node)
    1830             : {
    1831          10 :     CreateExtensionStmt *expr = (CreateExtensionStmt *) node;
    1832             : 
    1833          10 :     JUMBLE_STRING(extname);
    1834          10 :     JUMBLE_FIELD(if_not_exists);
    1835          10 :     JUMBLE_NODE(options);
    1836          10 : }
    1837             : 
    1838             : static void
    1839          16 : _jumbleAlterExtensionStmt(JumbleState *jstate, Node *node)
    1840             : {
    1841          16 :     AlterExtensionStmt *expr = (AlterExtensionStmt *) node;
    1842             : 
    1843          16 :     JUMBLE_STRING(extname);
    1844          16 :     JUMBLE_NODE(options);
    1845          16 : }
    1846             : 
    1847             : static void
    1848          90 : _jumbleAlterExtensionContentsStmt(JumbleState *jstate, Node *node)
    1849             : {
    1850          90 :     AlterExtensionContentsStmt *expr = (AlterExtensionContentsStmt *) node;
    1851             : 
    1852          90 :     JUMBLE_STRING(extname);
    1853          90 :     JUMBLE_FIELD(action);
    1854          90 :     JUMBLE_FIELD(objtype);
    1855          90 :     JUMBLE_NODE(object);
    1856          90 : }
    1857             : 
    1858             : static void
    1859          54 : _jumbleCreateFdwStmt(JumbleState *jstate, Node *node)
    1860             : {
    1861          54 :     CreateFdwStmt *expr = (CreateFdwStmt *) node;
    1862             : 
    1863          54 :     JUMBLE_STRING(fdwname);
    1864          54 :     JUMBLE_NODE(func_options);
    1865          54 :     JUMBLE_NODE(options);
    1866          54 : }
    1867             : 
    1868             : static void
    1869          38 : _jumbleAlterFdwStmt(JumbleState *jstate, Node *node)
    1870             : {
    1871          38 :     AlterFdwStmt *expr = (AlterFdwStmt *) node;
    1872             : 
    1873          38 :     JUMBLE_STRING(fdwname);
    1874          38 :     JUMBLE_NODE(func_options);
    1875          38 :     JUMBLE_NODE(options);
    1876          38 : }
    1877             : 
    1878             : static void
    1879          68 : _jumbleCreateForeignServerStmt(JumbleState *jstate, Node *node)
    1880             : {
    1881          68 :     CreateForeignServerStmt *expr = (CreateForeignServerStmt *) node;
    1882             : 
    1883          68 :     JUMBLE_STRING(servername);
    1884          68 :     JUMBLE_STRING(servertype);
    1885          68 :     JUMBLE_STRING(version);
    1886          68 :     JUMBLE_STRING(fdwname);
    1887          68 :     JUMBLE_FIELD(if_not_exists);
    1888          68 :     JUMBLE_NODE(options);
    1889          68 : }
    1890             : 
    1891             : static void
    1892          26 : _jumbleAlterForeignServerStmt(JumbleState *jstate, Node *node)
    1893             : {
    1894          26 :     AlterForeignServerStmt *expr = (AlterForeignServerStmt *) node;
    1895             : 
    1896          26 :     JUMBLE_STRING(servername);
    1897          26 :     JUMBLE_STRING(version);
    1898          26 :     JUMBLE_NODE(options);
    1899          26 :     JUMBLE_FIELD(has_version);
    1900          26 : }
    1901             : 
    1902             : static void
    1903          64 : _jumbleCreateForeignTableStmt(JumbleState *jstate, Node *node)
    1904             : {
    1905          64 :     CreateForeignTableStmt *expr = (CreateForeignTableStmt *) node;
    1906             : 
    1907          64 :     JUMBLE_NODE(base.relation);
    1908          64 :     JUMBLE_NODE(base.tableElts);
    1909          64 :     JUMBLE_NODE(base.inhRelations);
    1910          64 :     JUMBLE_NODE(base.partbound);
    1911          64 :     JUMBLE_NODE(base.partspec);
    1912          64 :     JUMBLE_NODE(base.ofTypename);
    1913          64 :     JUMBLE_NODE(base.constraints);
    1914          64 :     JUMBLE_NODE(base.nnconstraints);
    1915          64 :     JUMBLE_NODE(base.options);
    1916          64 :     JUMBLE_FIELD(base.oncommit);
    1917          64 :     JUMBLE_STRING(base.tablespacename);
    1918          64 :     JUMBLE_STRING(base.accessMethod);
    1919          64 :     JUMBLE_FIELD(base.if_not_exists);
    1920          64 :     JUMBLE_STRING(servername);
    1921          64 :     JUMBLE_NODE(options);
    1922          64 : }
    1923             : 
    1924             : static void
    1925          54 : _jumbleCreateUserMappingStmt(JumbleState *jstate, Node *node)
    1926             : {
    1927          54 :     CreateUserMappingStmt *expr = (CreateUserMappingStmt *) node;
    1928             : 
    1929          54 :     JUMBLE_NODE(user);
    1930          54 :     JUMBLE_STRING(servername);
    1931          54 :     JUMBLE_FIELD(if_not_exists);
    1932          54 :     JUMBLE_NODE(options);
    1933          54 : }
    1934             : 
    1935             : static void
    1936          22 : _jumbleAlterUserMappingStmt(JumbleState *jstate, Node *node)
    1937             : {
    1938          22 :     AlterUserMappingStmt *expr = (AlterUserMappingStmt *) node;
    1939             : 
    1940          22 :     JUMBLE_NODE(user);
    1941          22 :     JUMBLE_STRING(servername);
    1942          22 :     JUMBLE_NODE(options);
    1943          22 : }
    1944             : 
    1945             : static void
    1946          24 : _jumbleDropUserMappingStmt(JumbleState *jstate, Node *node)
    1947             : {
    1948          24 :     DropUserMappingStmt *expr = (DropUserMappingStmt *) node;
    1949             : 
    1950          24 :     JUMBLE_NODE(user);
    1951          24 :     JUMBLE_STRING(servername);
    1952          24 :     JUMBLE_FIELD(missing_ok);
    1953          24 : }
    1954             : 
    1955             : static void
    1956           8 : _jumbleImportForeignSchemaStmt(JumbleState *jstate, Node *node)
    1957             : {
    1958           8 :     ImportForeignSchemaStmt *expr = (ImportForeignSchemaStmt *) node;
    1959             : 
    1960           8 :     JUMBLE_STRING(server_name);
    1961           8 :     JUMBLE_STRING(remote_schema);
    1962           8 :     JUMBLE_STRING(local_schema);
    1963           8 :     JUMBLE_FIELD(list_type);
    1964           8 :     JUMBLE_NODE(table_list);
    1965           8 :     JUMBLE_NODE(options);
    1966           8 : }
    1967             : 
    1968             : static void
    1969         212 : _jumbleCreatePolicyStmt(JumbleState *jstate, Node *node)
    1970             : {
    1971         212 :     CreatePolicyStmt *expr = (CreatePolicyStmt *) node;
    1972             : 
    1973         212 :     JUMBLE_STRING(policy_name);
    1974         212 :     JUMBLE_NODE(table);
    1975         212 :     JUMBLE_STRING(cmd_name);
    1976         212 :     JUMBLE_FIELD(permissive);
    1977         212 :     JUMBLE_NODE(roles);
    1978         212 :     JUMBLE_NODE(qual);
    1979         212 :     JUMBLE_NODE(with_check);
    1980         212 : }
    1981             : 
    1982             : static void
    1983          28 : _jumbleAlterPolicyStmt(JumbleState *jstate, Node *node)
    1984             : {
    1985          28 :     AlterPolicyStmt *expr = (AlterPolicyStmt *) node;
    1986             : 
    1987          28 :     JUMBLE_STRING(policy_name);
    1988          28 :     JUMBLE_NODE(table);
    1989          28 :     JUMBLE_NODE(roles);
    1990          28 :     JUMBLE_NODE(qual);
    1991          28 :     JUMBLE_NODE(with_check);
    1992          28 : }
    1993             : 
    1994             : static void
    1995          14 : _jumbleCreateAmStmt(JumbleState *jstate, Node *node)
    1996             : {
    1997          14 :     CreateAmStmt *expr = (CreateAmStmt *) node;
    1998             : 
    1999          14 :     JUMBLE_STRING(amname);
    2000          14 :     JUMBLE_NODE(handler_name);
    2001          14 :     JUMBLE_FIELD(amtype);
    2002          14 : }
    2003             : 
    2004             : static void
    2005         764 : _jumbleCreateTrigStmt(JumbleState *jstate, Node *node)
    2006             : {
    2007         764 :     CreateTrigStmt *expr = (CreateTrigStmt *) node;
    2008             : 
    2009         764 :     JUMBLE_FIELD(replace);
    2010         764 :     JUMBLE_FIELD(isconstraint);
    2011         764 :     JUMBLE_STRING(trigname);
    2012         764 :     JUMBLE_NODE(relation);
    2013         764 :     JUMBLE_NODE(funcname);
    2014         764 :     JUMBLE_NODE(args);
    2015         764 :     JUMBLE_FIELD(row);
    2016         764 :     JUMBLE_FIELD(timing);
    2017         764 :     JUMBLE_FIELD(events);
    2018         764 :     JUMBLE_NODE(columns);
    2019         764 :     JUMBLE_NODE(whenClause);
    2020         764 :     JUMBLE_NODE(transitionRels);
    2021         764 :     JUMBLE_FIELD(deferrable);
    2022         764 :     JUMBLE_FIELD(initdeferred);
    2023         764 :     JUMBLE_NODE(constrrel);
    2024         764 : }
    2025             : 
    2026             : static void
    2027          56 : _jumbleCreateEventTrigStmt(JumbleState *jstate, Node *node)
    2028             : {
    2029          56 :     CreateEventTrigStmt *expr = (CreateEventTrigStmt *) node;
    2030             : 
    2031          56 :     JUMBLE_STRING(trigname);
    2032          56 :     JUMBLE_STRING(eventname);
    2033          56 :     JUMBLE_NODE(whenclause);
    2034          56 :     JUMBLE_NODE(funcname);
    2035          56 : }
    2036             : 
    2037             : static void
    2038          14 : _jumbleAlterEventTrigStmt(JumbleState *jstate, Node *node)
    2039             : {
    2040          14 :     AlterEventTrigStmt *expr = (AlterEventTrigStmt *) node;
    2041             : 
    2042          14 :     JUMBLE_STRING(trigname);
    2043          14 :     JUMBLE_FIELD(tgenabled);
    2044          14 : }
    2045             : 
    2046             : static void
    2047           4 : _jumbleCreatePLangStmt(JumbleState *jstate, Node *node)
    2048             : {
    2049           4 :     CreatePLangStmt *expr = (CreatePLangStmt *) node;
    2050             : 
    2051           4 :     JUMBLE_FIELD(replace);
    2052           4 :     JUMBLE_STRING(plname);
    2053           4 :     JUMBLE_NODE(plhandler);
    2054           4 :     JUMBLE_NODE(plinline);
    2055           4 :     JUMBLE_NODE(plvalidator);
    2056           4 :     JUMBLE_FIELD(pltrusted);
    2057           4 : }
    2058             : 
    2059             : static void
    2060         468 : _jumbleCreateRoleStmt(JumbleState *jstate, Node *node)
    2061             : {
    2062         468 :     CreateRoleStmt *expr = (CreateRoleStmt *) node;
    2063             : 
    2064         468 :     JUMBLE_FIELD(stmt_type);
    2065         468 :     JUMBLE_STRING(role);
    2066         468 :     JUMBLE_NODE(options);
    2067         468 : }
    2068             : 
    2069             : static void
    2070         100 : _jumbleAlterRoleStmt(JumbleState *jstate, Node *node)
    2071             : {
    2072         100 :     AlterRoleStmt *expr = (AlterRoleStmt *) node;
    2073             : 
    2074         100 :     JUMBLE_NODE(role);
    2075         100 :     JUMBLE_NODE(options);
    2076         100 :     JUMBLE_FIELD(action);
    2077         100 : }
    2078             : 
    2079             : static void
    2080           2 : _jumbleAlterRoleSetStmt(JumbleState *jstate, Node *node)
    2081             : {
    2082           2 :     AlterRoleSetStmt *expr = (AlterRoleSetStmt *) node;
    2083             : 
    2084           2 :     JUMBLE_NODE(role);
    2085           2 :     JUMBLE_STRING(database);
    2086           2 :     JUMBLE_NODE(setstmt);
    2087           2 : }
    2088             : 
    2089             : static void
    2090         522 : _jumbleDropRoleStmt(JumbleState *jstate, Node *node)
    2091             : {
    2092         522 :     DropRoleStmt *expr = (DropRoleStmt *) node;
    2093             : 
    2094         522 :     JUMBLE_NODE(roles);
    2095         522 :     JUMBLE_FIELD(missing_ok);
    2096         522 : }
    2097             : 
    2098             : static void
    2099         152 : _jumbleCreateSeqStmt(JumbleState *jstate, Node *node)
    2100             : {
    2101         152 :     CreateSeqStmt *expr = (CreateSeqStmt *) node;
    2102             : 
    2103         152 :     JUMBLE_NODE(sequence);
    2104         152 :     JUMBLE_NODE(options);
    2105         152 :     JUMBLE_FIELD(ownerId);
    2106         152 :     JUMBLE_FIELD(for_identity);
    2107         152 :     JUMBLE_FIELD(if_not_exists);
    2108         152 : }
    2109             : 
    2110             : static void
    2111          50 : _jumbleAlterSeqStmt(JumbleState *jstate, Node *node)
    2112             : {
    2113          50 :     AlterSeqStmt *expr = (AlterSeqStmt *) node;
    2114             : 
    2115          50 :     JUMBLE_NODE(sequence);
    2116          50 :     JUMBLE_NODE(options);
    2117          50 :     JUMBLE_FIELD(for_identity);
    2118          50 :     JUMBLE_FIELD(missing_ok);
    2119          50 : }
    2120             : 
    2121             : static void
    2122         634 : _jumbleDefineStmt(JumbleState *jstate, Node *node)
    2123             : {
    2124         634 :     DefineStmt *expr = (DefineStmt *) node;
    2125             : 
    2126         634 :     JUMBLE_FIELD(kind);
    2127         634 :     JUMBLE_FIELD(oldstyle);
    2128         634 :     JUMBLE_NODE(defnames);
    2129         634 :     JUMBLE_NODE(args);
    2130         634 :     JUMBLE_NODE(definition);
    2131         634 :     JUMBLE_FIELD(if_not_exists);
    2132         634 :     JUMBLE_FIELD(replace);
    2133         634 : }
    2134             : 
    2135             : static void
    2136         280 : _jumbleCreateDomainStmt(JumbleState *jstate, Node *node)
    2137             : {
    2138         280 :     CreateDomainStmt *expr = (CreateDomainStmt *) node;
    2139             : 
    2140         280 :     JUMBLE_NODE(domainname);
    2141         280 :     JUMBLE_NODE(typeName);
    2142         280 :     JUMBLE_NODE(collClause);
    2143         280 :     JUMBLE_NODE(constraints);
    2144         280 : }
    2145             : 
    2146             : static void
    2147          30 : _jumbleCreateOpClassStmt(JumbleState *jstate, Node *node)
    2148             : {
    2149          30 :     CreateOpClassStmt *expr = (CreateOpClassStmt *) node;
    2150             : 
    2151          30 :     JUMBLE_NODE(opclassname);
    2152          30 :     JUMBLE_NODE(opfamilyname);
    2153          30 :     JUMBLE_STRING(amname);
    2154          30 :     JUMBLE_NODE(datatype);
    2155          30 :     JUMBLE_NODE(items);
    2156          30 :     JUMBLE_FIELD(isDefault);
    2157          30 : }
    2158             : 
    2159             : static void
    2160         260 : _jumbleCreateOpClassItem(JumbleState *jstate, Node *node)
    2161             : {
    2162         260 :     CreateOpClassItem *expr = (CreateOpClassItem *) node;
    2163             : 
    2164         260 :     JUMBLE_FIELD(itemtype);
    2165         260 :     JUMBLE_NODE(name);
    2166         260 :     JUMBLE_FIELD(number);
    2167         260 :     JUMBLE_NODE(order_family);
    2168         260 :     JUMBLE_NODE(class_args);
    2169         260 :     JUMBLE_NODE(storedtype);
    2170         260 : }
    2171             : 
    2172             : static void
    2173          42 : _jumbleCreateOpFamilyStmt(JumbleState *jstate, Node *node)
    2174             : {
    2175          42 :     CreateOpFamilyStmt *expr = (CreateOpFamilyStmt *) node;
    2176             : 
    2177          42 :     JUMBLE_NODE(opfamilyname);
    2178          42 :     JUMBLE_STRING(amname);
    2179          42 : }
    2180             : 
    2181             : static void
    2182          92 : _jumbleAlterOpFamilyStmt(JumbleState *jstate, Node *node)
    2183             : {
    2184          92 :     AlterOpFamilyStmt *expr = (AlterOpFamilyStmt *) node;
    2185             : 
    2186          92 :     JUMBLE_NODE(opfamilyname);
    2187          92 :     JUMBLE_STRING(amname);
    2188          92 :     JUMBLE_FIELD(isDrop);
    2189          92 :     JUMBLE_NODE(items);
    2190          92 : }
    2191             : 
    2192             : static void
    2193        5892 : _jumbleDropStmt(JumbleState *jstate, Node *node)
    2194             : {
    2195        5892 :     DropStmt *expr = (DropStmt *) node;
    2196             : 
    2197        5892 :     JUMBLE_NODE(objects);
    2198        5892 :     JUMBLE_FIELD(removeType);
    2199        5892 :     JUMBLE_FIELD(behavior);
    2200        5892 :     JUMBLE_FIELD(missing_ok);
    2201        5892 :     JUMBLE_FIELD(concurrent);
    2202        5892 : }
    2203             : 
    2204             : static void
    2205         386 : _jumbleTruncateStmt(JumbleState *jstate, Node *node)
    2206             : {
    2207         386 :     TruncateStmt *expr = (TruncateStmt *) node;
    2208             : 
    2209         386 :     JUMBLE_NODE(relations);
    2210         386 :     JUMBLE_FIELD(restart_seqs);
    2211         386 :     JUMBLE_FIELD(behavior);
    2212         386 : }
    2213             : 
    2214             : static void
    2215         220 : _jumbleCommentStmt(JumbleState *jstate, Node *node)
    2216             : {
    2217         220 :     CommentStmt *expr = (CommentStmt *) node;
    2218             : 
    2219         220 :     JUMBLE_FIELD(objtype);
    2220         220 :     JUMBLE_NODE(object);
    2221         220 :     JUMBLE_STRING(comment);
    2222         220 : }
    2223             : 
    2224             : static void
    2225          16 : _jumbleSecLabelStmt(JumbleState *jstate, Node *node)
    2226             : {
    2227          16 :     SecLabelStmt *expr = (SecLabelStmt *) node;
    2228             : 
    2229          16 :     JUMBLE_FIELD(objtype);
    2230          16 :     JUMBLE_NODE(object);
    2231          16 :     JUMBLE_STRING(provider);
    2232          16 :     JUMBLE_STRING(label);
    2233          16 : }
    2234             : 
    2235             : static void
    2236         850 : _jumbleDeclareCursorStmt(JumbleState *jstate, Node *node)
    2237             : {
    2238         850 :     DeclareCursorStmt *expr = (DeclareCursorStmt *) node;
    2239             : 
    2240         850 :     JUMBLE_STRING(portalname);
    2241         850 :     JUMBLE_FIELD(options);
    2242         850 :     JUMBLE_NODE(query);
    2243         850 : }
    2244             : 
    2245             : static void
    2246          76 : _jumbleClosePortalStmt(JumbleState *jstate, Node *node)
    2247             : {
    2248          76 :     ClosePortalStmt *expr = (ClosePortalStmt *) node;
    2249             : 
    2250          76 :     JUMBLE_STRING(portalname);
    2251          76 : }
    2252             : 
    2253             : static void
    2254        1090 : _jumbleFetchStmt(JumbleState *jstate, Node *node)
    2255             : {
    2256        1090 :     FetchStmt *expr = (FetchStmt *) node;
    2257             : 
    2258        1090 :     JUMBLE_FIELD(direction);
    2259        1090 :     JUMBLE_FIELD(howMany);
    2260        1090 :     JUMBLE_STRING(portalname);
    2261        1090 :     JUMBLE_FIELD(ismove);
    2262        1090 : }
    2263             : 
    2264             : static void
    2265        1534 : _jumbleIndexStmt(JumbleState *jstate, Node *node)
    2266             : {
    2267        1534 :     IndexStmt *expr = (IndexStmt *) node;
    2268             : 
    2269        1534 :     JUMBLE_STRING(idxname);
    2270        1534 :     JUMBLE_NODE(relation);
    2271        1534 :     JUMBLE_STRING(accessMethod);
    2272        1534 :     JUMBLE_STRING(tableSpace);
    2273        1534 :     JUMBLE_NODE(indexParams);
    2274        1534 :     JUMBLE_NODE(indexIncludingParams);
    2275        1534 :     JUMBLE_NODE(options);
    2276        1534 :     JUMBLE_NODE(whereClause);
    2277        1534 :     JUMBLE_NODE(excludeOpNames);
    2278        1534 :     JUMBLE_STRING(idxcomment);
    2279        1534 :     JUMBLE_FIELD(indexOid);
    2280        1534 :     JUMBLE_FIELD(oldNumber);
    2281        1534 :     JUMBLE_FIELD(oldCreateSubid);
    2282        1534 :     JUMBLE_FIELD(oldFirstRelfilelocatorSubid);
    2283        1534 :     JUMBLE_FIELD(unique);
    2284        1534 :     JUMBLE_FIELD(nulls_not_distinct);
    2285        1534 :     JUMBLE_FIELD(primary);
    2286        1534 :     JUMBLE_FIELD(isconstraint);
    2287        1534 :     JUMBLE_FIELD(iswithoutoverlaps);
    2288        1534 :     JUMBLE_FIELD(deferrable);
    2289        1534 :     JUMBLE_FIELD(initdeferred);
    2290        1534 :     JUMBLE_FIELD(transformed);
    2291        1534 :     JUMBLE_FIELD(concurrent);
    2292        1534 :     JUMBLE_FIELD(if_not_exists);
    2293        1534 :     JUMBLE_FIELD(reset_default_tblspc);
    2294        1534 : }
    2295             : 
    2296             : static void
    2297         212 : _jumbleCreateStatsStmt(JumbleState *jstate, Node *node)
    2298             : {
    2299         212 :     CreateStatsStmt *expr = (CreateStatsStmt *) node;
    2300             : 
    2301         212 :     JUMBLE_NODE(defnames);
    2302         212 :     JUMBLE_NODE(stat_types);
    2303         212 :     JUMBLE_NODE(exprs);
    2304         212 :     JUMBLE_NODE(relations);
    2305         212 :     JUMBLE_STRING(stxcomment);
    2306         212 :     JUMBLE_FIELD(transformed);
    2307         212 :     JUMBLE_FIELD(if_not_exists);
    2308         212 : }
    2309             : 
    2310             : static void
    2311         518 : _jumbleStatsElem(JumbleState *jstate, Node *node)
    2312             : {
    2313         518 :     StatsElem *expr = (StatsElem *) node;
    2314             : 
    2315         518 :     JUMBLE_STRING(name);
    2316         518 :     JUMBLE_NODE(expr);
    2317         518 : }
    2318             : 
    2319             : static void
    2320           8 : _jumbleAlterStatsStmt(JumbleState *jstate, Node *node)
    2321             : {
    2322           8 :     AlterStatsStmt *expr = (AlterStatsStmt *) node;
    2323             : 
    2324           8 :     JUMBLE_NODE(defnames);
    2325           8 :     JUMBLE_NODE(stxstattarget);
    2326           8 :     JUMBLE_FIELD(missing_ok);
    2327           8 : }
    2328             : 
    2329             : static void
    2330        2054 : _jumbleCreateFunctionStmt(JumbleState *jstate, Node *node)
    2331             : {
    2332        2054 :     CreateFunctionStmt *expr = (CreateFunctionStmt *) node;
    2333             : 
    2334        2054 :     JUMBLE_FIELD(is_procedure);
    2335        2054 :     JUMBLE_FIELD(replace);
    2336        2054 :     JUMBLE_NODE(funcname);
    2337        2054 :     JUMBLE_NODE(parameters);
    2338        2054 :     JUMBLE_NODE(returnType);
    2339        2054 :     JUMBLE_NODE(options);
    2340        2054 :     JUMBLE_NODE(sql_body);
    2341        2054 : }
    2342             : 
    2343             : static void
    2344        5796 : _jumbleFunctionParameter(JumbleState *jstate, Node *node)
    2345             : {
    2346        5796 :     FunctionParameter *expr = (FunctionParameter *) node;
    2347             : 
    2348        5796 :     JUMBLE_STRING(name);
    2349        5796 :     JUMBLE_NODE(argType);
    2350        5796 :     JUMBLE_FIELD(mode);
    2351        5796 :     JUMBLE_NODE(defexpr);
    2352        5796 : }
    2353             : 
    2354             : static void
    2355          52 : _jumbleAlterFunctionStmt(JumbleState *jstate, Node *node)
    2356             : {
    2357          52 :     AlterFunctionStmt *expr = (AlterFunctionStmt *) node;
    2358             : 
    2359          52 :     JUMBLE_FIELD(objtype);
    2360          52 :     JUMBLE_NODE(func);
    2361          52 :     JUMBLE_NODE(actions);
    2362          52 : }
    2363             : 
    2364             : static void
    2365         164 : _jumbleDoStmt(JumbleState *jstate, Node *node)
    2366             : {
    2367         164 :     DoStmt *expr = (DoStmt *) node;
    2368             : 
    2369         164 :     JUMBLE_NODE(args);
    2370         164 : }
    2371             : 
    2372             : static void
    2373         100 : _jumbleCallStmt(JumbleState *jstate, Node *node)
    2374             : {
    2375         100 :     CallStmt *expr = (CallStmt *) node;
    2376             : 
    2377         100 :     JUMBLE_NODE(funcexpr);
    2378         100 :     JUMBLE_NODE(outargs);
    2379         100 : }
    2380             : 
    2381             : static void
    2382         412 : _jumbleRenameStmt(JumbleState *jstate, Node *node)
    2383             : {
    2384         412 :     RenameStmt *expr = (RenameStmt *) node;
    2385             : 
    2386         412 :     JUMBLE_FIELD(renameType);
    2387         412 :     JUMBLE_FIELD(relationType);
    2388         412 :     JUMBLE_NODE(relation);
    2389         412 :     JUMBLE_NODE(object);
    2390         412 :     JUMBLE_STRING(subname);
    2391         412 :     JUMBLE_STRING(newname);
    2392         412 :     JUMBLE_FIELD(behavior);
    2393         412 :     JUMBLE_FIELD(missing_ok);
    2394         412 : }
    2395             : 
    2396             : static void
    2397           0 : _jumbleAlterObjectDependsStmt(JumbleState *jstate, Node *node)
    2398             : {
    2399           0 :     AlterObjectDependsStmt *expr = (AlterObjectDependsStmt *) node;
    2400             : 
    2401           0 :     JUMBLE_FIELD(objectType);
    2402           0 :     JUMBLE_NODE(relation);
    2403           0 :     JUMBLE_NODE(object);
    2404           0 :     JUMBLE_NODE(extname);
    2405           0 :     JUMBLE_FIELD(remove);
    2406           0 : }
    2407             : 
    2408             : static void
    2409         124 : _jumbleAlterObjectSchemaStmt(JumbleState *jstate, Node *node)
    2410             : {
    2411         124 :     AlterObjectSchemaStmt *expr = (AlterObjectSchemaStmt *) node;
    2412             : 
    2413         124 :     JUMBLE_FIELD(objectType);
    2414         124 :     JUMBLE_NODE(relation);
    2415         124 :     JUMBLE_NODE(object);
    2416         124 :     JUMBLE_STRING(newschema);
    2417         124 :     JUMBLE_FIELD(missing_ok);
    2418         124 : }
    2419             : 
    2420             : static void
    2421         180 : _jumbleAlterOwnerStmt(JumbleState *jstate, Node *node)
    2422             : {
    2423         180 :     AlterOwnerStmt *expr = (AlterOwnerStmt *) node;
    2424             : 
    2425         180 :     JUMBLE_FIELD(objectType);
    2426         180 :     JUMBLE_NODE(relation);
    2427         180 :     JUMBLE_NODE(object);
    2428         180 :     JUMBLE_NODE(newowner);
    2429         180 : }
    2430             : 
    2431             : static void
    2432          56 : _jumbleAlterOperatorStmt(JumbleState *jstate, Node *node)
    2433             : {
    2434          56 :     AlterOperatorStmt *expr = (AlterOperatorStmt *) node;
    2435             : 
    2436          56 :     JUMBLE_NODE(opername);
    2437          56 :     JUMBLE_NODE(options);
    2438          56 : }
    2439             : 
    2440             : static void
    2441           8 : _jumbleAlterTypeStmt(JumbleState *jstate, Node *node)
    2442             : {
    2443           8 :     AlterTypeStmt *expr = (AlterTypeStmt *) node;
    2444             : 
    2445           8 :     JUMBLE_NODE(typeName);
    2446           8 :     JUMBLE_NODE(options);
    2447           8 : }
    2448             : 
    2449             : static void
    2450         270 : _jumbleRuleStmt(JumbleState *jstate, Node *node)
    2451             : {
    2452         270 :     RuleStmt *expr = (RuleStmt *) node;
    2453             : 
    2454         270 :     JUMBLE_NODE(relation);
    2455         270 :     JUMBLE_STRING(rulename);
    2456         270 :     JUMBLE_NODE(whereClause);
    2457         270 :     JUMBLE_FIELD(event);
    2458         270 :     JUMBLE_FIELD(instead);
    2459         270 :     JUMBLE_NODE(actions);
    2460         270 :     JUMBLE_FIELD(replace);
    2461         270 : }
    2462             : 
    2463             : static void
    2464          14 : _jumbleNotifyStmt(JumbleState *jstate, Node *node)
    2465             : {
    2466          14 :     NotifyStmt *expr = (NotifyStmt *) node;
    2467             : 
    2468          14 :     JUMBLE_STRING(conditionname);
    2469          14 :     JUMBLE_STRING(payload);
    2470          14 : }
    2471             : 
    2472             : static void
    2473           4 : _jumbleListenStmt(JumbleState *jstate, Node *node)
    2474             : {
    2475           4 :     ListenStmt *expr = (ListenStmt *) node;
    2476             : 
    2477           4 :     JUMBLE_STRING(conditionname);
    2478           4 : }
    2479             : 
    2480             : static void
    2481           4 : _jumbleUnlistenStmt(JumbleState *jstate, Node *node)
    2482             : {
    2483           4 :     UnlistenStmt *expr = (UnlistenStmt *) node;
    2484             : 
    2485           4 :     JUMBLE_STRING(conditionname);
    2486           4 : }
    2487             : 
    2488             : static void
    2489        3426 : _jumbleTransactionStmt(JumbleState *jstate, Node *node)
    2490             : {
    2491        3426 :     TransactionStmt *expr = (TransactionStmt *) node;
    2492             : 
    2493        3426 :     JUMBLE_FIELD(kind);
    2494        3426 :     JUMBLE_NODE(options);
    2495        3426 :     JUMBLE_FIELD(chain);
    2496        3426 :     JUMBLE_LOCATION(location);
    2497        3426 : }
    2498             : 
    2499             : static void
    2500         192 : _jumbleCompositeTypeStmt(JumbleState *jstate, Node *node)
    2501             : {
    2502         192 :     CompositeTypeStmt *expr = (CompositeTypeStmt *) node;
    2503             : 
    2504         192 :     JUMBLE_NODE(typevar);
    2505         192 :     JUMBLE_NODE(coldeflist);
    2506         192 : }
    2507             : 
    2508             : static void
    2509          46 : _jumbleCreateEnumStmt(JumbleState *jstate, Node *node)
    2510             : {
    2511          46 :     CreateEnumStmt *expr = (CreateEnumStmt *) node;
    2512             : 
    2513          46 :     JUMBLE_NODE(typeName);
    2514          46 :     JUMBLE_NODE(vals);
    2515          46 : }
    2516             : 
    2517             : static void
    2518          54 : _jumbleCreateRangeStmt(JumbleState *jstate, Node *node)
    2519             : {
    2520          54 :     CreateRangeStmt *expr = (CreateRangeStmt *) node;
    2521             : 
    2522          54 :     JUMBLE_NODE(typeName);
    2523          54 :     JUMBLE_NODE(params);
    2524          54 : }
    2525             : 
    2526             : static void
    2527          96 : _jumbleAlterEnumStmt(JumbleState *jstate, Node *node)
    2528             : {
    2529          96 :     AlterEnumStmt *expr = (AlterEnumStmt *) node;
    2530             : 
    2531          96 :     JUMBLE_NODE(typeName);
    2532          96 :     JUMBLE_STRING(oldVal);
    2533          96 :     JUMBLE_STRING(newVal);
    2534          96 :     JUMBLE_STRING(newValNeighbor);
    2535          96 :     JUMBLE_FIELD(newValIsAfter);
    2536          96 :     JUMBLE_FIELD(skipIfNewValExists);
    2537          96 : }
    2538             : 
    2539             : static void
    2540         950 : _jumbleViewStmt(JumbleState *jstate, Node *node)
    2541             : {
    2542         950 :     ViewStmt *expr = (ViewStmt *) node;
    2543             : 
    2544         950 :     JUMBLE_NODE(view);
    2545         950 :     JUMBLE_NODE(aliases);
    2546         950 :     JUMBLE_NODE(query);
    2547         950 :     JUMBLE_FIELD(replace);
    2548         950 :     JUMBLE_NODE(options);
    2549         950 :     JUMBLE_FIELD(withCheckOption);
    2550         950 : }
    2551             : 
    2552             : static void
    2553           4 : _jumbleLoadStmt(JumbleState *jstate, Node *node)
    2554             : {
    2555           4 :     LoadStmt *expr = (LoadStmt *) node;
    2556             : 
    2557           4 :     JUMBLE_STRING(filename);
    2558           4 : }
    2559             : 
    2560             : static void
    2561           8 : _jumbleCreatedbStmt(JumbleState *jstate, Node *node)
    2562             : {
    2563           8 :     CreatedbStmt *expr = (CreatedbStmt *) node;
    2564             : 
    2565           8 :     JUMBLE_STRING(dbname);
    2566           8 :     JUMBLE_NODE(options);
    2567           8 : }
    2568             : 
    2569             : static void
    2570           4 : _jumbleAlterDatabaseStmt(JumbleState *jstate, Node *node)
    2571             : {
    2572           4 :     AlterDatabaseStmt *expr = (AlterDatabaseStmt *) node;
    2573             : 
    2574           4 :     JUMBLE_STRING(dbname);
    2575           4 :     JUMBLE_NODE(options);
    2576           4 : }
    2577             : 
    2578             : static void
    2579           2 : _jumbleAlterDatabaseRefreshCollStmt(JumbleState *jstate, Node *node)
    2580             : {
    2581           2 :     AlterDatabaseRefreshCollStmt *expr = (AlterDatabaseRefreshCollStmt *) node;
    2582             : 
    2583           2 :     JUMBLE_STRING(dbname);
    2584           2 : }
    2585             : 
    2586             : static void
    2587          28 : _jumbleAlterDatabaseSetStmt(JumbleState *jstate, Node *node)
    2588             : {
    2589          28 :     AlterDatabaseSetStmt *expr = (AlterDatabaseSetStmt *) node;
    2590             : 
    2591          28 :     JUMBLE_STRING(dbname);
    2592          28 :     JUMBLE_NODE(setstmt);
    2593          28 : }
    2594             : 
    2595             : static void
    2596          12 : _jumbleDropdbStmt(JumbleState *jstate, Node *node)
    2597             : {
    2598          12 :     DropdbStmt *expr = (DropdbStmt *) node;
    2599             : 
    2600          12 :     JUMBLE_STRING(dbname);
    2601          12 :     JUMBLE_FIELD(missing_ok);
    2602          12 :     JUMBLE_NODE(options);
    2603          12 : }
    2604             : 
    2605             : static void
    2606           0 : _jumbleAlterSystemStmt(JumbleState *jstate, Node *node)
    2607             : {
    2608           0 :     AlterSystemStmt *expr = (AlterSystemStmt *) node;
    2609             : 
    2610           0 :     JUMBLE_NODE(setstmt);
    2611           0 : }
    2612             : 
    2613             : static void
    2614          60 : _jumbleClusterStmt(JumbleState *jstate, Node *node)
    2615             : {
    2616          60 :     ClusterStmt *expr = (ClusterStmt *) node;
    2617             : 
    2618          60 :     JUMBLE_NODE(relation);
    2619          60 :     JUMBLE_STRING(indexname);
    2620          60 :     JUMBLE_NODE(params);
    2621          60 : }
    2622             : 
    2623             : static void
    2624        1010 : _jumbleVacuumStmt(JumbleState *jstate, Node *node)
    2625             : {
    2626        1010 :     VacuumStmt *expr = (VacuumStmt *) node;
    2627             : 
    2628        1010 :     JUMBLE_NODE(options);
    2629        1010 :     JUMBLE_NODE(rels);
    2630        1010 :     JUMBLE_FIELD(is_vacuumcmd);
    2631        1010 : }
    2632             : 
    2633             : static void
    2634        1046 : _jumbleVacuumRelation(JumbleState *jstate, Node *node)
    2635             : {
    2636        1046 :     VacuumRelation *expr = (VacuumRelation *) node;
    2637             : 
    2638        1046 :     JUMBLE_NODE(relation);
    2639        1046 :     JUMBLE_FIELD(oid);
    2640        1046 :     JUMBLE_NODE(va_cols);
    2641        1046 : }
    2642             : 
    2643             : static void
    2644        6812 : _jumbleExplainStmt(JumbleState *jstate, Node *node)
    2645             : {
    2646        6812 :     ExplainStmt *expr = (ExplainStmt *) node;
    2647             : 
    2648        6812 :     JUMBLE_NODE(query);
    2649        6812 :     JUMBLE_NODE(options);
    2650        6812 : }
    2651             : 
    2652             : static void
    2653         608 : _jumbleCreateTableAsStmt(JumbleState *jstate, Node *node)
    2654             : {
    2655         608 :     CreateTableAsStmt *expr = (CreateTableAsStmt *) node;
    2656             : 
    2657         608 :     JUMBLE_NODE(query);
    2658         608 :     JUMBLE_NODE(into);
    2659         608 :     JUMBLE_FIELD(objtype);
    2660         608 :     JUMBLE_FIELD(is_select_into);
    2661         608 :     JUMBLE_FIELD(if_not_exists);
    2662         608 : }
    2663             : 
    2664             : static void
    2665          84 : _jumbleRefreshMatViewStmt(JumbleState *jstate, Node *node)
    2666             : {
    2667          84 :     RefreshMatViewStmt *expr = (RefreshMatViewStmt *) node;
    2668             : 
    2669          84 :     JUMBLE_FIELD(concurrent);
    2670          84 :     JUMBLE_FIELD(skipData);
    2671          84 :     JUMBLE_NODE(relation);
    2672          84 : }
    2673             : 
    2674             : static void
    2675          14 : _jumbleCheckPointStmt(JumbleState *jstate, Node *node)
    2676             : {
    2677          14 :     CheckPointStmt *expr = (CheckPointStmt *) node;
    2678             : 
    2679             :     (void) expr;
    2680          14 : }
    2681             : 
    2682             : static void
    2683           8 : _jumbleDiscardStmt(JumbleState *jstate, Node *node)
    2684             : {
    2685           8 :     DiscardStmt *expr = (DiscardStmt *) node;
    2686             : 
    2687           8 :     JUMBLE_FIELD(target);
    2688           8 : }
    2689             : 
    2690             : static void
    2691         132 : _jumbleLockStmt(JumbleState *jstate, Node *node)
    2692             : {
    2693         132 :     LockStmt *expr = (LockStmt *) node;
    2694             : 
    2695         132 :     JUMBLE_NODE(relations);
    2696         132 :     JUMBLE_FIELD(mode);
    2697         132 :     JUMBLE_FIELD(nowait);
    2698         132 : }
    2699             : 
    2700             : static void
    2701          32 : _jumbleConstraintsSetStmt(JumbleState *jstate, Node *node)
    2702             : {
    2703          32 :     ConstraintsSetStmt *expr = (ConstraintsSetStmt *) node;
    2704             : 
    2705          32 :     JUMBLE_NODE(constraints);
    2706          32 :     JUMBLE_FIELD(deferred);
    2707          32 : }
    2708             : 
    2709             : static void
    2710         264 : _jumbleReindexStmt(JumbleState *jstate, Node *node)
    2711             : {
    2712         264 :     ReindexStmt *expr = (ReindexStmt *) node;
    2713             : 
    2714         264 :     JUMBLE_FIELD(kind);
    2715         264 :     JUMBLE_NODE(relation);
    2716         264 :     JUMBLE_STRING(name);
    2717         264 :     JUMBLE_NODE(params);
    2718         264 : }
    2719             : 
    2720             : static void
    2721          20 : _jumbleCreateConversionStmt(JumbleState *jstate, Node *node)
    2722             : {
    2723          20 :     CreateConversionStmt *expr = (CreateConversionStmt *) node;
    2724             : 
    2725          20 :     JUMBLE_NODE(conversion_name);
    2726          20 :     JUMBLE_STRING(for_encoding_name);
    2727          20 :     JUMBLE_STRING(to_encoding_name);
    2728          20 :     JUMBLE_NODE(func_name);
    2729          20 :     JUMBLE_FIELD(def);
    2730          20 : }
    2731             : 
    2732             : static void
    2733          48 : _jumbleCreateCastStmt(JumbleState *jstate, Node *node)
    2734             : {
    2735          48 :     CreateCastStmt *expr = (CreateCastStmt *) node;
    2736             : 
    2737          48 :     JUMBLE_NODE(sourcetype);
    2738          48 :     JUMBLE_NODE(targettype);
    2739          48 :     JUMBLE_NODE(func);
    2740          48 :     JUMBLE_FIELD(context);
    2741          48 :     JUMBLE_FIELD(inout);
    2742          48 : }
    2743             : 
    2744             : static void
    2745           2 : _jumbleCreateTransformStmt(JumbleState *jstate, Node *node)
    2746             : {
    2747           2 :     CreateTransformStmt *expr = (CreateTransformStmt *) node;
    2748             : 
    2749           2 :     JUMBLE_FIELD(replace);
    2750           2 :     JUMBLE_NODE(type_name);
    2751           2 :     JUMBLE_STRING(lang);
    2752           2 :     JUMBLE_NODE(fromsql);
    2753           2 :     JUMBLE_NODE(tosql);
    2754           2 : }
    2755             : 
    2756             : static void
    2757         240 : _jumblePrepareStmt(JumbleState *jstate, Node *node)
    2758             : {
    2759         240 :     PrepareStmt *expr = (PrepareStmt *) node;
    2760             : 
    2761         240 :     JUMBLE_STRING(name);
    2762         240 :     JUMBLE_NODE(argtypes);
    2763         240 :     JUMBLE_NODE(query);
    2764         240 : }
    2765             : 
    2766             : static void
    2767        7450 : _jumbleExecuteStmt(JumbleState *jstate, Node *node)
    2768             : {
    2769        7450 :     ExecuteStmt *expr = (ExecuteStmt *) node;
    2770             : 
    2771        7450 :     JUMBLE_STRING(name);
    2772        7450 :     JUMBLE_NODE(params);
    2773        7450 : }
    2774             : 
    2775             : static void
    2776          76 : _jumbleDeallocateStmt(JumbleState *jstate, Node *node)
    2777             : {
    2778          76 :     DeallocateStmt *expr = (DeallocateStmt *) node;
    2779             : 
    2780          76 :     JUMBLE_FIELD(isall);
    2781          76 :     JUMBLE_LOCATION(location);
    2782          76 : }
    2783             : 
    2784             : static void
    2785          42 : _jumbleDropOwnedStmt(JumbleState *jstate, Node *node)
    2786             : {
    2787          42 :     DropOwnedStmt *expr = (DropOwnedStmt *) node;
    2788             : 
    2789          42 :     JUMBLE_NODE(roles);
    2790          42 :     JUMBLE_FIELD(behavior);
    2791          42 : }
    2792             : 
    2793             : static void
    2794          16 : _jumbleReassignOwnedStmt(JumbleState *jstate, Node *node)
    2795             : {
    2796          16 :     ReassignOwnedStmt *expr = (ReassignOwnedStmt *) node;
    2797             : 
    2798          16 :     JUMBLE_NODE(roles);
    2799          16 :     JUMBLE_NODE(newrole);
    2800          16 : }
    2801             : 
    2802             : static void
    2803           6 : _jumbleAlterTSDictionaryStmt(JumbleState *jstate, Node *node)
    2804             : {
    2805           6 :     AlterTSDictionaryStmt *expr = (AlterTSDictionaryStmt *) node;
    2806             : 
    2807           6 :     JUMBLE_NODE(dictname);
    2808           6 :     JUMBLE_NODE(options);
    2809           6 : }
    2810             : 
    2811             : static void
    2812          28 : _jumbleAlterTSConfigurationStmt(JumbleState *jstate, Node *node)
    2813             : {
    2814          28 :     AlterTSConfigurationStmt *expr = (AlterTSConfigurationStmt *) node;
    2815             : 
    2816          28 :     JUMBLE_FIELD(kind);
    2817          28 :     JUMBLE_NODE(cfgname);
    2818          28 :     JUMBLE_NODE(tokentype);
    2819          28 :     JUMBLE_NODE(dicts);
    2820          28 :     JUMBLE_FIELD(override);
    2821          28 :     JUMBLE_FIELD(replace);
    2822          28 :     JUMBLE_FIELD(missing_ok);
    2823          28 : }
    2824             : 
    2825             : static void
    2826         356 : _jumblePublicationTable(JumbleState *jstate, Node *node)
    2827             : {
    2828         356 :     PublicationTable *expr = (PublicationTable *) node;
    2829             : 
    2830         356 :     JUMBLE_NODE(relation);
    2831         356 :     JUMBLE_NODE(whereClause);
    2832         356 :     JUMBLE_NODE(columns);
    2833         356 : }
    2834             : 
    2835             : static void
    2836         470 : _jumblePublicationObjSpec(JumbleState *jstate, Node *node)
    2837             : {
    2838         470 :     PublicationObjSpec *expr = (PublicationObjSpec *) node;
    2839             : 
    2840         470 :     JUMBLE_FIELD(pubobjtype);
    2841         470 :     JUMBLE_STRING(name);
    2842         470 :     JUMBLE_NODE(pubtable);
    2843         470 : }
    2844             : 
    2845             : static void
    2846         170 : _jumbleCreatePublicationStmt(JumbleState *jstate, Node *node)
    2847             : {
    2848         170 :     CreatePublicationStmt *expr = (CreatePublicationStmt *) node;
    2849             : 
    2850         170 :     JUMBLE_STRING(pubname);
    2851         170 :     JUMBLE_NODE(options);
    2852         170 :     JUMBLE_NODE(pubobjects);
    2853         170 :     JUMBLE_FIELD(for_all_tables);
    2854         170 : }
    2855             : 
    2856             : static void
    2857         330 : _jumbleAlterPublicationStmt(JumbleState *jstate, Node *node)
    2858             : {
    2859         330 :     AlterPublicationStmt *expr = (AlterPublicationStmt *) node;
    2860             : 
    2861         330 :     JUMBLE_STRING(pubname);
    2862         330 :     JUMBLE_NODE(options);
    2863         330 :     JUMBLE_NODE(pubobjects);
    2864         330 :     JUMBLE_FIELD(for_all_tables);
    2865         330 :     JUMBLE_FIELD(action);
    2866         330 : }
    2867             : 
    2868             : static void
    2869          68 : _jumbleCreateSubscriptionStmt(JumbleState *jstate, Node *node)
    2870             : {
    2871          68 :     CreateSubscriptionStmt *expr = (CreateSubscriptionStmt *) node;
    2872             : 
    2873          68 :     JUMBLE_STRING(subname);
    2874          68 :     JUMBLE_STRING(conninfo);
    2875          68 :     JUMBLE_NODE(publication);
    2876          68 :     JUMBLE_NODE(options);
    2877          68 : }
    2878             : 
    2879             : static void
    2880          98 : _jumbleAlterSubscriptionStmt(JumbleState *jstate, Node *node)
    2881             : {
    2882          98 :     AlterSubscriptionStmt *expr = (AlterSubscriptionStmt *) node;
    2883             : 
    2884          98 :     JUMBLE_FIELD(kind);
    2885          98 :     JUMBLE_STRING(subname);
    2886          98 :     JUMBLE_STRING(conninfo);
    2887          98 :     JUMBLE_NODE(publication);
    2888          98 :     JUMBLE_NODE(options);
    2889          98 : }
    2890             : 
    2891             : static void
    2892          28 : _jumbleDropSubscriptionStmt(JumbleState *jstate, Node *node)
    2893             : {
    2894          28 :     DropSubscriptionStmt *expr = (DropSubscriptionStmt *) node;
    2895             : 
    2896          28 :     JUMBLE_STRING(subname);
    2897          28 :     JUMBLE_FIELD(missing_ok);
    2898          28 :     JUMBLE_FIELD(behavior);
    2899          28 : }
    2900             : 
    2901             : static void
    2902           0 : _jumbleGroupByOrdering(JumbleState *jstate, Node *node)
    2903             : {
    2904           0 :     GroupByOrdering *expr = (GroupByOrdering *) node;
    2905             : 
    2906           0 :     JUMBLE_NODE(pathkeys);
    2907           0 :     JUMBLE_NODE(clauses);
    2908           0 : }
    2909             : 
    2910             : static void
    2911           0 : _jumbleExtensibleNode(JumbleState *jstate, Node *node)
    2912             : {
    2913           0 :     ExtensibleNode *expr = (ExtensibleNode *) node;
    2914             : 
    2915           0 :     JUMBLE_STRING(extnodename);
    2916           0 : }
    2917             : 
    2918             : static void
    2919        1238 : _jumbleInteger(JumbleState *jstate, Node *node)
    2920             : {
    2921        1238 :     Integer *expr = (Integer *) node;
    2922             : 
    2923        1238 :     JUMBLE_FIELD(ival);
    2924        1238 : }
    2925             : 
    2926             : static void
    2927          34 : _jumbleFloat(JumbleState *jstate, Node *node)
    2928             : {
    2929          34 :     Float *expr = (Float *) node;
    2930             : 
    2931          34 :     JUMBLE_STRING(fval);
    2932          34 : }
    2933             : 
    2934             : static void
    2935         686 : _jumbleBoolean(JumbleState *jstate, Node *node)
    2936             : {
    2937         686 :     Boolean *expr = (Boolean *) node;
    2938             : 
    2939         686 :     JUMBLE_FIELD(boolval);
    2940         686 : }
    2941             : 
    2942             : static void
    2943       95162 : _jumbleString(JumbleState *jstate, Node *node)
    2944             : {
    2945       95162 :     String *expr = (String *) node;
    2946             : 
    2947       95162 :     JUMBLE_STRING(sval);
    2948       95162 : }
    2949             : 
    2950             : static void
    2951           0 : _jumbleBitString(JumbleState *jstate, Node *node)
    2952             : {
    2953           0 :     BitString *expr = (BitString *) node;
    2954             : 
    2955           0 :     JUMBLE_STRING(bsval);
    2956           0 : }

Generated by: LCOV version 1.14