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