Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * outfuncs.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 1853373 : _outAlias(StringInfo str, const Alias *node)
44 : {
45 1853373 : WRITE_NODE_TYPE("ALIAS");
46 :
47 1853373 : WRITE_STRING_FIELD(aliasname);
48 1853373 : WRITE_NODE_FIELD(colnames);
49 1853373 : }
50 :
51 : static void
52 576560 : _outRangeVar(StringInfo str, const RangeVar *node)
53 : {
54 576560 : WRITE_NODE_TYPE("RANGEVAR");
55 :
56 576560 : WRITE_STRING_FIELD(catalogname);
57 576560 : WRITE_STRING_FIELD(schemaname);
58 576560 : WRITE_STRING_FIELD(relname);
59 576560 : WRITE_BOOL_FIELD(inh);
60 576560 : WRITE_CHAR_FIELD(relpersistence);
61 576560 : WRITE_NODE_FIELD(alias);
62 576560 : WRITE_LOCATION_FIELD(location);
63 576560 : }
64 :
65 : static void
66 858 : _outTableFunc(StringInfo str, const TableFunc *node)
67 : {
68 858 : WRITE_NODE_TYPE("TABLEFUNC");
69 :
70 858 : WRITE_ENUM_FIELD(functype, TableFuncType);
71 858 : WRITE_NODE_FIELD(ns_uris);
72 858 : WRITE_NODE_FIELD(ns_names);
73 858 : WRITE_NODE_FIELD(docexpr);
74 858 : WRITE_NODE_FIELD(rowexpr);
75 858 : WRITE_NODE_FIELD(colnames);
76 858 : WRITE_NODE_FIELD(coltypes);
77 858 : WRITE_NODE_FIELD(coltypmods);
78 858 : WRITE_NODE_FIELD(colcollations);
79 858 : WRITE_NODE_FIELD(colexprs);
80 858 : WRITE_NODE_FIELD(coldefexprs);
81 858 : WRITE_NODE_FIELD(colvalexprs);
82 858 : WRITE_NODE_FIELD(passingvalexprs);
83 858 : WRITE_BITMAPSET_FIELD(notnulls);
84 858 : WRITE_NODE_FIELD(plan);
85 858 : WRITE_INT_FIELD(ordinalitycol);
86 858 : WRITE_LOCATION_FIELD(location);
87 858 : }
88 :
89 : static void
90 2578 : _outIntoClause(StringInfo str, const IntoClause *node)
91 : {
92 2578 : WRITE_NODE_TYPE("INTOCLAUSE");
93 :
94 2578 : WRITE_NODE_FIELD(rel);
95 2578 : WRITE_NODE_FIELD(colNames);
96 2578 : WRITE_STRING_FIELD(accessMethod);
97 2578 : WRITE_NODE_FIELD(options);
98 2578 : WRITE_ENUM_FIELD(onCommit, OnCommitAction);
99 2578 : WRITE_STRING_FIELD(tableSpaceName);
100 2578 : WRITE_NODE_FIELD(viewQuery);
101 2578 : WRITE_BOOL_FIELD(skipData);
102 2578 : }
103 :
104 : static void
105 8576457 : _outVar(StringInfo str, const Var *node)
106 : {
107 8576457 : WRITE_NODE_TYPE("VAR");
108 :
109 8576457 : WRITE_INT_FIELD(varno);
110 8576457 : WRITE_INT_FIELD(varattno);
111 8576457 : WRITE_OID_FIELD(vartype);
112 8576457 : WRITE_INT_FIELD(vartypmod);
113 8576457 : WRITE_OID_FIELD(varcollid);
114 8576457 : WRITE_BITMAPSET_FIELD(varnullingrels);
115 8576457 : WRITE_UINT_FIELD(varlevelsup);
116 8576457 : WRITE_ENUM_FIELD(varreturningtype, VarReturningType);
117 8576457 : WRITE_UINT_FIELD(varnosyn);
118 8576457 : WRITE_INT_FIELD(varattnosyn);
119 8576457 : WRITE_LOCATION_FIELD(location);
120 8576457 : }
121 :
122 : static void
123 215076 : _outParam(StringInfo str, const Param *node)
124 : {
125 215076 : WRITE_NODE_TYPE("PARAM");
126 :
127 215076 : WRITE_ENUM_FIELD(paramkind, ParamKind);
128 215076 : WRITE_INT_FIELD(paramid);
129 215076 : WRITE_OID_FIELD(paramtype);
130 215076 : WRITE_INT_FIELD(paramtypmod);
131 215076 : WRITE_OID_FIELD(paramcollid);
132 215076 : WRITE_LOCATION_FIELD(location);
133 215076 : }
134 :
135 : static void
136 68344 : _outAggref(StringInfo str, const Aggref *node)
137 : {
138 68344 : WRITE_NODE_TYPE("AGGREF");
139 :
140 68344 : WRITE_OID_FIELD(aggfnoid);
141 68344 : WRITE_OID_FIELD(aggtype);
142 68344 : WRITE_OID_FIELD(aggcollid);
143 68344 : WRITE_OID_FIELD(inputcollid);
144 68344 : WRITE_OID_FIELD(aggtranstype);
145 68344 : WRITE_NODE_FIELD(aggargtypes);
146 68344 : WRITE_NODE_FIELD(aggdirectargs);
147 68344 : WRITE_NODE_FIELD(args);
148 68344 : WRITE_NODE_FIELD(aggorder);
149 68344 : WRITE_NODE_FIELD(aggdistinct);
150 68344 : WRITE_NODE_FIELD(aggfilter);
151 68344 : WRITE_BOOL_FIELD(aggstar);
152 68344 : WRITE_BOOL_FIELD(aggvariadic);
153 68344 : WRITE_CHAR_FIELD(aggkind);
154 68344 : WRITE_BOOL_FIELD(aggpresorted);
155 68344 : WRITE_UINT_FIELD(agglevelsup);
156 68344 : WRITE_ENUM_FIELD(aggsplit, AggSplit);
157 68344 : WRITE_INT_FIELD(aggno);
158 68344 : WRITE_INT_FIELD(aggtransno);
159 68344 : WRITE_LOCATION_FIELD(location);
160 68344 : }
161 :
162 : static void
163 748 : _outGroupingFunc(StringInfo str, const GroupingFunc *node)
164 : {
165 748 : WRITE_NODE_TYPE("GROUPINGFUNC");
166 :
167 748 : WRITE_NODE_FIELD(args);
168 748 : WRITE_NODE_FIELD(refs);
169 748 : WRITE_NODE_FIELD(cols);
170 748 : WRITE_UINT_FIELD(agglevelsup);
171 748 : WRITE_LOCATION_FIELD(location);
172 748 : }
173 :
174 : static void
175 5225 : _outWindowFunc(StringInfo str, const WindowFunc *node)
176 : {
177 5225 : WRITE_NODE_TYPE("WINDOWFUNC");
178 :
179 5225 : WRITE_OID_FIELD(winfnoid);
180 5225 : WRITE_OID_FIELD(wintype);
181 5225 : WRITE_OID_FIELD(wincollid);
182 5225 : WRITE_OID_FIELD(inputcollid);
183 5225 : WRITE_NODE_FIELD(args);
184 5225 : WRITE_NODE_FIELD(aggfilter);
185 5225 : WRITE_NODE_FIELD(runCondition);
186 5225 : WRITE_UINT_FIELD(winref);
187 5225 : WRITE_BOOL_FIELD(winstar);
188 5225 : WRITE_BOOL_FIELD(winagg);
189 5225 : WRITE_INT_FIELD(ignore_nulls);
190 5225 : WRITE_LOCATION_FIELD(location);
191 5225 : }
192 :
193 : static void
194 240 : _outWindowFuncRunCondition(StringInfo str, const WindowFuncRunCondition *node)
195 : {
196 240 : WRITE_NODE_TYPE("WINDOWFUNCRUNCONDITION");
197 :
198 240 : WRITE_OID_FIELD(opno);
199 240 : WRITE_OID_FIELD(inputcollid);
200 240 : WRITE_BOOL_FIELD(wfunc_left);
201 240 : WRITE_NODE_FIELD(arg);
202 240 : }
203 :
204 : static void
205 573 : _outMergeSupportFunc(StringInfo str, const MergeSupportFunc *node)
206 : {
207 573 : WRITE_NODE_TYPE("MERGESUPPORTFUNC");
208 :
209 573 : WRITE_OID_FIELD(msftype);
210 573 : WRITE_OID_FIELD(msfcollid);
211 573 : WRITE_LOCATION_FIELD(location);
212 573 : }
213 :
214 : static void
215 26315 : _outSubscriptingRef(StringInfo str, const SubscriptingRef *node)
216 : {
217 26315 : WRITE_NODE_TYPE("SUBSCRIPTINGREF");
218 :
219 26315 : WRITE_OID_FIELD(refcontainertype);
220 26315 : WRITE_OID_FIELD(refelemtype);
221 26315 : WRITE_OID_FIELD(refrestype);
222 26315 : WRITE_INT_FIELD(reftypmod);
223 26315 : WRITE_OID_FIELD(refcollid);
224 26315 : WRITE_NODE_FIELD(refupperindexpr);
225 26315 : WRITE_NODE_FIELD(reflowerindexpr);
226 26315 : WRITE_NODE_FIELD(refexpr);
227 26315 : WRITE_NODE_FIELD(refassgnexpr);
228 26315 : }
229 :
230 : static void
231 506305 : _outFuncExpr(StringInfo str, const FuncExpr *node)
232 : {
233 506305 : WRITE_NODE_TYPE("FUNCEXPR");
234 :
235 506305 : WRITE_OID_FIELD(funcid);
236 506305 : WRITE_OID_FIELD(funcresulttype);
237 506305 : WRITE_BOOL_FIELD(funcretset);
238 506305 : WRITE_BOOL_FIELD(funcvariadic);
239 506305 : WRITE_ENUM_FIELD(funcformat, CoercionForm);
240 506305 : WRITE_OID_FIELD(funccollid);
241 506305 : WRITE_OID_FIELD(inputcollid);
242 506305 : WRITE_NODE_FIELD(args);
243 506305 : WRITE_LOCATION_FIELD(location);
244 506305 : }
245 :
246 : static void
247 53309 : _outNamedArgExpr(StringInfo str, const NamedArgExpr *node)
248 : {
249 53309 : WRITE_NODE_TYPE("NAMEDARGEXPR");
250 :
251 53309 : WRITE_NODE_FIELD(arg);
252 53309 : WRITE_STRING_FIELD(name);
253 53309 : WRITE_INT_FIELD(argnumber);
254 53309 : WRITE_LOCATION_FIELD(location);
255 53309 : }
256 :
257 : static void
258 1035608 : _outOpExpr(StringInfo str, const OpExpr *node)
259 : {
260 1035608 : WRITE_NODE_TYPE("OPEXPR");
261 :
262 1035608 : WRITE_OID_FIELD(opno);
263 1035608 : WRITE_OID_FIELD(opfuncid);
264 1035608 : WRITE_OID_FIELD(opresulttype);
265 1035608 : WRITE_BOOL_FIELD(opretset);
266 1035608 : WRITE_OID_FIELD(opcollid);
267 1035608 : WRITE_OID_FIELD(inputcollid);
268 1035608 : WRITE_NODE_FIELD(args);
269 1035608 : WRITE_LOCATION_FIELD(location);
270 1035608 : }
271 :
272 : static void
273 1554 : _outDistinctExpr(StringInfo str, const DistinctExpr *node)
274 : {
275 1554 : WRITE_NODE_TYPE("DISTINCTEXPR");
276 :
277 1554 : WRITE_OID_FIELD(opno);
278 1554 : WRITE_OID_FIELD(opfuncid);
279 1554 : WRITE_OID_FIELD(opresulttype);
280 1554 : WRITE_BOOL_FIELD(opretset);
281 1554 : WRITE_OID_FIELD(opcollid);
282 1554 : WRITE_OID_FIELD(inputcollid);
283 1554 : WRITE_NODE_FIELD(args);
284 1554 : WRITE_LOCATION_FIELD(location);
285 1554 : }
286 :
287 : static void
288 720 : _outNullIfExpr(StringInfo str, const NullIfExpr *node)
289 : {
290 720 : WRITE_NODE_TYPE("NULLIFEXPR");
291 :
292 720 : WRITE_OID_FIELD(opno);
293 720 : WRITE_OID_FIELD(opfuncid);
294 720 : WRITE_OID_FIELD(opresulttype);
295 720 : WRITE_BOOL_FIELD(opretset);
296 720 : WRITE_OID_FIELD(opcollid);
297 720 : WRITE_OID_FIELD(inputcollid);
298 720 : WRITE_NODE_FIELD(args);
299 720 : WRITE_LOCATION_FIELD(location);
300 720 : }
301 :
302 : static void
303 49624 : _outScalarArrayOpExpr(StringInfo str, const ScalarArrayOpExpr *node)
304 : {
305 49624 : WRITE_NODE_TYPE("SCALARARRAYOPEXPR");
306 :
307 49624 : WRITE_OID_FIELD(opno);
308 49624 : WRITE_OID_FIELD(opfuncid);
309 49624 : WRITE_OID_FIELD(hashfuncid);
310 49624 : WRITE_OID_FIELD(negfuncid);
311 49624 : WRITE_BOOL_FIELD(useOr);
312 49624 : WRITE_OID_FIELD(inputcollid);
313 49624 : WRITE_NODE_FIELD(args);
314 49624 : WRITE_LOCATION_FIELD(location);
315 49624 : }
316 :
317 : static void
318 70615 : _outSubLink(StringInfo str, const SubLink *node)
319 : {
320 70615 : WRITE_NODE_TYPE("SUBLINK");
321 :
322 70615 : WRITE_ENUM_FIELD(subLinkType, SubLinkType);
323 70615 : WRITE_INT_FIELD(subLinkId);
324 70615 : WRITE_NODE_FIELD(testexpr);
325 70615 : WRITE_NODE_FIELD(operName);
326 70615 : WRITE_NODE_FIELD(subselect);
327 70615 : WRITE_LOCATION_FIELD(location);
328 70615 : }
329 :
330 : static void
331 28788 : _outSubPlan(StringInfo str, const SubPlan *node)
332 : {
333 28788 : WRITE_NODE_TYPE("SUBPLAN");
334 :
335 28788 : WRITE_ENUM_FIELD(subLinkType, SubLinkType);
336 28788 : WRITE_NODE_FIELD(testexpr);
337 28788 : WRITE_NODE_FIELD(paramIds);
338 28788 : WRITE_INT_FIELD(plan_id);
339 28788 : WRITE_STRING_FIELD(plan_name);
340 28788 : WRITE_OID_FIELD(firstColType);
341 28788 : WRITE_INT_FIELD(firstColTypmod);
342 28788 : WRITE_OID_FIELD(firstColCollation);
343 28788 : WRITE_BOOL_FIELD(isInitPlan);
344 28788 : WRITE_BOOL_FIELD(useHashTable);
345 28788 : WRITE_BOOL_FIELD(unknownEqFalse);
346 28788 : WRITE_BOOL_FIELD(parallel_safe);
347 28788 : WRITE_NODE_FIELD(setParam);
348 28788 : WRITE_NODE_FIELD(parParam);
349 28788 : WRITE_NODE_FIELD(args);
350 28788 : WRITE_INT_FIELD(disabled_nodes);
351 28788 : WRITE_FLOAT_FIELD(startup_cost);
352 28788 : WRITE_FLOAT_FIELD(per_call_cost);
353 28788 : }
354 :
355 : static void
356 0 : _outAlternativeSubPlan(StringInfo str, const AlternativeSubPlan *node)
357 : {
358 0 : WRITE_NODE_TYPE("ALTERNATIVESUBPLAN");
359 :
360 0 : WRITE_NODE_FIELD(subplans);
361 0 : }
362 :
363 : static void
364 46282 : _outFieldSelect(StringInfo str, const FieldSelect *node)
365 : {
366 46282 : WRITE_NODE_TYPE("FIELDSELECT");
367 :
368 46282 : WRITE_NODE_FIELD(arg);
369 46282 : WRITE_INT_FIELD(fieldnum);
370 46282 : WRITE_OID_FIELD(resulttype);
371 46282 : WRITE_INT_FIELD(resulttypmod);
372 46282 : WRITE_OID_FIELD(resultcollid);
373 46282 : }
374 :
375 : static void
376 574 : _outFieldStore(StringInfo str, const FieldStore *node)
377 : {
378 574 : WRITE_NODE_TYPE("FIELDSTORE");
379 :
380 574 : WRITE_NODE_FIELD(arg);
381 574 : WRITE_NODE_FIELD(newvals);
382 574 : WRITE_NODE_FIELD(fieldnums);
383 574 : WRITE_OID_FIELD(resulttype);
384 574 : }
385 :
386 : static void
387 172790 : _outRelabelType(StringInfo str, const RelabelType *node)
388 : {
389 172790 : WRITE_NODE_TYPE("RELABELTYPE");
390 :
391 172790 : WRITE_NODE_FIELD(arg);
392 172790 : WRITE_OID_FIELD(resulttype);
393 172790 : WRITE_INT_FIELD(resulttypmod);
394 172790 : WRITE_OID_FIELD(resultcollid);
395 172790 : WRITE_ENUM_FIELD(relabelformat, CoercionForm);
396 172790 : WRITE_LOCATION_FIELD(location);
397 172790 : }
398 :
399 : static void
400 35605 : _outCoerceViaIO(StringInfo str, const CoerceViaIO *node)
401 : {
402 35605 : WRITE_NODE_TYPE("COERCEVIAIO");
403 :
404 35605 : WRITE_NODE_FIELD(arg);
405 35605 : WRITE_OID_FIELD(resulttype);
406 35605 : WRITE_OID_FIELD(resultcollid);
407 35605 : WRITE_ENUM_FIELD(coerceformat, CoercionForm);
408 35605 : WRITE_LOCATION_FIELD(location);
409 35605 : }
410 :
411 : static void
412 6976 : _outArrayCoerceExpr(StringInfo str, const ArrayCoerceExpr *node)
413 : {
414 6976 : WRITE_NODE_TYPE("ARRAYCOERCEEXPR");
415 :
416 6976 : WRITE_NODE_FIELD(arg);
417 6976 : WRITE_NODE_FIELD(elemexpr);
418 6976 : WRITE_OID_FIELD(resulttype);
419 6976 : WRITE_INT_FIELD(resulttypmod);
420 6976 : WRITE_OID_FIELD(resultcollid);
421 6976 : WRITE_ENUM_FIELD(coerceformat, CoercionForm);
422 6976 : WRITE_LOCATION_FIELD(location);
423 6976 : }
424 :
425 : static void
426 555 : _outConvertRowtypeExpr(StringInfo str, const ConvertRowtypeExpr *node)
427 : {
428 555 : WRITE_NODE_TYPE("CONVERTROWTYPEEXPR");
429 :
430 555 : WRITE_NODE_FIELD(arg);
431 555 : WRITE_OID_FIELD(resulttype);
432 555 : WRITE_ENUM_FIELD(convertformat, CoercionForm);
433 555 : WRITE_LOCATION_FIELD(location);
434 555 : }
435 :
436 : static void
437 6706 : _outCollateExpr(StringInfo str, const CollateExpr *node)
438 : {
439 6706 : WRITE_NODE_TYPE("COLLATEEXPR");
440 :
441 6706 : WRITE_NODE_FIELD(arg);
442 6706 : WRITE_OID_FIELD(collOid);
443 6706 : WRITE_LOCATION_FIELD(location);
444 6706 : }
445 :
446 : static void
447 93978 : _outCaseExpr(StringInfo str, const CaseExpr *node)
448 : {
449 93978 : WRITE_NODE_TYPE("CASEEXPR");
450 :
451 93978 : WRITE_OID_FIELD(casetype);
452 93978 : WRITE_OID_FIELD(casecollid);
453 93978 : WRITE_NODE_FIELD(arg);
454 93978 : WRITE_NODE_FIELD(args);
455 93978 : WRITE_NODE_FIELD(defresult);
456 93978 : WRITE_LOCATION_FIELD(location);
457 93978 : }
458 :
459 : static void
460 188204 : _outCaseWhen(StringInfo str, const CaseWhen *node)
461 : {
462 188204 : WRITE_NODE_TYPE("CASEWHEN");
463 :
464 188204 : WRITE_NODE_FIELD(expr);
465 188204 : WRITE_NODE_FIELD(result);
466 188204 : WRITE_LOCATION_FIELD(location);
467 188204 : }
468 :
469 : static void
470 41961 : _outCaseTestExpr(StringInfo str, const CaseTestExpr *node)
471 : {
472 41961 : WRITE_NODE_TYPE("CASETESTEXPR");
473 :
474 41961 : WRITE_OID_FIELD(typeId);
475 41961 : WRITE_INT_FIELD(typeMod);
476 41961 : WRITE_OID_FIELD(collation);
477 41961 : }
478 :
479 : static void
480 21881 : _outArrayExpr(StringInfo str, const ArrayExpr *node)
481 : {
482 21881 : WRITE_NODE_TYPE("ARRAYEXPR");
483 :
484 21881 : WRITE_OID_FIELD(array_typeid);
485 21881 : WRITE_OID_FIELD(array_collid);
486 21881 : WRITE_OID_FIELD(element_typeid);
487 21881 : WRITE_NODE_FIELD(elements);
488 21881 : WRITE_BOOL_FIELD(multidims);
489 21881 : WRITE_LOCATION_FIELD(list_start);
490 21881 : WRITE_LOCATION_FIELD(list_end);
491 21881 : WRITE_LOCATION_FIELD(location);
492 21881 : }
493 :
494 : static void
495 9024 : _outRowExpr(StringInfo str, const RowExpr *node)
496 : {
497 9024 : WRITE_NODE_TYPE("ROWEXPR");
498 :
499 9024 : WRITE_NODE_FIELD(args);
500 9024 : WRITE_OID_FIELD(row_typeid);
501 9024 : WRITE_ENUM_FIELD(row_format, CoercionForm);
502 9024 : WRITE_NODE_FIELD(colnames);
503 9024 : WRITE_LOCATION_FIELD(location);
504 9024 : }
505 :
506 : static void
507 508 : _outRowCompareExpr(StringInfo str, const RowCompareExpr *node)
508 : {
509 508 : WRITE_NODE_TYPE("ROWCOMPAREEXPR");
510 :
511 508 : WRITE_ENUM_FIELD(cmptype, CompareType);
512 508 : WRITE_NODE_FIELD(opnos);
513 508 : WRITE_NODE_FIELD(opfamilies);
514 508 : WRITE_NODE_FIELD(inputcollids);
515 508 : WRITE_NODE_FIELD(largs);
516 508 : WRITE_NODE_FIELD(rargs);
517 508 : }
518 :
519 : static void
520 10176 : _outCoalesceExpr(StringInfo str, const CoalesceExpr *node)
521 : {
522 10176 : WRITE_NODE_TYPE("COALESCEEXPR");
523 :
524 10176 : WRITE_OID_FIELD(coalescetype);
525 10176 : WRITE_OID_FIELD(coalescecollid);
526 10176 : WRITE_NODE_FIELD(args);
527 10176 : WRITE_LOCATION_FIELD(location);
528 10176 : }
529 :
530 : static void
531 635 : _outMinMaxExpr(StringInfo str, const MinMaxExpr *node)
532 : {
533 635 : WRITE_NODE_TYPE("MINMAXEXPR");
534 :
535 635 : WRITE_OID_FIELD(minmaxtype);
536 635 : WRITE_OID_FIELD(minmaxcollid);
537 635 : WRITE_OID_FIELD(inputcollid);
538 635 : WRITE_ENUM_FIELD(op, MinMaxOp);
539 635 : WRITE_NODE_FIELD(args);
540 635 : WRITE_LOCATION_FIELD(location);
541 635 : }
542 :
543 : static void
544 8419 : _outSQLValueFunction(StringInfo str, const SQLValueFunction *node)
545 : {
546 8419 : WRITE_NODE_TYPE("SQLVALUEFUNCTION");
547 :
548 8419 : WRITE_ENUM_FIELD(op, SQLValueFunctionOp);
549 8419 : WRITE_OID_FIELD(type);
550 8419 : WRITE_INT_FIELD(typmod);
551 8419 : WRITE_LOCATION_FIELD(location);
552 8419 : }
553 :
554 : static void
555 1426 : _outXmlExpr(StringInfo str, const XmlExpr *node)
556 : {
557 1426 : WRITE_NODE_TYPE("XMLEXPR");
558 :
559 1426 : WRITE_ENUM_FIELD(op, XmlExprOp);
560 1426 : WRITE_STRING_FIELD(name);
561 1426 : WRITE_NODE_FIELD(named_args);
562 1426 : WRITE_NODE_FIELD(arg_names);
563 1426 : WRITE_NODE_FIELD(args);
564 1426 : WRITE_ENUM_FIELD(xmloption, XmlOptionType);
565 1426 : WRITE_BOOL_FIELD(indent);
566 1426 : WRITE_OID_FIELD(type);
567 1426 : WRITE_INT_FIELD(typmod);
568 1426 : WRITE_LOCATION_FIELD(location);
569 1426 : }
570 :
571 : static void
572 16230 : _outJsonFormat(StringInfo str, const JsonFormat *node)
573 : {
574 16230 : WRITE_NODE_TYPE("JSONFORMAT");
575 :
576 16230 : WRITE_ENUM_FIELD(format_type, JsonFormatType);
577 16230 : WRITE_ENUM_FIELD(encoding, JsonEncoding);
578 16230 : WRITE_LOCATION_FIELD(location);
579 16230 : }
580 :
581 : static void
582 7062 : _outJsonReturning(StringInfo str, const JsonReturning *node)
583 : {
584 7062 : WRITE_NODE_TYPE("JSONRETURNING");
585 :
586 7062 : WRITE_NODE_FIELD(format);
587 7062 : WRITE_OID_FIELD(typid);
588 7062 : WRITE_INT_FIELD(typmod);
589 7062 : }
590 :
591 : static void
592 4340 : _outJsonValueExpr(StringInfo str, const JsonValueExpr *node)
593 : {
594 4340 : WRITE_NODE_TYPE("JSONVALUEEXPR");
595 :
596 4340 : WRITE_NODE_FIELD(raw_expr);
597 4340 : WRITE_NODE_FIELD(formatted_expr);
598 4340 : WRITE_NODE_FIELD(format);
599 4340 : }
600 :
601 : static void
602 1988 : _outJsonConstructorExpr(StringInfo str, const JsonConstructorExpr *node)
603 : {
604 1988 : WRITE_NODE_TYPE("JSONCONSTRUCTOREXPR");
605 :
606 1988 : WRITE_ENUM_FIELD(type, JsonConstructorType);
607 1988 : WRITE_NODE_FIELD(args);
608 1988 : WRITE_NODE_FIELD(func);
609 1988 : WRITE_NODE_FIELD(coercion);
610 1988 : WRITE_NODE_FIELD(returning);
611 1988 : WRITE_NODE_FIELD(orig_query);
612 1988 : WRITE_BOOL_FIELD(absent_on_null);
613 1988 : WRITE_BOOL_FIELD(unique);
614 1988 : WRITE_LOCATION_FIELD(location);
615 1988 : }
616 :
617 : static void
618 816 : _outJsonIsPredicate(StringInfo str, const JsonIsPredicate *node)
619 : {
620 816 : WRITE_NODE_TYPE("JSONISPREDICATE");
621 :
622 816 : WRITE_NODE_FIELD(expr);
623 816 : WRITE_NODE_FIELD(format);
624 816 : WRITE_ENUM_FIELD(item_type, JsonValueType);
625 816 : WRITE_BOOL_FIELD(unique_keys);
626 816 : WRITE_OID_FIELD(exprBaseType);
627 816 : WRITE_LOCATION_FIELD(location);
628 816 : }
629 :
630 : static void
631 7072 : _outJsonBehavior(StringInfo str, const JsonBehavior *node)
632 : {
633 7072 : WRITE_NODE_TYPE("JSONBEHAVIOR");
634 :
635 7072 : WRITE_ENUM_FIELD(btype, JsonBehaviorType);
636 7072 : WRITE_NODE_FIELD(expr);
637 7072 : WRITE_BOOL_FIELD(coerce);
638 7072 : WRITE_LOCATION_FIELD(location);
639 7072 : }
640 :
641 : static void
642 3612 : _outJsonExpr(StringInfo str, const JsonExpr *node)
643 : {
644 3612 : WRITE_NODE_TYPE("JSONEXPR");
645 :
646 3612 : WRITE_ENUM_FIELD(op, JsonExprOp);
647 3612 : WRITE_STRING_FIELD(column_name);
648 3612 : WRITE_NODE_FIELD(formatted_expr);
649 3612 : WRITE_NODE_FIELD(format);
650 3612 : WRITE_NODE_FIELD(path_spec);
651 3612 : WRITE_NODE_FIELD(returning);
652 3612 : WRITE_NODE_FIELD(passing_names);
653 3612 : WRITE_NODE_FIELD(passing_values);
654 3612 : WRITE_NODE_FIELD(on_empty);
655 3612 : WRITE_NODE_FIELD(on_error);
656 3612 : WRITE_BOOL_FIELD(use_io_coercion);
657 3612 : WRITE_BOOL_FIELD(use_json_coercion);
658 3612 : WRITE_ENUM_FIELD(wrapper, JsonWrapper);
659 3612 : WRITE_BOOL_FIELD(omit_quotes);
660 3612 : WRITE_OID_FIELD(collation);
661 3612 : WRITE_LOCATION_FIELD(location);
662 3612 : }
663 :
664 : static void
665 856 : _outJsonTablePath(StringInfo str, const JsonTablePath *node)
666 : {
667 856 : WRITE_NODE_TYPE("JSONTABLEPATH");
668 :
669 856 : WRITE_NODE_FIELD(value);
670 856 : WRITE_STRING_FIELD(name);
671 856 : }
672 :
673 : static void
674 856 : _outJsonTablePathScan(StringInfo str, const JsonTablePathScan *node)
675 : {
676 856 : WRITE_NODE_TYPE("JSONTABLEPATHSCAN");
677 :
678 856 : WRITE_NODE_FIELD(path);
679 856 : WRITE_BOOL_FIELD(errorOnError);
680 856 : WRITE_NODE_FIELD(child);
681 856 : WRITE_INT_FIELD(colMin);
682 856 : WRITE_INT_FIELD(colMax);
683 856 : }
684 :
685 : static void
686 100 : _outJsonTableSiblingJoin(StringInfo str, const JsonTableSiblingJoin *node)
687 : {
688 100 : WRITE_NODE_TYPE("JSONTABLESIBLINGJOIN");
689 :
690 100 : WRITE_NODE_FIELD(lplan);
691 100 : WRITE_NODE_FIELD(rplan);
692 100 : }
693 :
694 : static void
695 36626 : _outNullTest(StringInfo str, const NullTest *node)
696 : {
697 36626 : WRITE_NODE_TYPE("NULLTEST");
698 :
699 36626 : WRITE_NODE_FIELD(arg);
700 36626 : WRITE_ENUM_FIELD(nulltesttype, NullTestType);
701 36626 : WRITE_BOOL_FIELD(argisrow);
702 36626 : WRITE_LOCATION_FIELD(location);
703 36626 : }
704 :
705 : static void
706 2692 : _outBooleanTest(StringInfo str, const BooleanTest *node)
707 : {
708 2692 : WRITE_NODE_TYPE("BOOLEANTEST");
709 :
710 2692 : WRITE_NODE_FIELD(arg);
711 2692 : WRITE_ENUM_FIELD(booltesttype, BoolTestType);
712 2692 : WRITE_LOCATION_FIELD(location);
713 2692 : }
714 :
715 : static void
716 4335 : _outMergeAction(StringInfo str, const MergeAction *node)
717 : {
718 4335 : WRITE_NODE_TYPE("MERGEACTION");
719 :
720 4335 : WRITE_ENUM_FIELD(matchKind, MergeMatchKind);
721 4335 : WRITE_ENUM_FIELD(commandType, CmdType);
722 4335 : WRITE_ENUM_FIELD(override, OverridingKind);
723 4335 : WRITE_NODE_FIELD(qual);
724 4335 : WRITE_NODE_FIELD(targetList);
725 4335 : WRITE_NODE_FIELD(updateColnos);
726 4335 : }
727 :
728 : static void
729 67389 : _outCoerceToDomain(StringInfo str, const CoerceToDomain *node)
730 : {
731 67389 : WRITE_NODE_TYPE("COERCETODOMAIN");
732 :
733 67389 : WRITE_NODE_FIELD(arg);
734 67389 : WRITE_OID_FIELD(resulttype);
735 67389 : WRITE_INT_FIELD(resulttypmod);
736 67389 : WRITE_OID_FIELD(resultcollid);
737 67389 : WRITE_ENUM_FIELD(coercionformat, CoercionForm);
738 67389 : WRITE_LOCATION_FIELD(location);
739 67389 : }
740 :
741 : static void
742 567 : _outCoerceToDomainValue(StringInfo str, const CoerceToDomainValue *node)
743 : {
744 567 : WRITE_NODE_TYPE("COERCETODOMAINVALUE");
745 :
746 567 : WRITE_OID_FIELD(typeId);
747 567 : WRITE_INT_FIELD(typeMod);
748 567 : WRITE_OID_FIELD(collation);
749 567 : WRITE_LOCATION_FIELD(location);
750 567 : }
751 :
752 : static void
753 1044 : _outSetToDefault(StringInfo str, const SetToDefault *node)
754 : {
755 1044 : WRITE_NODE_TYPE("SETTODEFAULT");
756 :
757 1044 : WRITE_OID_FIELD(typeId);
758 1044 : WRITE_INT_FIELD(typeMod);
759 1044 : WRITE_OID_FIELD(collation);
760 1044 : WRITE_LOCATION_FIELD(location);
761 1044 : }
762 :
763 : static void
764 621 : _outCurrentOfExpr(StringInfo str, const CurrentOfExpr *node)
765 : {
766 621 : WRITE_NODE_TYPE("CURRENTOFEXPR");
767 :
768 621 : WRITE_UINT_FIELD(cvarno);
769 621 : WRITE_STRING_FIELD(cursor_name);
770 621 : WRITE_INT_FIELD(cursor_param);
771 621 : }
772 :
773 : static void
774 594 : _outNextValueExpr(StringInfo str, const NextValueExpr *node)
775 : {
776 594 : WRITE_NODE_TYPE("NEXTVALUEEXPR");
777 :
778 594 : WRITE_OID_FIELD(seqid);
779 594 : WRITE_OID_FIELD(typeId);
780 594 : }
781 :
782 : static void
783 1552 : _outInferenceElem(StringInfo str, const InferenceElem *node)
784 : {
785 1552 : WRITE_NODE_TYPE("INFERENCEELEM");
786 :
787 1552 : WRITE_NODE_FIELD(expr);
788 1552 : WRITE_OID_FIELD(infercollid);
789 1552 : WRITE_OID_FIELD(inferopclass);
790 1552 : }
791 :
792 : static void
793 868 : _outReturningExpr(StringInfo str, const ReturningExpr *node)
794 : {
795 868 : WRITE_NODE_TYPE("RETURNINGEXPR");
796 :
797 868 : WRITE_INT_FIELD(retlevelsup);
798 868 : WRITE_BOOL_FIELD(retold);
799 868 : WRITE_NODE_FIELD(retexpr);
800 868 : }
801 :
802 : static void
803 77 : _outGraphLabelRef(StringInfo str, const GraphLabelRef *node)
804 : {
805 77 : WRITE_NODE_TYPE("GRAPHLABELREF");
806 :
807 77 : WRITE_OID_FIELD(labelid);
808 77 : WRITE_LOCATION_FIELD(location);
809 77 : }
810 :
811 : static void
812 48 : _outGraphPropertyRef(StringInfo str, const GraphPropertyRef *node)
813 : {
814 48 : WRITE_NODE_TYPE("GRAPHPROPERTYREF");
815 :
816 48 : WRITE_STRING_FIELD(elvarname);
817 48 : WRITE_OID_FIELD(propid);
818 48 : WRITE_OID_FIELD(typeId);
819 48 : WRITE_INT_FIELD(typmod);
820 48 : WRITE_OID_FIELD(collation);
821 48 : WRITE_LOCATION_FIELD(location);
822 48 : }
823 :
824 : static void
825 4891937 : _outTargetEntry(StringInfo str, const TargetEntry *node)
826 : {
827 4891937 : WRITE_NODE_TYPE("TARGETENTRY");
828 :
829 4891937 : WRITE_NODE_FIELD(expr);
830 4891937 : WRITE_INT_FIELD(resno);
831 4891937 : WRITE_STRING_FIELD(resname);
832 4891937 : WRITE_UINT_FIELD(ressortgroupref);
833 4891937 : WRITE_OID_FIELD(resorigtbl);
834 4891937 : WRITE_INT_FIELD(resorigcol);
835 4891937 : WRITE_BOOL_FIELD(resjunk);
836 4891937 : }
837 :
838 : static void
839 399555 : _outRangeTblRef(StringInfo str, const RangeTblRef *node)
840 : {
841 399555 : WRITE_NODE_TYPE("RANGETBLREF");
842 :
843 399555 : WRITE_INT_FIELD(rtindex);
844 399555 : }
845 :
846 : static void
847 137922 : _outJoinExpr(StringInfo str, const JoinExpr *node)
848 : {
849 137922 : WRITE_NODE_TYPE("JOINEXPR");
850 :
851 137922 : WRITE_ENUM_FIELD(jointype, JoinType);
852 137922 : WRITE_BOOL_FIELD(isNatural);
853 137922 : WRITE_NODE_FIELD(larg);
854 137922 : WRITE_NODE_FIELD(rarg);
855 137922 : WRITE_NODE_FIELD(usingClause);
856 137922 : WRITE_NODE_FIELD(join_using_alias);
857 137922 : WRITE_NODE_FIELD(quals);
858 137922 : WRITE_NODE_FIELD(alias);
859 137922 : WRITE_INT_FIELD(rtindex);
860 137922 : }
861 :
862 : static void
863 400126 : _outFromExpr(StringInfo str, const FromExpr *node)
864 : {
865 400126 : WRITE_NODE_TYPE("FROMEXPR");
866 :
867 400126 : WRITE_NODE_FIELD(fromlist);
868 400126 : WRITE_NODE_FIELD(quals);
869 400126 : }
870 :
871 : static void
872 1532 : _outOnConflictExpr(StringInfo str, const OnConflictExpr *node)
873 : {
874 1532 : WRITE_NODE_TYPE("ONCONFLICTEXPR");
875 :
876 1532 : WRITE_ENUM_FIELD(action, OnConflictAction);
877 1532 : WRITE_NODE_FIELD(arbiterElems);
878 1532 : WRITE_NODE_FIELD(arbiterWhere);
879 1532 : WRITE_OID_FIELD(constraint);
880 1532 : WRITE_ENUM_FIELD(lockStrength, LockClauseStrength);
881 1532 : WRITE_NODE_FIELD(onConflictSet);
882 1532 : WRITE_NODE_FIELD(onConflictWhere);
883 1532 : WRITE_INT_FIELD(exclRelIndex);
884 1532 : WRITE_NODE_FIELD(exclRelTlist);
885 1532 : }
886 :
887 : static void
888 1722 : _outForPortionOfExpr(StringInfo str, const ForPortionOfExpr *node)
889 : {
890 1722 : WRITE_NODE_TYPE("FORPORTIONOFEXPR");
891 :
892 1722 : WRITE_NODE_FIELD(rangeVar);
893 1722 : WRITE_STRING_FIELD(range_name);
894 1722 : WRITE_NODE_FIELD(targetFrom);
895 1722 : WRITE_NODE_FIELD(targetTo);
896 1722 : WRITE_NODE_FIELD(targetRange);
897 1722 : WRITE_OID_FIELD(rangeType);
898 1722 : WRITE_BOOL_FIELD(isDomain);
899 1722 : WRITE_NODE_FIELD(overlapsExpr);
900 1722 : WRITE_NODE_FIELD(rangeTargetList);
901 1722 : WRITE_OID_FIELD(withoutPortionProc);
902 1722 : WRITE_LOCATION_FIELD(location);
903 1722 : WRITE_LOCATION_FIELD(targetLocation);
904 1722 : }
905 :
906 : static void
907 643974 : _outQuery(StringInfo str, const Query *node)
908 : {
909 643974 : WRITE_NODE_TYPE("QUERY");
910 :
911 643974 : WRITE_ENUM_FIELD(commandType, CmdType);
912 643974 : WRITE_ENUM_FIELD(querySource, QuerySource);
913 643974 : WRITE_BOOL_FIELD(canSetTag);
914 643974 : WRITE_NODE_FIELD(utilityStmt);
915 643974 : WRITE_INT_FIELD(resultRelation);
916 643974 : WRITE_NODE_FIELD(forPortionOf);
917 643974 : WRITE_BOOL_FIELD(hasAggs);
918 643974 : WRITE_BOOL_FIELD(hasWindowFuncs);
919 643974 : WRITE_BOOL_FIELD(hasTargetSRFs);
920 643974 : WRITE_BOOL_FIELD(hasSubLinks);
921 643974 : WRITE_BOOL_FIELD(hasDistinctOn);
922 643974 : WRITE_BOOL_FIELD(hasRecursive);
923 643974 : WRITE_BOOL_FIELD(hasModifyingCTE);
924 643974 : WRITE_BOOL_FIELD(hasForUpdate);
925 643974 : WRITE_BOOL_FIELD(hasRowSecurity);
926 643974 : WRITE_BOOL_FIELD(hasGroupRTE);
927 643974 : WRITE_BOOL_FIELD(isReturn);
928 643974 : WRITE_NODE_FIELD(cteList);
929 643974 : WRITE_NODE_FIELD(rtable);
930 643974 : WRITE_NODE_FIELD(rteperminfos);
931 643974 : WRITE_NODE_FIELD(jointree);
932 643974 : WRITE_NODE_FIELD(mergeActionList);
933 643974 : WRITE_INT_FIELD(mergeTargetRelation);
934 643974 : WRITE_NODE_FIELD(mergeJoinCondition);
935 643974 : WRITE_NODE_FIELD(targetList);
936 643974 : WRITE_ENUM_FIELD(override, OverridingKind);
937 643974 : WRITE_NODE_FIELD(onConflict);
938 643974 : WRITE_STRING_FIELD(returningOldAlias);
939 643974 : WRITE_STRING_FIELD(returningNewAlias);
940 643974 : WRITE_NODE_FIELD(returningList);
941 643974 : WRITE_NODE_FIELD(groupClause);
942 643974 : WRITE_BOOL_FIELD(groupDistinct);
943 643974 : WRITE_BOOL_FIELD(groupByAll);
944 643974 : WRITE_NODE_FIELD(groupingSets);
945 643974 : WRITE_NODE_FIELD(havingQual);
946 643974 : WRITE_NODE_FIELD(windowClause);
947 643974 : WRITE_NODE_FIELD(distinctClause);
948 643974 : WRITE_NODE_FIELD(sortClause);
949 643974 : WRITE_NODE_FIELD(limitOffset);
950 643974 : WRITE_NODE_FIELD(limitCount);
951 643974 : WRITE_ENUM_FIELD(limitOption, LimitOption);
952 643974 : WRITE_NODE_FIELD(rowMarks);
953 643974 : WRITE_NODE_FIELD(setOperations);
954 643974 : WRITE_NODE_FIELD(constraintDeps);
955 643974 : WRITE_NODE_FIELD(withCheckOptions);
956 643974 : WRITE_LOCATION_FIELD(stmt_location);
957 643974 : WRITE_LOCATION_FIELD(stmt_len);
958 643974 : }
959 :
960 : static void
961 481700 : _outTypeName(StringInfo str, const TypeName *node)
962 : {
963 481700 : WRITE_NODE_TYPE("TYPENAME");
964 :
965 481700 : WRITE_NODE_FIELD(names);
966 481700 : WRITE_OID_FIELD(typeOid);
967 481700 : WRITE_BOOL_FIELD(setof);
968 481700 : WRITE_BOOL_FIELD(pct_type);
969 481700 : WRITE_NODE_FIELD(typmods);
970 481700 : WRITE_INT_FIELD(typemod);
971 481700 : WRITE_NODE_FIELD(arrayBounds);
972 481700 : WRITE_LOCATION_FIELD(location);
973 481700 : }
974 :
975 : static void
976 1387648 : _outColumnRef(StringInfo str, const ColumnRef *node)
977 : {
978 1387648 : WRITE_NODE_TYPE("COLUMNREF");
979 :
980 1387648 : WRITE_NODE_FIELD(fields);
981 1387648 : WRITE_LOCATION_FIELD(location);
982 1387648 : }
983 :
984 : static void
985 31446 : _outParamRef(StringInfo str, const ParamRef *node)
986 : {
987 31446 : WRITE_NODE_TYPE("PARAMREF");
988 :
989 31446 : WRITE_INT_FIELD(number);
990 31446 : WRITE_LOCATION_FIELD(location);
991 31446 : }
992 :
993 : static void
994 237325 : _outTypeCast(StringInfo str, const TypeCast *node)
995 : {
996 237325 : WRITE_NODE_TYPE("TYPECAST");
997 :
998 237325 : WRITE_NODE_FIELD(arg);
999 237325 : WRITE_NODE_FIELD(typeName);
1000 237325 : WRITE_LOCATION_FIELD(location);
1001 237325 : }
1002 :
1003 : static void
1004 7955 : _outCollateClause(StringInfo str, const CollateClause *node)
1005 : {
1006 7955 : WRITE_NODE_TYPE("COLLATECLAUSE");
1007 :
1008 7955 : WRITE_NODE_FIELD(arg);
1009 7955 : WRITE_NODE_FIELD(collname);
1010 7955 : WRITE_LOCATION_FIELD(location);
1011 7955 : }
1012 :
1013 : static void
1014 28719 : _outRoleSpec(StringInfo str, const RoleSpec *node)
1015 : {
1016 28719 : WRITE_NODE_TYPE("ROLESPEC");
1017 :
1018 28719 : WRITE_ENUM_FIELD(roletype, RoleSpecType);
1019 28719 : WRITE_STRING_FIELD(rolename);
1020 28719 : WRITE_LOCATION_FIELD(location);
1021 28719 : }
1022 :
1023 : static void
1024 273449 : _outFuncCall(StringInfo str, const FuncCall *node)
1025 : {
1026 273449 : WRITE_NODE_TYPE("FUNCCALL");
1027 :
1028 273449 : WRITE_NODE_FIELD(funcname);
1029 273449 : WRITE_NODE_FIELD(args);
1030 273449 : WRITE_NODE_FIELD(agg_order);
1031 273449 : WRITE_NODE_FIELD(agg_filter);
1032 273449 : WRITE_NODE_FIELD(over);
1033 273449 : WRITE_INT_FIELD(ignore_nulls);
1034 273449 : WRITE_BOOL_FIELD(agg_within_group);
1035 273449 : WRITE_BOOL_FIELD(agg_star);
1036 273449 : WRITE_BOOL_FIELD(agg_distinct);
1037 273449 : WRITE_BOOL_FIELD(func_variadic);
1038 273449 : WRITE_ENUM_FIELD(funcformat, CoercionForm);
1039 273449 : WRITE_LOCATION_FIELD(location);
1040 273449 : }
1041 :
1042 : static void
1043 47052 : _outA_Star(StringInfo str, const A_Star *node)
1044 : {
1045 47052 : WRITE_NODE_TYPE("A_STAR");
1046 :
1047 47052 : }
1048 :
1049 : static void
1050 10296 : _outA_Indices(StringInfo str, const A_Indices *node)
1051 : {
1052 10296 : WRITE_NODE_TYPE("A_INDICES");
1053 :
1054 10296 : WRITE_BOOL_FIELD(is_slice);
1055 10296 : WRITE_NODE_FIELD(lidx);
1056 10296 : WRITE_NODE_FIELD(uidx);
1057 10296 : }
1058 :
1059 : static void
1060 25452 : _outA_Indirection(StringInfo str, const A_Indirection *node)
1061 : {
1062 25452 : WRITE_NODE_TYPE("A_INDIRECTION");
1063 :
1064 25452 : WRITE_NODE_FIELD(arg);
1065 25452 : WRITE_NODE_FIELD(indirection);
1066 25452 : }
1067 :
1068 : static void
1069 5174 : _outA_ArrayExpr(StringInfo str, const A_ArrayExpr *node)
1070 : {
1071 5174 : WRITE_NODE_TYPE("A_ARRAYEXPR");
1072 :
1073 5174 : WRITE_NODE_FIELD(elements);
1074 5174 : WRITE_LOCATION_FIELD(list_start);
1075 5174 : WRITE_LOCATION_FIELD(list_end);
1076 5174 : WRITE_LOCATION_FIELD(location);
1077 5174 : }
1078 :
1079 : static void
1080 865213 : _outResTarget(StringInfo str, const ResTarget *node)
1081 : {
1082 865213 : WRITE_NODE_TYPE("RESTARGET");
1083 :
1084 865213 : WRITE_STRING_FIELD(name);
1085 865213 : WRITE_NODE_FIELD(indirection);
1086 865213 : WRITE_NODE_FIELD(val);
1087 865213 : WRITE_LOCATION_FIELD(location);
1088 865213 : }
1089 :
1090 : static void
1091 265 : _outMultiAssignRef(StringInfo str, const MultiAssignRef *node)
1092 : {
1093 265 : WRITE_NODE_TYPE("MULTIASSIGNREF");
1094 :
1095 265 : WRITE_NODE_FIELD(source);
1096 265 : WRITE_INT_FIELD(colno);
1097 265 : WRITE_INT_FIELD(ncolumns);
1098 265 : }
1099 :
1100 : static void
1101 77181 : _outSortBy(StringInfo str, const SortBy *node)
1102 : {
1103 77181 : WRITE_NODE_TYPE("SORTBY");
1104 :
1105 77181 : WRITE_NODE_FIELD(node);
1106 77181 : WRITE_ENUM_FIELD(sortby_dir, SortByDir);
1107 77181 : WRITE_ENUM_FIELD(sortby_nulls, SortByNulls);
1108 77181 : WRITE_NODE_FIELD(useOp);
1109 77181 : WRITE_LOCATION_FIELD(location);
1110 77181 : }
1111 :
1112 : static void
1113 3175 : _outWindowDef(StringInfo str, const WindowDef *node)
1114 : {
1115 3175 : WRITE_NODE_TYPE("WINDOWDEF");
1116 :
1117 3175 : WRITE_STRING_FIELD(name);
1118 3175 : WRITE_STRING_FIELD(refname);
1119 3175 : WRITE_NODE_FIELD(partitionClause);
1120 3175 : WRITE_NODE_FIELD(orderClause);
1121 3175 : WRITE_INT_FIELD(frameOptions);
1122 3175 : WRITE_NODE_FIELD(startOffset);
1123 3175 : WRITE_NODE_FIELD(endOffset);
1124 3175 : WRITE_LOCATION_FIELD(location);
1125 3175 : }
1126 :
1127 : static void
1128 16112 : _outRangeSubselect(StringInfo str, const RangeSubselect *node)
1129 : {
1130 16112 : WRITE_NODE_TYPE("RANGESUBSELECT");
1131 :
1132 16112 : WRITE_BOOL_FIELD(lateral);
1133 16112 : WRITE_NODE_FIELD(subquery);
1134 16112 : WRITE_NODE_FIELD(alias);
1135 16112 : }
1136 :
1137 : static void
1138 33649 : _outRangeFunction(StringInfo str, const RangeFunction *node)
1139 : {
1140 33649 : WRITE_NODE_TYPE("RANGEFUNCTION");
1141 :
1142 33649 : WRITE_BOOL_FIELD(lateral);
1143 33649 : WRITE_BOOL_FIELD(ordinality);
1144 33649 : WRITE_BOOL_FIELD(is_rowsfrom);
1145 33649 : WRITE_NODE_FIELD(functions);
1146 33649 : WRITE_NODE_FIELD(alias);
1147 33649 : WRITE_NODE_FIELD(coldeflist);
1148 33649 : }
1149 :
1150 : static void
1151 168 : _outRangeTableFunc(StringInfo str, const RangeTableFunc *node)
1152 : {
1153 168 : WRITE_NODE_TYPE("RANGETABLEFUNC");
1154 :
1155 168 : WRITE_BOOL_FIELD(lateral);
1156 168 : WRITE_NODE_FIELD(docexpr);
1157 168 : WRITE_NODE_FIELD(rowexpr);
1158 168 : WRITE_NODE_FIELD(namespaces);
1159 168 : WRITE_NODE_FIELD(columns);
1160 168 : WRITE_NODE_FIELD(alias);
1161 168 : WRITE_LOCATION_FIELD(location);
1162 168 : }
1163 :
1164 : static void
1165 582 : _outRangeTableFuncCol(StringInfo str, const RangeTableFuncCol *node)
1166 : {
1167 582 : WRITE_NODE_TYPE("RANGETABLEFUNCCOL");
1168 :
1169 582 : WRITE_STRING_FIELD(colname);
1170 582 : WRITE_NODE_FIELD(typeName);
1171 582 : WRITE_BOOL_FIELD(for_ordinality);
1172 582 : WRITE_BOOL_FIELD(is_not_null);
1173 582 : WRITE_NODE_FIELD(colexpr);
1174 582 : WRITE_NODE_FIELD(coldefexpr);
1175 582 : WRITE_LOCATION_FIELD(location);
1176 582 : }
1177 :
1178 : static void
1179 455 : _outRangeGraphTable(StringInfo str, const RangeGraphTable *node)
1180 : {
1181 455 : WRITE_NODE_TYPE("RANGEGRAPHTABLE");
1182 :
1183 455 : WRITE_NODE_FIELD(graph_name);
1184 455 : WRITE_NODE_FIELD(graph_pattern);
1185 455 : WRITE_NODE_FIELD(columns);
1186 455 : WRITE_NODE_FIELD(alias);
1187 455 : WRITE_LOCATION_FIELD(location);
1188 455 : }
1189 :
1190 : static void
1191 188 : _outRangeTableSample(StringInfo str, const RangeTableSample *node)
1192 : {
1193 188 : WRITE_NODE_TYPE("RANGETABLESAMPLE");
1194 :
1195 188 : WRITE_NODE_FIELD(relation);
1196 188 : WRITE_NODE_FIELD(method);
1197 188 : WRITE_NODE_FIELD(args);
1198 188 : WRITE_NODE_FIELD(repeatable);
1199 188 : WRITE_LOCATION_FIELD(location);
1200 188 : }
1201 :
1202 : static void
1203 95509 : _outColumnDef(StringInfo str, const ColumnDef *node)
1204 : {
1205 95509 : WRITE_NODE_TYPE("COLUMNDEF");
1206 :
1207 95509 : WRITE_STRING_FIELD(colname);
1208 95509 : WRITE_NODE_FIELD(typeName);
1209 95509 : WRITE_STRING_FIELD(compression);
1210 95509 : WRITE_INT_FIELD(inhcount);
1211 95509 : WRITE_BOOL_FIELD(is_local);
1212 95509 : WRITE_BOOL_FIELD(is_not_null);
1213 95509 : WRITE_BOOL_FIELD(is_from_type);
1214 95509 : WRITE_CHAR_FIELD(storage);
1215 95509 : WRITE_STRING_FIELD(storage_name);
1216 95509 : WRITE_NODE_FIELD(raw_default);
1217 95509 : WRITE_NODE_FIELD(cooked_default);
1218 95509 : WRITE_CHAR_FIELD(identity);
1219 95509 : WRITE_NODE_FIELD(identitySequence);
1220 95509 : WRITE_CHAR_FIELD(generated);
1221 95509 : WRITE_NODE_FIELD(collClause);
1222 95509 : WRITE_OID_FIELD(collOid);
1223 95509 : WRITE_NODE_FIELD(constraints);
1224 95509 : WRITE_NODE_FIELD(fdwoptions);
1225 95509 : WRITE_LOCATION_FIELD(location);
1226 95509 : }
1227 :
1228 : static void
1229 1050 : _outTableLikeClause(StringInfo str, const TableLikeClause *node)
1230 : {
1231 1050 : WRITE_NODE_TYPE("TABLELIKECLAUSE");
1232 :
1233 1050 : WRITE_NODE_FIELD(relation);
1234 1050 : WRITE_UINT_FIELD(options);
1235 1050 : WRITE_OID_FIELD(relationOid);
1236 1050 : }
1237 :
1238 : static void
1239 13219 : _outIndexElem(StringInfo str, const IndexElem *node)
1240 : {
1241 13219 : WRITE_NODE_TYPE("INDEXELEM");
1242 :
1243 13219 : WRITE_STRING_FIELD(name);
1244 13219 : WRITE_NODE_FIELD(expr);
1245 13219 : WRITE_STRING_FIELD(indexcolname);
1246 13219 : WRITE_NODE_FIELD(collation);
1247 13219 : WRITE_NODE_FIELD(opclass);
1248 13219 : WRITE_NODE_FIELD(opclassopts);
1249 13219 : WRITE_ENUM_FIELD(ordering, SortByDir);
1250 13219 : WRITE_ENUM_FIELD(nulls_ordering, SortByNulls);
1251 13219 : WRITE_LOCATION_FIELD(location);
1252 13219 : }
1253 :
1254 : static void
1255 431891 : _outDefElem(StringInfo str, const DefElem *node)
1256 : {
1257 431891 : WRITE_NODE_TYPE("DEFELEM");
1258 :
1259 431891 : WRITE_STRING_FIELD(defnamespace);
1260 431891 : WRITE_STRING_FIELD(defname);
1261 431891 : WRITE_NODE_FIELD(arg);
1262 431891 : WRITE_ENUM_FIELD(defaction, DefElemAction);
1263 431891 : WRITE_LOCATION_FIELD(location);
1264 431891 : }
1265 :
1266 : static void
1267 4032 : _outLockingClause(StringInfo str, const LockingClause *node)
1268 : {
1269 4032 : WRITE_NODE_TYPE("LOCKINGCLAUSE");
1270 :
1271 4032 : WRITE_NODE_FIELD(lockedRels);
1272 4032 : WRITE_ENUM_FIELD(strength, LockClauseStrength);
1273 4032 : WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
1274 4032 : }
1275 :
1276 : static void
1277 164 : _outXmlSerialize(StringInfo str, const XmlSerialize *node)
1278 : {
1279 164 : WRITE_NODE_TYPE("XMLSERIALIZE");
1280 :
1281 164 : WRITE_ENUM_FIELD(xmloption, XmlOptionType);
1282 164 : WRITE_NODE_FIELD(expr);
1283 164 : WRITE_NODE_FIELD(typeName);
1284 164 : WRITE_BOOL_FIELD(indent);
1285 164 : WRITE_LOCATION_FIELD(location);
1286 164 : }
1287 :
1288 : static void
1289 7918 : _outPartitionElem(StringInfo str, const PartitionElem *node)
1290 : {
1291 7918 : WRITE_NODE_TYPE("PARTITIONELEM");
1292 :
1293 7918 : WRITE_STRING_FIELD(name);
1294 7918 : WRITE_NODE_FIELD(expr);
1295 7918 : WRITE_NODE_FIELD(collation);
1296 7918 : WRITE_NODE_FIELD(opclass);
1297 7918 : WRITE_LOCATION_FIELD(location);
1298 7918 : }
1299 :
1300 : static void
1301 7274 : _outPartitionSpec(StringInfo str, const PartitionSpec *node)
1302 : {
1303 7274 : WRITE_NODE_TYPE("PARTITIONSPEC");
1304 :
1305 7274 : WRITE_ENUM_FIELD(strategy, PartitionStrategy);
1306 7274 : WRITE_NODE_FIELD(partParams);
1307 7274 : WRITE_LOCATION_FIELD(location);
1308 7274 : }
1309 :
1310 : static void
1311 25318 : _outPartitionBoundSpec(StringInfo str, const PartitionBoundSpec *node)
1312 : {
1313 25318 : WRITE_NODE_TYPE("PARTITIONBOUNDSPEC");
1314 :
1315 25318 : WRITE_CHAR_FIELD(strategy);
1316 25318 : WRITE_BOOL_FIELD(is_default);
1317 25318 : WRITE_INT_FIELD(modulus);
1318 25318 : WRITE_INT_FIELD(remainder);
1319 25318 : WRITE_NODE_FIELD(listdatums);
1320 25318 : WRITE_NODE_FIELD(lowerdatums);
1321 25318 : WRITE_NODE_FIELD(upperdatums);
1322 25318 : WRITE_LOCATION_FIELD(location);
1323 25318 : }
1324 :
1325 : static void
1326 9638 : _outPartitionRangeDatum(StringInfo str, const PartitionRangeDatum *node)
1327 : {
1328 9638 : WRITE_NODE_TYPE("PARTITIONRANGEDATUM");
1329 :
1330 9638 : WRITE_ENUM_FIELD(kind, PartitionRangeDatumKind);
1331 9638 : WRITE_NODE_FIELD(value);
1332 9638 : WRITE_LOCATION_FIELD(location);
1333 9638 : }
1334 :
1335 : static void
1336 1524 : _outSinglePartitionSpec(StringInfo str, const SinglePartitionSpec *node)
1337 : {
1338 1524 : WRITE_NODE_TYPE("SINGLEPARTITIONSPEC");
1339 :
1340 1524 : WRITE_NODE_FIELD(name);
1341 1524 : WRITE_NODE_FIELD(bound);
1342 1524 : }
1343 :
1344 : static void
1345 5532 : _outPartitionCmd(StringInfo str, const PartitionCmd *node)
1346 : {
1347 5532 : WRITE_NODE_TYPE("PARTITIONCMD");
1348 :
1349 5532 : WRITE_NODE_FIELD(name);
1350 5532 : WRITE_NODE_FIELD(bound);
1351 5532 : WRITE_NODE_FIELD(partlist);
1352 5532 : WRITE_BOOL_FIELD(concurrent);
1353 5532 : }
1354 :
1355 : static void
1356 484 : _outGraphPattern(StringInfo str, const GraphPattern *node)
1357 : {
1358 484 : WRITE_NODE_TYPE("GRAPHPATTERN");
1359 :
1360 484 : WRITE_NODE_FIELD(path_pattern_list);
1361 484 : WRITE_NODE_FIELD(whereClause);
1362 484 : }
1363 :
1364 : static void
1365 1438 : _outGraphElementPattern(StringInfo str, const GraphElementPattern *node)
1366 : {
1367 1438 : WRITE_NODE_TYPE("GRAPHELEMENTPATTERN");
1368 :
1369 1438 : WRITE_ENUM_FIELD(kind, GraphElementPatternKind);
1370 1438 : WRITE_STRING_FIELD(variable);
1371 1438 : WRITE_NODE_FIELD(labelexpr);
1372 1438 : WRITE_NODE_FIELD(subexpr);
1373 1438 : WRITE_NODE_FIELD(whereClause);
1374 1438 : WRITE_NODE_FIELD(quantifier);
1375 1438 : WRITE_LOCATION_FIELD(location);
1376 1438 : }
1377 :
1378 : static void
1379 692389 : _outRTEPermissionInfo(StringInfo str, const RTEPermissionInfo *node)
1380 : {
1381 692389 : WRITE_NODE_TYPE("RTEPERMISSIONINFO");
1382 :
1383 692389 : WRITE_OID_FIELD(relid);
1384 692389 : WRITE_BOOL_FIELD(inh);
1385 692389 : WRITE_UINT64_FIELD(requiredPerms);
1386 692389 : WRITE_OID_FIELD(checkAsUser);
1387 692389 : WRITE_BITMAPSET_FIELD(selectedCols);
1388 692389 : WRITE_BITMAPSET_FIELD(insertedCols);
1389 692389 : WRITE_BITMAPSET_FIELD(updatedCols);
1390 692389 : }
1391 :
1392 : static void
1393 66710 : _outRangeTblFunction(StringInfo str, const RangeTblFunction *node)
1394 : {
1395 66710 : WRITE_NODE_TYPE("RANGETBLFUNCTION");
1396 :
1397 66710 : WRITE_NODE_FIELD(funcexpr);
1398 66710 : WRITE_INT_FIELD(funccolcount);
1399 66710 : WRITE_NODE_FIELD(funccolnames);
1400 66710 : WRITE_NODE_FIELD(funccoltypes);
1401 66710 : WRITE_NODE_FIELD(funccoltypmods);
1402 66710 : WRITE_NODE_FIELD(funccolcollations);
1403 66710 : WRITE_BITMAPSET_FIELD(funcparams);
1404 66710 : }
1405 :
1406 : static void
1407 355 : _outTableSampleClause(StringInfo str, const TableSampleClause *node)
1408 : {
1409 355 : WRITE_NODE_TYPE("TABLESAMPLECLAUSE");
1410 :
1411 355 : WRITE_OID_FIELD(tsmhandler);
1412 355 : WRITE_NODE_FIELD(args);
1413 355 : WRITE_NODE_FIELD(repeatable);
1414 355 : }
1415 :
1416 : static void
1417 4045 : _outWithCheckOption(StringInfo str, const WithCheckOption *node)
1418 : {
1419 4045 : WRITE_NODE_TYPE("WITHCHECKOPTION");
1420 :
1421 4045 : WRITE_ENUM_FIELD(kind, WCOKind);
1422 4045 : WRITE_STRING_FIELD(relname);
1423 4045 : WRITE_STRING_FIELD(polname);
1424 4045 : WRITE_NODE_FIELD(qual);
1425 4045 : WRITE_BOOL_FIELD(cascaded);
1426 4045 : }
1427 :
1428 : static void
1429 113422 : _outSortGroupClause(StringInfo str, const SortGroupClause *node)
1430 : {
1431 113422 : WRITE_NODE_TYPE("SORTGROUPCLAUSE");
1432 :
1433 113422 : WRITE_UINT_FIELD(tleSortGroupRef);
1434 113422 : WRITE_OID_FIELD(eqop);
1435 113422 : WRITE_OID_FIELD(sortop);
1436 113422 : WRITE_BOOL_FIELD(reverse_sort);
1437 113422 : WRITE_BOOL_FIELD(nulls_first);
1438 113422 : WRITE_BOOL_FIELD(hashable);
1439 113422 : }
1440 :
1441 : static void
1442 3498 : _outGroupingSet(StringInfo str, const GroupingSet *node)
1443 : {
1444 3498 : WRITE_NODE_TYPE("GROUPINGSET");
1445 :
1446 3498 : WRITE_ENUM_FIELD(kind, GroupingSetKind);
1447 3498 : WRITE_NODE_FIELD(content);
1448 3498 : WRITE_LOCATION_FIELD(location);
1449 3498 : }
1450 :
1451 : static void
1452 2091 : _outWindowClause(StringInfo str, const WindowClause *node)
1453 : {
1454 2091 : WRITE_NODE_TYPE("WINDOWCLAUSE");
1455 :
1456 2091 : WRITE_STRING_FIELD(name);
1457 2091 : WRITE_STRING_FIELD(refname);
1458 2091 : WRITE_NODE_FIELD(partitionClause);
1459 2091 : WRITE_NODE_FIELD(orderClause);
1460 2091 : WRITE_INT_FIELD(frameOptions);
1461 2091 : WRITE_NODE_FIELD(startOffset);
1462 2091 : WRITE_NODE_FIELD(endOffset);
1463 2091 : WRITE_OID_FIELD(startInRangeFunc);
1464 2091 : WRITE_OID_FIELD(endInRangeFunc);
1465 2091 : WRITE_OID_FIELD(inRangeColl);
1466 2091 : WRITE_BOOL_FIELD(inRangeAsc);
1467 2091 : WRITE_BOOL_FIELD(inRangeNullsFirst);
1468 2091 : WRITE_UINT_FIELD(winref);
1469 2091 : WRITE_BOOL_FIELD(copiedOrder);
1470 2091 : }
1471 :
1472 : static void
1473 5104 : _outRowMarkClause(StringInfo str, const RowMarkClause *node)
1474 : {
1475 5104 : WRITE_NODE_TYPE("ROWMARKCLAUSE");
1476 :
1477 5104 : WRITE_UINT_FIELD(rti);
1478 5104 : WRITE_ENUM_FIELD(strength, LockClauseStrength);
1479 5104 : WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
1480 5104 : WRITE_BOOL_FIELD(pushedDown);
1481 5104 : }
1482 :
1483 : static void
1484 1001 : _outForPortionOfClause(StringInfo str, const ForPortionOfClause *node)
1485 : {
1486 1001 : WRITE_NODE_TYPE("FORPORTIONOFCLAUSE");
1487 :
1488 1001 : WRITE_STRING_FIELD(range_name);
1489 1001 : WRITE_LOCATION_FIELD(location);
1490 1001 : WRITE_LOCATION_FIELD(target_location);
1491 1001 : WRITE_NODE_FIELD(target);
1492 1001 : WRITE_NODE_FIELD(target_start);
1493 1001 : WRITE_NODE_FIELD(target_end);
1494 1001 : }
1495 :
1496 : static void
1497 2265 : _outWithClause(StringInfo str, const WithClause *node)
1498 : {
1499 2265 : WRITE_NODE_TYPE("WITHCLAUSE");
1500 :
1501 2265 : WRITE_NODE_FIELD(ctes);
1502 2265 : WRITE_BOOL_FIELD(recursive);
1503 2265 : WRITE_LOCATION_FIELD(location);
1504 2265 : }
1505 :
1506 : static void
1507 1420 : _outInferClause(StringInfo str, const InferClause *node)
1508 : {
1509 1420 : WRITE_NODE_TYPE("INFERCLAUSE");
1510 :
1511 1420 : WRITE_NODE_FIELD(indexElems);
1512 1420 : WRITE_NODE_FIELD(whereClause);
1513 1420 : WRITE_STRING_FIELD(conname);
1514 1420 : WRITE_LOCATION_FIELD(location);
1515 1420 : }
1516 :
1517 : static void
1518 1576 : _outOnConflictClause(StringInfo str, const OnConflictClause *node)
1519 : {
1520 1576 : WRITE_NODE_TYPE("ONCONFLICTCLAUSE");
1521 :
1522 1576 : WRITE_ENUM_FIELD(action, OnConflictAction);
1523 1576 : WRITE_NODE_FIELD(infer);
1524 1576 : WRITE_ENUM_FIELD(lockStrength, LockClauseStrength);
1525 1576 : WRITE_NODE_FIELD(targetList);
1526 1576 : WRITE_NODE_FIELD(whereClause);
1527 1576 : WRITE_LOCATION_FIELD(location);
1528 1576 : }
1529 :
1530 : static void
1531 144 : _outCTESearchClause(StringInfo str, const CTESearchClause *node)
1532 : {
1533 144 : WRITE_NODE_TYPE("CTESEARCHCLAUSE");
1534 :
1535 144 : WRITE_NODE_FIELD(search_col_list);
1536 144 : WRITE_BOOL_FIELD(search_breadth_first);
1537 144 : WRITE_STRING_FIELD(search_seq_column);
1538 144 : WRITE_LOCATION_FIELD(location);
1539 144 : }
1540 :
1541 : static void
1542 148 : _outCTECycleClause(StringInfo str, const CTECycleClause *node)
1543 : {
1544 148 : WRITE_NODE_TYPE("CTECYCLECLAUSE");
1545 :
1546 148 : WRITE_NODE_FIELD(cycle_col_list);
1547 148 : WRITE_STRING_FIELD(cycle_mark_column);
1548 148 : WRITE_NODE_FIELD(cycle_mark_value);
1549 148 : WRITE_NODE_FIELD(cycle_mark_default);
1550 148 : WRITE_STRING_FIELD(cycle_path_column);
1551 148 : WRITE_LOCATION_FIELD(location);
1552 148 : WRITE_OID_FIELD(cycle_mark_type);
1553 148 : WRITE_INT_FIELD(cycle_mark_typmod);
1554 148 : WRITE_OID_FIELD(cycle_mark_collation);
1555 148 : WRITE_OID_FIELD(cycle_mark_neop);
1556 148 : }
1557 :
1558 : static void
1559 5759 : _outCommonTableExpr(StringInfo str, const CommonTableExpr *node)
1560 : {
1561 5759 : WRITE_NODE_TYPE("COMMONTABLEEXPR");
1562 :
1563 5759 : WRITE_STRING_FIELD(ctename);
1564 5759 : WRITE_NODE_FIELD(aliascolnames);
1565 5759 : WRITE_ENUM_FIELD(ctematerialized, CTEMaterialize);
1566 5759 : WRITE_NODE_FIELD(ctequery);
1567 5759 : WRITE_NODE_FIELD(search_clause);
1568 5759 : WRITE_NODE_FIELD(cycle_clause);
1569 5759 : WRITE_LOCATION_FIELD(location);
1570 5759 : WRITE_BOOL_FIELD(cterecursive);
1571 5759 : WRITE_INT_FIELD(cterefcount);
1572 5759 : WRITE_NODE_FIELD(ctecolnames);
1573 5759 : WRITE_NODE_FIELD(ctecoltypes);
1574 5759 : WRITE_NODE_FIELD(ctecoltypmods);
1575 5759 : WRITE_NODE_FIELD(ctecolcollations);
1576 5759 : }
1577 :
1578 : static void
1579 2043 : _outMergeWhenClause(StringInfo str, const MergeWhenClause *node)
1580 : {
1581 2043 : WRITE_NODE_TYPE("MERGEWHENCLAUSE");
1582 :
1583 2043 : WRITE_ENUM_FIELD(matchKind, MergeMatchKind);
1584 2043 : WRITE_ENUM_FIELD(commandType, CmdType);
1585 2043 : WRITE_ENUM_FIELD(override, OverridingKind);
1586 2043 : WRITE_NODE_FIELD(condition);
1587 2043 : WRITE_NODE_FIELD(targetList);
1588 2043 : WRITE_NODE_FIELD(values);
1589 2043 : }
1590 :
1591 : static void
1592 100 : _outReturningOption(StringInfo str, const ReturningOption *node)
1593 : {
1594 100 : WRITE_NODE_TYPE("RETURNINGOPTION");
1595 :
1596 100 : WRITE_ENUM_FIELD(option, ReturningOptionKind);
1597 100 : WRITE_STRING_FIELD(value);
1598 100 : WRITE_LOCATION_FIELD(location);
1599 100 : }
1600 :
1601 : static void
1602 2476 : _outReturningClause(StringInfo str, const ReturningClause *node)
1603 : {
1604 2476 : WRITE_NODE_TYPE("RETURNINGCLAUSE");
1605 :
1606 2476 : WRITE_NODE_FIELD(options);
1607 2476 : WRITE_NODE_FIELD(exprs);
1608 2476 : }
1609 :
1610 : static void
1611 856 : _outTriggerTransition(StringInfo str, const TriggerTransition *node)
1612 : {
1613 856 : WRITE_NODE_TYPE("TRIGGERTRANSITION");
1614 :
1615 856 : WRITE_STRING_FIELD(name);
1616 856 : WRITE_BOOL_FIELD(isNew);
1617 856 : WRITE_BOOL_FIELD(isTable);
1618 856 : }
1619 :
1620 : static void
1621 1462 : _outJsonOutput(StringInfo str, const JsonOutput *node)
1622 : {
1623 1462 : WRITE_NODE_TYPE("JSONOUTPUT");
1624 :
1625 1462 : WRITE_NODE_FIELD(typeName);
1626 1462 : WRITE_NODE_FIELD(returning);
1627 1462 : }
1628 :
1629 : static void
1630 420 : _outJsonArgument(StringInfo str, const JsonArgument *node)
1631 : {
1632 420 : WRITE_NODE_TYPE("JSONARGUMENT");
1633 :
1634 420 : WRITE_NODE_FIELD(val);
1635 420 : WRITE_STRING_FIELD(name);
1636 420 : }
1637 :
1638 : static void
1639 1432 : _outJsonFuncExpr(StringInfo str, const JsonFuncExpr *node)
1640 : {
1641 1432 : WRITE_NODE_TYPE("JSONFUNCEXPR");
1642 :
1643 1432 : WRITE_ENUM_FIELD(op, JsonExprOp);
1644 1432 : WRITE_STRING_FIELD(column_name);
1645 1432 : WRITE_NODE_FIELD(context_item);
1646 1432 : WRITE_NODE_FIELD(pathspec);
1647 1432 : WRITE_NODE_FIELD(passing);
1648 1432 : WRITE_NODE_FIELD(output);
1649 1432 : WRITE_NODE_FIELD(on_empty);
1650 1432 : WRITE_NODE_FIELD(on_error);
1651 1432 : WRITE_ENUM_FIELD(wrapper, JsonWrapper);
1652 1432 : WRITE_ENUM_FIELD(quotes, JsonQuotes);
1653 1432 : WRITE_LOCATION_FIELD(location);
1654 1432 : }
1655 :
1656 : static void
1657 1320 : _outJsonTablePathSpec(StringInfo str, const JsonTablePathSpec *node)
1658 : {
1659 1320 : WRITE_NODE_TYPE("JSONTABLEPATHSPEC");
1660 :
1661 1320 : WRITE_NODE_FIELD(string);
1662 1320 : WRITE_STRING_FIELD(name);
1663 1320 : WRITE_LOCATION_FIELD(name_location);
1664 1320 : WRITE_LOCATION_FIELD(location);
1665 1320 : }
1666 :
1667 : static void
1668 400 : _outJsonTable(StringInfo str, const JsonTable *node)
1669 : {
1670 400 : WRITE_NODE_TYPE("JSONTABLE");
1671 :
1672 400 : WRITE_NODE_FIELD(context_item);
1673 400 : WRITE_NODE_FIELD(pathspec);
1674 400 : WRITE_NODE_FIELD(passing);
1675 400 : WRITE_NODE_FIELD(columns);
1676 400 : WRITE_NODE_FIELD(on_error);
1677 400 : WRITE_NODE_FIELD(alias);
1678 400 : WRITE_BOOL_FIELD(lateral);
1679 400 : WRITE_LOCATION_FIELD(location);
1680 400 : }
1681 :
1682 : static void
1683 1104 : _outJsonTableColumn(StringInfo str, const JsonTableColumn *node)
1684 : {
1685 1104 : WRITE_NODE_TYPE("JSONTABLECOLUMN");
1686 :
1687 1104 : WRITE_ENUM_FIELD(coltype, JsonTableColumnType);
1688 1104 : WRITE_STRING_FIELD(name);
1689 1104 : WRITE_NODE_FIELD(typeName);
1690 1104 : WRITE_NODE_FIELD(pathspec);
1691 1104 : WRITE_NODE_FIELD(format);
1692 1104 : WRITE_ENUM_FIELD(wrapper, JsonWrapper);
1693 1104 : WRITE_ENUM_FIELD(quotes, JsonQuotes);
1694 1104 : WRITE_NODE_FIELD(columns);
1695 1104 : WRITE_NODE_FIELD(on_empty);
1696 1104 : WRITE_NODE_FIELD(on_error);
1697 1104 : WRITE_LOCATION_FIELD(location);
1698 1104 : }
1699 :
1700 : static void
1701 738 : _outJsonKeyValue(StringInfo str, const JsonKeyValue *node)
1702 : {
1703 738 : WRITE_NODE_TYPE("JSONKEYVALUE");
1704 :
1705 738 : WRITE_NODE_FIELD(key);
1706 738 : WRITE_NODE_FIELD(value);
1707 738 : }
1708 :
1709 : static void
1710 104 : _outJsonParseExpr(StringInfo str, const JsonParseExpr *node)
1711 : {
1712 104 : WRITE_NODE_TYPE("JSONPARSEEXPR");
1713 :
1714 104 : WRITE_NODE_FIELD(expr);
1715 104 : WRITE_NODE_FIELD(output);
1716 104 : WRITE_BOOL_FIELD(unique_keys);
1717 104 : WRITE_LOCATION_FIELD(location);
1718 104 : }
1719 :
1720 : static void
1721 70 : _outJsonScalarExpr(StringInfo str, const JsonScalarExpr *node)
1722 : {
1723 70 : WRITE_NODE_TYPE("JSONSCALAREXPR");
1724 :
1725 70 : WRITE_NODE_FIELD(expr);
1726 70 : WRITE_NODE_FIELD(output);
1727 70 : WRITE_LOCATION_FIELD(location);
1728 70 : }
1729 :
1730 : static void
1731 68 : _outJsonSerializeExpr(StringInfo str, const JsonSerializeExpr *node)
1732 : {
1733 68 : WRITE_NODE_TYPE("JSONSERIALIZEEXPR");
1734 :
1735 68 : WRITE_NODE_FIELD(expr);
1736 68 : WRITE_NODE_FIELD(output);
1737 68 : WRITE_LOCATION_FIELD(location);
1738 68 : }
1739 :
1740 : static void
1741 470 : _outJsonObjectConstructor(StringInfo str, const JsonObjectConstructor *node)
1742 : {
1743 470 : WRITE_NODE_TYPE("JSONOBJECTCONSTRUCTOR");
1744 :
1745 470 : WRITE_NODE_FIELD(exprs);
1746 470 : WRITE_NODE_FIELD(output);
1747 470 : WRITE_BOOL_FIELD(absent_on_null);
1748 470 : WRITE_BOOL_FIELD(unique);
1749 470 : WRITE_LOCATION_FIELD(location);
1750 470 : }
1751 :
1752 : static void
1753 316 : _outJsonArrayConstructor(StringInfo str, const JsonArrayConstructor *node)
1754 : {
1755 316 : WRITE_NODE_TYPE("JSONARRAYCONSTRUCTOR");
1756 :
1757 316 : WRITE_NODE_FIELD(exprs);
1758 316 : WRITE_NODE_FIELD(output);
1759 316 : WRITE_BOOL_FIELD(absent_on_null);
1760 316 : WRITE_LOCATION_FIELD(location);
1761 316 : }
1762 :
1763 : static void
1764 108 : _outJsonArrayQueryConstructor(StringInfo str, const JsonArrayQueryConstructor *node)
1765 : {
1766 108 : WRITE_NODE_TYPE("JSONARRAYQUERYCONSTRUCTOR");
1767 :
1768 108 : WRITE_NODE_FIELD(query);
1769 108 : WRITE_NODE_FIELD(output);
1770 108 : WRITE_NODE_FIELD(format);
1771 108 : WRITE_BOOL_FIELD(absent_on_null);
1772 108 : WRITE_LOCATION_FIELD(location);
1773 108 : }
1774 :
1775 : static void
1776 280 : _outJsonAggConstructor(StringInfo str, const JsonAggConstructor *node)
1777 : {
1778 280 : WRITE_NODE_TYPE("JSONAGGCONSTRUCTOR");
1779 :
1780 280 : WRITE_NODE_FIELD(output);
1781 280 : WRITE_NODE_FIELD(agg_filter);
1782 280 : WRITE_NODE_FIELD(agg_order);
1783 280 : WRITE_NODE_FIELD(over);
1784 280 : WRITE_LOCATION_FIELD(location);
1785 280 : }
1786 :
1787 : static void
1788 156 : _outJsonObjectAgg(StringInfo str, const JsonObjectAgg *node)
1789 : {
1790 156 : WRITE_NODE_TYPE("JSONOBJECTAGG");
1791 :
1792 156 : WRITE_NODE_FIELD(constructor);
1793 156 : WRITE_NODE_FIELD(arg);
1794 156 : WRITE_BOOL_FIELD(absent_on_null);
1795 156 : WRITE_BOOL_FIELD(unique);
1796 156 : }
1797 :
1798 : static void
1799 124 : _outJsonArrayAgg(StringInfo str, const JsonArrayAgg *node)
1800 : {
1801 124 : WRITE_NODE_TYPE("JSONARRAYAGG");
1802 :
1803 124 : WRITE_NODE_FIELD(constructor);
1804 124 : WRITE_NODE_FIELD(arg);
1805 124 : WRITE_BOOL_FIELD(absent_on_null);
1806 124 : }
1807 :
1808 : static void
1809 472553 : _outRawStmt(StringInfo str, const RawStmt *node)
1810 : {
1811 472553 : WRITE_NODE_TYPE("RAWSTMT");
1812 :
1813 472553 : WRITE_NODE_FIELD(stmt);
1814 472553 : WRITE_LOCATION_FIELD(stmt_location);
1815 472553 : WRITE_LOCATION_FIELD(stmt_len);
1816 472553 : }
1817 :
1818 : static void
1819 44971 : _outInsertStmt(StringInfo str, const InsertStmt *node)
1820 : {
1821 44971 : WRITE_NODE_TYPE("INSERTSTMT");
1822 :
1823 44971 : WRITE_NODE_FIELD(relation);
1824 44971 : WRITE_NODE_FIELD(cols);
1825 44971 : WRITE_NODE_FIELD(selectStmt);
1826 44971 : WRITE_NODE_FIELD(onConflictClause);
1827 44971 : WRITE_NODE_FIELD(returningClause);
1828 44971 : WRITE_NODE_FIELD(withClause);
1829 44971 : WRITE_ENUM_FIELD(override, OverridingKind);
1830 44971 : }
1831 :
1832 : static void
1833 3339 : _outDeleteStmt(StringInfo str, const DeleteStmt *node)
1834 : {
1835 3339 : WRITE_NODE_TYPE("DELETESTMT");
1836 :
1837 3339 : WRITE_NODE_FIELD(relation);
1838 3339 : WRITE_NODE_FIELD(usingClause);
1839 3339 : WRITE_NODE_FIELD(whereClause);
1840 3339 : WRITE_NODE_FIELD(returningClause);
1841 3339 : WRITE_NODE_FIELD(withClause);
1842 3339 : WRITE_NODE_FIELD(forPortionOf);
1843 3339 : }
1844 :
1845 : static void
1846 9125 : _outUpdateStmt(StringInfo str, const UpdateStmt *node)
1847 : {
1848 9125 : WRITE_NODE_TYPE("UPDATESTMT");
1849 :
1850 9125 : WRITE_NODE_FIELD(relation);
1851 9125 : WRITE_NODE_FIELD(targetList);
1852 9125 : WRITE_NODE_FIELD(whereClause);
1853 9125 : WRITE_NODE_FIELD(fromClause);
1854 9125 : WRITE_NODE_FIELD(returningClause);
1855 9125 : WRITE_NODE_FIELD(withClause);
1856 9125 : WRITE_NODE_FIELD(forPortionOf);
1857 9125 : }
1858 :
1859 : static void
1860 1342 : _outMergeStmt(StringInfo str, const MergeStmt *node)
1861 : {
1862 1342 : WRITE_NODE_TYPE("MERGESTMT");
1863 :
1864 1342 : WRITE_NODE_FIELD(relation);
1865 1342 : WRITE_NODE_FIELD(sourceRelation);
1866 1342 : WRITE_NODE_FIELD(joinCondition);
1867 1342 : WRITE_NODE_FIELD(mergeWhenClauses);
1868 1342 : WRITE_NODE_FIELD(returningClause);
1869 1342 : WRITE_NODE_FIELD(withClause);
1870 1342 : }
1871 :
1872 : static void
1873 346663 : _outSelectStmt(StringInfo str, const SelectStmt *node)
1874 : {
1875 346663 : WRITE_NODE_TYPE("SELECTSTMT");
1876 :
1877 346663 : WRITE_NODE_FIELD(distinctClause);
1878 346663 : WRITE_NODE_FIELD(intoClause);
1879 346663 : WRITE_NODE_FIELD(targetList);
1880 346663 : WRITE_NODE_FIELD(fromClause);
1881 346663 : WRITE_NODE_FIELD(whereClause);
1882 346663 : WRITE_NODE_FIELD(groupClause);
1883 346663 : WRITE_BOOL_FIELD(groupDistinct);
1884 346663 : WRITE_BOOL_FIELD(groupByAll);
1885 346663 : WRITE_NODE_FIELD(havingClause);
1886 346663 : WRITE_NODE_FIELD(windowClause);
1887 346663 : WRITE_NODE_FIELD(valuesLists);
1888 346663 : WRITE_NODE_FIELD(sortClause);
1889 346663 : WRITE_NODE_FIELD(limitOffset);
1890 346663 : WRITE_NODE_FIELD(limitCount);
1891 346663 : WRITE_ENUM_FIELD(limitOption, LimitOption);
1892 346663 : WRITE_NODE_FIELD(lockingClause);
1893 346663 : WRITE_NODE_FIELD(withClause);
1894 346663 : WRITE_ENUM_FIELD(op, SetOperation);
1895 346663 : WRITE_BOOL_FIELD(all);
1896 346663 : WRITE_NODE_FIELD(larg);
1897 346663 : WRITE_NODE_FIELD(rarg);
1898 346663 : }
1899 :
1900 : static void
1901 16799 : _outSetOperationStmt(StringInfo str, const SetOperationStmt *node)
1902 : {
1903 16799 : WRITE_NODE_TYPE("SETOPERATIONSTMT");
1904 :
1905 16799 : WRITE_ENUM_FIELD(op, SetOperation);
1906 16799 : WRITE_BOOL_FIELD(all);
1907 16799 : WRITE_NODE_FIELD(larg);
1908 16799 : WRITE_NODE_FIELD(rarg);
1909 16799 : WRITE_NODE_FIELD(colTypes);
1910 16799 : WRITE_NODE_FIELD(colTypmods);
1911 16799 : WRITE_NODE_FIELD(colCollations);
1912 16799 : WRITE_NODE_FIELD(groupClauses);
1913 16799 : }
1914 :
1915 : static void
1916 5492 : _outReturnStmt(StringInfo str, const ReturnStmt *node)
1917 : {
1918 5492 : WRITE_NODE_TYPE("RETURNSTMT");
1919 :
1920 5492 : WRITE_NODE_FIELD(returnval);
1921 5492 : }
1922 :
1923 : static void
1924 0 : _outPLAssignStmt(StringInfo str, const PLAssignStmt *node)
1925 : {
1926 0 : WRITE_NODE_TYPE("PLASSIGNSTMT");
1927 :
1928 0 : WRITE_STRING_FIELD(name);
1929 0 : WRITE_NODE_FIELD(indirection);
1930 0 : WRITE_INT_FIELD(nnames);
1931 0 : WRITE_NODE_FIELD(val);
1932 0 : WRITE_LOCATION_FIELD(location);
1933 0 : }
1934 :
1935 : static void
1936 1477 : _outCreateSchemaStmt(StringInfo str, const CreateSchemaStmt *node)
1937 : {
1938 1477 : WRITE_NODE_TYPE("CREATESCHEMASTMT");
1939 :
1940 1477 : WRITE_STRING_FIELD(schemaname);
1941 1477 : WRITE_NODE_FIELD(authrole);
1942 1477 : WRITE_NODE_FIELD(schemaElts);
1943 1477 : WRITE_BOOL_FIELD(if_not_exists);
1944 1477 : }
1945 :
1946 : static void
1947 41110 : _outAlterTableStmt(StringInfo str, const AlterTableStmt *node)
1948 : {
1949 41110 : WRITE_NODE_TYPE("ALTERTABLESTMT");
1950 :
1951 41110 : WRITE_NODE_FIELD(relation);
1952 41110 : WRITE_NODE_FIELD(cmds);
1953 41110 : WRITE_ENUM_FIELD(objtype, ObjectType);
1954 41110 : WRITE_BOOL_FIELD(missing_ok);
1955 41110 : }
1956 :
1957 : static void
1958 42520 : _outAlterTableCmd(StringInfo str, const AlterTableCmd *node)
1959 : {
1960 42520 : WRITE_NODE_TYPE("ALTERTABLECMD");
1961 :
1962 42520 : WRITE_ENUM_FIELD(subtype, AlterTableType);
1963 42520 : WRITE_STRING_FIELD(name);
1964 42520 : WRITE_INT_FIELD(num);
1965 42520 : WRITE_NODE_FIELD(newowner);
1966 42520 : WRITE_NODE_FIELD(def);
1967 42520 : WRITE_ENUM_FIELD(behavior, DropBehavior);
1968 42520 : WRITE_BOOL_FIELD(missing_ok);
1969 42520 : WRITE_BOOL_FIELD(recurse);
1970 42520 : }
1971 :
1972 : static void
1973 600 : _outATAlterConstraint(StringInfo str, const ATAlterConstraint *node)
1974 : {
1975 600 : WRITE_NODE_TYPE("ATALTERCONSTRAINT");
1976 :
1977 600 : WRITE_STRING_FIELD(conname);
1978 600 : WRITE_BOOL_FIELD(alterEnforceability);
1979 600 : WRITE_BOOL_FIELD(is_enforced);
1980 600 : WRITE_BOOL_FIELD(alterDeferrability);
1981 600 : WRITE_BOOL_FIELD(deferrable);
1982 600 : WRITE_BOOL_FIELD(initdeferred);
1983 600 : WRITE_BOOL_FIELD(alterInheritability);
1984 600 : WRITE_BOOL_FIELD(noinherit);
1985 600 : }
1986 :
1987 : static void
1988 624 : _outReplicaIdentityStmt(StringInfo str, const ReplicaIdentityStmt *node)
1989 : {
1990 624 : WRITE_NODE_TYPE("REPLICAIDENTITYSTMT");
1991 :
1992 624 : WRITE_CHAR_FIELD(identity_type);
1993 624 : WRITE_STRING_FIELD(name);
1994 624 : }
1995 :
1996 : static void
1997 8 : _outAlterCollationStmt(StringInfo str, const AlterCollationStmt *node)
1998 : {
1999 8 : WRITE_NODE_TYPE("ALTERCOLLATIONSTMT");
2000 :
2001 8 : WRITE_NODE_FIELD(collname);
2002 8 : }
2003 :
2004 : static void
2005 384 : _outAlterDomainStmt(StringInfo str, const AlterDomainStmt *node)
2006 : {
2007 384 : WRITE_NODE_TYPE("ALTERDOMAINSTMT");
2008 :
2009 384 : WRITE_ENUM_FIELD(subtype, AlterDomainType);
2010 384 : WRITE_NODE_FIELD(typeName);
2011 384 : WRITE_STRING_FIELD(name);
2012 384 : WRITE_NODE_FIELD(def);
2013 384 : WRITE_ENUM_FIELD(behavior, DropBehavior);
2014 384 : WRITE_BOOL_FIELD(missing_ok);
2015 384 : }
2016 :
2017 : static void
2018 16979 : _outGrantStmt(StringInfo str, const GrantStmt *node)
2019 : {
2020 16979 : WRITE_NODE_TYPE("GRANTSTMT");
2021 :
2022 16979 : WRITE_BOOL_FIELD(is_grant);
2023 16979 : WRITE_ENUM_FIELD(targtype, GrantTargetType);
2024 16979 : WRITE_ENUM_FIELD(objtype, ObjectType);
2025 16979 : WRITE_NODE_FIELD(objects);
2026 16979 : WRITE_NODE_FIELD(privileges);
2027 16979 : WRITE_NODE_FIELD(grantees);
2028 16979 : WRITE_BOOL_FIELD(grant_option);
2029 16979 : WRITE_NODE_FIELD(grantor);
2030 16979 : WRITE_ENUM_FIELD(behavior, DropBehavior);
2031 16979 : }
2032 :
2033 : static void
2034 15940 : _outObjectWithArgs(StringInfo str, const ObjectWithArgs *node)
2035 : {
2036 15940 : WRITE_NODE_TYPE("OBJECTWITHARGS");
2037 :
2038 15940 : WRITE_NODE_FIELD(objname);
2039 15940 : WRITE_NODE_FIELD(objargs);
2040 15940 : WRITE_NODE_FIELD(objfuncargs);
2041 15940 : WRITE_BOOL_FIELD(args_unspecified);
2042 15940 : }
2043 :
2044 : static void
2045 15187 : _outAccessPriv(StringInfo str, const AccessPriv *node)
2046 : {
2047 15187 : WRITE_NODE_TYPE("ACCESSPRIV");
2048 :
2049 15187 : WRITE_STRING_FIELD(priv_name);
2050 15187 : WRITE_NODE_FIELD(cols);
2051 15187 : }
2052 :
2053 : static void
2054 836 : _outGrantRoleStmt(StringInfo str, const GrantRoleStmt *node)
2055 : {
2056 836 : WRITE_NODE_TYPE("GRANTROLESTMT");
2057 :
2058 836 : WRITE_NODE_FIELD(granted_roles);
2059 836 : WRITE_NODE_FIELD(grantee_roles);
2060 836 : WRITE_BOOL_FIELD(is_grant);
2061 836 : WRITE_NODE_FIELD(opt);
2062 836 : WRITE_NODE_FIELD(grantor);
2063 836 : WRITE_ENUM_FIELD(behavior, DropBehavior);
2064 836 : }
2065 :
2066 : static void
2067 270 : _outAlterDefaultPrivilegesStmt(StringInfo str, const AlterDefaultPrivilegesStmt *node)
2068 : {
2069 270 : WRITE_NODE_TYPE("ALTERDEFAULTPRIVILEGESSTMT");
2070 :
2071 270 : WRITE_NODE_FIELD(options);
2072 270 : WRITE_NODE_FIELD(action);
2073 270 : }
2074 :
2075 : static void
2076 13475 : _outCopyStmt(StringInfo str, const CopyStmt *node)
2077 : {
2078 13475 : WRITE_NODE_TYPE("COPYSTMT");
2079 :
2080 13475 : WRITE_NODE_FIELD(relation);
2081 13475 : WRITE_NODE_FIELD(query);
2082 13475 : WRITE_NODE_FIELD(attlist);
2083 13475 : WRITE_BOOL_FIELD(is_from);
2084 13475 : WRITE_BOOL_FIELD(is_program);
2085 13475 : WRITE_STRING_FIELD(filename);
2086 13475 : WRITE_NODE_FIELD(options);
2087 13475 : WRITE_NODE_FIELD(whereClause);
2088 13475 : }
2089 :
2090 : static void
2091 39593 : _outVariableSetStmt(StringInfo str, const VariableSetStmt *node)
2092 : {
2093 39593 : WRITE_NODE_TYPE("VARIABLESETSTMT");
2094 :
2095 39593 : WRITE_ENUM_FIELD(kind, VariableSetKind);
2096 39593 : WRITE_STRING_FIELD(name);
2097 39593 : WRITE_NODE_FIELD(args);
2098 39593 : WRITE_BOOL_FIELD(jumble_args);
2099 39593 : WRITE_BOOL_FIELD(is_local);
2100 39593 : WRITE_LOCATION_FIELD(location);
2101 39593 : }
2102 :
2103 : static void
2104 1158 : _outVariableShowStmt(StringInfo str, const VariableShowStmt *node)
2105 : {
2106 1158 : WRITE_NODE_TYPE("VARIABLESHOWSTMT");
2107 :
2108 1158 : WRITE_STRING_FIELD(name);
2109 1158 : }
2110 :
2111 : static void
2112 51892 : _outCreateStmt(StringInfo str, const CreateStmt *node)
2113 : {
2114 51892 : WRITE_NODE_TYPE("CREATESTMT");
2115 :
2116 51892 : WRITE_NODE_FIELD(relation);
2117 51892 : WRITE_NODE_FIELD(tableElts);
2118 51892 : WRITE_NODE_FIELD(inhRelations);
2119 51892 : WRITE_NODE_FIELD(partbound);
2120 51892 : WRITE_NODE_FIELD(partspec);
2121 51892 : WRITE_NODE_FIELD(ofTypename);
2122 51892 : WRITE_NODE_FIELD(constraints);
2123 51892 : WRITE_NODE_FIELD(nnconstraints);
2124 51892 : WRITE_NODE_FIELD(options);
2125 51892 : WRITE_ENUM_FIELD(oncommit, OnCommitAction);
2126 51892 : WRITE_STRING_FIELD(tablespacename);
2127 51892 : WRITE_STRING_FIELD(accessMethod);
2128 51892 : WRITE_BOOL_FIELD(if_not_exists);
2129 51892 : }
2130 :
2131 : static void
2132 48004 : _outConstraint(StringInfo str, const Constraint *node)
2133 : {
2134 48004 : WRITE_NODE_TYPE("CONSTRAINT");
2135 :
2136 48004 : WRITE_ENUM_FIELD(contype, ConstrType);
2137 48004 : WRITE_STRING_FIELD(conname);
2138 48004 : WRITE_BOOL_FIELD(deferrable);
2139 48004 : WRITE_BOOL_FIELD(initdeferred);
2140 48004 : WRITE_BOOL_FIELD(is_enforced);
2141 48004 : WRITE_BOOL_FIELD(skip_validation);
2142 48004 : WRITE_BOOL_FIELD(initially_valid);
2143 48004 : WRITE_BOOL_FIELD(is_no_inherit);
2144 48004 : WRITE_NODE_FIELD(raw_expr);
2145 48004 : WRITE_STRING_FIELD(cooked_expr);
2146 48004 : WRITE_CHAR_FIELD(generated_when);
2147 48004 : WRITE_CHAR_FIELD(generated_kind);
2148 48004 : WRITE_BOOL_FIELD(nulls_not_distinct);
2149 48004 : WRITE_NODE_FIELD(keys);
2150 48004 : WRITE_BOOL_FIELD(without_overlaps);
2151 48004 : WRITE_NODE_FIELD(including);
2152 48004 : WRITE_NODE_FIELD(exclusions);
2153 48004 : WRITE_NODE_FIELD(options);
2154 48004 : WRITE_STRING_FIELD(indexname);
2155 48004 : WRITE_STRING_FIELD(indexspace);
2156 48004 : WRITE_BOOL_FIELD(reset_default_tblspc);
2157 48004 : WRITE_STRING_FIELD(access_method);
2158 48004 : WRITE_NODE_FIELD(where_clause);
2159 48004 : WRITE_NODE_FIELD(pktable);
2160 48004 : WRITE_NODE_FIELD(fk_attrs);
2161 48004 : WRITE_NODE_FIELD(pk_attrs);
2162 48004 : WRITE_BOOL_FIELD(fk_with_period);
2163 48004 : WRITE_BOOL_FIELD(pk_with_period);
2164 48004 : WRITE_CHAR_FIELD(fk_matchtype);
2165 48004 : WRITE_CHAR_FIELD(fk_upd_action);
2166 48004 : WRITE_CHAR_FIELD(fk_del_action);
2167 48004 : WRITE_NODE_FIELD(fk_del_set_cols);
2168 48004 : WRITE_NODE_FIELD(old_conpfeqop);
2169 48004 : WRITE_OID_FIELD(old_pktable_oid);
2170 48004 : WRITE_LOCATION_FIELD(location);
2171 48004 : }
2172 :
2173 : static void
2174 154 : _outCreateTableSpaceStmt(StringInfo str, const CreateTableSpaceStmt *node)
2175 : {
2176 154 : WRITE_NODE_TYPE("CREATETABLESPACESTMT");
2177 :
2178 154 : WRITE_STRING_FIELD(tablespacename);
2179 154 : WRITE_NODE_FIELD(owner);
2180 154 : WRITE_STRING_FIELD(location);
2181 154 : WRITE_NODE_FIELD(options);
2182 154 : }
2183 :
2184 : static void
2185 70 : _outDropTableSpaceStmt(StringInfo str, const DropTableSpaceStmt *node)
2186 : {
2187 70 : WRITE_NODE_TYPE("DROPTABLESPACESTMT");
2188 :
2189 70 : WRITE_STRING_FIELD(tablespacename);
2190 70 : WRITE_BOOL_FIELD(missing_ok);
2191 70 : }
2192 :
2193 : static void
2194 34 : _outAlterTableSpaceOptionsStmt(StringInfo str, const AlterTableSpaceOptionsStmt *node)
2195 : {
2196 34 : WRITE_NODE_TYPE("ALTERTABLESPACEOPTIONSSTMT");
2197 :
2198 34 : WRITE_STRING_FIELD(tablespacename);
2199 34 : WRITE_NODE_FIELD(options);
2200 34 : WRITE_BOOL_FIELD(isReset);
2201 34 : }
2202 :
2203 : static void
2204 30 : _outAlterTableMoveAllStmt(StringInfo str, const AlterTableMoveAllStmt *node)
2205 : {
2206 30 : WRITE_NODE_TYPE("ALTERTABLEMOVEALLSTMT");
2207 :
2208 30 : WRITE_STRING_FIELD(orig_tablespacename);
2209 30 : WRITE_ENUM_FIELD(objtype, ObjectType);
2210 30 : WRITE_NODE_FIELD(roles);
2211 30 : WRITE_STRING_FIELD(new_tablespacename);
2212 30 : WRITE_BOOL_FIELD(nowait);
2213 30 : }
2214 :
2215 : static void
2216 636 : _outCreateExtensionStmt(StringInfo str, const CreateExtensionStmt *node)
2217 : {
2218 636 : WRITE_NODE_TYPE("CREATEEXTENSIONSTMT");
2219 :
2220 636 : WRITE_STRING_FIELD(extname);
2221 636 : WRITE_BOOL_FIELD(if_not_exists);
2222 636 : WRITE_NODE_FIELD(options);
2223 636 : }
2224 :
2225 : static void
2226 37 : _outAlterExtensionStmt(StringInfo str, const AlterExtensionStmt *node)
2227 : {
2228 37 : WRITE_NODE_TYPE("ALTEREXTENSIONSTMT");
2229 :
2230 37 : WRITE_STRING_FIELD(extname);
2231 37 : WRITE_NODE_FIELD(options);
2232 37 : }
2233 :
2234 : static void
2235 280 : _outAlterExtensionContentsStmt(StringInfo str, const AlterExtensionContentsStmt *node)
2236 : {
2237 280 : WRITE_NODE_TYPE("ALTEREXTENSIONCONTENTSSTMT");
2238 :
2239 280 : WRITE_STRING_FIELD(extname);
2240 280 : WRITE_INT_FIELD(action);
2241 280 : WRITE_ENUM_FIELD(objtype, ObjectType);
2242 280 : WRITE_NODE_FIELD(object);
2243 280 : }
2244 :
2245 : static void
2246 268 : _outCreateFdwStmt(StringInfo str, const CreateFdwStmt *node)
2247 : {
2248 268 : WRITE_NODE_TYPE("CREATEFDWSTMT");
2249 :
2250 268 : WRITE_STRING_FIELD(fdwname);
2251 268 : WRITE_NODE_FIELD(func_options);
2252 268 : WRITE_NODE_FIELD(options);
2253 268 : }
2254 :
2255 : static void
2256 202 : _outAlterFdwStmt(StringInfo str, const AlterFdwStmt *node)
2257 : {
2258 202 : WRITE_NODE_TYPE("ALTERFDWSTMT");
2259 :
2260 202 : WRITE_STRING_FIELD(fdwname);
2261 202 : WRITE_NODE_FIELD(func_options);
2262 202 : WRITE_NODE_FIELD(options);
2263 202 : }
2264 :
2265 : static void
2266 377 : _outCreateForeignServerStmt(StringInfo str, const CreateForeignServerStmt *node)
2267 : {
2268 377 : WRITE_NODE_TYPE("CREATEFOREIGNSERVERSTMT");
2269 :
2270 377 : WRITE_STRING_FIELD(servername);
2271 377 : WRITE_STRING_FIELD(servertype);
2272 377 : WRITE_STRING_FIELD(version);
2273 377 : WRITE_STRING_FIELD(fdwname);
2274 377 : WRITE_BOOL_FIELD(if_not_exists);
2275 377 : WRITE_NODE_FIELD(options);
2276 377 : }
2277 :
2278 : static void
2279 258 : _outAlterForeignServerStmt(StringInfo str, const AlterForeignServerStmt *node)
2280 : {
2281 258 : WRITE_NODE_TYPE("ALTERFOREIGNSERVERSTMT");
2282 :
2283 258 : WRITE_STRING_FIELD(servername);
2284 258 : WRITE_STRING_FIELD(version);
2285 258 : WRITE_NODE_FIELD(options);
2286 258 : WRITE_BOOL_FIELD(has_version);
2287 258 : }
2288 :
2289 : static void
2290 568 : _outCreateForeignTableStmt(StringInfo str, const CreateForeignTableStmt *node)
2291 : {
2292 568 : WRITE_NODE_TYPE("CREATEFOREIGNTABLESTMT");
2293 :
2294 568 : WRITE_NODE_FIELD(base.relation);
2295 568 : WRITE_NODE_FIELD(base.tableElts);
2296 568 : WRITE_NODE_FIELD(base.inhRelations);
2297 568 : WRITE_NODE_FIELD(base.partbound);
2298 568 : WRITE_NODE_FIELD(base.partspec);
2299 568 : WRITE_NODE_FIELD(base.ofTypename);
2300 568 : WRITE_NODE_FIELD(base.constraints);
2301 568 : WRITE_NODE_FIELD(base.nnconstraints);
2302 568 : WRITE_NODE_FIELD(base.options);
2303 568 : WRITE_ENUM_FIELD(base.oncommit, OnCommitAction);
2304 568 : WRITE_STRING_FIELD(base.tablespacename);
2305 568 : WRITE_STRING_FIELD(base.accessMethod);
2306 568 : WRITE_BOOL_FIELD(base.if_not_exists);
2307 568 : WRITE_STRING_FIELD(servername);
2308 568 : WRITE_NODE_FIELD(options);
2309 568 : }
2310 :
2311 : static void
2312 328 : _outCreateUserMappingStmt(StringInfo str, const CreateUserMappingStmt *node)
2313 : {
2314 328 : WRITE_NODE_TYPE("CREATEUSERMAPPINGSTMT");
2315 :
2316 328 : WRITE_NODE_FIELD(user);
2317 328 : WRITE_STRING_FIELD(servername);
2318 328 : WRITE_BOOL_FIELD(if_not_exists);
2319 328 : WRITE_NODE_FIELD(options);
2320 328 : }
2321 :
2322 : static void
2323 144 : _outAlterUserMappingStmt(StringInfo str, const AlterUserMappingStmt *node)
2324 : {
2325 144 : WRITE_NODE_TYPE("ALTERUSERMAPPINGSTMT");
2326 :
2327 144 : WRITE_NODE_FIELD(user);
2328 144 : WRITE_STRING_FIELD(servername);
2329 144 : WRITE_NODE_FIELD(options);
2330 144 : }
2331 :
2332 : static void
2333 158 : _outDropUserMappingStmt(StringInfo str, const DropUserMappingStmt *node)
2334 : {
2335 158 : WRITE_NODE_TYPE("DROPUSERMAPPINGSTMT");
2336 :
2337 158 : WRITE_NODE_FIELD(user);
2338 158 : WRITE_STRING_FIELD(servername);
2339 158 : WRITE_BOOL_FIELD(missing_ok);
2340 158 : }
2341 :
2342 : static void
2343 56 : _outImportForeignSchemaStmt(StringInfo str, const ImportForeignSchemaStmt *node)
2344 : {
2345 56 : WRITE_NODE_TYPE("IMPORTFOREIGNSCHEMASTMT");
2346 :
2347 56 : WRITE_STRING_FIELD(server_name);
2348 56 : WRITE_STRING_FIELD(remote_schema);
2349 56 : WRITE_STRING_FIELD(local_schema);
2350 56 : WRITE_ENUM_FIELD(list_type, ImportForeignSchemaType);
2351 56 : WRITE_NODE_FIELD(table_list);
2352 56 : WRITE_NODE_FIELD(options);
2353 56 : }
2354 :
2355 : static void
2356 1134 : _outCreatePolicyStmt(StringInfo str, const CreatePolicyStmt *node)
2357 : {
2358 1134 : WRITE_NODE_TYPE("CREATEPOLICYSTMT");
2359 :
2360 1134 : WRITE_STRING_FIELD(policy_name);
2361 1134 : WRITE_NODE_FIELD(table);
2362 1134 : WRITE_STRING_FIELD(cmd_name);
2363 1134 : WRITE_BOOL_FIELD(permissive);
2364 1134 : WRITE_NODE_FIELD(roles);
2365 1134 : WRITE_NODE_FIELD(qual);
2366 1134 : WRITE_NODE_FIELD(with_check);
2367 1134 : }
2368 :
2369 : static void
2370 112 : _outAlterPolicyStmt(StringInfo str, const AlterPolicyStmt *node)
2371 : {
2372 112 : WRITE_NODE_TYPE("ALTERPOLICYSTMT");
2373 :
2374 112 : WRITE_STRING_FIELD(policy_name);
2375 112 : WRITE_NODE_FIELD(table);
2376 112 : WRITE_NODE_FIELD(roles);
2377 112 : WRITE_NODE_FIELD(qual);
2378 112 : WRITE_NODE_FIELD(with_check);
2379 112 : }
2380 :
2381 : static void
2382 92 : _outCreateAmStmt(StringInfo str, const CreateAmStmt *node)
2383 : {
2384 92 : WRITE_NODE_TYPE("CREATEAMSTMT");
2385 :
2386 92 : WRITE_STRING_FIELD(amname);
2387 92 : WRITE_NODE_FIELD(handler_name);
2388 92 : WRITE_CHAR_FIELD(amtype);
2389 92 : }
2390 :
2391 : static void
2392 4276 : _outCreateTrigStmt(StringInfo str, const CreateTrigStmt *node)
2393 : {
2394 4276 : WRITE_NODE_TYPE("CREATETRIGSTMT");
2395 :
2396 4276 : WRITE_BOOL_FIELD(replace);
2397 4276 : WRITE_BOOL_FIELD(isconstraint);
2398 4276 : WRITE_STRING_FIELD(trigname);
2399 4276 : WRITE_NODE_FIELD(relation);
2400 4276 : WRITE_NODE_FIELD(funcname);
2401 4276 : WRITE_NODE_FIELD(args);
2402 4276 : WRITE_BOOL_FIELD(row);
2403 4276 : WRITE_INT_FIELD(timing);
2404 4276 : WRITE_INT_FIELD(events);
2405 4276 : WRITE_NODE_FIELD(columns);
2406 4276 : WRITE_NODE_FIELD(whenClause);
2407 4276 : WRITE_NODE_FIELD(transitionRels);
2408 4276 : WRITE_BOOL_FIELD(deferrable);
2409 4276 : WRITE_BOOL_FIELD(initdeferred);
2410 4276 : WRITE_NODE_FIELD(constrrel);
2411 4276 : }
2412 :
2413 : static void
2414 256 : _outCreateEventTrigStmt(StringInfo str, const CreateEventTrigStmt *node)
2415 : {
2416 256 : WRITE_NODE_TYPE("CREATEEVENTTRIGSTMT");
2417 :
2418 256 : WRITE_STRING_FIELD(trigname);
2419 256 : WRITE_STRING_FIELD(eventname);
2420 256 : WRITE_NODE_FIELD(whenclause);
2421 256 : WRITE_NODE_FIELD(funcname);
2422 256 : }
2423 :
2424 : static void
2425 62 : _outAlterEventTrigStmt(StringInfo str, const AlterEventTrigStmt *node)
2426 : {
2427 62 : WRITE_NODE_TYPE("ALTEREVENTTRIGSTMT");
2428 :
2429 62 : WRITE_STRING_FIELD(trigname);
2430 62 : WRITE_CHAR_FIELD(tgenabled);
2431 62 : }
2432 :
2433 : static void
2434 160 : _outCreatePLangStmt(StringInfo str, const CreatePLangStmt *node)
2435 : {
2436 160 : WRITE_NODE_TYPE("CREATEPLANGSTMT");
2437 :
2438 160 : WRITE_BOOL_FIELD(replace);
2439 160 : WRITE_STRING_FIELD(plname);
2440 160 : WRITE_NODE_FIELD(plhandler);
2441 160 : WRITE_NODE_FIELD(plinline);
2442 160 : WRITE_NODE_FIELD(plvalidator);
2443 160 : WRITE_BOOL_FIELD(pltrusted);
2444 160 : }
2445 :
2446 : static void
2447 2580 : _outCreateRoleStmt(StringInfo str, const CreateRoleStmt *node)
2448 : {
2449 2580 : WRITE_NODE_TYPE("CREATEROLESTMT");
2450 :
2451 2580 : WRITE_ENUM_FIELD(stmt_type, RoleStmtType);
2452 2580 : WRITE_STRING_FIELD(role);
2453 2580 : WRITE_NODE_FIELD(options);
2454 2580 : }
2455 :
2456 : static void
2457 580 : _outAlterRoleStmt(StringInfo str, const AlterRoleStmt *node)
2458 : {
2459 580 : WRITE_NODE_TYPE("ALTERROLESTMT");
2460 :
2461 580 : WRITE_NODE_FIELD(role);
2462 580 : WRITE_NODE_FIELD(options);
2463 580 : WRITE_INT_FIELD(action);
2464 580 : }
2465 :
2466 : static void
2467 102 : _outAlterRoleSetStmt(StringInfo str, const AlterRoleSetStmt *node)
2468 : {
2469 102 : WRITE_NODE_TYPE("ALTERROLESETSTMT");
2470 :
2471 102 : WRITE_NODE_FIELD(role);
2472 102 : WRITE_STRING_FIELD(database);
2473 102 : WRITE_NODE_FIELD(setstmt);
2474 102 : }
2475 :
2476 : static void
2477 2444 : _outDropRoleStmt(StringInfo str, const DropRoleStmt *node)
2478 : {
2479 2444 : WRITE_NODE_TYPE("DROPROLESTMT");
2480 :
2481 2444 : WRITE_NODE_FIELD(roles);
2482 2444 : WRITE_BOOL_FIELD(missing_ok);
2483 2444 : }
2484 :
2485 : static void
2486 892 : _outCreateSeqStmt(StringInfo str, const CreateSeqStmt *node)
2487 : {
2488 892 : WRITE_NODE_TYPE("CREATESEQSTMT");
2489 :
2490 892 : WRITE_NODE_FIELD(sequence);
2491 892 : WRITE_NODE_FIELD(options);
2492 892 : WRITE_OID_FIELD(ownerId);
2493 892 : WRITE_BOOL_FIELD(for_identity);
2494 892 : WRITE_BOOL_FIELD(if_not_exists);
2495 892 : }
2496 :
2497 : static void
2498 266 : _outAlterSeqStmt(StringInfo str, const AlterSeqStmt *node)
2499 : {
2500 266 : WRITE_NODE_TYPE("ALTERSEQSTMT");
2501 :
2502 266 : WRITE_NODE_FIELD(sequence);
2503 266 : WRITE_NODE_FIELD(options);
2504 266 : WRITE_BOOL_FIELD(for_identity);
2505 266 : WRITE_BOOL_FIELD(missing_ok);
2506 266 : }
2507 :
2508 : static void
2509 11282 : _outDefineStmt(StringInfo str, const DefineStmt *node)
2510 : {
2511 11282 : WRITE_NODE_TYPE("DEFINESTMT");
2512 :
2513 11282 : WRITE_ENUM_FIELD(kind, ObjectType);
2514 11282 : WRITE_BOOL_FIELD(oldstyle);
2515 11282 : WRITE_NODE_FIELD(defnames);
2516 11282 : WRITE_NODE_FIELD(args);
2517 11282 : WRITE_NODE_FIELD(definition);
2518 11282 : WRITE_BOOL_FIELD(if_not_exists);
2519 11282 : WRITE_BOOL_FIELD(replace);
2520 11282 : }
2521 :
2522 : static void
2523 1986 : _outCreateDomainStmt(StringInfo str, const CreateDomainStmt *node)
2524 : {
2525 1986 : WRITE_NODE_TYPE("CREATEDOMAINSTMT");
2526 :
2527 1986 : WRITE_NODE_FIELD(domainname);
2528 1986 : WRITE_NODE_FIELD(typeName);
2529 1986 : WRITE_NODE_FIELD(collClause);
2530 1986 : WRITE_NODE_FIELD(constraints);
2531 1986 : }
2532 :
2533 : static void
2534 590 : _outCreateOpClassStmt(StringInfo str, const CreateOpClassStmt *node)
2535 : {
2536 590 : WRITE_NODE_TYPE("CREATEOPCLASSSTMT");
2537 :
2538 590 : WRITE_NODE_FIELD(opclassname);
2539 590 : WRITE_NODE_FIELD(opfamilyname);
2540 590 : WRITE_STRING_FIELD(amname);
2541 590 : WRITE_NODE_FIELD(datatype);
2542 590 : WRITE_NODE_FIELD(items);
2543 590 : WRITE_BOOL_FIELD(isDefault);
2544 590 : }
2545 :
2546 : static void
2547 7170 : _outCreateOpClassItem(StringInfo str, const CreateOpClassItem *node)
2548 : {
2549 7170 : WRITE_NODE_TYPE("CREATEOPCLASSITEM");
2550 :
2551 7170 : WRITE_INT_FIELD(itemtype);
2552 7170 : WRITE_NODE_FIELD(name);
2553 7170 : WRITE_INT_FIELD(number);
2554 7170 : WRITE_NODE_FIELD(order_family);
2555 7170 : WRITE_NODE_FIELD(class_args);
2556 7170 : WRITE_NODE_FIELD(storedtype);
2557 7170 : }
2558 :
2559 : static void
2560 190 : _outCreateOpFamilyStmt(StringInfo str, const CreateOpFamilyStmt *node)
2561 : {
2562 190 : WRITE_NODE_TYPE("CREATEOPFAMILYSTMT");
2563 :
2564 190 : WRITE_NODE_FIELD(opfamilyname);
2565 190 : WRITE_STRING_FIELD(amname);
2566 190 : }
2567 :
2568 : static void
2569 552 : _outAlterOpFamilyStmt(StringInfo str, const AlterOpFamilyStmt *node)
2570 : {
2571 552 : WRITE_NODE_TYPE("ALTEROPFAMILYSTMT");
2572 :
2573 552 : WRITE_NODE_FIELD(opfamilyname);
2574 552 : WRITE_STRING_FIELD(amname);
2575 552 : WRITE_BOOL_FIELD(isDrop);
2576 552 : WRITE_NODE_FIELD(items);
2577 552 : }
2578 :
2579 : static void
2580 34847 : _outDropStmt(StringInfo str, const DropStmt *node)
2581 : {
2582 34847 : WRITE_NODE_TYPE("DROPSTMT");
2583 :
2584 34847 : WRITE_NODE_FIELD(objects);
2585 34847 : WRITE_ENUM_FIELD(removeType, ObjectType);
2586 34847 : WRITE_ENUM_FIELD(behavior, DropBehavior);
2587 34847 : WRITE_BOOL_FIELD(missing_ok);
2588 34847 : WRITE_BOOL_FIELD(concurrent);
2589 34847 : }
2590 :
2591 : static void
2592 2318 : _outTruncateStmt(StringInfo str, const TruncateStmt *node)
2593 : {
2594 2318 : WRITE_NODE_TYPE("TRUNCATESTMT");
2595 :
2596 2318 : WRITE_NODE_FIELD(relations);
2597 2318 : WRITE_BOOL_FIELD(restart_seqs);
2598 2318 : WRITE_ENUM_FIELD(behavior, DropBehavior);
2599 2318 : }
2600 :
2601 : static void
2602 8729 : _outCommentStmt(StringInfo str, const CommentStmt *node)
2603 : {
2604 8729 : WRITE_NODE_TYPE("COMMENTSTMT");
2605 :
2606 8729 : WRITE_ENUM_FIELD(objtype, ObjectType);
2607 8729 : WRITE_NODE_FIELD(object);
2608 8729 : WRITE_STRING_FIELD(comment);
2609 8729 : }
2610 :
2611 : static void
2612 134 : _outSecLabelStmt(StringInfo str, const SecLabelStmt *node)
2613 : {
2614 134 : WRITE_NODE_TYPE("SECLABELSTMT");
2615 :
2616 134 : WRITE_ENUM_FIELD(objtype, ObjectType);
2617 134 : WRITE_NODE_FIELD(object);
2618 134 : WRITE_STRING_FIELD(provider);
2619 134 : WRITE_STRING_FIELD(label);
2620 134 : }
2621 :
2622 : static void
2623 4322 : _outDeclareCursorStmt(StringInfo str, const DeclareCursorStmt *node)
2624 : {
2625 4322 : WRITE_NODE_TYPE("DECLARECURSORSTMT");
2626 :
2627 4322 : WRITE_STRING_FIELD(portalname);
2628 4322 : WRITE_INT_FIELD(options);
2629 4322 : WRITE_NODE_FIELD(query);
2630 4322 : }
2631 :
2632 : static void
2633 2362 : _outClosePortalStmt(StringInfo str, const ClosePortalStmt *node)
2634 : {
2635 2362 : WRITE_NODE_TYPE("CLOSEPORTALSTMT");
2636 :
2637 2362 : WRITE_STRING_FIELD(portalname);
2638 2362 : }
2639 :
2640 : static void
2641 7718 : _outFetchStmt(StringInfo str, const FetchStmt *node)
2642 : {
2643 7718 : WRITE_NODE_TYPE("FETCHSTMT");
2644 :
2645 7718 : WRITE_ENUM_FIELD(direction, FetchDirection);
2646 7718 : WRITE_LONG_FIELD(howMany);
2647 7718 : WRITE_STRING_FIELD(portalname);
2648 7718 : WRITE_BOOL_FIELD(ismove);
2649 7718 : WRITE_ENUM_FIELD(direction_keyword, FetchDirectionKeywords);
2650 7718 : WRITE_LOCATION_FIELD(location);
2651 7718 : }
2652 :
2653 : static void
2654 8609 : _outIndexStmt(StringInfo str, const IndexStmt *node)
2655 : {
2656 8609 : WRITE_NODE_TYPE("INDEXSTMT");
2657 :
2658 8609 : WRITE_STRING_FIELD(idxname);
2659 8609 : WRITE_NODE_FIELD(relation);
2660 8609 : WRITE_STRING_FIELD(accessMethod);
2661 8609 : WRITE_STRING_FIELD(tableSpace);
2662 8609 : WRITE_NODE_FIELD(indexParams);
2663 8609 : WRITE_NODE_FIELD(indexIncludingParams);
2664 8609 : WRITE_NODE_FIELD(options);
2665 8609 : WRITE_NODE_FIELD(whereClause);
2666 8609 : WRITE_NODE_FIELD(excludeOpNames);
2667 8609 : WRITE_STRING_FIELD(idxcomment);
2668 8609 : WRITE_OID_FIELD(indexOid);
2669 8609 : WRITE_OID_FIELD(oldNumber);
2670 8609 : WRITE_UINT_FIELD(oldCreateSubid);
2671 8609 : WRITE_UINT_FIELD(oldFirstRelfilelocatorSubid);
2672 8609 : WRITE_BOOL_FIELD(unique);
2673 8609 : WRITE_BOOL_FIELD(nulls_not_distinct);
2674 8609 : WRITE_BOOL_FIELD(primary);
2675 8609 : WRITE_BOOL_FIELD(isconstraint);
2676 8609 : WRITE_BOOL_FIELD(iswithoutoverlaps);
2677 8609 : WRITE_BOOL_FIELD(deferrable);
2678 8609 : WRITE_BOOL_FIELD(initdeferred);
2679 8609 : WRITE_BOOL_FIELD(transformed);
2680 8609 : WRITE_BOOL_FIELD(concurrent);
2681 8609 : WRITE_BOOL_FIELD(if_not_exists);
2682 8609 : WRITE_BOOL_FIELD(reset_default_tblspc);
2683 8609 : }
2684 :
2685 : static void
2686 1204 : _outCreateStatsStmt(StringInfo str, const CreateStatsStmt *node)
2687 : {
2688 1204 : WRITE_NODE_TYPE("CREATESTATSSTMT");
2689 :
2690 1204 : WRITE_NODE_FIELD(defnames);
2691 1204 : WRITE_NODE_FIELD(stat_types);
2692 1204 : WRITE_NODE_FIELD(exprs);
2693 1204 : WRITE_NODE_FIELD(relations);
2694 1204 : WRITE_STRING_FIELD(stxcomment);
2695 1204 : WRITE_BOOL_FIELD(transformed);
2696 1204 : WRITE_BOOL_FIELD(if_not_exists);
2697 1204 : }
2698 :
2699 : static void
2700 2840 : _outStatsElem(StringInfo str, const StatsElem *node)
2701 : {
2702 2840 : WRITE_NODE_TYPE("STATSELEM");
2703 :
2704 2840 : WRITE_STRING_FIELD(name);
2705 2840 : WRITE_NODE_FIELD(expr);
2706 2840 : }
2707 :
2708 : static void
2709 34 : _outAlterStatsStmt(StringInfo str, const AlterStatsStmt *node)
2710 : {
2711 34 : WRITE_NODE_TYPE("ALTERSTATSSTMT");
2712 :
2713 34 : WRITE_NODE_FIELD(defnames);
2714 34 : WRITE_NODE_FIELD(stxstattarget);
2715 34 : WRITE_BOOL_FIELD(missing_ok);
2716 34 : }
2717 :
2718 : static void
2719 25776 : _outCreateFunctionStmt(StringInfo str, const CreateFunctionStmt *node)
2720 : {
2721 25776 : WRITE_NODE_TYPE("CREATEFUNCTIONSTMT");
2722 :
2723 25776 : WRITE_BOOL_FIELD(is_procedure);
2724 25776 : WRITE_BOOL_FIELD(replace);
2725 25776 : WRITE_NODE_FIELD(funcname);
2726 25776 : WRITE_NODE_FIELD(parameters);
2727 25776 : WRITE_NODE_FIELD(returnType);
2728 25776 : WRITE_NODE_FIELD(options);
2729 25776 : WRITE_NODE_FIELD(sql_body);
2730 25776 : }
2731 :
2732 : static void
2733 66931 : _outFunctionParameter(StringInfo str, const FunctionParameter *node)
2734 : {
2735 66931 : WRITE_NODE_TYPE("FUNCTIONPARAMETER");
2736 :
2737 66931 : WRITE_STRING_FIELD(name);
2738 66931 : WRITE_NODE_FIELD(argType);
2739 66931 : WRITE_ENUM_FIELD(mode, FunctionParameterMode);
2740 66931 : WRITE_NODE_FIELD(defexpr);
2741 66931 : WRITE_LOCATION_FIELD(location);
2742 66931 : }
2743 :
2744 : static void
2745 418 : _outAlterFunctionStmt(StringInfo str, const AlterFunctionStmt *node)
2746 : {
2747 418 : WRITE_NODE_TYPE("ALTERFUNCTIONSTMT");
2748 :
2749 418 : WRITE_ENUM_FIELD(objtype, ObjectType);
2750 418 : WRITE_NODE_FIELD(func);
2751 418 : WRITE_NODE_FIELD(actions);
2752 418 : }
2753 :
2754 : static void
2755 1296 : _outDoStmt(StringInfo str, const DoStmt *node)
2756 : {
2757 1296 : WRITE_NODE_TYPE("DOSTMT");
2758 :
2759 1296 : WRITE_NODE_FIELD(args);
2760 1296 : }
2761 :
2762 : static void
2763 546 : _outCallStmt(StringInfo str, const CallStmt *node)
2764 : {
2765 546 : WRITE_NODE_TYPE("CALLSTMT");
2766 :
2767 546 : WRITE_NODE_FIELD(funccall);
2768 546 : WRITE_NODE_FIELD(funcexpr);
2769 546 : WRITE_NODE_FIELD(outargs);
2770 546 : }
2771 :
2772 : static void
2773 1904 : _outRenameStmt(StringInfo str, const RenameStmt *node)
2774 : {
2775 1904 : WRITE_NODE_TYPE("RENAMESTMT");
2776 :
2777 1904 : WRITE_ENUM_FIELD(renameType, ObjectType);
2778 1904 : WRITE_ENUM_FIELD(relationType, ObjectType);
2779 1904 : WRITE_NODE_FIELD(relation);
2780 1904 : WRITE_NODE_FIELD(object);
2781 1904 : WRITE_STRING_FIELD(subname);
2782 1904 : WRITE_STRING_FIELD(newname);
2783 1904 : WRITE_ENUM_FIELD(behavior, DropBehavior);
2784 1904 : WRITE_BOOL_FIELD(missing_ok);
2785 1904 : }
2786 :
2787 : static void
2788 70 : _outAlterObjectDependsStmt(StringInfo str, const AlterObjectDependsStmt *node)
2789 : {
2790 70 : WRITE_NODE_TYPE("ALTEROBJECTDEPENDSSTMT");
2791 :
2792 70 : WRITE_ENUM_FIELD(objectType, ObjectType);
2793 70 : WRITE_NODE_FIELD(relation);
2794 70 : WRITE_NODE_FIELD(object);
2795 70 : WRITE_NODE_FIELD(extname);
2796 70 : WRITE_BOOL_FIELD(remove);
2797 70 : }
2798 :
2799 : static void
2800 562 : _outAlterObjectSchemaStmt(StringInfo str, const AlterObjectSchemaStmt *node)
2801 : {
2802 562 : WRITE_NODE_TYPE("ALTEROBJECTSCHEMASTMT");
2803 :
2804 562 : WRITE_ENUM_FIELD(objectType, ObjectType);
2805 562 : WRITE_NODE_FIELD(relation);
2806 562 : WRITE_NODE_FIELD(object);
2807 562 : WRITE_STRING_FIELD(newschema);
2808 562 : WRITE_BOOL_FIELD(missing_ok);
2809 562 : }
2810 :
2811 : static void
2812 1992 : _outAlterOwnerStmt(StringInfo str, const AlterOwnerStmt *node)
2813 : {
2814 1992 : WRITE_NODE_TYPE("ALTEROWNERSTMT");
2815 :
2816 1992 : WRITE_ENUM_FIELD(objectType, ObjectType);
2817 1992 : WRITE_NODE_FIELD(relation);
2818 1992 : WRITE_NODE_FIELD(object);
2819 1992 : WRITE_NODE_FIELD(newowner);
2820 1992 : }
2821 :
2822 : static void
2823 664 : _outAlterOperatorStmt(StringInfo str, const AlterOperatorStmt *node)
2824 : {
2825 664 : WRITE_NODE_TYPE("ALTEROPERATORSTMT");
2826 :
2827 664 : WRITE_NODE_FIELD(opername);
2828 664 : WRITE_NODE_FIELD(options);
2829 664 : }
2830 :
2831 : static void
2832 72 : _outAlterTypeStmt(StringInfo str, const AlterTypeStmt *node)
2833 : {
2834 72 : WRITE_NODE_TYPE("ALTERTYPESTMT");
2835 :
2836 72 : WRITE_NODE_FIELD(typeName);
2837 72 : WRITE_NODE_FIELD(options);
2838 72 : }
2839 :
2840 : static void
2841 1492 : _outRuleStmt(StringInfo str, const RuleStmt *node)
2842 : {
2843 1492 : WRITE_NODE_TYPE("RULESTMT");
2844 :
2845 1492 : WRITE_NODE_FIELD(relation);
2846 1492 : WRITE_STRING_FIELD(rulename);
2847 1492 : WRITE_NODE_FIELD(whereClause);
2848 1492 : WRITE_ENUM_FIELD(event, CmdType);
2849 1492 : WRITE_BOOL_FIELD(instead);
2850 1492 : WRITE_NODE_FIELD(actions);
2851 1492 : WRITE_BOOL_FIELD(replace);
2852 1492 : }
2853 :
2854 : static void
2855 206 : _outNotifyStmt(StringInfo str, const NotifyStmt *node)
2856 : {
2857 206 : WRITE_NODE_TYPE("NOTIFYSTMT");
2858 :
2859 206 : WRITE_STRING_FIELD(conditionname);
2860 206 : WRITE_STRING_FIELD(payload);
2861 206 : }
2862 :
2863 : static void
2864 120 : _outListenStmt(StringInfo str, const ListenStmt *node)
2865 : {
2866 120 : WRITE_NODE_TYPE("LISTENSTMT");
2867 :
2868 120 : WRITE_STRING_FIELD(conditionname);
2869 120 : }
2870 :
2871 : static void
2872 160 : _outUnlistenStmt(StringInfo str, const UnlistenStmt *node)
2873 : {
2874 160 : WRITE_NODE_TYPE("UNLISTENSTMT");
2875 :
2876 160 : WRITE_STRING_FIELD(conditionname);
2877 160 : }
2878 :
2879 : static void
2880 54238 : _outTransactionStmt(StringInfo str, const TransactionStmt *node)
2881 : {
2882 54238 : WRITE_NODE_TYPE("TRANSACTIONSTMT");
2883 :
2884 54238 : WRITE_ENUM_FIELD(kind, TransactionStmtKind);
2885 54238 : WRITE_NODE_FIELD(options);
2886 54238 : WRITE_STRING_FIELD(savepoint_name);
2887 54238 : WRITE_STRING_FIELD(gid);
2888 54238 : WRITE_BOOL_FIELD(chain);
2889 54238 : WRITE_LOCATION_FIELD(location);
2890 54238 : }
2891 :
2892 : static void
2893 2846 : _outCompositeTypeStmt(StringInfo str, const CompositeTypeStmt *node)
2894 : {
2895 2846 : WRITE_NODE_TYPE("COMPOSITETYPESTMT");
2896 :
2897 2846 : WRITE_NODE_FIELD(typevar);
2898 2846 : WRITE_NODE_FIELD(coldeflist);
2899 2846 : }
2900 :
2901 : static void
2902 264 : _outCreateEnumStmt(StringInfo str, const CreateEnumStmt *node)
2903 : {
2904 264 : WRITE_NODE_TYPE("CREATEENUMSTMT");
2905 :
2906 264 : WRITE_NODE_FIELD(typeName);
2907 264 : WRITE_NODE_FIELD(vals);
2908 264 : }
2909 :
2910 : static void
2911 300 : _outCreateRangeStmt(StringInfo str, const CreateRangeStmt *node)
2912 : {
2913 300 : WRITE_NODE_TYPE("CREATERANGESTMT");
2914 :
2915 300 : WRITE_NODE_FIELD(typeName);
2916 300 : WRITE_NODE_FIELD(params);
2917 300 : }
2918 :
2919 : static void
2920 492 : _outAlterEnumStmt(StringInfo str, const AlterEnumStmt *node)
2921 : {
2922 492 : WRITE_NODE_TYPE("ALTERENUMSTMT");
2923 :
2924 492 : WRITE_NODE_FIELD(typeName);
2925 492 : WRITE_STRING_FIELD(oldVal);
2926 492 : WRITE_STRING_FIELD(newVal);
2927 492 : WRITE_STRING_FIELD(newValNeighbor);
2928 492 : WRITE_BOOL_FIELD(newValIsAfter);
2929 492 : WRITE_BOOL_FIELD(skipIfNewValExists);
2930 492 : }
2931 :
2932 : static void
2933 21867 : _outViewStmt(StringInfo str, const ViewStmt *node)
2934 : {
2935 21867 : WRITE_NODE_TYPE("VIEWSTMT");
2936 :
2937 21867 : WRITE_NODE_FIELD(view);
2938 21867 : WRITE_NODE_FIELD(aliases);
2939 21867 : WRITE_NODE_FIELD(query);
2940 21867 : WRITE_BOOL_FIELD(replace);
2941 21867 : WRITE_NODE_FIELD(options);
2942 21867 : WRITE_ENUM_FIELD(withCheckOption, ViewCheckOption);
2943 21867 : }
2944 :
2945 : static void
2946 92 : _outLoadStmt(StringInfo str, const LoadStmt *node)
2947 : {
2948 92 : WRITE_NODE_TYPE("LOADSTMT");
2949 :
2950 92 : WRITE_STRING_FIELD(filename);
2951 92 : }
2952 :
2953 : static void
2954 896 : _outCreatedbStmt(StringInfo str, const CreatedbStmt *node)
2955 : {
2956 896 : WRITE_NODE_TYPE("CREATEDBSTMT");
2957 :
2958 896 : WRITE_STRING_FIELD(dbname);
2959 896 : WRITE_NODE_FIELD(options);
2960 896 : }
2961 :
2962 : static void
2963 106 : _outAlterDatabaseStmt(StringInfo str, const AlterDatabaseStmt *node)
2964 : {
2965 106 : WRITE_NODE_TYPE("ALTERDATABASESTMT");
2966 :
2967 106 : WRITE_STRING_FIELD(dbname);
2968 106 : WRITE_NODE_FIELD(options);
2969 106 : }
2970 :
2971 : static void
2972 8 : _outAlterDatabaseRefreshCollStmt(StringInfo str, const AlterDatabaseRefreshCollStmt *node)
2973 : {
2974 8 : WRITE_NODE_TYPE("ALTERDATABASEREFRESHCOLLSTMT");
2975 :
2976 8 : WRITE_STRING_FIELD(dbname);
2977 8 : }
2978 :
2979 : static void
2980 1322 : _outAlterDatabaseSetStmt(StringInfo str, const AlterDatabaseSetStmt *node)
2981 : {
2982 1322 : WRITE_NODE_TYPE("ALTERDATABASESETSTMT");
2983 :
2984 1322 : WRITE_STRING_FIELD(dbname);
2985 1322 : WRITE_NODE_FIELD(setstmt);
2986 1322 : }
2987 :
2988 : static void
2989 148 : _outDropdbStmt(StringInfo str, const DropdbStmt *node)
2990 : {
2991 148 : WRITE_NODE_TYPE("DROPDBSTMT");
2992 :
2993 148 : WRITE_STRING_FIELD(dbname);
2994 148 : WRITE_BOOL_FIELD(missing_ok);
2995 148 : WRITE_NODE_FIELD(options);
2996 148 : }
2997 :
2998 : static void
2999 238 : _outAlterSystemStmt(StringInfo str, const AlterSystemStmt *node)
3000 : {
3001 238 : WRITE_NODE_TYPE("ALTERSYSTEMSTMT");
3002 :
3003 238 : WRITE_NODE_FIELD(setstmt);
3004 238 : }
3005 :
3006 : static void
3007 17354 : _outVacuumStmt(StringInfo str, const VacuumStmt *node)
3008 : {
3009 17354 : WRITE_NODE_TYPE("VACUUMSTMT");
3010 :
3011 17354 : WRITE_NODE_FIELD(options);
3012 17354 : WRITE_NODE_FIELD(rels);
3013 17354 : WRITE_BOOL_FIELD(is_vacuumcmd);
3014 17354 : }
3015 :
3016 : static void
3017 17612 : _outVacuumRelation(StringInfo str, const VacuumRelation *node)
3018 : {
3019 17612 : WRITE_NODE_TYPE("VACUUMRELATION");
3020 :
3021 17612 : WRITE_NODE_FIELD(relation);
3022 17612 : WRITE_OID_FIELD(oid);
3023 17612 : WRITE_NODE_FIELD(va_cols);
3024 17612 : }
3025 :
3026 : static void
3027 468 : _outRepackStmt(StringInfo str, const RepackStmt *node)
3028 : {
3029 468 : WRITE_NODE_TYPE("REPACKSTMT");
3030 :
3031 468 : WRITE_ENUM_FIELD(command, RepackCommand);
3032 468 : WRITE_NODE_FIELD(relation);
3033 468 : WRITE_STRING_FIELD(indexname);
3034 468 : WRITE_BOOL_FIELD(usingindex);
3035 468 : WRITE_NODE_FIELD(params);
3036 468 : }
3037 :
3038 : static void
3039 27489 : _outExplainStmt(StringInfo str, const ExplainStmt *node)
3040 : {
3041 27489 : WRITE_NODE_TYPE("EXPLAINSTMT");
3042 :
3043 27489 : WRITE_NODE_FIELD(query);
3044 27489 : WRITE_NODE_FIELD(options);
3045 27489 : }
3046 :
3047 : static void
3048 2495 : _outCreateTableAsStmt(StringInfo str, const CreateTableAsStmt *node)
3049 : {
3050 2495 : WRITE_NODE_TYPE("CREATETABLEASSTMT");
3051 :
3052 2495 : WRITE_NODE_FIELD(query);
3053 2495 : WRITE_NODE_FIELD(into);
3054 2495 : WRITE_ENUM_FIELD(objtype, ObjectType);
3055 2495 : WRITE_BOOL_FIELD(is_select_into);
3056 2495 : WRITE_BOOL_FIELD(if_not_exists);
3057 2495 : }
3058 :
3059 : static void
3060 348 : _outRefreshMatViewStmt(StringInfo str, const RefreshMatViewStmt *node)
3061 : {
3062 348 : WRITE_NODE_TYPE("REFRESHMATVIEWSTMT");
3063 :
3064 348 : WRITE_BOOL_FIELD(concurrent);
3065 348 : WRITE_BOOL_FIELD(skipData);
3066 348 : WRITE_NODE_FIELD(relation);
3067 348 : }
3068 :
3069 : static void
3070 291 : _outCheckPointStmt(StringInfo str, const CheckPointStmt *node)
3071 : {
3072 291 : WRITE_NODE_TYPE("CHECKPOINTSTMT");
3073 :
3074 291 : WRITE_NODE_FIELD(options);
3075 291 : }
3076 :
3077 : static void
3078 48 : _outDiscardStmt(StringInfo str, const DiscardStmt *node)
3079 : {
3080 48 : WRITE_NODE_TYPE("DISCARDSTMT");
3081 :
3082 48 : WRITE_ENUM_FIELD(target, DiscardMode);
3083 48 : }
3084 :
3085 : static void
3086 1294 : _outLockStmt(StringInfo str, const LockStmt *node)
3087 : {
3088 1294 : WRITE_NODE_TYPE("LOCKSTMT");
3089 :
3090 1294 : WRITE_NODE_FIELD(relations);
3091 1294 : WRITE_INT_FIELD(mode);
3092 1294 : WRITE_BOOL_FIELD(nowait);
3093 1294 : }
3094 :
3095 : static void
3096 141 : _outConstraintsSetStmt(StringInfo str, const ConstraintsSetStmt *node)
3097 : {
3098 141 : WRITE_NODE_TYPE("CONSTRAINTSSETSTMT");
3099 :
3100 141 : WRITE_NODE_FIELD(constraints);
3101 141 : WRITE_BOOL_FIELD(deferred);
3102 141 : }
3103 :
3104 : static void
3105 1414 : _outReindexStmt(StringInfo str, const ReindexStmt *node)
3106 : {
3107 1414 : WRITE_NODE_TYPE("REINDEXSTMT");
3108 :
3109 1414 : WRITE_ENUM_FIELD(kind, ReindexObjectType);
3110 1414 : WRITE_NODE_FIELD(relation);
3111 1414 : WRITE_STRING_FIELD(name);
3112 1414 : WRITE_NODE_FIELD(params);
3113 1414 : }
3114 :
3115 : static void
3116 84 : _outCreateConversionStmt(StringInfo str, const CreateConversionStmt *node)
3117 : {
3118 84 : WRITE_NODE_TYPE("CREATECONVERSIONSTMT");
3119 :
3120 84 : WRITE_NODE_FIELD(conversion_name);
3121 84 : WRITE_STRING_FIELD(for_encoding_name);
3122 84 : WRITE_STRING_FIELD(to_encoding_name);
3123 84 : WRITE_NODE_FIELD(func_name);
3124 84 : WRITE_BOOL_FIELD(def);
3125 84 : }
3126 :
3127 : static void
3128 324 : _outCreateCastStmt(StringInfo str, const CreateCastStmt *node)
3129 : {
3130 324 : WRITE_NODE_TYPE("CREATECASTSTMT");
3131 :
3132 324 : WRITE_NODE_FIELD(sourcetype);
3133 324 : WRITE_NODE_FIELD(targettype);
3134 324 : WRITE_NODE_FIELD(func);
3135 324 : WRITE_ENUM_FIELD(context, CoercionContext);
3136 324 : WRITE_BOOL_FIELD(inout);
3137 324 : }
3138 :
3139 : static void
3140 402 : _outCreatePropGraphStmt(StringInfo str, const CreatePropGraphStmt *node)
3141 : {
3142 402 : WRITE_NODE_TYPE("CREATEPROPGRAPHSTMT");
3143 :
3144 402 : WRITE_NODE_FIELD(pgname);
3145 402 : WRITE_NODE_FIELD(vertex_tables);
3146 402 : WRITE_NODE_FIELD(edge_tables);
3147 402 : }
3148 :
3149 : static void
3150 796 : _outPropGraphVertex(StringInfo str, const PropGraphVertex *node)
3151 : {
3152 796 : WRITE_NODE_TYPE("PROPGRAPHVERTEX");
3153 :
3154 796 : WRITE_NODE_FIELD(vtable);
3155 796 : WRITE_NODE_FIELD(vkey);
3156 796 : WRITE_NODE_FIELD(labels);
3157 796 : WRITE_LOCATION_FIELD(location);
3158 796 : }
3159 :
3160 : static void
3161 426 : _outPropGraphEdge(StringInfo str, const PropGraphEdge *node)
3162 : {
3163 426 : WRITE_NODE_TYPE("PROPGRAPHEDGE");
3164 :
3165 426 : WRITE_NODE_FIELD(etable);
3166 426 : WRITE_NODE_FIELD(ekey);
3167 426 : WRITE_NODE_FIELD(esrckey);
3168 426 : WRITE_STRING_FIELD(esrcvertex);
3169 426 : WRITE_NODE_FIELD(esrcvertexcols);
3170 426 : WRITE_NODE_FIELD(edestkey);
3171 426 : WRITE_STRING_FIELD(edestvertex);
3172 426 : WRITE_NODE_FIELD(edestvertexcols);
3173 426 : WRITE_NODE_FIELD(labels);
3174 426 : WRITE_LOCATION_FIELD(location);
3175 426 : }
3176 :
3177 : static void
3178 1510 : _outPropGraphLabelAndProperties(StringInfo str, const PropGraphLabelAndProperties *node)
3179 : {
3180 1510 : WRITE_NODE_TYPE("PROPGRAPHLABELANDPROPERTIES");
3181 :
3182 1510 : WRITE_STRING_FIELD(label);
3183 1510 : WRITE_NODE_FIELD(properties);
3184 1510 : WRITE_LOCATION_FIELD(location);
3185 1510 : }
3186 :
3187 : static void
3188 1526 : _outPropGraphProperties(StringInfo str, const PropGraphProperties *node)
3189 : {
3190 1526 : WRITE_NODE_TYPE("PROPGRAPHPROPERTIES");
3191 :
3192 1526 : WRITE_NODE_FIELD(properties);
3193 1526 : WRITE_BOOL_FIELD(all);
3194 1526 : WRITE_LOCATION_FIELD(location);
3195 1526 : }
3196 :
3197 : static void
3198 248 : _outAlterPropGraphStmt(StringInfo str, const AlterPropGraphStmt *node)
3199 : {
3200 248 : WRITE_NODE_TYPE("ALTERPROPGRAPHSTMT");
3201 :
3202 248 : WRITE_NODE_FIELD(pgname);
3203 248 : WRITE_BOOL_FIELD(missing_ok);
3204 248 : WRITE_NODE_FIELD(add_vertex_tables);
3205 248 : WRITE_NODE_FIELD(add_edge_tables);
3206 248 : WRITE_NODE_FIELD(drop_vertex_tables);
3207 248 : WRITE_NODE_FIELD(drop_edge_tables);
3208 248 : WRITE_ENUM_FIELD(drop_behavior, DropBehavior);
3209 248 : WRITE_ENUM_FIELD(element_kind, AlterPropGraphElementKind);
3210 248 : WRITE_STRING_FIELD(element_alias);
3211 248 : WRITE_NODE_FIELD(add_labels);
3212 248 : WRITE_STRING_FIELD(drop_label);
3213 248 : WRITE_STRING_FIELD(alter_label);
3214 248 : WRITE_NODE_FIELD(add_properties);
3215 248 : WRITE_NODE_FIELD(drop_properties);
3216 248 : }
3217 :
3218 : static void
3219 52 : _outCreateTransformStmt(StringInfo str, const CreateTransformStmt *node)
3220 : {
3221 52 : WRITE_NODE_TYPE("CREATETRANSFORMSTMT");
3222 :
3223 52 : WRITE_BOOL_FIELD(replace);
3224 52 : WRITE_NODE_FIELD(type_name);
3225 52 : WRITE_STRING_FIELD(lang);
3226 52 : WRITE_NODE_FIELD(fromsql);
3227 52 : WRITE_NODE_FIELD(tosql);
3228 52 : }
3229 :
3230 : static void
3231 2370 : _outPrepareStmt(StringInfo str, const PrepareStmt *node)
3232 : {
3233 2370 : WRITE_NODE_TYPE("PREPARESTMT");
3234 :
3235 2370 : WRITE_STRING_FIELD(name);
3236 2370 : WRITE_NODE_FIELD(argtypes);
3237 2370 : WRITE_NODE_FIELD(query);
3238 2370 : }
3239 :
3240 : static void
3241 18010 : _outExecuteStmt(StringInfo str, const ExecuteStmt *node)
3242 : {
3243 18010 : WRITE_NODE_TYPE("EXECUTESTMT");
3244 :
3245 18010 : WRITE_STRING_FIELD(name);
3246 18010 : WRITE_NODE_FIELD(params);
3247 18010 : }
3248 :
3249 : static void
3250 4190 : _outDeallocateStmt(StringInfo str, const DeallocateStmt *node)
3251 : {
3252 4190 : WRITE_NODE_TYPE("DEALLOCATESTMT");
3253 :
3254 4190 : WRITE_STRING_FIELD(name);
3255 4190 : WRITE_BOOL_FIELD(isall);
3256 4190 : WRITE_LOCATION_FIELD(location);
3257 4190 : }
3258 :
3259 : static void
3260 188 : _outDropOwnedStmt(StringInfo str, const DropOwnedStmt *node)
3261 : {
3262 188 : WRITE_NODE_TYPE("DROPOWNEDSTMT");
3263 :
3264 188 : WRITE_NODE_FIELD(roles);
3265 188 : WRITE_ENUM_FIELD(behavior, DropBehavior);
3266 188 : }
3267 :
3268 : static void
3269 68 : _outReassignOwnedStmt(StringInfo str, const ReassignOwnedStmt *node)
3270 : {
3271 68 : WRITE_NODE_TYPE("REASSIGNOWNEDSTMT");
3272 :
3273 68 : WRITE_NODE_FIELD(roles);
3274 68 : WRITE_NODE_FIELD(newrole);
3275 68 : }
3276 :
3277 : static void
3278 46 : _outAlterTSDictionaryStmt(StringInfo str, const AlterTSDictionaryStmt *node)
3279 : {
3280 46 : WRITE_NODE_TYPE("ALTERTSDICTIONARYSTMT");
3281 :
3282 46 : WRITE_NODE_FIELD(dictname);
3283 46 : WRITE_NODE_FIELD(options);
3284 46 : }
3285 :
3286 : static void
3287 10500 : _outAlterTSConfigurationStmt(StringInfo str, const AlterTSConfigurationStmt *node)
3288 : {
3289 10500 : WRITE_NODE_TYPE("ALTERTSCONFIGURATIONSTMT");
3290 :
3291 10500 : WRITE_ENUM_FIELD(kind, AlterTSConfigType);
3292 10500 : WRITE_NODE_FIELD(cfgname);
3293 10500 : WRITE_NODE_FIELD(tokentype);
3294 10500 : WRITE_NODE_FIELD(dicts);
3295 10500 : WRITE_BOOL_FIELD(override);
3296 10500 : WRITE_BOOL_FIELD(replace);
3297 10500 : WRITE_BOOL_FIELD(missing_ok);
3298 10500 : }
3299 :
3300 : static void
3301 2040 : _outPublicationTable(StringInfo str, const PublicationTable *node)
3302 : {
3303 2040 : WRITE_NODE_TYPE("PUBLICATIONTABLE");
3304 :
3305 2040 : WRITE_NODE_FIELD(relation);
3306 2040 : WRITE_NODE_FIELD(whereClause);
3307 2040 : WRITE_NODE_FIELD(columns);
3308 2040 : WRITE_BOOL_FIELD(except);
3309 2040 : }
3310 :
3311 : static void
3312 2568 : _outPublicationObjSpec(StringInfo str, const PublicationObjSpec *node)
3313 : {
3314 2568 : WRITE_NODE_TYPE("PUBLICATIONOBJSPEC");
3315 :
3316 2568 : WRITE_ENUM_FIELD(pubobjtype, PublicationObjSpecType);
3317 2568 : WRITE_STRING_FIELD(name);
3318 2568 : WRITE_NODE_FIELD(pubtable);
3319 2568 : WRITE_LOCATION_FIELD(location);
3320 2568 : }
3321 :
3322 : static void
3323 0 : _outPublicationAllObjSpec(StringInfo str, const PublicationAllObjSpec *node)
3324 : {
3325 0 : WRITE_NODE_TYPE("PUBLICATIONALLOBJSPEC");
3326 :
3327 0 : WRITE_ENUM_FIELD(pubobjtype, PublicationAllObjType);
3328 0 : WRITE_NODE_FIELD(except_tables);
3329 0 : WRITE_LOCATION_FIELD(location);
3330 0 : }
3331 :
3332 : static void
3333 1260 : _outCreatePublicationStmt(StringInfo str, const CreatePublicationStmt *node)
3334 : {
3335 1260 : WRITE_NODE_TYPE("CREATEPUBLICATIONSTMT");
3336 :
3337 1260 : WRITE_STRING_FIELD(pubname);
3338 1260 : WRITE_NODE_FIELD(options);
3339 1260 : WRITE_NODE_FIELD(pubobjects);
3340 1260 : WRITE_BOOL_FIELD(for_all_tables);
3341 1260 : WRITE_BOOL_FIELD(for_all_sequences);
3342 1260 : }
3343 :
3344 : static void
3345 1562 : _outAlterPublicationStmt(StringInfo str, const AlterPublicationStmt *node)
3346 : {
3347 1562 : WRITE_NODE_TYPE("ALTERPUBLICATIONSTMT");
3348 :
3349 1562 : WRITE_STRING_FIELD(pubname);
3350 1562 : WRITE_NODE_FIELD(options);
3351 1562 : WRITE_NODE_FIELD(pubobjects);
3352 1562 : WRITE_ENUM_FIELD(action, AlterPublicationAction);
3353 1562 : WRITE_BOOL_FIELD(for_all_tables);
3354 1562 : WRITE_BOOL_FIELD(for_all_sequences);
3355 1562 : }
3356 :
3357 : static void
3358 608 : _outCreateSubscriptionStmt(StringInfo str, const CreateSubscriptionStmt *node)
3359 : {
3360 608 : WRITE_NODE_TYPE("CREATESUBSCRIPTIONSTMT");
3361 :
3362 608 : WRITE_STRING_FIELD(subname);
3363 608 : WRITE_STRING_FIELD(servername);
3364 608 : WRITE_STRING_FIELD(conninfo);
3365 608 : WRITE_NODE_FIELD(publication);
3366 608 : WRITE_NODE_FIELD(options);
3367 608 : }
3368 :
3369 : static void
3370 687 : _outAlterSubscriptionStmt(StringInfo str, const AlterSubscriptionStmt *node)
3371 : {
3372 687 : WRITE_NODE_TYPE("ALTERSUBSCRIPTIONSTMT");
3373 :
3374 687 : WRITE_ENUM_FIELD(kind, AlterSubscriptionType);
3375 687 : WRITE_STRING_FIELD(subname);
3376 687 : WRITE_STRING_FIELD(servername);
3377 687 : WRITE_STRING_FIELD(conninfo);
3378 687 : WRITE_NODE_FIELD(publication);
3379 687 : WRITE_NODE_FIELD(options);
3380 687 : }
3381 :
3382 : static void
3383 310 : _outDropSubscriptionStmt(StringInfo str, const DropSubscriptionStmt *node)
3384 : {
3385 310 : WRITE_NODE_TYPE("DROPSUBSCRIPTIONSTMT");
3386 :
3387 310 : WRITE_STRING_FIELD(subname);
3388 310 : WRITE_BOOL_FIELD(missing_ok);
3389 310 : WRITE_ENUM_FIELD(behavior, DropBehavior);
3390 310 : }
3391 :
3392 : static void
3393 499 : _outWaitStmt(StringInfo str, const WaitStmt *node)
3394 : {
3395 499 : WRITE_NODE_TYPE("WAITSTMT");
3396 :
3397 499 : WRITE_STRING_FIELD(lsn_literal);
3398 499 : WRITE_NODE_FIELD(options);
3399 499 : }
3400 :
3401 : static void
3402 0 : _outPlannerGlobal(StringInfo str, const PlannerGlobal *node)
3403 : {
3404 0 : WRITE_NODE_TYPE("PLANNERGLOBAL");
3405 :
3406 0 : WRITE_NODE_FIELD(subplans);
3407 0 : WRITE_NODE_FIELD(subpaths);
3408 0 : WRITE_BITMAPSET_FIELD(rewindPlanIDs);
3409 0 : WRITE_NODE_FIELD(finalrtable);
3410 0 : WRITE_BITMAPSET_FIELD(allRelids);
3411 0 : WRITE_BITMAPSET_FIELD(prunableRelids);
3412 0 : WRITE_NODE_FIELD(finalrteperminfos);
3413 0 : WRITE_NODE_FIELD(subrtinfos);
3414 0 : WRITE_NODE_FIELD(finalrowmarks);
3415 0 : WRITE_NODE_FIELD(resultRelations);
3416 0 : WRITE_NODE_FIELD(appendRelations);
3417 0 : WRITE_NODE_FIELD(partPruneInfos);
3418 0 : WRITE_NODE_FIELD(relationOids);
3419 0 : WRITE_NODE_FIELD(invalItems);
3420 0 : WRITE_NODE_FIELD(paramExecTypes);
3421 0 : WRITE_NODE_FIELD(elidedNodes);
3422 0 : WRITE_UINT_FIELD(lastPHId);
3423 0 : WRITE_UINT_FIELD(lastRowMarkId);
3424 0 : WRITE_INT_FIELD(lastPlanNodeId);
3425 0 : WRITE_BOOL_FIELD(transientPlan);
3426 0 : WRITE_BOOL_FIELD(dependsOnRole);
3427 0 : WRITE_BOOL_FIELD(parallelModeOK);
3428 0 : WRITE_BOOL_FIELD(parallelModeNeeded);
3429 0 : WRITE_CHAR_FIELD(maxParallelHazard);
3430 0 : WRITE_UINT64_FIELD(default_pgs_mask);
3431 0 : WRITE_INT_FIELD(extension_state_allocated);
3432 0 : }
3433 :
3434 : static void
3435 0 : _outPlannerInfo(StringInfo str, const PlannerInfo *node)
3436 : {
3437 0 : WRITE_NODE_TYPE("PLANNERINFO");
3438 :
3439 0 : WRITE_NODE_FIELD(parse);
3440 0 : WRITE_NODE_FIELD(glob);
3441 0 : WRITE_UINT_FIELD(query_level);
3442 0 : WRITE_STRING_FIELD(plan_name);
3443 0 : WRITE_STRING_FIELD(alternative_plan_name);
3444 0 : WRITE_NODE_FIELD(plan_params);
3445 0 : WRITE_BITMAPSET_FIELD(outer_params);
3446 0 : WRITE_NODE_ARRAY(simple_rel_array, node->simple_rel_array_size);
3447 0 : WRITE_INT_FIELD(simple_rel_array_size);
3448 0 : WRITE_BITMAPSET_FIELD(all_baserels);
3449 0 : WRITE_BITMAPSET_FIELD(outer_join_rels);
3450 0 : WRITE_BITMAPSET_FIELD(all_query_rels);
3451 0 : WRITE_NODE_FIELD(join_rel_list);
3452 0 : WRITE_INT_FIELD(join_cur_level);
3453 0 : WRITE_NODE_FIELD(init_plans);
3454 0 : WRITE_NODE_FIELD(cte_plan_ids);
3455 0 : WRITE_NODE_FIELD(multiexpr_params);
3456 0 : WRITE_NODE_FIELD(join_domains);
3457 0 : WRITE_NODE_FIELD(eq_classes);
3458 0 : WRITE_BOOL_FIELD(ec_merging_done);
3459 0 : WRITE_NODE_FIELD(canon_pathkeys);
3460 0 : WRITE_NODE_FIELD(left_join_clauses);
3461 0 : WRITE_NODE_FIELD(right_join_clauses);
3462 0 : WRITE_NODE_FIELD(full_join_clauses);
3463 0 : WRITE_NODE_FIELD(join_info_list);
3464 0 : WRITE_INT_FIELD(last_rinfo_serial);
3465 0 : WRITE_BITMAPSET_FIELD(all_result_relids);
3466 0 : WRITE_BITMAPSET_FIELD(leaf_result_relids);
3467 0 : WRITE_NODE_FIELD(append_rel_list);
3468 0 : WRITE_NODE_FIELD(row_identity_vars);
3469 0 : WRITE_NODE_FIELD(rowMarks);
3470 0 : WRITE_NODE_FIELD(placeholder_list);
3471 0 : WRITE_NODE_FIELD(agg_clause_list);
3472 0 : WRITE_NODE_FIELD(group_expr_list);
3473 0 : WRITE_NODE_FIELD(tlist_vars);
3474 0 : WRITE_NODE_FIELD(fkey_list);
3475 0 : WRITE_NODE_FIELD(query_pathkeys);
3476 0 : WRITE_NODE_FIELD(group_pathkeys);
3477 0 : WRITE_INT_FIELD(num_groupby_pathkeys);
3478 0 : WRITE_NODE_FIELD(window_pathkeys);
3479 0 : WRITE_NODE_FIELD(distinct_pathkeys);
3480 0 : WRITE_NODE_FIELD(sort_pathkeys);
3481 0 : WRITE_NODE_FIELD(setop_pathkeys);
3482 0 : WRITE_NODE_FIELD(processed_groupClause);
3483 0 : WRITE_NODE_FIELD(processed_distinctClause);
3484 0 : WRITE_NODE_FIELD(processed_tlist);
3485 0 : WRITE_NODE_FIELD(update_colnos);
3486 0 : WRITE_NODE_FIELD(minmax_aggs);
3487 0 : WRITE_FLOAT_FIELD(total_table_pages);
3488 0 : WRITE_FLOAT_FIELD(tuple_fraction);
3489 0 : WRITE_FLOAT_FIELD(limit_tuples);
3490 0 : WRITE_UINT_FIELD(qual_security_level);
3491 0 : WRITE_BOOL_FIELD(hasJoinRTEs);
3492 0 : WRITE_BOOL_FIELD(hasLateralRTEs);
3493 0 : WRITE_BOOL_FIELD(hasHavingQual);
3494 0 : WRITE_BOOL_FIELD(hasPseudoConstantQuals);
3495 0 : WRITE_BOOL_FIELD(hasAlternativeSubPlans);
3496 0 : WRITE_BOOL_FIELD(placeholdersFrozen);
3497 0 : WRITE_BOOL_FIELD(hasRecursion);
3498 0 : WRITE_BOOL_FIELD(assumeReplanning);
3499 0 : WRITE_INT_FIELD(group_rtindex);
3500 0 : WRITE_NODE_FIELD(agginfos);
3501 0 : WRITE_NODE_FIELD(aggtransinfos);
3502 0 : WRITE_INT_FIELD(numOrderedAggs);
3503 0 : WRITE_BOOL_FIELD(hasNonPartialAggs);
3504 0 : WRITE_BOOL_FIELD(hasNonSerialAggs);
3505 0 : WRITE_INT_FIELD(wt_param_id);
3506 0 : WRITE_NODE_FIELD(non_recursive_path);
3507 0 : WRITE_BITMAPSET_FIELD(curOuterRels);
3508 0 : WRITE_NODE_FIELD(curOuterParams);
3509 0 : WRITE_NODE_FIELD(partPruneInfos);
3510 0 : WRITE_INT_FIELD(extension_state_allocated);
3511 0 : }
3512 :
3513 : static void
3514 0 : _outRelOptInfo(StringInfo str, const RelOptInfo *node)
3515 : {
3516 0 : WRITE_NODE_TYPE("RELOPTINFO");
3517 :
3518 0 : WRITE_ENUM_FIELD(reloptkind, RelOptKind);
3519 0 : WRITE_BITMAPSET_FIELD(relids);
3520 0 : WRITE_FLOAT_FIELD(rows);
3521 0 : WRITE_BOOL_FIELD(consider_startup);
3522 0 : WRITE_BOOL_FIELD(consider_param_startup);
3523 0 : WRITE_BOOL_FIELD(consider_parallel);
3524 0 : WRITE_UINT64_FIELD(pgs_mask);
3525 0 : WRITE_NODE_FIELD(reltarget);
3526 0 : WRITE_NODE_FIELD(pathlist);
3527 0 : WRITE_NODE_FIELD(ppilist);
3528 0 : WRITE_NODE_FIELD(partial_pathlist);
3529 0 : WRITE_NODE_FIELD(cheapest_startup_path);
3530 0 : WRITE_NODE_FIELD(cheapest_total_path);
3531 0 : WRITE_NODE_FIELD(cheapest_parameterized_paths);
3532 0 : WRITE_BITMAPSET_FIELD(direct_lateral_relids);
3533 0 : WRITE_BITMAPSET_FIELD(lateral_relids);
3534 0 : WRITE_UINT_FIELD(relid);
3535 0 : WRITE_OID_FIELD(reltablespace);
3536 0 : WRITE_ENUM_FIELD(rtekind, RTEKind);
3537 0 : WRITE_INT_FIELD(min_attr);
3538 0 : WRITE_INT_FIELD(max_attr);
3539 0 : WRITE_BITMAPSET_FIELD(notnullattnums);
3540 0 : WRITE_BITMAPSET_FIELD(nulling_relids);
3541 0 : WRITE_NODE_FIELD(lateral_vars);
3542 0 : WRITE_BITMAPSET_FIELD(lateral_referencers);
3543 0 : WRITE_NODE_FIELD(indexlist);
3544 0 : WRITE_NODE_FIELD(statlist);
3545 0 : WRITE_UINT_FIELD(pages);
3546 0 : WRITE_FLOAT_FIELD(tuples);
3547 0 : WRITE_FLOAT_FIELD(allvisfrac);
3548 0 : WRITE_BITMAPSET_FIELD(eclass_indexes);
3549 0 : WRITE_NODE_FIELD(subroot);
3550 0 : WRITE_NODE_FIELD(subplan_params);
3551 0 : WRITE_INT_FIELD(rel_parallel_workers);
3552 0 : WRITE_UINT_FIELD(amflags);
3553 0 : WRITE_OID_FIELD(serverid);
3554 0 : WRITE_OID_FIELD(userid);
3555 0 : WRITE_BOOL_FIELD(useridiscurrent);
3556 0 : WRITE_NODE_FIELD(unique_for_rels);
3557 0 : WRITE_NODE_FIELD(non_unique_for_rels);
3558 0 : WRITE_NODE_FIELD(unique_rel);
3559 0 : WRITE_NODE_FIELD(unique_pathkeys);
3560 0 : WRITE_NODE_FIELD(unique_groupclause);
3561 0 : WRITE_NODE_FIELD(baserestrictinfo);
3562 0 : WRITE_FLOAT_FIELD(baserestrictcost.startup);
3563 0 : WRITE_FLOAT_FIELD(baserestrictcost.per_tuple);
3564 0 : WRITE_UINT_FIELD(baserestrict_min_security);
3565 0 : WRITE_NODE_FIELD(joininfo);
3566 0 : WRITE_BOOL_FIELD(has_eclass_joins);
3567 0 : WRITE_BOOL_FIELD(consider_partitionwise_join);
3568 0 : WRITE_NODE_FIELD(agg_info);
3569 0 : WRITE_NODE_FIELD(grouped_rel);
3570 0 : WRITE_BITMAPSET_FIELD(top_parent_relids);
3571 0 : WRITE_INT_FIELD(nparts);
3572 0 : WRITE_BOOL_FIELD(partbounds_merged);
3573 0 : WRITE_NODE_FIELD(partition_qual);
3574 0 : WRITE_BITMAPSET_FIELD(live_parts);
3575 0 : WRITE_BITMAPSET_FIELD(all_partrels);
3576 0 : WRITE_INT_FIELD(extension_state_allocated);
3577 0 : }
3578 :
3579 : static void
3580 0 : _outRelAggInfo(StringInfo str, const RelAggInfo *node)
3581 : {
3582 0 : WRITE_NODE_TYPE("RELAGGINFO");
3583 :
3584 0 : WRITE_NODE_FIELD(target);
3585 0 : WRITE_NODE_FIELD(agg_input);
3586 0 : WRITE_NODE_FIELD(group_clauses);
3587 0 : WRITE_NODE_FIELD(group_exprs);
3588 0 : WRITE_BITMAPSET_FIELD(apply_agg_at);
3589 0 : WRITE_FLOAT_FIELD(grouped_rows);
3590 0 : WRITE_BOOL_FIELD(agg_useful);
3591 0 : }
3592 :
3593 : static void
3594 0 : _outIndexOptInfo(StringInfo str, const IndexOptInfo *node)
3595 : {
3596 0 : WRITE_NODE_TYPE("INDEXOPTINFO");
3597 :
3598 0 : WRITE_OID_FIELD(indexoid);
3599 0 : WRITE_OID_FIELD(reltablespace);
3600 0 : WRITE_UINT_FIELD(pages);
3601 0 : WRITE_FLOAT_FIELD(tuples);
3602 0 : WRITE_INT_FIELD(tree_height);
3603 0 : WRITE_INT_FIELD(ncolumns);
3604 0 : WRITE_INT_FIELD(nkeycolumns);
3605 0 : WRITE_INT_ARRAY(indexkeys, node->ncolumns);
3606 0 : WRITE_OID_ARRAY(indexcollations, node->nkeycolumns);
3607 0 : WRITE_OID_ARRAY(opfamily, node->nkeycolumns);
3608 0 : WRITE_OID_ARRAY(opcintype, node->nkeycolumns);
3609 0 : WRITE_OID_ARRAY(sortopfamily, node->nkeycolumns);
3610 0 : WRITE_BOOL_ARRAY(reverse_sort, node->nkeycolumns);
3611 0 : WRITE_BOOL_ARRAY(nulls_first, node->nkeycolumns);
3612 0 : WRITE_BOOL_ARRAY(canreturn, node->ncolumns);
3613 0 : WRITE_OID_FIELD(relam);
3614 0 : WRITE_NODE_FIELD(indpred);
3615 0 : WRITE_NODE_FIELD(indextlist);
3616 0 : WRITE_NODE_FIELD(indrestrictinfo);
3617 0 : WRITE_BOOL_FIELD(predOK);
3618 0 : WRITE_BOOL_FIELD(unique);
3619 0 : WRITE_BOOL_FIELD(nullsnotdistinct);
3620 0 : WRITE_BOOL_FIELD(immediate);
3621 0 : WRITE_BOOL_FIELD(disabled);
3622 0 : WRITE_BOOL_FIELD(hypothetical);
3623 0 : WRITE_BOOL_FIELD(amcanorderbyop);
3624 0 : WRITE_BOOL_FIELD(amoptionalkey);
3625 0 : WRITE_BOOL_FIELD(amsearcharray);
3626 0 : WRITE_BOOL_FIELD(amsearchnulls);
3627 0 : WRITE_BOOL_FIELD(amhasgettuple);
3628 0 : WRITE_BOOL_FIELD(amhasgetbitmap);
3629 0 : WRITE_BOOL_FIELD(amcanparallel);
3630 0 : WRITE_BOOL_FIELD(amcanmarkpos);
3631 0 : }
3632 :
3633 : static void
3634 0 : _outStatisticExtInfo(StringInfo str, const StatisticExtInfo *node)
3635 : {
3636 0 : WRITE_NODE_TYPE("STATISTICEXTINFO");
3637 :
3638 0 : WRITE_OID_FIELD(statOid);
3639 0 : WRITE_BOOL_FIELD(inherit);
3640 0 : WRITE_CHAR_FIELD(kind);
3641 0 : WRITE_BITMAPSET_FIELD(keys);
3642 0 : WRITE_NODE_FIELD(exprs);
3643 0 : }
3644 :
3645 : static void
3646 0 : _outJoinDomain(StringInfo str, const JoinDomain *node)
3647 : {
3648 0 : WRITE_NODE_TYPE("JOINDOMAIN");
3649 :
3650 0 : WRITE_BITMAPSET_FIELD(jd_relids);
3651 0 : }
3652 :
3653 : static void
3654 0 : _outEquivalenceMember(StringInfo str, const EquivalenceMember *node)
3655 : {
3656 0 : WRITE_NODE_TYPE("EQUIVALENCEMEMBER");
3657 :
3658 0 : WRITE_NODE_FIELD(em_expr);
3659 0 : WRITE_BITMAPSET_FIELD(em_relids);
3660 0 : WRITE_BOOL_FIELD(em_is_const);
3661 0 : WRITE_BOOL_FIELD(em_is_child);
3662 0 : WRITE_OID_FIELD(em_datatype);
3663 0 : WRITE_NODE_FIELD(em_jdomain);
3664 0 : }
3665 :
3666 : static void
3667 0 : _outPathKey(StringInfo str, const PathKey *node)
3668 : {
3669 0 : WRITE_NODE_TYPE("PATHKEY");
3670 :
3671 0 : WRITE_NODE_FIELD(pk_eclass);
3672 0 : WRITE_OID_FIELD(pk_opfamily);
3673 0 : WRITE_ENUM_FIELD(pk_cmptype, CompareType);
3674 0 : WRITE_BOOL_FIELD(pk_nulls_first);
3675 0 : }
3676 :
3677 : static void
3678 0 : _outGroupByOrdering(StringInfo str, const GroupByOrdering *node)
3679 : {
3680 0 : WRITE_NODE_TYPE("GROUPBYORDERING");
3681 :
3682 0 : WRITE_NODE_FIELD(pathkeys);
3683 0 : WRITE_NODE_FIELD(clauses);
3684 0 : }
3685 :
3686 : static void
3687 0 : _outPathTarget(StringInfo str, const PathTarget *node)
3688 : {
3689 0 : WRITE_NODE_TYPE("PATHTARGET");
3690 :
3691 0 : WRITE_NODE_FIELD(exprs);
3692 0 : WRITE_INDEX_ARRAY(sortgrouprefs, list_length(node->exprs));
3693 0 : WRITE_FLOAT_FIELD(cost.startup);
3694 0 : WRITE_FLOAT_FIELD(cost.per_tuple);
3695 0 : WRITE_INT_FIELD(width);
3696 0 : WRITE_ENUM_FIELD(has_volatile_expr, VolatileFunctionStatus);
3697 0 : }
3698 :
3699 : static void
3700 0 : _outParamPathInfo(StringInfo str, const ParamPathInfo *node)
3701 : {
3702 0 : WRITE_NODE_TYPE("PARAMPATHINFO");
3703 :
3704 0 : WRITE_BITMAPSET_FIELD(ppi_req_outer);
3705 0 : WRITE_FLOAT_FIELD(ppi_rows);
3706 0 : WRITE_NODE_FIELD(ppi_clauses);
3707 0 : WRITE_BITMAPSET_FIELD(ppi_serials);
3708 0 : }
3709 :
3710 : static void
3711 0 : _outPath(StringInfo str, const Path *node)
3712 : {
3713 0 : WRITE_NODE_TYPE("PATH");
3714 :
3715 0 : WRITE_ENUM_FIELD(pathtype, NodeTag);
3716 0 : appendStringInfoString(str, " :parent_relids ");
3717 0 : outBitmapset(str, node->parent->relids);
3718 0 : if (node->pathtarget != node->parent->reltarget)
3719 0 : WRITE_NODE_FIELD(pathtarget);
3720 0 : appendStringInfoString(str, " :required_outer ");
3721 0 : if (node->param_info)
3722 0 : outBitmapset(str, node->param_info->ppi_req_outer);
3723 : else
3724 0 : outBitmapset(str, NULL);
3725 0 : WRITE_BOOL_FIELD(parallel_aware);
3726 0 : WRITE_BOOL_FIELD(parallel_safe);
3727 0 : WRITE_INT_FIELD(parallel_workers);
3728 0 : WRITE_FLOAT_FIELD(rows);
3729 0 : WRITE_INT_FIELD(disabled_nodes);
3730 0 : WRITE_FLOAT_FIELD(startup_cost);
3731 0 : WRITE_FLOAT_FIELD(total_cost);
3732 0 : WRITE_NODE_FIELD(pathkeys);
3733 0 : }
3734 :
3735 : static void
3736 0 : _outIndexPath(StringInfo str, const IndexPath *node)
3737 : {
3738 0 : WRITE_NODE_TYPE("INDEXPATH");
3739 :
3740 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
3741 0 : appendStringInfoString(str, " :parent_relids ");
3742 0 : outBitmapset(str, node->path.parent->relids);
3743 0 : if (node->path.pathtarget != node->path.parent->reltarget)
3744 0 : WRITE_NODE_FIELD(path.pathtarget);
3745 0 : appendStringInfoString(str, " :required_outer ");
3746 0 : if (node->path.param_info)
3747 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
3748 : else
3749 0 : outBitmapset(str, NULL);
3750 0 : WRITE_BOOL_FIELD(path.parallel_aware);
3751 0 : WRITE_BOOL_FIELD(path.parallel_safe);
3752 0 : WRITE_INT_FIELD(path.parallel_workers);
3753 0 : WRITE_FLOAT_FIELD(path.rows);
3754 0 : WRITE_INT_FIELD(path.disabled_nodes);
3755 0 : WRITE_FLOAT_FIELD(path.startup_cost);
3756 0 : WRITE_FLOAT_FIELD(path.total_cost);
3757 0 : WRITE_NODE_FIELD(path.pathkeys);
3758 0 : WRITE_NODE_FIELD(indexinfo);
3759 0 : WRITE_NODE_FIELD(indexclauses);
3760 0 : WRITE_NODE_FIELD(indexorderbys);
3761 0 : WRITE_NODE_FIELD(indexorderbycols);
3762 0 : WRITE_ENUM_FIELD(indexscandir, ScanDirection);
3763 0 : WRITE_FLOAT_FIELD(indextotalcost);
3764 0 : WRITE_FLOAT_FIELD(indexselectivity);
3765 0 : }
3766 :
3767 : static void
3768 0 : _outIndexClause(StringInfo str, const IndexClause *node)
3769 : {
3770 0 : WRITE_NODE_TYPE("INDEXCLAUSE");
3771 :
3772 0 : WRITE_NODE_FIELD(rinfo);
3773 0 : WRITE_NODE_FIELD(indexquals);
3774 0 : WRITE_BOOL_FIELD(lossy);
3775 0 : WRITE_INT_FIELD(indexcol);
3776 0 : WRITE_NODE_FIELD(indexcols);
3777 0 : }
3778 :
3779 : static void
3780 0 : _outBitmapHeapPath(StringInfo str, const BitmapHeapPath *node)
3781 : {
3782 0 : WRITE_NODE_TYPE("BITMAPHEAPPATH");
3783 :
3784 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
3785 0 : appendStringInfoString(str, " :parent_relids ");
3786 0 : outBitmapset(str, node->path.parent->relids);
3787 0 : if (node->path.pathtarget != node->path.parent->reltarget)
3788 0 : WRITE_NODE_FIELD(path.pathtarget);
3789 0 : appendStringInfoString(str, " :required_outer ");
3790 0 : if (node->path.param_info)
3791 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
3792 : else
3793 0 : outBitmapset(str, NULL);
3794 0 : WRITE_BOOL_FIELD(path.parallel_aware);
3795 0 : WRITE_BOOL_FIELD(path.parallel_safe);
3796 0 : WRITE_INT_FIELD(path.parallel_workers);
3797 0 : WRITE_FLOAT_FIELD(path.rows);
3798 0 : WRITE_INT_FIELD(path.disabled_nodes);
3799 0 : WRITE_FLOAT_FIELD(path.startup_cost);
3800 0 : WRITE_FLOAT_FIELD(path.total_cost);
3801 0 : WRITE_NODE_FIELD(path.pathkeys);
3802 0 : WRITE_NODE_FIELD(bitmapqual);
3803 0 : }
3804 :
3805 : static void
3806 0 : _outBitmapAndPath(StringInfo str, const BitmapAndPath *node)
3807 : {
3808 0 : WRITE_NODE_TYPE("BITMAPANDPATH");
3809 :
3810 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
3811 0 : appendStringInfoString(str, " :parent_relids ");
3812 0 : outBitmapset(str, node->path.parent->relids);
3813 0 : if (node->path.pathtarget != node->path.parent->reltarget)
3814 0 : WRITE_NODE_FIELD(path.pathtarget);
3815 0 : appendStringInfoString(str, " :required_outer ");
3816 0 : if (node->path.param_info)
3817 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
3818 : else
3819 0 : outBitmapset(str, NULL);
3820 0 : WRITE_BOOL_FIELD(path.parallel_aware);
3821 0 : WRITE_BOOL_FIELD(path.parallel_safe);
3822 0 : WRITE_INT_FIELD(path.parallel_workers);
3823 0 : WRITE_FLOAT_FIELD(path.rows);
3824 0 : WRITE_INT_FIELD(path.disabled_nodes);
3825 0 : WRITE_FLOAT_FIELD(path.startup_cost);
3826 0 : WRITE_FLOAT_FIELD(path.total_cost);
3827 0 : WRITE_NODE_FIELD(path.pathkeys);
3828 0 : WRITE_NODE_FIELD(bitmapquals);
3829 0 : WRITE_FLOAT_FIELD(bitmapselectivity);
3830 0 : }
3831 :
3832 : static void
3833 0 : _outBitmapOrPath(StringInfo str, const BitmapOrPath *node)
3834 : {
3835 0 : WRITE_NODE_TYPE("BITMAPORPATH");
3836 :
3837 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
3838 0 : appendStringInfoString(str, " :parent_relids ");
3839 0 : outBitmapset(str, node->path.parent->relids);
3840 0 : if (node->path.pathtarget != node->path.parent->reltarget)
3841 0 : WRITE_NODE_FIELD(path.pathtarget);
3842 0 : appendStringInfoString(str, " :required_outer ");
3843 0 : if (node->path.param_info)
3844 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
3845 : else
3846 0 : outBitmapset(str, NULL);
3847 0 : WRITE_BOOL_FIELD(path.parallel_aware);
3848 0 : WRITE_BOOL_FIELD(path.parallel_safe);
3849 0 : WRITE_INT_FIELD(path.parallel_workers);
3850 0 : WRITE_FLOAT_FIELD(path.rows);
3851 0 : WRITE_INT_FIELD(path.disabled_nodes);
3852 0 : WRITE_FLOAT_FIELD(path.startup_cost);
3853 0 : WRITE_FLOAT_FIELD(path.total_cost);
3854 0 : WRITE_NODE_FIELD(path.pathkeys);
3855 0 : WRITE_NODE_FIELD(bitmapquals);
3856 0 : WRITE_FLOAT_FIELD(bitmapselectivity);
3857 0 : }
3858 :
3859 : static void
3860 0 : _outTidPath(StringInfo str, const TidPath *node)
3861 : {
3862 0 : WRITE_NODE_TYPE("TIDPATH");
3863 :
3864 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
3865 0 : appendStringInfoString(str, " :parent_relids ");
3866 0 : outBitmapset(str, node->path.parent->relids);
3867 0 : if (node->path.pathtarget != node->path.parent->reltarget)
3868 0 : WRITE_NODE_FIELD(path.pathtarget);
3869 0 : appendStringInfoString(str, " :required_outer ");
3870 0 : if (node->path.param_info)
3871 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
3872 : else
3873 0 : outBitmapset(str, NULL);
3874 0 : WRITE_BOOL_FIELD(path.parallel_aware);
3875 0 : WRITE_BOOL_FIELD(path.parallel_safe);
3876 0 : WRITE_INT_FIELD(path.parallel_workers);
3877 0 : WRITE_FLOAT_FIELD(path.rows);
3878 0 : WRITE_INT_FIELD(path.disabled_nodes);
3879 0 : WRITE_FLOAT_FIELD(path.startup_cost);
3880 0 : WRITE_FLOAT_FIELD(path.total_cost);
3881 0 : WRITE_NODE_FIELD(path.pathkeys);
3882 0 : WRITE_NODE_FIELD(tidquals);
3883 0 : }
3884 :
3885 : static void
3886 0 : _outTidRangePath(StringInfo str, const TidRangePath *node)
3887 : {
3888 0 : WRITE_NODE_TYPE("TIDRANGEPATH");
3889 :
3890 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
3891 0 : appendStringInfoString(str, " :parent_relids ");
3892 0 : outBitmapset(str, node->path.parent->relids);
3893 0 : if (node->path.pathtarget != node->path.parent->reltarget)
3894 0 : WRITE_NODE_FIELD(path.pathtarget);
3895 0 : appendStringInfoString(str, " :required_outer ");
3896 0 : if (node->path.param_info)
3897 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
3898 : else
3899 0 : outBitmapset(str, NULL);
3900 0 : WRITE_BOOL_FIELD(path.parallel_aware);
3901 0 : WRITE_BOOL_FIELD(path.parallel_safe);
3902 0 : WRITE_INT_FIELD(path.parallel_workers);
3903 0 : WRITE_FLOAT_FIELD(path.rows);
3904 0 : WRITE_INT_FIELD(path.disabled_nodes);
3905 0 : WRITE_FLOAT_FIELD(path.startup_cost);
3906 0 : WRITE_FLOAT_FIELD(path.total_cost);
3907 0 : WRITE_NODE_FIELD(path.pathkeys);
3908 0 : WRITE_NODE_FIELD(tidrangequals);
3909 0 : }
3910 :
3911 : static void
3912 0 : _outSubqueryScanPath(StringInfo str, const SubqueryScanPath *node)
3913 : {
3914 0 : WRITE_NODE_TYPE("SUBQUERYSCANPATH");
3915 :
3916 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
3917 0 : appendStringInfoString(str, " :parent_relids ");
3918 0 : outBitmapset(str, node->path.parent->relids);
3919 0 : if (node->path.pathtarget != node->path.parent->reltarget)
3920 0 : WRITE_NODE_FIELD(path.pathtarget);
3921 0 : appendStringInfoString(str, " :required_outer ");
3922 0 : if (node->path.param_info)
3923 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
3924 : else
3925 0 : outBitmapset(str, NULL);
3926 0 : WRITE_BOOL_FIELD(path.parallel_aware);
3927 0 : WRITE_BOOL_FIELD(path.parallel_safe);
3928 0 : WRITE_INT_FIELD(path.parallel_workers);
3929 0 : WRITE_FLOAT_FIELD(path.rows);
3930 0 : WRITE_INT_FIELD(path.disabled_nodes);
3931 0 : WRITE_FLOAT_FIELD(path.startup_cost);
3932 0 : WRITE_FLOAT_FIELD(path.total_cost);
3933 0 : WRITE_NODE_FIELD(path.pathkeys);
3934 0 : WRITE_NODE_FIELD(subpath);
3935 0 : }
3936 :
3937 : static void
3938 0 : _outForeignPath(StringInfo str, const ForeignPath *node)
3939 : {
3940 0 : WRITE_NODE_TYPE("FOREIGNPATH");
3941 :
3942 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
3943 0 : appendStringInfoString(str, " :parent_relids ");
3944 0 : outBitmapset(str, node->path.parent->relids);
3945 0 : if (node->path.pathtarget != node->path.parent->reltarget)
3946 0 : WRITE_NODE_FIELD(path.pathtarget);
3947 0 : appendStringInfoString(str, " :required_outer ");
3948 0 : if (node->path.param_info)
3949 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
3950 : else
3951 0 : outBitmapset(str, NULL);
3952 0 : WRITE_BOOL_FIELD(path.parallel_aware);
3953 0 : WRITE_BOOL_FIELD(path.parallel_safe);
3954 0 : WRITE_INT_FIELD(path.parallel_workers);
3955 0 : WRITE_FLOAT_FIELD(path.rows);
3956 0 : WRITE_INT_FIELD(path.disabled_nodes);
3957 0 : WRITE_FLOAT_FIELD(path.startup_cost);
3958 0 : WRITE_FLOAT_FIELD(path.total_cost);
3959 0 : WRITE_NODE_FIELD(path.pathkeys);
3960 0 : WRITE_NODE_FIELD(fdw_outerpath);
3961 0 : WRITE_NODE_FIELD(fdw_restrictinfo);
3962 0 : WRITE_NODE_FIELD(fdw_private);
3963 0 : }
3964 :
3965 : static void
3966 0 : _outCustomPath(StringInfo str, const CustomPath *node)
3967 : {
3968 0 : WRITE_NODE_TYPE("CUSTOMPATH");
3969 :
3970 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
3971 0 : appendStringInfoString(str, " :parent_relids ");
3972 0 : outBitmapset(str, node->path.parent->relids);
3973 0 : if (node->path.pathtarget != node->path.parent->reltarget)
3974 0 : WRITE_NODE_FIELD(path.pathtarget);
3975 0 : appendStringInfoString(str, " :required_outer ");
3976 0 : if (node->path.param_info)
3977 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
3978 : else
3979 0 : outBitmapset(str, NULL);
3980 0 : WRITE_BOOL_FIELD(path.parallel_aware);
3981 0 : WRITE_BOOL_FIELD(path.parallel_safe);
3982 0 : WRITE_INT_FIELD(path.parallel_workers);
3983 0 : WRITE_FLOAT_FIELD(path.rows);
3984 0 : WRITE_INT_FIELD(path.disabled_nodes);
3985 0 : WRITE_FLOAT_FIELD(path.startup_cost);
3986 0 : WRITE_FLOAT_FIELD(path.total_cost);
3987 0 : WRITE_NODE_FIELD(path.pathkeys);
3988 0 : WRITE_UINT_FIELD(flags);
3989 0 : WRITE_NODE_FIELD(custom_paths);
3990 0 : WRITE_NODE_FIELD(custom_restrictinfo);
3991 0 : WRITE_NODE_FIELD(custom_private);
3992 :
3993 : /* CustomName is a key to lookup CustomScanMethods */
3994 0 : appendStringInfoString(str, " :methods ");
3995 0 : outToken(str, node->methods->CustomName);
3996 0 : }
3997 :
3998 : static void
3999 0 : _outAppendPath(StringInfo str, const AppendPath *node)
4000 : {
4001 0 : WRITE_NODE_TYPE("APPENDPATH");
4002 :
4003 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4004 0 : appendStringInfoString(str, " :parent_relids ");
4005 0 : outBitmapset(str, node->path.parent->relids);
4006 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4007 0 : WRITE_NODE_FIELD(path.pathtarget);
4008 0 : appendStringInfoString(str, " :required_outer ");
4009 0 : if (node->path.param_info)
4010 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4011 : else
4012 0 : outBitmapset(str, NULL);
4013 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4014 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4015 0 : WRITE_INT_FIELD(path.parallel_workers);
4016 0 : WRITE_FLOAT_FIELD(path.rows);
4017 0 : WRITE_INT_FIELD(path.disabled_nodes);
4018 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4019 0 : WRITE_FLOAT_FIELD(path.total_cost);
4020 0 : WRITE_NODE_FIELD(path.pathkeys);
4021 0 : WRITE_NODE_FIELD(subpaths);
4022 0 : WRITE_INT_FIELD(first_partial_path);
4023 0 : WRITE_FLOAT_FIELD(limit_tuples);
4024 0 : WRITE_NODE_FIELD(child_append_relid_sets);
4025 0 : }
4026 :
4027 : static void
4028 0 : _outMergeAppendPath(StringInfo str, const MergeAppendPath *node)
4029 : {
4030 0 : WRITE_NODE_TYPE("MERGEAPPENDPATH");
4031 :
4032 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4033 0 : appendStringInfoString(str, " :parent_relids ");
4034 0 : outBitmapset(str, node->path.parent->relids);
4035 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4036 0 : WRITE_NODE_FIELD(path.pathtarget);
4037 0 : appendStringInfoString(str, " :required_outer ");
4038 0 : if (node->path.param_info)
4039 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4040 : else
4041 0 : outBitmapset(str, NULL);
4042 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4043 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4044 0 : WRITE_INT_FIELD(path.parallel_workers);
4045 0 : WRITE_FLOAT_FIELD(path.rows);
4046 0 : WRITE_INT_FIELD(path.disabled_nodes);
4047 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4048 0 : WRITE_FLOAT_FIELD(path.total_cost);
4049 0 : WRITE_NODE_FIELD(path.pathkeys);
4050 0 : WRITE_NODE_FIELD(subpaths);
4051 0 : WRITE_FLOAT_FIELD(limit_tuples);
4052 0 : WRITE_NODE_FIELD(child_append_relid_sets);
4053 0 : }
4054 :
4055 : static void
4056 0 : _outGroupResultPath(StringInfo str, const GroupResultPath *node)
4057 : {
4058 0 : WRITE_NODE_TYPE("GROUPRESULTPATH");
4059 :
4060 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4061 0 : appendStringInfoString(str, " :parent_relids ");
4062 0 : outBitmapset(str, node->path.parent->relids);
4063 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4064 0 : WRITE_NODE_FIELD(path.pathtarget);
4065 0 : appendStringInfoString(str, " :required_outer ");
4066 0 : if (node->path.param_info)
4067 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4068 : else
4069 0 : outBitmapset(str, NULL);
4070 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4071 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4072 0 : WRITE_INT_FIELD(path.parallel_workers);
4073 0 : WRITE_FLOAT_FIELD(path.rows);
4074 0 : WRITE_INT_FIELD(path.disabled_nodes);
4075 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4076 0 : WRITE_FLOAT_FIELD(path.total_cost);
4077 0 : WRITE_NODE_FIELD(path.pathkeys);
4078 0 : WRITE_NODE_FIELD(quals);
4079 0 : }
4080 :
4081 : static void
4082 0 : _outMaterialPath(StringInfo str, const MaterialPath *node)
4083 : {
4084 0 : WRITE_NODE_TYPE("MATERIALPATH");
4085 :
4086 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4087 0 : appendStringInfoString(str, " :parent_relids ");
4088 0 : outBitmapset(str, node->path.parent->relids);
4089 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4090 0 : WRITE_NODE_FIELD(path.pathtarget);
4091 0 : appendStringInfoString(str, " :required_outer ");
4092 0 : if (node->path.param_info)
4093 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4094 : else
4095 0 : outBitmapset(str, NULL);
4096 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4097 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4098 0 : WRITE_INT_FIELD(path.parallel_workers);
4099 0 : WRITE_FLOAT_FIELD(path.rows);
4100 0 : WRITE_INT_FIELD(path.disabled_nodes);
4101 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4102 0 : WRITE_FLOAT_FIELD(path.total_cost);
4103 0 : WRITE_NODE_FIELD(path.pathkeys);
4104 0 : WRITE_NODE_FIELD(subpath);
4105 0 : }
4106 :
4107 : static void
4108 0 : _outMemoizePath(StringInfo str, const MemoizePath *node)
4109 : {
4110 0 : WRITE_NODE_TYPE("MEMOIZEPATH");
4111 :
4112 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4113 0 : appendStringInfoString(str, " :parent_relids ");
4114 0 : outBitmapset(str, node->path.parent->relids);
4115 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4116 0 : WRITE_NODE_FIELD(path.pathtarget);
4117 0 : appendStringInfoString(str, " :required_outer ");
4118 0 : if (node->path.param_info)
4119 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4120 : else
4121 0 : outBitmapset(str, NULL);
4122 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4123 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4124 0 : WRITE_INT_FIELD(path.parallel_workers);
4125 0 : WRITE_FLOAT_FIELD(path.rows);
4126 0 : WRITE_INT_FIELD(path.disabled_nodes);
4127 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4128 0 : WRITE_FLOAT_FIELD(path.total_cost);
4129 0 : WRITE_NODE_FIELD(path.pathkeys);
4130 0 : WRITE_NODE_FIELD(subpath);
4131 0 : WRITE_NODE_FIELD(hash_operators);
4132 0 : WRITE_NODE_FIELD(param_exprs);
4133 0 : WRITE_BOOL_FIELD(singlerow);
4134 0 : WRITE_BOOL_FIELD(binary_mode);
4135 0 : WRITE_UINT_FIELD(est_entries);
4136 0 : WRITE_FLOAT_FIELD(est_calls);
4137 0 : WRITE_FLOAT_FIELD(est_unique_keys);
4138 0 : WRITE_FLOAT_FIELD(est_hit_ratio);
4139 0 : }
4140 :
4141 : static void
4142 0 : _outGatherPath(StringInfo str, const GatherPath *node)
4143 : {
4144 0 : WRITE_NODE_TYPE("GATHERPATH");
4145 :
4146 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4147 0 : appendStringInfoString(str, " :parent_relids ");
4148 0 : outBitmapset(str, node->path.parent->relids);
4149 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4150 0 : WRITE_NODE_FIELD(path.pathtarget);
4151 0 : appendStringInfoString(str, " :required_outer ");
4152 0 : if (node->path.param_info)
4153 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4154 : else
4155 0 : outBitmapset(str, NULL);
4156 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4157 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4158 0 : WRITE_INT_FIELD(path.parallel_workers);
4159 0 : WRITE_FLOAT_FIELD(path.rows);
4160 0 : WRITE_INT_FIELD(path.disabled_nodes);
4161 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4162 0 : WRITE_FLOAT_FIELD(path.total_cost);
4163 0 : WRITE_NODE_FIELD(path.pathkeys);
4164 0 : WRITE_NODE_FIELD(subpath);
4165 0 : WRITE_BOOL_FIELD(single_copy);
4166 0 : WRITE_INT_FIELD(num_workers);
4167 0 : }
4168 :
4169 : static void
4170 0 : _outGatherMergePath(StringInfo str, const GatherMergePath *node)
4171 : {
4172 0 : WRITE_NODE_TYPE("GATHERMERGEPATH");
4173 :
4174 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4175 0 : appendStringInfoString(str, " :parent_relids ");
4176 0 : outBitmapset(str, node->path.parent->relids);
4177 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4178 0 : WRITE_NODE_FIELD(path.pathtarget);
4179 0 : appendStringInfoString(str, " :required_outer ");
4180 0 : if (node->path.param_info)
4181 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4182 : else
4183 0 : outBitmapset(str, NULL);
4184 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4185 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4186 0 : WRITE_INT_FIELD(path.parallel_workers);
4187 0 : WRITE_FLOAT_FIELD(path.rows);
4188 0 : WRITE_INT_FIELD(path.disabled_nodes);
4189 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4190 0 : WRITE_FLOAT_FIELD(path.total_cost);
4191 0 : WRITE_NODE_FIELD(path.pathkeys);
4192 0 : WRITE_NODE_FIELD(subpath);
4193 0 : WRITE_INT_FIELD(num_workers);
4194 0 : }
4195 :
4196 : static void
4197 0 : _outNestPath(StringInfo str, const NestPath *node)
4198 : {
4199 0 : WRITE_NODE_TYPE("NESTPATH");
4200 :
4201 0 : WRITE_ENUM_FIELD(jpath.path.pathtype, NodeTag);
4202 0 : appendStringInfoString(str, " :parent_relids ");
4203 0 : outBitmapset(str, node->jpath.path.parent->relids);
4204 0 : if (node->jpath.path.pathtarget != node->jpath.path.parent->reltarget)
4205 0 : WRITE_NODE_FIELD(jpath.path.pathtarget);
4206 0 : appendStringInfoString(str, " :required_outer ");
4207 0 : if (node->jpath.path.param_info)
4208 0 : outBitmapset(str, node->jpath.path.param_info->ppi_req_outer);
4209 : else
4210 0 : outBitmapset(str, NULL);
4211 0 : WRITE_BOOL_FIELD(jpath.path.parallel_aware);
4212 0 : WRITE_BOOL_FIELD(jpath.path.parallel_safe);
4213 0 : WRITE_INT_FIELD(jpath.path.parallel_workers);
4214 0 : WRITE_FLOAT_FIELD(jpath.path.rows);
4215 0 : WRITE_INT_FIELD(jpath.path.disabled_nodes);
4216 0 : WRITE_FLOAT_FIELD(jpath.path.startup_cost);
4217 0 : WRITE_FLOAT_FIELD(jpath.path.total_cost);
4218 0 : WRITE_NODE_FIELD(jpath.path.pathkeys);
4219 0 : WRITE_ENUM_FIELD(jpath.jointype, JoinType);
4220 0 : WRITE_BOOL_FIELD(jpath.inner_unique);
4221 0 : WRITE_NODE_FIELD(jpath.outerjoinpath);
4222 0 : WRITE_NODE_FIELD(jpath.innerjoinpath);
4223 0 : WRITE_NODE_FIELD(jpath.joinrestrictinfo);
4224 0 : }
4225 :
4226 : static void
4227 0 : _outMergePath(StringInfo str, const MergePath *node)
4228 : {
4229 0 : WRITE_NODE_TYPE("MERGEPATH");
4230 :
4231 0 : WRITE_ENUM_FIELD(jpath.path.pathtype, NodeTag);
4232 0 : appendStringInfoString(str, " :parent_relids ");
4233 0 : outBitmapset(str, node->jpath.path.parent->relids);
4234 0 : if (node->jpath.path.pathtarget != node->jpath.path.parent->reltarget)
4235 0 : WRITE_NODE_FIELD(jpath.path.pathtarget);
4236 0 : appendStringInfoString(str, " :required_outer ");
4237 0 : if (node->jpath.path.param_info)
4238 0 : outBitmapset(str, node->jpath.path.param_info->ppi_req_outer);
4239 : else
4240 0 : outBitmapset(str, NULL);
4241 0 : WRITE_BOOL_FIELD(jpath.path.parallel_aware);
4242 0 : WRITE_BOOL_FIELD(jpath.path.parallel_safe);
4243 0 : WRITE_INT_FIELD(jpath.path.parallel_workers);
4244 0 : WRITE_FLOAT_FIELD(jpath.path.rows);
4245 0 : WRITE_INT_FIELD(jpath.path.disabled_nodes);
4246 0 : WRITE_FLOAT_FIELD(jpath.path.startup_cost);
4247 0 : WRITE_FLOAT_FIELD(jpath.path.total_cost);
4248 0 : WRITE_NODE_FIELD(jpath.path.pathkeys);
4249 0 : WRITE_ENUM_FIELD(jpath.jointype, JoinType);
4250 0 : WRITE_BOOL_FIELD(jpath.inner_unique);
4251 0 : WRITE_NODE_FIELD(jpath.outerjoinpath);
4252 0 : WRITE_NODE_FIELD(jpath.innerjoinpath);
4253 0 : WRITE_NODE_FIELD(jpath.joinrestrictinfo);
4254 0 : WRITE_NODE_FIELD(path_mergeclauses);
4255 0 : WRITE_NODE_FIELD(outersortkeys);
4256 0 : WRITE_NODE_FIELD(innersortkeys);
4257 0 : WRITE_INT_FIELD(outer_presorted_keys);
4258 0 : WRITE_BOOL_FIELD(skip_mark_restore);
4259 0 : WRITE_BOOL_FIELD(materialize_inner);
4260 0 : }
4261 :
4262 : static void
4263 0 : _outHashPath(StringInfo str, const HashPath *node)
4264 : {
4265 0 : WRITE_NODE_TYPE("HASHPATH");
4266 :
4267 0 : WRITE_ENUM_FIELD(jpath.path.pathtype, NodeTag);
4268 0 : appendStringInfoString(str, " :parent_relids ");
4269 0 : outBitmapset(str, node->jpath.path.parent->relids);
4270 0 : if (node->jpath.path.pathtarget != node->jpath.path.parent->reltarget)
4271 0 : WRITE_NODE_FIELD(jpath.path.pathtarget);
4272 0 : appendStringInfoString(str, " :required_outer ");
4273 0 : if (node->jpath.path.param_info)
4274 0 : outBitmapset(str, node->jpath.path.param_info->ppi_req_outer);
4275 : else
4276 0 : outBitmapset(str, NULL);
4277 0 : WRITE_BOOL_FIELD(jpath.path.parallel_aware);
4278 0 : WRITE_BOOL_FIELD(jpath.path.parallel_safe);
4279 0 : WRITE_INT_FIELD(jpath.path.parallel_workers);
4280 0 : WRITE_FLOAT_FIELD(jpath.path.rows);
4281 0 : WRITE_INT_FIELD(jpath.path.disabled_nodes);
4282 0 : WRITE_FLOAT_FIELD(jpath.path.startup_cost);
4283 0 : WRITE_FLOAT_FIELD(jpath.path.total_cost);
4284 0 : WRITE_NODE_FIELD(jpath.path.pathkeys);
4285 0 : WRITE_ENUM_FIELD(jpath.jointype, JoinType);
4286 0 : WRITE_BOOL_FIELD(jpath.inner_unique);
4287 0 : WRITE_NODE_FIELD(jpath.outerjoinpath);
4288 0 : WRITE_NODE_FIELD(jpath.innerjoinpath);
4289 0 : WRITE_NODE_FIELD(jpath.joinrestrictinfo);
4290 0 : WRITE_NODE_FIELD(path_hashclauses);
4291 0 : WRITE_INT_FIELD(num_batches);
4292 0 : WRITE_FLOAT_FIELD(inner_rows_total);
4293 0 : }
4294 :
4295 : static void
4296 0 : _outProjectionPath(StringInfo str, const ProjectionPath *node)
4297 : {
4298 0 : WRITE_NODE_TYPE("PROJECTIONPATH");
4299 :
4300 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4301 0 : appendStringInfoString(str, " :parent_relids ");
4302 0 : outBitmapset(str, node->path.parent->relids);
4303 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4304 0 : WRITE_NODE_FIELD(path.pathtarget);
4305 0 : appendStringInfoString(str, " :required_outer ");
4306 0 : if (node->path.param_info)
4307 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4308 : else
4309 0 : outBitmapset(str, NULL);
4310 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4311 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4312 0 : WRITE_INT_FIELD(path.parallel_workers);
4313 0 : WRITE_FLOAT_FIELD(path.rows);
4314 0 : WRITE_INT_FIELD(path.disabled_nodes);
4315 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4316 0 : WRITE_FLOAT_FIELD(path.total_cost);
4317 0 : WRITE_NODE_FIELD(path.pathkeys);
4318 0 : WRITE_NODE_FIELD(subpath);
4319 0 : WRITE_BOOL_FIELD(dummypp);
4320 0 : }
4321 :
4322 : static void
4323 0 : _outProjectSetPath(StringInfo str, const ProjectSetPath *node)
4324 : {
4325 0 : WRITE_NODE_TYPE("PROJECTSETPATH");
4326 :
4327 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4328 0 : appendStringInfoString(str, " :parent_relids ");
4329 0 : outBitmapset(str, node->path.parent->relids);
4330 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4331 0 : WRITE_NODE_FIELD(path.pathtarget);
4332 0 : appendStringInfoString(str, " :required_outer ");
4333 0 : if (node->path.param_info)
4334 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4335 : else
4336 0 : outBitmapset(str, NULL);
4337 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4338 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4339 0 : WRITE_INT_FIELD(path.parallel_workers);
4340 0 : WRITE_FLOAT_FIELD(path.rows);
4341 0 : WRITE_INT_FIELD(path.disabled_nodes);
4342 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4343 0 : WRITE_FLOAT_FIELD(path.total_cost);
4344 0 : WRITE_NODE_FIELD(path.pathkeys);
4345 0 : WRITE_NODE_FIELD(subpath);
4346 0 : }
4347 :
4348 : static void
4349 0 : _outSortPath(StringInfo str, const SortPath *node)
4350 : {
4351 0 : WRITE_NODE_TYPE("SORTPATH");
4352 :
4353 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4354 0 : appendStringInfoString(str, " :parent_relids ");
4355 0 : outBitmapset(str, node->path.parent->relids);
4356 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4357 0 : WRITE_NODE_FIELD(path.pathtarget);
4358 0 : appendStringInfoString(str, " :required_outer ");
4359 0 : if (node->path.param_info)
4360 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4361 : else
4362 0 : outBitmapset(str, NULL);
4363 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4364 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4365 0 : WRITE_INT_FIELD(path.parallel_workers);
4366 0 : WRITE_FLOAT_FIELD(path.rows);
4367 0 : WRITE_INT_FIELD(path.disabled_nodes);
4368 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4369 0 : WRITE_FLOAT_FIELD(path.total_cost);
4370 0 : WRITE_NODE_FIELD(path.pathkeys);
4371 0 : WRITE_NODE_FIELD(subpath);
4372 0 : }
4373 :
4374 : static void
4375 0 : _outIncrementalSortPath(StringInfo str, const IncrementalSortPath *node)
4376 : {
4377 0 : WRITE_NODE_TYPE("INCREMENTALSORTPATH");
4378 :
4379 0 : WRITE_ENUM_FIELD(spath.path.pathtype, NodeTag);
4380 0 : appendStringInfoString(str, " :parent_relids ");
4381 0 : outBitmapset(str, node->spath.path.parent->relids);
4382 0 : if (node->spath.path.pathtarget != node->spath.path.parent->reltarget)
4383 0 : WRITE_NODE_FIELD(spath.path.pathtarget);
4384 0 : appendStringInfoString(str, " :required_outer ");
4385 0 : if (node->spath.path.param_info)
4386 0 : outBitmapset(str, node->spath.path.param_info->ppi_req_outer);
4387 : else
4388 0 : outBitmapset(str, NULL);
4389 0 : WRITE_BOOL_FIELD(spath.path.parallel_aware);
4390 0 : WRITE_BOOL_FIELD(spath.path.parallel_safe);
4391 0 : WRITE_INT_FIELD(spath.path.parallel_workers);
4392 0 : WRITE_FLOAT_FIELD(spath.path.rows);
4393 0 : WRITE_INT_FIELD(spath.path.disabled_nodes);
4394 0 : WRITE_FLOAT_FIELD(spath.path.startup_cost);
4395 0 : WRITE_FLOAT_FIELD(spath.path.total_cost);
4396 0 : WRITE_NODE_FIELD(spath.path.pathkeys);
4397 0 : WRITE_NODE_FIELD(spath.subpath);
4398 0 : WRITE_INT_FIELD(nPresortedCols);
4399 0 : }
4400 :
4401 : static void
4402 0 : _outGroupPath(StringInfo str, const GroupPath *node)
4403 : {
4404 0 : WRITE_NODE_TYPE("GROUPPATH");
4405 :
4406 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4407 0 : appendStringInfoString(str, " :parent_relids ");
4408 0 : outBitmapset(str, node->path.parent->relids);
4409 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4410 0 : WRITE_NODE_FIELD(path.pathtarget);
4411 0 : appendStringInfoString(str, " :required_outer ");
4412 0 : if (node->path.param_info)
4413 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4414 : else
4415 0 : outBitmapset(str, NULL);
4416 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4417 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4418 0 : WRITE_INT_FIELD(path.parallel_workers);
4419 0 : WRITE_FLOAT_FIELD(path.rows);
4420 0 : WRITE_INT_FIELD(path.disabled_nodes);
4421 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4422 0 : WRITE_FLOAT_FIELD(path.total_cost);
4423 0 : WRITE_NODE_FIELD(path.pathkeys);
4424 0 : WRITE_NODE_FIELD(subpath);
4425 0 : WRITE_NODE_FIELD(groupClause);
4426 0 : WRITE_NODE_FIELD(qual);
4427 0 : }
4428 :
4429 : static void
4430 0 : _outUniquePath(StringInfo str, const UniquePath *node)
4431 : {
4432 0 : WRITE_NODE_TYPE("UNIQUEPATH");
4433 :
4434 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4435 0 : appendStringInfoString(str, " :parent_relids ");
4436 0 : outBitmapset(str, node->path.parent->relids);
4437 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4438 0 : WRITE_NODE_FIELD(path.pathtarget);
4439 0 : appendStringInfoString(str, " :required_outer ");
4440 0 : if (node->path.param_info)
4441 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4442 : else
4443 0 : outBitmapset(str, NULL);
4444 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4445 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4446 0 : WRITE_INT_FIELD(path.parallel_workers);
4447 0 : WRITE_FLOAT_FIELD(path.rows);
4448 0 : WRITE_INT_FIELD(path.disabled_nodes);
4449 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4450 0 : WRITE_FLOAT_FIELD(path.total_cost);
4451 0 : WRITE_NODE_FIELD(path.pathkeys);
4452 0 : WRITE_NODE_FIELD(subpath);
4453 0 : WRITE_INT_FIELD(numkeys);
4454 0 : }
4455 :
4456 : static void
4457 0 : _outAggPath(StringInfo str, const AggPath *node)
4458 : {
4459 0 : WRITE_NODE_TYPE("AGGPATH");
4460 :
4461 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4462 0 : appendStringInfoString(str, " :parent_relids ");
4463 0 : outBitmapset(str, node->path.parent->relids);
4464 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4465 0 : WRITE_NODE_FIELD(path.pathtarget);
4466 0 : appendStringInfoString(str, " :required_outer ");
4467 0 : if (node->path.param_info)
4468 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4469 : else
4470 0 : outBitmapset(str, NULL);
4471 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4472 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4473 0 : WRITE_INT_FIELD(path.parallel_workers);
4474 0 : WRITE_FLOAT_FIELD(path.rows);
4475 0 : WRITE_INT_FIELD(path.disabled_nodes);
4476 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4477 0 : WRITE_FLOAT_FIELD(path.total_cost);
4478 0 : WRITE_NODE_FIELD(path.pathkeys);
4479 0 : WRITE_NODE_FIELD(subpath);
4480 0 : WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
4481 0 : WRITE_ENUM_FIELD(aggsplit, AggSplit);
4482 0 : WRITE_FLOAT_FIELD(numGroups);
4483 0 : WRITE_UINT64_FIELD(transitionSpace);
4484 0 : WRITE_NODE_FIELD(groupClause);
4485 0 : WRITE_NODE_FIELD(qual);
4486 0 : }
4487 :
4488 : static void
4489 0 : _outGroupingSetData(StringInfo str, const GroupingSetData *node)
4490 : {
4491 0 : WRITE_NODE_TYPE("GROUPINGSETDATA");
4492 :
4493 0 : WRITE_NODE_FIELD(set);
4494 0 : WRITE_FLOAT_FIELD(numGroups);
4495 0 : }
4496 :
4497 : static void
4498 0 : _outRollupData(StringInfo str, const RollupData *node)
4499 : {
4500 0 : WRITE_NODE_TYPE("ROLLUPDATA");
4501 :
4502 0 : WRITE_NODE_FIELD(groupClause);
4503 0 : WRITE_NODE_FIELD(gsets);
4504 0 : WRITE_NODE_FIELD(gsets_data);
4505 0 : WRITE_FLOAT_FIELD(numGroups);
4506 0 : WRITE_BOOL_FIELD(hashable);
4507 0 : WRITE_BOOL_FIELD(is_hashed);
4508 0 : }
4509 :
4510 : static void
4511 0 : _outGroupingSetsPath(StringInfo str, const GroupingSetsPath *node)
4512 : {
4513 0 : WRITE_NODE_TYPE("GROUPINGSETSPATH");
4514 :
4515 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4516 0 : appendStringInfoString(str, " :parent_relids ");
4517 0 : outBitmapset(str, node->path.parent->relids);
4518 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4519 0 : WRITE_NODE_FIELD(path.pathtarget);
4520 0 : appendStringInfoString(str, " :required_outer ");
4521 0 : if (node->path.param_info)
4522 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4523 : else
4524 0 : outBitmapset(str, NULL);
4525 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4526 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4527 0 : WRITE_INT_FIELD(path.parallel_workers);
4528 0 : WRITE_FLOAT_FIELD(path.rows);
4529 0 : WRITE_INT_FIELD(path.disabled_nodes);
4530 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4531 0 : WRITE_FLOAT_FIELD(path.total_cost);
4532 0 : WRITE_NODE_FIELD(path.pathkeys);
4533 0 : WRITE_NODE_FIELD(subpath);
4534 0 : WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
4535 0 : WRITE_NODE_FIELD(rollups);
4536 0 : WRITE_NODE_FIELD(qual);
4537 0 : WRITE_UINT64_FIELD(transitionSpace);
4538 0 : }
4539 :
4540 : static void
4541 0 : _outMinMaxAggPath(StringInfo str, const MinMaxAggPath *node)
4542 : {
4543 0 : WRITE_NODE_TYPE("MINMAXAGGPATH");
4544 :
4545 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4546 0 : appendStringInfoString(str, " :parent_relids ");
4547 0 : outBitmapset(str, node->path.parent->relids);
4548 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4549 0 : WRITE_NODE_FIELD(path.pathtarget);
4550 0 : appendStringInfoString(str, " :required_outer ");
4551 0 : if (node->path.param_info)
4552 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4553 : else
4554 0 : outBitmapset(str, NULL);
4555 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4556 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4557 0 : WRITE_INT_FIELD(path.parallel_workers);
4558 0 : WRITE_FLOAT_FIELD(path.rows);
4559 0 : WRITE_INT_FIELD(path.disabled_nodes);
4560 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4561 0 : WRITE_FLOAT_FIELD(path.total_cost);
4562 0 : WRITE_NODE_FIELD(path.pathkeys);
4563 0 : WRITE_NODE_FIELD(mmaggregates);
4564 0 : WRITE_NODE_FIELD(quals);
4565 0 : }
4566 :
4567 : static void
4568 0 : _outWindowAggPath(StringInfo str, const WindowAggPath *node)
4569 : {
4570 0 : WRITE_NODE_TYPE("WINDOWAGGPATH");
4571 :
4572 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4573 0 : appendStringInfoString(str, " :parent_relids ");
4574 0 : outBitmapset(str, node->path.parent->relids);
4575 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4576 0 : WRITE_NODE_FIELD(path.pathtarget);
4577 0 : appendStringInfoString(str, " :required_outer ");
4578 0 : if (node->path.param_info)
4579 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4580 : else
4581 0 : outBitmapset(str, NULL);
4582 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4583 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4584 0 : WRITE_INT_FIELD(path.parallel_workers);
4585 0 : WRITE_FLOAT_FIELD(path.rows);
4586 0 : WRITE_INT_FIELD(path.disabled_nodes);
4587 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4588 0 : WRITE_FLOAT_FIELD(path.total_cost);
4589 0 : WRITE_NODE_FIELD(path.pathkeys);
4590 0 : WRITE_NODE_FIELD(subpath);
4591 0 : WRITE_NODE_FIELD(winclause);
4592 0 : WRITE_NODE_FIELD(qual);
4593 0 : WRITE_NODE_FIELD(runCondition);
4594 0 : WRITE_BOOL_FIELD(topwindow);
4595 0 : }
4596 :
4597 : static void
4598 0 : _outSetOpPath(StringInfo str, const SetOpPath *node)
4599 : {
4600 0 : WRITE_NODE_TYPE("SETOPPATH");
4601 :
4602 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4603 0 : appendStringInfoString(str, " :parent_relids ");
4604 0 : outBitmapset(str, node->path.parent->relids);
4605 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4606 0 : WRITE_NODE_FIELD(path.pathtarget);
4607 0 : appendStringInfoString(str, " :required_outer ");
4608 0 : if (node->path.param_info)
4609 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4610 : else
4611 0 : outBitmapset(str, NULL);
4612 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4613 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4614 0 : WRITE_INT_FIELD(path.parallel_workers);
4615 0 : WRITE_FLOAT_FIELD(path.rows);
4616 0 : WRITE_INT_FIELD(path.disabled_nodes);
4617 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4618 0 : WRITE_FLOAT_FIELD(path.total_cost);
4619 0 : WRITE_NODE_FIELD(path.pathkeys);
4620 0 : WRITE_NODE_FIELD(leftpath);
4621 0 : WRITE_NODE_FIELD(rightpath);
4622 0 : WRITE_ENUM_FIELD(cmd, SetOpCmd);
4623 0 : WRITE_ENUM_FIELD(strategy, SetOpStrategy);
4624 0 : WRITE_NODE_FIELD(groupList);
4625 0 : WRITE_FLOAT_FIELD(numGroups);
4626 0 : }
4627 :
4628 : static void
4629 0 : _outRecursiveUnionPath(StringInfo str, const RecursiveUnionPath *node)
4630 : {
4631 0 : WRITE_NODE_TYPE("RECURSIVEUNIONPATH");
4632 :
4633 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4634 0 : appendStringInfoString(str, " :parent_relids ");
4635 0 : outBitmapset(str, node->path.parent->relids);
4636 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4637 0 : WRITE_NODE_FIELD(path.pathtarget);
4638 0 : appendStringInfoString(str, " :required_outer ");
4639 0 : if (node->path.param_info)
4640 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4641 : else
4642 0 : outBitmapset(str, NULL);
4643 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4644 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4645 0 : WRITE_INT_FIELD(path.parallel_workers);
4646 0 : WRITE_FLOAT_FIELD(path.rows);
4647 0 : WRITE_INT_FIELD(path.disabled_nodes);
4648 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4649 0 : WRITE_FLOAT_FIELD(path.total_cost);
4650 0 : WRITE_NODE_FIELD(path.pathkeys);
4651 0 : WRITE_NODE_FIELD(leftpath);
4652 0 : WRITE_NODE_FIELD(rightpath);
4653 0 : WRITE_NODE_FIELD(distinctList);
4654 0 : WRITE_INT_FIELD(wtParam);
4655 0 : WRITE_FLOAT_FIELD(numGroups);
4656 0 : }
4657 :
4658 : static void
4659 0 : _outLockRowsPath(StringInfo str, const LockRowsPath *node)
4660 : {
4661 0 : WRITE_NODE_TYPE("LOCKROWSPATH");
4662 :
4663 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4664 0 : appendStringInfoString(str, " :parent_relids ");
4665 0 : outBitmapset(str, node->path.parent->relids);
4666 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4667 0 : WRITE_NODE_FIELD(path.pathtarget);
4668 0 : appendStringInfoString(str, " :required_outer ");
4669 0 : if (node->path.param_info)
4670 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4671 : else
4672 0 : outBitmapset(str, NULL);
4673 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4674 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4675 0 : WRITE_INT_FIELD(path.parallel_workers);
4676 0 : WRITE_FLOAT_FIELD(path.rows);
4677 0 : WRITE_INT_FIELD(path.disabled_nodes);
4678 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4679 0 : WRITE_FLOAT_FIELD(path.total_cost);
4680 0 : WRITE_NODE_FIELD(path.pathkeys);
4681 0 : WRITE_NODE_FIELD(subpath);
4682 0 : WRITE_NODE_FIELD(rowMarks);
4683 0 : WRITE_INT_FIELD(epqParam);
4684 0 : }
4685 :
4686 : static void
4687 0 : _outModifyTablePath(StringInfo str, const ModifyTablePath *node)
4688 : {
4689 0 : WRITE_NODE_TYPE("MODIFYTABLEPATH");
4690 :
4691 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4692 0 : appendStringInfoString(str, " :parent_relids ");
4693 0 : outBitmapset(str, node->path.parent->relids);
4694 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4695 0 : WRITE_NODE_FIELD(path.pathtarget);
4696 0 : appendStringInfoString(str, " :required_outer ");
4697 0 : if (node->path.param_info)
4698 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4699 : else
4700 0 : outBitmapset(str, NULL);
4701 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4702 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4703 0 : WRITE_INT_FIELD(path.parallel_workers);
4704 0 : WRITE_FLOAT_FIELD(path.rows);
4705 0 : WRITE_INT_FIELD(path.disabled_nodes);
4706 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4707 0 : WRITE_FLOAT_FIELD(path.total_cost);
4708 0 : WRITE_NODE_FIELD(path.pathkeys);
4709 0 : WRITE_NODE_FIELD(subpath);
4710 0 : WRITE_ENUM_FIELD(operation, CmdType);
4711 0 : WRITE_BOOL_FIELD(canSetTag);
4712 0 : WRITE_UINT_FIELD(nominalRelation);
4713 0 : WRITE_UINT_FIELD(rootRelation);
4714 0 : WRITE_NODE_FIELD(resultRelations);
4715 0 : WRITE_NODE_FIELD(updateColnosLists);
4716 0 : WRITE_NODE_FIELD(withCheckOptionLists);
4717 0 : WRITE_NODE_FIELD(returningLists);
4718 0 : WRITE_NODE_FIELD(rowMarks);
4719 0 : WRITE_NODE_FIELD(onconflict);
4720 0 : WRITE_NODE_FIELD(forPortionOf);
4721 0 : WRITE_INT_FIELD(epqParam);
4722 0 : WRITE_NODE_FIELD(mergeActionLists);
4723 0 : WRITE_NODE_FIELD(mergeJoinConditions);
4724 0 : }
4725 :
4726 : static void
4727 0 : _outLimitPath(StringInfo str, const LimitPath *node)
4728 : {
4729 0 : WRITE_NODE_TYPE("LIMITPATH");
4730 :
4731 0 : WRITE_ENUM_FIELD(path.pathtype, NodeTag);
4732 0 : appendStringInfoString(str, " :parent_relids ");
4733 0 : outBitmapset(str, node->path.parent->relids);
4734 0 : if (node->path.pathtarget != node->path.parent->reltarget)
4735 0 : WRITE_NODE_FIELD(path.pathtarget);
4736 0 : appendStringInfoString(str, " :required_outer ");
4737 0 : if (node->path.param_info)
4738 0 : outBitmapset(str, node->path.param_info->ppi_req_outer);
4739 : else
4740 0 : outBitmapset(str, NULL);
4741 0 : WRITE_BOOL_FIELD(path.parallel_aware);
4742 0 : WRITE_BOOL_FIELD(path.parallel_safe);
4743 0 : WRITE_INT_FIELD(path.parallel_workers);
4744 0 : WRITE_FLOAT_FIELD(path.rows);
4745 0 : WRITE_INT_FIELD(path.disabled_nodes);
4746 0 : WRITE_FLOAT_FIELD(path.startup_cost);
4747 0 : WRITE_FLOAT_FIELD(path.total_cost);
4748 0 : WRITE_NODE_FIELD(path.pathkeys);
4749 0 : WRITE_NODE_FIELD(subpath);
4750 0 : WRITE_NODE_FIELD(limitOffset);
4751 0 : WRITE_NODE_FIELD(limitCount);
4752 0 : WRITE_ENUM_FIELD(limitOption, LimitOption);
4753 0 : }
4754 :
4755 : static void
4756 0 : _outRestrictInfo(StringInfo str, const RestrictInfo *node)
4757 : {
4758 0 : WRITE_NODE_TYPE("RESTRICTINFO");
4759 :
4760 0 : WRITE_NODE_FIELD(clause);
4761 0 : WRITE_BOOL_FIELD(is_pushed_down);
4762 0 : WRITE_BOOL_FIELD(can_join);
4763 0 : WRITE_BOOL_FIELD(pseudoconstant);
4764 0 : WRITE_BOOL_FIELD(has_clone);
4765 0 : WRITE_BOOL_FIELD(is_clone);
4766 0 : WRITE_BOOL_FIELD(leakproof);
4767 0 : WRITE_ENUM_FIELD(has_volatile, VolatileFunctionStatus);
4768 0 : WRITE_UINT_FIELD(security_level);
4769 0 : WRITE_INT_FIELD(num_base_rels);
4770 0 : WRITE_BITMAPSET_FIELD(clause_relids);
4771 0 : WRITE_BITMAPSET_FIELD(required_relids);
4772 0 : WRITE_BITMAPSET_FIELD(incompatible_relids);
4773 0 : WRITE_BITMAPSET_FIELD(outer_relids);
4774 0 : WRITE_BITMAPSET_FIELD(left_relids);
4775 0 : WRITE_BITMAPSET_FIELD(right_relids);
4776 0 : WRITE_NODE_FIELD(orclause);
4777 0 : WRITE_INT_FIELD(rinfo_serial);
4778 0 : WRITE_FLOAT_FIELD(eval_cost.startup);
4779 0 : WRITE_FLOAT_FIELD(eval_cost.per_tuple);
4780 0 : WRITE_FLOAT_FIELD(norm_selec);
4781 0 : WRITE_FLOAT_FIELD(outer_selec);
4782 0 : WRITE_NODE_FIELD(mergeopfamilies);
4783 0 : WRITE_NODE_FIELD(left_em);
4784 0 : WRITE_NODE_FIELD(right_em);
4785 0 : WRITE_BOOL_FIELD(outer_is_left);
4786 0 : WRITE_OID_FIELD(hashjoinoperator);
4787 0 : WRITE_FLOAT_FIELD(left_bucketsize);
4788 0 : WRITE_FLOAT_FIELD(right_bucketsize);
4789 0 : WRITE_FLOAT_FIELD(left_mcvfreq);
4790 0 : WRITE_FLOAT_FIELD(right_mcvfreq);
4791 0 : WRITE_OID_FIELD(left_hasheqoperator);
4792 0 : WRITE_OID_FIELD(right_hasheqoperator);
4793 0 : }
4794 :
4795 : static void
4796 0 : _outPlaceHolderVar(StringInfo str, const PlaceHolderVar *node)
4797 : {
4798 0 : WRITE_NODE_TYPE("PLACEHOLDERVAR");
4799 :
4800 0 : WRITE_NODE_FIELD(phexpr);
4801 0 : WRITE_BITMAPSET_FIELD(phrels);
4802 0 : WRITE_BITMAPSET_FIELD(phnullingrels);
4803 0 : WRITE_UINT_FIELD(phid);
4804 0 : WRITE_UINT_FIELD(phlevelsup);
4805 0 : }
4806 :
4807 : static void
4808 0 : _outSpecialJoinInfo(StringInfo str, const SpecialJoinInfo *node)
4809 : {
4810 0 : WRITE_NODE_TYPE("SPECIALJOININFO");
4811 :
4812 0 : WRITE_BITMAPSET_FIELD(min_lefthand);
4813 0 : WRITE_BITMAPSET_FIELD(min_righthand);
4814 0 : WRITE_BITMAPSET_FIELD(syn_lefthand);
4815 0 : WRITE_BITMAPSET_FIELD(syn_righthand);
4816 0 : WRITE_ENUM_FIELD(jointype, JoinType);
4817 0 : WRITE_UINT_FIELD(ojrelid);
4818 0 : WRITE_BITMAPSET_FIELD(commute_above_l);
4819 0 : WRITE_BITMAPSET_FIELD(commute_above_r);
4820 0 : WRITE_BITMAPSET_FIELD(commute_below_l);
4821 0 : WRITE_BITMAPSET_FIELD(commute_below_r);
4822 0 : WRITE_BOOL_FIELD(lhs_strict);
4823 0 : WRITE_BOOL_FIELD(semi_can_btree);
4824 0 : WRITE_BOOL_FIELD(semi_can_hash);
4825 0 : WRITE_NODE_FIELD(semi_operators);
4826 0 : WRITE_NODE_FIELD(semi_rhs_exprs);
4827 0 : }
4828 :
4829 : static void
4830 0 : _outOuterJoinClauseInfo(StringInfo str, const OuterJoinClauseInfo *node)
4831 : {
4832 0 : WRITE_NODE_TYPE("OUTERJOINCLAUSEINFO");
4833 :
4834 0 : WRITE_NODE_FIELD(rinfo);
4835 0 : WRITE_NODE_FIELD(sjinfo);
4836 0 : }
4837 :
4838 : static void
4839 40333 : _outAppendRelInfo(StringInfo str, const AppendRelInfo *node)
4840 : {
4841 40333 : WRITE_NODE_TYPE("APPENDRELINFO");
4842 :
4843 40333 : WRITE_UINT_FIELD(parent_relid);
4844 40333 : WRITE_UINT_FIELD(child_relid);
4845 40333 : WRITE_OID_FIELD(parent_reltype);
4846 40333 : WRITE_OID_FIELD(child_reltype);
4847 40333 : WRITE_NODE_FIELD(translated_vars);
4848 40333 : WRITE_INT_FIELD(num_child_cols);
4849 40333 : WRITE_ATTRNUMBER_ARRAY(parent_colnos, node->num_child_cols);
4850 40333 : WRITE_OID_FIELD(parent_reloid);
4851 40333 : }
4852 :
4853 : static void
4854 0 : _outRowIdentityVarInfo(StringInfo str, const RowIdentityVarInfo *node)
4855 : {
4856 0 : WRITE_NODE_TYPE("ROWIDENTITYVARINFO");
4857 :
4858 0 : WRITE_NODE_FIELD(rowidvar);
4859 0 : WRITE_INT_FIELD(rowidwidth);
4860 0 : WRITE_STRING_FIELD(rowidname);
4861 0 : WRITE_BITMAPSET_FIELD(rowidrels);
4862 0 : }
4863 :
4864 : static void
4865 0 : _outPlaceHolderInfo(StringInfo str, const PlaceHolderInfo *node)
4866 : {
4867 0 : WRITE_NODE_TYPE("PLACEHOLDERINFO");
4868 :
4869 0 : WRITE_UINT_FIELD(phid);
4870 0 : WRITE_NODE_FIELD(ph_var);
4871 0 : WRITE_BITMAPSET_FIELD(ph_eval_at);
4872 0 : WRITE_BITMAPSET_FIELD(ph_lateral);
4873 0 : WRITE_BITMAPSET_FIELD(ph_needed);
4874 0 : WRITE_INT_FIELD(ph_width);
4875 0 : }
4876 :
4877 : static void
4878 0 : _outMinMaxAggInfo(StringInfo str, const MinMaxAggInfo *node)
4879 : {
4880 0 : WRITE_NODE_TYPE("MINMAXAGGINFO");
4881 :
4882 0 : WRITE_OID_FIELD(aggfnoid);
4883 0 : WRITE_OID_FIELD(aggsortop);
4884 0 : WRITE_NODE_FIELD(target);
4885 0 : WRITE_NODE_FIELD(path);
4886 0 : WRITE_FLOAT_FIELD(pathcost);
4887 0 : WRITE_NODE_FIELD(param);
4888 0 : }
4889 :
4890 : static void
4891 0 : _outAggClauseInfo(StringInfo str, const AggClauseInfo *node)
4892 : {
4893 0 : WRITE_NODE_TYPE("AGGCLAUSEINFO");
4894 :
4895 0 : WRITE_NODE_FIELD(aggref);
4896 0 : WRITE_BITMAPSET_FIELD(agg_eval_at);
4897 0 : }
4898 :
4899 : static void
4900 0 : _outGroupingExprInfo(StringInfo str, const GroupingExprInfo *node)
4901 : {
4902 0 : WRITE_NODE_TYPE("GROUPINGEXPRINFO");
4903 :
4904 0 : WRITE_NODE_FIELD(expr);
4905 0 : WRITE_UINT_FIELD(sortgroupref);
4906 0 : WRITE_NODE_FIELD(ec);
4907 0 : }
4908 :
4909 : static void
4910 0 : _outPlannerParamItem(StringInfo str, const PlannerParamItem *node)
4911 : {
4912 0 : WRITE_NODE_TYPE("PLANNERPARAMITEM");
4913 :
4914 0 : WRITE_NODE_FIELD(item);
4915 0 : WRITE_INT_FIELD(paramId);
4916 0 : }
4917 :
4918 : static void
4919 0 : _outAggInfo(StringInfo str, const AggInfo *node)
4920 : {
4921 0 : WRITE_NODE_TYPE("AGGINFO");
4922 :
4923 0 : WRITE_NODE_FIELD(aggrefs);
4924 0 : WRITE_INT_FIELD(transno);
4925 0 : WRITE_BOOL_FIELD(shareable);
4926 0 : WRITE_OID_FIELD(finalfn_oid);
4927 0 : }
4928 :
4929 : static void
4930 0 : _outAggTransInfo(StringInfo str, const AggTransInfo *node)
4931 : {
4932 0 : WRITE_NODE_TYPE("AGGTRANSINFO");
4933 :
4934 0 : WRITE_NODE_FIELD(args);
4935 0 : WRITE_NODE_FIELD(aggfilter);
4936 0 : WRITE_OID_FIELD(transfn_oid);
4937 0 : WRITE_OID_FIELD(serialfn_oid);
4938 0 : WRITE_OID_FIELD(deserialfn_oid);
4939 0 : WRITE_OID_FIELD(combinefn_oid);
4940 0 : WRITE_OID_FIELD(aggtranstype);
4941 0 : WRITE_INT_FIELD(aggtranstypmod);
4942 0 : WRITE_INT_FIELD(transtypeLen);
4943 0 : WRITE_BOOL_FIELD(transtypeByVal);
4944 0 : WRITE_INT_FIELD(aggtransspace);
4945 0 : WRITE_BOOL_FIELD(initValueIsNull);
4946 0 : }
4947 :
4948 : static void
4949 0 : _outUniqueRelInfo(StringInfo str, const UniqueRelInfo *node)
4950 : {
4951 0 : WRITE_NODE_TYPE("UNIQUERELINFO");
4952 :
4953 0 : WRITE_BITMAPSET_FIELD(outerrelids);
4954 0 : WRITE_BOOL_FIELD(self_join);
4955 0 : WRITE_NODE_FIELD(extra_clauses);
4956 0 : }
4957 :
4958 : static void
4959 291805 : _outPlannedStmt(StringInfo str, const PlannedStmt *node)
4960 : {
4961 291805 : WRITE_NODE_TYPE("PLANNEDSTMT");
4962 :
4963 291805 : WRITE_ENUM_FIELD(commandType, CmdType);
4964 291805 : WRITE_INT64_FIELD(queryId);
4965 291805 : WRITE_INT64_FIELD(planId);
4966 291805 : WRITE_ENUM_FIELD(planOrigin, PlannedStmtOrigin);
4967 291805 : WRITE_BOOL_FIELD(hasReturning);
4968 291805 : WRITE_BOOL_FIELD(hasModifyingCTE);
4969 291805 : WRITE_BOOL_FIELD(canSetTag);
4970 291805 : WRITE_BOOL_FIELD(transientPlan);
4971 291805 : WRITE_BOOL_FIELD(dependsOnRole);
4972 291805 : WRITE_BOOL_FIELD(parallelModeNeeded);
4973 291805 : WRITE_INT_FIELD(jitFlags);
4974 291805 : WRITE_NODE_FIELD(planTree);
4975 291805 : WRITE_NODE_FIELD(partPruneInfos);
4976 291805 : WRITE_NODE_FIELD(rtable);
4977 291805 : WRITE_BITMAPSET_FIELD(unprunableRelids);
4978 291805 : WRITE_NODE_FIELD(permInfos);
4979 291805 : WRITE_BITMAPSET_FIELD(resultRelationRelids);
4980 291805 : WRITE_NODE_FIELD(appendRelations);
4981 291805 : WRITE_NODE_FIELD(subplans);
4982 291805 : WRITE_NODE_FIELD(subrtinfos);
4983 291805 : WRITE_BITMAPSET_FIELD(rewindPlanIDs);
4984 291805 : WRITE_NODE_FIELD(rowMarks);
4985 291805 : WRITE_BITMAPSET_FIELD(rowMarkRelids);
4986 291805 : WRITE_NODE_FIELD(relationOids);
4987 291805 : WRITE_NODE_FIELD(invalItems);
4988 291805 : WRITE_NODE_FIELD(paramExecTypes);
4989 291805 : WRITE_NODE_FIELD(utilityStmt);
4990 291805 : WRITE_NODE_FIELD(elidedNodes);
4991 291805 : WRITE_NODE_FIELD(extension_state);
4992 291805 : WRITE_LOCATION_FIELD(stmt_location);
4993 291805 : WRITE_LOCATION_FIELD(stmt_len);
4994 291805 : }
4995 :
4996 : static void
4997 135069 : _outResult(StringInfo str, const Result *node)
4998 : {
4999 135069 : WRITE_NODE_TYPE("RESULT");
5000 :
5001 135069 : WRITE_INT_FIELD(plan.disabled_nodes);
5002 135069 : WRITE_FLOAT_FIELD(plan.startup_cost);
5003 135069 : WRITE_FLOAT_FIELD(plan.total_cost);
5004 135069 : WRITE_FLOAT_FIELD(plan.plan_rows);
5005 135069 : WRITE_INT_FIELD(plan.plan_width);
5006 135069 : WRITE_BOOL_FIELD(plan.parallel_aware);
5007 135069 : WRITE_BOOL_FIELD(plan.parallel_safe);
5008 135069 : WRITE_BOOL_FIELD(plan.async_capable);
5009 135069 : WRITE_INT_FIELD(plan.plan_node_id);
5010 135069 : WRITE_NODE_FIELD(plan.targetlist);
5011 135069 : WRITE_NODE_FIELD(plan.qual);
5012 135069 : WRITE_NODE_FIELD(plan.lefttree);
5013 135069 : WRITE_NODE_FIELD(plan.righttree);
5014 135069 : WRITE_NODE_FIELD(plan.initPlan);
5015 135069 : WRITE_BITMAPSET_FIELD(plan.extParam);
5016 135069 : WRITE_BITMAPSET_FIELD(plan.allParam);
5017 135069 : WRITE_ENUM_FIELD(result_type, ResultType);
5018 135069 : WRITE_NODE_FIELD(resconstantqual);
5019 135069 : WRITE_BITMAPSET_FIELD(relids);
5020 135069 : }
5021 :
5022 : static void
5023 8646 : _outProjectSet(StringInfo str, const ProjectSet *node)
5024 : {
5025 8646 : WRITE_NODE_TYPE("PROJECTSET");
5026 :
5027 8646 : WRITE_INT_FIELD(plan.disabled_nodes);
5028 8646 : WRITE_FLOAT_FIELD(plan.startup_cost);
5029 8646 : WRITE_FLOAT_FIELD(plan.total_cost);
5030 8646 : WRITE_FLOAT_FIELD(plan.plan_rows);
5031 8646 : WRITE_INT_FIELD(plan.plan_width);
5032 8646 : WRITE_BOOL_FIELD(plan.parallel_aware);
5033 8646 : WRITE_BOOL_FIELD(plan.parallel_safe);
5034 8646 : WRITE_BOOL_FIELD(plan.async_capable);
5035 8646 : WRITE_INT_FIELD(plan.plan_node_id);
5036 8646 : WRITE_NODE_FIELD(plan.targetlist);
5037 8646 : WRITE_NODE_FIELD(plan.qual);
5038 8646 : WRITE_NODE_FIELD(plan.lefttree);
5039 8646 : WRITE_NODE_FIELD(plan.righttree);
5040 8646 : WRITE_NODE_FIELD(plan.initPlan);
5041 8646 : WRITE_BITMAPSET_FIELD(plan.extParam);
5042 8646 : WRITE_BITMAPSET_FIELD(plan.allParam);
5043 8646 : }
5044 :
5045 : static void
5046 57428 : _outModifyTable(StringInfo str, const ModifyTable *node)
5047 : {
5048 57428 : WRITE_NODE_TYPE("MODIFYTABLE");
5049 :
5050 57428 : WRITE_INT_FIELD(plan.disabled_nodes);
5051 57428 : WRITE_FLOAT_FIELD(plan.startup_cost);
5052 57428 : WRITE_FLOAT_FIELD(plan.total_cost);
5053 57428 : WRITE_FLOAT_FIELD(plan.plan_rows);
5054 57428 : WRITE_INT_FIELD(plan.plan_width);
5055 57428 : WRITE_BOOL_FIELD(plan.parallel_aware);
5056 57428 : WRITE_BOOL_FIELD(plan.parallel_safe);
5057 57428 : WRITE_BOOL_FIELD(plan.async_capable);
5058 57428 : WRITE_INT_FIELD(plan.plan_node_id);
5059 57428 : WRITE_NODE_FIELD(plan.targetlist);
5060 57428 : WRITE_NODE_FIELD(plan.qual);
5061 57428 : WRITE_NODE_FIELD(plan.lefttree);
5062 57428 : WRITE_NODE_FIELD(plan.righttree);
5063 57428 : WRITE_NODE_FIELD(plan.initPlan);
5064 57428 : WRITE_BITMAPSET_FIELD(plan.extParam);
5065 57428 : WRITE_BITMAPSET_FIELD(plan.allParam);
5066 57428 : WRITE_ENUM_FIELD(operation, CmdType);
5067 57428 : WRITE_BOOL_FIELD(canSetTag);
5068 57428 : WRITE_UINT_FIELD(nominalRelation);
5069 57428 : WRITE_UINT_FIELD(rootRelation);
5070 57428 : WRITE_NODE_FIELD(resultRelations);
5071 57428 : WRITE_NODE_FIELD(updateColnosLists);
5072 57428 : WRITE_NODE_FIELD(withCheckOptionLists);
5073 57428 : WRITE_STRING_FIELD(returningOldAlias);
5074 57428 : WRITE_STRING_FIELD(returningNewAlias);
5075 57428 : WRITE_NODE_FIELD(returningLists);
5076 57428 : WRITE_NODE_FIELD(fdwPrivLists);
5077 57428 : WRITE_BITMAPSET_FIELD(fdwDirectModifyPlans);
5078 57428 : WRITE_NODE_FIELD(rowMarks);
5079 57428 : WRITE_INT_FIELD(epqParam);
5080 57428 : WRITE_ENUM_FIELD(onConflictAction, OnConflictAction);
5081 57428 : WRITE_NODE_FIELD(arbiterIndexes);
5082 57428 : WRITE_ENUM_FIELD(onConflictLockStrength, LockClauseStrength);
5083 57428 : WRITE_NODE_FIELD(onConflictSet);
5084 57428 : WRITE_NODE_FIELD(onConflictCols);
5085 57428 : WRITE_NODE_FIELD(onConflictWhere);
5086 57428 : WRITE_NODE_FIELD(forPortionOf);
5087 57428 : WRITE_UINT_FIELD(exclRelRTI);
5088 57428 : WRITE_NODE_FIELD(exclRelTlist);
5089 57428 : WRITE_NODE_FIELD(mergeActionLists);
5090 57428 : WRITE_NODE_FIELD(mergeJoinConditions);
5091 57428 : }
5092 :
5093 : static void
5094 12400 : _outAppend(StringInfo str, const Append *node)
5095 : {
5096 12400 : WRITE_NODE_TYPE("APPEND");
5097 :
5098 12400 : WRITE_INT_FIELD(plan.disabled_nodes);
5099 12400 : WRITE_FLOAT_FIELD(plan.startup_cost);
5100 12400 : WRITE_FLOAT_FIELD(plan.total_cost);
5101 12400 : WRITE_FLOAT_FIELD(plan.plan_rows);
5102 12400 : WRITE_INT_FIELD(plan.plan_width);
5103 12400 : WRITE_BOOL_FIELD(plan.parallel_aware);
5104 12400 : WRITE_BOOL_FIELD(plan.parallel_safe);
5105 12400 : WRITE_BOOL_FIELD(plan.async_capable);
5106 12400 : WRITE_INT_FIELD(plan.plan_node_id);
5107 12400 : WRITE_NODE_FIELD(plan.targetlist);
5108 12400 : WRITE_NODE_FIELD(plan.qual);
5109 12400 : WRITE_NODE_FIELD(plan.lefttree);
5110 12400 : WRITE_NODE_FIELD(plan.righttree);
5111 12400 : WRITE_NODE_FIELD(plan.initPlan);
5112 12400 : WRITE_BITMAPSET_FIELD(plan.extParam);
5113 12400 : WRITE_BITMAPSET_FIELD(plan.allParam);
5114 12400 : WRITE_BITMAPSET_FIELD(apprelids);
5115 12400 : WRITE_NODE_FIELD(child_append_relid_sets);
5116 12400 : WRITE_NODE_FIELD(appendplans);
5117 12400 : WRITE_INT_FIELD(nasyncplans);
5118 12400 : WRITE_INT_FIELD(first_partial_plan);
5119 12400 : WRITE_INT_FIELD(part_prune_index);
5120 12400 : }
5121 :
5122 : static void
5123 386 : _outMergeAppend(StringInfo str, const MergeAppend *node)
5124 : {
5125 386 : WRITE_NODE_TYPE("MERGEAPPEND");
5126 :
5127 386 : WRITE_INT_FIELD(plan.disabled_nodes);
5128 386 : WRITE_FLOAT_FIELD(plan.startup_cost);
5129 386 : WRITE_FLOAT_FIELD(plan.total_cost);
5130 386 : WRITE_FLOAT_FIELD(plan.plan_rows);
5131 386 : WRITE_INT_FIELD(plan.plan_width);
5132 386 : WRITE_BOOL_FIELD(plan.parallel_aware);
5133 386 : WRITE_BOOL_FIELD(plan.parallel_safe);
5134 386 : WRITE_BOOL_FIELD(plan.async_capable);
5135 386 : WRITE_INT_FIELD(plan.plan_node_id);
5136 386 : WRITE_NODE_FIELD(plan.targetlist);
5137 386 : WRITE_NODE_FIELD(plan.qual);
5138 386 : WRITE_NODE_FIELD(plan.lefttree);
5139 386 : WRITE_NODE_FIELD(plan.righttree);
5140 386 : WRITE_NODE_FIELD(plan.initPlan);
5141 386 : WRITE_BITMAPSET_FIELD(plan.extParam);
5142 386 : WRITE_BITMAPSET_FIELD(plan.allParam);
5143 386 : WRITE_BITMAPSET_FIELD(apprelids);
5144 386 : WRITE_NODE_FIELD(child_append_relid_sets);
5145 386 : WRITE_NODE_FIELD(mergeplans);
5146 386 : WRITE_INT_FIELD(numCols);
5147 386 : WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
5148 386 : WRITE_OID_ARRAY(sortOperators, node->numCols);
5149 386 : WRITE_OID_ARRAY(collations, node->numCols);
5150 386 : WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
5151 386 : WRITE_INT_FIELD(part_prune_index);
5152 386 : }
5153 :
5154 : static void
5155 615 : _outRecursiveUnion(StringInfo str, const RecursiveUnion *node)
5156 : {
5157 615 : WRITE_NODE_TYPE("RECURSIVEUNION");
5158 :
5159 615 : WRITE_INT_FIELD(plan.disabled_nodes);
5160 615 : WRITE_FLOAT_FIELD(plan.startup_cost);
5161 615 : WRITE_FLOAT_FIELD(plan.total_cost);
5162 615 : WRITE_FLOAT_FIELD(plan.plan_rows);
5163 615 : WRITE_INT_FIELD(plan.plan_width);
5164 615 : WRITE_BOOL_FIELD(plan.parallel_aware);
5165 615 : WRITE_BOOL_FIELD(plan.parallel_safe);
5166 615 : WRITE_BOOL_FIELD(plan.async_capable);
5167 615 : WRITE_INT_FIELD(plan.plan_node_id);
5168 615 : WRITE_NODE_FIELD(plan.targetlist);
5169 615 : WRITE_NODE_FIELD(plan.qual);
5170 615 : WRITE_NODE_FIELD(plan.lefttree);
5171 615 : WRITE_NODE_FIELD(plan.righttree);
5172 615 : WRITE_NODE_FIELD(plan.initPlan);
5173 615 : WRITE_BITMAPSET_FIELD(plan.extParam);
5174 615 : WRITE_BITMAPSET_FIELD(plan.allParam);
5175 615 : WRITE_INT_FIELD(wtParam);
5176 615 : WRITE_INT_FIELD(numCols);
5177 615 : WRITE_ATTRNUMBER_ARRAY(dupColIdx, node->numCols);
5178 615 : WRITE_OID_ARRAY(dupOperators, node->numCols);
5179 615 : WRITE_OID_ARRAY(dupCollations, node->numCols);
5180 615 : WRITE_FLOAT_FIELD(numGroups);
5181 615 : }
5182 :
5183 : static void
5184 146 : _outBitmapAnd(StringInfo str, const BitmapAnd *node)
5185 : {
5186 146 : WRITE_NODE_TYPE("BITMAPAND");
5187 :
5188 146 : WRITE_INT_FIELD(plan.disabled_nodes);
5189 146 : WRITE_FLOAT_FIELD(plan.startup_cost);
5190 146 : WRITE_FLOAT_FIELD(plan.total_cost);
5191 146 : WRITE_FLOAT_FIELD(plan.plan_rows);
5192 146 : WRITE_INT_FIELD(plan.plan_width);
5193 146 : WRITE_BOOL_FIELD(plan.parallel_aware);
5194 146 : WRITE_BOOL_FIELD(plan.parallel_safe);
5195 146 : WRITE_BOOL_FIELD(plan.async_capable);
5196 146 : WRITE_INT_FIELD(plan.plan_node_id);
5197 146 : WRITE_NODE_FIELD(plan.targetlist);
5198 146 : WRITE_NODE_FIELD(plan.qual);
5199 146 : WRITE_NODE_FIELD(plan.lefttree);
5200 146 : WRITE_NODE_FIELD(plan.righttree);
5201 146 : WRITE_NODE_FIELD(plan.initPlan);
5202 146 : WRITE_BITMAPSET_FIELD(plan.extParam);
5203 146 : WRITE_BITMAPSET_FIELD(plan.allParam);
5204 146 : WRITE_NODE_FIELD(bitmapplans);
5205 146 : }
5206 :
5207 : static void
5208 254 : _outBitmapOr(StringInfo str, const BitmapOr *node)
5209 : {
5210 254 : WRITE_NODE_TYPE("BITMAPOR");
5211 :
5212 254 : WRITE_INT_FIELD(plan.disabled_nodes);
5213 254 : WRITE_FLOAT_FIELD(plan.startup_cost);
5214 254 : WRITE_FLOAT_FIELD(plan.total_cost);
5215 254 : WRITE_FLOAT_FIELD(plan.plan_rows);
5216 254 : WRITE_INT_FIELD(plan.plan_width);
5217 254 : WRITE_BOOL_FIELD(plan.parallel_aware);
5218 254 : WRITE_BOOL_FIELD(plan.parallel_safe);
5219 254 : WRITE_BOOL_FIELD(plan.async_capable);
5220 254 : WRITE_INT_FIELD(plan.plan_node_id);
5221 254 : WRITE_NODE_FIELD(plan.targetlist);
5222 254 : WRITE_NODE_FIELD(plan.qual);
5223 254 : WRITE_NODE_FIELD(plan.lefttree);
5224 254 : WRITE_NODE_FIELD(plan.righttree);
5225 254 : WRITE_NODE_FIELD(plan.initPlan);
5226 254 : WRITE_BITMAPSET_FIELD(plan.extParam);
5227 254 : WRITE_BITMAPSET_FIELD(plan.allParam);
5228 254 : WRITE_BOOL_FIELD(isshared);
5229 254 : WRITE_NODE_FIELD(bitmapplans);
5230 254 : }
5231 :
5232 : static void
5233 158291 : _outSeqScan(StringInfo str, const SeqScan *node)
5234 : {
5235 158291 : WRITE_NODE_TYPE("SEQSCAN");
5236 :
5237 158291 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5238 158291 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5239 158291 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5240 158291 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5241 158291 : WRITE_INT_FIELD(scan.plan.plan_width);
5242 158291 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5243 158291 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5244 158291 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5245 158291 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5246 158291 : WRITE_NODE_FIELD(scan.plan.targetlist);
5247 158291 : WRITE_NODE_FIELD(scan.plan.qual);
5248 158291 : WRITE_NODE_FIELD(scan.plan.lefttree);
5249 158291 : WRITE_NODE_FIELD(scan.plan.righttree);
5250 158291 : WRITE_NODE_FIELD(scan.plan.initPlan);
5251 158291 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5252 158291 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5253 158291 : WRITE_UINT_FIELD(scan.scanrelid);
5254 158291 : }
5255 :
5256 : static void
5257 200 : _outSampleScan(StringInfo str, const SampleScan *node)
5258 : {
5259 200 : WRITE_NODE_TYPE("SAMPLESCAN");
5260 :
5261 200 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5262 200 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5263 200 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5264 200 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5265 200 : WRITE_INT_FIELD(scan.plan.plan_width);
5266 200 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5267 200 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5268 200 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5269 200 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5270 200 : WRITE_NODE_FIELD(scan.plan.targetlist);
5271 200 : WRITE_NODE_FIELD(scan.plan.qual);
5272 200 : WRITE_NODE_FIELD(scan.plan.lefttree);
5273 200 : WRITE_NODE_FIELD(scan.plan.righttree);
5274 200 : WRITE_NODE_FIELD(scan.plan.initPlan);
5275 200 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5276 200 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5277 200 : WRITE_UINT_FIELD(scan.scanrelid);
5278 200 : WRITE_NODE_FIELD(tablesample);
5279 200 : }
5280 :
5281 : static void
5282 89240 : _outIndexScan(StringInfo str, const IndexScan *node)
5283 : {
5284 89240 : WRITE_NODE_TYPE("INDEXSCAN");
5285 :
5286 89240 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5287 89240 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5288 89240 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5289 89240 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5290 89240 : WRITE_INT_FIELD(scan.plan.plan_width);
5291 89240 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5292 89240 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5293 89240 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5294 89240 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5295 89240 : WRITE_NODE_FIELD(scan.plan.targetlist);
5296 89240 : WRITE_NODE_FIELD(scan.plan.qual);
5297 89240 : WRITE_NODE_FIELD(scan.plan.lefttree);
5298 89240 : WRITE_NODE_FIELD(scan.plan.righttree);
5299 89240 : WRITE_NODE_FIELD(scan.plan.initPlan);
5300 89240 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5301 89240 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5302 89240 : WRITE_UINT_FIELD(scan.scanrelid);
5303 89240 : WRITE_OID_FIELD(indexid);
5304 89240 : WRITE_NODE_FIELD(indexqual);
5305 89240 : WRITE_NODE_FIELD(indexqualorig);
5306 89240 : WRITE_NODE_FIELD(indexorderby);
5307 89240 : WRITE_NODE_FIELD(indexorderbyorig);
5308 89240 : WRITE_NODE_FIELD(indexorderbyops);
5309 89240 : WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
5310 89240 : }
5311 :
5312 : static void
5313 11918 : _outIndexOnlyScan(StringInfo str, const IndexOnlyScan *node)
5314 : {
5315 11918 : WRITE_NODE_TYPE("INDEXONLYSCAN");
5316 :
5317 11918 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5318 11918 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5319 11918 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5320 11918 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5321 11918 : WRITE_INT_FIELD(scan.plan.plan_width);
5322 11918 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5323 11918 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5324 11918 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5325 11918 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5326 11918 : WRITE_NODE_FIELD(scan.plan.targetlist);
5327 11918 : WRITE_NODE_FIELD(scan.plan.qual);
5328 11918 : WRITE_NODE_FIELD(scan.plan.lefttree);
5329 11918 : WRITE_NODE_FIELD(scan.plan.righttree);
5330 11918 : WRITE_NODE_FIELD(scan.plan.initPlan);
5331 11918 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5332 11918 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5333 11918 : WRITE_UINT_FIELD(scan.scanrelid);
5334 11918 : WRITE_OID_FIELD(indexid);
5335 11918 : WRITE_NODE_FIELD(indexqual);
5336 11918 : WRITE_NODE_FIELD(recheckqual);
5337 11918 : WRITE_NODE_FIELD(indexorderby);
5338 11918 : WRITE_NODE_FIELD(indextlist);
5339 11918 : WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
5340 11918 : }
5341 :
5342 : static void
5343 17055 : _outBitmapIndexScan(StringInfo str, const BitmapIndexScan *node)
5344 : {
5345 17055 : WRITE_NODE_TYPE("BITMAPINDEXSCAN");
5346 :
5347 17055 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5348 17055 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5349 17055 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5350 17055 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5351 17055 : WRITE_INT_FIELD(scan.plan.plan_width);
5352 17055 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5353 17055 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5354 17055 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5355 17055 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5356 17055 : WRITE_NODE_FIELD(scan.plan.targetlist);
5357 17055 : WRITE_NODE_FIELD(scan.plan.qual);
5358 17055 : WRITE_NODE_FIELD(scan.plan.lefttree);
5359 17055 : WRITE_NODE_FIELD(scan.plan.righttree);
5360 17055 : WRITE_NODE_FIELD(scan.plan.initPlan);
5361 17055 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5362 17055 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5363 17055 : WRITE_UINT_FIELD(scan.scanrelid);
5364 17055 : WRITE_OID_FIELD(indexid);
5365 17055 : WRITE_BOOL_FIELD(isshared);
5366 17055 : WRITE_NODE_FIELD(indexqual);
5367 17055 : WRITE_NODE_FIELD(indexqualorig);
5368 17055 : }
5369 :
5370 : static void
5371 16651 : _outBitmapHeapScan(StringInfo str, const BitmapHeapScan *node)
5372 : {
5373 16651 : WRITE_NODE_TYPE("BITMAPHEAPSCAN");
5374 :
5375 16651 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5376 16651 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5377 16651 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5378 16651 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5379 16651 : WRITE_INT_FIELD(scan.plan.plan_width);
5380 16651 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5381 16651 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5382 16651 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5383 16651 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5384 16651 : WRITE_NODE_FIELD(scan.plan.targetlist);
5385 16651 : WRITE_NODE_FIELD(scan.plan.qual);
5386 16651 : WRITE_NODE_FIELD(scan.plan.lefttree);
5387 16651 : WRITE_NODE_FIELD(scan.plan.righttree);
5388 16651 : WRITE_NODE_FIELD(scan.plan.initPlan);
5389 16651 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5390 16651 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5391 16651 : WRITE_UINT_FIELD(scan.scanrelid);
5392 16651 : WRITE_NODE_FIELD(bitmapqualorig);
5393 16651 : }
5394 :
5395 : static void
5396 471 : _outTidScan(StringInfo str, const TidScan *node)
5397 : {
5398 471 : WRITE_NODE_TYPE("TIDSCAN");
5399 :
5400 471 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5401 471 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5402 471 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5403 471 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5404 471 : WRITE_INT_FIELD(scan.plan.plan_width);
5405 471 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5406 471 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5407 471 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5408 471 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5409 471 : WRITE_NODE_FIELD(scan.plan.targetlist);
5410 471 : WRITE_NODE_FIELD(scan.plan.qual);
5411 471 : WRITE_NODE_FIELD(scan.plan.lefttree);
5412 471 : WRITE_NODE_FIELD(scan.plan.righttree);
5413 471 : WRITE_NODE_FIELD(scan.plan.initPlan);
5414 471 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5415 471 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5416 471 : WRITE_UINT_FIELD(scan.scanrelid);
5417 471 : WRITE_NODE_FIELD(tidquals);
5418 471 : }
5419 :
5420 : static void
5421 1348 : _outTidRangeScan(StringInfo str, const TidRangeScan *node)
5422 : {
5423 1348 : WRITE_NODE_TYPE("TIDRANGESCAN");
5424 :
5425 1348 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5426 1348 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5427 1348 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5428 1348 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5429 1348 : WRITE_INT_FIELD(scan.plan.plan_width);
5430 1348 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5431 1348 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5432 1348 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5433 1348 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5434 1348 : WRITE_NODE_FIELD(scan.plan.targetlist);
5435 1348 : WRITE_NODE_FIELD(scan.plan.qual);
5436 1348 : WRITE_NODE_FIELD(scan.plan.lefttree);
5437 1348 : WRITE_NODE_FIELD(scan.plan.righttree);
5438 1348 : WRITE_NODE_FIELD(scan.plan.initPlan);
5439 1348 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5440 1348 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5441 1348 : WRITE_UINT_FIELD(scan.scanrelid);
5442 1348 : WRITE_NODE_FIELD(tidrangequals);
5443 1348 : }
5444 :
5445 : static void
5446 14483 : _outSubqueryScan(StringInfo str, const SubqueryScan *node)
5447 : {
5448 14483 : WRITE_NODE_TYPE("SUBQUERYSCAN");
5449 :
5450 14483 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5451 14483 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5452 14483 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5453 14483 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5454 14483 : WRITE_INT_FIELD(scan.plan.plan_width);
5455 14483 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5456 14483 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5457 14483 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5458 14483 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5459 14483 : WRITE_NODE_FIELD(scan.plan.targetlist);
5460 14483 : WRITE_NODE_FIELD(scan.plan.qual);
5461 14483 : WRITE_NODE_FIELD(scan.plan.lefttree);
5462 14483 : WRITE_NODE_FIELD(scan.plan.righttree);
5463 14483 : WRITE_NODE_FIELD(scan.plan.initPlan);
5464 14483 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5465 14483 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5466 14483 : WRITE_UINT_FIELD(scan.scanrelid);
5467 14483 : WRITE_NODE_FIELD(subplan);
5468 14483 : WRITE_ENUM_FIELD(scanstatus, SubqueryScanStatus);
5469 14483 : }
5470 :
5471 : static void
5472 31890 : _outFunctionScan(StringInfo str, const FunctionScan *node)
5473 : {
5474 31890 : WRITE_NODE_TYPE("FUNCTIONSCAN");
5475 :
5476 31890 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5477 31890 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5478 31890 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5479 31890 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5480 31890 : WRITE_INT_FIELD(scan.plan.plan_width);
5481 31890 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5482 31890 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5483 31890 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5484 31890 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5485 31890 : WRITE_NODE_FIELD(scan.plan.targetlist);
5486 31890 : WRITE_NODE_FIELD(scan.plan.qual);
5487 31890 : WRITE_NODE_FIELD(scan.plan.lefttree);
5488 31890 : WRITE_NODE_FIELD(scan.plan.righttree);
5489 31890 : WRITE_NODE_FIELD(scan.plan.initPlan);
5490 31890 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5491 31890 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5492 31890 : WRITE_UINT_FIELD(scan.scanrelid);
5493 31890 : WRITE_NODE_FIELD(functions);
5494 31890 : WRITE_BOOL_FIELD(funcordinality);
5495 31890 : }
5496 :
5497 : static void
5498 5707 : _outValuesScan(StringInfo str, const ValuesScan *node)
5499 : {
5500 5707 : WRITE_NODE_TYPE("VALUESSCAN");
5501 :
5502 5707 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5503 5707 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5504 5707 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5505 5707 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5506 5707 : WRITE_INT_FIELD(scan.plan.plan_width);
5507 5707 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5508 5707 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5509 5707 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5510 5707 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5511 5707 : WRITE_NODE_FIELD(scan.plan.targetlist);
5512 5707 : WRITE_NODE_FIELD(scan.plan.qual);
5513 5707 : WRITE_NODE_FIELD(scan.plan.lefttree);
5514 5707 : WRITE_NODE_FIELD(scan.plan.righttree);
5515 5707 : WRITE_NODE_FIELD(scan.plan.initPlan);
5516 5707 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5517 5707 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5518 5707 : WRITE_UINT_FIELD(scan.scanrelid);
5519 5707 : WRITE_NODE_FIELD(values_lists);
5520 5707 : }
5521 :
5522 : static void
5523 416 : _outTableFuncScan(StringInfo str, const TableFuncScan *node)
5524 : {
5525 416 : WRITE_NODE_TYPE("TABLEFUNCSCAN");
5526 :
5527 416 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5528 416 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5529 416 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5530 416 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5531 416 : WRITE_INT_FIELD(scan.plan.plan_width);
5532 416 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5533 416 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5534 416 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5535 416 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5536 416 : WRITE_NODE_FIELD(scan.plan.targetlist);
5537 416 : WRITE_NODE_FIELD(scan.plan.qual);
5538 416 : WRITE_NODE_FIELD(scan.plan.lefttree);
5539 416 : WRITE_NODE_FIELD(scan.plan.righttree);
5540 416 : WRITE_NODE_FIELD(scan.plan.initPlan);
5541 416 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5542 416 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5543 416 : WRITE_UINT_FIELD(scan.scanrelid);
5544 416 : WRITE_NODE_FIELD(tablefunc);
5545 416 : }
5546 :
5547 : static void
5548 2684 : _outCteScan(StringInfo str, const CteScan *node)
5549 : {
5550 2684 : WRITE_NODE_TYPE("CTESCAN");
5551 :
5552 2684 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5553 2684 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5554 2684 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5555 2684 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5556 2684 : WRITE_INT_FIELD(scan.plan.plan_width);
5557 2684 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5558 2684 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5559 2684 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5560 2684 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5561 2684 : WRITE_NODE_FIELD(scan.plan.targetlist);
5562 2684 : WRITE_NODE_FIELD(scan.plan.qual);
5563 2684 : WRITE_NODE_FIELD(scan.plan.lefttree);
5564 2684 : WRITE_NODE_FIELD(scan.plan.righttree);
5565 2684 : WRITE_NODE_FIELD(scan.plan.initPlan);
5566 2684 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5567 2684 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5568 2684 : WRITE_UINT_FIELD(scan.scanrelid);
5569 2684 : WRITE_INT_FIELD(ctePlanId);
5570 2684 : WRITE_INT_FIELD(cteParam);
5571 2684 : }
5572 :
5573 : static void
5574 352 : _outNamedTuplestoreScan(StringInfo str, const NamedTuplestoreScan *node)
5575 : {
5576 352 : WRITE_NODE_TYPE("NAMEDTUPLESTORESCAN");
5577 :
5578 352 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5579 352 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5580 352 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5581 352 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5582 352 : WRITE_INT_FIELD(scan.plan.plan_width);
5583 352 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5584 352 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5585 352 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5586 352 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5587 352 : WRITE_NODE_FIELD(scan.plan.targetlist);
5588 352 : WRITE_NODE_FIELD(scan.plan.qual);
5589 352 : WRITE_NODE_FIELD(scan.plan.lefttree);
5590 352 : WRITE_NODE_FIELD(scan.plan.righttree);
5591 352 : WRITE_NODE_FIELD(scan.plan.initPlan);
5592 352 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5593 352 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5594 352 : WRITE_UINT_FIELD(scan.scanrelid);
5595 352 : WRITE_STRING_FIELD(enrname);
5596 352 : }
5597 :
5598 : static void
5599 615 : _outWorkTableScan(StringInfo str, const WorkTableScan *node)
5600 : {
5601 615 : WRITE_NODE_TYPE("WORKTABLESCAN");
5602 :
5603 615 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5604 615 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5605 615 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5606 615 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5607 615 : WRITE_INT_FIELD(scan.plan.plan_width);
5608 615 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5609 615 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5610 615 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5611 615 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5612 615 : WRITE_NODE_FIELD(scan.plan.targetlist);
5613 615 : WRITE_NODE_FIELD(scan.plan.qual);
5614 615 : WRITE_NODE_FIELD(scan.plan.lefttree);
5615 615 : WRITE_NODE_FIELD(scan.plan.righttree);
5616 615 : WRITE_NODE_FIELD(scan.plan.initPlan);
5617 615 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5618 615 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5619 615 : WRITE_UINT_FIELD(scan.scanrelid);
5620 615 : WRITE_INT_FIELD(wtParam);
5621 615 : }
5622 :
5623 : static void
5624 1050 : _outForeignScan(StringInfo str, const ForeignScan *node)
5625 : {
5626 1050 : WRITE_NODE_TYPE("FOREIGNSCAN");
5627 :
5628 1050 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5629 1050 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5630 1050 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5631 1050 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5632 1050 : WRITE_INT_FIELD(scan.plan.plan_width);
5633 1050 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5634 1050 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5635 1050 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5636 1050 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5637 1050 : WRITE_NODE_FIELD(scan.plan.targetlist);
5638 1050 : WRITE_NODE_FIELD(scan.plan.qual);
5639 1050 : WRITE_NODE_FIELD(scan.plan.lefttree);
5640 1050 : WRITE_NODE_FIELD(scan.plan.righttree);
5641 1050 : WRITE_NODE_FIELD(scan.plan.initPlan);
5642 1050 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5643 1050 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5644 1050 : WRITE_UINT_FIELD(scan.scanrelid);
5645 1050 : WRITE_ENUM_FIELD(operation, CmdType);
5646 1050 : WRITE_UINT_FIELD(resultRelation);
5647 1050 : WRITE_OID_FIELD(checkAsUser);
5648 1050 : WRITE_OID_FIELD(fs_server);
5649 1050 : WRITE_NODE_FIELD(fdw_exprs);
5650 1050 : WRITE_NODE_FIELD(fdw_private);
5651 1050 : WRITE_NODE_FIELD(fdw_scan_tlist);
5652 1050 : WRITE_NODE_FIELD(fdw_recheck_quals);
5653 1050 : WRITE_BITMAPSET_FIELD(fs_relids);
5654 1050 : WRITE_BITMAPSET_FIELD(fs_base_relids);
5655 1050 : WRITE_BOOL_FIELD(fsSystemCol);
5656 1050 : }
5657 :
5658 : static void
5659 0 : _outCustomScan(StringInfo str, const CustomScan *node)
5660 : {
5661 0 : WRITE_NODE_TYPE("CUSTOMSCAN");
5662 :
5663 0 : WRITE_INT_FIELD(scan.plan.disabled_nodes);
5664 0 : WRITE_FLOAT_FIELD(scan.plan.startup_cost);
5665 0 : WRITE_FLOAT_FIELD(scan.plan.total_cost);
5666 0 : WRITE_FLOAT_FIELD(scan.plan.plan_rows);
5667 0 : WRITE_INT_FIELD(scan.plan.plan_width);
5668 0 : WRITE_BOOL_FIELD(scan.plan.parallel_aware);
5669 0 : WRITE_BOOL_FIELD(scan.plan.parallel_safe);
5670 0 : WRITE_BOOL_FIELD(scan.plan.async_capable);
5671 0 : WRITE_INT_FIELD(scan.plan.plan_node_id);
5672 0 : WRITE_NODE_FIELD(scan.plan.targetlist);
5673 0 : WRITE_NODE_FIELD(scan.plan.qual);
5674 0 : WRITE_NODE_FIELD(scan.plan.lefttree);
5675 0 : WRITE_NODE_FIELD(scan.plan.righttree);
5676 0 : WRITE_NODE_FIELD(scan.plan.initPlan);
5677 0 : WRITE_BITMAPSET_FIELD(scan.plan.extParam);
5678 0 : WRITE_BITMAPSET_FIELD(scan.plan.allParam);
5679 0 : WRITE_UINT_FIELD(scan.scanrelid);
5680 0 : WRITE_UINT_FIELD(flags);
5681 0 : WRITE_NODE_FIELD(custom_plans);
5682 0 : WRITE_NODE_FIELD(custom_exprs);
5683 0 : WRITE_NODE_FIELD(custom_private);
5684 0 : WRITE_NODE_FIELD(custom_scan_tlist);
5685 0 : WRITE_BITMAPSET_FIELD(custom_relids);
5686 :
5687 : /* CustomName is a key to lookup CustomScanMethods */
5688 0 : appendStringInfoString(str, " :methods ");
5689 0 : outToken(str, node->methods->CustomName);
5690 0 : }
5691 :
5692 : static void
5693 66784 : _outNestLoop(StringInfo str, const NestLoop *node)
5694 : {
5695 66784 : WRITE_NODE_TYPE("NESTLOOP");
5696 :
5697 66784 : WRITE_INT_FIELD(join.plan.disabled_nodes);
5698 66784 : WRITE_FLOAT_FIELD(join.plan.startup_cost);
5699 66784 : WRITE_FLOAT_FIELD(join.plan.total_cost);
5700 66784 : WRITE_FLOAT_FIELD(join.plan.plan_rows);
5701 66784 : WRITE_INT_FIELD(join.plan.plan_width);
5702 66784 : WRITE_BOOL_FIELD(join.plan.parallel_aware);
5703 66784 : WRITE_BOOL_FIELD(join.plan.parallel_safe);
5704 66784 : WRITE_BOOL_FIELD(join.plan.async_capable);
5705 66784 : WRITE_INT_FIELD(join.plan.plan_node_id);
5706 66784 : WRITE_NODE_FIELD(join.plan.targetlist);
5707 66784 : WRITE_NODE_FIELD(join.plan.qual);
5708 66784 : WRITE_NODE_FIELD(join.plan.lefttree);
5709 66784 : WRITE_NODE_FIELD(join.plan.righttree);
5710 66784 : WRITE_NODE_FIELD(join.plan.initPlan);
5711 66784 : WRITE_BITMAPSET_FIELD(join.plan.extParam);
5712 66784 : WRITE_BITMAPSET_FIELD(join.plan.allParam);
5713 66784 : WRITE_ENUM_FIELD(join.jointype, JoinType);
5714 66784 : WRITE_BOOL_FIELD(join.inner_unique);
5715 66784 : WRITE_NODE_FIELD(join.joinqual);
5716 66784 : WRITE_NODE_FIELD(nestParams);
5717 66784 : }
5718 :
5719 : static void
5720 39002 : _outNestLoopParam(StringInfo str, const NestLoopParam *node)
5721 : {
5722 39002 : WRITE_NODE_TYPE("NESTLOOPPARAM");
5723 :
5724 39002 : WRITE_INT_FIELD(paramno);
5725 39002 : WRITE_NODE_FIELD(paramval);
5726 39002 : }
5727 :
5728 : static void
5729 5038 : _outMergeJoin(StringInfo str, const MergeJoin *node)
5730 : {
5731 5038 : WRITE_NODE_TYPE("MERGEJOIN");
5732 :
5733 5038 : WRITE_INT_FIELD(join.plan.disabled_nodes);
5734 5038 : WRITE_FLOAT_FIELD(join.plan.startup_cost);
5735 5038 : WRITE_FLOAT_FIELD(join.plan.total_cost);
5736 5038 : WRITE_FLOAT_FIELD(join.plan.plan_rows);
5737 5038 : WRITE_INT_FIELD(join.plan.plan_width);
5738 5038 : WRITE_BOOL_FIELD(join.plan.parallel_aware);
5739 5038 : WRITE_BOOL_FIELD(join.plan.parallel_safe);
5740 5038 : WRITE_BOOL_FIELD(join.plan.async_capable);
5741 5038 : WRITE_INT_FIELD(join.plan.plan_node_id);
5742 5038 : WRITE_NODE_FIELD(join.plan.targetlist);
5743 5038 : WRITE_NODE_FIELD(join.plan.qual);
5744 5038 : WRITE_NODE_FIELD(join.plan.lefttree);
5745 5038 : WRITE_NODE_FIELD(join.plan.righttree);
5746 5038 : WRITE_NODE_FIELD(join.plan.initPlan);
5747 5038 : WRITE_BITMAPSET_FIELD(join.plan.extParam);
5748 5038 : WRITE_BITMAPSET_FIELD(join.plan.allParam);
5749 5038 : WRITE_ENUM_FIELD(join.jointype, JoinType);
5750 5038 : WRITE_BOOL_FIELD(join.inner_unique);
5751 5038 : WRITE_NODE_FIELD(join.joinqual);
5752 5038 : WRITE_BOOL_FIELD(skip_mark_restore);
5753 5038 : WRITE_NODE_FIELD(mergeclauses);
5754 5038 : WRITE_OID_ARRAY(mergeFamilies, list_length(node->mergeclauses));
5755 5038 : WRITE_OID_ARRAY(mergeCollations, list_length(node->mergeclauses));
5756 5038 : WRITE_BOOL_ARRAY(mergeReversals, list_length(node->mergeclauses));
5757 5038 : WRITE_BOOL_ARRAY(mergeNullsFirst, list_length(node->mergeclauses));
5758 5038 : }
5759 :
5760 : static void
5761 27391 : _outHashJoin(StringInfo str, const HashJoin *node)
5762 : {
5763 27391 : WRITE_NODE_TYPE("HASHJOIN");
5764 :
5765 27391 : WRITE_INT_FIELD(join.plan.disabled_nodes);
5766 27391 : WRITE_FLOAT_FIELD(join.plan.startup_cost);
5767 27391 : WRITE_FLOAT_FIELD(join.plan.total_cost);
5768 27391 : WRITE_FLOAT_FIELD(join.plan.plan_rows);
5769 27391 : WRITE_INT_FIELD(join.plan.plan_width);
5770 27391 : WRITE_BOOL_FIELD(join.plan.parallel_aware);
5771 27391 : WRITE_BOOL_FIELD(join.plan.parallel_safe);
5772 27391 : WRITE_BOOL_FIELD(join.plan.async_capable);
5773 27391 : WRITE_INT_FIELD(join.plan.plan_node_id);
5774 27391 : WRITE_NODE_FIELD(join.plan.targetlist);
5775 27391 : WRITE_NODE_FIELD(join.plan.qual);
5776 27391 : WRITE_NODE_FIELD(join.plan.lefttree);
5777 27391 : WRITE_NODE_FIELD(join.plan.righttree);
5778 27391 : WRITE_NODE_FIELD(join.plan.initPlan);
5779 27391 : WRITE_BITMAPSET_FIELD(join.plan.extParam);
5780 27391 : WRITE_BITMAPSET_FIELD(join.plan.allParam);
5781 27391 : WRITE_ENUM_FIELD(join.jointype, JoinType);
5782 27391 : WRITE_BOOL_FIELD(join.inner_unique);
5783 27391 : WRITE_NODE_FIELD(join.joinqual);
5784 27391 : WRITE_NODE_FIELD(hashclauses);
5785 27391 : WRITE_NODE_FIELD(hashoperators);
5786 27391 : WRITE_NODE_FIELD(hashcollations);
5787 27391 : WRITE_NODE_FIELD(hashkeys);
5788 27391 : }
5789 :
5790 : static void
5791 2804 : _outMaterial(StringInfo str, const Material *node)
5792 : {
5793 2804 : WRITE_NODE_TYPE("MATERIAL");
5794 :
5795 2804 : WRITE_INT_FIELD(plan.disabled_nodes);
5796 2804 : WRITE_FLOAT_FIELD(plan.startup_cost);
5797 2804 : WRITE_FLOAT_FIELD(plan.total_cost);
5798 2804 : WRITE_FLOAT_FIELD(plan.plan_rows);
5799 2804 : WRITE_INT_FIELD(plan.plan_width);
5800 2804 : WRITE_BOOL_FIELD(plan.parallel_aware);
5801 2804 : WRITE_BOOL_FIELD(plan.parallel_safe);
5802 2804 : WRITE_BOOL_FIELD(plan.async_capable);
5803 2804 : WRITE_INT_FIELD(plan.plan_node_id);
5804 2804 : WRITE_NODE_FIELD(plan.targetlist);
5805 2804 : WRITE_NODE_FIELD(plan.qual);
5806 2804 : WRITE_NODE_FIELD(plan.lefttree);
5807 2804 : WRITE_NODE_FIELD(plan.righttree);
5808 2804 : WRITE_NODE_FIELD(plan.initPlan);
5809 2804 : WRITE_BITMAPSET_FIELD(plan.extParam);
5810 2804 : WRITE_BITMAPSET_FIELD(plan.allParam);
5811 2804 : }
5812 :
5813 : static void
5814 1287 : _outMemoize(StringInfo str, const Memoize *node)
5815 : {
5816 1287 : WRITE_NODE_TYPE("MEMOIZE");
5817 :
5818 1287 : WRITE_INT_FIELD(plan.disabled_nodes);
5819 1287 : WRITE_FLOAT_FIELD(plan.startup_cost);
5820 1287 : WRITE_FLOAT_FIELD(plan.total_cost);
5821 1287 : WRITE_FLOAT_FIELD(plan.plan_rows);
5822 1287 : WRITE_INT_FIELD(plan.plan_width);
5823 1287 : WRITE_BOOL_FIELD(plan.parallel_aware);
5824 1287 : WRITE_BOOL_FIELD(plan.parallel_safe);
5825 1287 : WRITE_BOOL_FIELD(plan.async_capable);
5826 1287 : WRITE_INT_FIELD(plan.plan_node_id);
5827 1287 : WRITE_NODE_FIELD(plan.targetlist);
5828 1287 : WRITE_NODE_FIELD(plan.qual);
5829 1287 : WRITE_NODE_FIELD(plan.lefttree);
5830 1287 : WRITE_NODE_FIELD(plan.righttree);
5831 1287 : WRITE_NODE_FIELD(plan.initPlan);
5832 1287 : WRITE_BITMAPSET_FIELD(plan.extParam);
5833 1287 : WRITE_BITMAPSET_FIELD(plan.allParam);
5834 1287 : WRITE_INT_FIELD(numKeys);
5835 1287 : WRITE_OID_ARRAY(hashOperators, node->numKeys);
5836 1287 : WRITE_OID_ARRAY(collations, node->numKeys);
5837 1287 : WRITE_NODE_FIELD(param_exprs);
5838 1287 : WRITE_BOOL_FIELD(singlerow);
5839 1287 : WRITE_BOOL_FIELD(binary_mode);
5840 1287 : WRITE_UINT_FIELD(est_entries);
5841 1287 : WRITE_BITMAPSET_FIELD(keyparamids);
5842 1287 : WRITE_FLOAT_FIELD(est_calls);
5843 1287 : WRITE_FLOAT_FIELD(est_unique_keys);
5844 1287 : WRITE_FLOAT_FIELD(est_hit_ratio);
5845 1287 : }
5846 :
5847 : static void
5848 56339 : _outSort(StringInfo str, const Sort *node)
5849 : {
5850 56339 : WRITE_NODE_TYPE("SORT");
5851 :
5852 56339 : WRITE_INT_FIELD(plan.disabled_nodes);
5853 56339 : WRITE_FLOAT_FIELD(plan.startup_cost);
5854 56339 : WRITE_FLOAT_FIELD(plan.total_cost);
5855 56339 : WRITE_FLOAT_FIELD(plan.plan_rows);
5856 56339 : WRITE_INT_FIELD(plan.plan_width);
5857 56339 : WRITE_BOOL_FIELD(plan.parallel_aware);
5858 56339 : WRITE_BOOL_FIELD(plan.parallel_safe);
5859 56339 : WRITE_BOOL_FIELD(plan.async_capable);
5860 56339 : WRITE_INT_FIELD(plan.plan_node_id);
5861 56339 : WRITE_NODE_FIELD(plan.targetlist);
5862 56339 : WRITE_NODE_FIELD(plan.qual);
5863 56339 : WRITE_NODE_FIELD(plan.lefttree);
5864 56339 : WRITE_NODE_FIELD(plan.righttree);
5865 56339 : WRITE_NODE_FIELD(plan.initPlan);
5866 56339 : WRITE_BITMAPSET_FIELD(plan.extParam);
5867 56339 : WRITE_BITMAPSET_FIELD(plan.allParam);
5868 56339 : WRITE_INT_FIELD(numCols);
5869 56339 : WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
5870 56339 : WRITE_OID_ARRAY(sortOperators, node->numCols);
5871 56339 : WRITE_OID_ARRAY(collations, node->numCols);
5872 56339 : WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
5873 56339 : }
5874 :
5875 : static void
5876 623 : _outIncrementalSort(StringInfo str, const IncrementalSort *node)
5877 : {
5878 623 : WRITE_NODE_TYPE("INCREMENTALSORT");
5879 :
5880 623 : WRITE_INT_FIELD(sort.plan.disabled_nodes);
5881 623 : WRITE_FLOAT_FIELD(sort.plan.startup_cost);
5882 623 : WRITE_FLOAT_FIELD(sort.plan.total_cost);
5883 623 : WRITE_FLOAT_FIELD(sort.plan.plan_rows);
5884 623 : WRITE_INT_FIELD(sort.plan.plan_width);
5885 623 : WRITE_BOOL_FIELD(sort.plan.parallel_aware);
5886 623 : WRITE_BOOL_FIELD(sort.plan.parallel_safe);
5887 623 : WRITE_BOOL_FIELD(sort.plan.async_capable);
5888 623 : WRITE_INT_FIELD(sort.plan.plan_node_id);
5889 623 : WRITE_NODE_FIELD(sort.plan.targetlist);
5890 623 : WRITE_NODE_FIELD(sort.plan.qual);
5891 623 : WRITE_NODE_FIELD(sort.plan.lefttree);
5892 623 : WRITE_NODE_FIELD(sort.plan.righttree);
5893 623 : WRITE_NODE_FIELD(sort.plan.initPlan);
5894 623 : WRITE_BITMAPSET_FIELD(sort.plan.extParam);
5895 623 : WRITE_BITMAPSET_FIELD(sort.plan.allParam);
5896 623 : WRITE_INT_FIELD(sort.numCols);
5897 623 : WRITE_ATTRNUMBER_ARRAY(sort.sortColIdx, node->sort.numCols);
5898 623 : WRITE_OID_ARRAY(sort.sortOperators, node->sort.numCols);
5899 623 : WRITE_OID_ARRAY(sort.collations, node->sort.numCols);
5900 623 : WRITE_BOOL_ARRAY(sort.nullsFirst, node->sort.numCols);
5901 623 : WRITE_INT_FIELD(nPresortedCols);
5902 623 : }
5903 :
5904 : static void
5905 182 : _outGroup(StringInfo str, const Group *node)
5906 : {
5907 182 : WRITE_NODE_TYPE("GROUP");
5908 :
5909 182 : WRITE_INT_FIELD(plan.disabled_nodes);
5910 182 : WRITE_FLOAT_FIELD(plan.startup_cost);
5911 182 : WRITE_FLOAT_FIELD(plan.total_cost);
5912 182 : WRITE_FLOAT_FIELD(plan.plan_rows);
5913 182 : WRITE_INT_FIELD(plan.plan_width);
5914 182 : WRITE_BOOL_FIELD(plan.parallel_aware);
5915 182 : WRITE_BOOL_FIELD(plan.parallel_safe);
5916 182 : WRITE_BOOL_FIELD(plan.async_capable);
5917 182 : WRITE_INT_FIELD(plan.plan_node_id);
5918 182 : WRITE_NODE_FIELD(plan.targetlist);
5919 182 : WRITE_NODE_FIELD(plan.qual);
5920 182 : WRITE_NODE_FIELD(plan.lefttree);
5921 182 : WRITE_NODE_FIELD(plan.righttree);
5922 182 : WRITE_NODE_FIELD(plan.initPlan);
5923 182 : WRITE_BITMAPSET_FIELD(plan.extParam);
5924 182 : WRITE_BITMAPSET_FIELD(plan.allParam);
5925 182 : WRITE_INT_FIELD(numCols);
5926 182 : WRITE_ATTRNUMBER_ARRAY(grpColIdx, node->numCols);
5927 182 : WRITE_OID_ARRAY(grpOperators, node->numCols);
5928 182 : WRITE_OID_ARRAY(grpCollations, node->numCols);
5929 182 : }
5930 :
5931 : static void
5932 32640 : _outAgg(StringInfo str, const Agg *node)
5933 : {
5934 32640 : WRITE_NODE_TYPE("AGG");
5935 :
5936 32640 : WRITE_INT_FIELD(plan.disabled_nodes);
5937 32640 : WRITE_FLOAT_FIELD(plan.startup_cost);
5938 32640 : WRITE_FLOAT_FIELD(plan.total_cost);
5939 32640 : WRITE_FLOAT_FIELD(plan.plan_rows);
5940 32640 : WRITE_INT_FIELD(plan.plan_width);
5941 32640 : WRITE_BOOL_FIELD(plan.parallel_aware);
5942 32640 : WRITE_BOOL_FIELD(plan.parallel_safe);
5943 32640 : WRITE_BOOL_FIELD(plan.async_capable);
5944 32640 : WRITE_INT_FIELD(plan.plan_node_id);
5945 32640 : WRITE_NODE_FIELD(plan.targetlist);
5946 32640 : WRITE_NODE_FIELD(plan.qual);
5947 32640 : WRITE_NODE_FIELD(plan.lefttree);
5948 32640 : WRITE_NODE_FIELD(plan.righttree);
5949 32640 : WRITE_NODE_FIELD(plan.initPlan);
5950 32640 : WRITE_BITMAPSET_FIELD(plan.extParam);
5951 32640 : WRITE_BITMAPSET_FIELD(plan.allParam);
5952 32640 : WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
5953 32640 : WRITE_ENUM_FIELD(aggsplit, AggSplit);
5954 32640 : WRITE_INT_FIELD(numCols);
5955 32640 : WRITE_ATTRNUMBER_ARRAY(grpColIdx, node->numCols);
5956 32640 : WRITE_OID_ARRAY(grpOperators, node->numCols);
5957 32640 : WRITE_OID_ARRAY(grpCollations, node->numCols);
5958 32640 : WRITE_FLOAT_FIELD(numGroups);
5959 32640 : WRITE_UINT64_FIELD(transitionSpace);
5960 32640 : WRITE_BITMAPSET_FIELD(aggParams);
5961 32640 : WRITE_NODE_FIELD(groupingSets);
5962 32640 : WRITE_NODE_FIELD(chain);
5963 32640 : }
5964 :
5965 : static void
5966 1922 : _outWindowAgg(StringInfo str, const WindowAgg *node)
5967 : {
5968 1922 : WRITE_NODE_TYPE("WINDOWAGG");
5969 :
5970 1922 : WRITE_INT_FIELD(plan.disabled_nodes);
5971 1922 : WRITE_FLOAT_FIELD(plan.startup_cost);
5972 1922 : WRITE_FLOAT_FIELD(plan.total_cost);
5973 1922 : WRITE_FLOAT_FIELD(plan.plan_rows);
5974 1922 : WRITE_INT_FIELD(plan.plan_width);
5975 1922 : WRITE_BOOL_FIELD(plan.parallel_aware);
5976 1922 : WRITE_BOOL_FIELD(plan.parallel_safe);
5977 1922 : WRITE_BOOL_FIELD(plan.async_capable);
5978 1922 : WRITE_INT_FIELD(plan.plan_node_id);
5979 1922 : WRITE_NODE_FIELD(plan.targetlist);
5980 1922 : WRITE_NODE_FIELD(plan.qual);
5981 1922 : WRITE_NODE_FIELD(plan.lefttree);
5982 1922 : WRITE_NODE_FIELD(plan.righttree);
5983 1922 : WRITE_NODE_FIELD(plan.initPlan);
5984 1922 : WRITE_BITMAPSET_FIELD(plan.extParam);
5985 1922 : WRITE_BITMAPSET_FIELD(plan.allParam);
5986 1922 : WRITE_STRING_FIELD(winname);
5987 1922 : WRITE_UINT_FIELD(winref);
5988 1922 : WRITE_INT_FIELD(partNumCols);
5989 1922 : WRITE_ATTRNUMBER_ARRAY(partColIdx, node->partNumCols);
5990 1922 : WRITE_OID_ARRAY(partOperators, node->partNumCols);
5991 1922 : WRITE_OID_ARRAY(partCollations, node->partNumCols);
5992 1922 : WRITE_INT_FIELD(ordNumCols);
5993 1922 : WRITE_ATTRNUMBER_ARRAY(ordColIdx, node->ordNumCols);
5994 1922 : WRITE_OID_ARRAY(ordOperators, node->ordNumCols);
5995 1922 : WRITE_OID_ARRAY(ordCollations, node->ordNumCols);
5996 1922 : WRITE_INT_FIELD(frameOptions);
5997 1922 : WRITE_NODE_FIELD(startOffset);
5998 1922 : WRITE_NODE_FIELD(endOffset);
5999 1922 : WRITE_NODE_FIELD(runCondition);
6000 1922 : WRITE_NODE_FIELD(runConditionOrig);
6001 1922 : WRITE_OID_FIELD(startInRangeFunc);
6002 1922 : WRITE_OID_FIELD(endInRangeFunc);
6003 1922 : WRITE_OID_FIELD(inRangeColl);
6004 1922 : WRITE_BOOL_FIELD(inRangeAsc);
6005 1922 : WRITE_BOOL_FIELD(inRangeNullsFirst);
6006 1922 : WRITE_BOOL_FIELD(topWindow);
6007 1922 : }
6008 :
6009 : static void
6010 3577 : _outUnique(StringInfo str, const Unique *node)
6011 : {
6012 3577 : WRITE_NODE_TYPE("UNIQUE");
6013 :
6014 3577 : WRITE_INT_FIELD(plan.disabled_nodes);
6015 3577 : WRITE_FLOAT_FIELD(plan.startup_cost);
6016 3577 : WRITE_FLOAT_FIELD(plan.total_cost);
6017 3577 : WRITE_FLOAT_FIELD(plan.plan_rows);
6018 3577 : WRITE_INT_FIELD(plan.plan_width);
6019 3577 : WRITE_BOOL_FIELD(plan.parallel_aware);
6020 3577 : WRITE_BOOL_FIELD(plan.parallel_safe);
6021 3577 : WRITE_BOOL_FIELD(plan.async_capable);
6022 3577 : WRITE_INT_FIELD(plan.plan_node_id);
6023 3577 : WRITE_NODE_FIELD(plan.targetlist);
6024 3577 : WRITE_NODE_FIELD(plan.qual);
6025 3577 : WRITE_NODE_FIELD(plan.lefttree);
6026 3577 : WRITE_NODE_FIELD(plan.righttree);
6027 3577 : WRITE_NODE_FIELD(plan.initPlan);
6028 3577 : WRITE_BITMAPSET_FIELD(plan.extParam);
6029 3577 : WRITE_BITMAPSET_FIELD(plan.allParam);
6030 3577 : WRITE_INT_FIELD(numCols);
6031 3577 : WRITE_ATTRNUMBER_ARRAY(uniqColIdx, node->numCols);
6032 3577 : WRITE_OID_ARRAY(uniqOperators, node->numCols);
6033 3577 : WRITE_OID_ARRAY(uniqCollations, node->numCols);
6034 3577 : }
6035 :
6036 : static void
6037 773 : _outGather(StringInfo str, const Gather *node)
6038 : {
6039 773 : WRITE_NODE_TYPE("GATHER");
6040 :
6041 773 : WRITE_INT_FIELD(plan.disabled_nodes);
6042 773 : WRITE_FLOAT_FIELD(plan.startup_cost);
6043 773 : WRITE_FLOAT_FIELD(plan.total_cost);
6044 773 : WRITE_FLOAT_FIELD(plan.plan_rows);
6045 773 : WRITE_INT_FIELD(plan.plan_width);
6046 773 : WRITE_BOOL_FIELD(plan.parallel_aware);
6047 773 : WRITE_BOOL_FIELD(plan.parallel_safe);
6048 773 : WRITE_BOOL_FIELD(plan.async_capable);
6049 773 : WRITE_INT_FIELD(plan.plan_node_id);
6050 773 : WRITE_NODE_FIELD(plan.targetlist);
6051 773 : WRITE_NODE_FIELD(plan.qual);
6052 773 : WRITE_NODE_FIELD(plan.lefttree);
6053 773 : WRITE_NODE_FIELD(plan.righttree);
6054 773 : WRITE_NODE_FIELD(plan.initPlan);
6055 773 : WRITE_BITMAPSET_FIELD(plan.extParam);
6056 773 : WRITE_BITMAPSET_FIELD(plan.allParam);
6057 773 : WRITE_INT_FIELD(num_workers);
6058 773 : WRITE_INT_FIELD(rescan_param);
6059 773 : WRITE_BOOL_FIELD(single_copy);
6060 773 : WRITE_BOOL_FIELD(invisible);
6061 773 : WRITE_BITMAPSET_FIELD(initParam);
6062 773 : }
6063 :
6064 : static void
6065 260 : _outGatherMerge(StringInfo str, const GatherMerge *node)
6066 : {
6067 260 : WRITE_NODE_TYPE("GATHERMERGE");
6068 :
6069 260 : WRITE_INT_FIELD(plan.disabled_nodes);
6070 260 : WRITE_FLOAT_FIELD(plan.startup_cost);
6071 260 : WRITE_FLOAT_FIELD(plan.total_cost);
6072 260 : WRITE_FLOAT_FIELD(plan.plan_rows);
6073 260 : WRITE_INT_FIELD(plan.plan_width);
6074 260 : WRITE_BOOL_FIELD(plan.parallel_aware);
6075 260 : WRITE_BOOL_FIELD(plan.parallel_safe);
6076 260 : WRITE_BOOL_FIELD(plan.async_capable);
6077 260 : WRITE_INT_FIELD(plan.plan_node_id);
6078 260 : WRITE_NODE_FIELD(plan.targetlist);
6079 260 : WRITE_NODE_FIELD(plan.qual);
6080 260 : WRITE_NODE_FIELD(plan.lefttree);
6081 260 : WRITE_NODE_FIELD(plan.righttree);
6082 260 : WRITE_NODE_FIELD(plan.initPlan);
6083 260 : WRITE_BITMAPSET_FIELD(plan.extParam);
6084 260 : WRITE_BITMAPSET_FIELD(plan.allParam);
6085 260 : WRITE_INT_FIELD(num_workers);
6086 260 : WRITE_INT_FIELD(rescan_param);
6087 260 : WRITE_INT_FIELD(numCols);
6088 260 : WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols);
6089 260 : WRITE_OID_ARRAY(sortOperators, node->numCols);
6090 260 : WRITE_OID_ARRAY(collations, node->numCols);
6091 260 : WRITE_BOOL_ARRAY(nullsFirst, node->numCols);
6092 260 : WRITE_BITMAPSET_FIELD(initParam);
6093 260 : }
6094 :
6095 : static void
6096 27391 : _outHash(StringInfo str, const Hash *node)
6097 : {
6098 27391 : WRITE_NODE_TYPE("HASH");
6099 :
6100 27391 : WRITE_INT_FIELD(plan.disabled_nodes);
6101 27391 : WRITE_FLOAT_FIELD(plan.startup_cost);
6102 27391 : WRITE_FLOAT_FIELD(plan.total_cost);
6103 27391 : WRITE_FLOAT_FIELD(plan.plan_rows);
6104 27391 : WRITE_INT_FIELD(plan.plan_width);
6105 27391 : WRITE_BOOL_FIELD(plan.parallel_aware);
6106 27391 : WRITE_BOOL_FIELD(plan.parallel_safe);
6107 27391 : WRITE_BOOL_FIELD(plan.async_capable);
6108 27391 : WRITE_INT_FIELD(plan.plan_node_id);
6109 27391 : WRITE_NODE_FIELD(plan.targetlist);
6110 27391 : WRITE_NODE_FIELD(plan.qual);
6111 27391 : WRITE_NODE_FIELD(plan.lefttree);
6112 27391 : WRITE_NODE_FIELD(plan.righttree);
6113 27391 : WRITE_NODE_FIELD(plan.initPlan);
6114 27391 : WRITE_BITMAPSET_FIELD(plan.extParam);
6115 27391 : WRITE_BITMAPSET_FIELD(plan.allParam);
6116 27391 : WRITE_NODE_FIELD(hashkeys);
6117 27391 : WRITE_OID_FIELD(skewTable);
6118 27391 : WRITE_INT_FIELD(skewColumn);
6119 27391 : WRITE_BOOL_FIELD(skewInherit);
6120 27391 : WRITE_FLOAT_FIELD(rows_total);
6121 27391 : }
6122 :
6123 : static void
6124 480 : _outSetOp(StringInfo str, const SetOp *node)
6125 : {
6126 480 : WRITE_NODE_TYPE("SETOP");
6127 :
6128 480 : WRITE_INT_FIELD(plan.disabled_nodes);
6129 480 : WRITE_FLOAT_FIELD(plan.startup_cost);
6130 480 : WRITE_FLOAT_FIELD(plan.total_cost);
6131 480 : WRITE_FLOAT_FIELD(plan.plan_rows);
6132 480 : WRITE_INT_FIELD(plan.plan_width);
6133 480 : WRITE_BOOL_FIELD(plan.parallel_aware);
6134 480 : WRITE_BOOL_FIELD(plan.parallel_safe);
6135 480 : WRITE_BOOL_FIELD(plan.async_capable);
6136 480 : WRITE_INT_FIELD(plan.plan_node_id);
6137 480 : WRITE_NODE_FIELD(plan.targetlist);
6138 480 : WRITE_NODE_FIELD(plan.qual);
6139 480 : WRITE_NODE_FIELD(plan.lefttree);
6140 480 : WRITE_NODE_FIELD(plan.righttree);
6141 480 : WRITE_NODE_FIELD(plan.initPlan);
6142 480 : WRITE_BITMAPSET_FIELD(plan.extParam);
6143 480 : WRITE_BITMAPSET_FIELD(plan.allParam);
6144 480 : WRITE_ENUM_FIELD(cmd, SetOpCmd);
6145 480 : WRITE_ENUM_FIELD(strategy, SetOpStrategy);
6146 480 : WRITE_INT_FIELD(numCols);
6147 480 : WRITE_ATTRNUMBER_ARRAY(cmpColIdx, node->numCols);
6148 480 : WRITE_OID_ARRAY(cmpOperators, node->numCols);
6149 480 : WRITE_OID_ARRAY(cmpCollations, node->numCols);
6150 480 : WRITE_BOOL_ARRAY(cmpNullsFirst, node->numCols);
6151 480 : WRITE_FLOAT_FIELD(numGroups);
6152 480 : }
6153 :
6154 : static void
6155 6057 : _outLockRows(StringInfo str, const LockRows *node)
6156 : {
6157 6057 : WRITE_NODE_TYPE("LOCKROWS");
6158 :
6159 6057 : WRITE_INT_FIELD(plan.disabled_nodes);
6160 6057 : WRITE_FLOAT_FIELD(plan.startup_cost);
6161 6057 : WRITE_FLOAT_FIELD(plan.total_cost);
6162 6057 : WRITE_FLOAT_FIELD(plan.plan_rows);
6163 6057 : WRITE_INT_FIELD(plan.plan_width);
6164 6057 : WRITE_BOOL_FIELD(plan.parallel_aware);
6165 6057 : WRITE_BOOL_FIELD(plan.parallel_safe);
6166 6057 : WRITE_BOOL_FIELD(plan.async_capable);
6167 6057 : WRITE_INT_FIELD(plan.plan_node_id);
6168 6057 : WRITE_NODE_FIELD(plan.targetlist);
6169 6057 : WRITE_NODE_FIELD(plan.qual);
6170 6057 : WRITE_NODE_FIELD(plan.lefttree);
6171 6057 : WRITE_NODE_FIELD(plan.righttree);
6172 6057 : WRITE_NODE_FIELD(plan.initPlan);
6173 6057 : WRITE_BITMAPSET_FIELD(plan.extParam);
6174 6057 : WRITE_BITMAPSET_FIELD(plan.allParam);
6175 6057 : WRITE_NODE_FIELD(rowMarks);
6176 6057 : WRITE_INT_FIELD(epqParam);
6177 6057 : }
6178 :
6179 : static void
6180 3116 : _outLimit(StringInfo str, const Limit *node)
6181 : {
6182 3116 : WRITE_NODE_TYPE("LIMIT");
6183 :
6184 3116 : WRITE_INT_FIELD(plan.disabled_nodes);
6185 3116 : WRITE_FLOAT_FIELD(plan.startup_cost);
6186 3116 : WRITE_FLOAT_FIELD(plan.total_cost);
6187 3116 : WRITE_FLOAT_FIELD(plan.plan_rows);
6188 3116 : WRITE_INT_FIELD(plan.plan_width);
6189 3116 : WRITE_BOOL_FIELD(plan.parallel_aware);
6190 3116 : WRITE_BOOL_FIELD(plan.parallel_safe);
6191 3116 : WRITE_BOOL_FIELD(plan.async_capable);
6192 3116 : WRITE_INT_FIELD(plan.plan_node_id);
6193 3116 : WRITE_NODE_FIELD(plan.targetlist);
6194 3116 : WRITE_NODE_FIELD(plan.qual);
6195 3116 : WRITE_NODE_FIELD(plan.lefttree);
6196 3116 : WRITE_NODE_FIELD(plan.righttree);
6197 3116 : WRITE_NODE_FIELD(plan.initPlan);
6198 3116 : WRITE_BITMAPSET_FIELD(plan.extParam);
6199 3116 : WRITE_BITMAPSET_FIELD(plan.allParam);
6200 3116 : WRITE_NODE_FIELD(limitOffset);
6201 3116 : WRITE_NODE_FIELD(limitCount);
6202 3116 : WRITE_ENUM_FIELD(limitOption, LimitOption);
6203 3116 : WRITE_INT_FIELD(uniqNumCols);
6204 3116 : WRITE_ATTRNUMBER_ARRAY(uniqColIdx, node->uniqNumCols);
6205 3116 : WRITE_OID_ARRAY(uniqOperators, node->uniqNumCols);
6206 3116 : WRITE_OID_ARRAY(uniqCollations, node->uniqNumCols);
6207 3116 : }
6208 :
6209 : static void
6210 19100 : _outPlanRowMark(StringInfo str, const PlanRowMark *node)
6211 : {
6212 19100 : WRITE_NODE_TYPE("PLANROWMARK");
6213 :
6214 19100 : WRITE_UINT_FIELD(rti);
6215 19100 : WRITE_UINT_FIELD(prti);
6216 19100 : WRITE_UINT_FIELD(rowmarkId);
6217 19100 : WRITE_ENUM_FIELD(markType, RowMarkType);
6218 19100 : WRITE_INT_FIELD(allMarkTypes);
6219 19100 : WRITE_ENUM_FIELD(strength, LockClauseStrength);
6220 19100 : WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
6221 19100 : WRITE_BOOL_FIELD(isParent);
6222 19100 : }
6223 :
6224 : static void
6225 427 : _outPartitionPruneInfo(StringInfo str, const PartitionPruneInfo *node)
6226 : {
6227 427 : WRITE_NODE_TYPE("PARTITIONPRUNEINFO");
6228 :
6229 427 : WRITE_BITMAPSET_FIELD(relids);
6230 427 : WRITE_NODE_FIELD(prune_infos);
6231 427 : WRITE_BITMAPSET_FIELD(other_subplans);
6232 427 : }
6233 :
6234 : static void
6235 837 : _outPartitionedRelPruneInfo(StringInfo str, const PartitionedRelPruneInfo *node)
6236 : {
6237 837 : WRITE_NODE_TYPE("PARTITIONEDRELPRUNEINFO");
6238 :
6239 837 : WRITE_UINT_FIELD(rtindex);
6240 837 : WRITE_BITMAPSET_FIELD(present_parts);
6241 837 : WRITE_INT_FIELD(nparts);
6242 837 : WRITE_INT_ARRAY(subplan_map, node->nparts);
6243 837 : WRITE_INT_ARRAY(subpart_map, node->nparts);
6244 837 : WRITE_INT_ARRAY(leafpart_rti_map, node->nparts);
6245 837 : WRITE_OID_ARRAY(relid_map, node->nparts);
6246 837 : WRITE_NODE_FIELD(initial_pruning_steps);
6247 837 : WRITE_NODE_FIELD(exec_pruning_steps);
6248 837 : WRITE_BITMAPSET_FIELD(execparamids);
6249 837 : }
6250 :
6251 : static void
6252 712 : _outPartitionPruneStepOp(StringInfo str, const PartitionPruneStepOp *node)
6253 : {
6254 712 : WRITE_NODE_TYPE("PARTITIONPRUNESTEPOP");
6255 :
6256 712 : WRITE_INT_FIELD(step.step_id);
6257 712 : WRITE_INT_FIELD(opstrategy);
6258 712 : WRITE_NODE_FIELD(exprs);
6259 712 : WRITE_NODE_FIELD(cmpfns);
6260 712 : WRITE_BITMAPSET_FIELD(nullkeys);
6261 712 : }
6262 :
6263 : static void
6264 127 : _outPartitionPruneStepCombine(StringInfo str, const PartitionPruneStepCombine *node)
6265 : {
6266 127 : WRITE_NODE_TYPE("PARTITIONPRUNESTEPCOMBINE");
6267 :
6268 127 : WRITE_INT_FIELD(step.step_id);
6269 127 : WRITE_ENUM_FIELD(combineOp, PartitionPruneCombineOp);
6270 127 : WRITE_NODE_FIELD(source_stepids);
6271 127 : }
6272 :
6273 : static void
6274 37021 : _outPlanInvalItem(StringInfo str, const PlanInvalItem *node)
6275 : {
6276 37021 : WRITE_NODE_TYPE("PLANINVALITEM");
6277 :
6278 37021 : WRITE_INT_FIELD(cacheId);
6279 37021 : WRITE_UINT_FIELD(hashValue);
6280 37021 : }
6281 :
6282 : static void
6283 56279 : _outSubPlanRTInfo(StringInfo str, const SubPlanRTInfo *node)
6284 : {
6285 56279 : WRITE_NODE_TYPE("SUBPLANRTINFO");
6286 :
6287 56279 : WRITE_STRING_FIELD(plan_name);
6288 56279 : WRITE_UINT_FIELD(rtoffset);
6289 56279 : WRITE_BOOL_FIELD(dummy);
6290 56279 : }
6291 :
6292 : static void
6293 16283 : _outElidedNode(StringInfo str, const ElidedNode *node)
6294 : {
6295 16283 : WRITE_NODE_TYPE("ELIDEDNODE");
6296 :
6297 16283 : WRITE_INT_FIELD(plan_node_id);
6298 16283 : WRITE_ENUM_FIELD(elided_type, NodeTag);
6299 16283 : WRITE_BITMAPSET_FIELD(relids);
6300 16283 : }
6301 :
6302 : static void
6303 0 : _outForeignKeyCacheInfo(StringInfo str, const ForeignKeyCacheInfo *node)
6304 : {
6305 0 : WRITE_NODE_TYPE("FOREIGNKEYCACHEINFO");
6306 :
6307 0 : WRITE_OID_FIELD(conoid);
6308 0 : WRITE_OID_FIELD(conrelid);
6309 0 : WRITE_OID_FIELD(confrelid);
6310 0 : WRITE_INT_FIELD(nkeys);
6311 0 : WRITE_BOOL_FIELD(conenforced);
6312 0 : WRITE_ATTRNUMBER_ARRAY(conkey, node->nkeys);
6313 0 : WRITE_ATTRNUMBER_ARRAY(confkey, node->nkeys);
6314 0 : WRITE_OID_ARRAY(conpfeqop, node->nkeys);
6315 0 : }
|
