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(withCheckOptions);
 248         READ_NODE_FIELD(onConflict);
 249         READ_NODE_FIELD(returningList);
 250         READ_NODE_FIELD(groupClause);
 251         READ_NODE_FIELD(groupingSets);
 252         READ_NODE_FIELD(havingQual);
 253         READ_NODE_FIELD(windowClause);
 254         READ_NODE_FIELD(distinctClause);
 255         READ_NODE_FIELD(sortClause);
 256         READ_NODE_FIELD(limitOffset);
 257         READ_NODE_FIELD(limitCount);
 258         READ_NODE_FIELD(rowMarks);
 259         READ_NODE_FIELD(setOperations);
 260         READ_NODE_FIELD(constraintDeps);
 261
 262         READ_DONE();
 263 }
 264
 265 /*
 266  * _readNotifyStmt
 267  */
 268 static NotifyStmt *
 269 _readNotifyStmt(void)
 270 {
 271         READ_LOCALS(NotifyStmt);
 272
 273         READ_STRING_FIELD(conditionname);
 274         READ_STRING_FIELD(payload);
 275
 276         READ_DONE();
 277 }
 278
 279 /*
 280  * _readDeclareCursorStmt
 281  */
 282 static DeclareCursorStmt *
 283 _readDeclareCursorStmt(void)
 284 {
 285         READ_LOCALS(DeclareCursorStmt);
 286
 287         READ_STRING_FIELD(portalname);
 288         READ_INT_FIELD(options);
 289         READ_NODE_FIELD(query);
 290
 291         READ_DONE();
 292 }
 293
 294 /*
 295  * _readWithCheckOption
 296  */
 297 static WithCheckOption *
 298 _readWithCheckOption(void)
 299 {
 300         READ_LOCALS(WithCheckOption);
 301
 302         READ_ENUM_FIELD(kind, WCOKind);
 303         READ_STRING_FIELD(relname);
 304         READ_STRING_FIELD(polname);
 305         READ_NODE_FIELD(qual);
 306         READ_BOOL_FIELD(cascaded);
 307
 308         READ_DONE();
 309 }
 310
 311 /*
 312  * _readSortGroupClause
 313  */
 314 static SortGroupClause *
 315 _readSortGroupClause(void)
 316 {
 317         READ_LOCALS(SortGroupClause);
 318
 319         READ_UINT_FIELD(tleSortGroupRef);
 320         READ_OID_FIELD(eqop);
 321         READ_OID_FIELD(sortop);
 322         READ_BOOL_FIELD(nulls_first);
 323         READ_BOOL_FIELD(hashable);
 324
 325         READ_DONE();
 326 }
 327
 328 /*
 329  * _readGroupingSet
 330  */
 331 static GroupingSet *
 332 _readGroupingSet(void)
 333 {
 334         READ_LOCALS(GroupingSet);
 335
 336         READ_ENUM_FIELD(kind, GroupingSetKind);
 337         READ_NODE_FIELD(content);
 338         READ_LOCATION_FIELD(location);
 339
 340         READ_DONE();
 341 }
 342
 343 /*
 344  * _readWindowClause
 345  */
 346 static WindowClause *
 347 _readWindowClause(void)
 348 {
 349         READ_LOCALS(WindowClause);
 350
 351         READ_STRING_FIELD(name);
 352         READ_STRING_FIELD(refname);
 353         READ_NODE_FIELD(partitionClause);
 354         READ_NODE_FIELD(orderClause);
 355         READ_INT_FIELD(frameOptions);
 356         READ_NODE_FIELD(startOffset);
 357         READ_NODE_FIELD(endOffset);
 358         READ_UINT_FIELD(winref);
 359         READ_BOOL_FIELD(copiedOrder);
 360
 361         READ_DONE();
 362 }
 363
 364 /*
 365  * _readRowMarkClause
 366  */
 367 static RowMarkClause *
 368 _readRowMarkClause(void)
 369 {
 370         READ_LOCALS(RowMarkClause);
 371
 372         READ_UINT_FIELD(rti);
 373         READ_ENUM_FIELD(strength, LockClauseStrength);
 374         READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
 375         READ_BOOL_FIELD(pushedDown);
 376
 377         READ_DONE();
 378 }
 379
 380 /*
 381  * _readCommonTableExpr
 382  */
 383 static CommonTableExpr *
 384 _readCommonTableExpr(void)
 385 {
 386         READ_LOCALS(CommonTableExpr);
 387
 388         READ_STRING_FIELD(ctename);
 389         READ_NODE_FIELD(aliascolnames);
 390         READ_NODE_FIELD(ctequery);
 391         READ_LOCATION_FIELD(location);
 392         READ_BOOL_FIELD(cterecursive);
 393         READ_INT_FIELD(cterefcount);
 394         READ_NODE_FIELD(ctecolnames);
 395         READ_NODE_FIELD(ctecoltypes);
 396         READ_NODE_FIELD(ctecoltypmods);
 397         READ_NODE_FIELD(ctecolcollations);
 398
 399         READ_DONE();
 400 }
 401
 402 /*
 403  * _readSetOperationStmt
 404  */
 405 static SetOperationStmt *
 406 _readSetOperationStmt(void)
 407 {
 408         READ_LOCALS(SetOperationStmt);
 409
 410         READ_ENUM_FIELD(op, SetOperation);
 411         READ_BOOL_FIELD(all);
 412         READ_NODE_FIELD(larg);
 413         READ_NODE_FIELD(rarg);
 414         READ_NODE_FIELD(colTypes);
 415         READ_NODE_FIELD(colTypmods);
 416         READ_NODE_FIELD(colCollations);
 417         READ_NODE_FIELD(groupClauses);
 418
 419         READ_DONE();
 420 }
 421
 422
 423 /*
 424  *      Stuff from primnodes.h.
 425  */
 426
 427 static Alias *
 428 _readAlias(void)
 429 {
 430         READ_LOCALS(Alias);
 431
 432         READ_STRING_FIELD(aliasname);
 433         READ_NODE_FIELD(colnames);
 434
 435         READ_DONE();
 436 }
 437
 438 static RangeVar *
 439 _readRangeVar(void)
 440 {
 441         READ_LOCALS(RangeVar);
 442
 443         local_node->catalogname = NULL;         /* not currently saved in output
 444                                                                                  * format */
 445
 446         READ_STRING_FIELD(schemaname);
 447         READ_STRING_FIELD(relname);
 448         READ_ENUM_FIELD(inhOpt, InhOption);
 449         READ_CHAR_FIELD(relpersistence);
 450         READ_NODE_FIELD(alias);
 451         READ_LOCATION_FIELD(location);
 452
 453         READ_DONE();
 454 }
 455
 456 static IntoClause *
 457 _readIntoClause(void)
 458 {
 459         READ_LOCALS(IntoClause);
 460
 461         READ_NODE_FIELD(rel);
 462         READ_NODE_FIELD(colNames);
 463         READ_NODE_FIELD(options);
 464         READ_ENUM_FIELD(onCommit, OnCommitAction);
 465         READ_STRING_FIELD(tableSpaceName);
 466         READ_NODE_FIELD(viewQuery);
 467         READ_BOOL_FIELD(skipData);
 468
 469         READ_DONE();
 470 }
 471
 472 /*
 473  * _readVar
 474  */
 475 static Var *
 476 _readVar(void)
 477 {
 478         READ_LOCALS(Var);
 479
 480         READ_UINT_FIELD(varno);
 481         READ_INT_FIELD(varattno);
 482         READ_OID_FIELD(vartype);
 483         READ_INT_FIELD(vartypmod);
 484         READ_OID_FIELD(varcollid);
 485         READ_UINT_FIELD(varlevelsup);
 486         READ_UINT_FIELD(varnoold);
 487         READ_INT_FIELD(varoattno);
 488         READ_LOCATION_FIELD(location);
 489
 490         READ_DONE();
 491 }
 492
 493 /*
 494  * _readConst
 495  */
 496 static Const *
 497 _readConst(void)
 498 {
 499         READ_LOCALS(Const);
 500
 501         READ_OID_FIELD(consttype);
 502         READ_INT_FIELD(consttypmod);
 503         READ_OID_FIELD(constcollid);
 504         READ_INT_FIELD(constlen);
 505         READ_BOOL_FIELD(constbyval);
 506         READ_BOOL_FIELD(constisnull);
 507         READ_LOCATION_FIELD(location);
 508
 509         token = pg_strtok(&length); /* skip :constvalue */
 510         if (local_node->constisnull)
 511                 token = pg_strtok(&length);             /* skip "<>" */
 512         else
 513                 local_node->constvalue = readDatum(local_node->constbyval);
 514
 515         READ_DONE();
 516 }
 517
 518 /*
 519  * _readParam
 520  */
 521 static Param *
 522 _readParam(void)
 523 {
 524         READ_LOCALS(Param);
 525
 526         READ_ENUM_FIELD(paramkind, ParamKind);
 527         READ_INT_FIELD(paramid);
 528         READ_OID_FIELD(paramtype);
 529         READ_INT_FIELD(paramtypmod);
 530         READ_OID_FIELD(paramcollid);
 531         READ_LOCATION_FIELD(location);
 532
 533         READ_DONE();
 534 }
 535
 536 /*
 537  * _readAggref
 538  */
 539 static Aggref *
 540 _readAggref(void)
 541 {
 542         READ_LOCALS(Aggref);
 543
 544         READ_OID_FIELD(aggfnoid);
 545         READ_OID_FIELD(aggtype);
 546         READ_OID_FIELD(aggcollid);
 547         READ_OID_FIELD(inputcollid);
 548         READ_NODE_FIELD(aggdirectargs);
 549         READ_NODE_FIELD(args);
 550         READ_NODE_FIELD(aggorder);
 551         READ_NODE_FIELD(aggdistinct);
 552         READ_NODE_FIELD(aggfilter);
 553         READ_BOOL_FIELD(aggstar);
 554         READ_BOOL_FIELD(aggvariadic);
 555         READ_CHAR_FIELD(aggkind);
 556         READ_UINT_FIELD(agglevelsup);
 557         READ_LOCATION_FIELD(location);
 558
 559         READ_DONE();
 560 }
 561
 562 /*
 563  * _readGroupingFunc
 564  */
 565 static GroupingFunc *
 566 _readGroupingFunc(void)
 567 {
 568         READ_LOCALS(GroupingFunc);
 569
 570         READ_NODE_FIELD(args);
 571         READ_NODE_FIELD(refs);
 572         READ_NODE_FIELD(cols);
 573         READ_UINT_FIELD(agglevelsup);
 574         READ_LOCATION_FIELD(location);
 575
 576         READ_DONE();
 577 }
 578
 579 /*
 580  * _readWindowFunc
 581  */
 582 static WindowFunc *
 583 _readWindowFunc(void)
 584 {
 585         READ_LOCALS(WindowFunc);
 586
 587         READ_OID_FIELD(winfnoid);
 588         READ_OID_FIELD(wintype);
 589         READ_OID_FIELD(wincollid);
 590         READ_OID_FIELD(inputcollid);
 591         READ_NODE_FIELD(args);
 592         READ_NODE_FIELD(aggfilter);
 593         READ_UINT_FIELD(winref);
 594         READ_BOOL_FIELD(winstar);
 595         READ_BOOL_FIELD(winagg);
 596         READ_LOCATION_FIELD(location);
 597
 598         READ_DONE();
 599 }
 600
 601 /*
 602  * _readArrayRef
 603  */
 604 static ArrayRef *
 605 _readArrayRef(void)
 606 {
 607         READ_LOCALS(ArrayRef);
 608
 609         READ_OID_FIELD(refarraytype);
 610         READ_OID_FIELD(refelemtype);
 611         READ_INT_FIELD(reftypmod);
 612         READ_OID_FIELD(refcollid);
 613         READ_NODE_FIELD(refupperindexpr);
 614         READ_NODE_FIELD(reflowerindexpr);
 615         READ_NODE_FIELD(refexpr);
 616         READ_NODE_FIELD(refassgnexpr);
 617
 618         READ_DONE();
 619 }
 620
 621 /*
 622  * _readFuncExpr
 623  */
 624 static FuncExpr *
 625 _readFuncExpr(void)
 626 {
 627         READ_LOCALS(FuncExpr);
 628
 629         READ_OID_FIELD(funcid);
 630         READ_OID_FIELD(funcresulttype);
 631         READ_BOOL_FIELD(funcretset);
 632         READ_BOOL_FIELD(funcvariadic);
 633         READ_ENUM_FIELD(funcformat, CoercionForm);
 634         READ_OID_FIELD(funccollid);
 635         READ_OID_FIELD(inputcollid);
 636         READ_NODE_FIELD(args);
 637         READ_LOCATION_FIELD(location);
 638
 639         READ_DONE();
 640 }
 641
 642 /*
 643  * _readNamedArgExpr
 644  */
 645 static NamedArgExpr *
 646 _readNamedArgExpr(void)
 647 {
 648         READ_LOCALS(NamedArgExpr);
 649
 650         READ_NODE_FIELD(arg);
 651         READ_STRING_FIELD(name);
 652         READ_INT_FIELD(argnumber);
 653         READ_LOCATION_FIELD(location);
 654
 655         READ_DONE();
 656 }
 657
 658 /*
 659  * _readOpExpr
 660  */
 661 static OpExpr *
 662 _readOpExpr(void)
 663 {
 664         READ_LOCALS(OpExpr);
 665
 666         READ_OID_FIELD(opno);
 667         READ_OID_FIELD(opfuncid);
 668         READ_OID_FIELD(opresulttype);
 669         READ_BOOL_FIELD(opretset);
 670         READ_OID_FIELD(opcollid);
 671         READ_OID_FIELD(inputcollid);
 672         READ_NODE_FIELD(args);
 673         READ_LOCATION_FIELD(location);
 674
 675         READ_DONE();
 676 }
 677
 678 /*
 679  * _readDistinctExpr
 680  */
 681 static DistinctExpr *
 682 _readDistinctExpr(void)
 683 {
 684         READ_LOCALS(DistinctExpr);
 685
 686         READ_OID_FIELD(opno);
 687         READ_OID_FIELD(opfuncid);
 688         READ_OID_FIELD(opresulttype);
 689         READ_BOOL_FIELD(opretset);
 690         READ_OID_FIELD(opcollid);
 691         READ_OID_FIELD(inputcollid);
 692         READ_NODE_FIELD(args);
 693         READ_LOCATION_FIELD(location);
 694
 695         READ_DONE();
 696 }
 697
 698 /*
 699  * _readNullIfExpr
 700  */
 701 static NullIfExpr *
 702 _readNullIfExpr(void)
 703 {
 704         READ_LOCALS(NullIfExpr);
 705
 706         READ_OID_FIELD(opno);
 707         READ_OID_FIELD(opfuncid);
 708         READ_OID_FIELD(opresulttype);
 709         READ_BOOL_FIELD(opretset);
 710         READ_OID_FIELD(opcollid);
 711         READ_OID_FIELD(inputcollid);
 712         READ_NODE_FIELD(args);
 713         READ_LOCATION_FIELD(location);
 714
 715         READ_DONE();
 716 }
 717
 718 /*
 719  * _readScalarArrayOpExpr
 720  */
 721 static ScalarArrayOpExpr *
 722 _readScalarArrayOpExpr(void)
 723 {
 724         READ_LOCALS(ScalarArrayOpExpr);
 725
 726         READ_OID_FIELD(opno);
 727         READ_OID_FIELD(opfuncid);
 728         READ_BOOL_FIELD(useOr);
 729         READ_OID_FIELD(inputcollid);
 730         READ_NODE_FIELD(args);
 731         READ_LOCATION_FIELD(location);
 732
 733         READ_DONE();
 734 }
 735
 736 /*
 737  * _readBoolExpr
 738  */
 739 static BoolExpr *
 740 _readBoolExpr(void)
 741 {
 742         READ_LOCALS(BoolExpr);
 743
 744         /* do-it-yourself enum representation */
 745         token = pg_strtok(&length); /* skip :boolop */
 746         token = pg_strtok(&length); /* get field value */
 747         if (strncmp(token, "and", 3) == 0)
 748                 local_node->boolop = AND_EXPR;
 749         else if (strncmp(token, "or", 2) == 0)
 750                 local_node->boolop = OR_EXPR;
 751         else if (strncmp(token, "not", 3) == 0)
 752                 local_node->boolop = NOT_EXPR;
 753         else
 754                 elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
 755
 756         READ_NODE_FIELD(args);
 757         READ_LOCATION_FIELD(location);
 758
 759         READ_DONE();
 760 }
 761
 762 /*
 763  * _readSubLink
 764  */
 765 static SubLink *
 766 _readSubLink(void)
 767 {
 768         READ_LOCALS(SubLink);
 769
 770         READ_ENUM_FIELD(subLinkType, SubLinkType);
 771         READ_INT_FIELD(subLinkId);
 772         READ_NODE_FIELD(testexpr);
 773         READ_NODE_FIELD(operName);
 774         READ_NODE_FIELD(subselect);
 775         READ_LOCATION_FIELD(location);
 776
 777         READ_DONE();
 778 }
 779
 780 /*
 781  * _readSubPlan is not needed since it doesn't appear in stored rules.
 782  */
 783
 784 /*
 785  * _readFieldSelect
 786  */
 787 static FieldSelect *
 788 _readFieldSelect(void)
 789 {
 790         READ_LOCALS(FieldSelect);
 791
 792         READ_NODE_FIELD(arg);
 793         READ_INT_FIELD(fieldnum);
 794         READ_OID_FIELD(resulttype);
 795         READ_INT_FIELD(resulttypmod);
 796         READ_OID_FIELD(resultcollid);
 797
 798         READ_DONE();
 799 }
 800
 801 /*
 802  * _readFieldStore
 803  */
 804 static FieldStore *
 805 _readFieldStore(void)
 806 {
 807         READ_LOCALS(FieldStore);
 808
 809         READ_NODE_FIELD(arg);
 810         READ_NODE_FIELD(newvals);
 811         READ_NODE_FIELD(fieldnums);
 812         READ_OID_FIELD(resulttype);
 813
 814         READ_DONE();
 815 }
 816
 817 /*
 818  * _readRelabelType
 819  */
 820 static RelabelType *
 821 _readRelabelType(void)
 822 {
 823         READ_LOCALS(RelabelType);
 824
 825         READ_NODE_FIELD(arg);
 826         READ_OID_FIELD(resulttype);
 827         READ_INT_FIELD(resulttypmod);
 828         READ_OID_FIELD(resultcollid);
 829         READ_ENUM_FIELD(relabelformat, CoercionForm);
 830         READ_LOCATION_FIELD(location);
 831
 832         READ_DONE();
 833 }
 834
 835 /*
 836  * _readCoerceViaIO
 837  */
 838 static CoerceViaIO *
 839 _readCoerceViaIO(void)
 840 {
 841         READ_LOCALS(CoerceViaIO);
 842
 843         READ_NODE_FIELD(arg);
 844         READ_OID_FIELD(resulttype);
 845         READ_OID_FIELD(resultcollid);
 846         READ_ENUM_FIELD(coerceformat, CoercionForm);
 847         READ_LOCATION_FIELD(location);
 848
 849         READ_DONE();
 850 }
 851
 852 /*
 853  * _readArrayCoerceExpr
 854  */
 855 static ArrayCoerceExpr *
 856 _readArrayCoerceExpr(void)
 857 {
 858         READ_LOCALS(ArrayCoerceExpr);
 859
 860         READ_NODE_FIELD(arg);
 861         READ_OID_FIELD(elemfuncid);
 862         READ_OID_FIELD(resulttype);
 863         READ_INT_FIELD(resulttypmod);
 864         READ_OID_FIELD(resultcollid);
 865         READ_BOOL_FIELD(isExplicit);
 866         READ_ENUM_FIELD(coerceformat, CoercionForm);
 867         READ_LOCATION_FIELD(location);
 868
 869         READ_DONE();
 870 }
 871
 872 /*
 873  * _readConvertRowtypeExpr
 874  */
 875 static ConvertRowtypeExpr *
 876 _readConvertRowtypeExpr(void)
 877 {
 878         READ_LOCALS(ConvertRowtypeExpr);
 879
 880         READ_NODE_FIELD(arg);
 881         READ_OID_FIELD(resulttype);
 882         READ_ENUM_FIELD(convertformat, CoercionForm);
 883         READ_LOCATION_FIELD(location);
 884
 885         READ_DONE();
 886 }
 887
 888 /*
 889  * _readCollateExpr
 890  */
 891 static CollateExpr *
 892 _readCollateExpr(void)
 893 {
 894         READ_LOCALS(CollateExpr);
 895
 896         READ_NODE_FIELD(arg);
 897         READ_OID_FIELD(collOid);
 898         READ_LOCATION_FIELD(location);
 899
 900         READ_DONE();
 901 }
 902
 903 /*
 904  * _readCaseExpr
 905  */
 906 static CaseExpr *
 907 _readCaseExpr(void)
 908 {
 909         READ_LOCALS(CaseExpr);
 910
 911         READ_OID_FIELD(casetype);
 912         READ_OID_FIELD(casecollid);
 913         READ_NODE_FIELD(arg);
 914         READ_NODE_FIELD(args);
 915         READ_NODE_FIELD(defresult);
 916         READ_LOCATION_FIELD(location);
 917
 918         READ_DONE();
 919 }
 920
 921 /*
 922  * _readCaseWhen
 923  */
 924 static CaseWhen *
 925 _readCaseWhen(void)
 926 {
 927         READ_LOCALS(CaseWhen);
 928
 929         READ_NODE_FIELD(expr);
 930         READ_NODE_FIELD(result);
 931         READ_LOCATION_FIELD(location);
 932
 933         READ_DONE();
 934 }
 935
 936 /*
 937  * _readCaseTestExpr
 938  */
 939 static CaseTestExpr *
 940 _readCaseTestExpr(void)
 941 {
 942         READ_LOCALS(CaseTestExpr);
 943
 944         READ_OID_FIELD(typeId);
 945         READ_INT_FIELD(typeMod);
 946         READ_OID_FIELD(collation);
 947
 948         READ_DONE();
 949 }
 950
 951 /*
 952  * _readArrayExpr
 953  */
 954 static ArrayExpr *
 955 _readArrayExpr(void)
 956 {
 957         READ_LOCALS(ArrayExpr);
 958
 959         READ_OID_FIELD(array_typeid);
 960         READ_OID_FIELD(array_collid);
 961         READ_OID_FIELD(element_typeid);
 962         READ_NODE_FIELD(elements);
 963         READ_BOOL_FIELD(multidims);
 964         READ_LOCATION_FIELD(location);
 965
 966         READ_DONE();
 967 }
 968
 969 /*
 970  * _readRowExpr
 971  */
 972 static RowExpr *
 973 _readRowExpr(void)
 974 {
 975         READ_LOCALS(RowExpr);
 976
 977         READ_NODE_FIELD(args);
 978         READ_OID_FIELD(row_typeid);
 979         READ_ENUM_FIELD(row_format, CoercionForm);
 980         READ_NODE_FIELD(colnames);
 981         READ_LOCATION_FIELD(location);
 982
 983         READ_DONE();
 984 }
 985
 986 /*
 987  * _readRowCompareExpr
 988  */
 989 static RowCompareExpr *
 990 _readRowCompareExpr(void)
 991 {
 992         READ_LOCALS(RowCompareExpr);
 993
 994         READ_ENUM_FIELD(rctype, RowCompareType);
 995         READ_NODE_FIELD(opnos);
 996         READ_NODE_FIELD(opfamilies);
 997         READ_NODE_FIELD(inputcollids);
 998         READ_NODE_FIELD(largs);
 999         READ_NODE_FIELD(rargs);
1000
1001         READ_DONE();
1002 }
1003
1004 /*
1005  * _readCoalesceExpr
1006  */
1007 static CoalesceExpr *
1008 _readCoalesceExpr(void)
1009 {
1010         READ_LOCALS(CoalesceExpr);
1011
1012         READ_OID_FIELD(coalescetype);
1013         READ_OID_FIELD(coalescecollid);
1014         READ_NODE_FIELD(args);
1015         READ_LOCATION_FIELD(location);
1016
1017         READ_DONE();
1018 }
1019
1020 /*
1021  * _readMinMaxExpr
1022  */
1023 static MinMaxExpr *
1024 _readMinMaxExpr(void)
1025 {
1026         READ_LOCALS(MinMaxExpr);
1027
1028         READ_OID_FIELD(minmaxtype);
1029         READ_OID_FIELD(minmaxcollid);
1030         READ_OID_FIELD(inputcollid);
1031         READ_ENUM_FIELD(op, MinMaxOp);
1032         READ_NODE_FIELD(args);
1033         READ_LOCATION_FIELD(location);
1034
1035         READ_DONE();
1036 }
1037
1038 /*
1039  * _readXmlExpr
1040  */
1041 static XmlExpr *
1042 _readXmlExpr(void)
1043 {
1044         READ_LOCALS(XmlExpr);
1045
1046         READ_ENUM_FIELD(op, XmlExprOp);
1047         READ_STRING_FIELD(name);
1048         READ_NODE_FIELD(named_args);
1049         READ_NODE_FIELD(arg_names);
1050         READ_NODE_FIELD(args);
1051         READ_ENUM_FIELD(xmloption, XmlOptionType);
1052         READ_OID_FIELD(type);
1053         READ_INT_FIELD(typmod);
1054         READ_LOCATION_FIELD(location);
1055
1056         READ_DONE();
1057 }
1058
1059 /*
1060  * _readNullTest
1061  */
1062 static NullTest *
1063 _readNullTest(void)
1064 {
1065         READ_LOCALS(NullTest);
1066
1067         READ_NODE_FIELD(arg);
1068         READ_ENUM_FIELD(nulltesttype, NullTestType);
1069         READ_BOOL_FIELD(argisrow);
1070         READ_LOCATION_FIELD(location);
1071
1072         READ_DONE();
1073 }
1074
1075 /*
1076  * _readBooleanTest
1077  */
1078 static BooleanTest *
1079 _readBooleanTest(void)
1080 {
1081         READ_LOCALS(BooleanTest);
1082
1083         READ_NODE_FIELD(arg);
1084         READ_ENUM_FIELD(booltesttype, BoolTestType);
1085         READ_LOCATION_FIELD(location);
1086
1087         READ_DONE();
1088 }
1089
1090 /*
1091  * _readCoerceToDomain
1092  */
1093 static CoerceToDomain *
1094 _readCoerceToDomain(void)
1095 {
1096         READ_LOCALS(CoerceToDomain);
1097
1098         READ_NODE_FIELD(arg);
1099         READ_OID_FIELD(resulttype);
1100         READ_INT_FIELD(resulttypmod);
1101         READ_OID_FIELD(resultcollid);
1102         READ_ENUM_FIELD(coercionformat, CoercionForm);
1103         READ_LOCATION_FIELD(location);
1104
1105         READ_DONE();
1106 }
1107
1108 /*
1109  * _readCoerceToDomainValue
1110  */
1111 static CoerceToDomainValue *
1112 _readCoerceToDomainValue(void)
1113 {
1114         READ_LOCALS(CoerceToDomainValue);
1115
1116         READ_OID_FIELD(typeId);
1117         READ_INT_FIELD(typeMod);
1118         READ_OID_FIELD(collation);
1119         READ_LOCATION_FIELD(location);
1120
1121         READ_DONE();
1122 }
1123
1124 /*
1125  * _readSetToDefault
1126  */
1127 static SetToDefault *
1128 _readSetToDefault(void)
1129 {
1130         READ_LOCALS(SetToDefault);
1131
1132         READ_OID_FIELD(typeId);
1133         READ_INT_FIELD(typeMod);
1134         READ_OID_FIELD(collation);
1135         READ_LOCATION_FIELD(location);
1136
1137         READ_DONE();
1138 }
1139
1140 /*
1141  * _readCurrentOfExpr
1142  */
1143 static CurrentOfExpr *
1144 _readCurrentOfExpr(void)
1145 {
1146         READ_LOCALS(CurrentOfExpr);
1147
1148         READ_UINT_FIELD(cvarno);
1149         READ_STRING_FIELD(cursor_name);
1150         READ_INT_FIELD(cursor_param);
1151
1152         READ_DONE();
1153 }
1154
1155 /*
1156  * _readInferenceElem
1157  */
1158 static InferenceElem *
1159 _readInferenceElem(void)
1160 {
1161         READ_LOCALS(InferenceElem);
1162
1163         READ_NODE_FIELD(expr);
1164         READ_OID_FIELD(infercollid);
1165         READ_OID_FIELD(inferopclass);
1166
1167         READ_DONE();
1168 }
1169
1170 /*
1171  * _readTargetEntry
1172  */
1173 static TargetEntry *
1174 _readTargetEntry(void)
1175 {
1176         READ_LOCALS(TargetEntry);
1177
1178         READ_NODE_FIELD(expr);
1179         READ_INT_FIELD(resno);
1180         READ_STRING_FIELD(resname);
1181         READ_UINT_FIELD(ressortgroupref);
1182         READ_OID_FIELD(resorigtbl);
1183         READ_INT_FIELD(resorigcol);
1184         READ_BOOL_FIELD(resjunk);
1185
1186         READ_DONE();
1187 }
1188
1189 /*
1190  * _readRangeTblRef
1191  */
1192 static RangeTblRef *
1193 _readRangeTblRef(void)
1194 {
1195         READ_LOCALS(RangeTblRef);
1196
1197         READ_INT_FIELD(rtindex);
1198
1199         READ_DONE();
1200 }
1201
1202 /*
1203  * _readJoinExpr
1204  */
1205 static JoinExpr *
1206 _readJoinExpr(void)
1207 {
1208         READ_LOCALS(JoinExpr);
1209
1210         READ_ENUM_FIELD(jointype, JoinType);
1211         READ_BOOL_FIELD(isNatural);
1212         READ_NODE_FIELD(larg);
1213         READ_NODE_FIELD(rarg);
1214         READ_NODE_FIELD(usingClause);
1215         READ_NODE_FIELD(quals);
1216         READ_NODE_FIELD(alias);
1217         READ_INT_FIELD(rtindex);
1218
1219         READ_DONE();
1220 }
1221
1222 /*
1223  * _readFromExpr
1224  */
1225 static FromExpr *
1226 _readFromExpr(void)
1227 {
1228         READ_LOCALS(FromExpr);
1229
1230         READ_NODE_FIELD(fromlist);
1231         READ_NODE_FIELD(quals);
1232
1233         READ_DONE();
1234 }
1235
1236 /*
1237  * _readOnConflictExpr
1238  */
1239 static OnConflictExpr *
1240 _readOnConflictExpr(void)
1241 {
1242         READ_LOCALS(OnConflictExpr);
1243
1244         READ_ENUM_FIELD(action, OnConflictAction);
1245         READ_NODE_FIELD(arbiterElems);
1246         READ_NODE_FIELD(arbiterWhere);
1247         READ_OID_FIELD(constraint);
1248         READ_NODE_FIELD(onConflictSet);
1249         READ_NODE_FIELD(onConflictWhere);
1250         READ_INT_FIELD(exclRelIndex);
1251         READ_NODE_FIELD(exclRelTlist);
1252
1253         READ_DONE();
1254 }
1255
1256 /*
1257  *      Stuff from parsenodes.h.
1258  */
1259
1260 /*
1261  * _readRangeTblEntry
1262  */
1263 static RangeTblEntry *
1264 _readRangeTblEntry(void)
1265 {
1266         READ_LOCALS(RangeTblEntry);
1267
1268         /* put alias + eref first to make dump more legible */
1269         READ_NODE_FIELD(alias);
1270         READ_NODE_FIELD(eref);
1271         READ_ENUM_FIELD(rtekind, RTEKind);
1272
1273         switch (local_node->rtekind)
1274         {
1275                 case RTE_RELATION:
1276                         READ_OID_FIELD(relid);
1277                         READ_CHAR_FIELD(relkind);
1278                         READ_NODE_FIELD(tablesample);
1279                         break;
1280                 case RTE_SUBQUERY:
1281                         READ_NODE_FIELD(subquery);
1282                         READ_BOOL_FIELD(security_barrier);
1283                         break;
1284                 case RTE_JOIN:
1285                         READ_ENUM_FIELD(jointype, JoinType);
1286                         READ_NODE_FIELD(joinaliasvars);
1287                         break;
1288                 case RTE_FUNCTION:
1289                         READ_NODE_FIELD(functions);
1290                         READ_BOOL_FIELD(funcordinality);
1291                         break;
1292                 case RTE_VALUES:
1293                         READ_NODE_FIELD(values_lists);
1294                         READ_NODE_FIELD(values_collations);
1295                         break;
1296                 case RTE_CTE:
1297                         READ_STRING_FIELD(ctename);
1298                         READ_UINT_FIELD(ctelevelsup);
1299                         READ_BOOL_FIELD(self_reference);
1300                         READ_NODE_FIELD(ctecoltypes);
1301                         READ_NODE_FIELD(ctecoltypmods);
1302                         READ_NODE_FIELD(ctecolcollations);
1303                         break;
1304                 default:
1305                         elog(ERROR, "unrecognized RTE kind: %d",
1306                                  (int) local_node->rtekind);
1307                         break;
1308         }
1309
1310         READ_BOOL_FIELD(lateral);
1311         READ_BOOL_FIELD(inh);
1312         READ_BOOL_FIELD(inFromCl);
1313         READ_UINT_FIELD(requiredPerms);
1314         READ_OID_FIELD(checkAsUser);
1315         READ_BITMAPSET_FIELD(selectedCols);
1316         READ_BITMAPSET_FIELD(insertedCols);
1317         READ_BITMAPSET_FIELD(updatedCols);
1318         READ_NODE_FIELD(securityQuals);
1319
1320         READ_DONE();
1321 }
1322
1323 /*
1324  * _readRangeTblFunction
1325  */
1326 static RangeTblFunction *
1327 _readRangeTblFunction(void)
1328 {
1329         READ_LOCALS(RangeTblFunction);
1330
1331         READ_NODE_FIELD(funcexpr);
1332         READ_INT_FIELD(funccolcount);
1333         READ_NODE_FIELD(funccolnames);
1334         READ_NODE_FIELD(funccoltypes);
1335         READ_NODE_FIELD(funccoltypmods);
1336         READ_NODE_FIELD(funccolcollations);
1337         READ_BITMAPSET_FIELD(funcparams);
1338
1339         READ_DONE();
1340 }
1341
1342 /*
1343  * _readTableSampleClause
1344  */
1345 static TableSampleClause *
1346 _readTableSampleClause(void)
1347 {
1348         READ_LOCALS(TableSampleClause);
1349
1350         READ_OID_FIELD(tsmhandler);
1351         READ_NODE_FIELD(args);
1352         READ_NODE_FIELD(repeatable);
1353
1354         READ_DONE();
1355 }
1356
1357 /*
1358  * _readDefElem
1359  */
1360 static DefElem *
1361 _readDefElem(void)
1362 {
1363         READ_LOCALS(DefElem);
1364
1365         READ_STRING_FIELD(defnamespace);
1366         READ_STRING_FIELD(defname);
1367         READ_NODE_FIELD(arg);
1368         READ_ENUM_FIELD(defaction, DefElemAction);
1369
1370         READ_DONE();
1371 }
1372
1373 /*
1374  * _readPlannedStmt
1375  */
1376 static PlannedStmt *
1377 _readPlannedStmt(void)
1378 {
1379         READ_LOCALS(PlannedStmt);
1380
1381         READ_ENUM_FIELD(commandType, CmdType);
1382         READ_UINT_FIELD(queryId);
1383         READ_BOOL_FIELD(hasReturning);
1384         READ_BOOL_FIELD(hasModifyingCTE);
1385         READ_BOOL_FIELD(canSetTag);
1386         READ_BOOL_FIELD(transientPlan);
1387         READ_NODE_FIELD(planTree);
1388         READ_NODE_FIELD(rtable);
1389         READ_NODE_FIELD(resultRelations);
1390         READ_NODE_FIELD(utilityStmt);
1391         READ_NODE_FIELD(subplans);
1392         READ_BITMAPSET_FIELD(rewindPlanIDs);
1393         READ_NODE_FIELD(rowMarks);
1394         READ_NODE_FIELD(relationOids);
1395         READ_NODE_FIELD(invalItems);
1396         READ_INT_FIELD(nParamExec);
1397         READ_BOOL_FIELD(hasRowSecurity);
1398         READ_BOOL_FIELD(parallelModeNeeded);
1399
1400         READ_DONE();
1401 }
1402
1403 /*
1404  * ReadCommonPlan
1405  *      Assign the basic stuff of all nodes that inherit from Plan
1406  */
1407 static void
1408 ReadCommonPlan(Plan *local_node)
1409 {
1410         READ_TEMP_LOCALS();
1411
1412         READ_FLOAT_FIELD(startup_cost);
1413         READ_FLOAT_FIELD(total_cost);
1414         READ_FLOAT_FIELD(plan_rows);
1415         READ_INT_FIELD(plan_width);
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_BITMAPSET_FIELD(fs_relids);
1803         READ_BOOL_FIELD(fsSystemCol);
1804
1805         READ_DONE();
1806 }
1807
1808 /*
1809  * ReadCommonJoin
1810  *      Assign the basic stuff of all nodes that inherit from Join
1811  */
1812 static void
1813 ReadCommonJoin(Join *local_node)
1814 {
1815         READ_TEMP_LOCALS();
1816
1817         ReadCommonPlan(&local_node->plan);
1818
1819         READ_ENUM_FIELD(jointype, JoinType);
1820         READ_NODE_FIELD(joinqual);
1821 }
1822
1823 /*
1824  * _readJoin
1825  */
1826 static Join *
1827 _readJoin(void)
1828 {
1829         READ_LOCALS_NO_FIELDS(Join);
1830
1831         ReadCommonJoin(local_node);
1832
1833         READ_DONE();
1834 }
1835
1836 /*
1837  * _readNestLoop
1838  */
1839 static NestLoop *
1840 _readNestLoop(void)
1841 {
1842         READ_LOCALS(NestLoop);
1843
1844         ReadCommonJoin(&local_node->join);
1845
1846         READ_NODE_FIELD(nestParams);
1847
1848         READ_DONE();
1849 }
1850
1851 /*
1852  * _readMergeJoin
1853  */
1854 static MergeJoin *
1855 _readMergeJoin(void)
1856 {
1857         int                     numCols;
1858
1859         READ_LOCALS(MergeJoin);
1860
1861         ReadCommonJoin(&local_node->join);
1862
1863         READ_NODE_FIELD(mergeclauses);
1864
1865         numCols = list_length(local_node->mergeclauses);
1866
1867         READ_OID_ARRAY(mergeFamilies, numCols);
1868         READ_OID_ARRAY(mergeCollations, numCols);
1869         READ_INT_ARRAY(mergeStrategies, numCols);
1870         READ_BOOL_ARRAY(mergeNullsFirst, numCols);
1871
1872         READ_DONE();
1873 }
1874
1875 /*
1876  * _readHashJoin
1877  */
1878 static HashJoin *
1879 _readHashJoin(void)
1880 {
1881         READ_LOCALS(HashJoin);
1882
1883         ReadCommonJoin(&local_node->join);
1884
1885         READ_NODE_FIELD(hashclauses);
1886
1887         READ_DONE();
1888 }
1889
1890 /*
1891  * _readMaterial
1892  */
1893 static Material *
1894 _readMaterial(void)
1895 {
1896         READ_LOCALS_NO_FIELDS(Material);
1897
1898         ReadCommonPlan(&local_node->plan);
1899
1900         READ_DONE();
1901 }
1902
1903 /*
1904  * _readSort
1905  */
1906 static Sort *
1907 _readSort(void)
1908 {
1909         READ_LOCALS(Sort);
1910
1911         ReadCommonPlan(&local_node->plan);
1912
1913         READ_INT_FIELD(numCols);
1914         READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
1915         READ_OID_ARRAY(sortOperators, local_node->numCols);
1916         READ_OID_ARRAY(collations, local_node->numCols);
1917         READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
1918
1919         READ_DONE();
1920 }
1921
1922 /*
1923  * _readGroup
1924  */
1925 static Group *
1926 _readGroup(void)
1927 {
1928         READ_LOCALS(Group);
1929
1930         ReadCommonPlan(&local_node->plan);
1931
1932         READ_INT_FIELD(numCols);
1933         READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
1934         READ_OID_ARRAY(grpOperators, local_node->numCols);
1935
1936         READ_DONE();
1937 }
1938
1939 /*
1940  * _readAgg
1941  */
1942 static Agg *
1943 _readAgg(void)
1944 {
1945         READ_LOCALS(Agg);
1946
1947         ReadCommonPlan(&local_node->plan);
1948
1949         READ_ENUM_FIELD(aggstrategy, AggStrategy);
1950         READ_INT_FIELD(numCols);
1951         READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
1952         READ_OID_ARRAY(grpOperators, local_node->numCols);
1953         READ_LONG_FIELD(numGroups);
1954         READ_NODE_FIELD(groupingSets);
1955         READ_NODE_FIELD(chain);
1956
1957         READ_DONE();
1958 }
1959
1960 /*
1961  * _readWindowAgg
1962  */
1963 static WindowAgg *
1964 _readWindowAgg(void)
1965 {
1966         READ_LOCALS(WindowAgg);
1967
1968         ReadCommonPlan(&local_node->plan);
1969
1970         READ_UINT_FIELD(winref);
1971         READ_INT_FIELD(partNumCols);
1972         READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
1973         READ_OID_ARRAY(partOperators, local_node->partNumCols);
1974         READ_INT_FIELD(ordNumCols);
1975         READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
1976         READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
1977         READ_INT_FIELD(frameOptions);
1978         READ_NODE_FIELD(startOffset);
1979         READ_NODE_FIELD(endOffset);
1980
1981         READ_DONE();
1982 }
1983
1984 /*
1985  * _readUnique
1986  */
1987 static Unique *
1988 _readUnique(void)
1989 {
1990         READ_LOCALS(Unique);
1991
1992         ReadCommonPlan(&local_node->plan);
1993
1994         READ_INT_FIELD(numCols);
1995         READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
1996         READ_OID_ARRAY(uniqOperators, local_node->numCols);
1997
1998         READ_DONE();
1999 }
2000
2001 /*
2002  * _readHash
2003  */
2004 static Hash *
2005 _readHash(void)
2006 {
2007         READ_LOCALS(Hash);
2008
2009         ReadCommonPlan(&local_node->plan);
2010
2011         READ_OID_FIELD(skewTable);
2012         READ_INT_FIELD(skewColumn);
2013         READ_BOOL_FIELD(skewInherit);
2014         READ_OID_FIELD(skewColType);
2015         READ_INT_FIELD(skewColTypmod);
2016
2017         READ_DONE();
2018 }
2019
2020 /*
2021  * _readSetOp
2022  */
2023 static SetOp *
2024 _readSetOp(void)
2025 {
2026         READ_LOCALS(SetOp);
2027
2028         ReadCommonPlan(&local_node->plan);
2029
2030         READ_ENUM_FIELD(cmd, SetOpCmd);
2031         READ_ENUM_FIELD(strategy, SetOpStrategy);
2032         READ_INT_FIELD(numCols);
2033         READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
2034         READ_OID_ARRAY(dupOperators, local_node->numCols);
2035         READ_INT_FIELD(flagColIdx);
2036         READ_INT_FIELD(firstFlag);
2037         READ_LONG_FIELD(numGroups);
2038
2039         READ_DONE();
2040 }
2041
2042 /*
2043  * _readLockRows
2044  */
2045 static LockRows *
2046 _readLockRows(void)
2047 {
2048         READ_LOCALS(LockRows);
2049
2050         ReadCommonPlan(&local_node->plan);
2051
2052         READ_NODE_FIELD(rowMarks);
2053         READ_INT_FIELD(epqParam);
2054
2055         READ_DONE();
2056 }
2057
2058 /*
2059  * _readLimit
2060  */
2061 static Limit *
2062 _readLimit(void)
2063 {
2064         READ_LOCALS(Limit);
2065
2066         ReadCommonPlan(&local_node->plan);
2067
2068         READ_NODE_FIELD(limitOffset);
2069         READ_NODE_FIELD(limitCount);
2070
2071         READ_DONE();
2072 }
2073
2074 /*
2075  * _readNestLoopParam
2076  */
2077 static NestLoopParam *
2078 _readNestLoopParam(void)
2079 {
2080         READ_LOCALS(NestLoopParam);
2081
2082         READ_INT_FIELD(paramno);
2083         READ_NODE_FIELD(paramval);
2084
2085         READ_DONE();
2086 }
2087
2088 /*
2089  * _readPlanRowMark
2090  */
2091 static PlanRowMark *
2092 _readPlanRowMark(void)
2093 {
2094         READ_LOCALS(PlanRowMark);
2095
2096         READ_UINT_FIELD(rti);
2097         READ_UINT_FIELD(prti);
2098         READ_UINT_FIELD(rowmarkId);
2099         READ_ENUM_FIELD(markType, RowMarkType);
2100         READ_INT_FIELD(allMarkTypes);
2101         READ_ENUM_FIELD(strength, LockClauseStrength);
2102         READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
2103         READ_BOOL_FIELD(isParent);
2104
2105         READ_DONE();
2106 }
2107
2108 /*
2109  * _readPlanInvalItem
2110  */
2111 static PlanInvalItem *
2112 _readPlanInvalItem(void)
2113 {
2114         READ_LOCALS(PlanInvalItem);
2115
2116         READ_INT_FIELD(cacheId);
2117         READ_UINT_FIELD(hashValue);
2118
2119         READ_DONE();
2120 }
2121
2122 /*
2123  * _readSubPlan
2124  */
2125 static SubPlan *
2126 _readSubPlan(void)
2127 {
2128         READ_LOCALS(SubPlan);
2129
2130         READ_ENUM_FIELD(subLinkType, SubLinkType);
2131         READ_NODE_FIELD(testexpr);
2132         READ_NODE_FIELD(paramIds);
2133         READ_INT_FIELD(plan_id);
2134         READ_STRING_FIELD(plan_name);
2135         READ_OID_FIELD(firstColType);
2136         READ_INT_FIELD(firstColTypmod);
2137         READ_OID_FIELD(firstColCollation);
2138         READ_BOOL_FIELD(useHashTable);
2139         READ_BOOL_FIELD(unknownEqFalse);
2140         READ_NODE_FIELD(setParam);
2141         READ_NODE_FIELD(parParam);
2142         READ_NODE_FIELD(args);
2143         READ_FLOAT_FIELD(startup_cost);
2144         READ_FLOAT_FIELD(per_call_cost);
2145
2146         READ_DONE();
2147 }
2148
2149 /*
2150  * _readAlternativeSubPlan
2151  */
2152 static AlternativeSubPlan *
2153 _readAlternativeSubPlan(void)
2154 {
2155         READ_LOCALS(AlternativeSubPlan);
2156
2157         READ_NODE_FIELD(subplans);
2158
2159         READ_DONE();
2160 }
2161
2162 /*
2163  * parseNodeString
2164  *
2165  * Given a character string representing a node tree, parseNodeString creates
2166  * the internal node structure.
2167  *
2168  * The string to be read must already have been loaded into pg_strtok().
2169  */
2170 Node *
2171 parseNodeString(void)
2172 {
2173         void       *return_value;
2174
2175         READ_TEMP_LOCALS();
2176
2177         token = pg_strtok(&length);
2178
2179 #define MATCH(tokname, namelen) \
2180         (length == namelen && memcmp(token, tokname, namelen) == 0)
2181
2182         if (MATCH("QUERY", 5))
2183                 return_value = _readQuery();
2184         else if (MATCH("WITHCHECKOPTION", 15))
2185                 return_value = _readWithCheckOption();
2186         else if (MATCH("SORTGROUPCLAUSE", 15))
2187                 return_value = _readSortGroupClause();
2188         else if (MATCH("GROUPINGSET", 11))
2189                 return_value = _readGroupingSet();
2190         else if (MATCH("WINDOWCLAUSE", 12))
2191                 return_value = _readWindowClause();
2192         else if (MATCH("ROWMARKCLAUSE", 13))
2193                 return_value = _readRowMarkClause();
2194         else if (MATCH("COMMONTABLEEXPR", 15))
2195                 return_value = _readCommonTableExpr();
2196         else if (MATCH("SETOPERATIONSTMT", 16))
2197                 return_value = _readSetOperationStmt();
2198         else if (MATCH("ALIAS", 5))
2199                 return_value = _readAlias();
2200         else if (MATCH("RANGEVAR", 8))
2201                 return_value = _readRangeVar();
2202         else if (MATCH("INTOCLAUSE", 10))
2203                 return_value = _readIntoClause();
2204         else if (MATCH("VAR", 3))
2205                 return_value = _readVar();
2206         else if (MATCH("CONST", 5))
2207                 return_value = _readConst();
2208         else if (MATCH("PARAM", 5))
2209                 return_value = _readParam();
2210         else if (MATCH("AGGREF", 6))
2211                 return_value = _readAggref();
2212         else if (MATCH("GROUPINGFUNC", 12))
2213                 return_value = _readGroupingFunc();
2214         else if (MATCH("WINDOWFUNC", 10))
2215                 return_value = _readWindowFunc();
2216         else if (MATCH("ARRAYREF", 8))
2217                 return_value = _readArrayRef();
2218         else if (MATCH("FUNCEXPR", 8))
2219                 return_value = _readFuncExpr();
2220         else if (MATCH("NAMEDARGEXPR", 12))
2221                 return_value = _readNamedArgExpr();
2222         else if (MATCH("OPEXPR", 6))
2223                 return_value = _readOpExpr();
2224         else if (MATCH("DISTINCTEXPR", 12))
2225                 return_value = _readDistinctExpr();
2226         else if (MATCH("NULLIFEXPR", 10))
2227                 return_value = _readNullIfExpr();
2228         else if (MATCH("SCALARARRAYOPEXPR", 17))
2229                 return_value = _readScalarArrayOpExpr();
2230         else if (MATCH("BOOLEXPR", 8))
2231                 return_value = _readBoolExpr();
2232         else if (MATCH("SUBLINK", 7))
2233                 return_value = _readSubLink();
2234         else if (MATCH("FIELDSELECT", 11))
2235                 return_value = _readFieldSelect();
2236         else if (MATCH("FIELDSTORE", 10))
2237                 return_value = _readFieldStore();
2238         else if (MATCH("RELABELTYPE", 11))
2239                 return_value = _readRelabelType();
2240         else if (MATCH("COERCEVIAIO", 11))
2241                 return_value = _readCoerceViaIO();
2242         else if (MATCH("ARRAYCOERCEEXPR", 15))
2243                 return_value = _readArrayCoerceExpr();
2244         else if (MATCH("CONVERTROWTYPEEXPR", 18))
2245                 return_value = _readConvertRowtypeExpr();
2246         else if (MATCH("COLLATE", 7))
2247                 return_value = _readCollateExpr();
2248         else if (MATCH("CASE", 4))
2249                 return_value = _readCaseExpr();
2250         else if (MATCH("WHEN", 4))
2251                 return_value = _readCaseWhen();
2252         else if (MATCH("CASETESTEXPR", 12))
2253                 return_value = _readCaseTestExpr();
2254         else if (MATCH("ARRAY", 5))
2255                 return_value = _readArrayExpr();
2256         else if (MATCH("ROW", 3))
2257                 return_value = _readRowExpr();
2258         else if (MATCH("ROWCOMPARE", 10))
2259                 return_value = _readRowCompareExpr();
2260         else if (MATCH("COALESCE", 8))
2261                 return_value = _readCoalesceExpr();
2262         else if (MATCH("MINMAX", 6))
2263                 return_value = _readMinMaxExpr();
2264         else if (MATCH("XMLEXPR", 7))
2265                 return_value = _readXmlExpr();
2266         else if (MATCH("NULLTEST", 8))
2267                 return_value = _readNullTest();
2268         else if (MATCH("BOOLEANTEST", 11))
2269                 return_value = _readBooleanTest();
2270         else if (MATCH("COERCETODOMAIN", 14))
2271                 return_value = _readCoerceToDomain();
2272         else if (MATCH("COERCETODOMAINVALUE", 19))
2273                 return_value = _readCoerceToDomainValue();
2274         else if (MATCH("SETTODEFAULT", 12))
2275                 return_value = _readSetToDefault();
2276         else if (MATCH("CURRENTOFEXPR", 13))
2277                 return_value = _readCurrentOfExpr();
2278         else if (MATCH("INFERENCEELEM", 13))
2279                 return_value = _readInferenceElem();
2280         else if (MATCH("TARGETENTRY", 11))
2281                 return_value = _readTargetEntry();
2282         else if (MATCH("RANGETBLREF", 11))
2283                 return_value = _readRangeTblRef();
2284         else if (MATCH("JOINEXPR", 8))
2285                 return_value = _readJoinExpr();
2286         else if (MATCH("FROMEXPR", 8))
2287                 return_value = _readFromExpr();
2288         else if (MATCH("ONCONFLICTEXPR", 14))
2289                 return_value = _readOnConflictExpr();
2290         else if (MATCH("RTE", 3))
2291                 return_value = _readRangeTblEntry();
2292         else if (MATCH("RANGETBLFUNCTION", 16))
2293                 return_value = _readRangeTblFunction();
2294         else if (MATCH("TABLESAMPLECLAUSE", 17))
2295                 return_value = _readTableSampleClause();
2296         else if (MATCH("NOTIFY", 6))
2297                 return_value = _readNotifyStmt();
2298         else if (MATCH("DEFELEM", 7))
2299                 return_value = _readDefElem();
2300         else if (MATCH("DECLARECURSOR", 13))
2301                 return_value = _readDeclareCursorStmt();
2302         else if (MATCH("PLANNEDSTMT", 11))
2303                 return_value = _readPlannedStmt();
2304         else if (MATCH("PLAN", 4))
2305                 return_value = _readPlan();
2306         else if (MATCH("RESULT", 6))
2307                 return_value = _readResult();
2308         else if (MATCH("MODIFYTABLE", 11))
2309                 return_value = _readModifyTable();
2310         else if (MATCH("APPEND", 6))
2311                 return_value = _readAppend();
2312         else if (MATCH("MERGEAPPEND", 11))
2313                 return_value = _readMergeAppend();
2314         else if (MATCH("RECURSIVEUNION", 14))
2315                 return_value = _readRecursiveUnion();
2316         else if (MATCH("BITMAPAND", 9))
2317                 return_value = _readBitmapAnd();
2318         else if (MATCH("BITMAPOR", 8))
2319                 return_value = _readBitmapOr();
2320         else if (MATCH("SCAN", 4))
2321                 return_value = _readScan();
2322         else if (MATCH("SEQSCAN", 7))
2323                 return_value = _readSeqScan();
2324         else if (MATCH("SAMPLESCAN", 10))
2325                 return_value = _readSampleScan();
2326         else if (MATCH("INDEXSCAN", 9))
2327                 return_value = _readIndexScan();
2328         else if (MATCH("INDEXONLYSCAN", 13))
2329                 return_value = _readIndexOnlyScan();
2330         else if (MATCH("BITMAPINDEXSCAN", 15))
2331                 return_value = _readBitmapIndexScan();
2332         else if (MATCH("BITMAPHEAPSCAN", 14))
2333                 return_value = _readBitmapHeapScan();
2334         else if (MATCH("TIDSCAN", 7))
2335                 return_value = _readTidScan();
2336         else if (MATCH("SUBQUERYSCAN", 12))
2337                 return_value = _readSubqueryScan();
2338         else if (MATCH("FUNCTIONSCAN", 12))
2339                 return_value = _readFunctionScan();
2340         else if (MATCH("VALUESSCAN", 10))
2341                 return_value = _readValuesScan();
2342         else if (MATCH("CTESCAN", 7))
2343                 return_value = _readCteScan();
2344         else if (MATCH("WORKTABLESCAN", 13))
2345                 return_value = _readWorkTableScan();
2346         else if (MATCH("FOREIGNSCAN", 11))
2347                 return_value = _readForeignScan();
2348         else if (MATCH("JOIN", 4))
2349                 return_value = _readJoin();
2350         else if (MATCH("NESTLOOP", 8))
2351                 return_value = _readNestLoop();
2352         else if (MATCH("MERGEJOIN", 9))
2353                 return_value = _readMergeJoin();
2354         else if (MATCH("HASHJOIN", 8))
2355                 return_value = _readHashJoin();
2356         else if (MATCH("MATERIAL", 8))
2357                 return_value = _readMaterial();
2358         else if (MATCH("SORT", 4))
2359                 return_value = _readSort();
2360         else if (MATCH("GROUP", 5))
2361                 return_value = _readGroup();
2362         else if (MATCH("AGG", 3))
2363                 return_value = _readAgg();
2364         else if (MATCH("WINDOWAGG", 9))
2365                 return_value = _readWindowAgg();
2366         else if (MATCH("UNIQUE", 6))
2367                 return_value = _readUnique();
2368         else if (MATCH("HASH", 4))
2369                 return_value = _readHash();
2370         else if (MATCH("SETOP", 5))
2371                 return_value = _readSetOp();
2372         else if (MATCH("LOCKROWS", 8))
2373                 return_value = _readLockRows();
2374         else if (MATCH("LIMIT", 5))
2375                 return_value = _readLimit();
2376         else if (MATCH("NESTLOOPPARAM", 13))
2377                 return_value = _readNestLoopParam();
2378         else if (MATCH("PLANROWMARK", 11))
2379                 return_value = _readPlanRowMark();
2380         else if (MATCH("PLANINVALITEM", 13))
2381                 return_value = _readPlanInvalItem();
2382         else if (MATCH("SUBPLAN", 7))
2383                 return_value = _readSubPlan();
2384         else if (MATCH("ALTERNATIVESUBPLAN", 18))
2385                 return_value = _readAlternativeSubPlan();
2386         else
2387         {
2388                 elog(ERROR, "badly formatted node string \"%.32s\"...", token);
2389                 return_value = NULL;    /* keep compiler quiet */
2390         }
2391
2392         return (Node *) return_value;
2393 }
2394
2395
2396 /*
2397  * readDatum
2398  *
2399  * Given a string representation of a constant, recreate the appropriate
2400  * Datum.  The string representation embeds length info, but not byValue,
2401  * so we must be told that.
2402  */
2403 static Datum
2404 readDatum(bool typbyval)
2405 {
2406         Size            length,
2407                                 i;
2408         int                     tokenLength;
2409         char       *token;
2410         Datum           res;
2411         char       *s;
2412
2413         /*
2414          * read the actual length of the value
2415          */
2416         token = pg_strtok(&tokenLength);
2417         length = atoui(token);
2418
2419         token = pg_strtok(&tokenLength);        /* read the '[' */
2420         if (token == NULL || token[0] != '[')
2421                 elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
2422                          token ? (const char *) token : "[NULL]", length);
2423
2424         if (typbyval)
2425         {
2426                 if (length > (Size) sizeof(Datum))
2427                         elog(ERROR, "byval datum but length = %zu", length);
2428                 res = (Datum) 0;
2429                 s = (char *) (&res);
2430                 for (i = 0; i < (Size) sizeof(Datum); i++)
2431                 {
2432                         token = pg_strtok(&tokenLength);
2433                         s[i] = (char) atoi(token);
2434                 }
2435         }
2436         else if (length <= 0)
2437                 res = (Datum) NULL;
2438         else
2439         {
2440                 s = (char *) palloc(length);
2441                 for (i = 0; i < length; i++)
2442                 {
2443                         token = pg_strtok(&tokenLength);
2444                         s[i] = (char) atoi(token);
2445                 }
2446                 res = PointerGetDatum(s);
2447         }
2448
2449         token = pg_strtok(&tokenLength);        /* read the ']' */
2450         if (token == NULL || token[0] != ']')
2451                 elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
2452                          token ? (const char *) token : "[NULL]", length);
2453
2454         return res;
2455 }
2456
2457 /*
2458  * readAttrNumberCols
2459  */
2460 static AttrNumber *
2461 readAttrNumberCols(int numCols)
2462 {
2463         int                     tokenLength,
2464                                 i;
2465         char       *token;
2466         AttrNumber *attr_vals;
2467
2468         if (numCols <= 0)
2469                 return NULL;
2470
2471         attr_vals = (AttrNumber *) palloc(numCols * sizeof(AttrNumber));
2472         for (i = 0; i < numCols; i++)
2473         {
2474                 token = pg_strtok(&tokenLength);
2475                 attr_vals[i] = atoi(token);
2476         }
2477
2478         return attr_vals;
2479 }
2480
2481 /*
2482  * readOidCols
2483  */
2484 static Oid *
2485 readOidCols(int numCols)
2486 {
2487         int                     tokenLength,
2488                                 i;
2489         char       *token;
2490         Oid                *oid_vals;
2491
2492         if (numCols <= 0)
2493                 return NULL;
2494
2495         oid_vals = (Oid *) palloc(numCols * sizeof(Oid));
2496         for (i = 0; i < numCols; i++)
2497         {
2498                 token = pg_strtok(&tokenLength);
2499                 oid_vals[i] = atooid(token);
2500         }
2501
2502         return oid_vals;
2503 }
2504
2505 /*
2506  * readIntCols
2507  */
2508 static int *
2509 readIntCols(int numCols)
2510 {
2511         int                     tokenLength,
2512                                 i;
2513         char       *token;
2514         int                *int_vals;
2515
2516         if (numCols <= 0)
2517                 return NULL;
2518
2519         int_vals = (int *) palloc(numCols * sizeof(int));
2520         for (i = 0; i < numCols; i++)
2521         {
2522                 token = pg_strtok(&tokenLength);
2523                 int_vals[i] = atoi(token);
2524         }
2525
2526         return int_vals;
2527 }
2528
2529 /*
2530  * readBoolCols
2531  */
2532 static bool *
2533 readBoolCols(int numCols)
2534 {
2535         int                     tokenLength,
2536                                 i;
2537         char       *token;
2538         bool       *bool_vals;
2539
2540         if (numCols <= 0)
2541                 return NULL;
2542
2543         bool_vals = (bool *) palloc(numCols * sizeof(bool));
2544         for (i = 0; i < numCols; i++)
2545         {
2546                 token = pg_strtok(&tokenLength);
2547                 bool_vals[i] = strtobool(token);
2548         }
2549
2550         return bool_vals;
2551 }