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