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