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