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