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