1 /*-------------------------------------------------------------------------
2 *
3 * outfuncs.c
4 * Output functions for Postgres tree nodes.
5 *
6 * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/nodes/outfuncs.c
12 *
13 * NOTES
14 * Every node type that can appear in stored rules' parsetrees *must*
15 * have an output function defined here (as well as an input function
16 * in readfuncs.c). In addition, plan nodes should have input and
17 * output functions so that they can be sent to parallel workers.
18 *
19 * For use in debugging, we also provide output functions for nodes
20 * that appear in raw parsetrees and planner Paths. These node types
21 * need not have input functions. Output support for raw parsetrees
22 * is somewhat incomplete, too; in particular, utility statements are
23 * almost entirely unsupported. We try to support everything that can
24 * appear in a raw SELECT, though.
25 *
26 *-------------------------------------------------------------------------
27 */
28 #include "postgres.h"
29
30 #include <ctype.h>
31
32 #include "lib/stringinfo.h"
33 #include "miscadmin.h"
34 #include "nodes/extensible.h"
35 #include "nodes/plannodes.h"
36 #include "nodes/relation.h"
37 #include "utils/datum.h"
38 #include "utils/rel.h"
39
40 static void outChar(StringInfo str, char c);
41
42
43 /*
44 * Macros to simplify output of different kinds of fields. Use these
45 * wherever possible to reduce the chance for silly typos. Note that these
46 * hard-wire conventions about the names of the local variables in an Out
47 * routine.
48 */
49
50 /* Write the label for the node type */
51 #define WRITE_NODE_TYPE(nodelabel) \
52 appendStringInfoString(str, nodelabel)
53
54 /* Write an integer field (anything written as ":fldname %d") */
55 #define WRITE_INT_FIELD(fldname) \
56 appendStringInfo(str, " :" CppAsString(fldname) " %d", node->fldname)
57
58 /* Write an unsigned integer field (anything written as ":fldname %u") */
59 #define WRITE_UINT_FIELD(fldname) \
60 appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
61
62 /* Write an OID field (don't hard-wire assumption that OID is same as uint) */
63 #define WRITE_OID_FIELD(fldname) \
64 appendStringInfo(str, " :" CppAsString(fldname) " %u", node->fldname)
65
66 /* Write a long-integer field */
67 #define WRITE_LONG_FIELD(fldname) \
68 appendStringInfo(str, " :" CppAsString(fldname) " %ld", node->fldname)
69
70 /* Write a char field (ie, one ascii character) */
71 #define WRITE_CHAR_FIELD(fldname) \
72 (appendStringInfo(str, " :" CppAsString(fldname) " "), \
73 outChar(str, node->fldname))
74
75 /* Write an enumerated-type field as an integer code */
76 #define WRITE_ENUM_FIELD(fldname, enumtype) \
77 appendStringInfo(str, " :" CppAsString(fldname) " %d", \
78 (int) node->fldname)
79
80 /* Write a float field --- caller must give format to define precision */
81 #define WRITE_FLOAT_FIELD(fldname,format) \
82 appendStringInfo(str, " :" CppAsString(fldname) " " format, node->fldname)
83
84 /* Write a boolean field */
85 #define WRITE_BOOL_FIELD(fldname) \
86 appendStringInfo(str, " :" CppAsString(fldname) " %s", \
87 booltostr(node->fldname))
88
89 /* Write a character-string (possibly NULL) field */
90 #define WRITE_STRING_FIELD(fldname) \
91 (appendStringInfo(str, " :" CppAsString(fldname) " "), \
92 outToken(str, node->fldname))
93
94 /* Write a parse location field (actually same as INT case) */
95 #define WRITE_LOCATION_FIELD(fldname) \
96 appendStringInfo(str, " :" CppAsString(fldname) " %d", node->fldname)
97
98 /* Write a Node field */
99 #define WRITE_NODE_FIELD(fldname) \
100 (appendStringInfo(str, " :" CppAsString(fldname) " "), \
101 outNode(str, node->fldname))
102
103 /* Write a bitmapset field */
104 #define WRITE_BITMAPSET_FIELD(fldname) \
105 (appendStringInfo(str, " :" CppAsString(fldname) " "), \
106 outBitmapset(str, node->fldname))
107
108
109 #define booltostr(x) ((x) ? "true" : "false")
110
111
112 /*
113 * outToken
114 * Convert an ordinary string (eg, an identifier) into a form that
115 * will be decoded back to a plain token by read.c's functions.
116 *
117 * If a null or empty string is given, it is encoded as "<>".
118 */
119 void
outToken(StringInfo str,const char * s)120 outToken(StringInfo str, const char *s)
121 {
122 if (s == NULL || *s == '\0')
123 {
124 appendStringInfoString(str, "<>");
125 return;
126 }
127
128 /*
129 * Look for characters or patterns that are treated specially by read.c
130 * (either in pg_strtok() or in nodeRead()), and therefore need a
131 * protective backslash.
132 */
133 /* These characters only need to be quoted at the start of the string */
134 if (*s == '<' ||
135 *s == '"' ||
136 isdigit((unsigned char) *s) ||
137 ((*s == '+' || *s == '-') &&
138 (isdigit((unsigned char) s[1]) || s[1] == '.')))
139 appendStringInfoChar(str, '\\');
140 while (*s)
141 {
142 /* These chars must be backslashed anywhere in the string */
143 if (*s == ' ' || *s == '\n' || *s == '\t' ||
144 *s == '(' || *s == ')' || *s == '{' || *s == '}' ||
145 *s == '\\')
146 appendStringInfoChar(str, '\\');
147 appendStringInfoChar(str, *s++);
148 }
149 }
150
151 /*
152 * Convert one char. Goes through outToken() so that special characters are
153 * escaped.
154 */
155 static void
outChar(StringInfo str,char c)156 outChar(StringInfo str, char c)
157 {
158 char in[2];
159
160 in[0] = c;
161 in[1] = '\0';
162
163 outToken(str, in);
164 }
165
166 static void
_outList(StringInfo str,const List * node)167 _outList(StringInfo str, const List *node)
168 {
169 const ListCell *lc;
170
171 appendStringInfoChar(str, '(');
172
173 if (IsA(node, IntList))
174 appendStringInfoChar(str, 'i');
175 else if (IsA(node, OidList))
176 appendStringInfoChar(str, 'o');
177
178 foreach(lc, node)
179 {
180 /*
181 * For the sake of backward compatibility, we emit a slightly
182 * different whitespace format for lists of nodes vs. other types of
183 * lists. XXX: is this necessary?
184 */
185 if (IsA(node, List))
186 {
187 outNode(str, lfirst(lc));
188 if (lnext(lc))
189 appendStringInfoChar(str, ' ');
190 }
191 else if (IsA(node, IntList))
192 appendStringInfo(str, " %d", lfirst_int(lc));
193 else if (IsA(node, OidList))
194 appendStringInfo(str, " %u", lfirst_oid(lc));
195 else
196 elog(ERROR, "unrecognized list node type: %d",
197 (int) node->type);
198 }
199
200 appendStringInfoChar(str, ')');
201 }
202
203 /*
204 * outBitmapset -
205 * converts a bitmap set of integers
206 *
207 * Note: the output format is "(b int int ...)", similar to an integer List.
208 */
209 void
outBitmapset(StringInfo str,const Bitmapset * bms)210 outBitmapset(StringInfo str, const Bitmapset *bms)
211 {
212 int x;
213
214 appendStringInfoChar(str, '(');
215 appendStringInfoChar(str, 'b');
216 x = -1;
217 while ((x = bms_next_member(bms, x)) >= 0)
218 appendStringInfo(str, " %d", x);
219 appendStringInfoChar(str, ')');
220 }
221
222 /*
223 * Print the value of a Datum given its type.
224 */
225 void
outDatum(StringInfo str,Datum value,int typlen,bool typbyval)226 outDatum(StringInfo str, Datum value, int typlen, bool typbyval)
227 {
228 Size length,
229 i;
230 char *s;
231
232 length = datumGetSize(value, typbyval, typlen);
233
234 if (typbyval)
235 {
236 s = (char *) (&value);
237 appendStringInfo(str, "%u [ ", (unsigned int) length);
238 for (i = 0; i < (Size) sizeof(Datum); i++)
239 appendStringInfo(str, "%d ", (int) (s[i]));
240 appendStringInfoChar(str, ']');
241 }
242 else
243 {
244 s = (char *) DatumGetPointer(value);
245 if (!PointerIsValid(s))
246 appendStringInfoString(str, "0 [ ]");
247 else
248 {
249 appendStringInfo(str, "%u [ ", (unsigned int) length);
250 for (i = 0; i < length; i++)
251 appendStringInfo(str, "%d ", (int) (s[i]));
252 appendStringInfoChar(str, ']');
253 }
254 }
255 }
256
257
258 /*
259 * Stuff from plannodes.h
260 */
261
262 static void
_outPlannedStmt(StringInfo str,const PlannedStmt * node)263 _outPlannedStmt(StringInfo str, const PlannedStmt *node)
264 {
265 WRITE_NODE_TYPE("PLANNEDSTMT");
266
267 WRITE_ENUM_FIELD(commandType, CmdType);
268 WRITE_UINT_FIELD(queryId);
269 WRITE_BOOL_FIELD(hasReturning);
270 WRITE_BOOL_FIELD(hasModifyingCTE);
271 WRITE_BOOL_FIELD(canSetTag);
272 WRITE_BOOL_FIELD(transientPlan);
273 WRITE_BOOL_FIELD(dependsOnRole);
274 WRITE_BOOL_FIELD(parallelModeNeeded);
275 WRITE_NODE_FIELD(planTree);
276 WRITE_NODE_FIELD(rtable);
277 WRITE_NODE_FIELD(resultRelations);
278 WRITE_NODE_FIELD(nonleafResultRelations);
279 WRITE_NODE_FIELD(rootResultRelations);
280 WRITE_NODE_FIELD(subplans);
281 WRITE_BITMAPSET_FIELD(rewindPlanIDs);
282 WRITE_NODE_FIELD(rowMarks);
283 WRITE_NODE_FIELD(relationOids);
284 WRITE_NODE_FIELD(invalItems);
285 WRITE_INT_FIELD(nParamExec);
286 WRITE_NODE_FIELD(utilityStmt);
287 WRITE_LOCATION_FIELD(stmt_location);
288 WRITE_LOCATION_FIELD(stmt_len);
289 }
290
291 /*
292 * print the basic stuff of all nodes that inherit from Plan
293 */
294 static void
_outPlanInfo(StringInfo str,const Plan * node)295 _outPlanInfo(StringInfo str, const Plan *node)
296 {
297 WRITE_FLOAT_FIELD(startup_cost, "%.2f");
298 WRITE_FLOAT_FIELD(total_cost, "%.2f");
299 WRITE_FLOAT_FIELD(plan_rows, "%.0f");
300 WRITE_INT_FIELD(plan_width);
301 WRITE_BOOL_FIELD(parallel_aware);
302 WRITE_BOOL_FIELD(parallel_safe);
303 WRITE_INT_FIELD(plan_node_id);
304 WRITE_NODE_FIELD(targetlist);
305 WRITE_NODE_FIELD(qual);
306 WRITE_NODE_FIELD(lefttree);
307 WRITE_NODE_FIELD(righttree);
308 WRITE_NODE_FIELD(initPlan);
309 WRITE_BITMAPSET_FIELD(extParam);
310 WRITE_BITMAPSET_FIELD(allParam);
311 }
312
313 /*
314 * print the basic stuff of all nodes that inherit from Scan
315 */
316 static void
_outScanInfo(StringInfo str,const Scan * node)317 _outScanInfo(StringInfo str, const Scan *node)
318 {
319 _outPlanInfo(str, (const Plan *) node);
320
321 WRITE_UINT_FIELD(scanrelid);
322 }
323
324 /*
325 * print the basic stuff of all nodes that inherit from Join
326 */
327 static void
_outJoinPlanInfo(StringInfo str,const Join * node)328 _outJoinPlanInfo(StringInfo str, const Join *node)
329 {
330 _outPlanInfo(str, (const Plan *) node);
331
332 WRITE_ENUM_FIELD(jointype, JoinType);
333 WRITE_BOOL_FIELD(inner_unique);
334 WRITE_NODE_FIELD(joinqual);
335 }
336
337
338 static void
_outPlan(StringInfo str,const Plan * node)339 _outPlan(StringInfo str, const Plan *node)
340 {
341 WRITE_NODE_TYPE("PLAN");
342
343 _outPlanInfo(str, (const Plan *) node);
344 }
345
346 static void
_outResult(StringInfo str,const Result * node)347 _outResult(StringInfo str, const Result *node)
348 {
349 WRITE_NODE_TYPE("RESULT");
350
351 _outPlanInfo(str, (const Plan *) node);
352
353 WRITE_NODE_FIELD(resconstantqual);
354 }
355
356 static void
_outProjectSet(StringInfo str,const ProjectSet * node)357 _outProjectSet(StringInfo str, const ProjectSet *node)
358 {
359 WRITE_NODE_TYPE("PROJECTSET");
360
361 _outPlanInfo(str, (const Plan *) node);
362 }
363
364 static void
_outModifyTable(StringInfo str,const ModifyTable * node)365 _outModifyTable(StringInfo str, const ModifyTable *node)
366 {
367 WRITE_NODE_TYPE("MODIFYTABLE");
368
369 _outPlanInfo(str, (const Plan *) node);
370
371 WRITE_ENUM_FIELD(operation, CmdType);
372 WRITE_BOOL_FIELD(canSetTag);
373 WRITE_UINT_FIELD(nominalRelation);
374 WRITE_NODE_FIELD(partitioned_rels);
375 WRITE_NODE_FIELD(resultRelations);
376 WRITE_INT_FIELD(resultRelIndex);
377 WRITE_INT_FIELD(rootResultRelIndex);
378 WRITE_NODE_FIELD(plans);
379 WRITE_NODE_FIELD(withCheckOptionLists);
380 WRITE_NODE_FIELD(returningLists);
381 WRITE_NODE_FIELD(fdwPrivLists);
382 WRITE_BITMAPSET_FIELD(fdwDirectModifyPlans);
383 WRITE_NODE_FIELD(rowMarks);
384 WRITE_INT_FIELD(epqParam);
385 WRITE_ENUM_FIELD(onConflictAction, OnConflictAction);
386 WRITE_NODE_FIELD(arbiterIndexes);
387 WRITE_NODE_FIELD(onConflictSet);
388 WRITE_NODE_FIELD(onConflictWhere);
389 WRITE_UINT_FIELD(exclRelRTI);
390 WRITE_NODE_FIELD(exclRelTlist);
391 }
392
393 static void
_outAppend(StringInfo str,const Append * node)394 _outAppend(StringInfo str, const Append *node)
395 {
396 WRITE_NODE_TYPE("APPEND");
397
398 _outPlanInfo(str, (const Plan *) node);
399
400 WRITE_NODE_FIELD(partitioned_rels);
401 WRITE_NODE_FIELD(appendplans);
402 }
403
404 static void
_outMergeAppend(StringInfo str,const MergeAppend * node)405 _outMergeAppend(StringInfo str, const MergeAppend *node)
406 {
407 int i;
408
409 WRITE_NODE_TYPE("MERGEAPPEND");
410
411 _outPlanInfo(str, (const Plan *) node);
412
413 WRITE_NODE_FIELD(partitioned_rels);
414 WRITE_NODE_FIELD(mergeplans);
415
416 WRITE_INT_FIELD(numCols);
417
418 appendStringInfoString(str, " :sortColIdx");
419 for (i = 0; i < node->numCols; i++)
420 appendStringInfo(str, " %d", node->sortColIdx[i]);
421
422 appendStringInfoString(str, " :sortOperators");
423 for (i = 0; i < node->numCols; i++)
424 appendStringInfo(str, " %u", node->sortOperators[i]);
425
426 appendStringInfoString(str, " :collations");
427 for (i = 0; i < node->numCols; i++)
428 appendStringInfo(str, " %u", node->collations[i]);
429
430 appendStringInfoString(str, " :nullsFirst");
431 for (i = 0; i < node->numCols; i++)
432 appendStringInfo(str, " %s", booltostr(node->nullsFirst[i]));
433 }
434
435 static void
_outRecursiveUnion(StringInfo str,const RecursiveUnion * node)436 _outRecursiveUnion(StringInfo str, const RecursiveUnion *node)
437 {
438 int i;
439
440 WRITE_NODE_TYPE("RECURSIVEUNION");
441
442 _outPlanInfo(str, (const Plan *) node);
443
444 WRITE_INT_FIELD(wtParam);
445 WRITE_INT_FIELD(numCols);
446
447 appendStringInfoString(str, " :dupColIdx");
448 for (i = 0; i < node->numCols; i++)
449 appendStringInfo(str, " %d", node->dupColIdx[i]);
450
451 appendStringInfoString(str, " :dupOperators");
452 for (i = 0; i < node->numCols; i++)
453 appendStringInfo(str, " %u", node->dupOperators[i]);
454
455 WRITE_LONG_FIELD(numGroups);
456 }
457
458 static void
_outBitmapAnd(StringInfo str,const BitmapAnd * node)459 _outBitmapAnd(StringInfo str, const BitmapAnd *node)
460 {
461 WRITE_NODE_TYPE("BITMAPAND");
462
463 _outPlanInfo(str, (const Plan *) node);
464
465 WRITE_NODE_FIELD(bitmapplans);
466 }
467
468 static void
_outBitmapOr(StringInfo str,const BitmapOr * node)469 _outBitmapOr(StringInfo str, const BitmapOr *node)
470 {
471 WRITE_NODE_TYPE("BITMAPOR");
472
473 _outPlanInfo(str, (const Plan *) node);
474
475 WRITE_BOOL_FIELD(isshared);
476 WRITE_NODE_FIELD(bitmapplans);
477 }
478
479 static void
_outGather(StringInfo str,const Gather * node)480 _outGather(StringInfo str, const Gather *node)
481 {
482 WRITE_NODE_TYPE("GATHER");
483
484 _outPlanInfo(str, (const Plan *) node);
485
486 WRITE_INT_FIELD(num_workers);
487 WRITE_INT_FIELD(rescan_param);
488 WRITE_BOOL_FIELD(single_copy);
489 WRITE_BOOL_FIELD(invisible);
490 }
491
492 static void
_outGatherMerge(StringInfo str,const GatherMerge * node)493 _outGatherMerge(StringInfo str, const GatherMerge *node)
494 {
495 int i;
496
497 WRITE_NODE_TYPE("GATHERMERGE");
498
499 _outPlanInfo(str, (const Plan *) node);
500
501 WRITE_INT_FIELD(num_workers);
502 WRITE_INT_FIELD(rescan_param);
503 WRITE_INT_FIELD(numCols);
504
505 appendStringInfoString(str, " :sortColIdx");
506 for (i = 0; i < node->numCols; i++)
507 appendStringInfo(str, " %d", node->sortColIdx[i]);
508
509 appendStringInfoString(str, " :sortOperators");
510 for (i = 0; i < node->numCols; i++)
511 appendStringInfo(str, " %u", node->sortOperators[i]);
512
513 appendStringInfoString(str, " :collations");
514 for (i = 0; i < node->numCols; i++)
515 appendStringInfo(str, " %u", node->collations[i]);
516
517 appendStringInfoString(str, " :nullsFirst");
518 for (i = 0; i < node->numCols; i++)
519 appendStringInfo(str, " %s", booltostr(node->nullsFirst[i]));
520 }
521
522 static void
_outScan(StringInfo str,const Scan * node)523 _outScan(StringInfo str, const Scan *node)
524 {
525 WRITE_NODE_TYPE("SCAN");
526
527 _outScanInfo(str, node);
528 }
529
530 static void
_outSeqScan(StringInfo str,const SeqScan * node)531 _outSeqScan(StringInfo str, const SeqScan *node)
532 {
533 WRITE_NODE_TYPE("SEQSCAN");
534
535 _outScanInfo(str, (const Scan *) node);
536 }
537
538 static void
_outSampleScan(StringInfo str,const SampleScan * node)539 _outSampleScan(StringInfo str, const SampleScan *node)
540 {
541 WRITE_NODE_TYPE("SAMPLESCAN");
542
543 _outScanInfo(str, (const Scan *) node);
544
545 WRITE_NODE_FIELD(tablesample);
546 }
547
548 static void
_outIndexScan(StringInfo str,const IndexScan * node)549 _outIndexScan(StringInfo str, const IndexScan *node)
550 {
551 WRITE_NODE_TYPE("INDEXSCAN");
552
553 _outScanInfo(str, (const Scan *) node);
554
555 WRITE_OID_FIELD(indexid);
556 WRITE_NODE_FIELD(indexqual);
557 WRITE_NODE_FIELD(indexqualorig);
558 WRITE_NODE_FIELD(indexorderby);
559 WRITE_NODE_FIELD(indexorderbyorig);
560 WRITE_NODE_FIELD(indexorderbyops);
561 WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
562 }
563
564 static void
_outIndexOnlyScan(StringInfo str,const IndexOnlyScan * node)565 _outIndexOnlyScan(StringInfo str, const IndexOnlyScan *node)
566 {
567 WRITE_NODE_TYPE("INDEXONLYSCAN");
568
569 _outScanInfo(str, (const Scan *) node);
570
571 WRITE_OID_FIELD(indexid);
572 WRITE_NODE_FIELD(indexqual);
573 WRITE_NODE_FIELD(indexorderby);
574 WRITE_NODE_FIELD(indextlist);
575 WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
576 }
577
578 static void
_outBitmapIndexScan(StringInfo str,const BitmapIndexScan * node)579 _outBitmapIndexScan(StringInfo str, const BitmapIndexScan *node)
580 {
581 WRITE_NODE_TYPE("BITMAPINDEXSCAN");
582
583 _outScanInfo(str, (const Scan *) node);
584
585 WRITE_OID_FIELD(indexid);
586 WRITE_BOOL_FIELD(isshared);
587 WRITE_NODE_FIELD(indexqual);
588 WRITE_NODE_FIELD(indexqualorig);
589 }
590
591 static void
_outBitmapHeapScan(StringInfo str,const BitmapHeapScan * node)592 _outBitmapHeapScan(StringInfo str, const BitmapHeapScan *node)
593 {
594 WRITE_NODE_TYPE("BITMAPHEAPSCAN");
595
596 _outScanInfo(str, (const Scan *) node);
597
598 WRITE_NODE_FIELD(bitmapqualorig);
599 }
600
601 static void
_outTidScan(StringInfo str,const TidScan * node)602 _outTidScan(StringInfo str, const TidScan *node)
603 {
604 WRITE_NODE_TYPE("TIDSCAN");
605
606 _outScanInfo(str, (const Scan *) node);
607
608 WRITE_NODE_FIELD(tidquals);
609 }
610
611 static void
_outSubqueryScan(StringInfo str,const SubqueryScan * node)612 _outSubqueryScan(StringInfo str, const SubqueryScan *node)
613 {
614 WRITE_NODE_TYPE("SUBQUERYSCAN");
615
616 _outScanInfo(str, (const Scan *) node);
617
618 WRITE_NODE_FIELD(subplan);
619 }
620
621 static void
_outFunctionScan(StringInfo str,const FunctionScan * node)622 _outFunctionScan(StringInfo str, const FunctionScan *node)
623 {
624 WRITE_NODE_TYPE("FUNCTIONSCAN");
625
626 _outScanInfo(str, (const Scan *) node);
627
628 WRITE_NODE_FIELD(functions);
629 WRITE_BOOL_FIELD(funcordinality);
630 }
631
632 static void
_outTableFuncScan(StringInfo str,const TableFuncScan * node)633 _outTableFuncScan(StringInfo str, const TableFuncScan *node)
634 {
635 WRITE_NODE_TYPE("TABLEFUNCSCAN");
636
637 _outScanInfo(str, (const Scan *) node);
638
639 WRITE_NODE_FIELD(tablefunc);
640 }
641
642 static void
_outValuesScan(StringInfo str,const ValuesScan * node)643 _outValuesScan(StringInfo str, const ValuesScan *node)
644 {
645 WRITE_NODE_TYPE("VALUESSCAN");
646
647 _outScanInfo(str, (const Scan *) node);
648
649 WRITE_NODE_FIELD(values_lists);
650 }
651
652 static void
_outCteScan(StringInfo str,const CteScan * node)653 _outCteScan(StringInfo str, const CteScan *node)
654 {
655 WRITE_NODE_TYPE("CTESCAN");
656
657 _outScanInfo(str, (const Scan *) node);
658
659 WRITE_INT_FIELD(ctePlanId);
660 WRITE_INT_FIELD(cteParam);
661 }
662
663 static void
_outNamedTuplestoreScan(StringInfo str,const NamedTuplestoreScan * node)664 _outNamedTuplestoreScan(StringInfo str, const NamedTuplestoreScan *node)
665 {
666 WRITE_NODE_TYPE("NAMEDTUPLESTORESCAN");
667
668 _outScanInfo(str, (const Scan *) node);
669
670 WRITE_STRING_FIELD(enrname);
671 }
672
673 static void
_outWorkTableScan(StringInfo str,const WorkTableScan * node)674 _outWorkTableScan(StringInfo str, const WorkTableScan *node)
675 {
676 WRITE_NODE_TYPE("WORKTABLESCAN");
677
678 _outScanInfo(str, (const Scan *) node);
679
680 WRITE_INT_FIELD(wtParam);
681 }
682
683 static void
_outForeignScan(StringInfo str,const ForeignScan * node)684 _outForeignScan(StringInfo str, const ForeignScan *node)
685 {
686 WRITE_NODE_TYPE("FOREIGNSCAN");
687
688 _outScanInfo(str, (const Scan *) node);
689
690 WRITE_ENUM_FIELD(operation, CmdType);
691 WRITE_OID_FIELD(fs_server);
692 WRITE_NODE_FIELD(fdw_exprs);
693 WRITE_NODE_FIELD(fdw_private);
694 WRITE_NODE_FIELD(fdw_scan_tlist);
695 WRITE_NODE_FIELD(fdw_recheck_quals);
696 WRITE_BITMAPSET_FIELD(fs_relids);
697 WRITE_BOOL_FIELD(fsSystemCol);
698 }
699
700 static void
_outCustomScan(StringInfo str,const CustomScan * node)701 _outCustomScan(StringInfo str, const CustomScan *node)
702 {
703 WRITE_NODE_TYPE("CUSTOMSCAN");
704
705 _outScanInfo(str, (const Scan *) node);
706
707 WRITE_UINT_FIELD(flags);
708 WRITE_NODE_FIELD(custom_plans);
709 WRITE_NODE_FIELD(custom_exprs);
710 WRITE_NODE_FIELD(custom_private);
711 WRITE_NODE_FIELD(custom_scan_tlist);
712 WRITE_BITMAPSET_FIELD(custom_relids);
713 /* CustomName is a key to lookup CustomScanMethods */
714 appendStringInfoString(str, " :methods ");
715 outToken(str, node->methods->CustomName);
716 }
717
718 static void
_outJoin(StringInfo str,const Join * node)719 _outJoin(StringInfo str, const Join *node)
720 {
721 WRITE_NODE_TYPE("JOIN");
722
723 _outJoinPlanInfo(str, (const Join *) node);
724 }
725
726 static void
_outNestLoop(StringInfo str,const NestLoop * node)727 _outNestLoop(StringInfo str, const NestLoop *node)
728 {
729 WRITE_NODE_TYPE("NESTLOOP");
730
731 _outJoinPlanInfo(str, (const Join *) node);
732
733 WRITE_NODE_FIELD(nestParams);
734 }
735
736 static void
_outMergeJoin(StringInfo str,const MergeJoin * node)737 _outMergeJoin(StringInfo str, const MergeJoin *node)
738 {
739 int numCols;
740 int i;
741
742 WRITE_NODE_TYPE("MERGEJOIN");
743
744 _outJoinPlanInfo(str, (const Join *) node);
745
746 WRITE_BOOL_FIELD(skip_mark_restore);
747 WRITE_NODE_FIELD(mergeclauses);
748
749 numCols = list_length(node->mergeclauses);
750
751 appendStringInfoString(str, " :mergeFamilies");
752 for (i = 0; i < numCols; i++)
753 appendStringInfo(str, " %u", node->mergeFamilies[i]);
754
755 appendStringInfoString(str, " :mergeCollations");
756 for (i = 0; i < numCols; i++)
757 appendStringInfo(str, " %u", node->mergeCollations[i]);
758
759 appendStringInfoString(str, " :mergeStrategies");
760 for (i = 0; i < numCols; i++)
761 appendStringInfo(str, " %d", node->mergeStrategies[i]);
762
763 appendStringInfoString(str, " :mergeNullsFirst");
764 for (i = 0; i < numCols; i++)
765 appendStringInfo(str, " %s", booltostr(node->mergeNullsFirst[i]));
766 }
767
768 static void
_outHashJoin(StringInfo str,const HashJoin * node)769 _outHashJoin(StringInfo str, const HashJoin *node)
770 {
771 WRITE_NODE_TYPE("HASHJOIN");
772
773 _outJoinPlanInfo(str, (const Join *) node);
774
775 WRITE_NODE_FIELD(hashclauses);
776 }
777
778 static void
_outAgg(StringInfo str,const Agg * node)779 _outAgg(StringInfo str, const Agg *node)
780 {
781 int i;
782
783 WRITE_NODE_TYPE("AGG");
784
785 _outPlanInfo(str, (const Plan *) node);
786
787 WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
788 WRITE_ENUM_FIELD(aggsplit, AggSplit);
789 WRITE_INT_FIELD(numCols);
790
791 appendStringInfoString(str, " :grpColIdx");
792 for (i = 0; i < node->numCols; i++)
793 appendStringInfo(str, " %d", node->grpColIdx[i]);
794
795 appendStringInfoString(str, " :grpOperators");
796 for (i = 0; i < node->numCols; i++)
797 appendStringInfo(str, " %u", node->grpOperators[i]);
798
799 WRITE_LONG_FIELD(numGroups);
800 WRITE_BITMAPSET_FIELD(aggParams);
801 WRITE_NODE_FIELD(groupingSets);
802 WRITE_NODE_FIELD(chain);
803 }
804
805 static void
_outWindowAgg(StringInfo str,const WindowAgg * node)806 _outWindowAgg(StringInfo str, const WindowAgg *node)
807 {
808 int i;
809
810 WRITE_NODE_TYPE("WINDOWAGG");
811
812 _outPlanInfo(str, (const Plan *) node);
813
814 WRITE_UINT_FIELD(winref);
815 WRITE_INT_FIELD(partNumCols);
816
817 appendStringInfoString(str, " :partColIdx");
818 for (i = 0; i < node->partNumCols; i++)
819 appendStringInfo(str, " %d", node->partColIdx[i]);
820
821 appendStringInfoString(str, " :partOperations");
822 for (i = 0; i < node->partNumCols; i++)
823 appendStringInfo(str, " %u", node->partOperators[i]);
824
825 WRITE_INT_FIELD(ordNumCols);
826
827 appendStringInfoString(str, " :ordColIdx");
828 for (i = 0; i < node->ordNumCols; i++)
829 appendStringInfo(str, " %d", node->ordColIdx[i]);
830
831 appendStringInfoString(str, " :ordOperations");
832 for (i = 0; i < node->ordNumCols; i++)
833 appendStringInfo(str, " %u", node->ordOperators[i]);
834
835 WRITE_INT_FIELD(frameOptions);
836 WRITE_NODE_FIELD(startOffset);
837 WRITE_NODE_FIELD(endOffset);
838 }
839
840 static void
_outGroup(StringInfo str,const Group * node)841 _outGroup(StringInfo str, const Group *node)
842 {
843 int i;
844
845 WRITE_NODE_TYPE("GROUP");
846
847 _outPlanInfo(str, (const Plan *) node);
848
849 WRITE_INT_FIELD(numCols);
850
851 appendStringInfoString(str, " :grpColIdx");
852 for (i = 0; i < node->numCols; i++)
853 appendStringInfo(str, " %d", node->grpColIdx[i]);
854
855 appendStringInfoString(str, " :grpOperators");
856 for (i = 0; i < node->numCols; i++)
857 appendStringInfo(str, " %u", node->grpOperators[i]);
858 }
859
860 static void
_outMaterial(StringInfo str,const Material * node)861 _outMaterial(StringInfo str, const Material *node)
862 {
863 WRITE_NODE_TYPE("MATERIAL");
864
865 _outPlanInfo(str, (const Plan *) node);
866 }
867
868 static void
_outSort(StringInfo str,const Sort * node)869 _outSort(StringInfo str, const Sort *node)
870 {
871 int i;
872
873 WRITE_NODE_TYPE("SORT");
874
875 _outPlanInfo(str, (const Plan *) node);
876
877 WRITE_INT_FIELD(numCols);
878
879 appendStringInfoString(str, " :sortColIdx");
880 for (i = 0; i < node->numCols; i++)
881 appendStringInfo(str, " %d", node->sortColIdx[i]);
882
883 appendStringInfoString(str, " :sortOperators");
884 for (i = 0; i < node->numCols; i++)
885 appendStringInfo(str, " %u", node->sortOperators[i]);
886
887 appendStringInfoString(str, " :collations");
888 for (i = 0; i < node->numCols; i++)
889 appendStringInfo(str, " %u", node->collations[i]);
890
891 appendStringInfoString(str, " :nullsFirst");
892 for (i = 0; i < node->numCols; i++)
893 appendStringInfo(str, " %s", booltostr(node->nullsFirst[i]));
894 }
895
896 static void
_outUnique(StringInfo str,const Unique * node)897 _outUnique(StringInfo str, const Unique *node)
898 {
899 int i;
900
901 WRITE_NODE_TYPE("UNIQUE");
902
903 _outPlanInfo(str, (const Plan *) node);
904
905 WRITE_INT_FIELD(numCols);
906
907 appendStringInfoString(str, " :uniqColIdx");
908 for (i = 0; i < node->numCols; i++)
909 appendStringInfo(str, " %d", node->uniqColIdx[i]);
910
911 appendStringInfoString(str, " :uniqOperators");
912 for (i = 0; i < node->numCols; i++)
913 appendStringInfo(str, " %u", node->uniqOperators[i]);
914 }
915
916 static void
_outHash(StringInfo str,const Hash * node)917 _outHash(StringInfo str, const Hash *node)
918 {
919 WRITE_NODE_TYPE("HASH");
920
921 _outPlanInfo(str, (const Plan *) node);
922
923 WRITE_OID_FIELD(skewTable);
924 WRITE_INT_FIELD(skewColumn);
925 WRITE_BOOL_FIELD(skewInherit);
926 }
927
928 static void
_outSetOp(StringInfo str,const SetOp * node)929 _outSetOp(StringInfo str, const SetOp *node)
930 {
931 int i;
932
933 WRITE_NODE_TYPE("SETOP");
934
935 _outPlanInfo(str, (const Plan *) node);
936
937 WRITE_ENUM_FIELD(cmd, SetOpCmd);
938 WRITE_ENUM_FIELD(strategy, SetOpStrategy);
939 WRITE_INT_FIELD(numCols);
940
941 appendStringInfoString(str, " :dupColIdx");
942 for (i = 0; i < node->numCols; i++)
943 appendStringInfo(str, " %d", node->dupColIdx[i]);
944
945 appendStringInfoString(str, " :dupOperators");
946 for (i = 0; i < node->numCols; i++)
947 appendStringInfo(str, " %u", node->dupOperators[i]);
948
949 WRITE_INT_FIELD(flagColIdx);
950 WRITE_INT_FIELD(firstFlag);
951 WRITE_LONG_FIELD(numGroups);
952 }
953
954 static void
_outLockRows(StringInfo str,const LockRows * node)955 _outLockRows(StringInfo str, const LockRows *node)
956 {
957 WRITE_NODE_TYPE("LOCKROWS");
958
959 _outPlanInfo(str, (const Plan *) node);
960
961 WRITE_NODE_FIELD(rowMarks);
962 WRITE_INT_FIELD(epqParam);
963 }
964
965 static void
_outLimit(StringInfo str,const Limit * node)966 _outLimit(StringInfo str, const Limit *node)
967 {
968 WRITE_NODE_TYPE("LIMIT");
969
970 _outPlanInfo(str, (const Plan *) node);
971
972 WRITE_NODE_FIELD(limitOffset);
973 WRITE_NODE_FIELD(limitCount);
974 }
975
976 static void
_outNestLoopParam(StringInfo str,const NestLoopParam * node)977 _outNestLoopParam(StringInfo str, const NestLoopParam *node)
978 {
979 WRITE_NODE_TYPE("NESTLOOPPARAM");
980
981 WRITE_INT_FIELD(paramno);
982 WRITE_NODE_FIELD(paramval);
983 }
984
985 static void
_outPlanRowMark(StringInfo str,const PlanRowMark * node)986 _outPlanRowMark(StringInfo str, const PlanRowMark *node)
987 {
988 WRITE_NODE_TYPE("PLANROWMARK");
989
990 WRITE_UINT_FIELD(rti);
991 WRITE_UINT_FIELD(prti);
992 WRITE_UINT_FIELD(rowmarkId);
993 WRITE_ENUM_FIELD(markType, RowMarkType);
994 WRITE_INT_FIELD(allMarkTypes);
995 WRITE_ENUM_FIELD(strength, LockClauseStrength);
996 WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
997 WRITE_BOOL_FIELD(isParent);
998 }
999
1000 static void
_outPlanInvalItem(StringInfo str,const PlanInvalItem * node)1001 _outPlanInvalItem(StringInfo str, const PlanInvalItem *node)
1002 {
1003 WRITE_NODE_TYPE("PLANINVALITEM");
1004
1005 WRITE_INT_FIELD(cacheId);
1006 WRITE_UINT_FIELD(hashValue);
1007 }
1008
1009 /*****************************************************************************
1010 *
1011 * Stuff from primnodes.h.
1012 *
1013 *****************************************************************************/
1014
1015 static void
_outAlias(StringInfo str,const Alias * node)1016 _outAlias(StringInfo str, const Alias *node)
1017 {
1018 WRITE_NODE_TYPE("ALIAS");
1019
1020 WRITE_STRING_FIELD(aliasname);
1021 WRITE_NODE_FIELD(colnames);
1022 }
1023
1024 static void
_outRangeVar(StringInfo str,const RangeVar * node)1025 _outRangeVar(StringInfo str, const RangeVar *node)
1026 {
1027 WRITE_NODE_TYPE("RANGEVAR");
1028
1029 /*
1030 * we deliberately ignore catalogname here, since it is presently not
1031 * semantically meaningful
1032 */
1033 WRITE_STRING_FIELD(schemaname);
1034 WRITE_STRING_FIELD(relname);
1035 WRITE_BOOL_FIELD(inh);
1036 WRITE_CHAR_FIELD(relpersistence);
1037 WRITE_NODE_FIELD(alias);
1038 WRITE_LOCATION_FIELD(location);
1039 }
1040
1041 static void
_outTableFunc(StringInfo str,const TableFunc * node)1042 _outTableFunc(StringInfo str, const TableFunc *node)
1043 {
1044 WRITE_NODE_TYPE("TABLEFUNC");
1045
1046 WRITE_NODE_FIELD(ns_uris);
1047 WRITE_NODE_FIELD(ns_names);
1048 WRITE_NODE_FIELD(docexpr);
1049 WRITE_NODE_FIELD(rowexpr);
1050 WRITE_NODE_FIELD(colnames);
1051 WRITE_NODE_FIELD(coltypes);
1052 WRITE_NODE_FIELD(coltypmods);
1053 WRITE_NODE_FIELD(colcollations);
1054 WRITE_NODE_FIELD(colexprs);
1055 WRITE_NODE_FIELD(coldefexprs);
1056 WRITE_BITMAPSET_FIELD(notnulls);
1057 WRITE_INT_FIELD(ordinalitycol);
1058 WRITE_LOCATION_FIELD(location);
1059 }
1060
1061 static void
_outIntoClause(StringInfo str,const IntoClause * node)1062 _outIntoClause(StringInfo str, const IntoClause *node)
1063 {
1064 WRITE_NODE_TYPE("INTOCLAUSE");
1065
1066 WRITE_NODE_FIELD(rel);
1067 WRITE_NODE_FIELD(colNames);
1068 WRITE_NODE_FIELD(options);
1069 WRITE_ENUM_FIELD(onCommit, OnCommitAction);
1070 WRITE_STRING_FIELD(tableSpaceName);
1071 WRITE_NODE_FIELD(viewQuery);
1072 WRITE_BOOL_FIELD(skipData);
1073 }
1074
1075 static void
_outVar(StringInfo str,const Var * node)1076 _outVar(StringInfo str, const Var *node)
1077 {
1078 WRITE_NODE_TYPE("VAR");
1079
1080 WRITE_UINT_FIELD(varno);
1081 WRITE_INT_FIELD(varattno);
1082 WRITE_OID_FIELD(vartype);
1083 WRITE_INT_FIELD(vartypmod);
1084 WRITE_OID_FIELD(varcollid);
1085 WRITE_UINT_FIELD(varlevelsup);
1086 WRITE_UINT_FIELD(varnoold);
1087 WRITE_INT_FIELD(varoattno);
1088 WRITE_LOCATION_FIELD(location);
1089 }
1090
1091 static void
_outConst(StringInfo str,const Const * node)1092 _outConst(StringInfo str, const Const *node)
1093 {
1094 WRITE_NODE_TYPE("CONST");
1095
1096 WRITE_OID_FIELD(consttype);
1097 WRITE_INT_FIELD(consttypmod);
1098 WRITE_OID_FIELD(constcollid);
1099 WRITE_INT_FIELD(constlen);
1100 WRITE_BOOL_FIELD(constbyval);
1101 WRITE_BOOL_FIELD(constisnull);
1102 WRITE_LOCATION_FIELD(location);
1103
1104 appendStringInfoString(str, " :constvalue ");
1105 if (node->constisnull)
1106 appendStringInfoString(str, "<>");
1107 else
1108 outDatum(str, node->constvalue, node->constlen, node->constbyval);
1109 }
1110
1111 static void
_outParam(StringInfo str,const Param * node)1112 _outParam(StringInfo str, const Param *node)
1113 {
1114 WRITE_NODE_TYPE("PARAM");
1115
1116 WRITE_ENUM_FIELD(paramkind, ParamKind);
1117 WRITE_INT_FIELD(paramid);
1118 WRITE_OID_FIELD(paramtype);
1119 WRITE_INT_FIELD(paramtypmod);
1120 WRITE_OID_FIELD(paramcollid);
1121 WRITE_LOCATION_FIELD(location);
1122 }
1123
1124 static void
_outAggref(StringInfo str,const Aggref * node)1125 _outAggref(StringInfo str, const Aggref *node)
1126 {
1127 WRITE_NODE_TYPE("AGGREF");
1128
1129 WRITE_OID_FIELD(aggfnoid);
1130 WRITE_OID_FIELD(aggtype);
1131 WRITE_OID_FIELD(aggcollid);
1132 WRITE_OID_FIELD(inputcollid);
1133 WRITE_OID_FIELD(aggtranstype);
1134 WRITE_NODE_FIELD(aggargtypes);
1135 WRITE_NODE_FIELD(aggdirectargs);
1136 WRITE_NODE_FIELD(args);
1137 WRITE_NODE_FIELD(aggorder);
1138 WRITE_NODE_FIELD(aggdistinct);
1139 WRITE_NODE_FIELD(aggfilter);
1140 WRITE_BOOL_FIELD(aggstar);
1141 WRITE_BOOL_FIELD(aggvariadic);
1142 WRITE_CHAR_FIELD(aggkind);
1143 WRITE_UINT_FIELD(agglevelsup);
1144 WRITE_ENUM_FIELD(aggsplit, AggSplit);
1145 WRITE_LOCATION_FIELD(location);
1146 }
1147
1148 static void
_outGroupingFunc(StringInfo str,const GroupingFunc * node)1149 _outGroupingFunc(StringInfo str, const GroupingFunc *node)
1150 {
1151 WRITE_NODE_TYPE("GROUPINGFUNC");
1152
1153 WRITE_NODE_FIELD(args);
1154 WRITE_NODE_FIELD(refs);
1155 WRITE_NODE_FIELD(cols);
1156 WRITE_UINT_FIELD(agglevelsup);
1157 WRITE_LOCATION_FIELD(location);
1158 }
1159
1160 static void
_outWindowFunc(StringInfo str,const WindowFunc * node)1161 _outWindowFunc(StringInfo str, const WindowFunc *node)
1162 {
1163 WRITE_NODE_TYPE("WINDOWFUNC");
1164
1165 WRITE_OID_FIELD(winfnoid);
1166 WRITE_OID_FIELD(wintype);
1167 WRITE_OID_FIELD(wincollid);
1168 WRITE_OID_FIELD(inputcollid);
1169 WRITE_NODE_FIELD(args);
1170 WRITE_NODE_FIELD(aggfilter);
1171 WRITE_UINT_FIELD(winref);
1172 WRITE_BOOL_FIELD(winstar);
1173 WRITE_BOOL_FIELD(winagg);
1174 WRITE_LOCATION_FIELD(location);
1175 }
1176
1177 static void
_outArrayRef(StringInfo str,const ArrayRef * node)1178 _outArrayRef(StringInfo str, const ArrayRef *node)
1179 {
1180 WRITE_NODE_TYPE("ARRAYREF");
1181
1182 WRITE_OID_FIELD(refarraytype);
1183 WRITE_OID_FIELD(refelemtype);
1184 WRITE_INT_FIELD(reftypmod);
1185 WRITE_OID_FIELD(refcollid);
1186 WRITE_NODE_FIELD(refupperindexpr);
1187 WRITE_NODE_FIELD(reflowerindexpr);
1188 WRITE_NODE_FIELD(refexpr);
1189 WRITE_NODE_FIELD(refassgnexpr);
1190 }
1191
1192 static void
_outFuncExpr(StringInfo str,const FuncExpr * node)1193 _outFuncExpr(StringInfo str, const FuncExpr *node)
1194 {
1195 WRITE_NODE_TYPE("FUNCEXPR");
1196
1197 WRITE_OID_FIELD(funcid);
1198 WRITE_OID_FIELD(funcresulttype);
1199 WRITE_BOOL_FIELD(funcretset);
1200 WRITE_BOOL_FIELD(funcvariadic);
1201 WRITE_ENUM_FIELD(funcformat, CoercionForm);
1202 WRITE_OID_FIELD(funccollid);
1203 WRITE_OID_FIELD(inputcollid);
1204 WRITE_NODE_FIELD(args);
1205 WRITE_LOCATION_FIELD(location);
1206 }
1207
1208 static void
_outNamedArgExpr(StringInfo str,const NamedArgExpr * node)1209 _outNamedArgExpr(StringInfo str, const NamedArgExpr *node)
1210 {
1211 WRITE_NODE_TYPE("NAMEDARGEXPR");
1212
1213 WRITE_NODE_FIELD(arg);
1214 WRITE_STRING_FIELD(name);
1215 WRITE_INT_FIELD(argnumber);
1216 WRITE_LOCATION_FIELD(location);
1217 }
1218
1219 static void
_outOpExpr(StringInfo str,const OpExpr * node)1220 _outOpExpr(StringInfo str, const OpExpr *node)
1221 {
1222 WRITE_NODE_TYPE("OPEXPR");
1223
1224 WRITE_OID_FIELD(opno);
1225 WRITE_OID_FIELD(opfuncid);
1226 WRITE_OID_FIELD(opresulttype);
1227 WRITE_BOOL_FIELD(opretset);
1228 WRITE_OID_FIELD(opcollid);
1229 WRITE_OID_FIELD(inputcollid);
1230 WRITE_NODE_FIELD(args);
1231 WRITE_LOCATION_FIELD(location);
1232 }
1233
1234 static void
_outDistinctExpr(StringInfo str,const DistinctExpr * node)1235 _outDistinctExpr(StringInfo str, const DistinctExpr *node)
1236 {
1237 WRITE_NODE_TYPE("DISTINCTEXPR");
1238
1239 WRITE_OID_FIELD(opno);
1240 WRITE_OID_FIELD(opfuncid);
1241 WRITE_OID_FIELD(opresulttype);
1242 WRITE_BOOL_FIELD(opretset);
1243 WRITE_OID_FIELD(opcollid);
1244 WRITE_OID_FIELD(inputcollid);
1245 WRITE_NODE_FIELD(args);
1246 WRITE_LOCATION_FIELD(location);
1247 }
1248
1249 static void
_outNullIfExpr(StringInfo str,const NullIfExpr * node)1250 _outNullIfExpr(StringInfo str, const NullIfExpr *node)
1251 {
1252 WRITE_NODE_TYPE("NULLIFEXPR");
1253
1254 WRITE_OID_FIELD(opno);
1255 WRITE_OID_FIELD(opfuncid);
1256 WRITE_OID_FIELD(opresulttype);
1257 WRITE_BOOL_FIELD(opretset);
1258 WRITE_OID_FIELD(opcollid);
1259 WRITE_OID_FIELD(inputcollid);
1260 WRITE_NODE_FIELD(args);
1261 WRITE_LOCATION_FIELD(location);
1262 }
1263
1264 static void
_outScalarArrayOpExpr(StringInfo str,const ScalarArrayOpExpr * node)1265 _outScalarArrayOpExpr(StringInfo str, const ScalarArrayOpExpr *node)
1266 {
1267 WRITE_NODE_TYPE("SCALARARRAYOPEXPR");
1268
1269 WRITE_OID_FIELD(opno);
1270 WRITE_OID_FIELD(opfuncid);
1271 WRITE_BOOL_FIELD(useOr);
1272 WRITE_OID_FIELD(inputcollid);
1273 WRITE_NODE_FIELD(args);
1274 WRITE_LOCATION_FIELD(location);
1275 }
1276
1277 static void
_outBoolExpr(StringInfo str,const BoolExpr * node)1278 _outBoolExpr(StringInfo str, const BoolExpr *node)
1279 {
1280 char *opstr = NULL;
1281
1282 WRITE_NODE_TYPE("BOOLEXPR");
1283
1284 /* do-it-yourself enum representation */
1285 switch (node->boolop)
1286 {
1287 case AND_EXPR:
1288 opstr = "and";
1289 break;
1290 case OR_EXPR:
1291 opstr = "or";
1292 break;
1293 case NOT_EXPR:
1294 opstr = "not";
1295 break;
1296 }
1297 appendStringInfoString(str, " :boolop ");
1298 outToken(str, opstr);
1299
1300 WRITE_NODE_FIELD(args);
1301 WRITE_LOCATION_FIELD(location);
1302 }
1303
1304 static void
_outSubLink(StringInfo str,const SubLink * node)1305 _outSubLink(StringInfo str, const SubLink *node)
1306 {
1307 WRITE_NODE_TYPE("SUBLINK");
1308
1309 WRITE_ENUM_FIELD(subLinkType, SubLinkType);
1310 WRITE_INT_FIELD(subLinkId);
1311 WRITE_NODE_FIELD(testexpr);
1312 WRITE_NODE_FIELD(operName);
1313 WRITE_NODE_FIELD(subselect);
1314 WRITE_LOCATION_FIELD(location);
1315 }
1316
1317 static void
_outSubPlan(StringInfo str,const SubPlan * node)1318 _outSubPlan(StringInfo str, const SubPlan *node)
1319 {
1320 WRITE_NODE_TYPE("SUBPLAN");
1321
1322 WRITE_ENUM_FIELD(subLinkType, SubLinkType);
1323 WRITE_NODE_FIELD(testexpr);
1324 WRITE_NODE_FIELD(paramIds);
1325 WRITE_INT_FIELD(plan_id);
1326 WRITE_STRING_FIELD(plan_name);
1327 WRITE_OID_FIELD(firstColType);
1328 WRITE_INT_FIELD(firstColTypmod);
1329 WRITE_OID_FIELD(firstColCollation);
1330 WRITE_BOOL_FIELD(useHashTable);
1331 WRITE_BOOL_FIELD(unknownEqFalse);
1332 WRITE_BOOL_FIELD(parallel_safe);
1333 WRITE_NODE_FIELD(setParam);
1334 WRITE_NODE_FIELD(parParam);
1335 WRITE_NODE_FIELD(args);
1336 WRITE_FLOAT_FIELD(startup_cost, "%.2f");
1337 WRITE_FLOAT_FIELD(per_call_cost, "%.2f");
1338 }
1339
1340 static void
_outAlternativeSubPlan(StringInfo str,const AlternativeSubPlan * node)1341 _outAlternativeSubPlan(StringInfo str, const AlternativeSubPlan *node)
1342 {
1343 WRITE_NODE_TYPE("ALTERNATIVESUBPLAN");
1344
1345 WRITE_NODE_FIELD(subplans);
1346 }
1347
1348 static void
_outFieldSelect(StringInfo str,const FieldSelect * node)1349 _outFieldSelect(StringInfo str, const FieldSelect *node)
1350 {
1351 WRITE_NODE_TYPE("FIELDSELECT");
1352
1353 WRITE_NODE_FIELD(arg);
1354 WRITE_INT_FIELD(fieldnum);
1355 WRITE_OID_FIELD(resulttype);
1356 WRITE_INT_FIELD(resulttypmod);
1357 WRITE_OID_FIELD(resultcollid);
1358 }
1359
1360 static void
_outFieldStore(StringInfo str,const FieldStore * node)1361 _outFieldStore(StringInfo str, const FieldStore *node)
1362 {
1363 WRITE_NODE_TYPE("FIELDSTORE");
1364
1365 WRITE_NODE_FIELD(arg);
1366 WRITE_NODE_FIELD(newvals);
1367 WRITE_NODE_FIELD(fieldnums);
1368 WRITE_OID_FIELD(resulttype);
1369 }
1370
1371 static void
_outRelabelType(StringInfo str,const RelabelType * node)1372 _outRelabelType(StringInfo str, const RelabelType *node)
1373 {
1374 WRITE_NODE_TYPE("RELABELTYPE");
1375
1376 WRITE_NODE_FIELD(arg);
1377 WRITE_OID_FIELD(resulttype);
1378 WRITE_INT_FIELD(resulttypmod);
1379 WRITE_OID_FIELD(resultcollid);
1380 WRITE_ENUM_FIELD(relabelformat, CoercionForm);
1381 WRITE_LOCATION_FIELD(location);
1382 }
1383
1384 static void
_outCoerceViaIO(StringInfo str,const CoerceViaIO * node)1385 _outCoerceViaIO(StringInfo str, const CoerceViaIO *node)
1386 {
1387 WRITE_NODE_TYPE("COERCEVIAIO");
1388
1389 WRITE_NODE_FIELD(arg);
1390 WRITE_OID_FIELD(resulttype);
1391 WRITE_OID_FIELD(resultcollid);
1392 WRITE_ENUM_FIELD(coerceformat, CoercionForm);
1393 WRITE_LOCATION_FIELD(location);
1394 }
1395
1396 static void
_outArrayCoerceExpr(StringInfo str,const ArrayCoerceExpr * node)1397 _outArrayCoerceExpr(StringInfo str, const ArrayCoerceExpr *node)
1398 {
1399 WRITE_NODE_TYPE("ARRAYCOERCEEXPR");
1400
1401 WRITE_NODE_FIELD(arg);
1402 WRITE_OID_FIELD(elemfuncid);
1403 WRITE_OID_FIELD(resulttype);
1404 WRITE_INT_FIELD(resulttypmod);
1405 WRITE_OID_FIELD(resultcollid);
1406 WRITE_BOOL_FIELD(isExplicit);
1407 WRITE_ENUM_FIELD(coerceformat, CoercionForm);
1408 WRITE_LOCATION_FIELD(location);
1409 }
1410
1411 static void
_outConvertRowtypeExpr(StringInfo str,const ConvertRowtypeExpr * node)1412 _outConvertRowtypeExpr(StringInfo str, const ConvertRowtypeExpr *node)
1413 {
1414 WRITE_NODE_TYPE("CONVERTROWTYPEEXPR");
1415
1416 WRITE_NODE_FIELD(arg);
1417 WRITE_OID_FIELD(resulttype);
1418 WRITE_ENUM_FIELD(convertformat, CoercionForm);
1419 WRITE_LOCATION_FIELD(location);
1420 }
1421
1422 static void
_outCollateExpr(StringInfo str,const CollateExpr * node)1423 _outCollateExpr(StringInfo str, const CollateExpr *node)
1424 {
1425 WRITE_NODE_TYPE("COLLATE");
1426
1427 WRITE_NODE_FIELD(arg);
1428 WRITE_OID_FIELD(collOid);
1429 WRITE_LOCATION_FIELD(location);
1430 }
1431
1432 static void
_outCaseExpr(StringInfo str,const CaseExpr * node)1433 _outCaseExpr(StringInfo str, const CaseExpr *node)
1434 {
1435 WRITE_NODE_TYPE("CASE");
1436
1437 WRITE_OID_FIELD(casetype);
1438 WRITE_OID_FIELD(casecollid);
1439 WRITE_NODE_FIELD(arg);
1440 WRITE_NODE_FIELD(args);
1441 WRITE_NODE_FIELD(defresult);
1442 WRITE_LOCATION_FIELD(location);
1443 }
1444
1445 static void
_outCaseWhen(StringInfo str,const CaseWhen * node)1446 _outCaseWhen(StringInfo str, const CaseWhen *node)
1447 {
1448 WRITE_NODE_TYPE("WHEN");
1449
1450 WRITE_NODE_FIELD(expr);
1451 WRITE_NODE_FIELD(result);
1452 WRITE_LOCATION_FIELD(location);
1453 }
1454
1455 static void
_outCaseTestExpr(StringInfo str,const CaseTestExpr * node)1456 _outCaseTestExpr(StringInfo str, const CaseTestExpr *node)
1457 {
1458 WRITE_NODE_TYPE("CASETESTEXPR");
1459
1460 WRITE_OID_FIELD(typeId);
1461 WRITE_INT_FIELD(typeMod);
1462 WRITE_OID_FIELD(collation);
1463 }
1464
1465 static void
_outArrayExpr(StringInfo str,const ArrayExpr * node)1466 _outArrayExpr(StringInfo str, const ArrayExpr *node)
1467 {
1468 WRITE_NODE_TYPE("ARRAY");
1469
1470 WRITE_OID_FIELD(array_typeid);
1471 WRITE_OID_FIELD(array_collid);
1472 WRITE_OID_FIELD(element_typeid);
1473 WRITE_NODE_FIELD(elements);
1474 WRITE_BOOL_FIELD(multidims);
1475 WRITE_LOCATION_FIELD(location);
1476 }
1477
1478 static void
_outRowExpr(StringInfo str,const RowExpr * node)1479 _outRowExpr(StringInfo str, const RowExpr *node)
1480 {
1481 WRITE_NODE_TYPE("ROW");
1482
1483 WRITE_NODE_FIELD(args);
1484 WRITE_OID_FIELD(row_typeid);
1485 WRITE_ENUM_FIELD(row_format, CoercionForm);
1486 WRITE_NODE_FIELD(colnames);
1487 WRITE_LOCATION_FIELD(location);
1488 }
1489
1490 static void
_outRowCompareExpr(StringInfo str,const RowCompareExpr * node)1491 _outRowCompareExpr(StringInfo str, const RowCompareExpr *node)
1492 {
1493 WRITE_NODE_TYPE("ROWCOMPARE");
1494
1495 WRITE_ENUM_FIELD(rctype, RowCompareType);
1496 WRITE_NODE_FIELD(opnos);
1497 WRITE_NODE_FIELD(opfamilies);
1498 WRITE_NODE_FIELD(inputcollids);
1499 WRITE_NODE_FIELD(largs);
1500 WRITE_NODE_FIELD(rargs);
1501 }
1502
1503 static void
_outCoalesceExpr(StringInfo str,const CoalesceExpr * node)1504 _outCoalesceExpr(StringInfo str, const CoalesceExpr *node)
1505 {
1506 WRITE_NODE_TYPE("COALESCE");
1507
1508 WRITE_OID_FIELD(coalescetype);
1509 WRITE_OID_FIELD(coalescecollid);
1510 WRITE_NODE_FIELD(args);
1511 WRITE_LOCATION_FIELD(location);
1512 }
1513
1514 static void
_outMinMaxExpr(StringInfo str,const MinMaxExpr * node)1515 _outMinMaxExpr(StringInfo str, const MinMaxExpr *node)
1516 {
1517 WRITE_NODE_TYPE("MINMAX");
1518
1519 WRITE_OID_FIELD(minmaxtype);
1520 WRITE_OID_FIELD(minmaxcollid);
1521 WRITE_OID_FIELD(inputcollid);
1522 WRITE_ENUM_FIELD(op, MinMaxOp);
1523 WRITE_NODE_FIELD(args);
1524 WRITE_LOCATION_FIELD(location);
1525 }
1526
1527 static void
_outSQLValueFunction(StringInfo str,const SQLValueFunction * node)1528 _outSQLValueFunction(StringInfo str, const SQLValueFunction *node)
1529 {
1530 WRITE_NODE_TYPE("SQLVALUEFUNCTION");
1531
1532 WRITE_ENUM_FIELD(op, SQLValueFunctionOp);
1533 WRITE_OID_FIELD(type);
1534 WRITE_INT_FIELD(typmod);
1535 WRITE_LOCATION_FIELD(location);
1536 }
1537
1538 static void
_outXmlExpr(StringInfo str,const XmlExpr * node)1539 _outXmlExpr(StringInfo str, const XmlExpr *node)
1540 {
1541 WRITE_NODE_TYPE("XMLEXPR");
1542
1543 WRITE_ENUM_FIELD(op, XmlExprOp);
1544 WRITE_STRING_FIELD(name);
1545 WRITE_NODE_FIELD(named_args);
1546 WRITE_NODE_FIELD(arg_names);
1547 WRITE_NODE_FIELD(args);
1548 WRITE_ENUM_FIELD(xmloption, XmlOptionType);
1549 WRITE_OID_FIELD(type);
1550 WRITE_INT_FIELD(typmod);
1551 WRITE_LOCATION_FIELD(location);
1552 }
1553
1554 static void
_outNullTest(StringInfo str,const NullTest * node)1555 _outNullTest(StringInfo str, const NullTest *node)
1556 {
1557 WRITE_NODE_TYPE("NULLTEST");
1558
1559 WRITE_NODE_FIELD(arg);
1560 WRITE_ENUM_FIELD(nulltesttype, NullTestType);
1561 WRITE_BOOL_FIELD(argisrow);
1562 WRITE_LOCATION_FIELD(location);
1563 }
1564
1565 static void
_outBooleanTest(StringInfo str,const BooleanTest * node)1566 _outBooleanTest(StringInfo str, const BooleanTest *node)
1567 {
1568 WRITE_NODE_TYPE("BOOLEANTEST");
1569
1570 WRITE_NODE_FIELD(arg);
1571 WRITE_ENUM_FIELD(booltesttype, BoolTestType);
1572 WRITE_LOCATION_FIELD(location);
1573 }
1574
1575 static void
_outCoerceToDomain(StringInfo str,const CoerceToDomain * node)1576 _outCoerceToDomain(StringInfo str, const CoerceToDomain *node)
1577 {
1578 WRITE_NODE_TYPE("COERCETODOMAIN");
1579
1580 WRITE_NODE_FIELD(arg);
1581 WRITE_OID_FIELD(resulttype);
1582 WRITE_INT_FIELD(resulttypmod);
1583 WRITE_OID_FIELD(resultcollid);
1584 WRITE_ENUM_FIELD(coercionformat, CoercionForm);
1585 WRITE_LOCATION_FIELD(location);
1586 }
1587
1588 static void
_outCoerceToDomainValue(StringInfo str,const CoerceToDomainValue * node)1589 _outCoerceToDomainValue(StringInfo str, const CoerceToDomainValue *node)
1590 {
1591 WRITE_NODE_TYPE("COERCETODOMAINVALUE");
1592
1593 WRITE_OID_FIELD(typeId);
1594 WRITE_INT_FIELD(typeMod);
1595 WRITE_OID_FIELD(collation);
1596 WRITE_LOCATION_FIELD(location);
1597 }
1598
1599 static void
_outSetToDefault(StringInfo str,const SetToDefault * node)1600 _outSetToDefault(StringInfo str, const SetToDefault *node)
1601 {
1602 WRITE_NODE_TYPE("SETTODEFAULT");
1603
1604 WRITE_OID_FIELD(typeId);
1605 WRITE_INT_FIELD(typeMod);
1606 WRITE_OID_FIELD(collation);
1607 WRITE_LOCATION_FIELD(location);
1608 }
1609
1610 static void
_outCurrentOfExpr(StringInfo str,const CurrentOfExpr * node)1611 _outCurrentOfExpr(StringInfo str, const CurrentOfExpr *node)
1612 {
1613 WRITE_NODE_TYPE("CURRENTOFEXPR");
1614
1615 WRITE_UINT_FIELD(cvarno);
1616 WRITE_STRING_FIELD(cursor_name);
1617 WRITE_INT_FIELD(cursor_param);
1618 }
1619
1620 static void
_outNextValueExpr(StringInfo str,const NextValueExpr * node)1621 _outNextValueExpr(StringInfo str, const NextValueExpr *node)
1622 {
1623 WRITE_NODE_TYPE("NEXTVALUEEXPR");
1624
1625 WRITE_OID_FIELD(seqid);
1626 WRITE_OID_FIELD(typeId);
1627 }
1628
1629 static void
_outInferenceElem(StringInfo str,const InferenceElem * node)1630 _outInferenceElem(StringInfo str, const InferenceElem *node)
1631 {
1632 WRITE_NODE_TYPE("INFERENCEELEM");
1633
1634 WRITE_NODE_FIELD(expr);
1635 WRITE_OID_FIELD(infercollid);
1636 WRITE_OID_FIELD(inferopclass);
1637 }
1638
1639 static void
_outTargetEntry(StringInfo str,const TargetEntry * node)1640 _outTargetEntry(StringInfo str, const TargetEntry *node)
1641 {
1642 WRITE_NODE_TYPE("TARGETENTRY");
1643
1644 WRITE_NODE_FIELD(expr);
1645 WRITE_INT_FIELD(resno);
1646 WRITE_STRING_FIELD(resname);
1647 WRITE_UINT_FIELD(ressortgroupref);
1648 WRITE_OID_FIELD(resorigtbl);
1649 WRITE_INT_FIELD(resorigcol);
1650 WRITE_BOOL_FIELD(resjunk);
1651 }
1652
1653 static void
_outRangeTblRef(StringInfo str,const RangeTblRef * node)1654 _outRangeTblRef(StringInfo str, const RangeTblRef *node)
1655 {
1656 WRITE_NODE_TYPE("RANGETBLREF");
1657
1658 WRITE_INT_FIELD(rtindex);
1659 }
1660
1661 static void
_outJoinExpr(StringInfo str,const JoinExpr * node)1662 _outJoinExpr(StringInfo str, const JoinExpr *node)
1663 {
1664 WRITE_NODE_TYPE("JOINEXPR");
1665
1666 WRITE_ENUM_FIELD(jointype, JoinType);
1667 WRITE_BOOL_FIELD(isNatural);
1668 WRITE_NODE_FIELD(larg);
1669 WRITE_NODE_FIELD(rarg);
1670 WRITE_NODE_FIELD(usingClause);
1671 WRITE_NODE_FIELD(quals);
1672 WRITE_NODE_FIELD(alias);
1673 WRITE_INT_FIELD(rtindex);
1674 }
1675
1676 static void
_outFromExpr(StringInfo str,const FromExpr * node)1677 _outFromExpr(StringInfo str, const FromExpr *node)
1678 {
1679 WRITE_NODE_TYPE("FROMEXPR");
1680
1681 WRITE_NODE_FIELD(fromlist);
1682 WRITE_NODE_FIELD(quals);
1683 }
1684
1685 static void
_outOnConflictExpr(StringInfo str,const OnConflictExpr * node)1686 _outOnConflictExpr(StringInfo str, const OnConflictExpr *node)
1687 {
1688 WRITE_NODE_TYPE("ONCONFLICTEXPR");
1689
1690 WRITE_ENUM_FIELD(action, OnConflictAction);
1691 WRITE_NODE_FIELD(arbiterElems);
1692 WRITE_NODE_FIELD(arbiterWhere);
1693 WRITE_OID_FIELD(constraint);
1694 WRITE_NODE_FIELD(onConflictSet);
1695 WRITE_NODE_FIELD(onConflictWhere);
1696 WRITE_INT_FIELD(exclRelIndex);
1697 WRITE_NODE_FIELD(exclRelTlist);
1698 }
1699
1700 /*****************************************************************************
1701 *
1702 * Stuff from relation.h.
1703 *
1704 *****************************************************************************/
1705
1706 /*
1707 * print the basic stuff of all nodes that inherit from Path
1708 *
1709 * Note we do NOT print the parent, else we'd be in infinite recursion.
1710 * We can print the parent's relids for identification purposes, though.
1711 * We print the pathtarget only if it's not the default one for the rel.
1712 * We also do not print the whole of param_info, since it's printed by
1713 * _outRelOptInfo; it's sufficient and less cluttering to print just the
1714 * required outer relids.
1715 */
1716 static void
_outPathInfo(StringInfo str,const Path * node)1717 _outPathInfo(StringInfo str, const Path *node)
1718 {
1719 WRITE_ENUM_FIELD(pathtype, NodeTag);
1720 appendStringInfoString(str, " :parent_relids ");
1721 outBitmapset(str, node->parent->relids);
1722 if (node->pathtarget != node->parent->reltarget)
1723 WRITE_NODE_FIELD(pathtarget);
1724 appendStringInfoString(str, " :required_outer ");
1725 if (node->param_info)
1726 outBitmapset(str, node->param_info->ppi_req_outer);
1727 else
1728 outBitmapset(str, NULL);
1729 WRITE_BOOL_FIELD(parallel_aware);
1730 WRITE_BOOL_FIELD(parallel_safe);
1731 WRITE_INT_FIELD(parallel_workers);
1732 WRITE_FLOAT_FIELD(rows, "%.0f");
1733 WRITE_FLOAT_FIELD(startup_cost, "%.2f");
1734 WRITE_FLOAT_FIELD(total_cost, "%.2f");
1735 WRITE_NODE_FIELD(pathkeys);
1736 }
1737
1738 /*
1739 * print the basic stuff of all nodes that inherit from JoinPath
1740 */
1741 static void
_outJoinPathInfo(StringInfo str,const JoinPath * node)1742 _outJoinPathInfo(StringInfo str, const JoinPath *node)
1743 {
1744 _outPathInfo(str, (const Path *) node);
1745
1746 WRITE_ENUM_FIELD(jointype, JoinType);
1747 WRITE_BOOL_FIELD(inner_unique);
1748 WRITE_NODE_FIELD(outerjoinpath);
1749 WRITE_NODE_FIELD(innerjoinpath);
1750 WRITE_NODE_FIELD(joinrestrictinfo);
1751 }
1752
1753 static void
_outPath(StringInfo str,const Path * node)1754 _outPath(StringInfo str, const Path *node)
1755 {
1756 WRITE_NODE_TYPE("PATH");
1757
1758 _outPathInfo(str, (const Path *) node);
1759 }
1760
1761 static void
_outIndexPath(StringInfo str,const IndexPath * node)1762 _outIndexPath(StringInfo str, const IndexPath *node)
1763 {
1764 WRITE_NODE_TYPE("INDEXPATH");
1765
1766 _outPathInfo(str, (const Path *) node);
1767
1768 WRITE_NODE_FIELD(indexinfo);
1769 WRITE_NODE_FIELD(indexclauses);
1770 WRITE_NODE_FIELD(indexquals);
1771 WRITE_NODE_FIELD(indexqualcols);
1772 WRITE_NODE_FIELD(indexorderbys);
1773 WRITE_NODE_FIELD(indexorderbycols);
1774 WRITE_ENUM_FIELD(indexscandir, ScanDirection);
1775 WRITE_FLOAT_FIELD(indextotalcost, "%.2f");
1776 WRITE_FLOAT_FIELD(indexselectivity, "%.4f");
1777 }
1778
1779 static void
_outBitmapHeapPath(StringInfo str,const BitmapHeapPath * node)1780 _outBitmapHeapPath(StringInfo str, const BitmapHeapPath *node)
1781 {
1782 WRITE_NODE_TYPE("BITMAPHEAPPATH");
1783
1784 _outPathInfo(str, (const Path *) node);
1785
1786 WRITE_NODE_FIELD(bitmapqual);
1787 }
1788
1789 static void
_outBitmapAndPath(StringInfo str,const BitmapAndPath * node)1790 _outBitmapAndPath(StringInfo str, const BitmapAndPath *node)
1791 {
1792 WRITE_NODE_TYPE("BITMAPANDPATH");
1793
1794 _outPathInfo(str, (const Path *) node);
1795
1796 WRITE_NODE_FIELD(bitmapquals);
1797 WRITE_FLOAT_FIELD(bitmapselectivity, "%.4f");
1798 }
1799
1800 static void
_outBitmapOrPath(StringInfo str,const BitmapOrPath * node)1801 _outBitmapOrPath(StringInfo str, const BitmapOrPath *node)
1802 {
1803 WRITE_NODE_TYPE("BITMAPORPATH");
1804
1805 _outPathInfo(str, (const Path *) node);
1806
1807 WRITE_NODE_FIELD(bitmapquals);
1808 WRITE_FLOAT_FIELD(bitmapselectivity, "%.4f");
1809 }
1810
1811 static void
_outTidPath(StringInfo str,const TidPath * node)1812 _outTidPath(StringInfo str, const TidPath *node)
1813 {
1814 WRITE_NODE_TYPE("TIDPATH");
1815
1816 _outPathInfo(str, (const Path *) node);
1817
1818 WRITE_NODE_FIELD(tidquals);
1819 }
1820
1821 static void
_outSubqueryScanPath(StringInfo str,const SubqueryScanPath * node)1822 _outSubqueryScanPath(StringInfo str, const SubqueryScanPath *node)
1823 {
1824 WRITE_NODE_TYPE("SUBQUERYSCANPATH");
1825
1826 _outPathInfo(str, (const Path *) node);
1827
1828 WRITE_NODE_FIELD(subpath);
1829 }
1830
1831 static void
_outForeignPath(StringInfo str,const ForeignPath * node)1832 _outForeignPath(StringInfo str, const ForeignPath *node)
1833 {
1834 WRITE_NODE_TYPE("FOREIGNPATH");
1835
1836 _outPathInfo(str, (const Path *) node);
1837
1838 WRITE_NODE_FIELD(fdw_outerpath);
1839 WRITE_NODE_FIELD(fdw_private);
1840 }
1841
1842 static void
_outCustomPath(StringInfo str,const CustomPath * node)1843 _outCustomPath(StringInfo str, const CustomPath *node)
1844 {
1845 WRITE_NODE_TYPE("CUSTOMPATH");
1846
1847 _outPathInfo(str, (const Path *) node);
1848
1849 WRITE_UINT_FIELD(flags);
1850 WRITE_NODE_FIELD(custom_paths);
1851 WRITE_NODE_FIELD(custom_private);
1852 appendStringInfoString(str, " :methods ");
1853 outToken(str, node->methods->CustomName);
1854 }
1855
1856 static void
_outAppendPath(StringInfo str,const AppendPath * node)1857 _outAppendPath(StringInfo str, const AppendPath *node)
1858 {
1859 WRITE_NODE_TYPE("APPENDPATH");
1860
1861 _outPathInfo(str, (const Path *) node);
1862
1863 WRITE_NODE_FIELD(partitioned_rels);
1864 WRITE_NODE_FIELD(subpaths);
1865 }
1866
1867 static void
_outMergeAppendPath(StringInfo str,const MergeAppendPath * node)1868 _outMergeAppendPath(StringInfo str, const MergeAppendPath *node)
1869 {
1870 WRITE_NODE_TYPE("MERGEAPPENDPATH");
1871
1872 _outPathInfo(str, (const Path *) node);
1873
1874 WRITE_NODE_FIELD(partitioned_rels);
1875 WRITE_NODE_FIELD(subpaths);
1876 WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
1877 }
1878
1879 static void
_outResultPath(StringInfo str,const ResultPath * node)1880 _outResultPath(StringInfo str, const ResultPath *node)
1881 {
1882 WRITE_NODE_TYPE("RESULTPATH");
1883
1884 _outPathInfo(str, (const Path *) node);
1885
1886 WRITE_NODE_FIELD(quals);
1887 }
1888
1889 static void
_outMaterialPath(StringInfo str,const MaterialPath * node)1890 _outMaterialPath(StringInfo str, const MaterialPath *node)
1891 {
1892 WRITE_NODE_TYPE("MATERIALPATH");
1893
1894 _outPathInfo(str, (const Path *) node);
1895
1896 WRITE_NODE_FIELD(subpath);
1897 }
1898
1899 static void
_outUniquePath(StringInfo str,const UniquePath * node)1900 _outUniquePath(StringInfo str, const UniquePath *node)
1901 {
1902 WRITE_NODE_TYPE("UNIQUEPATH");
1903
1904 _outPathInfo(str, (const Path *) node);
1905
1906 WRITE_NODE_FIELD(subpath);
1907 WRITE_ENUM_FIELD(umethod, UniquePathMethod);
1908 WRITE_NODE_FIELD(in_operators);
1909 WRITE_NODE_FIELD(uniq_exprs);
1910 }
1911
1912 static void
_outGatherPath(StringInfo str,const GatherPath * node)1913 _outGatherPath(StringInfo str, const GatherPath *node)
1914 {
1915 WRITE_NODE_TYPE("GATHERPATH");
1916
1917 _outPathInfo(str, (const Path *) node);
1918
1919 WRITE_NODE_FIELD(subpath);
1920 WRITE_BOOL_FIELD(single_copy);
1921 WRITE_INT_FIELD(num_workers);
1922 }
1923
1924 static void
_outProjectionPath(StringInfo str,const ProjectionPath * node)1925 _outProjectionPath(StringInfo str, const ProjectionPath *node)
1926 {
1927 WRITE_NODE_TYPE("PROJECTIONPATH");
1928
1929 _outPathInfo(str, (const Path *) node);
1930
1931 WRITE_NODE_FIELD(subpath);
1932 WRITE_BOOL_FIELD(dummypp);
1933 }
1934
1935 static void
_outProjectSetPath(StringInfo str,const ProjectSetPath * node)1936 _outProjectSetPath(StringInfo str, const ProjectSetPath *node)
1937 {
1938 WRITE_NODE_TYPE("PROJECTSETPATH");
1939
1940 _outPathInfo(str, (const Path *) node);
1941
1942 WRITE_NODE_FIELD(subpath);
1943 }
1944
1945 static void
_outSortPath(StringInfo str,const SortPath * node)1946 _outSortPath(StringInfo str, const SortPath *node)
1947 {
1948 WRITE_NODE_TYPE("SORTPATH");
1949
1950 _outPathInfo(str, (const Path *) node);
1951
1952 WRITE_NODE_FIELD(subpath);
1953 }
1954
1955 static void
_outGroupPath(StringInfo str,const GroupPath * node)1956 _outGroupPath(StringInfo str, const GroupPath *node)
1957 {
1958 WRITE_NODE_TYPE("GROUPPATH");
1959
1960 _outPathInfo(str, (const Path *) node);
1961
1962 WRITE_NODE_FIELD(subpath);
1963 WRITE_NODE_FIELD(groupClause);
1964 WRITE_NODE_FIELD(qual);
1965 }
1966
1967 static void
_outUpperUniquePath(StringInfo str,const UpperUniquePath * node)1968 _outUpperUniquePath(StringInfo str, const UpperUniquePath *node)
1969 {
1970 WRITE_NODE_TYPE("UPPERUNIQUEPATH");
1971
1972 _outPathInfo(str, (const Path *) node);
1973
1974 WRITE_NODE_FIELD(subpath);
1975 WRITE_INT_FIELD(numkeys);
1976 }
1977
1978 static void
_outAggPath(StringInfo str,const AggPath * node)1979 _outAggPath(StringInfo str, const AggPath *node)
1980 {
1981 WRITE_NODE_TYPE("AGGPATH");
1982
1983 _outPathInfo(str, (const Path *) node);
1984
1985 WRITE_NODE_FIELD(subpath);
1986 WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
1987 WRITE_ENUM_FIELD(aggsplit, AggSplit);
1988 WRITE_FLOAT_FIELD(numGroups, "%.0f");
1989 WRITE_NODE_FIELD(groupClause);
1990 WRITE_NODE_FIELD(qual);
1991 }
1992
1993 static void
_outRollupData(StringInfo str,const RollupData * node)1994 _outRollupData(StringInfo str, const RollupData *node)
1995 {
1996 WRITE_NODE_TYPE("ROLLUP");
1997
1998 WRITE_NODE_FIELD(groupClause);
1999 WRITE_NODE_FIELD(gsets);
2000 WRITE_NODE_FIELD(gsets_data);
2001 WRITE_FLOAT_FIELD(numGroups, "%.0f");
2002 WRITE_BOOL_FIELD(hashable);
2003 WRITE_BOOL_FIELD(is_hashed);
2004 }
2005
2006 static void
_outGroupingSetData(StringInfo str,const GroupingSetData * node)2007 _outGroupingSetData(StringInfo str, const GroupingSetData *node)
2008 {
2009 WRITE_NODE_TYPE("GSDATA");
2010
2011 WRITE_NODE_FIELD(set);
2012 WRITE_FLOAT_FIELD(numGroups, "%.0f");
2013 }
2014
2015 static void
_outGroupingSetsPath(StringInfo str,const GroupingSetsPath * node)2016 _outGroupingSetsPath(StringInfo str, const GroupingSetsPath *node)
2017 {
2018 WRITE_NODE_TYPE("GROUPINGSETSPATH");
2019
2020 _outPathInfo(str, (const Path *) node);
2021
2022 WRITE_NODE_FIELD(subpath);
2023 WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
2024 WRITE_NODE_FIELD(rollups);
2025 WRITE_NODE_FIELD(qual);
2026 }
2027
2028 static void
_outMinMaxAggPath(StringInfo str,const MinMaxAggPath * node)2029 _outMinMaxAggPath(StringInfo str, const MinMaxAggPath *node)
2030 {
2031 WRITE_NODE_TYPE("MINMAXAGGPATH");
2032
2033 _outPathInfo(str, (const Path *) node);
2034
2035 WRITE_NODE_FIELD(mmaggregates);
2036 WRITE_NODE_FIELD(quals);
2037 }
2038
2039 static void
_outWindowAggPath(StringInfo str,const WindowAggPath * node)2040 _outWindowAggPath(StringInfo str, const WindowAggPath *node)
2041 {
2042 WRITE_NODE_TYPE("WINDOWAGGPATH");
2043
2044 _outPathInfo(str, (const Path *) node);
2045
2046 WRITE_NODE_FIELD(subpath);
2047 WRITE_NODE_FIELD(winclause);
2048 WRITE_NODE_FIELD(winpathkeys);
2049 }
2050
2051 static void
_outSetOpPath(StringInfo str,const SetOpPath * node)2052 _outSetOpPath(StringInfo str, const SetOpPath *node)
2053 {
2054 WRITE_NODE_TYPE("SETOPPATH");
2055
2056 _outPathInfo(str, (const Path *) node);
2057
2058 WRITE_NODE_FIELD(subpath);
2059 WRITE_ENUM_FIELD(cmd, SetOpCmd);
2060 WRITE_ENUM_FIELD(strategy, SetOpStrategy);
2061 WRITE_NODE_FIELD(distinctList);
2062 WRITE_INT_FIELD(flagColIdx);
2063 WRITE_INT_FIELD(firstFlag);
2064 WRITE_FLOAT_FIELD(numGroups, "%.0f");
2065 }
2066
2067 static void
_outRecursiveUnionPath(StringInfo str,const RecursiveUnionPath * node)2068 _outRecursiveUnionPath(StringInfo str, const RecursiveUnionPath *node)
2069 {
2070 WRITE_NODE_TYPE("RECURSIVEUNIONPATH");
2071
2072 _outPathInfo(str, (const Path *) node);
2073
2074 WRITE_NODE_FIELD(leftpath);
2075 WRITE_NODE_FIELD(rightpath);
2076 WRITE_NODE_FIELD(distinctList);
2077 WRITE_INT_FIELD(wtParam);
2078 WRITE_FLOAT_FIELD(numGroups, "%.0f");
2079 }
2080
2081 static void
_outLockRowsPath(StringInfo str,const LockRowsPath * node)2082 _outLockRowsPath(StringInfo str, const LockRowsPath *node)
2083 {
2084 WRITE_NODE_TYPE("LOCKROWSPATH");
2085
2086 _outPathInfo(str, (const Path *) node);
2087
2088 WRITE_NODE_FIELD(subpath);
2089 WRITE_NODE_FIELD(rowMarks);
2090 WRITE_INT_FIELD(epqParam);
2091 }
2092
2093 static void
_outModifyTablePath(StringInfo str,const ModifyTablePath * node)2094 _outModifyTablePath(StringInfo str, const ModifyTablePath *node)
2095 {
2096 WRITE_NODE_TYPE("MODIFYTABLEPATH");
2097
2098 _outPathInfo(str, (const Path *) node);
2099
2100 WRITE_ENUM_FIELD(operation, CmdType);
2101 WRITE_BOOL_FIELD(canSetTag);
2102 WRITE_UINT_FIELD(nominalRelation);
2103 WRITE_NODE_FIELD(partitioned_rels);
2104 WRITE_NODE_FIELD(resultRelations);
2105 WRITE_NODE_FIELD(subpaths);
2106 WRITE_NODE_FIELD(subroots);
2107 WRITE_NODE_FIELD(withCheckOptionLists);
2108 WRITE_NODE_FIELD(returningLists);
2109 WRITE_NODE_FIELD(rowMarks);
2110 WRITE_NODE_FIELD(onconflict);
2111 WRITE_INT_FIELD(epqParam);
2112 }
2113
2114 static void
_outLimitPath(StringInfo str,const LimitPath * node)2115 _outLimitPath(StringInfo str, const LimitPath *node)
2116 {
2117 WRITE_NODE_TYPE("LIMITPATH");
2118
2119 _outPathInfo(str, (const Path *) node);
2120
2121 WRITE_NODE_FIELD(subpath);
2122 WRITE_NODE_FIELD(limitOffset);
2123 WRITE_NODE_FIELD(limitCount);
2124 }
2125
2126 static void
_outGatherMergePath(StringInfo str,const GatherMergePath * node)2127 _outGatherMergePath(StringInfo str, const GatherMergePath *node)
2128 {
2129 WRITE_NODE_TYPE("GATHERMERGEPATH");
2130
2131 _outPathInfo(str, (const Path *) node);
2132
2133 WRITE_NODE_FIELD(subpath);
2134 WRITE_INT_FIELD(num_workers);
2135 }
2136
2137 static void
_outNestPath(StringInfo str,const NestPath * node)2138 _outNestPath(StringInfo str, const NestPath *node)
2139 {
2140 WRITE_NODE_TYPE("NESTPATH");
2141
2142 _outJoinPathInfo(str, (const JoinPath *) node);
2143 }
2144
2145 static void
_outMergePath(StringInfo str,const MergePath * node)2146 _outMergePath(StringInfo str, const MergePath *node)
2147 {
2148 WRITE_NODE_TYPE("MERGEPATH");
2149
2150 _outJoinPathInfo(str, (const JoinPath *) node);
2151
2152 WRITE_NODE_FIELD(path_mergeclauses);
2153 WRITE_NODE_FIELD(outersortkeys);
2154 WRITE_NODE_FIELD(innersortkeys);
2155 WRITE_BOOL_FIELD(skip_mark_restore);
2156 WRITE_BOOL_FIELD(materialize_inner);
2157 }
2158
2159 static void
_outHashPath(StringInfo str,const HashPath * node)2160 _outHashPath(StringInfo str, const HashPath *node)
2161 {
2162 WRITE_NODE_TYPE("HASHPATH");
2163
2164 _outJoinPathInfo(str, (const JoinPath *) node);
2165
2166 WRITE_NODE_FIELD(path_hashclauses);
2167 WRITE_INT_FIELD(num_batches);
2168 }
2169
2170 static void
_outPlannerGlobal(StringInfo str,const PlannerGlobal * node)2171 _outPlannerGlobal(StringInfo str, const PlannerGlobal *node)
2172 {
2173 WRITE_NODE_TYPE("PLANNERGLOBAL");
2174
2175 /* NB: this isn't a complete set of fields */
2176 WRITE_NODE_FIELD(subplans);
2177 WRITE_BITMAPSET_FIELD(rewindPlanIDs);
2178 WRITE_NODE_FIELD(finalrtable);
2179 WRITE_NODE_FIELD(finalrowmarks);
2180 WRITE_NODE_FIELD(resultRelations);
2181 WRITE_NODE_FIELD(nonleafResultRelations);
2182 WRITE_NODE_FIELD(rootResultRelations);
2183 WRITE_NODE_FIELD(relationOids);
2184 WRITE_NODE_FIELD(invalItems);
2185 WRITE_INT_FIELD(nParamExec);
2186 WRITE_UINT_FIELD(lastPHId);
2187 WRITE_UINT_FIELD(lastRowMarkId);
2188 WRITE_INT_FIELD(lastPlanNodeId);
2189 WRITE_BOOL_FIELD(transientPlan);
2190 WRITE_BOOL_FIELD(dependsOnRole);
2191 WRITE_BOOL_FIELD(parallelModeOK);
2192 WRITE_BOOL_FIELD(parallelModeNeeded);
2193 WRITE_CHAR_FIELD(maxParallelHazard);
2194 }
2195
2196 static void
_outPlannerInfo(StringInfo str,const PlannerInfo * node)2197 _outPlannerInfo(StringInfo str, const PlannerInfo *node)
2198 {
2199 WRITE_NODE_TYPE("PLANNERINFO");
2200
2201 /* NB: this isn't a complete set of fields */
2202 WRITE_NODE_FIELD(parse);
2203 WRITE_NODE_FIELD(glob);
2204 WRITE_UINT_FIELD(query_level);
2205 WRITE_NODE_FIELD(plan_params);
2206 WRITE_BITMAPSET_FIELD(outer_params);
2207 WRITE_BITMAPSET_FIELD(all_baserels);
2208 WRITE_BITMAPSET_FIELD(nullable_baserels);
2209 WRITE_NODE_FIELD(join_rel_list);
2210 WRITE_INT_FIELD(join_cur_level);
2211 WRITE_NODE_FIELD(init_plans);
2212 WRITE_NODE_FIELD(cte_plan_ids);
2213 WRITE_NODE_FIELD(multiexpr_params);
2214 WRITE_NODE_FIELD(eq_classes);
2215 WRITE_NODE_FIELD(canon_pathkeys);
2216 WRITE_NODE_FIELD(left_join_clauses);
2217 WRITE_NODE_FIELD(right_join_clauses);
2218 WRITE_NODE_FIELD(full_join_clauses);
2219 WRITE_NODE_FIELD(join_info_list);
2220 WRITE_NODE_FIELD(append_rel_list);
2221 WRITE_NODE_FIELD(pcinfo_list);
2222 WRITE_NODE_FIELD(rowMarks);
2223 WRITE_NODE_FIELD(placeholder_list);
2224 WRITE_NODE_FIELD(fkey_list);
2225 WRITE_NODE_FIELD(query_pathkeys);
2226 WRITE_NODE_FIELD(group_pathkeys);
2227 WRITE_NODE_FIELD(window_pathkeys);
2228 WRITE_NODE_FIELD(distinct_pathkeys);
2229 WRITE_NODE_FIELD(sort_pathkeys);
2230 WRITE_NODE_FIELD(processed_tlist);
2231 WRITE_NODE_FIELD(minmax_aggs);
2232 WRITE_FLOAT_FIELD(total_table_pages, "%.0f");
2233 WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
2234 WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
2235 WRITE_UINT_FIELD(qual_security_level);
2236 WRITE_BOOL_FIELD(hasInheritedTarget);
2237 WRITE_BOOL_FIELD(hasJoinRTEs);
2238 WRITE_BOOL_FIELD(hasLateralRTEs);
2239 WRITE_BOOL_FIELD(hasDeletedRTEs);
2240 WRITE_BOOL_FIELD(hasHavingQual);
2241 WRITE_BOOL_FIELD(hasPseudoConstantQuals);
2242 WRITE_BOOL_FIELD(hasRecursion);
2243 WRITE_INT_FIELD(wt_param_id);
2244 WRITE_BITMAPSET_FIELD(curOuterRels);
2245 WRITE_NODE_FIELD(curOuterParams);
2246 }
2247
2248 static void
_outRelOptInfo(StringInfo str,const RelOptInfo * node)2249 _outRelOptInfo(StringInfo str, const RelOptInfo *node)
2250 {
2251 WRITE_NODE_TYPE("RELOPTINFO");
2252
2253 /* NB: this isn't a complete set of fields */
2254 WRITE_ENUM_FIELD(reloptkind, RelOptKind);
2255 WRITE_BITMAPSET_FIELD(relids);
2256 WRITE_FLOAT_FIELD(rows, "%.0f");
2257 WRITE_BOOL_FIELD(consider_startup);
2258 WRITE_BOOL_FIELD(consider_param_startup);
2259 WRITE_BOOL_FIELD(consider_parallel);
2260 WRITE_NODE_FIELD(reltarget);
2261 WRITE_NODE_FIELD(pathlist);
2262 WRITE_NODE_FIELD(ppilist);
2263 WRITE_NODE_FIELD(partial_pathlist);
2264 WRITE_NODE_FIELD(cheapest_startup_path);
2265 WRITE_NODE_FIELD(cheapest_total_path);
2266 WRITE_NODE_FIELD(cheapest_unique_path);
2267 WRITE_NODE_FIELD(cheapest_parameterized_paths);
2268 WRITE_BITMAPSET_FIELD(direct_lateral_relids);
2269 WRITE_BITMAPSET_FIELD(lateral_relids);
2270 WRITE_UINT_FIELD(relid);
2271 WRITE_OID_FIELD(reltablespace);
2272 WRITE_ENUM_FIELD(rtekind, RTEKind);
2273 WRITE_INT_FIELD(min_attr);
2274 WRITE_INT_FIELD(max_attr);
2275 WRITE_NODE_FIELD(lateral_vars);
2276 WRITE_BITMAPSET_FIELD(lateral_referencers);
2277 WRITE_NODE_FIELD(indexlist);
2278 WRITE_NODE_FIELD(statlist);
2279 WRITE_UINT_FIELD(pages);
2280 WRITE_FLOAT_FIELD(tuples, "%.0f");
2281 WRITE_FLOAT_FIELD(allvisfrac, "%.6f");
2282 WRITE_NODE_FIELD(subroot);
2283 WRITE_NODE_FIELD(subplan_params);
2284 WRITE_INT_FIELD(rel_parallel_workers);
2285 WRITE_OID_FIELD(serverid);
2286 WRITE_OID_FIELD(userid);
2287 WRITE_BOOL_FIELD(useridiscurrent);
2288 /* we don't try to print fdwroutine or fdw_private */
2289 /* can't print unique_for_rels/non_unique_for_rels; BMSes aren't Nodes */
2290 WRITE_NODE_FIELD(baserestrictinfo);
2291 WRITE_UINT_FIELD(baserestrict_min_security);
2292 WRITE_NODE_FIELD(joininfo);
2293 WRITE_BOOL_FIELD(has_eclass_joins);
2294 WRITE_BITMAPSET_FIELD(top_parent_relids);
2295 }
2296
2297 static void
_outIndexOptInfo(StringInfo str,const IndexOptInfo * node)2298 _outIndexOptInfo(StringInfo str, const IndexOptInfo *node)
2299 {
2300 WRITE_NODE_TYPE("INDEXOPTINFO");
2301
2302 /* NB: this isn't a complete set of fields */
2303 WRITE_OID_FIELD(indexoid);
2304 /* Do NOT print rel field, else infinite recursion */
2305 WRITE_UINT_FIELD(pages);
2306 WRITE_FLOAT_FIELD(tuples, "%.0f");
2307 WRITE_INT_FIELD(tree_height);
2308 WRITE_INT_FIELD(ncolumns);
2309 /* array fields aren't really worth the trouble to print */
2310 WRITE_OID_FIELD(relam);
2311 /* indexprs is redundant since we print indextlist */
2312 WRITE_NODE_FIELD(indpred);
2313 WRITE_NODE_FIELD(indextlist);
2314 WRITE_NODE_FIELD(indrestrictinfo);
2315 WRITE_BOOL_FIELD(predOK);
2316 WRITE_BOOL_FIELD(unique);
2317 WRITE_BOOL_FIELD(immediate);
2318 WRITE_BOOL_FIELD(hypothetical);
2319 /* we don't bother with fields copied from the index AM's API struct */
2320 }
2321
2322 static void
_outForeignKeyOptInfo(StringInfo str,const ForeignKeyOptInfo * node)2323 _outForeignKeyOptInfo(StringInfo str, const ForeignKeyOptInfo *node)
2324 {
2325 int i;
2326
2327 WRITE_NODE_TYPE("FOREIGNKEYOPTINFO");
2328
2329 WRITE_UINT_FIELD(con_relid);
2330 WRITE_UINT_FIELD(ref_relid);
2331 WRITE_INT_FIELD(nkeys);
2332 appendStringInfoString(str, " :conkey");
2333 for (i = 0; i < node->nkeys; i++)
2334 appendStringInfo(str, " %d", node->conkey[i]);
2335 appendStringInfoString(str, " :confkey");
2336 for (i = 0; i < node->nkeys; i++)
2337 appendStringInfo(str, " %d", node->confkey[i]);
2338 appendStringInfoString(str, " :conpfeqop");
2339 for (i = 0; i < node->nkeys; i++)
2340 appendStringInfo(str, " %u", node->conpfeqop[i]);
2341 WRITE_INT_FIELD(nmatched_ec);
2342 WRITE_INT_FIELD(nmatched_rcols);
2343 WRITE_INT_FIELD(nmatched_ri);
2344 /* for compactness, just print the number of matches per column: */
2345 appendStringInfoString(str, " :eclass");
2346 for (i = 0; i < node->nkeys; i++)
2347 appendStringInfo(str, " %d", (node->eclass[i] != NULL));
2348 appendStringInfoString(str, " :rinfos");
2349 for (i = 0; i < node->nkeys; i++)
2350 appendStringInfo(str, " %d", list_length(node->rinfos[i]));
2351 }
2352
2353 static void
_outStatisticExtInfo(StringInfo str,const StatisticExtInfo * node)2354 _outStatisticExtInfo(StringInfo str, const StatisticExtInfo *node)
2355 {
2356 WRITE_NODE_TYPE("STATISTICEXTINFO");
2357
2358 /* NB: this isn't a complete set of fields */
2359 WRITE_OID_FIELD(statOid);
2360 /* don't write rel, leads to infinite recursion in plan tree dump */
2361 WRITE_CHAR_FIELD(kind);
2362 WRITE_BITMAPSET_FIELD(keys);
2363 }
2364
2365 static void
_outEquivalenceClass(StringInfo str,const EquivalenceClass * node)2366 _outEquivalenceClass(StringInfo str, const EquivalenceClass *node)
2367 {
2368 /*
2369 * To simplify reading, we just chase up to the topmost merged EC and
2370 * print that, without bothering to show the merge-ees separately.
2371 */
2372 while (node->ec_merged)
2373 node = node->ec_merged;
2374
2375 WRITE_NODE_TYPE("EQUIVALENCECLASS");
2376
2377 WRITE_NODE_FIELD(ec_opfamilies);
2378 WRITE_OID_FIELD(ec_collation);
2379 WRITE_NODE_FIELD(ec_members);
2380 WRITE_NODE_FIELD(ec_sources);
2381 WRITE_NODE_FIELD(ec_derives);
2382 WRITE_BITMAPSET_FIELD(ec_relids);
2383 WRITE_BOOL_FIELD(ec_has_const);
2384 WRITE_BOOL_FIELD(ec_has_volatile);
2385 WRITE_BOOL_FIELD(ec_below_outer_join);
2386 WRITE_BOOL_FIELD(ec_broken);
2387 WRITE_UINT_FIELD(ec_sortref);
2388 WRITE_UINT_FIELD(ec_min_security);
2389 WRITE_UINT_FIELD(ec_max_security);
2390 }
2391
2392 static void
_outEquivalenceMember(StringInfo str,const EquivalenceMember * node)2393 _outEquivalenceMember(StringInfo str, const EquivalenceMember *node)
2394 {
2395 WRITE_NODE_TYPE("EQUIVALENCEMEMBER");
2396
2397 WRITE_NODE_FIELD(em_expr);
2398 WRITE_BITMAPSET_FIELD(em_relids);
2399 WRITE_BITMAPSET_FIELD(em_nullable_relids);
2400 WRITE_BOOL_FIELD(em_is_const);
2401 WRITE_BOOL_FIELD(em_is_child);
2402 WRITE_OID_FIELD(em_datatype);
2403 }
2404
2405 static void
_outPathKey(StringInfo str,const PathKey * node)2406 _outPathKey(StringInfo str, const PathKey *node)
2407 {
2408 WRITE_NODE_TYPE("PATHKEY");
2409
2410 WRITE_NODE_FIELD(pk_eclass);
2411 WRITE_OID_FIELD(pk_opfamily);
2412 WRITE_INT_FIELD(pk_strategy);
2413 WRITE_BOOL_FIELD(pk_nulls_first);
2414 }
2415
2416 static void
_outPathTarget(StringInfo str,const PathTarget * node)2417 _outPathTarget(StringInfo str, const PathTarget *node)
2418 {
2419 WRITE_NODE_TYPE("PATHTARGET");
2420
2421 WRITE_NODE_FIELD(exprs);
2422 if (node->sortgrouprefs)
2423 {
2424 int i;
2425
2426 appendStringInfoString(str, " :sortgrouprefs");
2427 for (i = 0; i < list_length(node->exprs); i++)
2428 appendStringInfo(str, " %u", node->sortgrouprefs[i]);
2429 }
2430 WRITE_FLOAT_FIELD(cost.startup, "%.2f");
2431 WRITE_FLOAT_FIELD(cost.per_tuple, "%.2f");
2432 WRITE_INT_FIELD(width);
2433 }
2434
2435 static void
_outParamPathInfo(StringInfo str,const ParamPathInfo * node)2436 _outParamPathInfo(StringInfo str, const ParamPathInfo *node)
2437 {
2438 WRITE_NODE_TYPE("PARAMPATHINFO");
2439
2440 WRITE_BITMAPSET_FIELD(ppi_req_outer);
2441 WRITE_FLOAT_FIELD(ppi_rows, "%.0f");
2442 WRITE_NODE_FIELD(ppi_clauses);
2443 }
2444
2445 static void
_outRestrictInfo(StringInfo str,const RestrictInfo * node)2446 _outRestrictInfo(StringInfo str, const RestrictInfo *node)
2447 {
2448 WRITE_NODE_TYPE("RESTRICTINFO");
2449
2450 /* NB: this isn't a complete set of fields */
2451 WRITE_NODE_FIELD(clause);
2452 WRITE_BOOL_FIELD(is_pushed_down);
2453 WRITE_BOOL_FIELD(outerjoin_delayed);
2454 WRITE_BOOL_FIELD(can_join);
2455 WRITE_BOOL_FIELD(pseudoconstant);
2456 WRITE_BOOL_FIELD(leakproof);
2457 WRITE_UINT_FIELD(security_level);
2458 WRITE_BITMAPSET_FIELD(clause_relids);
2459 WRITE_BITMAPSET_FIELD(required_relids);
2460 WRITE_BITMAPSET_FIELD(outer_relids);
2461 WRITE_BITMAPSET_FIELD(nullable_relids);
2462 WRITE_BITMAPSET_FIELD(left_relids);
2463 WRITE_BITMAPSET_FIELD(right_relids);
2464 WRITE_NODE_FIELD(orclause);
2465 /* don't write parent_ec, leads to infinite recursion in plan tree dump */
2466 WRITE_FLOAT_FIELD(norm_selec, "%.4f");
2467 WRITE_FLOAT_FIELD(outer_selec, "%.4f");
2468 WRITE_NODE_FIELD(mergeopfamilies);
2469 /* don't write left_ec, leads to infinite recursion in plan tree dump */
2470 /* don't write right_ec, leads to infinite recursion in plan tree dump */
2471 WRITE_NODE_FIELD(left_em);
2472 WRITE_NODE_FIELD(right_em);
2473 WRITE_BOOL_FIELD(outer_is_left);
2474 WRITE_OID_FIELD(hashjoinoperator);
2475 }
2476
2477 static void
_outPlaceHolderVar(StringInfo str,const PlaceHolderVar * node)2478 _outPlaceHolderVar(StringInfo str, const PlaceHolderVar *node)
2479 {
2480 WRITE_NODE_TYPE("PLACEHOLDERVAR");
2481
2482 WRITE_NODE_FIELD(phexpr);
2483 WRITE_BITMAPSET_FIELD(phrels);
2484 WRITE_UINT_FIELD(phid);
2485 WRITE_UINT_FIELD(phlevelsup);
2486 }
2487
2488 static void
_outSpecialJoinInfo(StringInfo str,const SpecialJoinInfo * node)2489 _outSpecialJoinInfo(StringInfo str, const SpecialJoinInfo *node)
2490 {
2491 WRITE_NODE_TYPE("SPECIALJOININFO");
2492
2493 WRITE_BITMAPSET_FIELD(min_lefthand);
2494 WRITE_BITMAPSET_FIELD(min_righthand);
2495 WRITE_BITMAPSET_FIELD(syn_lefthand);
2496 WRITE_BITMAPSET_FIELD(syn_righthand);
2497 WRITE_ENUM_FIELD(jointype, JoinType);
2498 WRITE_BOOL_FIELD(lhs_strict);
2499 WRITE_BOOL_FIELD(delay_upper_joins);
2500 WRITE_BOOL_FIELD(semi_can_btree);
2501 WRITE_BOOL_FIELD(semi_can_hash);
2502 WRITE_NODE_FIELD(semi_operators);
2503 WRITE_NODE_FIELD(semi_rhs_exprs);
2504 }
2505
2506 static void
_outAppendRelInfo(StringInfo str,const AppendRelInfo * node)2507 _outAppendRelInfo(StringInfo str, const AppendRelInfo *node)
2508 {
2509 WRITE_NODE_TYPE("APPENDRELINFO");
2510
2511 WRITE_UINT_FIELD(parent_relid);
2512 WRITE_UINT_FIELD(child_relid);
2513 WRITE_OID_FIELD(parent_reltype);
2514 WRITE_OID_FIELD(child_reltype);
2515 WRITE_NODE_FIELD(translated_vars);
2516 WRITE_OID_FIELD(parent_reloid);
2517 }
2518
2519 static void
_outPartitionedChildRelInfo(StringInfo str,const PartitionedChildRelInfo * node)2520 _outPartitionedChildRelInfo(StringInfo str, const PartitionedChildRelInfo *node)
2521 {
2522 WRITE_NODE_TYPE("PARTITIONEDCHILDRELINFO");
2523
2524 WRITE_UINT_FIELD(parent_relid);
2525 WRITE_NODE_FIELD(child_rels);
2526 }
2527
2528 static void
_outPlaceHolderInfo(StringInfo str,const PlaceHolderInfo * node)2529 _outPlaceHolderInfo(StringInfo str, const PlaceHolderInfo *node)
2530 {
2531 WRITE_NODE_TYPE("PLACEHOLDERINFO");
2532
2533 WRITE_UINT_FIELD(phid);
2534 WRITE_NODE_FIELD(ph_var);
2535 WRITE_BITMAPSET_FIELD(ph_eval_at);
2536 WRITE_BITMAPSET_FIELD(ph_lateral);
2537 WRITE_BITMAPSET_FIELD(ph_needed);
2538 WRITE_INT_FIELD(ph_width);
2539 }
2540
2541 static void
_outMinMaxAggInfo(StringInfo str,const MinMaxAggInfo * node)2542 _outMinMaxAggInfo(StringInfo str, const MinMaxAggInfo *node)
2543 {
2544 WRITE_NODE_TYPE("MINMAXAGGINFO");
2545
2546 WRITE_OID_FIELD(aggfnoid);
2547 WRITE_OID_FIELD(aggsortop);
2548 WRITE_NODE_FIELD(target);
2549 /* We intentionally omit subroot --- too large, not interesting enough */
2550 WRITE_NODE_FIELD(path);
2551 WRITE_FLOAT_FIELD(pathcost, "%.2f");
2552 WRITE_NODE_FIELD(param);
2553 }
2554
2555 static void
_outPlannerParamItem(StringInfo str,const PlannerParamItem * node)2556 _outPlannerParamItem(StringInfo str, const PlannerParamItem *node)
2557 {
2558 WRITE_NODE_TYPE("PLANNERPARAMITEM");
2559
2560 WRITE_NODE_FIELD(item);
2561 WRITE_INT_FIELD(paramId);
2562 }
2563
2564 /*****************************************************************************
2565 *
2566 * Stuff from extensible.h
2567 *
2568 *****************************************************************************/
2569
2570 static void
_outExtensibleNode(StringInfo str,const ExtensibleNode * node)2571 _outExtensibleNode(StringInfo str, const ExtensibleNode *node)
2572 {
2573 const ExtensibleNodeMethods *methods;
2574
2575 methods = GetExtensibleNodeMethods(node->extnodename, false);
2576
2577 WRITE_NODE_TYPE("EXTENSIBLENODE");
2578
2579 WRITE_STRING_FIELD(extnodename);
2580
2581 /* serialize the private fields */
2582 methods->nodeOut(str, node);
2583 }
2584
2585 /*****************************************************************************
2586 *
2587 * Stuff from parsenodes.h.
2588 *
2589 *****************************************************************************/
2590
2591 /*
2592 * print the basic stuff of all nodes that inherit from CreateStmt
2593 */
2594 static void
_outCreateStmtInfo(StringInfo str,const CreateStmt * node)2595 _outCreateStmtInfo(StringInfo str, const CreateStmt *node)
2596 {
2597 WRITE_NODE_FIELD(relation);
2598 WRITE_NODE_FIELD(tableElts);
2599 WRITE_NODE_FIELD(inhRelations);
2600 WRITE_NODE_FIELD(partspec);
2601 WRITE_NODE_FIELD(partbound);
2602 WRITE_NODE_FIELD(ofTypename);
2603 WRITE_NODE_FIELD(constraints);
2604 WRITE_NODE_FIELD(options);
2605 WRITE_ENUM_FIELD(oncommit, OnCommitAction);
2606 WRITE_STRING_FIELD(tablespacename);
2607 WRITE_BOOL_FIELD(if_not_exists);
2608 }
2609
2610 static void
_outCreateStmt(StringInfo str,const CreateStmt * node)2611 _outCreateStmt(StringInfo str, const CreateStmt *node)
2612 {
2613 WRITE_NODE_TYPE("CREATESTMT");
2614
2615 _outCreateStmtInfo(str, (const CreateStmt *) node);
2616 }
2617
2618 static void
_outCreateForeignTableStmt(StringInfo str,const CreateForeignTableStmt * node)2619 _outCreateForeignTableStmt(StringInfo str, const CreateForeignTableStmt *node)
2620 {
2621 WRITE_NODE_TYPE("CREATEFOREIGNTABLESTMT");
2622
2623 _outCreateStmtInfo(str, (const CreateStmt *) node);
2624
2625 WRITE_STRING_FIELD(servername);
2626 WRITE_NODE_FIELD(options);
2627 }
2628
2629 static void
_outImportForeignSchemaStmt(StringInfo str,const ImportForeignSchemaStmt * node)2630 _outImportForeignSchemaStmt(StringInfo str, const ImportForeignSchemaStmt *node)
2631 {
2632 WRITE_NODE_TYPE("IMPORTFOREIGNSCHEMASTMT");
2633
2634 WRITE_STRING_FIELD(server_name);
2635 WRITE_STRING_FIELD(remote_schema);
2636 WRITE_STRING_FIELD(local_schema);
2637 WRITE_ENUM_FIELD(list_type, ImportForeignSchemaType);
2638 WRITE_NODE_FIELD(table_list);
2639 WRITE_NODE_FIELD(options);
2640 }
2641
2642 static void
_outIndexStmt(StringInfo str,const IndexStmt * node)2643 _outIndexStmt(StringInfo str, const IndexStmt *node)
2644 {
2645 WRITE_NODE_TYPE("INDEXSTMT");
2646
2647 WRITE_STRING_FIELD(idxname);
2648 WRITE_NODE_FIELD(relation);
2649 WRITE_STRING_FIELD(accessMethod);
2650 WRITE_STRING_FIELD(tableSpace);
2651 WRITE_NODE_FIELD(indexParams);
2652 WRITE_NODE_FIELD(options);
2653 WRITE_NODE_FIELD(whereClause);
2654 WRITE_NODE_FIELD(excludeOpNames);
2655 WRITE_STRING_FIELD(idxcomment);
2656 WRITE_OID_FIELD(indexOid);
2657 WRITE_OID_FIELD(oldNode);
2658 WRITE_BOOL_FIELD(unique);
2659 WRITE_BOOL_FIELD(primary);
2660 WRITE_BOOL_FIELD(isconstraint);
2661 WRITE_BOOL_FIELD(deferrable);
2662 WRITE_BOOL_FIELD(initdeferred);
2663 WRITE_BOOL_FIELD(transformed);
2664 WRITE_BOOL_FIELD(concurrent);
2665 WRITE_BOOL_FIELD(if_not_exists);
2666 }
2667
2668 static void
_outCreateStatsStmt(StringInfo str,const CreateStatsStmt * node)2669 _outCreateStatsStmt(StringInfo str, const CreateStatsStmt *node)
2670 {
2671 WRITE_NODE_TYPE("CREATESTATSSTMT");
2672
2673 WRITE_NODE_FIELD(defnames);
2674 WRITE_NODE_FIELD(stat_types);
2675 WRITE_NODE_FIELD(exprs);
2676 WRITE_NODE_FIELD(relations);
2677 WRITE_BOOL_FIELD(if_not_exists);
2678 }
2679
2680 static void
_outNotifyStmt(StringInfo str,const NotifyStmt * node)2681 _outNotifyStmt(StringInfo str, const NotifyStmt *node)
2682 {
2683 WRITE_NODE_TYPE("NOTIFY");
2684
2685 WRITE_STRING_FIELD(conditionname);
2686 WRITE_STRING_FIELD(payload);
2687 }
2688
2689 static void
_outDeclareCursorStmt(StringInfo str,const DeclareCursorStmt * node)2690 _outDeclareCursorStmt(StringInfo str, const DeclareCursorStmt *node)
2691 {
2692 WRITE_NODE_TYPE("DECLARECURSOR");
2693
2694 WRITE_STRING_FIELD(portalname);
2695 WRITE_INT_FIELD(options);
2696 WRITE_NODE_FIELD(query);
2697 }
2698
2699 static void
_outSelectStmt(StringInfo str,const SelectStmt * node)2700 _outSelectStmt(StringInfo str, const SelectStmt *node)
2701 {
2702 WRITE_NODE_TYPE("SELECT");
2703
2704 WRITE_NODE_FIELD(distinctClause);
2705 WRITE_NODE_FIELD(intoClause);
2706 WRITE_NODE_FIELD(targetList);
2707 WRITE_NODE_FIELD(fromClause);
2708 WRITE_NODE_FIELD(whereClause);
2709 WRITE_NODE_FIELD(groupClause);
2710 WRITE_NODE_FIELD(havingClause);
2711 WRITE_NODE_FIELD(windowClause);
2712 WRITE_NODE_FIELD(valuesLists);
2713 WRITE_NODE_FIELD(sortClause);
2714 WRITE_NODE_FIELD(limitOffset);
2715 WRITE_NODE_FIELD(limitCount);
2716 WRITE_NODE_FIELD(lockingClause);
2717 WRITE_NODE_FIELD(withClause);
2718 WRITE_ENUM_FIELD(op, SetOperation);
2719 WRITE_BOOL_FIELD(all);
2720 WRITE_NODE_FIELD(larg);
2721 WRITE_NODE_FIELD(rarg);
2722 }
2723
2724 static void
_outFuncCall(StringInfo str,const FuncCall * node)2725 _outFuncCall(StringInfo str, const FuncCall *node)
2726 {
2727 WRITE_NODE_TYPE("FUNCCALL");
2728
2729 WRITE_NODE_FIELD(funcname);
2730 WRITE_NODE_FIELD(args);
2731 WRITE_NODE_FIELD(agg_order);
2732 WRITE_NODE_FIELD(agg_filter);
2733 WRITE_BOOL_FIELD(agg_within_group);
2734 WRITE_BOOL_FIELD(agg_star);
2735 WRITE_BOOL_FIELD(agg_distinct);
2736 WRITE_BOOL_FIELD(func_variadic);
2737 WRITE_NODE_FIELD(over);
2738 WRITE_LOCATION_FIELD(location);
2739 }
2740
2741 static void
_outDefElem(StringInfo str,const DefElem * node)2742 _outDefElem(StringInfo str, const DefElem *node)
2743 {
2744 WRITE_NODE_TYPE("DEFELEM");
2745
2746 WRITE_STRING_FIELD(defnamespace);
2747 WRITE_STRING_FIELD(defname);
2748 WRITE_NODE_FIELD(arg);
2749 WRITE_ENUM_FIELD(defaction, DefElemAction);
2750 WRITE_LOCATION_FIELD(location);
2751 }
2752
2753 static void
_outTableLikeClause(StringInfo str,const TableLikeClause * node)2754 _outTableLikeClause(StringInfo str, const TableLikeClause *node)
2755 {
2756 WRITE_NODE_TYPE("TABLELIKECLAUSE");
2757
2758 WRITE_NODE_FIELD(relation);
2759 WRITE_UINT_FIELD(options);
2760 WRITE_OID_FIELD(relationOid);
2761 }
2762
2763 static void
_outLockingClause(StringInfo str,const LockingClause * node)2764 _outLockingClause(StringInfo str, const LockingClause *node)
2765 {
2766 WRITE_NODE_TYPE("LOCKINGCLAUSE");
2767
2768 WRITE_NODE_FIELD(lockedRels);
2769 WRITE_ENUM_FIELD(strength, LockClauseStrength);
2770 WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
2771 }
2772
2773 static void
_outXmlSerialize(StringInfo str,const XmlSerialize * node)2774 _outXmlSerialize(StringInfo str, const XmlSerialize *node)
2775 {
2776 WRITE_NODE_TYPE("XMLSERIALIZE");
2777
2778 WRITE_ENUM_FIELD(xmloption, XmlOptionType);
2779 WRITE_NODE_FIELD(expr);
2780 WRITE_NODE_FIELD(typeName);
2781 WRITE_LOCATION_FIELD(location);
2782 }
2783
2784 static void
_outTriggerTransition(StringInfo str,const TriggerTransition * node)2785 _outTriggerTransition(StringInfo str, const TriggerTransition *node)
2786 {
2787 WRITE_NODE_TYPE("TRIGGERTRANSITION");
2788
2789 WRITE_STRING_FIELD(name);
2790 WRITE_BOOL_FIELD(isNew);
2791 WRITE_BOOL_FIELD(isTable);
2792 }
2793
2794 static void
_outColumnDef(StringInfo str,const ColumnDef * node)2795 _outColumnDef(StringInfo str, const ColumnDef *node)
2796 {
2797 WRITE_NODE_TYPE("COLUMNDEF");
2798
2799 WRITE_STRING_FIELD(colname);
2800 WRITE_NODE_FIELD(typeName);
2801 WRITE_INT_FIELD(inhcount);
2802 WRITE_BOOL_FIELD(is_local);
2803 WRITE_BOOL_FIELD(is_not_null);
2804 WRITE_BOOL_FIELD(is_from_type);
2805 WRITE_BOOL_FIELD(is_from_parent);
2806 WRITE_CHAR_FIELD(storage);
2807 WRITE_NODE_FIELD(raw_default);
2808 WRITE_NODE_FIELD(cooked_default);
2809 WRITE_CHAR_FIELD(identity);
2810 WRITE_NODE_FIELD(identitySequence);
2811 WRITE_NODE_FIELD(collClause);
2812 WRITE_OID_FIELD(collOid);
2813 WRITE_NODE_FIELD(constraints);
2814 WRITE_NODE_FIELD(fdwoptions);
2815 WRITE_LOCATION_FIELD(location);
2816 }
2817
2818 static void
_outTypeName(StringInfo str,const TypeName * node)2819 _outTypeName(StringInfo str, const TypeName *node)
2820 {
2821 WRITE_NODE_TYPE("TYPENAME");
2822
2823 WRITE_NODE_FIELD(names);
2824 WRITE_OID_FIELD(typeOid);
2825 WRITE_BOOL_FIELD(setof);
2826 WRITE_BOOL_FIELD(pct_type);
2827 WRITE_NODE_FIELD(typmods);
2828 WRITE_INT_FIELD(typemod);
2829 WRITE_NODE_FIELD(arrayBounds);
2830 WRITE_LOCATION_FIELD(location);
2831 }
2832
2833 static void
_outTypeCast(StringInfo str,const TypeCast * node)2834 _outTypeCast(StringInfo str, const TypeCast *node)
2835 {
2836 WRITE_NODE_TYPE("TYPECAST");
2837
2838 WRITE_NODE_FIELD(arg);
2839 WRITE_NODE_FIELD(typeName);
2840 WRITE_LOCATION_FIELD(location);
2841 }
2842
2843 static void
_outCollateClause(StringInfo str,const CollateClause * node)2844 _outCollateClause(StringInfo str, const CollateClause *node)
2845 {
2846 WRITE_NODE_TYPE("COLLATECLAUSE");
2847
2848 WRITE_NODE_FIELD(arg);
2849 WRITE_NODE_FIELD(collname);
2850 WRITE_LOCATION_FIELD(location);
2851 }
2852
2853 static void
_outIndexElem(StringInfo str,const IndexElem * node)2854 _outIndexElem(StringInfo str, const IndexElem *node)
2855 {
2856 WRITE_NODE_TYPE("INDEXELEM");
2857
2858 WRITE_STRING_FIELD(name);
2859 WRITE_NODE_FIELD(expr);
2860 WRITE_STRING_FIELD(indexcolname);
2861 WRITE_NODE_FIELD(collation);
2862 WRITE_NODE_FIELD(opclass);
2863 WRITE_ENUM_FIELD(ordering, SortByDir);
2864 WRITE_ENUM_FIELD(nulls_ordering, SortByNulls);
2865 }
2866
2867 static void
_outQuery(StringInfo str,const Query * node)2868 _outQuery(StringInfo str, const Query *node)
2869 {
2870 WRITE_NODE_TYPE("QUERY");
2871
2872 WRITE_ENUM_FIELD(commandType, CmdType);
2873 WRITE_ENUM_FIELD(querySource, QuerySource);
2874 /* we intentionally do not print the queryId field */
2875 WRITE_BOOL_FIELD(canSetTag);
2876
2877 /*
2878 * Hack to work around missing outfuncs routines for a lot of the
2879 * utility-statement node types. (The only one we actually *need* for
2880 * rules support is NotifyStmt.) Someday we ought to support 'em all, but
2881 * for the meantime do this to avoid getting lots of warnings when running
2882 * with debug_print_parse on.
2883 */
2884 if (node->utilityStmt)
2885 {
2886 switch (nodeTag(node->utilityStmt))
2887 {
2888 case T_CreateStmt:
2889 case T_IndexStmt:
2890 case T_NotifyStmt:
2891 case T_DeclareCursorStmt:
2892 WRITE_NODE_FIELD(utilityStmt);
2893 break;
2894 default:
2895 appendStringInfoString(str, " :utilityStmt ?");
2896 break;
2897 }
2898 }
2899 else
2900 appendStringInfoString(str, " :utilityStmt <>");
2901
2902 WRITE_INT_FIELD(resultRelation);
2903 WRITE_BOOL_FIELD(hasAggs);
2904 WRITE_BOOL_FIELD(hasWindowFuncs);
2905 WRITE_BOOL_FIELD(hasTargetSRFs);
2906 WRITE_BOOL_FIELD(hasSubLinks);
2907 WRITE_BOOL_FIELD(hasDistinctOn);
2908 WRITE_BOOL_FIELD(hasRecursive);
2909 WRITE_BOOL_FIELD(hasModifyingCTE);
2910 WRITE_BOOL_FIELD(hasForUpdate);
2911 WRITE_BOOL_FIELD(hasRowSecurity);
2912 WRITE_NODE_FIELD(cteList);
2913 WRITE_NODE_FIELD(rtable);
2914 WRITE_NODE_FIELD(jointree);
2915 WRITE_NODE_FIELD(targetList);
2916 WRITE_ENUM_FIELD(override, OverridingKind);
2917 WRITE_NODE_FIELD(onConflict);
2918 WRITE_NODE_FIELD(returningList);
2919 WRITE_NODE_FIELD(groupClause);
2920 WRITE_NODE_FIELD(groupingSets);
2921 WRITE_NODE_FIELD(havingQual);
2922 WRITE_NODE_FIELD(windowClause);
2923 WRITE_NODE_FIELD(distinctClause);
2924 WRITE_NODE_FIELD(sortClause);
2925 WRITE_NODE_FIELD(limitOffset);
2926 WRITE_NODE_FIELD(limitCount);
2927 WRITE_NODE_FIELD(rowMarks);
2928 WRITE_NODE_FIELD(setOperations);
2929 WRITE_NODE_FIELD(constraintDeps);
2930 /* withCheckOptions intentionally omitted, see comment in parsenodes.h */
2931 WRITE_LOCATION_FIELD(stmt_location);
2932 WRITE_LOCATION_FIELD(stmt_len);
2933 }
2934
2935 static void
_outWithCheckOption(StringInfo str,const WithCheckOption * node)2936 _outWithCheckOption(StringInfo str, const WithCheckOption *node)
2937 {
2938 WRITE_NODE_TYPE("WITHCHECKOPTION");
2939
2940 WRITE_ENUM_FIELD(kind, WCOKind);
2941 WRITE_STRING_FIELD(relname);
2942 WRITE_STRING_FIELD(polname);
2943 WRITE_NODE_FIELD(qual);
2944 WRITE_BOOL_FIELD(cascaded);
2945 }
2946
2947 static void
_outSortGroupClause(StringInfo str,const SortGroupClause * node)2948 _outSortGroupClause(StringInfo str, const SortGroupClause *node)
2949 {
2950 WRITE_NODE_TYPE("SORTGROUPCLAUSE");
2951
2952 WRITE_UINT_FIELD(tleSortGroupRef);
2953 WRITE_OID_FIELD(eqop);
2954 WRITE_OID_FIELD(sortop);
2955 WRITE_BOOL_FIELD(nulls_first);
2956 WRITE_BOOL_FIELD(hashable);
2957 }
2958
2959 static void
_outGroupingSet(StringInfo str,const GroupingSet * node)2960 _outGroupingSet(StringInfo str, const GroupingSet *node)
2961 {
2962 WRITE_NODE_TYPE("GROUPINGSET");
2963
2964 WRITE_ENUM_FIELD(kind, GroupingSetKind);
2965 WRITE_NODE_FIELD(content);
2966 WRITE_LOCATION_FIELD(location);
2967 }
2968
2969 static void
_outWindowClause(StringInfo str,const WindowClause * node)2970 _outWindowClause(StringInfo str, const WindowClause *node)
2971 {
2972 WRITE_NODE_TYPE("WINDOWCLAUSE");
2973
2974 WRITE_STRING_FIELD(name);
2975 WRITE_STRING_FIELD(refname);
2976 WRITE_NODE_FIELD(partitionClause);
2977 WRITE_NODE_FIELD(orderClause);
2978 WRITE_INT_FIELD(frameOptions);
2979 WRITE_NODE_FIELD(startOffset);
2980 WRITE_NODE_FIELD(endOffset);
2981 WRITE_UINT_FIELD(winref);
2982 WRITE_BOOL_FIELD(copiedOrder);
2983 }
2984
2985 static void
_outRowMarkClause(StringInfo str,const RowMarkClause * node)2986 _outRowMarkClause(StringInfo str, const RowMarkClause *node)
2987 {
2988 WRITE_NODE_TYPE("ROWMARKCLAUSE");
2989
2990 WRITE_UINT_FIELD(rti);
2991 WRITE_ENUM_FIELD(strength, LockClauseStrength);
2992 WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy);
2993 WRITE_BOOL_FIELD(pushedDown);
2994 }
2995
2996 static void
_outWithClause(StringInfo str,const WithClause * node)2997 _outWithClause(StringInfo str, const WithClause *node)
2998 {
2999 WRITE_NODE_TYPE("WITHCLAUSE");
3000
3001 WRITE_NODE_FIELD(ctes);
3002 WRITE_BOOL_FIELD(recursive);
3003 WRITE_LOCATION_FIELD(location);
3004 }
3005
3006 static void
_outCommonTableExpr(StringInfo str,const CommonTableExpr * node)3007 _outCommonTableExpr(StringInfo str, const CommonTableExpr *node)
3008 {
3009 WRITE_NODE_TYPE("COMMONTABLEEXPR");
3010
3011 WRITE_STRING_FIELD(ctename);
3012 WRITE_NODE_FIELD(aliascolnames);
3013 WRITE_NODE_FIELD(ctequery);
3014 WRITE_LOCATION_FIELD(location);
3015 WRITE_BOOL_FIELD(cterecursive);
3016 WRITE_INT_FIELD(cterefcount);
3017 WRITE_NODE_FIELD(ctecolnames);
3018 WRITE_NODE_FIELD(ctecoltypes);
3019 WRITE_NODE_FIELD(ctecoltypmods);
3020 WRITE_NODE_FIELD(ctecolcollations);
3021 }
3022
3023 static void
_outSetOperationStmt(StringInfo str,const SetOperationStmt * node)3024 _outSetOperationStmt(StringInfo str, const SetOperationStmt *node)
3025 {
3026 WRITE_NODE_TYPE("SETOPERATIONSTMT");
3027
3028 WRITE_ENUM_FIELD(op, SetOperation);
3029 WRITE_BOOL_FIELD(all);
3030 WRITE_NODE_FIELD(larg);
3031 WRITE_NODE_FIELD(rarg);
3032 WRITE_NODE_FIELD(colTypes);
3033 WRITE_NODE_FIELD(colTypmods);
3034 WRITE_NODE_FIELD(colCollations);
3035 WRITE_NODE_FIELD(groupClauses);
3036 }
3037
3038 static void
_outRangeTblEntry(StringInfo str,const RangeTblEntry * node)3039 _outRangeTblEntry(StringInfo str, const RangeTblEntry *node)
3040 {
3041 WRITE_NODE_TYPE("RTE");
3042
3043 /* put alias + eref first to make dump more legible */
3044 WRITE_NODE_FIELD(alias);
3045 WRITE_NODE_FIELD(eref);
3046 WRITE_ENUM_FIELD(rtekind, RTEKind);
3047
3048 switch (node->rtekind)
3049 {
3050 case RTE_RELATION:
3051 WRITE_OID_FIELD(relid);
3052 WRITE_CHAR_FIELD(relkind);
3053 WRITE_NODE_FIELD(tablesample);
3054 break;
3055 case RTE_SUBQUERY:
3056 WRITE_NODE_FIELD(subquery);
3057 WRITE_BOOL_FIELD(security_barrier);
3058 break;
3059 case RTE_JOIN:
3060 WRITE_ENUM_FIELD(jointype, JoinType);
3061 WRITE_NODE_FIELD(joinaliasvars);
3062 break;
3063 case RTE_FUNCTION:
3064 WRITE_NODE_FIELD(functions);
3065 WRITE_BOOL_FIELD(funcordinality);
3066 break;
3067 case RTE_TABLEFUNC:
3068 WRITE_NODE_FIELD(tablefunc);
3069 break;
3070 case RTE_VALUES:
3071 WRITE_NODE_FIELD(values_lists);
3072 WRITE_NODE_FIELD(coltypes);
3073 WRITE_NODE_FIELD(coltypmods);
3074 WRITE_NODE_FIELD(colcollations);
3075 break;
3076 case RTE_CTE:
3077 WRITE_STRING_FIELD(ctename);
3078 WRITE_UINT_FIELD(ctelevelsup);
3079 WRITE_BOOL_FIELD(self_reference);
3080 WRITE_NODE_FIELD(coltypes);
3081 WRITE_NODE_FIELD(coltypmods);
3082 WRITE_NODE_FIELD(colcollations);
3083 break;
3084 case RTE_NAMEDTUPLESTORE:
3085 WRITE_STRING_FIELD(enrname);
3086 WRITE_FLOAT_FIELD(enrtuples, "%.0f");
3087 WRITE_OID_FIELD(relid);
3088 WRITE_NODE_FIELD(coltypes);
3089 WRITE_NODE_FIELD(coltypmods);
3090 WRITE_NODE_FIELD(colcollations);
3091 break;
3092 default:
3093 elog(ERROR, "unrecognized RTE kind: %d", (int) node->rtekind);
3094 break;
3095 }
3096
3097 WRITE_BOOL_FIELD(lateral);
3098 WRITE_BOOL_FIELD(inh);
3099 WRITE_BOOL_FIELD(inFromCl);
3100 WRITE_UINT_FIELD(requiredPerms);
3101 WRITE_OID_FIELD(checkAsUser);
3102 WRITE_BITMAPSET_FIELD(selectedCols);
3103 WRITE_BITMAPSET_FIELD(insertedCols);
3104 WRITE_BITMAPSET_FIELD(updatedCols);
3105 WRITE_NODE_FIELD(securityQuals);
3106 }
3107
3108 static void
_outRangeTblFunction(StringInfo str,const RangeTblFunction * node)3109 _outRangeTblFunction(StringInfo str, const RangeTblFunction *node)
3110 {
3111 WRITE_NODE_TYPE("RANGETBLFUNCTION");
3112
3113 WRITE_NODE_FIELD(funcexpr);
3114 WRITE_INT_FIELD(funccolcount);
3115 WRITE_NODE_FIELD(funccolnames);
3116 WRITE_NODE_FIELD(funccoltypes);
3117 WRITE_NODE_FIELD(funccoltypmods);
3118 WRITE_NODE_FIELD(funccolcollations);
3119 WRITE_BITMAPSET_FIELD(funcparams);
3120 }
3121
3122 static void
_outTableSampleClause(StringInfo str,const TableSampleClause * node)3123 _outTableSampleClause(StringInfo str, const TableSampleClause *node)
3124 {
3125 WRITE_NODE_TYPE("TABLESAMPLECLAUSE");
3126
3127 WRITE_OID_FIELD(tsmhandler);
3128 WRITE_NODE_FIELD(args);
3129 WRITE_NODE_FIELD(repeatable);
3130 }
3131
3132 static void
_outAExpr(StringInfo str,const A_Expr * node)3133 _outAExpr(StringInfo str, const A_Expr *node)
3134 {
3135 WRITE_NODE_TYPE("AEXPR");
3136
3137 switch (node->kind)
3138 {
3139 case AEXPR_OP:
3140 appendStringInfoChar(str, ' ');
3141 WRITE_NODE_FIELD(name);
3142 break;
3143 case AEXPR_OP_ANY:
3144 appendStringInfoChar(str, ' ');
3145 WRITE_NODE_FIELD(name);
3146 appendStringInfoString(str, " ANY ");
3147 break;
3148 case AEXPR_OP_ALL:
3149 appendStringInfoChar(str, ' ');
3150 WRITE_NODE_FIELD(name);
3151 appendStringInfoString(str, " ALL ");
3152 break;
3153 case AEXPR_DISTINCT:
3154 appendStringInfoString(str, " DISTINCT ");
3155 WRITE_NODE_FIELD(name);
3156 break;
3157 case AEXPR_NOT_DISTINCT:
3158 appendStringInfoString(str, " NOT_DISTINCT ");
3159 WRITE_NODE_FIELD(name);
3160 break;
3161 case AEXPR_NULLIF:
3162 appendStringInfoString(str, " NULLIF ");
3163 WRITE_NODE_FIELD(name);
3164 break;
3165 case AEXPR_OF:
3166 appendStringInfoString(str, " OF ");
3167 WRITE_NODE_FIELD(name);
3168 break;
3169 case AEXPR_IN:
3170 appendStringInfoString(str, " IN ");
3171 WRITE_NODE_FIELD(name);
3172 break;
3173 case AEXPR_LIKE:
3174 appendStringInfoString(str, " LIKE ");
3175 WRITE_NODE_FIELD(name);
3176 break;
3177 case AEXPR_ILIKE:
3178 appendStringInfoString(str, " ILIKE ");
3179 WRITE_NODE_FIELD(name);
3180 break;
3181 case AEXPR_SIMILAR:
3182 appendStringInfoString(str, " SIMILAR ");
3183 WRITE_NODE_FIELD(name);
3184 break;
3185 case AEXPR_BETWEEN:
3186 appendStringInfoString(str, " BETWEEN ");
3187 WRITE_NODE_FIELD(name);
3188 break;
3189 case AEXPR_NOT_BETWEEN:
3190 appendStringInfoString(str, " NOT_BETWEEN ");
3191 WRITE_NODE_FIELD(name);
3192 break;
3193 case AEXPR_BETWEEN_SYM:
3194 appendStringInfoString(str, " BETWEEN_SYM ");
3195 WRITE_NODE_FIELD(name);
3196 break;
3197 case AEXPR_NOT_BETWEEN_SYM:
3198 appendStringInfoString(str, " NOT_BETWEEN_SYM ");
3199 WRITE_NODE_FIELD(name);
3200 break;
3201 case AEXPR_PAREN:
3202 appendStringInfoString(str, " PAREN");
3203 break;
3204 default:
3205 appendStringInfoString(str, " ??");
3206 break;
3207 }
3208
3209 WRITE_NODE_FIELD(lexpr);
3210 WRITE_NODE_FIELD(rexpr);
3211 WRITE_LOCATION_FIELD(location);
3212 }
3213
3214 static void
_outValue(StringInfo str,const Value * value)3215 _outValue(StringInfo str, const Value *value)
3216 {
3217 switch (value->type)
3218 {
3219 case T_Integer:
3220 appendStringInfo(str, "%ld", value->val.ival);
3221 break;
3222 case T_Float:
3223
3224 /*
3225 * We assume the value is a valid numeric literal and so does not
3226 * need quoting.
3227 */
3228 appendStringInfoString(str, value->val.str);
3229 break;
3230 case T_String:
3231
3232 /*
3233 * We use outToken to provide escaping of the string's content,
3234 * but we don't want it to do anything with an empty string.
3235 */
3236 appendStringInfoChar(str, '"');
3237 if (value->val.str[0] != '\0')
3238 outToken(str, value->val.str);
3239 appendStringInfoChar(str, '"');
3240 break;
3241 case T_BitString:
3242 /* internal representation already has leading 'b' */
3243 appendStringInfoString(str, value->val.str);
3244 break;
3245 case T_Null:
3246 /* this is seen only within A_Const, not in transformed trees */
3247 appendStringInfoString(str, "NULL");
3248 break;
3249 default:
3250 elog(ERROR, "unrecognized node type: %d", (int) value->type);
3251 break;
3252 }
3253 }
3254
3255 static void
_outColumnRef(StringInfo str,const ColumnRef * node)3256 _outColumnRef(StringInfo str, const ColumnRef *node)
3257 {
3258 WRITE_NODE_TYPE("COLUMNREF");
3259
3260 WRITE_NODE_FIELD(fields);
3261 WRITE_LOCATION_FIELD(location);
3262 }
3263
3264 static void
_outParamRef(StringInfo str,const ParamRef * node)3265 _outParamRef(StringInfo str, const ParamRef *node)
3266 {
3267 WRITE_NODE_TYPE("PARAMREF");
3268
3269 WRITE_INT_FIELD(number);
3270 WRITE_LOCATION_FIELD(location);
3271 }
3272
3273 /*
3274 * Node types found in raw parse trees (supported for debug purposes)
3275 */
3276
3277 static void
_outRawStmt(StringInfo str,const RawStmt * node)3278 _outRawStmt(StringInfo str, const RawStmt *node)
3279 {
3280 WRITE_NODE_TYPE("RAWSTMT");
3281
3282 WRITE_NODE_FIELD(stmt);
3283 WRITE_LOCATION_FIELD(stmt_location);
3284 WRITE_INT_FIELD(stmt_len);
3285 }
3286
3287 static void
_outAConst(StringInfo str,const A_Const * node)3288 _outAConst(StringInfo str, const A_Const *node)
3289 {
3290 WRITE_NODE_TYPE("A_CONST");
3291
3292 appendStringInfoString(str, " :val ");
3293 _outValue(str, &(node->val));
3294 WRITE_LOCATION_FIELD(location);
3295 }
3296
3297 static void
_outA_Star(StringInfo str,const A_Star * node)3298 _outA_Star(StringInfo str, const A_Star *node)
3299 {
3300 WRITE_NODE_TYPE("A_STAR");
3301 }
3302
3303 static void
_outA_Indices(StringInfo str,const A_Indices * node)3304 _outA_Indices(StringInfo str, const A_Indices *node)
3305 {
3306 WRITE_NODE_TYPE("A_INDICES");
3307
3308 WRITE_BOOL_FIELD(is_slice);
3309 WRITE_NODE_FIELD(lidx);
3310 WRITE_NODE_FIELD(uidx);
3311 }
3312
3313 static void
_outA_Indirection(StringInfo str,const A_Indirection * node)3314 _outA_Indirection(StringInfo str, const A_Indirection *node)
3315 {
3316 WRITE_NODE_TYPE("A_INDIRECTION");
3317
3318 WRITE_NODE_FIELD(arg);
3319 WRITE_NODE_FIELD(indirection);
3320 }
3321
3322 static void
_outA_ArrayExpr(StringInfo str,const A_ArrayExpr * node)3323 _outA_ArrayExpr(StringInfo str, const A_ArrayExpr *node)
3324 {
3325 WRITE_NODE_TYPE("A_ARRAYEXPR");
3326
3327 WRITE_NODE_FIELD(elements);
3328 WRITE_LOCATION_FIELD(location);
3329 }
3330
3331 static void
_outResTarget(StringInfo str,const ResTarget * node)3332 _outResTarget(StringInfo str, const ResTarget *node)
3333 {
3334 WRITE_NODE_TYPE("RESTARGET");
3335
3336 WRITE_STRING_FIELD(name);
3337 WRITE_NODE_FIELD(indirection);
3338 WRITE_NODE_FIELD(val);
3339 WRITE_LOCATION_FIELD(location);
3340 }
3341
3342 static void
_outMultiAssignRef(StringInfo str,const MultiAssignRef * node)3343 _outMultiAssignRef(StringInfo str, const MultiAssignRef *node)
3344 {
3345 WRITE_NODE_TYPE("MULTIASSIGNREF");
3346
3347 WRITE_NODE_FIELD(source);
3348 WRITE_INT_FIELD(colno);
3349 WRITE_INT_FIELD(ncolumns);
3350 }
3351
3352 static void
_outSortBy(StringInfo str,const SortBy * node)3353 _outSortBy(StringInfo str, const SortBy *node)
3354 {
3355 WRITE_NODE_TYPE("SORTBY");
3356
3357 WRITE_NODE_FIELD(node);
3358 WRITE_ENUM_FIELD(sortby_dir, SortByDir);
3359 WRITE_ENUM_FIELD(sortby_nulls, SortByNulls);
3360 WRITE_NODE_FIELD(useOp);
3361 WRITE_LOCATION_FIELD(location);
3362 }
3363
3364 static void
_outWindowDef(StringInfo str,const WindowDef * node)3365 _outWindowDef(StringInfo str, const WindowDef *node)
3366 {
3367 WRITE_NODE_TYPE("WINDOWDEF");
3368
3369 WRITE_STRING_FIELD(name);
3370 WRITE_STRING_FIELD(refname);
3371 WRITE_NODE_FIELD(partitionClause);
3372 WRITE_NODE_FIELD(orderClause);
3373 WRITE_INT_FIELD(frameOptions);
3374 WRITE_NODE_FIELD(startOffset);
3375 WRITE_NODE_FIELD(endOffset);
3376 WRITE_LOCATION_FIELD(location);
3377 }
3378
3379 static void
_outRangeSubselect(StringInfo str,const RangeSubselect * node)3380 _outRangeSubselect(StringInfo str, const RangeSubselect *node)
3381 {
3382 WRITE_NODE_TYPE("RANGESUBSELECT");
3383
3384 WRITE_BOOL_FIELD(lateral);
3385 WRITE_NODE_FIELD(subquery);
3386 WRITE_NODE_FIELD(alias);
3387 }
3388
3389 static void
_outRangeFunction(StringInfo str,const RangeFunction * node)3390 _outRangeFunction(StringInfo str, const RangeFunction *node)
3391 {
3392 WRITE_NODE_TYPE("RANGEFUNCTION");
3393
3394 WRITE_BOOL_FIELD(lateral);
3395 WRITE_BOOL_FIELD(ordinality);
3396 WRITE_BOOL_FIELD(is_rowsfrom);
3397 WRITE_NODE_FIELD(functions);
3398 WRITE_NODE_FIELD(alias);
3399 WRITE_NODE_FIELD(coldeflist);
3400 }
3401
3402 static void
_outRangeTableSample(StringInfo str,const RangeTableSample * node)3403 _outRangeTableSample(StringInfo str, const RangeTableSample *node)
3404 {
3405 WRITE_NODE_TYPE("RANGETABLESAMPLE");
3406
3407 WRITE_NODE_FIELD(relation);
3408 WRITE_NODE_FIELD(method);
3409 WRITE_NODE_FIELD(args);
3410 WRITE_NODE_FIELD(repeatable);
3411 WRITE_LOCATION_FIELD(location);
3412 }
3413
3414 static void
_outRangeTableFunc(StringInfo str,const RangeTableFunc * node)3415 _outRangeTableFunc(StringInfo str, const RangeTableFunc *node)
3416 {
3417 WRITE_NODE_TYPE("RANGETABLEFUNC");
3418
3419 WRITE_BOOL_FIELD(lateral);
3420 WRITE_NODE_FIELD(docexpr);
3421 WRITE_NODE_FIELD(rowexpr);
3422 WRITE_NODE_FIELD(namespaces);
3423 WRITE_NODE_FIELD(columns);
3424 WRITE_NODE_FIELD(alias);
3425 WRITE_LOCATION_FIELD(location);
3426 }
3427
3428 static void
_outRangeTableFuncCol(StringInfo str,const RangeTableFuncCol * node)3429 _outRangeTableFuncCol(StringInfo str, const RangeTableFuncCol *node)
3430 {
3431 WRITE_NODE_TYPE("RANGETABLEFUNCCOL");
3432
3433 WRITE_STRING_FIELD(colname);
3434 WRITE_NODE_FIELD(typeName);
3435 WRITE_BOOL_FIELD(for_ordinality);
3436 WRITE_BOOL_FIELD(is_not_null);
3437 WRITE_NODE_FIELD(colexpr);
3438 WRITE_NODE_FIELD(coldefexpr);
3439 WRITE_LOCATION_FIELD(location);
3440 }
3441
3442 static void
_outConstraint(StringInfo str,const Constraint * node)3443 _outConstraint(StringInfo str, const Constraint *node)
3444 {
3445 WRITE_NODE_TYPE("CONSTRAINT");
3446
3447 WRITE_STRING_FIELD(conname);
3448 WRITE_BOOL_FIELD(deferrable);
3449 WRITE_BOOL_FIELD(initdeferred);
3450 WRITE_LOCATION_FIELD(location);
3451
3452 appendStringInfoString(str, " :contype ");
3453 switch (node->contype)
3454 {
3455 case CONSTR_NULL:
3456 appendStringInfoString(str, "NULL");
3457 break;
3458
3459 case CONSTR_NOTNULL:
3460 appendStringInfoString(str, "NOT_NULL");
3461 break;
3462
3463 case CONSTR_DEFAULT:
3464 appendStringInfoString(str, "DEFAULT");
3465 WRITE_NODE_FIELD(raw_expr);
3466 WRITE_STRING_FIELD(cooked_expr);
3467 break;
3468
3469 case CONSTR_IDENTITY:
3470 appendStringInfoString(str, "IDENTITY");
3471 WRITE_NODE_FIELD(raw_expr);
3472 WRITE_STRING_FIELD(cooked_expr);
3473 WRITE_CHAR_FIELD(generated_when);
3474 break;
3475
3476 case CONSTR_CHECK:
3477 appendStringInfoString(str, "CHECK");
3478 WRITE_BOOL_FIELD(is_no_inherit);
3479 WRITE_NODE_FIELD(raw_expr);
3480 WRITE_STRING_FIELD(cooked_expr);
3481 break;
3482
3483 case CONSTR_PRIMARY:
3484 appendStringInfoString(str, "PRIMARY_KEY");
3485 WRITE_NODE_FIELD(keys);
3486 WRITE_NODE_FIELD(options);
3487 WRITE_STRING_FIELD(indexname);
3488 WRITE_STRING_FIELD(indexspace);
3489 /* access_method and where_clause not currently used */
3490 break;
3491
3492 case CONSTR_UNIQUE:
3493 appendStringInfoString(str, "UNIQUE");
3494 WRITE_NODE_FIELD(keys);
3495 WRITE_NODE_FIELD(options);
3496 WRITE_STRING_FIELD(indexname);
3497 WRITE_STRING_FIELD(indexspace);
3498 /* access_method and where_clause not currently used */
3499 break;
3500
3501 case CONSTR_EXCLUSION:
3502 appendStringInfoString(str, "EXCLUSION");
3503 WRITE_NODE_FIELD(exclusions);
3504 WRITE_NODE_FIELD(options);
3505 WRITE_STRING_FIELD(indexname);
3506 WRITE_STRING_FIELD(indexspace);
3507 WRITE_STRING_FIELD(access_method);
3508 WRITE_NODE_FIELD(where_clause);
3509 break;
3510
3511 case CONSTR_FOREIGN:
3512 appendStringInfoString(str, "FOREIGN_KEY");
3513 WRITE_NODE_FIELD(pktable);
3514 WRITE_NODE_FIELD(fk_attrs);
3515 WRITE_NODE_FIELD(pk_attrs);
3516 WRITE_CHAR_FIELD(fk_matchtype);
3517 WRITE_CHAR_FIELD(fk_upd_action);
3518 WRITE_CHAR_FIELD(fk_del_action);
3519 WRITE_NODE_FIELD(old_conpfeqop);
3520 WRITE_OID_FIELD(old_pktable_oid);
3521 WRITE_BOOL_FIELD(skip_validation);
3522 WRITE_BOOL_FIELD(initially_valid);
3523 break;
3524
3525 case CONSTR_ATTR_DEFERRABLE:
3526 appendStringInfoString(str, "ATTR_DEFERRABLE");
3527 break;
3528
3529 case CONSTR_ATTR_NOT_DEFERRABLE:
3530 appendStringInfoString(str, "ATTR_NOT_DEFERRABLE");
3531 break;
3532
3533 case CONSTR_ATTR_DEFERRED:
3534 appendStringInfoString(str, "ATTR_DEFERRED");
3535 break;
3536
3537 case CONSTR_ATTR_IMMEDIATE:
3538 appendStringInfoString(str, "ATTR_IMMEDIATE");
3539 break;
3540
3541 default:
3542 appendStringInfo(str, "<unrecognized_constraint %d>",
3543 (int) node->contype);
3544 break;
3545 }
3546 }
3547
3548 static void
_outForeignKeyCacheInfo(StringInfo str,const ForeignKeyCacheInfo * node)3549 _outForeignKeyCacheInfo(StringInfo str, const ForeignKeyCacheInfo *node)
3550 {
3551 int i;
3552
3553 WRITE_NODE_TYPE("FOREIGNKEYCACHEINFO");
3554
3555 WRITE_OID_FIELD(conrelid);
3556 WRITE_OID_FIELD(confrelid);
3557 WRITE_INT_FIELD(nkeys);
3558 appendStringInfoString(str, " :conkey");
3559 for (i = 0; i < node->nkeys; i++)
3560 appendStringInfo(str, " %d", node->conkey[i]);
3561 appendStringInfoString(str, " :confkey");
3562 for (i = 0; i < node->nkeys; i++)
3563 appendStringInfo(str, " %d", node->confkey[i]);
3564 appendStringInfoString(str, " :conpfeqop");
3565 for (i = 0; i < node->nkeys; i++)
3566 appendStringInfo(str, " %u", node->conpfeqop[i]);
3567 }
3568
3569 static void
_outPartitionElem(StringInfo str,const PartitionElem * node)3570 _outPartitionElem(StringInfo str, const PartitionElem *node)
3571 {
3572 WRITE_NODE_TYPE("PARTITIONELEM");
3573
3574 WRITE_STRING_FIELD(name);
3575 WRITE_NODE_FIELD(expr);
3576 WRITE_NODE_FIELD(collation);
3577 WRITE_NODE_FIELD(opclass);
3578 WRITE_LOCATION_FIELD(location);
3579 }
3580
3581 static void
_outPartitionSpec(StringInfo str,const PartitionSpec * node)3582 _outPartitionSpec(StringInfo str, const PartitionSpec *node)
3583 {
3584 WRITE_NODE_TYPE("PARTITIONSPEC");
3585
3586 WRITE_STRING_FIELD(strategy);
3587 WRITE_NODE_FIELD(partParams);
3588 WRITE_LOCATION_FIELD(location);
3589 }
3590
3591 static void
_outPartitionBoundSpec(StringInfo str,const PartitionBoundSpec * node)3592 _outPartitionBoundSpec(StringInfo str, const PartitionBoundSpec *node)
3593 {
3594 WRITE_NODE_TYPE("PARTITIONBOUNDSPEC");
3595
3596 WRITE_CHAR_FIELD(strategy);
3597 WRITE_NODE_FIELD(listdatums);
3598 WRITE_NODE_FIELD(lowerdatums);
3599 WRITE_NODE_FIELD(upperdatums);
3600 WRITE_LOCATION_FIELD(location);
3601 }
3602
3603 static void
_outPartitionRangeDatum(StringInfo str,const PartitionRangeDatum * node)3604 _outPartitionRangeDatum(StringInfo str, const PartitionRangeDatum *node)
3605 {
3606 WRITE_NODE_TYPE("PARTITIONRANGEDATUM");
3607
3608 WRITE_ENUM_FIELD(kind, PartitionRangeDatumKind);
3609 WRITE_NODE_FIELD(value);
3610 WRITE_LOCATION_FIELD(location);
3611 }
3612
3613 /*
3614 * outNode -
3615 * converts a Node into ascii string and append it to 'str'
3616 */
3617 void
outNode(StringInfo str,const void * obj)3618 outNode(StringInfo str, const void *obj)
3619 {
3620 /* Guard against stack overflow due to overly complex expressions */
3621 check_stack_depth();
3622
3623 if (obj == NULL)
3624 appendStringInfoString(str, "<>");
3625 else if (IsA(obj, List) ||IsA(obj, IntList) || IsA(obj, OidList))
3626 _outList(str, obj);
3627 else if (IsA(obj, Integer) ||
3628 IsA(obj, Float) ||
3629 IsA(obj, String) ||
3630 IsA(obj, BitString))
3631 {
3632 /* nodeRead does not want to see { } around these! */
3633 _outValue(str, obj);
3634 }
3635 else
3636 {
3637 appendStringInfoChar(str, '{');
3638 switch (nodeTag(obj))
3639 {
3640 case T_PlannedStmt:
3641 _outPlannedStmt(str, obj);
3642 break;
3643 case T_Plan:
3644 _outPlan(str, obj);
3645 break;
3646 case T_Result:
3647 _outResult(str, obj);
3648 break;
3649 case T_ProjectSet:
3650 _outProjectSet(str, obj);
3651 break;
3652 case T_ModifyTable:
3653 _outModifyTable(str, obj);
3654 break;
3655 case T_Append:
3656 _outAppend(str, obj);
3657 break;
3658 case T_MergeAppend:
3659 _outMergeAppend(str, obj);
3660 break;
3661 case T_RecursiveUnion:
3662 _outRecursiveUnion(str, obj);
3663 break;
3664 case T_BitmapAnd:
3665 _outBitmapAnd(str, obj);
3666 break;
3667 case T_BitmapOr:
3668 _outBitmapOr(str, obj);
3669 break;
3670 case T_Gather:
3671 _outGather(str, obj);
3672 break;
3673 case T_GatherMerge:
3674 _outGatherMerge(str, obj);
3675 break;
3676 case T_Scan:
3677 _outScan(str, obj);
3678 break;
3679 case T_SeqScan:
3680 _outSeqScan(str, obj);
3681 break;
3682 case T_SampleScan:
3683 _outSampleScan(str, obj);
3684 break;
3685 case T_IndexScan:
3686 _outIndexScan(str, obj);
3687 break;
3688 case T_IndexOnlyScan:
3689 _outIndexOnlyScan(str, obj);
3690 break;
3691 case T_BitmapIndexScan:
3692 _outBitmapIndexScan(str, obj);
3693 break;
3694 case T_BitmapHeapScan:
3695 _outBitmapHeapScan(str, obj);
3696 break;
3697 case T_TidScan:
3698 _outTidScan(str, obj);
3699 break;
3700 case T_SubqueryScan:
3701 _outSubqueryScan(str, obj);
3702 break;
3703 case T_FunctionScan:
3704 _outFunctionScan(str, obj);
3705 break;
3706 case T_TableFuncScan:
3707 _outTableFuncScan(str, obj);
3708 break;
3709 case T_ValuesScan:
3710 _outValuesScan(str, obj);
3711 break;
3712 case T_CteScan:
3713 _outCteScan(str, obj);
3714 break;
3715 case T_NamedTuplestoreScan:
3716 _outNamedTuplestoreScan(str, obj);
3717 break;
3718 case T_WorkTableScan:
3719 _outWorkTableScan(str, obj);
3720 break;
3721 case T_ForeignScan:
3722 _outForeignScan(str, obj);
3723 break;
3724 case T_CustomScan:
3725 _outCustomScan(str, obj);
3726 break;
3727 case T_Join:
3728 _outJoin(str, obj);
3729 break;
3730 case T_NestLoop:
3731 _outNestLoop(str, obj);
3732 break;
3733 case T_MergeJoin:
3734 _outMergeJoin(str, obj);
3735 break;
3736 case T_HashJoin:
3737 _outHashJoin(str, obj);
3738 break;
3739 case T_Agg:
3740 _outAgg(str, obj);
3741 break;
3742 case T_WindowAgg:
3743 _outWindowAgg(str, obj);
3744 break;
3745 case T_Group:
3746 _outGroup(str, obj);
3747 break;
3748 case T_Material:
3749 _outMaterial(str, obj);
3750 break;
3751 case T_Sort:
3752 _outSort(str, obj);
3753 break;
3754 case T_Unique:
3755 _outUnique(str, obj);
3756 break;
3757 case T_Hash:
3758 _outHash(str, obj);
3759 break;
3760 case T_SetOp:
3761 _outSetOp(str, obj);
3762 break;
3763 case T_LockRows:
3764 _outLockRows(str, obj);
3765 break;
3766 case T_Limit:
3767 _outLimit(str, obj);
3768 break;
3769 case T_NestLoopParam:
3770 _outNestLoopParam(str, obj);
3771 break;
3772 case T_PlanRowMark:
3773 _outPlanRowMark(str, obj);
3774 break;
3775 case T_PlanInvalItem:
3776 _outPlanInvalItem(str, obj);
3777 break;
3778 case T_Alias:
3779 _outAlias(str, obj);
3780 break;
3781 case T_RangeVar:
3782 _outRangeVar(str, obj);
3783 break;
3784 case T_TableFunc:
3785 _outTableFunc(str, obj);
3786 break;
3787 case T_IntoClause:
3788 _outIntoClause(str, obj);
3789 break;
3790 case T_Var:
3791 _outVar(str, obj);
3792 break;
3793 case T_Const:
3794 _outConst(str, obj);
3795 break;
3796 case T_Param:
3797 _outParam(str, obj);
3798 break;
3799 case T_Aggref:
3800 _outAggref(str, obj);
3801 break;
3802 case T_GroupingFunc:
3803 _outGroupingFunc(str, obj);
3804 break;
3805 case T_WindowFunc:
3806 _outWindowFunc(str, obj);
3807 break;
3808 case T_ArrayRef:
3809 _outArrayRef(str, obj);
3810 break;
3811 case T_FuncExpr:
3812 _outFuncExpr(str, obj);
3813 break;
3814 case T_NamedArgExpr:
3815 _outNamedArgExpr(str, obj);
3816 break;
3817 case T_OpExpr:
3818 _outOpExpr(str, obj);
3819 break;
3820 case T_DistinctExpr:
3821 _outDistinctExpr(str, obj);
3822 break;
3823 case T_NullIfExpr:
3824 _outNullIfExpr(str, obj);
3825 break;
3826 case T_ScalarArrayOpExpr:
3827 _outScalarArrayOpExpr(str, obj);
3828 break;
3829 case T_BoolExpr:
3830 _outBoolExpr(str, obj);
3831 break;
3832 case T_SubLink:
3833 _outSubLink(str, obj);
3834 break;
3835 case T_SubPlan:
3836 _outSubPlan(str, obj);
3837 break;
3838 case T_AlternativeSubPlan:
3839 _outAlternativeSubPlan(str, obj);
3840 break;
3841 case T_FieldSelect:
3842 _outFieldSelect(str, obj);
3843 break;
3844 case T_FieldStore:
3845 _outFieldStore(str, obj);
3846 break;
3847 case T_RelabelType:
3848 _outRelabelType(str, obj);
3849 break;
3850 case T_CoerceViaIO:
3851 _outCoerceViaIO(str, obj);
3852 break;
3853 case T_ArrayCoerceExpr:
3854 _outArrayCoerceExpr(str, obj);
3855 break;
3856 case T_ConvertRowtypeExpr:
3857 _outConvertRowtypeExpr(str, obj);
3858 break;
3859 case T_CollateExpr:
3860 _outCollateExpr(str, obj);
3861 break;
3862 case T_CaseExpr:
3863 _outCaseExpr(str, obj);
3864 break;
3865 case T_CaseWhen:
3866 _outCaseWhen(str, obj);
3867 break;
3868 case T_CaseTestExpr:
3869 _outCaseTestExpr(str, obj);
3870 break;
3871 case T_ArrayExpr:
3872 _outArrayExpr(str, obj);
3873 break;
3874 case T_RowExpr:
3875 _outRowExpr(str, obj);
3876 break;
3877 case T_RowCompareExpr:
3878 _outRowCompareExpr(str, obj);
3879 break;
3880 case T_CoalesceExpr:
3881 _outCoalesceExpr(str, obj);
3882 break;
3883 case T_MinMaxExpr:
3884 _outMinMaxExpr(str, obj);
3885 break;
3886 case T_SQLValueFunction:
3887 _outSQLValueFunction(str, obj);
3888 break;
3889 case T_XmlExpr:
3890 _outXmlExpr(str, obj);
3891 break;
3892 case T_NullTest:
3893 _outNullTest(str, obj);
3894 break;
3895 case T_BooleanTest:
3896 _outBooleanTest(str, obj);
3897 break;
3898 case T_CoerceToDomain:
3899 _outCoerceToDomain(str, obj);
3900 break;
3901 case T_CoerceToDomainValue:
3902 _outCoerceToDomainValue(str, obj);
3903 break;
3904 case T_SetToDefault:
3905 _outSetToDefault(str, obj);
3906 break;
3907 case T_CurrentOfExpr:
3908 _outCurrentOfExpr(str, obj);
3909 break;
3910 case T_NextValueExpr:
3911 _outNextValueExpr(str, obj);
3912 break;
3913 case T_InferenceElem:
3914 _outInferenceElem(str, obj);
3915 break;
3916 case T_TargetEntry:
3917 _outTargetEntry(str, obj);
3918 break;
3919 case T_RangeTblRef:
3920 _outRangeTblRef(str, obj);
3921 break;
3922 case T_JoinExpr:
3923 _outJoinExpr(str, obj);
3924 break;
3925 case T_FromExpr:
3926 _outFromExpr(str, obj);
3927 break;
3928 case T_OnConflictExpr:
3929 _outOnConflictExpr(str, obj);
3930 break;
3931 case T_Path:
3932 _outPath(str, obj);
3933 break;
3934 case T_IndexPath:
3935 _outIndexPath(str, obj);
3936 break;
3937 case T_BitmapHeapPath:
3938 _outBitmapHeapPath(str, obj);
3939 break;
3940 case T_BitmapAndPath:
3941 _outBitmapAndPath(str, obj);
3942 break;
3943 case T_BitmapOrPath:
3944 _outBitmapOrPath(str, obj);
3945 break;
3946 case T_TidPath:
3947 _outTidPath(str, obj);
3948 break;
3949 case T_SubqueryScanPath:
3950 _outSubqueryScanPath(str, obj);
3951 break;
3952 case T_ForeignPath:
3953 _outForeignPath(str, obj);
3954 break;
3955 case T_CustomPath:
3956 _outCustomPath(str, obj);
3957 break;
3958 case T_AppendPath:
3959 _outAppendPath(str, obj);
3960 break;
3961 case T_MergeAppendPath:
3962 _outMergeAppendPath(str, obj);
3963 break;
3964 case T_ResultPath:
3965 _outResultPath(str, obj);
3966 break;
3967 case T_MaterialPath:
3968 _outMaterialPath(str, obj);
3969 break;
3970 case T_UniquePath:
3971 _outUniquePath(str, obj);
3972 break;
3973 case T_GatherPath:
3974 _outGatherPath(str, obj);
3975 break;
3976 case T_ProjectionPath:
3977 _outProjectionPath(str, obj);
3978 break;
3979 case T_ProjectSetPath:
3980 _outProjectSetPath(str, obj);
3981 break;
3982 case T_SortPath:
3983 _outSortPath(str, obj);
3984 break;
3985 case T_GroupPath:
3986 _outGroupPath(str, obj);
3987 break;
3988 case T_UpperUniquePath:
3989 _outUpperUniquePath(str, obj);
3990 break;
3991 case T_AggPath:
3992 _outAggPath(str, obj);
3993 break;
3994 case T_GroupingSetsPath:
3995 _outGroupingSetsPath(str, obj);
3996 break;
3997 case T_MinMaxAggPath:
3998 _outMinMaxAggPath(str, obj);
3999 break;
4000 case T_WindowAggPath:
4001 _outWindowAggPath(str, obj);
4002 break;
4003 case T_SetOpPath:
4004 _outSetOpPath(str, obj);
4005 break;
4006 case T_RecursiveUnionPath:
4007 _outRecursiveUnionPath(str, obj);
4008 break;
4009 case T_LockRowsPath:
4010 _outLockRowsPath(str, obj);
4011 break;
4012 case T_ModifyTablePath:
4013 _outModifyTablePath(str, obj);
4014 break;
4015 case T_LimitPath:
4016 _outLimitPath(str, obj);
4017 break;
4018 case T_GatherMergePath:
4019 _outGatherMergePath(str, obj);
4020 break;
4021 case T_NestPath:
4022 _outNestPath(str, obj);
4023 break;
4024 case T_MergePath:
4025 _outMergePath(str, obj);
4026 break;
4027 case T_HashPath:
4028 _outHashPath(str, obj);
4029 break;
4030 case T_PlannerGlobal:
4031 _outPlannerGlobal(str, obj);
4032 break;
4033 case T_PlannerInfo:
4034 _outPlannerInfo(str, obj);
4035 break;
4036 case T_RelOptInfo:
4037 _outRelOptInfo(str, obj);
4038 break;
4039 case T_IndexOptInfo:
4040 _outIndexOptInfo(str, obj);
4041 break;
4042 case T_ForeignKeyOptInfo:
4043 _outForeignKeyOptInfo(str, obj);
4044 break;
4045 case T_EquivalenceClass:
4046 _outEquivalenceClass(str, obj);
4047 break;
4048 case T_EquivalenceMember:
4049 _outEquivalenceMember(str, obj);
4050 break;
4051 case T_PathKey:
4052 _outPathKey(str, obj);
4053 break;
4054 case T_PathTarget:
4055 _outPathTarget(str, obj);
4056 break;
4057 case T_ParamPathInfo:
4058 _outParamPathInfo(str, obj);
4059 break;
4060 case T_RestrictInfo:
4061 _outRestrictInfo(str, obj);
4062 break;
4063 case T_PlaceHolderVar:
4064 _outPlaceHolderVar(str, obj);
4065 break;
4066 case T_SpecialJoinInfo:
4067 _outSpecialJoinInfo(str, obj);
4068 break;
4069 case T_AppendRelInfo:
4070 _outAppendRelInfo(str, obj);
4071 break;
4072 case T_PartitionedChildRelInfo:
4073 _outPartitionedChildRelInfo(str, obj);
4074 break;
4075 case T_PlaceHolderInfo:
4076 _outPlaceHolderInfo(str, obj);
4077 break;
4078 case T_MinMaxAggInfo:
4079 _outMinMaxAggInfo(str, obj);
4080 break;
4081 case T_PlannerParamItem:
4082 _outPlannerParamItem(str, obj);
4083 break;
4084 case T_RollupData:
4085 _outRollupData(str, obj);
4086 break;
4087 case T_GroupingSetData:
4088 _outGroupingSetData(str, obj);
4089 break;
4090 case T_StatisticExtInfo:
4091 _outStatisticExtInfo(str, obj);
4092 break;
4093 case T_ExtensibleNode:
4094 _outExtensibleNode(str, obj);
4095 break;
4096 case T_CreateStmt:
4097 _outCreateStmt(str, obj);
4098 break;
4099 case T_CreateForeignTableStmt:
4100 _outCreateForeignTableStmt(str, obj);
4101 break;
4102 case T_ImportForeignSchemaStmt:
4103 _outImportForeignSchemaStmt(str, obj);
4104 break;
4105 case T_IndexStmt:
4106 _outIndexStmt(str, obj);
4107 break;
4108 case T_CreateStatsStmt:
4109 _outCreateStatsStmt(str, obj);
4110 break;
4111 case T_NotifyStmt:
4112 _outNotifyStmt(str, obj);
4113 break;
4114 case T_DeclareCursorStmt:
4115 _outDeclareCursorStmt(str, obj);
4116 break;
4117 case T_SelectStmt:
4118 _outSelectStmt(str, obj);
4119 break;
4120 case T_ColumnDef:
4121 _outColumnDef(str, obj);
4122 break;
4123 case T_TypeName:
4124 _outTypeName(str, obj);
4125 break;
4126 case T_TypeCast:
4127 _outTypeCast(str, obj);
4128 break;
4129 case T_CollateClause:
4130 _outCollateClause(str, obj);
4131 break;
4132 case T_IndexElem:
4133 _outIndexElem(str, obj);
4134 break;
4135 case T_Query:
4136 _outQuery(str, obj);
4137 break;
4138 case T_WithCheckOption:
4139 _outWithCheckOption(str, obj);
4140 break;
4141 case T_SortGroupClause:
4142 _outSortGroupClause(str, obj);
4143 break;
4144 case T_GroupingSet:
4145 _outGroupingSet(str, obj);
4146 break;
4147 case T_WindowClause:
4148 _outWindowClause(str, obj);
4149 break;
4150 case T_RowMarkClause:
4151 _outRowMarkClause(str, obj);
4152 break;
4153 case T_WithClause:
4154 _outWithClause(str, obj);
4155 break;
4156 case T_CommonTableExpr:
4157 _outCommonTableExpr(str, obj);
4158 break;
4159 case T_SetOperationStmt:
4160 _outSetOperationStmt(str, obj);
4161 break;
4162 case T_RangeTblEntry:
4163 _outRangeTblEntry(str, obj);
4164 break;
4165 case T_RangeTblFunction:
4166 _outRangeTblFunction(str, obj);
4167 break;
4168 case T_TableSampleClause:
4169 _outTableSampleClause(str, obj);
4170 break;
4171 case T_A_Expr:
4172 _outAExpr(str, obj);
4173 break;
4174 case T_ColumnRef:
4175 _outColumnRef(str, obj);
4176 break;
4177 case T_ParamRef:
4178 _outParamRef(str, obj);
4179 break;
4180 case T_RawStmt:
4181 _outRawStmt(str, obj);
4182 break;
4183 case T_A_Const:
4184 _outAConst(str, obj);
4185 break;
4186 case T_A_Star:
4187 _outA_Star(str, obj);
4188 break;
4189 case T_A_Indices:
4190 _outA_Indices(str, obj);
4191 break;
4192 case T_A_Indirection:
4193 _outA_Indirection(str, obj);
4194 break;
4195 case T_A_ArrayExpr:
4196 _outA_ArrayExpr(str, obj);
4197 break;
4198 case T_ResTarget:
4199 _outResTarget(str, obj);
4200 break;
4201 case T_MultiAssignRef:
4202 _outMultiAssignRef(str, obj);
4203 break;
4204 case T_SortBy:
4205 _outSortBy(str, obj);
4206 break;
4207 case T_WindowDef:
4208 _outWindowDef(str, obj);
4209 break;
4210 case T_RangeSubselect:
4211 _outRangeSubselect(str, obj);
4212 break;
4213 case T_RangeFunction:
4214 _outRangeFunction(str, obj);
4215 break;
4216 case T_RangeTableSample:
4217 _outRangeTableSample(str, obj);
4218 break;
4219 case T_RangeTableFunc:
4220 _outRangeTableFunc(str, obj);
4221 break;
4222 case T_RangeTableFuncCol:
4223 _outRangeTableFuncCol(str, obj);
4224 break;
4225 case T_Constraint:
4226 _outConstraint(str, obj);
4227 break;
4228 case T_FuncCall:
4229 _outFuncCall(str, obj);
4230 break;
4231 case T_DefElem:
4232 _outDefElem(str, obj);
4233 break;
4234 case T_TableLikeClause:
4235 _outTableLikeClause(str, obj);
4236 break;
4237 case T_LockingClause:
4238 _outLockingClause(str, obj);
4239 break;
4240 case T_XmlSerialize:
4241 _outXmlSerialize(str, obj);
4242 break;
4243 case T_ForeignKeyCacheInfo:
4244 _outForeignKeyCacheInfo(str, obj);
4245 break;
4246 case T_TriggerTransition:
4247 _outTriggerTransition(str, obj);
4248 break;
4249 case T_PartitionElem:
4250 _outPartitionElem(str, obj);
4251 break;
4252 case T_PartitionSpec:
4253 _outPartitionSpec(str, obj);
4254 break;
4255 case T_PartitionBoundSpec:
4256 _outPartitionBoundSpec(str, obj);
4257 break;
4258 case T_PartitionRangeDatum:
4259 _outPartitionRangeDatum(str, obj);
4260 break;
4261
4262 default:
4263
4264 /*
4265 * This should be an ERROR, but it's too useful to be able to
4266 * dump structures that outNode only understands part of.
4267 */
4268 elog(WARNING, "could not dump unrecognized node type: %d",
4269 (int) nodeTag(obj));
4270 break;
4271 }
4272 appendStringInfoChar(str, '}');
4273 }
4274 }
4275
4276 /*
4277 * nodeToString -
4278 * returns the ascii representation of the Node as a palloc'd string
4279 */
4280 char *
nodeToString(const void * obj)4281 nodeToString(const void *obj)
4282 {
4283 StringInfoData str;
4284
4285 /* see stringinfo.h for an explanation of this maneuver */
4286 initStringInfo(&str);
4287 outNode(&str, obj);
4288 return str.data;
4289 }
4290
4291 /*
4292 * bmsToString -
4293 * returns the ascii representation of the Bitmapset as a palloc'd string
4294 */
4295 char *
bmsToString(const Bitmapset * bms)4296 bmsToString(const Bitmapset *bms)
4297 {
4298 StringInfoData str;
4299
4300 /* see stringinfo.h for an explanation of this maneuver */
4301 initStringInfo(&str);
4302 outBitmapset(&str, bms);
4303 return str.data;
4304 }
4305