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