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_NODE_FIELD(targetlist);
1417         READ_NODE_FIELD(qual);
1418         READ_NODE_FIELD(lefttree);
1419         READ_NODE_FIELD(righttree);
1420         READ_NODE_FIELD(initPlan);
1421         READ_BITMAPSET_FIELD(extParam);
1422         READ_BITMAPSET_FIELD(allParam);
1423 }
1424
1425 /*
1426  * _readPlan
1427  */
1428 static Plan *
1429 _readPlan(void)
1430 {
1431         READ_LOCALS_NO_FIELDS(Plan);
1432
1433         ReadCommonPlan(local_node);
1434
1435         READ_DONE();
1436 }
1437
1438 /*
1439  * _readResult
1440  */
1441 static Result *
1442 _readResult(void)
1443 {
1444         READ_LOCALS(Result);
1445
1446         ReadCommonPlan(&local_node->plan);
1447
1448         READ_NODE_FIELD(resconstantqual);
1449
1450         READ_DONE();
1451 }
1452
1453 /*
1454  * _readModifyTable
1455  */
1456 static ModifyTable *
1457 _readModifyTable(void)
1458 {
1459         READ_LOCALS(ModifyTable);
1460
1461         ReadCommonPlan(&local_node->plan);
1462
1463         READ_ENUM_FIELD(operation, CmdType);
1464         READ_BOOL_FIELD(canSetTag);
1465         READ_UINT_FIELD(nominalRelation);
1466         READ_NODE_FIELD(resultRelations);
1467         READ_INT_FIELD(resultRelIndex);
1468         READ_NODE_FIELD(plans);
1469         READ_NODE_FIELD(withCheckOptionLists);
1470         READ_NODE_FIELD(returningLists);
1471         READ_NODE_FIELD(fdwPrivLists);
1472         READ_NODE_FIELD(rowMarks);
1473         READ_INT_FIELD(epqParam);
1474         READ_ENUM_FIELD(onConflictAction, OnConflictAction);
1475         READ_NODE_FIELD(arbiterIndexes);
1476         READ_NODE_FIELD(onConflictSet);
1477         READ_NODE_FIELD(onConflictWhere);
1478         READ_UINT_FIELD(exclRelRTI);
1479         READ_NODE_FIELD(exclRelTlist);
1480
1481         READ_DONE();
1482 }
1483
1484 /*
1485  * _readAppend
1486  */
1487 static Append *
1488 _readAppend(void)
1489 {
1490         READ_LOCALS(Append);
1491
1492         ReadCommonPlan(&local_node->plan);
1493
1494         READ_NODE_FIELD(appendplans);
1495
1496         READ_DONE();
1497 }
1498
1499 /*
1500  * _readMergeAppend
1501  */
1502 static MergeAppend *
1503 _readMergeAppend(void)
1504 {
1505         READ_LOCALS(MergeAppend);
1506
1507         ReadCommonPlan(&local_node->plan);
1508
1509         READ_NODE_FIELD(mergeplans);
1510         READ_INT_FIELD(numCols);
1511         READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
1512         READ_OID_ARRAY(sortOperators, local_node->numCols);
1513         READ_OID_ARRAY(collations, local_node->numCols);
1514         READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
1515
1516         READ_DONE();
1517 }
1518
1519 /*
1520  * _readRecursiveUnion
1521  */
1522 static RecursiveUnion *
1523 _readRecursiveUnion(void)
1524 {
1525         READ_LOCALS(RecursiveUnion);
1526
1527         ReadCommonPlan(&local_node->plan);
1528
1529         READ_INT_FIELD(wtParam);
1530         READ_INT_FIELD(numCols);
1531         READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
1532         READ_OID_ARRAY(dupOperators, local_node->numCols);
1533         READ_LONG_FIELD(numGroups);
1534
1535         READ_DONE();
1536 }
1537
1538 /*
1539  * _readBitmapAnd
1540  */
1541 static BitmapAnd *
1542 _readBitmapAnd(void)
1543 {
1544         READ_LOCALS(BitmapAnd);
1545
1546         ReadCommonPlan(&local_node->plan);
1547
1548         READ_NODE_FIELD(bitmapplans);
1549
1550         READ_DONE();
1551 }
1552
1553 /*
1554  * _readBitmapOr
1555  */
1556 static BitmapOr *
1557 _readBitmapOr(void)
1558 {
1559         READ_LOCALS(BitmapOr);
1560
1561         ReadCommonPlan(&local_node->plan);
1562
1563         READ_NODE_FIELD(bitmapplans);
1564
1565         READ_DONE();
1566 }
1567
1568 /*
1569  * ReadCommonScan
1570  *      Assign the basic stuff of all nodes that inherit from Scan
1571  */
1572 static void
1573 ReadCommonScan(Scan *local_node)
1574 {
1575         READ_TEMP_LOCALS();
1576
1577         ReadCommonPlan(&local_node->plan);
1578
1579         READ_UINT_FIELD(scanrelid);
1580 }
1581
1582 /*
1583  * _readScan
1584  */
1585 static Scan *
1586 _readScan(void)
1587 {
1588         READ_LOCALS_NO_FIELDS(Scan);
1589
1590         ReadCommonScan(local_node);
1591
1592         READ_DONE();
1593 }
1594
1595 /*
1596  * _readSeqScan
1597  */
1598 static SeqScan *
1599 _readSeqScan(void)
1600 {
1601         READ_LOCALS_NO_FIELDS(SeqScan);
1602
1603         ReadCommonScan(local_node);
1604
1605         READ_DONE();
1606 }
1607
1608 /*
1609  * _readSampleScan
1610  */
1611 static SampleScan *
1612 _readSampleScan(void)
1613 {
1614         READ_LOCALS(SampleScan);
1615
1616         ReadCommonScan(&local_node->scan);
1617
1618         READ_NODE_FIELD(tablesample);
1619
1620         READ_DONE();
1621 }
1622
1623 /*
1624  * _readIndexScan
1625  */
1626 static IndexScan *
1627 _readIndexScan(void)
1628 {
1629         READ_LOCALS(IndexScan);
1630
1631         ReadCommonScan(&local_node->scan);
1632
1633         READ_OID_FIELD(indexid);
1634         READ_NODE_FIELD(indexqual);
1635         READ_NODE_FIELD(indexqualorig);
1636         READ_NODE_FIELD(indexorderby);
1637         READ_NODE_FIELD(indexorderbyorig);
1638         READ_NODE_FIELD(indexorderbyops);
1639         READ_ENUM_FIELD(indexorderdir, ScanDirection);
1640
1641         READ_DONE();
1642 }
1643
1644 /*
1645  * _readIndexOnlyScan
1646  */
1647 static IndexOnlyScan *
1648 _readIndexOnlyScan(void)
1649 {
1650         READ_LOCALS(IndexOnlyScan);
1651
1652         ReadCommonScan(&local_node->scan);
1653
1654         READ_OID_FIELD(indexid);
1655         READ_NODE_FIELD(indexqual);
1656         READ_NODE_FIELD(indexorderby);
1657         READ_NODE_FIELD(indextlist);
1658         READ_ENUM_FIELD(indexorderdir, ScanDirection);
1659
1660         READ_DONE();
1661 }
1662
1663 /*
1664  * _readBitmapIndexScan
1665  */
1666 static BitmapIndexScan *
1667 _readBitmapIndexScan(void)
1668 {
1669         READ_LOCALS(BitmapIndexScan);
1670
1671         ReadCommonScan(&local_node->scan);
1672
1673         READ_OID_FIELD(indexid);
1674         READ_NODE_FIELD(indexqual);
1675         READ_NODE_FIELD(indexqualorig);
1676
1677         READ_DONE();
1678 }
1679
1680 /*
1681  * _readBitmapHeapScan
1682  */
1683 static BitmapHeapScan *
1684 _readBitmapHeapScan(void)
1685 {
1686         READ_LOCALS(BitmapHeapScan);
1687
1688         ReadCommonScan(&local_node->scan);
1689
1690         READ_NODE_FIELD(bitmapqualorig);
1691
1692         READ_DONE();
1693 }
1694
1695 /*
1696  * _readTidScan
1697  */
1698 static TidScan *
1699 _readTidScan(void)
1700 {
1701         READ_LOCALS(TidScan);
1702
1703         ReadCommonScan(&local_node->scan);
1704
1705         READ_NODE_FIELD(tidquals);
1706
1707         READ_DONE();
1708 }
1709
1710 /*
1711  * _readSubqueryScan
1712  */
1713 static SubqueryScan *
1714 _readSubqueryScan(void)
1715 {
1716         READ_LOCALS(SubqueryScan);
1717
1718         ReadCommonScan(&local_node->scan);
1719
1720         READ_NODE_FIELD(subplan);
1721
1722         READ_DONE();
1723 }
1724
1725 /*
1726  * _readFunctionScan
1727  */
1728 static FunctionScan *
1729 _readFunctionScan(void)
1730 {
1731         READ_LOCALS(FunctionScan);
1732
1733         ReadCommonScan(&local_node->scan);
1734
1735         READ_NODE_FIELD(functions);
1736         READ_BOOL_FIELD(funcordinality);
1737
1738         READ_DONE();
1739 }
1740
1741 /*
1742  * _readValuesScan
1743  */
1744 static ValuesScan *
1745 _readValuesScan(void)
1746 {
1747         READ_LOCALS(ValuesScan);
1748
1749         ReadCommonScan(&local_node->scan);
1750
1751         READ_NODE_FIELD(values_lists);
1752
1753         READ_DONE();
1754 }
1755
1756 /*
1757  * _readCteScan
1758  */
1759 static CteScan *
1760 _readCteScan(void)
1761 {
1762         READ_LOCALS(CteScan);
1763
1764         ReadCommonScan(&local_node->scan);
1765
1766         READ_INT_FIELD(ctePlanId);
1767         READ_INT_FIELD(cteParam);
1768
1769         READ_DONE();
1770 }
1771
1772 /*
1773  * _readWorkTableScan
1774  */
1775 static WorkTableScan *
1776 _readWorkTableScan(void)
1777 {
1778         READ_LOCALS(WorkTableScan);
1779
1780         ReadCommonScan(&local_node->scan);
1781
1782         READ_INT_FIELD(wtParam);
1783
1784         READ_DONE();
1785 }
1786
1787 /*
1788  * _readForeignScan
1789  */
1790 static ForeignScan *
1791 _readForeignScan(void)
1792 {
1793         READ_LOCALS(ForeignScan);
1794
1795         ReadCommonScan(&local_node->scan);
1796
1797         READ_OID_FIELD(fs_server);
1798         READ_NODE_FIELD(fdw_exprs);
1799         READ_NODE_FIELD(fdw_private);
1800         READ_NODE_FIELD(fdw_scan_tlist);
1801         READ_BITMAPSET_FIELD(fs_relids);
1802         READ_BOOL_FIELD(fsSystemCol);
1803
1804         READ_DONE();
1805 }
1806
1807 /*
1808  * ReadCommonJoin
1809  *      Assign the basic stuff of all nodes that inherit from Join
1810  */
1811 static void
1812 ReadCommonJoin(Join *local_node)
1813 {
1814         READ_TEMP_LOCALS();
1815
1816         ReadCommonPlan(&local_node->plan);
1817
1818         READ_ENUM_FIELD(jointype, JoinType);
1819         READ_NODE_FIELD(joinqual);
1820 }
1821
1822 /*
1823  * _readJoin
1824  */
1825 static Join *
1826 _readJoin(void)
1827 {
1828         READ_LOCALS_NO_FIELDS(Join);
1829
1830         ReadCommonJoin(local_node);
1831
1832         READ_DONE();
1833 }
1834
1835 /*
1836  * _readNestLoop
1837  */
1838 static NestLoop *
1839 _readNestLoop(void)
1840 {
1841         READ_LOCALS(NestLoop);
1842
1843         ReadCommonJoin(&local_node->join);
1844
1845         READ_NODE_FIELD(nestParams);
1846
1847         READ_DONE();
1848 }
1849
1850 /*
1851  * _readMergeJoin
1852  */
1853 static MergeJoin *
1854 _readMergeJoin(void)
1855 {
1856         int                     numCols;
1857
1858         READ_LOCALS(MergeJoin);
1859
1860         ReadCommonJoin(&local_node->join);
1861
1862         READ_NODE_FIELD(mergeclauses);
1863
1864         numCols = list_length(local_node->mergeclauses);
1865
1866         READ_OID_ARRAY(mergeFamilies, numCols);
1867         READ_OID_ARRAY(mergeCollations, numCols);
1868         READ_INT_ARRAY(mergeStrategies, numCols);
1869         READ_BOOL_ARRAY(mergeNullsFirst, numCols);
1870
1871         READ_DONE();
1872 }
1873
1874 /*
1875  * _readHashJoin
1876  */
1877 static HashJoin *
1878 _readHashJoin(void)
1879 {
1880         READ_LOCALS(HashJoin);
1881
1882         ReadCommonJoin(&local_node->join);
1883
1884         READ_NODE_FIELD(hashclauses);
1885
1886         READ_DONE();
1887 }
1888
1889 /*
1890  * _readMaterial
1891  */
1892 static Material *
1893 _readMaterial(void)
1894 {
1895         READ_LOCALS_NO_FIELDS(Material);
1896
1897         ReadCommonPlan(&local_node->plan);
1898
1899         READ_DONE();
1900 }
1901
1902 /*
1903  * _readSort
1904  */
1905 static Sort *
1906 _readSort(void)
1907 {
1908         READ_LOCALS(Sort);
1909
1910         ReadCommonPlan(&local_node->plan);
1911
1912         READ_INT_FIELD(numCols);
1913         READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
1914         READ_OID_ARRAY(sortOperators, local_node->numCols);
1915         READ_OID_ARRAY(collations, local_node->numCols);
1916         READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
1917
1918         READ_DONE();
1919 }
1920
1921 /*
1922  * _readGroup
1923  */
1924 static Group *
1925 _readGroup(void)
1926 {
1927         READ_LOCALS(Group);
1928
1929         ReadCommonPlan(&local_node->plan);
1930
1931         READ_INT_FIELD(numCols);
1932         READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
1933         READ_OID_ARRAY(grpOperators, local_node->numCols);
1934
1935         READ_DONE();
1936 }
1937
1938 /*
1939  * _readAgg
1940  */
1941 static Agg *
1942 _readAgg(void)
1943 {
1944         READ_LOCALS(Agg);
1945
1946         ReadCommonPlan(&local_node->plan);
1947
1948         READ_ENUM_FIELD(aggstrategy, AggStrategy);
1949         READ_INT_FIELD(numCols);
1950         READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
1951         READ_OID_ARRAY(grpOperators, local_node->numCols);
1952         READ_LONG_FIELD(numGroups);
1953         READ_NODE_FIELD(groupingSets);
1954         READ_NODE_FIELD(chain);
1955
1956         READ_DONE();
1957 }
1958
1959 /*
1960  * _readWindowAgg
1961  */
1962 static WindowAgg *
1963 _readWindowAgg(void)
1964 {
1965         READ_LOCALS(WindowAgg);
1966
1967         ReadCommonPlan(&local_node->plan);
1968
1969         READ_UINT_FIELD(winref);
1970         READ_INT_FIELD(partNumCols);
1971         READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
1972         READ_OID_ARRAY(partOperators, local_node->partNumCols);
1973         READ_INT_FIELD(ordNumCols);
1974         READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
1975         READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
1976         READ_INT_FIELD(frameOptions);
1977         READ_NODE_FIELD(startOffset);
1978         READ_NODE_FIELD(endOffset);
1979
1980         READ_DONE();
1981 }
1982
1983 /*
1984  * _readUnique
1985  */
1986 static Unique *
1987 _readUnique(void)
1988 {
1989         READ_LOCALS(Unique);
1990
1991         ReadCommonPlan(&local_node->plan);
1992
1993         READ_INT_FIELD(numCols);
1994         READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
1995         READ_OID_ARRAY(uniqOperators, local_node->numCols);
1996
1997         READ_DONE();
1998 }
1999
2000 /*
2001  * _readHash
2002  */
2003 static Hash *
2004 _readHash(void)
2005 {
2006         READ_LOCALS(Hash);
2007
2008         ReadCommonPlan(&local_node->plan);
2009
2010         READ_OID_FIELD(skewTable);
2011         READ_INT_FIELD(skewColumn);
2012         READ_BOOL_FIELD(skewInherit);
2013         READ_OID_FIELD(skewColType);
2014         READ_INT_FIELD(skewColTypmod);
2015
2016         READ_DONE();
2017 }
2018
2019 /*
2020  * _readSetOp
2021  */
2022 static SetOp *
2023 _readSetOp(void)
2024 {
2025         READ_LOCALS(SetOp);
2026
2027         ReadCommonPlan(&local_node->plan);
2028
2029         READ_ENUM_FIELD(cmd, SetOpCmd);
2030         READ_ENUM_FIELD(strategy, SetOpStrategy);
2031         READ_INT_FIELD(numCols);
2032         READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
2033         READ_OID_ARRAY(dupOperators, local_node->numCols);
2034         READ_INT_FIELD(flagColIdx);
2035         READ_INT_FIELD(firstFlag);
2036         READ_LONG_FIELD(numGroups);
2037
2038         READ_DONE();
2039 }
2040
2041 /*
2042  * _readLockRows
2043  */
2044 static LockRows *
2045 _readLockRows(void)
2046 {
2047         READ_LOCALS(LockRows);
2048
2049         ReadCommonPlan(&local_node->plan);
2050
2051         READ_NODE_FIELD(rowMarks);
2052         READ_INT_FIELD(epqParam);
2053
2054         READ_DONE();
2055 }
2056
2057 /*
2058  * _readLimit
2059  */
2060 static Limit *
2061 _readLimit(void)
2062 {
2063         READ_LOCALS(Limit);
2064
2065         ReadCommonPlan(&local_node->plan);
2066
2067         READ_NODE_FIELD(limitOffset);
2068         READ_NODE_FIELD(limitCount);
2069
2070         READ_DONE();
2071 }
2072
2073 /*
2074  * _readNestLoopParam
2075  */
2076 static NestLoopParam *
2077 _readNestLoopParam(void)
2078 {
2079         READ_LOCALS(NestLoopParam);
2080
2081         READ_INT_FIELD(paramno);
2082         READ_NODE_FIELD(paramval);
2083
2084         READ_DONE();
2085 }
2086
2087 /*
2088  * _readPlanRowMark
2089  */
2090 static PlanRowMark *
2091 _readPlanRowMark(void)
2092 {
2093         READ_LOCALS(PlanRowMark);
2094
2095         READ_UINT_FIELD(rti);
2096         READ_UINT_FIELD(prti);
2097         READ_UINT_FIELD(rowmarkId);
2098         READ_ENUM_FIELD(markType, RowMarkType);
2099         READ_INT_FIELD(allMarkTypes);
2100         READ_ENUM_FIELD(strength, LockClauseStrength);
2101         READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
2102         READ_BOOL_FIELD(isParent);
2103
2104         READ_DONE();
2105 }
2106
2107 /*
2108  * _readPlanInvalItem
2109  */
2110 static PlanInvalItem *
2111 _readPlanInvalItem(void)
2112 {
2113         READ_LOCALS(PlanInvalItem);
2114
2115         READ_INT_FIELD(cacheId);
2116         READ_UINT_FIELD(hashValue);
2117
2118         READ_DONE();
2119 }
2120
2121 /*
2122  * _readSubPlan
2123  */
2124 static SubPlan *
2125 _readSubPlan(void)
2126 {
2127         READ_LOCALS(SubPlan);
2128
2129         READ_ENUM_FIELD(subLinkType, SubLinkType);
2130         READ_NODE_FIELD(testexpr);
2131         READ_NODE_FIELD(paramIds);
2132         READ_INT_FIELD(plan_id);
2133         READ_STRING_FIELD(plan_name);
2134         READ_OID_FIELD(firstColType);
2135         READ_INT_FIELD(firstColTypmod);
2136         READ_OID_FIELD(firstColCollation);
2137         READ_BOOL_FIELD(useHashTable);
2138         READ_BOOL_FIELD(unknownEqFalse);
2139         READ_NODE_FIELD(setParam);
2140         READ_NODE_FIELD(parParam);
2141         READ_NODE_FIELD(args);
2142         READ_FLOAT_FIELD(startup_cost);
2143         READ_FLOAT_FIELD(per_call_cost);
2144
2145         READ_DONE();
2146 }
2147
2148 /*
2149  * _readAlternativeSubPlan
2150  */
2151 static AlternativeSubPlan *
2152 _readAlternativeSubPlan(void)
2153 {
2154         READ_LOCALS(AlternativeSubPlan);
2155
2156         READ_NODE_FIELD(subplans);
2157
2158         READ_DONE();
2159 }
2160
2161 /*
2162  * parseNodeString
2163  *
2164  * Given a character string representing a node tree, parseNodeString creates
2165  * the internal node structure.
2166  *
2167  * The string to be read must already have been loaded into pg_strtok().
2168  */
2169 Node *
2170 parseNodeString(void)
2171 {
2172         void       *return_value;
2173
2174         READ_TEMP_LOCALS();
2175
2176         token = pg_strtok(&length);
2177
2178 #define MATCH(tokname, namelen) \
2179         (length == namelen && memcmp(token, tokname, namelen) == 0)
2180
2181         if (MATCH("QUERY", 5))
2182                 return_value = _readQuery();
2183         else if (MATCH("WITHCHECKOPTION", 15))
2184                 return_value = _readWithCheckOption();
2185         else if (MATCH("SORTGROUPCLAUSE", 15))
2186                 return_value = _readSortGroupClause();
2187         else if (MATCH("GROUPINGSET", 11))
2188                 return_value = _readGroupingSet();
2189         else if (MATCH("WINDOWCLAUSE", 12))
2190                 return_value = _readWindowClause();
2191         else if (MATCH("ROWMARKCLAUSE", 13))
2192                 return_value = _readRowMarkClause();
2193         else if (MATCH("COMMONTABLEEXPR", 15))
2194                 return_value = _readCommonTableExpr();
2195         else if (MATCH("SETOPERATIONSTMT", 16))
2196                 return_value = _readSetOperationStmt();
2197         else if (MATCH("ALIAS", 5))
2198                 return_value = _readAlias();
2199         else if (MATCH("RANGEVAR", 8))
2200                 return_value = _readRangeVar();
2201         else if (MATCH("INTOCLAUSE", 10))
2202                 return_value = _readIntoClause();
2203         else if (MATCH("VAR", 3))
2204                 return_value = _readVar();
2205         else if (MATCH("CONST", 5))
2206                 return_value = _readConst();
2207         else if (MATCH("PARAM", 5))
2208                 return_value = _readParam();
2209         else if (MATCH("AGGREF", 6))
2210                 return_value = _readAggref();
2211         else if (MATCH("GROUPINGFUNC", 12))
2212                 return_value = _readGroupingFunc();
2213         else if (MATCH("WINDOWFUNC", 10))
2214                 return_value = _readWindowFunc();
2215         else if (MATCH("ARRAYREF", 8))
2216                 return_value = _readArrayRef();
2217         else if (MATCH("FUNCEXPR", 8))
2218                 return_value = _readFuncExpr();
2219         else if (MATCH("NAMEDARGEXPR", 12))
2220                 return_value = _readNamedArgExpr();
2221         else if (MATCH("OPEXPR", 6))
2222                 return_value = _readOpExpr();
2223         else if (MATCH("DISTINCTEXPR", 12))
2224                 return_value = _readDistinctExpr();
2225         else if (MATCH("NULLIFEXPR", 10))
2226                 return_value = _readNullIfExpr();
2227         else if (MATCH("SCALARARRAYOPEXPR", 17))
2228                 return_value = _readScalarArrayOpExpr();
2229         else if (MATCH("BOOLEXPR", 8))
2230                 return_value = _readBoolExpr();
2231         else if (MATCH("SUBLINK", 7))
2232                 return_value = _readSubLink();
2233         else if (MATCH("FIELDSELECT", 11))
2234                 return_value = _readFieldSelect();
2235         else if (MATCH("FIELDSTORE", 10))
2236                 return_value = _readFieldStore();
2237         else if (MATCH("RELABELTYPE", 11))
2238                 return_value = _readRelabelType();
2239         else if (MATCH("COERCEVIAIO", 11))
2240                 return_value = _readCoerceViaIO();
2241         else if (MATCH("ARRAYCOERCEEXPR", 15))
2242                 return_value = _readArrayCoerceExpr();
2243         else if (MATCH("CONVERTROWTYPEEXPR", 18))
2244                 return_value = _readConvertRowtypeExpr();
2245         else if (MATCH("COLLATE", 7))
2246                 return_value = _readCollateExpr();
2247         else if (MATCH("CASE", 4))
2248                 return_value = _readCaseExpr();
2249         else if (MATCH("WHEN", 4))
2250                 return_value = _readCaseWhen();
2251         else if (MATCH("CASETESTEXPR", 12))
2252                 return_value = _readCaseTestExpr();
2253         else if (MATCH("ARRAY", 5))
2254                 return_value = _readArrayExpr();
2255         else if (MATCH("ROW", 3))
2256                 return_value = _readRowExpr();
2257         else if (MATCH("ROWCOMPARE", 10))
2258                 return_value = _readRowCompareExpr();
2259         else if (MATCH("COALESCE", 8))
2260                 return_value = _readCoalesceExpr();
2261         else if (MATCH("MINMAX", 6))
2262                 return_value = _readMinMaxExpr();
2263         else if (MATCH("XMLEXPR", 7))
2264                 return_value = _readXmlExpr();
2265         else if (MATCH("NULLTEST", 8))
2266                 return_value = _readNullTest();
2267         else if (MATCH("BOOLEANTEST", 11))
2268                 return_value = _readBooleanTest();
2269         else if (MATCH("COERCETODOMAIN", 14))
2270                 return_value = _readCoerceToDomain();
2271         else if (MATCH("COERCETODOMAINVALUE", 19))
2272                 return_value = _readCoerceToDomainValue();
2273         else if (MATCH("SETTODEFAULT", 12))
2274                 return_value = _readSetToDefault();
2275         else if (MATCH("CURRENTOFEXPR", 13))
2276                 return_value = _readCurrentOfExpr();
2277         else if (MATCH("INFERENCEELEM", 13))
2278                 return_value = _readInferenceElem();
2279         else if (MATCH("TARGETENTRY", 11))
2280                 return_value = _readTargetEntry();
2281         else if (MATCH("RANGETBLREF", 11))
2282                 return_value = _readRangeTblRef();
2283         else if (MATCH("JOINEXPR", 8))
2284                 return_value = _readJoinExpr();
2285         else if (MATCH("FROMEXPR", 8))
2286                 return_value = _readFromExpr();
2287         else if (MATCH("ONCONFLICTEXPR", 14))
2288                 return_value = _readOnConflictExpr();
2289         else if (MATCH("RTE", 3))
2290                 return_value = _readRangeTblEntry();
2291         else if (MATCH("RANGETBLFUNCTION", 16))
2292                 return_value = _readRangeTblFunction();
2293         else if (MATCH("TABLESAMPLECLAUSE", 17))
2294                 return_value = _readTableSampleClause();
2295         else if (MATCH("NOTIFY", 6))
2296                 return_value = _readNotifyStmt();
2297         else if (MATCH("DEFELEM", 7))
2298                 return_value = _readDefElem();
2299         else if (MATCH("DECLARECURSOR", 13))
2300                 return_value = _readDeclareCursorStmt();
2301         else if (MATCH("PLANNEDSTMT", 11))
2302                 return_value = _readPlannedStmt();
2303         else if (MATCH("PLAN", 4))
2304                 return_value = _readPlan();
2305         else if (MATCH("RESULT", 6))
2306                 return_value = _readResult();
2307         else if (MATCH("MODIFYTABLE", 11))
2308                 return_value = _readModifyTable();
2309         else if (MATCH("APPEND", 6))
2310                 return_value = _readAppend();
2311         else if (MATCH("MERGEAPPEND", 11))
2312                 return_value = _readMergeAppend();
2313         else if (MATCH("RECURSIVEUNION", 14))
2314                 return_value = _readRecursiveUnion();
2315         else if (MATCH("BITMAPAND", 9))
2316                 return_value = _readBitmapAnd();
2317         else if (MATCH("BITMAPOR", 8))
2318                 return_value = _readBitmapOr();
2319         else if (MATCH("SCAN", 4))
2320                 return_value = _readScan();
2321         else if (MATCH("SEQSCAN", 7))
2322                 return_value = _readSeqScan();
2323         else if (MATCH("SAMPLESCAN", 10))
2324                 return_value = _readSampleScan();
2325         else if (MATCH("INDEXSCAN", 9))
2326                 return_value = _readIndexScan();
2327         else if (MATCH("INDEXONLYSCAN", 13))
2328                 return_value = _readIndexOnlyScan();
2329         else if (MATCH("BITMAPINDEXSCAN", 15))
2330                 return_value = _readBitmapIndexScan();
2331         else if (MATCH("BITMAPHEAPSCAN", 14))
2332                 return_value = _readBitmapHeapScan();
2333         else if (MATCH("TIDSCAN", 7))
2334                 return_value = _readTidScan();
2335         else if (MATCH("SUBQUERYSCAN", 12))
2336                 return_value = _readSubqueryScan();
2337         else if (MATCH("FUNCTIONSCAN", 12))
2338                 return_value = _readFunctionScan();
2339         else if (MATCH("VALUESSCAN", 10))
2340                 return_value = _readValuesScan();
2341         else if (MATCH("CTESCAN", 7))
2342                 return_value = _readCteScan();
2343         else if (MATCH("WORKTABLESCAN", 13))
2344                 return_value = _readWorkTableScan();
2345         else if (MATCH("FOREIGNSCAN", 11))
2346                 return_value = _readForeignScan();
2347         else if (MATCH("JOIN", 4))
2348                 return_value = _readJoin();
2349         else if (MATCH("NESTLOOP", 8))
2350                 return_value = _readNestLoop();
2351         else if (MATCH("MERGEJOIN", 9))
2352                 return_value = _readMergeJoin();
2353         else if (MATCH("HASHJOIN", 8))
2354                 return_value = _readHashJoin();
2355         else if (MATCH("MATERIAL", 8))
2356                 return_value = _readMaterial();
2357         else if (MATCH("SORT", 4))
2358                 return_value = _readSort();
2359         else if (MATCH("GROUP", 5))
2360                 return_value = _readGroup();
2361         else if (MATCH("AGG", 3))
2362                 return_value = _readAgg();
2363         else if (MATCH("WINDOWAGG", 9))
2364                 return_value = _readWindowAgg();
2365         else if (MATCH("UNIQUE", 6))
2366                 return_value = _readUnique();
2367         else if (MATCH("HASH", 4))
2368                 return_value = _readHash();
2369         else if (MATCH("SETOP", 5))
2370                 return_value = _readSetOp();
2371         else if (MATCH("LOCKROWS", 8))
2372                 return_value = _readLockRows();
2373         else if (MATCH("LIMIT", 5))
2374                 return_value = _readLimit();
2375         else if (MATCH("NESTLOOPPARAM", 13))
2376                 return_value = _readNestLoopParam();
2377         else if (MATCH("PLANROWMARK", 11))
2378                 return_value = _readPlanRowMark();
2379         else if (MATCH("PLANINVALITEM", 13))
2380                 return_value = _readPlanInvalItem();
2381         else if (MATCH("SUBPLAN", 7))
2382                 return_value = _readSubPlan();
2383         else if (MATCH("ALTERNATIVESUBPLAN", 18))
2384                 return_value = _readAlternativeSubPlan();
2385         else
2386         {
2387                 elog(ERROR, "badly formatted node string \"%.32s\"...", token);
2388                 return_value = NULL;    /* keep compiler quiet */
2389         }
2390
2391         return (Node *) return_value;
2392 }
2393
2394
2395 /*
2396  * readDatum
2397  *
2398  * Given a string representation of a constant, recreate the appropriate
2399  * Datum.  The string representation embeds length info, but not byValue,
2400  * so we must be told that.
2401  */
2402 static Datum
2403 readDatum(bool typbyval)
2404 {
2405         Size            length,
2406                                 i;
2407         int                     tokenLength;
2408         char       *token;
2409         Datum           res;
2410         char       *s;
2411
2412         /*
2413          * read the actual length of the value
2414          */
2415         token = pg_strtok(&tokenLength);
2416         length = atoui(token);
2417
2418         token = pg_strtok(&tokenLength);        /* read the '[' */
2419         if (token == NULL || token[0] != '[')
2420                 elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
2421                          token ? (const char *) token : "[NULL]", length);
2422
2423         if (typbyval)
2424         {
2425                 if (length > (Size) sizeof(Datum))
2426                         elog(ERROR, "byval datum but length = %zu", length);
2427                 res = (Datum) 0;
2428                 s = (char *) (&res);
2429                 for (i = 0; i < (Size) sizeof(Datum); i++)
2430                 {
2431                         token = pg_strtok(&tokenLength);
2432                         s[i] = (char) atoi(token);
2433                 }
2434         }
2435         else if (length <= 0)
2436                 res = (Datum) NULL;
2437         else
2438         {
2439                 s = (char *) palloc(length);
2440                 for (i = 0; i < length; i++)
2441                 {
2442                         token = pg_strtok(&tokenLength);
2443                         s[i] = (char) atoi(token);
2444                 }
2445                 res = PointerGetDatum(s);
2446         }
2447
2448         token = pg_strtok(&tokenLength);        /* read the ']' */
2449         if (token == NULL || token[0] != ']')
2450                 elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
2451                          token ? (const char *) token : "[NULL]", length);
2452
2453         return res;
2454 }
2455
2456 /*
2457  * readAttrNumberCols
2458  */
2459 static AttrNumber *
2460 readAttrNumberCols(int numCols)
2461 {
2462         int                     tokenLength,
2463                                 i;
2464         char       *token;
2465         AttrNumber *attr_vals;
2466
2467         if (numCols <= 0)
2468                 return NULL;
2469
2470         attr_vals = (AttrNumber *) palloc(numCols * sizeof(AttrNumber));
2471         for (i = 0; i < numCols; i++)
2472         {
2473                 token = pg_strtok(&tokenLength);
2474                 attr_vals[i] = atoi(token);
2475         }
2476
2477         return attr_vals;
2478 }
2479
2480 /*
2481  * readOidCols
2482  */
2483 static Oid *
2484 readOidCols(int numCols)
2485 {
2486         int                     tokenLength,
2487                                 i;
2488         char       *token;
2489         Oid                *oid_vals;
2490
2491         if (numCols <= 0)
2492                 return NULL;
2493
2494         oid_vals = (Oid *) palloc(numCols * sizeof(Oid));
2495         for (i = 0; i < numCols; i++)
2496         {
2497                 token = pg_strtok(&tokenLength);
2498                 oid_vals[i] = atooid(token);
2499         }
2500
2501         return oid_vals;
2502 }
2503
2504 /*
2505  * readIntCols
2506  */
2507 static int *
2508 readIntCols(int numCols)
2509 {
2510         int                     tokenLength,
2511                                 i;
2512         char       *token;
2513         int                *int_vals;
2514
2515         if (numCols <= 0)
2516                 return NULL;
2517
2518         int_vals = (int *) palloc(numCols * sizeof(int));
2519         for (i = 0; i < numCols; i++)
2520         {
2521                 token = pg_strtok(&tokenLength);
2522                 int_vals[i] = atoi(token);
2523         }
2524
2525         return int_vals;
2526 }
2527
2528 /*
2529  * readBoolCols
2530  */
2531 static bool *
2532 readBoolCols(int numCols)
2533 {
2534         int                     tokenLength,
2535                                 i;
2536         char       *token;
2537         bool       *bool_vals;
2538
2539         if (numCols <= 0)
2540                 return NULL;
2541
2542         bool_vals = (bool *) palloc(numCols * sizeof(bool));
2543         for (i = 0; i < numCols; i++)
2544         {
2545                 token = pg_strtok(&tokenLength);
2546                 bool_vals[i] = strtobool(token);
2547         }
2548
2549         return bool_vals;
2550 }