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