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