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