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