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