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