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