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