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