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