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