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