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