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