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