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