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

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

Generated by: LCOV version 1.14