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