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