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