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