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