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