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