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

Generated by: LCOV version 1.14