granicus.if.org Git - postgresql/blob - src/backend/nodes/readfuncs.c

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