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