1 /*------------------------------------------------------------------------- 2 * 3 * readfuncs.c 4 * Reader 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/readfuncs.c 12 * 13 * NOTES 14 * Path nodes do not have any readfuncs support, because we never 15 * have occasion to read them in. (There was once code here that 16 * claimed to read them, but it was broken as well as unused.) We 17 * never read executor state trees, either. 18 * 19 * Parse location fields are written out by outfuncs.c, but only for 20 * debugging use. When reading a location field, we normally discard 21 * the stored value and set the location field to -1 (ie, "unknown"). 22 * This is because nodes coming from a stored rule should not be thought 23 * to have a known location in the current query's text. 24 * However, if restore_location_fields is true, we do restore location 25 * fields from the string. This is currently intended only for use by the 26 * WRITE_READ_PARSE_PLAN_TREES test code, which doesn't want to cause 27 * any change in the node contents. 28 * 29 *------------------------------------------------------------------------- 30 */ 31 #include "postgres.h" 32 33 #include <math.h> 34 35 #include "fmgr.h" 36 #include "miscadmin.h" 37 #include "nodes/extensible.h" 38 #include "nodes/parsenodes.h" 39 #include "nodes/plannodes.h" 40 #include "nodes/readfuncs.h" 41 #include "utils/builtins.h" 42 43 44 /* 45 * Macros to simplify reading of different kinds of fields. Use these 46 * wherever possible to reduce the chance for silly typos. Note that these 47 * hard-wire conventions about the names of the local variables in a Read 48 * routine. 49 */ 50 51 /* Macros for declaring appropriate local variables */ 52 53 /* A few guys need only local_node */ 54 #define READ_LOCALS_NO_FIELDS(nodeTypeName) \ 55 nodeTypeName *local_node = makeNode(nodeTypeName) 56 57 /* And a few guys need only the pg_strtok support fields */ 58 #define READ_TEMP_LOCALS() \ 59 const char *token; \ 60 int length 61 62 /* ... but most need both */ 63 #define READ_LOCALS(nodeTypeName) \ 64 READ_LOCALS_NO_FIELDS(nodeTypeName); \ 65 READ_TEMP_LOCALS() 66 67 /* Read an integer field (anything written as ":fldname %d") */ 68 #define READ_INT_FIELD(fldname) \ 69 token = pg_strtok(&length); /* skip :fldname */ \ 70 token = pg_strtok(&length); /* get field value */ \ 71 local_node->fldname = atoi(token) 72 73 /* Read an unsigned integer field (anything written as ":fldname %u") */ 74 #define READ_UINT_FIELD(fldname) \ 75 token = pg_strtok(&length); /* skip :fldname */ \ 76 token = pg_strtok(&length); /* get field value */ \ 77 local_node->fldname = atoui(token) 78 79 /* Read an unsigned integer field (anything written using UINT64_FORMAT) */ 80 #define READ_UINT64_FIELD(fldname) \ 81 token = pg_strtok(&length); /* skip :fldname */ \ 82 token = pg_strtok(&length); /* get field value */ \ 83 local_node->fldname = pg_strtouint64(token, NULL, 10) 84 85 /* Read a long integer field (anything written as ":fldname %ld") */ 86 #define READ_LONG_FIELD(fldname) \ 87 token = pg_strtok(&length); /* skip :fldname */ \ 88 token = pg_strtok(&length); /* get field value */ \ 89 local_node->fldname = atol(token) 90 91 /* Read an OID field (don't hard-wire assumption that OID is same as uint) */ 92 #define READ_OID_FIELD(fldname) \ 93 token = pg_strtok(&length); /* skip :fldname */ \ 94 token = pg_strtok(&length); /* get field value */ \ 95 local_node->fldname = atooid(token) 96 97 /* Read a char field (ie, one ascii character) */ 98 #define READ_CHAR_FIELD(fldname) \ 99 token = pg_strtok(&length); /* skip :fldname */ \ 100 token = pg_strtok(&length); /* get field value */ \ 101 /* avoid overhead of calling debackslash() for one char */ \ 102 local_node->fldname = (length == 0) ? '\0' : (token[0] == '\\' ? token[1] : token[0]) 103 104 /* Read an enumerated-type field that was written as an integer code */ 105 #define READ_ENUM_FIELD(fldname, enumtype) \ 106 token = pg_strtok(&length); /* skip :fldname */ \ 107 token = pg_strtok(&length); /* get field value */ \ 108 local_node->fldname = (enumtype) atoi(token) 109 110 /* Read a float field */ 111 #define READ_FLOAT_FIELD(fldname) \ 112 token = pg_strtok(&length); /* skip :fldname */ \ 113 token = pg_strtok(&length); /* get field value */ \ 114 local_node->fldname = atof(token) 115 116 /* Read a boolean field */ 117 #define READ_BOOL_FIELD(fldname) \ 118 token = pg_strtok(&length); /* skip :fldname */ \ 119 token = pg_strtok(&length); /* get field value */ \ 120 local_node->fldname = strtobool(token) 121 122 /* Read a character-string field */ 123 #define READ_STRING_FIELD(fldname) \ 124 token = pg_strtok(&length); /* skip :fldname */ \ 125 token = pg_strtok(&length); /* get field value */ \ 126 local_node->fldname = nullable_string(token, length) 127 128 /* Read a parse location field (and possibly throw away the value) */ 129 #ifdef WRITE_READ_PARSE_PLAN_TREES 130 #define READ_LOCATION_FIELD(fldname) \ 131 token = pg_strtok(&length); /* skip :fldname */ \ 132 token = pg_strtok(&length); /* get field value */ \ 133 local_node->fldname = restore_location_fields ? atoi(token) : -1 134 #else 135 #define READ_LOCATION_FIELD(fldname) \ 136 token = pg_strtok(&length); /* skip :fldname */ \ 137 token = pg_strtok(&length); /* get field value */ \ 138 (void) token; /* in case not used elsewhere */ \ 139 local_node->fldname = -1 /* set field to "unknown" */ 140 #endif 141 142 /* Read a Node field */ 143 #define READ_NODE_FIELD(fldname) \ 144 token = pg_strtok(&length); /* skip :fldname */ \ 145 (void) token; /* in case not used elsewhere */ \ 146 local_node->fldname = nodeRead(NULL, 0) 147 148 /* Read a bitmapset field */ 149 #define READ_BITMAPSET_FIELD(fldname) \ 150 token = pg_strtok(&length); /* skip :fldname */ \ 151 (void) token; /* in case not used elsewhere */ \ 152 local_node->fldname = _readBitmapset() 153 154 /* Read an attribute number array */ 155 #define READ_ATTRNUMBER_ARRAY(fldname, len) \ 156 token = pg_strtok(&length); /* skip :fldname */ \ 157 local_node->fldname = readAttrNumberCols(len) 158 159 /* Read an oid array */ 160 #define READ_OID_ARRAY(fldname, len) \ 161 token = pg_strtok(&length); /* skip :fldname */ \ 162 local_node->fldname = readOidCols(len) 163 164 /* Read an int array */ 165 #define READ_INT_ARRAY(fldname, len) \ 166 token = pg_strtok(&length); /* skip :fldname */ \ 167 local_node->fldname = readIntCols(len) 168 169 /* Read a bool array */ 170 #define READ_BOOL_ARRAY(fldname, len) \ 171 token = pg_strtok(&length); /* skip :fldname */ \ 172 local_node->fldname = readBoolCols(len) 173 174 /* Routine exit */ 175 #define READ_DONE() \ 176 return local_node 177 178 179 /* 180 * NOTE: use atoi() to read values written with %d, or atoui() to read 181 * values written with %u in outfuncs.c. An exception is OID values, 182 * for which use atooid(). (As of 7.1, outfuncs.c writes OIDs as %u, 183 * but this will probably change in the future.) 184 */ 185 #define atoui(x) ((unsigned int) strtoul((x), NULL, 10)) 186 187 #define strtobool(x) ((*(x) == 't') ? true : false) 188 189 #define nullable_string(token,length) \ 190 ((length) == 0 ? NULL : debackslash(token, length)) 191 192 193 /* 194 * _readBitmapset 195 */ 196 static Bitmapset * 197 _readBitmapset(void) 198 { 199 Bitmapset *result = NULL; 200 201 READ_TEMP_LOCALS(); 202 203 token = pg_strtok(&length); 204 if (token == NULL) 205 elog(ERROR, "incomplete Bitmapset structure"); 206 if (length != 1 || token[0] != '(') 207 elog(ERROR, "unrecognized token: \"%.*s\"", length, token); 208 209 token = pg_strtok(&length); 210 if (token == NULL) 211 elog(ERROR, "incomplete Bitmapset structure"); 212 if (length != 1 || token[0] != 'b') 213 elog(ERROR, "unrecognized token: \"%.*s\"", length, token); 214 215 for (;;) 216 { 217 int val; 218 char *endptr; 219 220 token = pg_strtok(&length); 221 if (token == NULL) 222 elog(ERROR, "unterminated Bitmapset structure"); 223 if (length == 1 && token[0] == ')') 224 break; 225 val = (int) strtol(token, &endptr, 10); 226 if (endptr != token + length) 227 elog(ERROR, "unrecognized integer: \"%.*s\"", length, token); 228 result = bms_add_member(result, val); 229 } 230 231 return result; 232 } 233 234 /* 235 * for use by extensions which define extensible nodes 236 */ 237 Bitmapset * 238 readBitmapset(void) 239 { 240 return _readBitmapset(); 241 } 242 243 /* 244 * _readQuery 245 */ 246 static Query * 247 _readQuery(void) 248 { 249 READ_LOCALS(Query); 250 251 READ_ENUM_FIELD(commandType, CmdType); 252 READ_ENUM_FIELD(querySource, QuerySource); 253 local_node->queryId = UINT64CONST(0); /* not saved in output format */ 254 READ_BOOL_FIELD(canSetTag); 255 READ_NODE_FIELD(utilityStmt); 256 READ_INT_FIELD(resultRelation); 257 READ_BOOL_FIELD(hasAggs); 258 READ_BOOL_FIELD(hasWindowFuncs); 259 READ_BOOL_FIELD(hasTargetSRFs); 260 READ_BOOL_FIELD(hasSubLinks); 261 READ_BOOL_FIELD(hasDistinctOn); 262 READ_BOOL_FIELD(hasRecursive); 263 READ_BOOL_FIELD(hasModifyingCTE); 264 READ_BOOL_FIELD(hasForUpdate); 265 READ_BOOL_FIELD(hasRowSecurity); 266 READ_NODE_FIELD(cteList); 267 READ_NODE_FIELD(rtable); 268 READ_NODE_FIELD(jointree); 269 READ_NODE_FIELD(targetList); 270 READ_ENUM_FIELD(override, OverridingKind); 271 READ_NODE_FIELD(onConflict); 272 READ_NODE_FIELD(returningList); 273 READ_NODE_FIELD(groupClause); 274 READ_NODE_FIELD(groupingSets); 275 READ_NODE_FIELD(havingQual); 276 READ_NODE_FIELD(windowClause); 277 READ_NODE_FIELD(distinctClause); 278 READ_NODE_FIELD(sortClause); 279 READ_NODE_FIELD(limitOffset); 280 READ_NODE_FIELD(limitCount); 281 READ_ENUM_FIELD(limitOption, LimitOption); 282 READ_NODE_FIELD(rowMarks); 283 READ_NODE_FIELD(setOperations); 284 READ_NODE_FIELD(constraintDeps); 285 READ_NODE_FIELD(withCheckOptions); 286 READ_LOCATION_FIELD(stmt_location); 287 READ_INT_FIELD(stmt_len); 288 289 READ_DONE(); 290 } 291 292 /* 293 * _readNotifyStmt 294 */ 295 static NotifyStmt * 296 _readNotifyStmt(void) 297 { 298 READ_LOCALS(NotifyStmt); 299 300 READ_STRING_FIELD(conditionname); 301 READ_STRING_FIELD(payload); 302 303 READ_DONE(); 304 } 305 306 /* 307 * _readDeclareCursorStmt 308 */ 309 static DeclareCursorStmt * 310 _readDeclareCursorStmt(void) 311 { 312 READ_LOCALS(DeclareCursorStmt); 313 314 READ_STRING_FIELD(portalname); 315 READ_INT_FIELD(options); 316 READ_NODE_FIELD(query); 317 318 READ_DONE(); 319 } 320 321 /* 322 * _readWithCheckOption 323 */ 324 static WithCheckOption * 325 _readWithCheckOption(void) 326 { 327 READ_LOCALS(WithCheckOption); 328 329 READ_ENUM_FIELD(kind, WCOKind); 330 READ_STRING_FIELD(relname); 331 READ_STRING_FIELD(polname); 332 READ_NODE_FIELD(qual); 333 READ_BOOL_FIELD(cascaded); 334 335 READ_DONE(); 336 } 337 338 /* 339 * _readSortGroupClause 340 */ 341 static SortGroupClause * 342 _readSortGroupClause(void) 343 { 344 READ_LOCALS(SortGroupClause); 345 346 READ_UINT_FIELD(tleSortGroupRef); 347 READ_OID_FIELD(eqop); 348 READ_OID_FIELD(sortop); 349 READ_BOOL_FIELD(nulls_first); 350 READ_BOOL_FIELD(hashable); 351 352 READ_DONE(); 353 } 354 355 /* 356 * _readGroupingSet 357 */ 358 static GroupingSet * 359 _readGroupingSet(void) 360 { 361 READ_LOCALS(GroupingSet); 362 363 READ_ENUM_FIELD(kind, GroupingSetKind); 364 READ_NODE_FIELD(content); 365 READ_LOCATION_FIELD(location); 366 367 READ_DONE(); 368 } 369 370 /* 371 * _readWindowClause 372 */ 373 static WindowClause * 374 _readWindowClause(void) 375 { 376 READ_LOCALS(WindowClause); 377 378 READ_STRING_FIELD(name); 379 READ_STRING_FIELD(refname); 380 READ_NODE_FIELD(partitionClause); 381 READ_NODE_FIELD(orderClause); 382 READ_INT_FIELD(frameOptions); 383 READ_NODE_FIELD(startOffset); 384 READ_NODE_FIELD(endOffset); 385 READ_OID_FIELD(startInRangeFunc); 386 READ_OID_FIELD(endInRangeFunc); 387 READ_OID_FIELD(inRangeColl); 388 READ_BOOL_FIELD(inRangeAsc); 389 READ_BOOL_FIELD(inRangeNullsFirst); 390 READ_UINT_FIELD(winref); 391 READ_BOOL_FIELD(copiedOrder); 392 393 READ_DONE(); 394 } 395 396 /* 397 * _readRowMarkClause 398 */ 399 static RowMarkClause * 400 _readRowMarkClause(void) 401 { 402 READ_LOCALS(RowMarkClause); 403 404 READ_UINT_FIELD(rti); 405 READ_ENUM_FIELD(strength, LockClauseStrength); 406 READ_ENUM_FIELD(waitPolicy, LockWaitPolicy); 407 READ_BOOL_FIELD(pushedDown); 408 409 READ_DONE(); 410 } 411 412 /* 413 * _readCommonTableExpr 414 */ 415 static CommonTableExpr * 416 _readCommonTableExpr(void) 417 { 418 READ_LOCALS(CommonTableExpr); 419 420 READ_STRING_FIELD(ctename); 421 READ_NODE_FIELD(aliascolnames); 422 READ_ENUM_FIELD(ctematerialized, CTEMaterialize); 423 READ_NODE_FIELD(ctequery); 424 READ_LOCATION_FIELD(location); 425 READ_BOOL_FIELD(cterecursive); 426 READ_INT_FIELD(cterefcount); 427 READ_NODE_FIELD(ctecolnames); 428 READ_NODE_FIELD(ctecoltypes); 429 READ_NODE_FIELD(ctecoltypmods); 430 READ_NODE_FIELD(ctecolcollations); 431 432 READ_DONE(); 433 } 434 435 /* 436 * _readSetOperationStmt 437 */ 438 static SetOperationStmt * 439 _readSetOperationStmt(void) 440 { 441 READ_LOCALS(SetOperationStmt); 442 443 READ_ENUM_FIELD(op, SetOperation); 444 READ_BOOL_FIELD(all); 445 READ_NODE_FIELD(larg); 446 READ_NODE_FIELD(rarg); 447 READ_NODE_FIELD(colTypes); 448 READ_NODE_FIELD(colTypmods); 449 READ_NODE_FIELD(colCollations); 450 READ_NODE_FIELD(groupClauses); 451 452 READ_DONE(); 453 } 454 455 456 /* 457 * Stuff from primnodes.h. 458 */ 459 460 static Alias * 461 _readAlias(void) 462 { 463 READ_LOCALS(Alias); 464 465 READ_STRING_FIELD(aliasname); 466 READ_NODE_FIELD(colnames); 467 468 READ_DONE(); 469 } 470 471 static RangeVar * 472 _readRangeVar(void) 473 { 474 READ_LOCALS(RangeVar); 475 476 local_node->catalogname = NULL; /* not currently saved in output format */ 477 478 READ_STRING_FIELD(schemaname); 479 READ_STRING_FIELD(relname); 480 READ_BOOL_FIELD(inh); 481 READ_CHAR_FIELD(relpersistence); 482 READ_NODE_FIELD(alias); 483 READ_LOCATION_FIELD(location); 484 485 READ_DONE(); 486 } 487 488 /* 489 * _readTableFunc 490 */ 491 static TableFunc * 492 _readTableFunc(void) 493 { 494 READ_LOCALS(TableFunc); 495 496 READ_NODE_FIELD(ns_uris); 497 READ_NODE_FIELD(ns_names); 498 READ_NODE_FIELD(docexpr); 499 READ_NODE_FIELD(rowexpr); 500 READ_NODE_FIELD(colnames); 501 READ_NODE_FIELD(coltypes); 502 READ_NODE_FIELD(coltypmods); 503 READ_NODE_FIELD(colcollations); 504 READ_NODE_FIELD(colexprs); 505 READ_NODE_FIELD(coldefexprs); 506 READ_BITMAPSET_FIELD(notnulls); 507 READ_INT_FIELD(ordinalitycol); 508 READ_LOCATION_FIELD(location); 509 510 READ_DONE(); 511 } 512 513 static IntoClause * 514 _readIntoClause(void) 515 { 516 READ_LOCALS(IntoClause); 517 518 READ_NODE_FIELD(rel); 519 READ_NODE_FIELD(colNames); 520 READ_STRING_FIELD(accessMethod); 521 READ_NODE_FIELD(options); 522 READ_ENUM_FIELD(onCommit, OnCommitAction); 523 READ_STRING_FIELD(tableSpaceName); 524 READ_NODE_FIELD(viewQuery); 525 READ_BOOL_FIELD(skipData); 526 527 READ_DONE(); 528 } 529 530 /* 531 * _readVar 532 */ 533 static Var * 534 _readVar(void) 535 { 536 READ_LOCALS(Var); 537 538 READ_UINT_FIELD(varno); 539 READ_INT_FIELD(varattno); 540 READ_OID_FIELD(vartype); 541 READ_INT_FIELD(vartypmod); 542 READ_OID_FIELD(varcollid); 543 READ_UINT_FIELD(varlevelsup); 544 READ_UINT_FIELD(varnosyn); 545 READ_INT_FIELD(varattnosyn); 546 READ_LOCATION_FIELD(location); 547 548 READ_DONE(); 549 } 550 551 /* 552 * _readConst 553 */ 554 static Const * 555 _readConst(void) 556 { 557 READ_LOCALS(Const); 558 559 READ_OID_FIELD(consttype); 560 READ_INT_FIELD(consttypmod); 561 READ_OID_FIELD(constcollid); 562 READ_INT_FIELD(constlen); 563 READ_BOOL_FIELD(constbyval); 564 READ_BOOL_FIELD(constisnull); 565 READ_LOCATION_FIELD(location); 566 567 token = pg_strtok(&length); /* skip :constvalue */ 568 if (local_node->constisnull) 569 token = pg_strtok(&length); /* skip "<>" */ 570 else 571 local_node->constvalue = readDatum(local_node->constbyval); 572 573 READ_DONE(); 574 } 575 576 /* 577 * _readParam 578 */ 579 static Param * 580 _readParam(void) 581 { 582 READ_LOCALS(Param); 583 584 READ_ENUM_FIELD(paramkind, ParamKind); 585 READ_INT_FIELD(paramid); 586 READ_OID_FIELD(paramtype); 587 READ_INT_FIELD(paramtypmod); 588 READ_OID_FIELD(paramcollid); 589 READ_LOCATION_FIELD(location); 590 591 READ_DONE(); 592 } 593 594 /* 595 * _readAggref 596 */ 597 static Aggref * 598 _readAggref(void) 599 { 600 READ_LOCALS(Aggref); 601 602 READ_OID_FIELD(aggfnoid); 603 READ_OID_FIELD(aggtype); 604 READ_OID_FIELD(aggcollid); 605 READ_OID_FIELD(inputcollid); 606 READ_OID_FIELD(aggtranstype); 607 READ_NODE_FIELD(aggargtypes); 608 READ_NODE_FIELD(aggdirectargs); 609 READ_NODE_FIELD(args); 610 READ_NODE_FIELD(aggorder); 611 READ_NODE_FIELD(aggdistinct); 612 READ_NODE_FIELD(aggfilter); 613 READ_BOOL_FIELD(aggstar); 614 READ_BOOL_FIELD(aggvariadic); 615 READ_CHAR_FIELD(aggkind); 616 READ_UINT_FIELD(agglevelsup); 617 READ_ENUM_FIELD(aggsplit, AggSplit); 618 READ_LOCATION_FIELD(location); 619 620 READ_DONE(); 621 } 622 623 /* 624 * _readGroupingFunc 625 */ 626 static GroupingFunc * 627 _readGroupingFunc(void) 628 { 629 READ_LOCALS(GroupingFunc); 630 631 READ_NODE_FIELD(args); 632 READ_NODE_FIELD(refs); 633 READ_NODE_FIELD(cols); 634 READ_UINT_FIELD(agglevelsup); 635 READ_LOCATION_FIELD(location); 636 637 READ_DONE(); 638 } 639 640 /* 641 * _readWindowFunc 642 */ 643 static WindowFunc * 644 _readWindowFunc(void) 645 { 646 READ_LOCALS(WindowFunc); 647 648 READ_OID_FIELD(winfnoid); 649 READ_OID_FIELD(wintype); 650 READ_OID_FIELD(wincollid); 651 READ_OID_FIELD(inputcollid); 652 READ_NODE_FIELD(args); 653 READ_NODE_FIELD(aggfilter); 654 READ_UINT_FIELD(winref); 655 READ_BOOL_FIELD(winstar); 656 READ_BOOL_FIELD(winagg); 657 READ_LOCATION_FIELD(location); 658 659 READ_DONE(); 660 } 661 662 /* 663 * _readSubscriptingRef 664 */ 665 static SubscriptingRef * 666 _readSubscriptingRef(void) 667 { 668 READ_LOCALS(SubscriptingRef); 669 670 READ_OID_FIELD(refcontainertype); 671 READ_OID_FIELD(refelemtype); 672 READ_INT_FIELD(reftypmod); 673 READ_OID_FIELD(refcollid); 674 READ_NODE_FIELD(refupperindexpr); 675 READ_NODE_FIELD(reflowerindexpr); 676 READ_NODE_FIELD(refexpr); 677 READ_NODE_FIELD(refassgnexpr); 678 679 READ_DONE(); 680 } 681 682 /* 683 * _readFuncExpr 684 */ 685 static FuncExpr * 686 _readFuncExpr(void) 687 { 688 READ_LOCALS(FuncExpr); 689 690 READ_OID_FIELD(funcid); 691 READ_OID_FIELD(funcresulttype); 692 READ_BOOL_FIELD(funcretset); 693 READ_BOOL_FIELD(funcvariadic); 694 READ_ENUM_FIELD(funcformat, CoercionForm); 695 READ_OID_FIELD(funccollid); 696 READ_OID_FIELD(inputcollid); 697 READ_NODE_FIELD(args); 698 READ_LOCATION_FIELD(location); 699 700 READ_DONE(); 701 } 702 703 /* 704 * _readNamedArgExpr 705 */ 706 static NamedArgExpr * 707 _readNamedArgExpr(void) 708 { 709 READ_LOCALS(NamedArgExpr); 710 711 READ_NODE_FIELD(arg); 712 READ_STRING_FIELD(name); 713 READ_INT_FIELD(argnumber); 714 READ_LOCATION_FIELD(location); 715 716 READ_DONE(); 717 } 718 719 /* 720 * _readOpExpr 721 */ 722 static OpExpr * 723 _readOpExpr(void) 724 { 725 READ_LOCALS(OpExpr); 726 727 READ_OID_FIELD(opno); 728 READ_OID_FIELD(opfuncid); 729 READ_OID_FIELD(opresulttype); 730 READ_BOOL_FIELD(opretset); 731 READ_OID_FIELD(opcollid); 732 READ_OID_FIELD(inputcollid); 733 READ_NODE_FIELD(args); 734 READ_LOCATION_FIELD(location); 735 736 READ_DONE(); 737 } 738 739 /* 740 * _readDistinctExpr 741 */ 742 static DistinctExpr * 743 _readDistinctExpr(void) 744 { 745 READ_LOCALS(DistinctExpr); 746 747 READ_OID_FIELD(opno); 748 READ_OID_FIELD(opfuncid); 749 READ_OID_FIELD(opresulttype); 750 READ_BOOL_FIELD(opretset); 751 READ_OID_FIELD(opcollid); 752 READ_OID_FIELD(inputcollid); 753 READ_NODE_FIELD(args); 754 READ_LOCATION_FIELD(location); 755 756 READ_DONE(); 757 } 758 759 /* 760 * _readNullIfExpr 761 */ 762 static NullIfExpr * 763 _readNullIfExpr(void) 764 { 765 READ_LOCALS(NullIfExpr); 766 767 READ_OID_FIELD(opno); 768 READ_OID_FIELD(opfuncid); 769 READ_OID_FIELD(opresulttype); 770 READ_BOOL_FIELD(opretset); 771 READ_OID_FIELD(opcollid); 772 READ_OID_FIELD(inputcollid); 773 READ_NODE_FIELD(args); 774 READ_LOCATION_FIELD(location); 775 776 READ_DONE(); 777 } 778 779 /* 780 * _readScalarArrayOpExpr 781 */ 782 static ScalarArrayOpExpr * 783 _readScalarArrayOpExpr(void) 784 { 785 READ_LOCALS(ScalarArrayOpExpr); 786 787 READ_OID_FIELD(opno); 788 READ_OID_FIELD(opfuncid); 789 READ_BOOL_FIELD(useOr); 790 READ_OID_FIELD(inputcollid); 791 READ_NODE_FIELD(args); 792 READ_LOCATION_FIELD(location); 793 794 READ_DONE(); 795 } 796 797 /* 798 * _readBoolExpr 799 */ 800 static BoolExpr * 801 _readBoolExpr(void) 802 { 803 READ_LOCALS(BoolExpr); 804 805 /* do-it-yourself enum representation */ 806 token = pg_strtok(&length); /* skip :boolop */ 807 token = pg_strtok(&length); /* get field value */ 808 if (strncmp(token, "and", 3) == 0) 809 local_node->boolop = AND_EXPR; 810 else if (strncmp(token, "or", 2) == 0) 811 local_node->boolop = OR_EXPR; 812 else if (strncmp(token, "not", 3) == 0) 813 local_node->boolop = NOT_EXPR; 814 else 815 elog(ERROR, "unrecognized boolop \"%.*s\"", length, token); 816 817 READ_NODE_FIELD(args); 818 READ_LOCATION_FIELD(location); 819 820 READ_DONE(); 821 } 822 823 /* 824 * _readSubLink 825 */ 826 static SubLink * 827 _readSubLink(void) 828 { 829 READ_LOCALS(SubLink); 830 831 READ_ENUM_FIELD(subLinkType, SubLinkType); 832 READ_INT_FIELD(subLinkId); 833 READ_NODE_FIELD(testexpr); 834 READ_NODE_FIELD(operName); 835 READ_NODE_FIELD(subselect); 836 READ_LOCATION_FIELD(location); 837 838 READ_DONE(); 839 } 840 841 /* 842 * _readSubPlan is not needed since it doesn't appear in stored rules. 843 */ 844 845 /* 846 * _readFieldSelect 847 */ 848 static FieldSelect * 849 _readFieldSelect(void) 850 { 851 READ_LOCALS(FieldSelect); 852 853 READ_NODE_FIELD(arg); 854 READ_INT_FIELD(fieldnum); 855 READ_OID_FIELD(resulttype); 856 READ_INT_FIELD(resulttypmod); 857 READ_OID_FIELD(resultcollid); 858 859 READ_DONE(); 860 } 861 862 /* 863 * _readFieldStore 864 */ 865 static FieldStore * 866 _readFieldStore(void) 867 { 868 READ_LOCALS(FieldStore); 869 870 READ_NODE_FIELD(arg); 871 READ_NODE_FIELD(newvals); 872 READ_NODE_FIELD(fieldnums); 873 READ_OID_FIELD(resulttype); 874 875 READ_DONE(); 876 } 877 878 /* 879 * _readRelabelType 880 */ 881 static RelabelType * 882 _readRelabelType(void) 883 { 884 READ_LOCALS(RelabelType); 885 886 READ_NODE_FIELD(arg); 887 READ_OID_FIELD(resulttype); 888 READ_INT_FIELD(resulttypmod); 889 READ_OID_FIELD(resultcollid); 890 READ_ENUM_FIELD(relabelformat, CoercionForm); 891 READ_LOCATION_FIELD(location); 892 893 READ_DONE(); 894 } 895 896 /* 897 * _readCoerceViaIO 898 */ 899 static CoerceViaIO * 900 _readCoerceViaIO(void) 901 { 902 READ_LOCALS(CoerceViaIO); 903 904 READ_NODE_FIELD(arg); 905 READ_OID_FIELD(resulttype); 906 READ_OID_FIELD(resultcollid); 907 READ_ENUM_FIELD(coerceformat, CoercionForm); 908 READ_LOCATION_FIELD(location); 909 910 READ_DONE(); 911 } 912 913 /* 914 * _readArrayCoerceExpr 915 */ 916 static ArrayCoerceExpr * 917 _readArrayCoerceExpr(void) 918 { 919 READ_LOCALS(ArrayCoerceExpr); 920 921 READ_NODE_FIELD(arg); 922 READ_NODE_FIELD(elemexpr); 923 READ_OID_FIELD(resulttype); 924 READ_INT_FIELD(resulttypmod); 925 READ_OID_FIELD(resultcollid); 926 READ_ENUM_FIELD(coerceformat, CoercionForm); 927 READ_LOCATION_FIELD(location); 928 929 READ_DONE(); 930 } 931 932 /* 933 * _readConvertRowtypeExpr 934 */ 935 static ConvertRowtypeExpr * 936 _readConvertRowtypeExpr(void) 937 { 938 READ_LOCALS(ConvertRowtypeExpr); 939 940 READ_NODE_FIELD(arg); 941 READ_OID_FIELD(resulttype); 942 READ_ENUM_FIELD(convertformat, CoercionForm); 943 READ_LOCATION_FIELD(location); 944 945 READ_DONE(); 946 } 947 948 /* 949 * _readCollateExpr 950 */ 951 static CollateExpr * 952 _readCollateExpr(void) 953 { 954 READ_LOCALS(CollateExpr); 955 956 READ_NODE_FIELD(arg); 957 READ_OID_FIELD(collOid); 958 READ_LOCATION_FIELD(location); 959 960 READ_DONE(); 961 } 962 963 /* 964 * _readCaseExpr 965 */ 966 static CaseExpr * 967 _readCaseExpr(void) 968 { 969 READ_LOCALS(CaseExpr); 970 971 READ_OID_FIELD(casetype); 972 READ_OID_FIELD(casecollid); 973 READ_NODE_FIELD(arg); 974 READ_NODE_FIELD(args); 975 READ_NODE_FIELD(defresult); 976 READ_LOCATION_FIELD(location); 977 978 READ_DONE(); 979 } 980 981 /* 982 * _readCaseWhen 983 */ 984 static CaseWhen * 985 _readCaseWhen(void) 986 { 987 READ_LOCALS(CaseWhen); 988 989 READ_NODE_FIELD(expr); 990 READ_NODE_FIELD(result); 991 READ_LOCATION_FIELD(location); 992 993 READ_DONE(); 994 } 995 996 /* 997 * _readCaseTestExpr 998 */ 999 static CaseTestExpr * 1000 _readCaseTestExpr(void) 1001 { 1002 READ_LOCALS(CaseTestExpr); 1003 1004 READ_OID_FIELD(typeId); 1005 READ_INT_FIELD(typeMod); 1006 READ_OID_FIELD(collation); 1007 1008 READ_DONE(); 1009 } 1010 1011 /* 1012 * _readArrayExpr 1013 */ 1014 static ArrayExpr * 1015 _readArrayExpr(void) 1016 { 1017 READ_LOCALS(ArrayExpr); 1018 1019 READ_OID_FIELD(array_typeid); 1020 READ_OID_FIELD(array_collid); 1021 READ_OID_FIELD(element_typeid); 1022 READ_NODE_FIELD(elements); 1023 READ_BOOL_FIELD(multidims); 1024 READ_LOCATION_FIELD(location); 1025 1026 READ_DONE(); 1027 } 1028 1029 /* 1030 * _readRowExpr 1031 */ 1032 static RowExpr * 1033 _readRowExpr(void) 1034 { 1035 READ_LOCALS(RowExpr); 1036 1037 READ_NODE_FIELD(args); 1038 READ_OID_FIELD(row_typeid); 1039 READ_ENUM_FIELD(row_format, CoercionForm); 1040 READ_NODE_FIELD(colnames); 1041 READ_LOCATION_FIELD(location); 1042 1043 READ_DONE(); 1044 } 1045 1046 /* 1047 * _readRowCompareExpr 1048 */ 1049 static RowCompareExpr * 1050 _readRowCompareExpr(void) 1051 { 1052 READ_LOCALS(RowCompareExpr); 1053 1054 READ_ENUM_FIELD(rctype, RowCompareType); 1055 READ_NODE_FIELD(opnos); 1056 READ_NODE_FIELD(opfamilies); 1057 READ_NODE_FIELD(inputcollids); 1058 READ_NODE_FIELD(largs); 1059 READ_NODE_FIELD(rargs); 1060 1061 READ_DONE(); 1062 } 1063 1064 /* 1065 * _readCoalesceExpr 1066 */ 1067 static CoalesceExpr * 1068 _readCoalesceExpr(void) 1069 { 1070 READ_LOCALS(CoalesceExpr); 1071 1072 READ_OID_FIELD(coalescetype); 1073 READ_OID_FIELD(coalescecollid); 1074 READ_NODE_FIELD(args); 1075 READ_LOCATION_FIELD(location); 1076 1077 READ_DONE(); 1078 } 1079 1080 /* 1081 * _readMinMaxExpr 1082 */ 1083 static MinMaxExpr * 1084 _readMinMaxExpr(void) 1085 { 1086 READ_LOCALS(MinMaxExpr); 1087 1088 READ_OID_FIELD(minmaxtype); 1089 READ_OID_FIELD(minmaxcollid); 1090 READ_OID_FIELD(inputcollid); 1091 READ_ENUM_FIELD(op, MinMaxOp); 1092 READ_NODE_FIELD(args); 1093 READ_LOCATION_FIELD(location); 1094 1095 READ_DONE(); 1096 } 1097 1098 /* 1099 * _readSQLValueFunction 1100 */ 1101 static SQLValueFunction * 1102 _readSQLValueFunction(void) 1103 { 1104 READ_LOCALS(SQLValueFunction); 1105 1106 READ_ENUM_FIELD(op, SQLValueFunctionOp); 1107 READ_OID_FIELD(type); 1108 READ_INT_FIELD(typmod); 1109 READ_LOCATION_FIELD(location); 1110 1111 READ_DONE(); 1112 } 1113 1114 /* 1115 * _readXmlExpr 1116 */ 1117 static XmlExpr * 1118 _readXmlExpr(void) 1119 { 1120 READ_LOCALS(XmlExpr); 1121 1122 READ_ENUM_FIELD(op, XmlExprOp); 1123 READ_STRING_FIELD(name); 1124 READ_NODE_FIELD(named_args); 1125 READ_NODE_FIELD(arg_names); 1126 READ_NODE_FIELD(args); 1127 READ_ENUM_FIELD(xmloption, XmlOptionType); 1128 READ_OID_FIELD(type); 1129 READ_INT_FIELD(typmod); 1130 READ_LOCATION_FIELD(location); 1131 1132 READ_DONE(); 1133 } 1134 1135 /* 1136 * _readNullTest 1137 */ 1138 static NullTest * 1139 _readNullTest(void) 1140 { 1141 READ_LOCALS(NullTest); 1142 1143 READ_NODE_FIELD(arg); 1144 READ_ENUM_FIELD(nulltesttype, NullTestType); 1145 READ_BOOL_FIELD(argisrow); 1146 READ_LOCATION_FIELD(location); 1147 1148 READ_DONE(); 1149 } 1150 1151 /* 1152 * _readBooleanTest 1153 */ 1154 static BooleanTest * 1155 _readBooleanTest(void) 1156 { 1157 READ_LOCALS(BooleanTest); 1158 1159 READ_NODE_FIELD(arg); 1160 READ_ENUM_FIELD(booltesttype, BoolTestType); 1161 READ_LOCATION_FIELD(location); 1162 1163 READ_DONE(); 1164 } 1165 1166 /* 1167 * _readCoerceToDomain 1168 */ 1169 static CoerceToDomain * 1170 _readCoerceToDomain(void) 1171 { 1172 READ_LOCALS(CoerceToDomain); 1173 1174 READ_NODE_FIELD(arg); 1175 READ_OID_FIELD(resulttype); 1176 READ_INT_FIELD(resulttypmod); 1177 READ_OID_FIELD(resultcollid); 1178 READ_ENUM_FIELD(coercionformat, CoercionForm); 1179 READ_LOCATION_FIELD(location); 1180 1181 READ_DONE(); 1182 } 1183 1184 /* 1185 * _readCoerceToDomainValue 1186 */ 1187 static CoerceToDomainValue * 1188 _readCoerceToDomainValue(void) 1189 { 1190 READ_LOCALS(CoerceToDomainValue); 1191 1192 READ_OID_FIELD(typeId); 1193 READ_INT_FIELD(typeMod); 1194 READ_OID_FIELD(collation); 1195 READ_LOCATION_FIELD(location); 1196 1197 READ_DONE(); 1198 } 1199 1200 /* 1201 * _readSetToDefault 1202 */ 1203 static SetToDefault * 1204 _readSetToDefault(void) 1205 { 1206 READ_LOCALS(SetToDefault); 1207 1208 READ_OID_FIELD(typeId); 1209 READ_INT_FIELD(typeMod); 1210 READ_OID_FIELD(collation); 1211 READ_LOCATION_FIELD(location); 1212 1213 READ_DONE(); 1214 } 1215 1216 /* 1217 * _readCurrentOfExpr 1218 */ 1219 static CurrentOfExpr * 1220 _readCurrentOfExpr(void) 1221 { 1222 READ_LOCALS(CurrentOfExpr); 1223 1224 READ_UINT_FIELD(cvarno); 1225 READ_STRING_FIELD(cursor_name); 1226 READ_INT_FIELD(cursor_param); 1227 1228 READ_DONE(); 1229 } 1230 1231 /* 1232 * _readNextValueExpr 1233 */ 1234 static NextValueExpr * 1235 _readNextValueExpr(void) 1236 { 1237 READ_LOCALS(NextValueExpr); 1238 1239 READ_OID_FIELD(seqid); 1240 READ_OID_FIELD(typeId); 1241 1242 READ_DONE(); 1243 } 1244 1245 /* 1246 * _readInferenceElem 1247 */ 1248 static InferenceElem * 1249 _readInferenceElem(void) 1250 { 1251 READ_LOCALS(InferenceElem); 1252 1253 READ_NODE_FIELD(expr); 1254 READ_OID_FIELD(infercollid); 1255 READ_OID_FIELD(inferopclass); 1256 1257 READ_DONE(); 1258 } 1259 1260 /* 1261 * _readTargetEntry 1262 */ 1263 static TargetEntry * 1264 _readTargetEntry(void) 1265 { 1266 READ_LOCALS(TargetEntry); 1267 1268 READ_NODE_FIELD(expr); 1269 READ_INT_FIELD(resno); 1270 READ_STRING_FIELD(resname); 1271 READ_UINT_FIELD(ressortgroupref); 1272 READ_OID_FIELD(resorigtbl); 1273 READ_INT_FIELD(resorigcol); 1274 READ_BOOL_FIELD(resjunk); 1275 1276 READ_DONE(); 1277 } 1278 1279 /* 1280 * _readRangeTblRef 1281 */ 1282 static RangeTblRef * 1283 _readRangeTblRef(void) 1284 { 1285 READ_LOCALS(RangeTblRef); 1286 1287 READ_INT_FIELD(rtindex); 1288 1289 READ_DONE(); 1290 } 1291 1292 /* 1293 * _readJoinExpr 1294 */ 1295 static JoinExpr * 1296 _readJoinExpr(void) 1297 { 1298 READ_LOCALS(JoinExpr); 1299 1300 READ_ENUM_FIELD(jointype, JoinType); 1301 READ_BOOL_FIELD(isNatural); 1302 READ_NODE_FIELD(larg); 1303 READ_NODE_FIELD(rarg); 1304 READ_NODE_FIELD(usingClause); 1305 READ_NODE_FIELD(quals); 1306 READ_NODE_FIELD(alias); 1307 READ_INT_FIELD(rtindex); 1308 1309 READ_DONE(); 1310 } 1311 1312 /* 1313 * _readFromExpr 1314 */ 1315 static FromExpr * 1316 _readFromExpr(void) 1317 { 1318 READ_LOCALS(FromExpr); 1319 1320 READ_NODE_FIELD(fromlist); 1321 READ_NODE_FIELD(quals); 1322 1323 READ_DONE(); 1324 } 1325 1326 /* 1327 * _readOnConflictExpr 1328 */ 1329 static OnConflictExpr * 1330 _readOnConflictExpr(void) 1331 { 1332 READ_LOCALS(OnConflictExpr); 1333 1334 READ_ENUM_FIELD(action, OnConflictAction); 1335 READ_NODE_FIELD(arbiterElems); 1336 READ_NODE_FIELD(arbiterWhere); 1337 READ_OID_FIELD(constraint); 1338 READ_NODE_FIELD(onConflictSet); 1339 READ_NODE_FIELD(onConflictWhere); 1340 READ_INT_FIELD(exclRelIndex); 1341 READ_NODE_FIELD(exclRelTlist); 1342 1343 READ_DONE(); 1344 } 1345 1346 /* 1347 * Stuff from pathnodes.h. 1348 * 1349 * Mostly we don't need to read planner nodes back in again, but some 1350 * of these also end up in plan trees. 1351 */ 1352 1353 /* 1354 * _readAppendRelInfo 1355 */ 1356 static AppendRelInfo * 1357 _readAppendRelInfo(void) 1358 { 1359 READ_LOCALS(AppendRelInfo); 1360 1361 READ_UINT_FIELD(parent_relid); 1362 READ_UINT_FIELD(child_relid); 1363 READ_OID_FIELD(parent_reltype); 1364 READ_OID_FIELD(child_reltype); 1365 READ_NODE_FIELD(translated_vars); 1366 READ_INT_FIELD(num_child_cols); 1367 READ_ATTRNUMBER_ARRAY(parent_colnos, local_node->num_child_cols); 1368 READ_OID_FIELD(parent_reloid); 1369 1370 READ_DONE(); 1371 } 1372 1373 /* 1374 * Stuff from parsenodes.h. 1375 */ 1376 1377 /* 1378 * _readRangeTblEntry 1379 */ 1380 static RangeTblEntry * 1381 _readRangeTblEntry(void) 1382 { 1383 READ_LOCALS(RangeTblEntry); 1384 1385 /* put alias + eref first to make dump more legible */ 1386 READ_NODE_FIELD(alias); 1387 READ_NODE_FIELD(eref); 1388 READ_ENUM_FIELD(rtekind, RTEKind); 1389 1390 switch (local_node->rtekind) 1391 { 1392 case RTE_RELATION: 1393 READ_OID_FIELD(relid); 1394 READ_CHAR_FIELD(relkind); 1395 READ_INT_FIELD(rellockmode); 1396 READ_NODE_FIELD(tablesample); 1397 break; 1398 case RTE_SUBQUERY: 1399 READ_NODE_FIELD(subquery); 1400 READ_BOOL_FIELD(security_barrier); 1401 break; 1402 case RTE_JOIN: 1403 READ_ENUM_FIELD(jointype, JoinType); 1404 READ_INT_FIELD(joinmergedcols); 1405 READ_NODE_FIELD(joinaliasvars); 1406 READ_NODE_FIELD(joinleftcols); 1407 READ_NODE_FIELD(joinrightcols); 1408 break; 1409 case RTE_FUNCTION: 1410 READ_NODE_FIELD(functions); 1411 READ_BOOL_FIELD(funcordinality); 1412 break; 1413 case RTE_TABLEFUNC: 1414 READ_NODE_FIELD(tablefunc); 1415 /* The RTE must have a copy of the column type info, if any */ 1416 if (local_node->tablefunc) 1417 { 1418 TableFunc *tf = local_node->tablefunc; 1419 1420 local_node->coltypes = tf->coltypes; 1421 local_node->coltypmods = tf->coltypmods; 1422 local_node->colcollations = tf->colcollations; 1423 } 1424 break; 1425 case RTE_VALUES: 1426 READ_NODE_FIELD(values_lists); 1427 READ_NODE_FIELD(coltypes); 1428 READ_NODE_FIELD(coltypmods); 1429 READ_NODE_FIELD(colcollations); 1430 break; 1431 case RTE_CTE: 1432 READ_STRING_FIELD(ctename); 1433 READ_UINT_FIELD(ctelevelsup); 1434 READ_BOOL_FIELD(self_reference); 1435 READ_NODE_FIELD(coltypes); 1436 READ_NODE_FIELD(coltypmods); 1437 READ_NODE_FIELD(colcollations); 1438 break; 1439 case RTE_NAMEDTUPLESTORE: 1440 READ_STRING_FIELD(enrname); 1441 READ_FLOAT_FIELD(enrtuples); 1442 READ_OID_FIELD(relid); 1443 READ_NODE_FIELD(coltypes); 1444 READ_NODE_FIELD(coltypmods); 1445 READ_NODE_FIELD(colcollations); 1446 break; 1447 case RTE_RESULT: 1448 /* no extra fields */ 1449 break; 1450 default: 1451 elog(ERROR, "unrecognized RTE kind: %d", 1452 (int) local_node->rtekind); 1453 break; 1454 } 1455 1456 READ_BOOL_FIELD(lateral); 1457 READ_BOOL_FIELD(inh); 1458 READ_BOOL_FIELD(inFromCl); 1459 READ_UINT_FIELD(requiredPerms); 1460 READ_OID_FIELD(checkAsUser); 1461 READ_BITMAPSET_FIELD(selectedCols); 1462 READ_BITMAPSET_FIELD(insertedCols); 1463 READ_BITMAPSET_FIELD(updatedCols); 1464 READ_BITMAPSET_FIELD(extraUpdatedCols); 1465 READ_NODE_FIELD(securityQuals); 1466 1467 READ_DONE(); 1468 } 1469 1470 /* 1471 * _readRangeTblFunction 1472 */ 1473 static RangeTblFunction * 1474 _readRangeTblFunction(void) 1475 { 1476 READ_LOCALS(RangeTblFunction); 1477 1478 READ_NODE_FIELD(funcexpr); 1479 READ_INT_FIELD(funccolcount); 1480 READ_NODE_FIELD(funccolnames); 1481 READ_NODE_FIELD(funccoltypes); 1482 READ_NODE_FIELD(funccoltypmods); 1483 READ_NODE_FIELD(funccolcollations); 1484 READ_BITMAPSET_FIELD(funcparams); 1485 1486 READ_DONE(); 1487 } 1488 1489 /* 1490 * _readTableSampleClause 1491 */ 1492 static TableSampleClause * 1493 _readTableSampleClause(void) 1494 { 1495 READ_LOCALS(TableSampleClause); 1496 1497 READ_OID_FIELD(tsmhandler); 1498 READ_NODE_FIELD(args); 1499 READ_NODE_FIELD(repeatable); 1500 1501 READ_DONE(); 1502 } 1503 1504 /* 1505 * _readDefElem 1506 */ 1507 static DefElem * 1508 _readDefElem(void) 1509 { 1510 READ_LOCALS(DefElem); 1511 1512 READ_STRING_FIELD(defnamespace); 1513 READ_STRING_FIELD(defname); 1514 READ_NODE_FIELD(arg); 1515 READ_ENUM_FIELD(defaction, DefElemAction); 1516 READ_LOCATION_FIELD(location); 1517 1518 READ_DONE(); 1519 } 1520 1521 /* 1522 * Stuff from plannodes.h. 1523 */ 1524 1525 /* 1526 * _readPlannedStmt 1527 */ 1528 static PlannedStmt * 1529 _readPlannedStmt(void) 1530 { 1531 READ_LOCALS(PlannedStmt); 1532 1533 READ_ENUM_FIELD(commandType, CmdType); 1534 READ_UINT64_FIELD(queryId); 1535 READ_BOOL_FIELD(hasReturning); 1536 READ_BOOL_FIELD(hasModifyingCTE); 1537 READ_BOOL_FIELD(canSetTag); 1538 READ_BOOL_FIELD(transientPlan); 1539 READ_BOOL_FIELD(dependsOnRole); 1540 READ_BOOL_FIELD(parallelModeNeeded); 1541 READ_INT_FIELD(jitFlags); 1542 READ_NODE_FIELD(planTree); 1543 READ_NODE_FIELD(rtable); 1544 READ_NODE_FIELD(resultRelations); 1545 READ_NODE_FIELD(rootResultRelations); 1546 READ_NODE_FIELD(appendRelations); 1547 READ_NODE_FIELD(subplans); 1548 READ_BITMAPSET_FIELD(rewindPlanIDs); 1549 READ_NODE_FIELD(rowMarks); 1550 READ_NODE_FIELD(relationOids); 1551 READ_NODE_FIELD(invalItems); 1552 READ_NODE_FIELD(paramExecTypes); 1553 READ_NODE_FIELD(utilityStmt); 1554 READ_LOCATION_FIELD(stmt_location); 1555 READ_INT_FIELD(stmt_len); 1556 1557 READ_DONE(); 1558 } 1559 1560 /* 1561 * ReadCommonPlan 1562 * Assign the basic stuff of all nodes that inherit from Plan 1563 */ 1564 static void 1565 ReadCommonPlan(Plan *local_node) 1566 { 1567 READ_TEMP_LOCALS(); 1568 1569 READ_FLOAT_FIELD(startup_cost); 1570 READ_FLOAT_FIELD(total_cost); 1571 READ_FLOAT_FIELD(plan_rows); 1572 READ_INT_FIELD(plan_width); 1573 READ_BOOL_FIELD(parallel_aware); 1574 READ_BOOL_FIELD(parallel_safe); 1575 READ_INT_FIELD(plan_node_id); 1576 READ_NODE_FIELD(targetlist); 1577 READ_NODE_FIELD(qual); 1578 READ_NODE_FIELD(lefttree); 1579 READ_NODE_FIELD(righttree); 1580 READ_NODE_FIELD(initPlan); 1581 READ_BITMAPSET_FIELD(extParam); 1582 READ_BITMAPSET_FIELD(allParam); 1583 } 1584 1585 /* 1586 * _readPlan 1587 */ 1588 static Plan * 1589 _readPlan(void) 1590 { 1591 READ_LOCALS_NO_FIELDS(Plan); 1592 1593 ReadCommonPlan(local_node); 1594 1595 READ_DONE(); 1596 } 1597 1598 /* 1599 * _readResult 1600 */ 1601 static Result * 1602 _readResult(void) 1603 { 1604 READ_LOCALS(Result); 1605 1606 ReadCommonPlan(&local_node->plan); 1607 1608 READ_NODE_FIELD(resconstantqual); 1609 1610 READ_DONE(); 1611 } 1612 1613 /* 1614 * _readProjectSet 1615 */ 1616 static ProjectSet * 1617 _readProjectSet(void) 1618 { 1619 READ_LOCALS_NO_FIELDS(ProjectSet); 1620 1621 ReadCommonPlan(&local_node->plan); 1622 1623 READ_DONE(); 1624 } 1625 1626 /* 1627 * _readModifyTable 1628 */ 1629 static ModifyTable * 1630 _readModifyTable(void) 1631 { 1632 READ_LOCALS(ModifyTable); 1633 1634 ReadCommonPlan(&local_node->plan); 1635 1636 READ_ENUM_FIELD(operation, CmdType); 1637 READ_BOOL_FIELD(canSetTag); 1638 READ_UINT_FIELD(nominalRelation); 1639 READ_UINT_FIELD(rootRelation); 1640 READ_BOOL_FIELD(partColsUpdated); 1641 READ_NODE_FIELD(resultRelations); 1642 READ_INT_FIELD(resultRelIndex); 1643 READ_INT_FIELD(rootResultRelIndex); 1644 READ_NODE_FIELD(plans); 1645 READ_NODE_FIELD(withCheckOptionLists); 1646 READ_NODE_FIELD(returningLists); 1647 READ_NODE_FIELD(fdwPrivLists); 1648 READ_BITMAPSET_FIELD(fdwDirectModifyPlans); 1649 READ_NODE_FIELD(rowMarks); 1650 READ_INT_FIELD(epqParam); 1651 READ_ENUM_FIELD(onConflictAction, OnConflictAction); 1652 READ_NODE_FIELD(arbiterIndexes); 1653 READ_NODE_FIELD(onConflictSet); 1654 READ_NODE_FIELD(onConflictWhere); 1655 READ_UINT_FIELD(exclRelRTI); 1656 READ_NODE_FIELD(exclRelTlist); 1657 1658 READ_DONE(); 1659 } 1660 1661 /* 1662 * _readAppend 1663 */ 1664 static Append * 1665 _readAppend(void) 1666 { 1667 READ_LOCALS(Append); 1668 1669 ReadCommonPlan(&local_node->plan); 1670 1671 READ_BITMAPSET_FIELD(apprelids); 1672 READ_NODE_FIELD(appendplans); 1673 READ_INT_FIELD(first_partial_plan); 1674 READ_NODE_FIELD(part_prune_info); 1675 1676 READ_DONE(); 1677 } 1678 1679 /* 1680 * _readMergeAppend 1681 */ 1682 static MergeAppend * 1683 _readMergeAppend(void) 1684 { 1685 READ_LOCALS(MergeAppend); 1686 1687 ReadCommonPlan(&local_node->plan); 1688 1689 READ_BITMAPSET_FIELD(apprelids); 1690 READ_NODE_FIELD(mergeplans); 1691 READ_INT_FIELD(numCols); 1692 READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols); 1693 READ_OID_ARRAY(sortOperators, local_node->numCols); 1694 READ_OID_ARRAY(collations, local_node->numCols); 1695 READ_BOOL_ARRAY(nullsFirst, local_node->numCols); 1696 READ_NODE_FIELD(part_prune_info); 1697 1698 READ_DONE(); 1699 } 1700 1701 /* 1702 * _readRecursiveUnion 1703 */ 1704 static RecursiveUnion * 1705 _readRecursiveUnion(void) 1706 { 1707 READ_LOCALS(RecursiveUnion); 1708 1709 ReadCommonPlan(&local_node->plan); 1710 1711 READ_INT_FIELD(wtParam); 1712 READ_INT_FIELD(numCols); 1713 READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols); 1714 READ_OID_ARRAY(dupOperators, local_node->numCols); 1715 READ_OID_ARRAY(dupCollations, local_node->numCols); 1716 READ_LONG_FIELD(numGroups); 1717 1718 READ_DONE(); 1719 } 1720 1721 /* 1722 * _readBitmapAnd 1723 */ 1724 static BitmapAnd * 1725 _readBitmapAnd(void) 1726 { 1727 READ_LOCALS(BitmapAnd); 1728 1729 ReadCommonPlan(&local_node->plan); 1730 1731 READ_NODE_FIELD(bitmapplans); 1732 1733 READ_DONE(); 1734 } 1735 1736 /* 1737 * _readBitmapOr 1738 */ 1739 static BitmapOr * 1740 _readBitmapOr(void) 1741 { 1742 READ_LOCALS(BitmapOr); 1743 1744 ReadCommonPlan(&local_node->plan); 1745 1746 READ_BOOL_FIELD(isshared); 1747 READ_NODE_FIELD(bitmapplans); 1748 1749 READ_DONE(); 1750 } 1751 1752 /* 1753 * ReadCommonScan 1754 * Assign the basic stuff of all nodes that inherit from Scan 1755 */ 1756 static void 1757 ReadCommonScan(Scan *local_node) 1758 { 1759 READ_TEMP_LOCALS(); 1760 1761 ReadCommonPlan(&local_node->plan); 1762 1763 READ_UINT_FIELD(scanrelid); 1764 } 1765 1766 /* 1767 * _readScan 1768 */ 1769 static Scan * 1770 _readScan(void) 1771 { 1772 READ_LOCALS_NO_FIELDS(Scan); 1773 1774 ReadCommonScan(local_node); 1775 1776 READ_DONE(); 1777 } 1778 1779 /* 1780 * _readSeqScan 1781 */ 1782 static SeqScan * 1783 _readSeqScan(void) 1784 { 1785 READ_LOCALS_NO_FIELDS(SeqScan); 1786 1787 ReadCommonScan(local_node); 1788 1789 READ_DONE(); 1790 } 1791 1792 /* 1793 * _readSampleScan 1794 */ 1795 static SampleScan * 1796 _readSampleScan(void) 1797 { 1798 READ_LOCALS(SampleScan); 1799 1800 ReadCommonScan(&local_node->scan); 1801 1802 READ_NODE_FIELD(tablesample); 1803 1804 READ_DONE(); 1805 } 1806 1807 /* 1808 * _readIndexScan 1809 */ 1810 static IndexScan * 1811 _readIndexScan(void) 1812 { 1813 READ_LOCALS(IndexScan); 1814 1815 ReadCommonScan(&local_node->scan); 1816 1817 READ_OID_FIELD(indexid); 1818 READ_NODE_FIELD(indexqual); 1819 READ_NODE_FIELD(indexqualorig); 1820 READ_NODE_FIELD(indexorderby); 1821 READ_NODE_FIELD(indexorderbyorig); 1822 READ_NODE_FIELD(indexorderbyops); 1823 READ_ENUM_FIELD(indexorderdir, ScanDirection); 1824 1825 READ_DONE(); 1826 } 1827 1828 /* 1829 * _readIndexOnlyScan 1830 */ 1831 static IndexOnlyScan * 1832 _readIndexOnlyScan(void) 1833 { 1834 READ_LOCALS(IndexOnlyScan); 1835 1836 ReadCommonScan(&local_node->scan); 1837 1838 READ_OID_FIELD(indexid); 1839 READ_NODE_FIELD(indexqual); 1840 READ_NODE_FIELD(indexorderby); 1841 READ_NODE_FIELD(indextlist); 1842 READ_ENUM_FIELD(indexorderdir, ScanDirection); 1843 1844 READ_DONE(); 1845 } 1846 1847 /* 1848 * _readBitmapIndexScan 1849 */ 1850 static BitmapIndexScan * 1851 _readBitmapIndexScan(void) 1852 { 1853 READ_LOCALS(BitmapIndexScan); 1854 1855 ReadCommonScan(&local_node->scan); 1856 1857 READ_OID_FIELD(indexid); 1858 READ_BOOL_FIELD(isshared); 1859 READ_NODE_FIELD(indexqual); 1860 READ_NODE_FIELD(indexqualorig); 1861 1862 READ_DONE(); 1863 } 1864 1865 /* 1866 * _readBitmapHeapScan 1867 */ 1868 static BitmapHeapScan * 1869 _readBitmapHeapScan(void) 1870 { 1871 READ_LOCALS(BitmapHeapScan); 1872 1873 ReadCommonScan(&local_node->scan); 1874 1875 READ_NODE_FIELD(bitmapqualorig); 1876 1877 READ_DONE(); 1878 } 1879 1880 /* 1881 * _readTidScan 1882 */ 1883 static TidScan * 1884 _readTidScan(void) 1885 { 1886 READ_LOCALS(TidScan); 1887 1888 ReadCommonScan(&local_node->scan); 1889 1890 READ_NODE_FIELD(tidquals); 1891 1892 READ_DONE(); 1893 } 1894 1895 /* 1896 * _readSubqueryScan 1897 */ 1898 static SubqueryScan * 1899 _readSubqueryScan(void) 1900 { 1901 READ_LOCALS(SubqueryScan); 1902 1903 ReadCommonScan(&local_node->scan); 1904 1905 READ_NODE_FIELD(subplan); 1906 1907 READ_DONE(); 1908 } 1909 1910 /* 1911 * _readFunctionScan 1912 */ 1913 static FunctionScan * 1914 _readFunctionScan(void) 1915 { 1916 READ_LOCALS(FunctionScan); 1917 1918 ReadCommonScan(&local_node->scan); 1919 1920 READ_NODE_FIELD(functions); 1921 READ_BOOL_FIELD(funcordinality); 1922 1923 READ_DONE(); 1924 } 1925 1926 /* 1927 * _readValuesScan 1928 */ 1929 static ValuesScan * 1930 _readValuesScan(void) 1931 { 1932 READ_LOCALS(ValuesScan); 1933 1934 ReadCommonScan(&local_node->scan); 1935 1936 READ_NODE_FIELD(values_lists); 1937 1938 READ_DONE(); 1939 } 1940 1941 /* 1942 * _readTableFuncScan 1943 */ 1944 static TableFuncScan * 1945 _readTableFuncScan(void) 1946 { 1947 READ_LOCALS(TableFuncScan); 1948 1949 ReadCommonScan(&local_node->scan); 1950 1951 READ_NODE_FIELD(tablefunc); 1952 1953 READ_DONE(); 1954 } 1955 1956 /* 1957 * _readCteScan 1958 */ 1959 static CteScan * 1960 _readCteScan(void) 1961 { 1962 READ_LOCALS(CteScan); 1963 1964 ReadCommonScan(&local_node->scan); 1965 1966 READ_INT_FIELD(ctePlanId); 1967 READ_INT_FIELD(cteParam); 1968 1969 READ_DONE(); 1970 } 1971 1972 /* 1973 * _readNamedTuplestoreScan 1974 */ 1975 static NamedTuplestoreScan * 1976 _readNamedTuplestoreScan(void) 1977 { 1978 READ_LOCALS(NamedTuplestoreScan); 1979 1980 ReadCommonScan(&local_node->scan); 1981 1982 READ_STRING_FIELD(enrname); 1983 1984 READ_DONE(); 1985 } 1986 1987 /* 1988 * _readWorkTableScan 1989 */ 1990 static WorkTableScan * 1991 _readWorkTableScan(void) 1992 { 1993 READ_LOCALS(WorkTableScan); 1994 1995 ReadCommonScan(&local_node->scan); 1996 1997 READ_INT_FIELD(wtParam); 1998 1999 READ_DONE(); 2000 } 2001 2002 /* 2003 * _readForeignScan 2004 */ 2005 static ForeignScan * 2006 _readForeignScan(void) 2007 { 2008 READ_LOCALS(ForeignScan); 2009 2010 ReadCommonScan(&local_node->scan); 2011 2012 READ_ENUM_FIELD(operation, CmdType); 2013 READ_OID_FIELD(fs_server); 2014 READ_NODE_FIELD(fdw_exprs); 2015 READ_NODE_FIELD(fdw_private); 2016 READ_NODE_FIELD(fdw_scan_tlist); 2017 READ_NODE_FIELD(fdw_recheck_quals); 2018 READ_BITMAPSET_FIELD(fs_relids); 2019 READ_BOOL_FIELD(fsSystemCol); 2020 2021 READ_DONE(); 2022 } 2023 2024 /* 2025 * _readCustomScan 2026 */ 2027 static CustomScan * 2028 _readCustomScan(void) 2029 { 2030 READ_LOCALS(CustomScan); 2031 char *custom_name; 2032 const CustomScanMethods *methods; 2033 2034 ReadCommonScan(&local_node->scan); 2035 2036 READ_UINT_FIELD(flags); 2037 READ_NODE_FIELD(custom_plans); 2038 READ_NODE_FIELD(custom_exprs); 2039 READ_NODE_FIELD(custom_private); 2040 READ_NODE_FIELD(custom_scan_tlist); 2041 READ_BITMAPSET_FIELD(custom_relids); 2042 2043 /* Lookup CustomScanMethods by CustomName */ 2044 token = pg_strtok(&length); /* skip methods: */ 2045 token = pg_strtok(&length); /* CustomName */ 2046 custom_name = nullable_string(token, length); 2047 methods = GetCustomScanMethods(custom_name, false); 2048 local_node->methods = methods; 2049 2050 READ_DONE(); 2051 } 2052 2053 /* 2054 * ReadCommonJoin 2055 * Assign the basic stuff of all nodes that inherit from Join 2056 */ 2057 static void 2058 ReadCommonJoin(Join *local_node) 2059 { 2060 READ_TEMP_LOCALS(); 2061 2062 ReadCommonPlan(&local_node->plan); 2063 2064 READ_ENUM_FIELD(jointype, JoinType); 2065 READ_BOOL_FIELD(inner_unique); 2066 READ_NODE_FIELD(joinqual); 2067 } 2068 2069 /* 2070 * _readJoin 2071 */ 2072 static Join * 2073 _readJoin(void) 2074 { 2075 READ_LOCALS_NO_FIELDS(Join); 2076 2077 ReadCommonJoin(local_node); 2078 2079 READ_DONE(); 2080 } 2081 2082 /* 2083 * _readNestLoop 2084 */ 2085 static NestLoop * 2086 _readNestLoop(void) 2087 { 2088 READ_LOCALS(NestLoop); 2089 2090 ReadCommonJoin(&local_node->join); 2091 2092 READ_NODE_FIELD(nestParams); 2093 2094 READ_DONE(); 2095 } 2096 2097 /* 2098 * _readMergeJoin 2099 */ 2100 static MergeJoin * 2101 _readMergeJoin(void) 2102 { 2103 int numCols; 2104 2105 READ_LOCALS(MergeJoin); 2106 2107 ReadCommonJoin(&local_node->join); 2108 2109 READ_BOOL_FIELD(skip_mark_restore); 2110 READ_NODE_FIELD(mergeclauses); 2111 2112 numCols = list_length(local_node->mergeclauses); 2113 2114 READ_OID_ARRAY(mergeFamilies, numCols); 2115 READ_OID_ARRAY(mergeCollations, numCols); 2116 READ_INT_ARRAY(mergeStrategies, numCols); 2117 READ_BOOL_ARRAY(mergeNullsFirst, numCols); 2118 2119 READ_DONE(); 2120 } 2121 2122 /* 2123 * _readHashJoin 2124 */ 2125 static HashJoin * 2126 _readHashJoin(void) 2127 { 2128 READ_LOCALS(HashJoin); 2129 2130 ReadCommonJoin(&local_node->join); 2131 2132 READ_NODE_FIELD(hashclauses); 2133 READ_NODE_FIELD(hashoperators); 2134 READ_NODE_FIELD(hashcollations); 2135 READ_NODE_FIELD(hashkeys); 2136 2137 READ_DONE(); 2138 } 2139 2140 /* 2141 * _readMaterial 2142 */ 2143 static Material * 2144 _readMaterial(void) 2145 { 2146 READ_LOCALS_NO_FIELDS(Material); 2147 2148 ReadCommonPlan(&local_node->plan); 2149 2150 READ_DONE(); 2151 } 2152 2153 /* 2154 * ReadCommonSort 2155 * Assign the basic stuff of all nodes that inherit from Sort 2156 */ 2157 static void 2158 ReadCommonSort(Sort *local_node) 2159 { 2160 READ_TEMP_LOCALS(); 2161 2162 ReadCommonPlan(&local_node->plan); 2163 2164 READ_INT_FIELD(numCols); 2165 READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols); 2166 READ_OID_ARRAY(sortOperators, local_node->numCols); 2167 READ_OID_ARRAY(collations, local_node->numCols); 2168 READ_BOOL_ARRAY(nullsFirst, local_node->numCols); 2169 } 2170 2171 /* 2172 * _readSort 2173 */ 2174 static Sort * 2175 _readSort(void) 2176 { 2177 READ_LOCALS_NO_FIELDS(Sort); 2178 2179 ReadCommonSort(local_node); 2180 2181 READ_DONE(); 2182 } 2183 2184 /* 2185 * _readIncrementalSort 2186 */ 2187 static IncrementalSort * 2188 _readIncrementalSort(void) 2189 { 2190 READ_LOCALS(IncrementalSort); 2191 2192 ReadCommonSort(&local_node->sort); 2193 2194 READ_INT_FIELD(nPresortedCols); 2195 2196 READ_DONE(); 2197 } 2198 2199 /* 2200 * _readGroup 2201 */ 2202 static Group * 2203 _readGroup(void) 2204 { 2205 READ_LOCALS(Group); 2206 2207 ReadCommonPlan(&local_node->plan); 2208 2209 READ_INT_FIELD(numCols); 2210 READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols); 2211 READ_OID_ARRAY(grpOperators, local_node->numCols); 2212 READ_OID_ARRAY(grpCollations, local_node->numCols); 2213 2214 READ_DONE(); 2215 } 2216 2217 /* 2218 * _readAgg 2219 */ 2220 static Agg * 2221 _readAgg(void) 2222 { 2223 READ_LOCALS(Agg); 2224 2225 ReadCommonPlan(&local_node->plan); 2226 2227 READ_ENUM_FIELD(aggstrategy, AggStrategy); 2228 READ_ENUM_FIELD(aggsplit, AggSplit); 2229 READ_INT_FIELD(numCols); 2230 READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols); 2231 READ_OID_ARRAY(grpOperators, local_node->numCols); 2232 READ_OID_ARRAY(grpCollations, local_node->numCols); 2233 READ_LONG_FIELD(numGroups); 2234 READ_UINT64_FIELD(transitionSpace); 2235 READ_BITMAPSET_FIELD(aggParams); 2236 READ_NODE_FIELD(groupingSets); 2237 READ_NODE_FIELD(chain); 2238 2239 READ_DONE(); 2240 } 2241 2242 /* 2243 * _readWindowAgg 2244 */ 2245 static WindowAgg * 2246 _readWindowAgg(void) 2247 { 2248 READ_LOCALS(WindowAgg); 2249 2250 ReadCommonPlan(&local_node->plan); 2251 2252 READ_UINT_FIELD(winref); 2253 READ_INT_FIELD(partNumCols); 2254 READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols); 2255 READ_OID_ARRAY(partOperators, local_node->partNumCols); 2256 READ_OID_ARRAY(partCollations, local_node->partNumCols); 2257 READ_INT_FIELD(ordNumCols); 2258 READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols); 2259 READ_OID_ARRAY(ordOperators, local_node->ordNumCols); 2260 READ_OID_ARRAY(ordCollations, local_node->ordNumCols); 2261 READ_INT_FIELD(frameOptions); 2262 READ_NODE_FIELD(startOffset); 2263 READ_NODE_FIELD(endOffset); 2264 READ_OID_FIELD(startInRangeFunc); 2265 READ_OID_FIELD(endInRangeFunc); 2266 READ_OID_FIELD(inRangeColl); 2267 READ_BOOL_FIELD(inRangeAsc); 2268 READ_BOOL_FIELD(inRangeNullsFirst); 2269 2270 READ_DONE(); 2271 } 2272 2273 /* 2274 * _readUnique 2275 */ 2276 static Unique * 2277 _readUnique(void) 2278 { 2279 READ_LOCALS(Unique); 2280 2281 ReadCommonPlan(&local_node->plan); 2282 2283 READ_INT_FIELD(numCols); 2284 READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols); 2285 READ_OID_ARRAY(uniqOperators, local_node->numCols); 2286 READ_OID_ARRAY(uniqCollations, local_node->numCols); 2287 2288 READ_DONE(); 2289 } 2290 2291 /* 2292 * _readGather 2293 */ 2294 static Gather * 2295 _readGather(void) 2296 { 2297 READ_LOCALS(Gather); 2298 2299 ReadCommonPlan(&local_node->plan); 2300 2301 READ_INT_FIELD(num_workers); 2302 READ_INT_FIELD(rescan_param); 2303 READ_BOOL_FIELD(single_copy); 2304 READ_BOOL_FIELD(invisible); 2305 READ_BITMAPSET_FIELD(initParam); 2306 2307 READ_DONE(); 2308 } 2309 2310 /* 2311 * _readGatherMerge 2312 */ 2313 static GatherMerge * 2314 _readGatherMerge(void) 2315 { 2316 READ_LOCALS(GatherMerge); 2317 2318 ReadCommonPlan(&local_node->plan); 2319 2320 READ_INT_FIELD(num_workers); 2321 READ_INT_FIELD(rescan_param); 2322 READ_INT_FIELD(numCols); 2323 READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols); 2324 READ_OID_ARRAY(sortOperators, local_node->numCols); 2325 READ_OID_ARRAY(collations, local_node->numCols); 2326 READ_BOOL_ARRAY(nullsFirst, local_node->numCols); 2327 READ_BITMAPSET_FIELD(initParam); 2328 2329 READ_DONE(); 2330 } 2331 2332 /* 2333 * _readHash 2334 */ 2335 static Hash * 2336 _readHash(void) 2337 { 2338 READ_LOCALS(Hash); 2339 2340 ReadCommonPlan(&local_node->plan); 2341 2342 READ_NODE_FIELD(hashkeys); 2343 READ_OID_FIELD(skewTable); 2344 READ_INT_FIELD(skewColumn); 2345 READ_BOOL_FIELD(skewInherit); 2346 READ_FLOAT_FIELD(rows_total); 2347 2348 READ_DONE(); 2349 } 2350 2351 /* 2352 * _readSetOp 2353 */ 2354 static SetOp * 2355 _readSetOp(void) 2356 { 2357 READ_LOCALS(SetOp); 2358 2359 ReadCommonPlan(&local_node->plan); 2360 2361 READ_ENUM_FIELD(cmd, SetOpCmd); 2362 READ_ENUM_FIELD(strategy, SetOpStrategy); 2363 READ_INT_FIELD(numCols); 2364 READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols); 2365 READ_OID_ARRAY(dupOperators, local_node->numCols); 2366 READ_OID_ARRAY(dupCollations, local_node->numCols); 2367 READ_INT_FIELD(flagColIdx); 2368 READ_INT_FIELD(firstFlag); 2369 READ_LONG_FIELD(numGroups); 2370 2371 READ_DONE(); 2372 } 2373 2374 /* 2375 * _readLockRows 2376 */ 2377 static LockRows * 2378 _readLockRows(void) 2379 { 2380 READ_LOCALS(LockRows); 2381 2382 ReadCommonPlan(&local_node->plan); 2383 2384 READ_NODE_FIELD(rowMarks); 2385 READ_INT_FIELD(epqParam); 2386 2387 READ_DONE(); 2388 } 2389 2390 /* 2391 * _readLimit 2392 */ 2393 static Limit * 2394 _readLimit(void) 2395 { 2396 READ_LOCALS(Limit); 2397 2398 ReadCommonPlan(&local_node->plan); 2399 2400 READ_NODE_FIELD(limitOffset); 2401 READ_NODE_FIELD(limitCount); 2402 READ_ENUM_FIELD(limitOption, LimitOption); 2403 READ_INT_FIELD(uniqNumCols); 2404 READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->uniqNumCols); 2405 READ_OID_ARRAY(uniqOperators, local_node->uniqNumCols); 2406 READ_OID_ARRAY(uniqCollations, local_node->uniqNumCols); 2407 2408 READ_DONE(); 2409 } 2410 2411 /* 2412 * _readNestLoopParam 2413 */ 2414 static NestLoopParam * 2415 _readNestLoopParam(void) 2416 { 2417 READ_LOCALS(NestLoopParam); 2418 2419 READ_INT_FIELD(paramno); 2420 READ_NODE_FIELD(paramval); 2421 2422 READ_DONE(); 2423 } 2424 2425 /* 2426 * _readPlanRowMark 2427 */ 2428 static PlanRowMark * 2429 _readPlanRowMark(void) 2430 { 2431 READ_LOCALS(PlanRowMark); 2432 2433 READ_UINT_FIELD(rti); 2434 READ_UINT_FIELD(prti); 2435 READ_UINT_FIELD(rowmarkId); 2436 READ_ENUM_FIELD(markType, RowMarkType); 2437 READ_INT_FIELD(allMarkTypes); 2438 READ_ENUM_FIELD(strength, LockClauseStrength); 2439 READ_ENUM_FIELD(waitPolicy, LockWaitPolicy); 2440 READ_BOOL_FIELD(isParent); 2441 2442 READ_DONE(); 2443 } 2444 2445 static PartitionPruneInfo * 2446 _readPartitionPruneInfo(void) 2447 { 2448 READ_LOCALS(PartitionPruneInfo); 2449 2450 READ_NODE_FIELD(prune_infos); 2451 READ_BITMAPSET_FIELD(other_subplans); 2452 2453 READ_DONE(); 2454 } 2455 2456 static PartitionedRelPruneInfo * 2457 _readPartitionedRelPruneInfo(void) 2458 { 2459 READ_LOCALS(PartitionedRelPruneInfo); 2460 2461 READ_UINT_FIELD(rtindex); 2462 READ_BITMAPSET_FIELD(present_parts); 2463 READ_INT_FIELD(nparts); 2464 READ_INT_ARRAY(subplan_map, local_node->nparts); 2465 READ_INT_ARRAY(subpart_map, local_node->nparts); 2466 READ_OID_ARRAY(relid_map, local_node->nparts); 2467 READ_NODE_FIELD(initial_pruning_steps); 2468 READ_NODE_FIELD(exec_pruning_steps); 2469 READ_BITMAPSET_FIELD(execparamids); 2470 2471 READ_DONE(); 2472 } 2473 2474 static PartitionPruneStepOp * 2475 _readPartitionPruneStepOp(void) 2476 { 2477 READ_LOCALS(PartitionPruneStepOp); 2478 2479 READ_INT_FIELD(step.step_id); 2480 READ_INT_FIELD(opstrategy); 2481 READ_NODE_FIELD(exprs); 2482 READ_NODE_FIELD(cmpfns); 2483 READ_BITMAPSET_FIELD(nullkeys); 2484 2485 READ_DONE(); 2486 } 2487 2488 static PartitionPruneStepCombine * 2489 _readPartitionPruneStepCombine(void) 2490 { 2491 READ_LOCALS(PartitionPruneStepCombine); 2492 2493 READ_INT_FIELD(step.step_id); 2494 READ_ENUM_FIELD(combineOp, PartitionPruneCombineOp); 2495 READ_NODE_FIELD(source_stepids); 2496 2497 READ_DONE(); 2498 } 2499 2500 /* 2501 * _readPlanInvalItem 2502 */ 2503 static PlanInvalItem * 2504 _readPlanInvalItem(void) 2505 { 2506 READ_LOCALS(PlanInvalItem); 2507 2508 READ_INT_FIELD(cacheId); 2509 READ_UINT_FIELD(hashValue); 2510 2511 READ_DONE(); 2512 } 2513 2514 /* 2515 * _readSubPlan 2516 */ 2517 static SubPlan * 2518 _readSubPlan(void) 2519 { 2520 READ_LOCALS(SubPlan); 2521 2522 READ_ENUM_FIELD(subLinkType, SubLinkType); 2523 READ_NODE_FIELD(testexpr); 2524 READ_NODE_FIELD(paramIds); 2525 READ_INT_FIELD(plan_id); 2526 READ_STRING_FIELD(plan_name); 2527 READ_OID_FIELD(firstColType); 2528 READ_INT_FIELD(firstColTypmod); 2529 READ_OID_FIELD(firstColCollation); 2530 READ_BOOL_FIELD(useHashTable); 2531 READ_BOOL_FIELD(unknownEqFalse); 2532 READ_BOOL_FIELD(parallel_safe); 2533 READ_NODE_FIELD(setParam); 2534 READ_NODE_FIELD(parParam); 2535 READ_NODE_FIELD(args); 2536 READ_FLOAT_FIELD(startup_cost); 2537 READ_FLOAT_FIELD(per_call_cost); 2538 2539 READ_DONE(); 2540 } 2541 2542 /* 2543 * _readAlternativeSubPlan 2544 */ 2545 static AlternativeSubPlan * 2546 _readAlternativeSubPlan(void) 2547 { 2548 READ_LOCALS(AlternativeSubPlan); 2549 2550 READ_NODE_FIELD(subplans); 2551 2552 READ_DONE(); 2553 } 2554 2555 /* 2556 * _readExtensibleNode 2557 */ 2558 static ExtensibleNode * 2559 _readExtensibleNode(void) 2560 { 2561 const ExtensibleNodeMethods *methods; 2562 ExtensibleNode *local_node; 2563 const char *extnodename; 2564 2565 READ_TEMP_LOCALS(); 2566 2567 token = pg_strtok(&length); /* skip :extnodename */ 2568 token = pg_strtok(&length); /* get extnodename */ 2569 2570 extnodename = nullable_string(token, length); 2571 if (!extnodename) 2572 elog(ERROR, "extnodename has to be supplied"); 2573 methods = GetExtensibleNodeMethods(extnodename, false); 2574 2575 local_node = (ExtensibleNode *) newNode(methods->node_size, 2576 T_ExtensibleNode); 2577 local_node->extnodename = extnodename; 2578 2579 /* deserialize the private fields */ 2580 methods->nodeRead(local_node); 2581 2582 READ_DONE(); 2583 } 2584 2585 /* 2586 * _readPartitionBoundSpec 2587 */ 2588 static PartitionBoundSpec * 2589 _readPartitionBoundSpec(void) 2590 { 2591 READ_LOCALS(PartitionBoundSpec); 2592 2593 READ_CHAR_FIELD(strategy); 2594 READ_BOOL_FIELD(is_default); 2595 READ_INT_FIELD(modulus); 2596 READ_INT_FIELD(remainder); 2597 READ_NODE_FIELD(listdatums); 2598 READ_NODE_FIELD(lowerdatums); 2599 READ_NODE_FIELD(upperdatums); 2600 READ_LOCATION_FIELD(location); 2601 2602 READ_DONE(); 2603 } 2604 2605 /* 2606 * _readPartitionRangeDatum 2607 */ 2608 static PartitionRangeDatum * 2609 _readPartitionRangeDatum(void) 2610 { 2611 READ_LOCALS(PartitionRangeDatum); 2612 2613 READ_ENUM_FIELD(kind, PartitionRangeDatumKind); 2614 READ_NODE_FIELD(value); 2615 READ_LOCATION_FIELD(location); 2616 2617 READ_DONE(); 2618 } 2619 2620 /* 2621 * parseNodeString 2622 * 2623 * Given a character string representing a node tree, parseNodeString creates 2624 * the internal node structure. 2625 * 2626 * The string to be read must already have been loaded into pg_strtok(). 2627 */ 2628 Node * 2629 parseNodeString(void) 2630 { 2631 void *return_value; 2632 2633 READ_TEMP_LOCALS(); 2634 2635 /* Guard against stack overflow due to overly complex expressions */ 2636 check_stack_depth(); 2637 2638 token = pg_strtok(&length); 2639 2640 #define MATCH(tokname, namelen) \ 2641 (length == namelen && memcmp(token, tokname, namelen) == 0) 2642 2643 if (MATCH("QUERY", 5)) 2644 return_value = _readQuery(); 2645 else if (MATCH("WITHCHECKOPTION", 15)) 2646 return_value = _readWithCheckOption(); 2647 else if (MATCH("SORTGROUPCLAUSE", 15)) 2648 return_value = _readSortGroupClause(); 2649 else if (MATCH("GROUPINGSET", 11)) 2650 return_value = _readGroupingSet(); 2651 else if (MATCH("WINDOWCLAUSE", 12)) 2652 return_value = _readWindowClause(); 2653 else if (MATCH("ROWMARKCLAUSE", 13)) 2654 return_value = _readRowMarkClause(); 2655 else if (MATCH("COMMONTABLEEXPR", 15)) 2656 return_value = _readCommonTableExpr(); 2657 else if (MATCH("SETOPERATIONSTMT", 16)) 2658 return_value = _readSetOperationStmt(); 2659 else if (MATCH("ALIAS", 5)) 2660 return_value = _readAlias(); 2661 else if (MATCH("RANGEVAR", 8)) 2662 return_value = _readRangeVar(); 2663 else if (MATCH("INTOCLAUSE", 10)) 2664 return_value = _readIntoClause(); 2665 else if (MATCH("TABLEFUNC", 9)) 2666 return_value = _readTableFunc(); 2667 else if (MATCH("VAR", 3)) 2668 return_value = _readVar(); 2669 else if (MATCH("CONST", 5)) 2670 return_value = _readConst(); 2671 else if (MATCH("PARAM", 5)) 2672 return_value = _readParam(); 2673 else if (MATCH("AGGREF", 6)) 2674 return_value = _readAggref(); 2675 else if (MATCH("GROUPINGFUNC", 12)) 2676 return_value = _readGroupingFunc(); 2677 else if (MATCH("WINDOWFUNC", 10)) 2678 return_value = _readWindowFunc(); 2679 else if (MATCH("SUBSCRIPTINGREF", 15)) 2680 return_value = _readSubscriptingRef(); 2681 else if (MATCH("FUNCEXPR", 8)) 2682 return_value = _readFuncExpr(); 2683 else if (MATCH("NAMEDARGEXPR", 12)) 2684 return_value = _readNamedArgExpr(); 2685 else if (MATCH("OPEXPR", 6)) 2686 return_value = _readOpExpr(); 2687 else if (MATCH("DISTINCTEXPR", 12)) 2688 return_value = _readDistinctExpr(); 2689 else if (MATCH("NULLIFEXPR", 10)) 2690 return_value = _readNullIfExpr(); 2691 else if (MATCH("SCALARARRAYOPEXPR", 17)) 2692 return_value = _readScalarArrayOpExpr(); 2693 else if (MATCH("BOOLEXPR", 8)) 2694 return_value = _readBoolExpr(); 2695 else if (MATCH("SUBLINK", 7)) 2696 return_value = _readSubLink(); 2697 else if (MATCH("FIELDSELECT", 11)) 2698 return_value = _readFieldSelect(); 2699 else if (MATCH("FIELDSTORE", 10)) 2700 return_value = _readFieldStore(); 2701 else if (MATCH("RELABELTYPE", 11)) 2702 return_value = _readRelabelType(); 2703 else if (MATCH("COERCEVIAIO", 11)) 2704 return_value = _readCoerceViaIO(); 2705 else if (MATCH("ARRAYCOERCEEXPR", 15)) 2706 return_value = _readArrayCoerceExpr(); 2707 else if (MATCH("CONVERTROWTYPEEXPR", 18)) 2708 return_value = _readConvertRowtypeExpr(); 2709 else if (MATCH("COLLATE", 7)) 2710 return_value = _readCollateExpr(); 2711 else if (MATCH("CASE", 4)) 2712 return_value = _readCaseExpr(); 2713 else if (MATCH("WHEN", 4)) 2714 return_value = _readCaseWhen(); 2715 else if (MATCH("CASETESTEXPR", 12)) 2716 return_value = _readCaseTestExpr(); 2717 else if (MATCH("ARRAY", 5)) 2718 return_value = _readArrayExpr(); 2719 else if (MATCH("ROW", 3)) 2720 return_value = _readRowExpr(); 2721 else if (MATCH("ROWCOMPARE", 10)) 2722 return_value = _readRowCompareExpr(); 2723 else if (MATCH("COALESCE", 8)) 2724 return_value = _readCoalesceExpr(); 2725 else if (MATCH("MINMAX", 6)) 2726 return_value = _readMinMaxExpr(); 2727 else if (MATCH("SQLVALUEFUNCTION", 16)) 2728 return_value = _readSQLValueFunction(); 2729 else if (MATCH("XMLEXPR", 7)) 2730 return_value = _readXmlExpr(); 2731 else if (MATCH("NULLTEST", 8)) 2732 return_value = _readNullTest(); 2733 else if (MATCH("BOOLEANTEST", 11)) 2734 return_value = _readBooleanTest(); 2735 else if (MATCH("COERCETODOMAIN", 14)) 2736 return_value = _readCoerceToDomain(); 2737 else if (MATCH("COERCETODOMAINVALUE", 19)) 2738 return_value = _readCoerceToDomainValue(); 2739 else if (MATCH("SETTODEFAULT", 12)) 2740 return_value = _readSetToDefault(); 2741 else if (MATCH("CURRENTOFEXPR", 13)) 2742 return_value = _readCurrentOfExpr(); 2743 else if (MATCH("NEXTVALUEEXPR", 13)) 2744 return_value = _readNextValueExpr(); 2745 else if (MATCH("INFERENCEELEM", 13)) 2746 return_value = _readInferenceElem(); 2747 else if (MATCH("TARGETENTRY", 11)) 2748 return_value = _readTargetEntry(); 2749 else if (MATCH("RANGETBLREF", 11)) 2750 return_value = _readRangeTblRef(); 2751 else if (MATCH("JOINEXPR", 8)) 2752 return_value = _readJoinExpr(); 2753 else if (MATCH("FROMEXPR", 8)) 2754 return_value = _readFromExpr(); 2755 else if (MATCH("ONCONFLICTEXPR", 14)) 2756 return_value = _readOnConflictExpr(); 2757 else if (MATCH("APPENDRELINFO", 13)) 2758 return_value = _readAppendRelInfo(); 2759 else if (MATCH("RTE", 3)) 2760 return_value = _readRangeTblEntry(); 2761 else if (MATCH("RANGETBLFUNCTION", 16)) 2762 return_value = _readRangeTblFunction(); 2763 else if (MATCH("TABLESAMPLECLAUSE", 17)) 2764 return_value = _readTableSampleClause(); 2765 else if (MATCH("NOTIFY", 6)) 2766 return_value = _readNotifyStmt(); 2767 else if (MATCH("DEFELEM", 7)) 2768 return_value = _readDefElem(); 2769 else if (MATCH("DECLARECURSOR", 13)) 2770 return_value = _readDeclareCursorStmt(); 2771 else if (MATCH("PLANNEDSTMT", 11)) 2772 return_value = _readPlannedStmt(); 2773 else if (MATCH("PLAN", 4)) 2774 return_value = _readPlan(); 2775 else if (MATCH("RESULT", 6)) 2776 return_value = _readResult(); 2777 else if (MATCH("PROJECTSET", 10)) 2778 return_value = _readProjectSet(); 2779 else if (MATCH("MODIFYTABLE", 11)) 2780 return_value = _readModifyTable(); 2781 else if (MATCH("APPEND", 6)) 2782 return_value = _readAppend(); 2783 else if (MATCH("MERGEAPPEND", 11)) 2784 return_value = _readMergeAppend(); 2785 else if (MATCH("RECURSIVEUNION", 14)) 2786 return_value = _readRecursiveUnion(); 2787 else if (MATCH("BITMAPAND", 9)) 2788 return_value = _readBitmapAnd(); 2789 else if (MATCH("BITMAPOR", 8)) 2790 return_value = _readBitmapOr(); 2791 else if (MATCH("SCAN", 4)) 2792 return_value = _readScan(); 2793 else if (MATCH("SEQSCAN", 7)) 2794 return_value = _readSeqScan(); 2795 else if (MATCH("SAMPLESCAN", 10)) 2796 return_value = _readSampleScan(); 2797 else if (MATCH("INDEXSCAN", 9)) 2798 return_value = _readIndexScan(); 2799 else if (MATCH("INDEXONLYSCAN", 13)) 2800 return_value = _readIndexOnlyScan(); 2801 else if (MATCH("BITMAPINDEXSCAN", 15)) 2802 return_value = _readBitmapIndexScan(); 2803 else if (MATCH("BITMAPHEAPSCAN", 14)) 2804 return_value = _readBitmapHeapScan(); 2805 else if (MATCH("TIDSCAN", 7)) 2806 return_value = _readTidScan(); 2807 else if (MATCH("SUBQUERYSCAN", 12)) 2808 return_value = _readSubqueryScan(); 2809 else if (MATCH("FUNCTIONSCAN", 12)) 2810 return_value = _readFunctionScan(); 2811 else if (MATCH("VALUESSCAN", 10)) 2812 return_value = _readValuesScan(); 2813 else if (MATCH("TABLEFUNCSCAN", 13)) 2814 return_value = _readTableFuncScan(); 2815 else if (MATCH("CTESCAN", 7)) 2816 return_value = _readCteScan(); 2817 else if (MATCH("NAMEDTUPLESTORESCAN", 19)) 2818 return_value = _readNamedTuplestoreScan(); 2819 else if (MATCH("WORKTABLESCAN", 13)) 2820 return_value = _readWorkTableScan(); 2821 else if (MATCH("FOREIGNSCAN", 11)) 2822 return_value = _readForeignScan(); 2823 else if (MATCH("CUSTOMSCAN", 10)) 2824 return_value = _readCustomScan(); 2825 else if (MATCH("JOIN", 4)) 2826 return_value = _readJoin(); 2827 else if (MATCH("NESTLOOP", 8)) 2828 return_value = _readNestLoop(); 2829 else if (MATCH("MERGEJOIN", 9)) 2830 return_value = _readMergeJoin(); 2831 else if (MATCH("HASHJOIN", 8)) 2832 return_value = _readHashJoin(); 2833 else if (MATCH("MATERIAL", 8)) 2834 return_value = _readMaterial(); 2835 else if (MATCH("SORT", 4)) 2836 return_value = _readSort(); 2837 else if (MATCH("INCREMENTALSORT", 15)) 2838 return_value = _readIncrementalSort(); 2839 else if (MATCH("GROUP", 5)) 2840 return_value = _readGroup(); 2841 else if (MATCH("AGG", 3)) 2842 return_value = _readAgg(); 2843 else if (MATCH("WINDOWAGG", 9)) 2844 return_value = _readWindowAgg(); 2845 else if (MATCH("UNIQUE", 6)) 2846 return_value = _readUnique(); 2847 else if (MATCH("GATHER", 6)) 2848 return_value = _readGather(); 2849 else if (MATCH("GATHERMERGE", 11)) 2850 return_value = _readGatherMerge(); 2851 else if (MATCH("HASH", 4)) 2852 return_value = _readHash(); 2853 else if (MATCH("SETOP", 5)) 2854 return_value = _readSetOp(); 2855 else if (MATCH("LOCKROWS", 8)) 2856 return_value = _readLockRows(); 2857 else if (MATCH("LIMIT", 5)) 2858 return_value = _readLimit(); 2859 else if (MATCH("NESTLOOPPARAM", 13)) 2860 return_value = _readNestLoopParam(); 2861 else if (MATCH("PLANROWMARK", 11)) 2862 return_value = _readPlanRowMark(); 2863 else if (MATCH("PARTITIONPRUNEINFO", 18)) 2864 return_value = _readPartitionPruneInfo(); 2865 else if (MATCH("PARTITIONEDRELPRUNEINFO", 23)) 2866 return_value = _readPartitionedRelPruneInfo(); 2867 else if (MATCH("PARTITIONPRUNESTEPOP", 20)) 2868 return_value = _readPartitionPruneStepOp(); 2869 else if (MATCH("PARTITIONPRUNESTEPCOMBINE", 25)) 2870 return_value = _readPartitionPruneStepCombine(); 2871 else if (MATCH("PLANINVALITEM", 13)) 2872 return_value = _readPlanInvalItem(); 2873 else if (MATCH("SUBPLAN", 7)) 2874 return_value = _readSubPlan(); 2875 else if (MATCH("ALTERNATIVESUBPLAN", 18)) 2876 return_value = _readAlternativeSubPlan(); 2877 else if (MATCH("EXTENSIBLENODE", 14)) 2878 return_value = _readExtensibleNode(); 2879 else if (MATCH("PARTITIONBOUNDSPEC", 18)) 2880 return_value = _readPartitionBoundSpec(); 2881 else if (MATCH("PARTITIONRANGEDATUM", 19)) 2882 return_value = _readPartitionRangeDatum(); 2883 else 2884 { 2885 elog(ERROR, "badly formatted node string \"%.32s\"...", token); 2886 return_value = NULL; /* keep compiler quiet */ 2887 } 2888 2889 return (Node *) return_value; 2890 } 2891 2892 2893 /* 2894 * readDatum 2895 * 2896 * Given a string representation of a constant, recreate the appropriate 2897 * Datum. The string representation embeds length info, but not byValue, 2898 * so we must be told that. 2899 */ 2900 Datum 2901 readDatum(bool typbyval) 2902 { 2903 Size length, 2904 i; 2905 int tokenLength; 2906 const char *token; 2907 Datum res; 2908 char *s; 2909 2910 /* 2911 * read the actual length of the value 2912 */ 2913 token = pg_strtok(&tokenLength); 2914 length = atoui(token); 2915 2916 token = pg_strtok(&tokenLength); /* read the '[' */ 2917 if (token == NULL || token[0] != '[') 2918 elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu", 2919 token ? token : "[NULL]", length); 2920 2921 if (typbyval) 2922 { 2923 if (length > (Size) sizeof(Datum)) 2924 elog(ERROR, "byval datum but length = %zu", length); 2925 res = (Datum) 0; 2926 s = (char *) (&res); 2927 for (i = 0; i < (Size) sizeof(Datum); i++) 2928 { 2929 token = pg_strtok(&tokenLength); 2930 s[i] = (char) atoi(token); 2931 } 2932 } 2933 else if (length <= 0) 2934 res = (Datum) NULL; 2935 else 2936 { 2937 s = (char *) palloc(length); 2938 for (i = 0; i < length; i++) 2939 { 2940 token = pg_strtok(&tokenLength); 2941 s[i] = (char) atoi(token); 2942 } 2943 res = PointerGetDatum(s); 2944 } 2945 2946 token = pg_strtok(&tokenLength); /* read the ']' */ 2947 if (token == NULL || token[0] != ']') 2948 elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu", 2949 token ? token : "[NULL]", length); 2950 2951 return res; 2952 } 2953 2954 /* 2955 * readAttrNumberCols 2956 */ 2957 AttrNumber * 2958 readAttrNumberCols(int numCols) 2959 { 2960 int tokenLength, 2961 i; 2962 const char *token; 2963 AttrNumber *attr_vals; 2964 2965 if (numCols <= 0) 2966 return NULL; 2967 2968 attr_vals = (AttrNumber *) palloc(numCols * sizeof(AttrNumber)); 2969 for (i = 0; i < numCols; i++) 2970 { 2971 token = pg_strtok(&tokenLength); 2972 attr_vals[i] = atoi(token); 2973 } 2974 2975 return attr_vals; 2976 } 2977 2978 /* 2979 * readOidCols 2980 */ 2981 Oid * 2982 readOidCols(int numCols) 2983 { 2984 int tokenLength, 2985 i; 2986 const char *token; 2987 Oid *oid_vals; 2988 2989 if (numCols <= 0) 2990 return NULL; 2991 2992 oid_vals = (Oid *) palloc(numCols * sizeof(Oid)); 2993 for (i = 0; i < numCols; i++) 2994 { 2995 token = pg_strtok(&tokenLength); 2996 oid_vals[i] = atooid(token); 2997 } 2998 2999 return oid_vals; 3000 } 3001 3002 /* 3003 * readIntCols 3004 */ 3005 int * 3006 readIntCols(int numCols) 3007 { 3008 int tokenLength, 3009 i; 3010 const char *token; 3011 int *int_vals; 3012 3013 if (numCols <= 0) 3014 return NULL; 3015 3016 int_vals = (int *) palloc(numCols * sizeof(int)); 3017 for (i = 0; i < numCols; i++) 3018 { 3019 token = pg_strtok(&tokenLength); 3020 int_vals[i] = atoi(token); 3021 } 3022 3023 return int_vals; 3024 } 3025 3026 /* 3027 * readBoolCols 3028 */ 3029 bool * 3030 readBoolCols(int numCols) 3031 { 3032 int tokenLength, 3033 i; 3034 const char *token; 3035 bool *bool_vals; 3036 3037 if (numCols <= 0) 3038 return NULL; 3039 3040 bool_vals = (bool *) palloc(numCols * sizeof(bool)); 3041 for (i = 0; i < numCols; i++) 3042 { 3043 token = pg_strtok(&tokenLength); 3044 bool_vals[i] = strtobool(token); 3045 } 3046 3047 return bool_vals; 3048 } 3049