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