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