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