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 506 : _jumbleAlias(JumbleState *jstate, Node *node)
44 : {
45 506 : Alias *expr = (Alias *) node;
46 :
47 506 : JUMBLE_STRING(aliasname);
48 506 : JUMBLE_NODE(colnames);
49 506 : }
50 :
51 : static void
52 34132 : _jumbleRangeVar(JumbleState *jstate, Node *node)
53 : {
54 34132 : RangeVar *expr = (RangeVar *) node;
55 :
56 34132 : JUMBLE_STRING(catalogname);
57 34132 : JUMBLE_STRING(schemaname);
58 34132 : JUMBLE_STRING(relname);
59 34132 : JUMBLE_FIELD(inh);
60 34132 : JUMBLE_FIELD(relpersistence);
61 34132 : JUMBLE_NODE(alias);
62 34132 : }
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 446172 : _jumbleVar(JumbleState *jstate, Node *node)
91 : {
92 446172 : Var *expr = (Var *) node;
93 :
94 446172 : JUMBLE_FIELD(varno);
95 446172 : JUMBLE_FIELD(varattno);
96 446172 : JUMBLE_FIELD(varlevelsup);
97 446172 : JUMBLE_FIELD(varreturningtype);
98 446172 : }
99 :
100 : static void
101 224650 : _jumbleConst(JumbleState *jstate, Node *node)
102 : {
103 224650 : Const *expr = (Const *) node;
104 :
105 224650 : JUMBLE_FIELD(consttype);
106 224650 : JUMBLE_LOCATION(location);
107 224650 : }
108 :
109 : static void
110 11158 : _jumbleParam(JumbleState *jstate, Node *node)
111 : {
112 11158 : Param *expr = (Param *) node;
113 :
114 11158 : JUMBLE_FIELD(paramkind);
115 11158 : JUMBLE_FIELD(paramid);
116 11158 : JUMBLE_FIELD(paramtype);
117 11158 : }
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 62 : _jumbleMergeSupportFunc(JumbleState *jstate, Node *node)
164 : {
165 62 : MergeSupportFunc *expr = (MergeSupportFunc *) node;
166 :
167 62 : JUMBLE_FIELD(msftype);
168 62 : JUMBLE_FIELD(msfcollid);
169 62 : }
170 :
171 : static void
172 2944 : _jumbleSubscriptingRef(JumbleState *jstate, Node *node)
173 : {
174 2944 : SubscriptingRef *expr = (SubscriptingRef *) node;
175 :
176 2944 : JUMBLE_NODE(refupperindexpr);
177 2944 : JUMBLE_NODE(reflowerindexpr);
178 2944 : JUMBLE_NODE(refexpr);
179 2944 : JUMBLE_NODE(refassgnexpr);
180 2944 : }
181 :
182 : static void
183 72802 : _jumbleFuncExpr(JumbleState *jstate, Node *node)
184 : {
185 72802 : FuncExpr *expr = (FuncExpr *) node;
186 :
187 72802 : JUMBLE_FIELD(funcid);
188 72802 : JUMBLE_NODE(args);
189 72802 : }
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 134114 : _jumbleOpExpr(JumbleState *jstate, Node *node)
202 : {
203 134114 : OpExpr *expr = (OpExpr *) node;
204 :
205 134114 : JUMBLE_FIELD(opno);
206 134114 : JUMBLE_NODE(args);
207 134114 : }
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 7262 : _jumbleScalarArrayOpExpr(JumbleState *jstate, Node *node)
229 : {
230 7262 : ScalarArrayOpExpr *expr = (ScalarArrayOpExpr *) node;
231 :
232 7262 : JUMBLE_FIELD(opno);
233 7262 : JUMBLE_FIELD(useOr);
234 7262 : JUMBLE_NODE(args);
235 7262 : }
236 :
237 : static void
238 32342 : _jumbleBoolExpr(JumbleState *jstate, Node *node)
239 : {
240 32342 : BoolExpr *expr = (BoolExpr *) node;
241 :
242 32342 : JUMBLE_FIELD(boolop);
243 32342 : JUMBLE_NODE(args);
244 32342 : }
245 :
246 : static void
247 11480 : _jumbleSubLink(JumbleState *jstate, Node *node)
248 : {
249 11480 : SubLink *expr = (SubLink *) node;
250 :
251 11480 : JUMBLE_FIELD(subLinkType);
252 11480 : JUMBLE_FIELD(subLinkId);
253 11480 : JUMBLE_NODE(testexpr);
254 11480 : JUMBLE_NODE(subselect);
255 11480 : }
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 34044 : _jumbleRelabelType(JumbleState *jstate, Node *node)
277 : {
278 34044 : RelabelType *expr = (RelabelType *) node;
279 :
280 34044 : JUMBLE_NODE(arg);
281 34044 : JUMBLE_FIELD(resulttype);
282 34044 : }
283 :
284 : static void
285 5578 : _jumbleCoerceViaIO(JumbleState *jstate, Node *node)
286 : {
287 5578 : CoerceViaIO *expr = (CoerceViaIO *) node;
288 :
289 5578 : JUMBLE_NODE(arg);
290 5578 : JUMBLE_FIELD(resulttype);
291 5578 : }
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 2940 : _jumbleCollateExpr(JumbleState *jstate, Node *node)
314 : {
315 2940 : CollateExpr *expr = (CollateExpr *) node;
316 :
317 2940 : JUMBLE_NODE(arg);
318 2940 : JUMBLE_FIELD(collOid);
319 2940 : }
320 :
321 : static void
322 6716 : _jumbleCaseExpr(JumbleState *jstate, Node *node)
323 : {
324 6716 : CaseExpr *expr = (CaseExpr *) node;
325 :
326 6716 : JUMBLE_NODE(arg);
327 6716 : JUMBLE_NODE(args);
328 6716 : JUMBLE_NODE(defresult);
329 6716 : }
330 :
331 : static void
332 10974 : _jumbleCaseWhen(JumbleState *jstate, Node *node)
333 : {
334 10974 : CaseWhen *expr = (CaseWhen *) node;
335 :
336 10974 : JUMBLE_NODE(expr);
337 10974 : JUMBLE_NODE(result);
338 10974 : }
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 4846 : _jumbleArrayExpr(JumbleState *jstate, Node *node)
350 : {
351 4846 : ArrayExpr *expr = (ArrayExpr *) node;
352 :
353 4846 : JUMBLE_ELEMENTS(elements);
354 4846 : }
355 :
356 : static void
357 1110 : _jumbleRowExpr(JumbleState *jstate, Node *node)
358 : {
359 1110 : RowExpr *expr = (RowExpr *) node;
360 :
361 1110 : JUMBLE_NODE(args);
362 1110 : }
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 510 : _jumbleSQLValueFunction(JumbleState *jstate, Node *node)
393 : {
394 510 : SQLValueFunction *expr = (SQLValueFunction *) node;
395 :
396 510 : JUMBLE_FIELD(op);
397 510 : JUMBLE_FIELD(typmod);
398 510 : }
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 3978 : _jumbleNullTest(JumbleState *jstate, Node *node)
529 : {
530 3978 : NullTest *expr = (NullTest *) node;
531 :
532 3978 : JUMBLE_NODE(arg);
533 3978 : JUMBLE_FIELD(nulltesttype);
534 3978 : }
535 :
536 : static void
537 218 : _jumbleBooleanTest(JumbleState *jstate, Node *node)
538 : {
539 218 : BooleanTest *expr = (BooleanTest *) node;
540 :
541 218 : JUMBLE_NODE(arg);
542 218 : JUMBLE_FIELD(booltesttype);
543 218 : }
544 :
545 : static void
546 1002 : _jumbleMergeAction(JumbleState *jstate, Node *node)
547 : {
548 1002 : MergeAction *expr = (MergeAction *) node;
549 :
550 1002 : JUMBLE_FIELD(matchKind);
551 1002 : JUMBLE_FIELD(commandType);
552 1002 : JUMBLE_NODE(qual);
553 1002 : JUMBLE_NODE(targetList);
554 1002 : }
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 343724 : _jumbleTargetEntry(JumbleState *jstate, Node *node)
622 : {
623 343724 : TargetEntry *expr = (TargetEntry *) node;
624 :
625 343724 : JUMBLE_NODE(expr);
626 343724 : JUMBLE_FIELD(resno);
627 343724 : JUMBLE_FIELD(ressortgroupref);
628 343724 : }
629 :
630 : static void
631 123558 : _jumbleRangeTblRef(JumbleState *jstate, Node *node)
632 : {
633 123558 : RangeTblRef *expr = (RangeTblRef *) node;
634 :
635 123558 : JUMBLE_FIELD(rtindex);
636 123558 : }
637 :
638 : static void
639 20664 : _jumbleJoinExpr(JumbleState *jstate, Node *node)
640 : {
641 20664 : JoinExpr *expr = (JoinExpr *) node;
642 :
643 20664 : JUMBLE_FIELD(jointype);
644 20664 : JUMBLE_FIELD(isNatural);
645 20664 : JUMBLE_NODE(larg);
646 20664 : JUMBLE_NODE(rarg);
647 20664 : JUMBLE_NODE(quals);
648 20664 : JUMBLE_FIELD(rtindex);
649 20664 : }
650 :
651 : static void
652 125356 : _jumbleFromExpr(JumbleState *jstate, Node *node)
653 : {
654 125356 : FromExpr *expr = (FromExpr *) node;
655 :
656 125356 : JUMBLE_NODE(fromlist);
657 125356 : JUMBLE_NODE(quals);
658 125356 : }
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 188128 : _jumbleQuery(JumbleState *jstate, Node *node)
677 : {
678 188128 : Query *expr = (Query *) node;
679 :
680 188128 : JUMBLE_FIELD(commandType);
681 188128 : JUMBLE_NODE(utilityStmt);
682 188128 : JUMBLE_NODE(cteList);
683 188128 : JUMBLE_NODE(rtable);
684 188128 : JUMBLE_NODE(jointree);
685 188128 : JUMBLE_NODE(mergeActionList);
686 188128 : JUMBLE_NODE(mergeJoinCondition);
687 188128 : JUMBLE_NODE(targetList);
688 188128 : JUMBLE_NODE(onConflict);
689 188128 : JUMBLE_NODE(returningList);
690 188128 : JUMBLE_NODE(groupClause);
691 188128 : JUMBLE_FIELD(groupDistinct);
692 188128 : JUMBLE_NODE(groupingSets);
693 188128 : JUMBLE_NODE(havingQual);
694 188128 : JUMBLE_NODE(windowClause);
695 188128 : JUMBLE_NODE(distinctClause);
696 188128 : JUMBLE_NODE(sortClause);
697 188128 : JUMBLE_NODE(limitOffset);
698 188128 : JUMBLE_NODE(limitCount);
699 188128 : JUMBLE_FIELD(limitOption);
700 188128 : JUMBLE_NODE(rowMarks);
701 188128 : JUMBLE_NODE(setOperations);
702 188128 : }
703 :
704 : static void
705 27826 : _jumbleTypeName(JumbleState *jstate, Node *node)
706 : {
707 27826 : TypeName *expr = (TypeName *) node;
708 :
709 27826 : JUMBLE_NODE(names);
710 27826 : JUMBLE_FIELD(typeOid);
711 27826 : JUMBLE_FIELD(setof);
712 27826 : JUMBLE_FIELD(pct_type);
713 27826 : JUMBLE_NODE(typmods);
714 27826 : JUMBLE_FIELD(typemod);
715 27826 : JUMBLE_NODE(arrayBounds);
716 27826 : }
717 :
718 : static void
719 7474 : _jumbleColumnRef(JumbleState *jstate, Node *node)
720 : {
721 7474 : ColumnRef *expr = (ColumnRef *) node;
722 :
723 7474 : JUMBLE_NODE(fields);
724 7474 : }
725 :
726 : static void
727 220 : _jumbleParamRef(JumbleState *jstate, Node *node)
728 : {
729 220 : ParamRef *expr = (ParamRef *) node;
730 :
731 220 : JUMBLE_FIELD(number);
732 220 : }
733 :
734 : static void
735 3108 : _jumbleA_Expr(JumbleState *jstate, Node *node)
736 : {
737 3108 : A_Expr *expr = (A_Expr *) node;
738 :
739 3108 : JUMBLE_FIELD(kind);
740 3108 : JUMBLE_NODE(name);
741 3108 : JUMBLE_NODE(lexpr);
742 3108 : JUMBLE_NODE(rexpr);
743 3108 : }
744 :
745 : static void
746 532 : _jumbleTypeCast(JumbleState *jstate, Node *node)
747 : {
748 532 : TypeCast *expr = (TypeCast *) node;
749 :
750 532 : JUMBLE_NODE(arg);
751 532 : JUMBLE_NODE(typeName);
752 532 : }
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 2686 : _jumbleRoleSpec(JumbleState *jstate, Node *node)
765 : {
766 2686 : RoleSpec *expr = (RoleSpec *) node;
767 :
768 2686 : JUMBLE_FIELD(roletype);
769 2686 : JUMBLE_STRING(rolename);
770 2686 : }
771 :
772 : static void
773 1116 : _jumbleFuncCall(JumbleState *jstate, Node *node)
774 : {
775 1116 : FuncCall *expr = (FuncCall *) node;
776 :
777 1116 : JUMBLE_NODE(funcname);
778 1116 : JUMBLE_NODE(args);
779 1116 : JUMBLE_NODE(agg_order);
780 1116 : JUMBLE_NODE(agg_filter);
781 1116 : JUMBLE_NODE(over);
782 1116 : JUMBLE_FIELD(agg_within_group);
783 1116 : JUMBLE_FIELD(agg_star);
784 1116 : JUMBLE_FIELD(agg_distinct);
785 1116 : JUMBLE_FIELD(func_variadic);
786 1116 : JUMBLE_FIELD(funcformat);
787 1116 : }
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 3520 : _jumbleResTarget(JumbleState *jstate, Node *node)
826 : {
827 3520 : ResTarget *expr = (ResTarget *) node;
828 :
829 3520 : JUMBLE_STRING(name);
830 3520 : JUMBLE_NODE(indirection);
831 3520 : JUMBLE_NODE(val);
832 3520 : }
833 :
834 : static void
835 6 : _jumbleMultiAssignRef(JumbleState *jstate, Node *node)
836 : {
837 6 : MultiAssignRef *expr = (MultiAssignRef *) node;
838 :
839 6 : JUMBLE_NODE(source);
840 6 : JUMBLE_FIELD(colno);
841 6 : JUMBLE_FIELD(ncolumns);
842 6 : }
843 :
844 : static void
845 150 : _jumbleSortBy(JumbleState *jstate, Node *node)
846 : {
847 150 : SortBy *expr = (SortBy *) node;
848 :
849 150 : JUMBLE_NODE(node);
850 150 : JUMBLE_FIELD(sortby_dir);
851 150 : JUMBLE_FIELD(sortby_nulls);
852 150 : JUMBLE_NODE(useOp);
853 150 : }
854 :
855 : static void
856 28 : _jumbleWindowDef(JumbleState *jstate, Node *node)
857 : {
858 28 : WindowDef *expr = (WindowDef *) node;
859 :
860 28 : JUMBLE_STRING(name);
861 28 : JUMBLE_STRING(refname);
862 28 : JUMBLE_NODE(partitionClause);
863 28 : JUMBLE_NODE(orderClause);
864 28 : JUMBLE_FIELD(frameOptions);
865 28 : JUMBLE_NODE(startOffset);
866 28 : JUMBLE_NODE(endOffset);
867 28 : }
868 :
869 : static void
870 96 : _jumbleRangeSubselect(JumbleState *jstate, Node *node)
871 : {
872 96 : RangeSubselect *expr = (RangeSubselect *) node;
873 :
874 96 : JUMBLE_FIELD(lateral);
875 96 : JUMBLE_NODE(subquery);
876 96 : JUMBLE_NODE(alias);
877 96 : }
878 :
879 : static void
880 230 : _jumbleRangeFunction(JumbleState *jstate, Node *node)
881 : {
882 230 : RangeFunction *expr = (RangeFunction *) node;
883 :
884 230 : JUMBLE_FIELD(lateral);
885 230 : JUMBLE_FIELD(ordinality);
886 230 : JUMBLE_FIELD(is_rowsfrom);
887 230 : JUMBLE_NODE(functions);
888 230 : JUMBLE_NODE(alias);
889 230 : JUMBLE_NODE(coldeflist);
890 230 : }
891 :
892 : static void
893 6 : _jumbleRangeTableFunc(JumbleState *jstate, Node *node)
894 : {
895 6 : RangeTableFunc *expr = (RangeTableFunc *) node;
896 :
897 6 : JUMBLE_FIELD(lateral);
898 6 : JUMBLE_NODE(docexpr);
899 6 : JUMBLE_NODE(rowexpr);
900 6 : JUMBLE_NODE(namespaces);
901 6 : JUMBLE_NODE(columns);
902 6 : JUMBLE_NODE(alias);
903 6 : }
904 :
905 : static void
906 34 : _jumbleRangeTableFuncCol(JumbleState *jstate, Node *node)
907 : {
908 34 : RangeTableFuncCol *expr = (RangeTableFuncCol *) node;
909 :
910 34 : JUMBLE_STRING(colname);
911 34 : JUMBLE_NODE(typeName);
912 34 : JUMBLE_FIELD(for_ordinality);
913 34 : JUMBLE_FIELD(is_not_null);
914 34 : JUMBLE_NODE(colexpr);
915 34 : JUMBLE_NODE(coldefexpr);
916 34 : }
917 :
918 : static void
919 4 : _jumbleRangeTableSample(JumbleState *jstate, Node *node)
920 : {
921 4 : RangeTableSample *expr = (RangeTableSample *) node;
922 :
923 4 : JUMBLE_NODE(relation);
924 4 : JUMBLE_NODE(method);
925 4 : JUMBLE_NODE(args);
926 4 : JUMBLE_NODE(repeatable);
927 4 : }
928 :
929 : static void
930 14710 : _jumbleColumnDef(JumbleState *jstate, Node *node)
931 : {
932 14710 : ColumnDef *expr = (ColumnDef *) node;
933 :
934 14710 : JUMBLE_STRING(colname);
935 14710 : JUMBLE_NODE(typeName);
936 14710 : JUMBLE_STRING(compression);
937 14710 : JUMBLE_FIELD(inhcount);
938 14710 : JUMBLE_FIELD(is_local);
939 14710 : JUMBLE_FIELD(is_not_null);
940 14710 : JUMBLE_FIELD(is_from_type);
941 14710 : JUMBLE_FIELD(storage);
942 14710 : JUMBLE_STRING(storage_name);
943 14710 : JUMBLE_NODE(raw_default);
944 14710 : JUMBLE_NODE(cooked_default);
945 14710 : JUMBLE_FIELD(identity);
946 14710 : JUMBLE_NODE(identitySequence);
947 14710 : JUMBLE_FIELD(generated);
948 14710 : JUMBLE_NODE(collClause);
949 14710 : JUMBLE_FIELD(collOid);
950 14710 : JUMBLE_NODE(constraints);
951 14710 : JUMBLE_NODE(fdwoptions);
952 14710 : }
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 2200 : _jumbleIndexElem(JumbleState *jstate, Node *node)
966 : {
967 2200 : IndexElem *expr = (IndexElem *) node;
968 :
969 2200 : JUMBLE_STRING(name);
970 2200 : JUMBLE_NODE(expr);
971 2200 : JUMBLE_STRING(indexcolname);
972 2200 : JUMBLE_NODE(collation);
973 2200 : JUMBLE_NODE(opclass);
974 2200 : JUMBLE_NODE(opclassopts);
975 2200 : JUMBLE_FIELD(ordering);
976 2200 : JUMBLE_FIELD(nulls_ordering);
977 2200 : }
978 :
979 : static void
980 17736 : _jumbleDefElem(JumbleState *jstate, Node *node)
981 : {
982 17736 : DefElem *expr = (DefElem *) node;
983 :
984 17736 : JUMBLE_STRING(defnamespace);
985 17736 : JUMBLE_STRING(defname);
986 17736 : JUMBLE_NODE(arg);
987 17736 : JUMBLE_FIELD(defaction);
988 17736 : }
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 1428 : _jumblePartitionElem(JumbleState *jstate, Node *node)
1013 : {
1014 1428 : PartitionElem *expr = (PartitionElem *) node;
1015 :
1016 1428 : JUMBLE_STRING(name);
1017 1428 : JUMBLE_NODE(expr);
1018 1428 : JUMBLE_NODE(collation);
1019 1428 : JUMBLE_NODE(opclass);
1020 1428 : }
1021 :
1022 : static void
1023 1280 : _jumblePartitionSpec(JumbleState *jstate, Node *node)
1024 : {
1025 1280 : PartitionSpec *expr = (PartitionSpec *) node;
1026 :
1027 1280 : JUMBLE_FIELD(strategy);
1028 1280 : JUMBLE_NODE(partParams);
1029 1280 : }
1030 :
1031 : static void
1032 2716 : _jumblePartitionBoundSpec(JumbleState *jstate, Node *node)
1033 : {
1034 2716 : PartitionBoundSpec *expr = (PartitionBoundSpec *) node;
1035 :
1036 2716 : JUMBLE_FIELD(strategy);
1037 2716 : JUMBLE_FIELD(is_default);
1038 2716 : JUMBLE_FIELD(modulus);
1039 2716 : JUMBLE_FIELD(remainder);
1040 2716 : JUMBLE_NODE(listdatums);
1041 2716 : JUMBLE_NODE(lowerdatums);
1042 2716 : JUMBLE_NODE(upperdatums);
1043 2716 : }
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 836 : _jumblePartitionCmd(JumbleState *jstate, Node *node)
1056 : {
1057 836 : PartitionCmd *expr = (PartitionCmd *) node;
1058 :
1059 836 : JUMBLE_NODE(name);
1060 836 : JUMBLE_NODE(bound);
1061 836 : JUMBLE_FIELD(concurrent);
1062 836 : }
1063 :
1064 : static void
1065 157214 : _jumbleRangeTblEntry(JumbleState *jstate, Node *node)
1066 : {
1067 157214 : RangeTblEntry *expr = (RangeTblEntry *) node;
1068 :
1069 157214 : JUMBLE_CUSTOM(RangeTblEntry, eref);
1070 157214 : JUMBLE_FIELD(rtekind);
1071 157214 : JUMBLE_FIELD(inh);
1072 157214 : JUMBLE_NODE(tablesample);
1073 157214 : JUMBLE_NODE(subquery);
1074 157214 : JUMBLE_FIELD(jointype);
1075 157214 : JUMBLE_NODE(functions);
1076 157214 : JUMBLE_FIELD(funcordinality);
1077 157214 : JUMBLE_NODE(tablefunc);
1078 157214 : JUMBLE_NODE(values_lists);
1079 157214 : JUMBLE_STRING(ctename);
1080 157214 : JUMBLE_FIELD(ctelevelsup);
1081 157214 : JUMBLE_STRING(enrname);
1082 157214 : }
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 7352 : _jumbleRangeTblFunction(JumbleState *jstate, Node *node)
1100 : {
1101 7352 : RangeTblFunction *expr = (RangeTblFunction *) node;
1102 :
1103 7352 : JUMBLE_NODE(funcexpr);
1104 7352 : }
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 35546 : _jumbleSortGroupClause(JumbleState *jstate, Node *node)
1130 : {
1131 35546 : SortGroupClause *expr = (SortGroupClause *) node;
1132 :
1133 35546 : JUMBLE_FIELD(tleSortGroupRef);
1134 35546 : JUMBLE_FIELD(eqop);
1135 35546 : JUMBLE_FIELD(sortop);
1136 35546 : JUMBLE_FIELD(reverse_sort);
1137 35546 : JUMBLE_FIELD(nulls_first);
1138 35546 : }
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 694 : _jumbleRowMarkClause(JumbleState *jstate, Node *node)
1163 : {
1164 694 : RowMarkClause *expr = (RowMarkClause *) node;
1165 :
1166 694 : JUMBLE_FIELD(rti);
1167 694 : JUMBLE_FIELD(strength);
1168 694 : JUMBLE_FIELD(waitPolicy);
1169 694 : JUMBLE_FIELD(pushedDown);
1170 694 : }
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 1924 : _jumbleSelectStmt(JumbleState *jstate, Node *node)
1509 : {
1510 1924 : SelectStmt *expr = (SelectStmt *) node;
1511 :
1512 1924 : JUMBLE_NODE(distinctClause);
1513 1924 : JUMBLE_NODE(intoClause);
1514 1924 : JUMBLE_NODE(targetList);
1515 1924 : JUMBLE_NODE(fromClause);
1516 1924 : JUMBLE_NODE(whereClause);
1517 1924 : JUMBLE_NODE(groupClause);
1518 1924 : JUMBLE_FIELD(groupDistinct);
1519 1924 : JUMBLE_NODE(havingClause);
1520 1924 : JUMBLE_NODE(windowClause);
1521 1924 : JUMBLE_NODE(valuesLists);
1522 1924 : JUMBLE_NODE(sortClause);
1523 1924 : JUMBLE_NODE(limitOffset);
1524 1924 : JUMBLE_NODE(limitCount);
1525 1924 : JUMBLE_FIELD(limitOption);
1526 1924 : JUMBLE_NODE(lockingClause);
1527 1924 : JUMBLE_NODE(withClause);
1528 1924 : JUMBLE_FIELD(op);
1529 1924 : JUMBLE_FIELD(all);
1530 1924 : JUMBLE_NODE(larg);
1531 1924 : JUMBLE_NODE(rarg);
1532 1924 : }
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 4686 : _jumbleAlterTableStmt(JumbleState *jstate, Node *node)
1577 : {
1578 4686 : AlterTableStmt *expr = (AlterTableStmt *) node;
1579 :
1580 4686 : JUMBLE_NODE(relation);
1581 4686 : JUMBLE_NODE(cmds);
1582 4686 : JUMBLE_FIELD(objtype);
1583 4686 : JUMBLE_FIELD(missing_ok);
1584 4686 : }
1585 :
1586 : static void
1587 5022 : _jumbleAlterTableCmd(JumbleState *jstate, Node *node)
1588 : {
1589 5022 : AlterTableCmd *expr = (AlterTableCmd *) node;
1590 :
1591 5022 : JUMBLE_FIELD(subtype);
1592 5022 : JUMBLE_STRING(name);
1593 5022 : JUMBLE_FIELD(num);
1594 5022 : JUMBLE_NODE(newowner);
1595 5022 : JUMBLE_NODE(def);
1596 5022 : JUMBLE_FIELD(behavior);
1597 5022 : JUMBLE_FIELD(missing_ok);
1598 5022 : JUMBLE_FIELD(recurse);
1599 5022 : }
1600 :
1601 : static void
1602 98 : _jumbleATAlterConstraint(JumbleState *jstate, Node *node)
1603 : {
1604 98 : ATAlterConstraint *expr = (ATAlterConstraint *) node;
1605 :
1606 98 : JUMBLE_STRING(conname);
1607 98 : JUMBLE_FIELD(alterEnforceability);
1608 98 : JUMBLE_FIELD(is_enforced);
1609 98 : JUMBLE_FIELD(alterDeferrability);
1610 98 : JUMBLE_FIELD(deferrable);
1611 98 : JUMBLE_FIELD(initdeferred);
1612 98 : JUMBLE_FIELD(alterInheritability);
1613 98 : JUMBLE_FIELD(noinherit);
1614 98 : }
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 3576 : _jumbleCopyStmt(JumbleState *jstate, Node *node)
1706 : {
1707 3576 : CopyStmt *expr = (CopyStmt *) node;
1708 :
1709 3576 : JUMBLE_NODE(relation);
1710 3576 : JUMBLE_NODE(query);
1711 3576 : JUMBLE_NODE(attlist);
1712 3576 : JUMBLE_FIELD(is_from);
1713 3576 : JUMBLE_FIELD(is_program);
1714 3576 : JUMBLE_STRING(filename);
1715 3576 : JUMBLE_NODE(options);
1716 3576 : JUMBLE_NODE(whereClause);
1717 3576 : }
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 8288 : _jumbleCreateStmt(JumbleState *jstate, Node *node)
1729 : {
1730 8288 : CreateStmt *expr = (CreateStmt *) node;
1731 :
1732 8288 : JUMBLE_NODE(relation);
1733 8288 : JUMBLE_NODE(tableElts);
1734 8288 : JUMBLE_NODE(inhRelations);
1735 8288 : JUMBLE_NODE(partbound);
1736 8288 : JUMBLE_NODE(partspec);
1737 8288 : JUMBLE_NODE(ofTypename);
1738 8288 : JUMBLE_NODE(constraints);
1739 8288 : JUMBLE_NODE(nnconstraints);
1740 8288 : JUMBLE_NODE(options);
1741 8288 : JUMBLE_FIELD(oncommit);
1742 8288 : JUMBLE_STRING(tablespacename);
1743 8288 : JUMBLE_STRING(accessMethod);
1744 8288 : JUMBLE_FIELD(if_not_exists);
1745 8288 : }
1746 :
1747 : static void
1748 4766 : _jumbleConstraint(JumbleState *jstate, Node *node)
1749 : {
1750 4766 : Constraint *expr = (Constraint *) node;
1751 :
1752 4766 : JUMBLE_FIELD(contype);
1753 4766 : JUMBLE_STRING(conname);
1754 4766 : JUMBLE_FIELD(deferrable);
1755 4766 : JUMBLE_FIELD(initdeferred);
1756 4766 : JUMBLE_FIELD(is_enforced);
1757 4766 : JUMBLE_FIELD(skip_validation);
1758 4766 : JUMBLE_FIELD(initially_valid);
1759 4766 : JUMBLE_FIELD(is_no_inherit);
1760 4766 : JUMBLE_NODE(raw_expr);
1761 4766 : JUMBLE_STRING(cooked_expr);
1762 4766 : JUMBLE_FIELD(generated_when);
1763 4766 : JUMBLE_FIELD(generated_kind);
1764 4766 : JUMBLE_FIELD(nulls_not_distinct);
1765 4766 : JUMBLE_NODE(keys);
1766 4766 : JUMBLE_FIELD(without_overlaps);
1767 4766 : JUMBLE_NODE(including);
1768 4766 : JUMBLE_NODE(exclusions);
1769 4766 : JUMBLE_NODE(options);
1770 4766 : JUMBLE_STRING(indexname);
1771 4766 : JUMBLE_STRING(indexspace);
1772 4766 : JUMBLE_FIELD(reset_default_tblspc);
1773 4766 : JUMBLE_STRING(access_method);
1774 4766 : JUMBLE_NODE(where_clause);
1775 4766 : JUMBLE_NODE(pktable);
1776 4766 : JUMBLE_NODE(fk_attrs);
1777 4766 : JUMBLE_NODE(pk_attrs);
1778 4766 : JUMBLE_FIELD(fk_with_period);
1779 4766 : JUMBLE_FIELD(pk_with_period);
1780 4766 : JUMBLE_FIELD(fk_matchtype);
1781 4766 : JUMBLE_FIELD(fk_upd_action);
1782 4766 : JUMBLE_FIELD(fk_del_action);
1783 4766 : JUMBLE_NODE(fk_del_set_cols);
1784 4766 : JUMBLE_NODE(old_conpfeqop);
1785 4766 : JUMBLE_FIELD(old_pktable_oid);
1786 4766 : }
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 216 : _jumbleCreatePolicyStmt(JumbleState *jstate, Node *node)
1972 : {
1973 216 : CreatePolicyStmt *expr = (CreatePolicyStmt *) node;
1974 :
1975 216 : JUMBLE_STRING(policy_name);
1976 216 : JUMBLE_NODE(table);
1977 216 : JUMBLE_STRING(cmd_name);
1978 216 : JUMBLE_FIELD(permissive);
1979 216 : JUMBLE_NODE(roles);
1980 216 : JUMBLE_NODE(qual);
1981 216 : JUMBLE_NODE(with_check);
1982 216 : }
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 5926 : _jumbleDropStmt(JumbleState *jstate, Node *node)
2196 : {
2197 5926 : DropStmt *expr = (DropStmt *) node;
2198 :
2199 5926 : JUMBLE_NODE(objects);
2200 5926 : JUMBLE_FIELD(removeType);
2201 5926 : JUMBLE_FIELD(behavior);
2202 5926 : JUMBLE_FIELD(missing_ok);
2203 5926 : JUMBLE_FIELD(concurrent);
2204 5926 : }
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 1530 : _jumbleIndexStmt(JumbleState *jstate, Node *node)
2268 : {
2269 1530 : IndexStmt *expr = (IndexStmt *) node;
2270 :
2271 1530 : JUMBLE_STRING(idxname);
2272 1530 : JUMBLE_NODE(relation);
2273 1530 : JUMBLE_STRING(accessMethod);
2274 1530 : JUMBLE_STRING(tableSpace);
2275 1530 : JUMBLE_NODE(indexParams);
2276 1530 : JUMBLE_NODE(indexIncludingParams);
2277 1530 : JUMBLE_NODE(options);
2278 1530 : JUMBLE_NODE(whereClause);
2279 1530 : JUMBLE_NODE(excludeOpNames);
2280 1530 : JUMBLE_STRING(idxcomment);
2281 1530 : JUMBLE_FIELD(indexOid);
2282 1530 : JUMBLE_FIELD(oldNumber);
2283 1530 : JUMBLE_FIELD(oldCreateSubid);
2284 1530 : JUMBLE_FIELD(oldFirstRelfilelocatorSubid);
2285 1530 : JUMBLE_FIELD(unique);
2286 1530 : JUMBLE_FIELD(nulls_not_distinct);
2287 1530 : JUMBLE_FIELD(primary);
2288 1530 : JUMBLE_FIELD(isconstraint);
2289 1530 : JUMBLE_FIELD(iswithoutoverlaps);
2290 1530 : JUMBLE_FIELD(deferrable);
2291 1530 : JUMBLE_FIELD(initdeferred);
2292 1530 : JUMBLE_FIELD(transformed);
2293 1530 : JUMBLE_FIELD(concurrent);
2294 1530 : JUMBLE_FIELD(if_not_exists);
2295 1530 : JUMBLE_FIELD(reset_default_tblspc);
2296 1530 : }
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 168 : _jumbleDoStmt(JumbleState *jstate, Node *node)
2368 : {
2369 168 : DoStmt *expr = (DoStmt *) node;
2370 :
2371 168 : JUMBLE_NODE(args);
2372 168 : }
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 3450 : _jumbleTransactionStmt(JumbleState *jstate, Node *node)
2492 : {
2493 3450 : TransactionStmt *expr = (TransactionStmt *) node;
2494 :
2495 3450 : JUMBLE_FIELD(kind);
2496 3450 : JUMBLE_NODE(options);
2497 3450 : JUMBLE_FIELD(chain);
2498 3450 : JUMBLE_LOCATION(location);
2499 3450 : }
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 952 : _jumbleViewStmt(JumbleState *jstate, Node *node)
2543 : {
2544 952 : ViewStmt *expr = (ViewStmt *) node;
2545 :
2546 952 : JUMBLE_NODE(view);
2547 952 : JUMBLE_NODE(aliases);
2548 952 : JUMBLE_NODE(query);
2549 952 : JUMBLE_FIELD(replace);
2550 952 : JUMBLE_NODE(options);
2551 952 : JUMBLE_FIELD(withCheckOption);
2552 952 : }
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 1010 : _jumbleVacuumStmt(JumbleState *jstate, Node *node)
2627 : {
2628 1010 : VacuumStmt *expr = (VacuumStmt *) node;
2629 :
2630 1010 : JUMBLE_NODE(options);
2631 1010 : JUMBLE_NODE(rels);
2632 1010 : JUMBLE_FIELD(is_vacuumcmd);
2633 1010 : }
2634 :
2635 : static void
2636 1044 : _jumbleVacuumRelation(JumbleState *jstate, Node *node)
2637 : {
2638 1044 : VacuumRelation *expr = (VacuumRelation *) node;
2639 :
2640 1044 : JUMBLE_NODE(relation);
2641 1044 : JUMBLE_FIELD(oid);
2642 1044 : JUMBLE_NODE(va_cols);
2643 1044 : }
2644 :
2645 : static void
2646 6914 : _jumbleExplainStmt(JumbleState *jstate, Node *node)
2647 : {
2648 6914 : ExplainStmt *expr = (ExplainStmt *) node;
2649 :
2650 6914 : JUMBLE_NODE(query);
2651 6914 : JUMBLE_NODE(options);
2652 6914 : }
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 240 : _jumblePrepareStmt(JumbleState *jstate, Node *node)
2760 : {
2761 240 : PrepareStmt *expr = (PrepareStmt *) node;
2762 :
2763 240 : JUMBLE_STRING(name);
2764 240 : JUMBLE_NODE(argtypes);
2765 240 : JUMBLE_NODE(query);
2766 240 : }
2767 :
2768 : static void
2769 6756 : _jumbleExecuteStmt(JumbleState *jstate, Node *node)
2770 : {
2771 6756 : ExecuteStmt *expr = (ExecuteStmt *) node;
2772 :
2773 6756 : JUMBLE_STRING(name);
2774 6756 : JUMBLE_NODE(params);
2775 6756 : }
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 1234 : _jumbleInteger(JumbleState *jstate, Node *node)
2922 : {
2923 1234 : Integer *expr = (Integer *) node;
2924 :
2925 1234 : JUMBLE_FIELD(ival);
2926 1234 : }
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 95652 : _jumbleString(JumbleState *jstate, Node *node)
2946 : {
2947 95652 : String *expr = (String *) node;
2948 :
2949 95652 : JUMBLE_STRING(sval);
2950 95652 : }
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 : }
|
