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