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  * _readXmlExpr
1046  */
1047 static XmlExpr *
1048 _readXmlExpr(void)
1049 {
1050         READ_LOCALS(XmlExpr);
1051
1052         READ_ENUM_FIELD(op, XmlExprOp);
1053         READ_STRING_FIELD(name);
1054         READ_NODE_FIELD(named_args);
1055         READ_NODE_FIELD(arg_names);
1056         READ_NODE_FIELD(args);
1057         READ_ENUM_FIELD(xmloption, XmlOptionType);
1058         READ_OID_FIELD(type);
1059         READ_INT_FIELD(typmod);
1060         READ_LOCATION_FIELD(location);
1061
1062         READ_DONE();
1063 }
1064
1065 /*
1066  * _readNullTest
1067  */
1068 static NullTest *
1069 _readNullTest(void)
1070 {
1071         READ_LOCALS(NullTest);
1072
1073         READ_NODE_FIELD(arg);
1074         READ_ENUM_FIELD(nulltesttype, NullTestType);
1075         READ_BOOL_FIELD(argisrow);
1076         READ_LOCATION_FIELD(location);
1077
1078         READ_DONE();
1079 }
1080
1081 /*
1082  * _readBooleanTest
1083  */
1084 static BooleanTest *
1085 _readBooleanTest(void)
1086 {
1087         READ_LOCALS(BooleanTest);
1088
1089         READ_NODE_FIELD(arg);
1090         READ_ENUM_FIELD(booltesttype, BoolTestType);
1091         READ_LOCATION_FIELD(location);
1092
1093         READ_DONE();
1094 }
1095
1096 /*
1097  * _readCoerceToDomain
1098  */
1099 static CoerceToDomain *
1100 _readCoerceToDomain(void)
1101 {
1102         READ_LOCALS(CoerceToDomain);
1103
1104         READ_NODE_FIELD(arg);
1105         READ_OID_FIELD(resulttype);
1106         READ_INT_FIELD(resulttypmod);
1107         READ_OID_FIELD(resultcollid);
1108         READ_ENUM_FIELD(coercionformat, CoercionForm);
1109         READ_LOCATION_FIELD(location);
1110
1111         READ_DONE();
1112 }
1113
1114 /*
1115  * _readCoerceToDomainValue
1116  */
1117 static CoerceToDomainValue *
1118 _readCoerceToDomainValue(void)
1119 {
1120         READ_LOCALS(CoerceToDomainValue);
1121
1122         READ_OID_FIELD(typeId);
1123         READ_INT_FIELD(typeMod);
1124         READ_OID_FIELD(collation);
1125         READ_LOCATION_FIELD(location);
1126
1127         READ_DONE();
1128 }
1129
1130 /*
1131  * _readSetToDefault
1132  */
1133 static SetToDefault *
1134 _readSetToDefault(void)
1135 {
1136         READ_LOCALS(SetToDefault);
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  * _readCurrentOfExpr
1148  */
1149 static CurrentOfExpr *
1150 _readCurrentOfExpr(void)
1151 {
1152         READ_LOCALS(CurrentOfExpr);
1153
1154         READ_UINT_FIELD(cvarno);
1155         READ_STRING_FIELD(cursor_name);
1156         READ_INT_FIELD(cursor_param);
1157
1158         READ_DONE();
1159 }
1160
1161 /*
1162  * _readInferenceElem
1163  */
1164 static InferenceElem *
1165 _readInferenceElem(void)
1166 {
1167         READ_LOCALS(InferenceElem);
1168
1169         READ_NODE_FIELD(expr);
1170         READ_OID_FIELD(infercollid);
1171         READ_OID_FIELD(inferopclass);
1172
1173         READ_DONE();
1174 }
1175
1176 /*
1177  * _readTargetEntry
1178  */
1179 static TargetEntry *
1180 _readTargetEntry(void)
1181 {
1182         READ_LOCALS(TargetEntry);
1183
1184         READ_NODE_FIELD(expr);
1185         READ_INT_FIELD(resno);
1186         READ_STRING_FIELD(resname);
1187         READ_UINT_FIELD(ressortgroupref);
1188         READ_OID_FIELD(resorigtbl);
1189         READ_INT_FIELD(resorigcol);
1190         READ_BOOL_FIELD(resjunk);
1191
1192         READ_DONE();
1193 }
1194
1195 /*
1196  * _readRangeTblRef
1197  */
1198 static RangeTblRef *
1199 _readRangeTblRef(void)
1200 {
1201         READ_LOCALS(RangeTblRef);
1202
1203         READ_INT_FIELD(rtindex);
1204
1205         READ_DONE();
1206 }
1207
1208 /*
1209  * _readJoinExpr
1210  */
1211 static JoinExpr *
1212 _readJoinExpr(void)
1213 {
1214         READ_LOCALS(JoinExpr);
1215
1216         READ_ENUM_FIELD(jointype, JoinType);
1217         READ_BOOL_FIELD(isNatural);
1218         READ_NODE_FIELD(larg);
1219         READ_NODE_FIELD(rarg);
1220         READ_NODE_FIELD(usingClause);
1221         READ_NODE_FIELD(quals);
1222         READ_NODE_FIELD(alias);
1223         READ_INT_FIELD(rtindex);
1224
1225         READ_DONE();
1226 }
1227
1228 /*
1229  * _readFromExpr
1230  */
1231 static FromExpr *
1232 _readFromExpr(void)
1233 {
1234         READ_LOCALS(FromExpr);
1235
1236         READ_NODE_FIELD(fromlist);
1237         READ_NODE_FIELD(quals);
1238
1239         READ_DONE();
1240 }
1241
1242 /*
1243  * _readOnConflictExpr
1244  */
1245 static OnConflictExpr *
1246 _readOnConflictExpr(void)
1247 {
1248         READ_LOCALS(OnConflictExpr);
1249
1250         READ_ENUM_FIELD(action, OnConflictAction);
1251         READ_NODE_FIELD(arbiterElems);
1252         READ_NODE_FIELD(arbiterWhere);
1253         READ_OID_FIELD(constraint);
1254         READ_NODE_FIELD(onConflictSet);
1255         READ_NODE_FIELD(onConflictWhere);
1256         READ_INT_FIELD(exclRelIndex);
1257         READ_NODE_FIELD(exclRelTlist);
1258
1259         READ_DONE();
1260 }
1261
1262 /*
1263  *      Stuff from parsenodes.h.
1264  */
1265
1266 /*
1267  * _readRangeTblEntry
1268  */
1269 static RangeTblEntry *
1270 _readRangeTblEntry(void)
1271 {
1272         READ_LOCALS(RangeTblEntry);
1273
1274         /* put alias + eref first to make dump more legible */
1275         READ_NODE_FIELD(alias);
1276         READ_NODE_FIELD(eref);
1277         READ_ENUM_FIELD(rtekind, RTEKind);
1278
1279         switch (local_node->rtekind)
1280         {
1281                 case RTE_RELATION:
1282                         READ_OID_FIELD(relid);
1283                         READ_CHAR_FIELD(relkind);
1284                         READ_NODE_FIELD(tablesample);
1285                         break;
1286                 case RTE_SUBQUERY:
1287                         READ_NODE_FIELD(subquery);
1288                         READ_BOOL_FIELD(security_barrier);
1289                         break;
1290                 case RTE_JOIN:
1291                         READ_ENUM_FIELD(jointype, JoinType);
1292                         READ_NODE_FIELD(joinaliasvars);
1293                         break;
1294                 case RTE_FUNCTION:
1295                         READ_NODE_FIELD(functions);
1296                         READ_BOOL_FIELD(funcordinality);
1297                         break;
1298                 case RTE_VALUES:
1299                         READ_NODE_FIELD(values_lists);
1300                         READ_NODE_FIELD(values_collations);
1301                         break;
1302                 case RTE_CTE:
1303                         READ_STRING_FIELD(ctename);
1304                         READ_UINT_FIELD(ctelevelsup);
1305                         READ_BOOL_FIELD(self_reference);
1306                         READ_NODE_FIELD(ctecoltypes);
1307                         READ_NODE_FIELD(ctecoltypmods);
1308                         READ_NODE_FIELD(ctecolcollations);
1309                         break;
1310                 default:
1311                         elog(ERROR, "unrecognized RTE kind: %d",
1312                                  (int) local_node->rtekind);
1313                         break;
1314         }
1315
1316         READ_BOOL_FIELD(lateral);
1317         READ_BOOL_FIELD(inh);
1318         READ_BOOL_FIELD(inFromCl);
1319         READ_UINT_FIELD(requiredPerms);
1320         READ_OID_FIELD(checkAsUser);
1321         READ_BITMAPSET_FIELD(selectedCols);
1322         READ_BITMAPSET_FIELD(insertedCols);
1323         READ_BITMAPSET_FIELD(updatedCols);
1324         READ_NODE_FIELD(securityQuals);
1325
1326         READ_DONE();
1327 }
1328
1329 /*
1330  * _readRangeTblFunction
1331  */
1332 static RangeTblFunction *
1333 _readRangeTblFunction(void)
1334 {
1335         READ_LOCALS(RangeTblFunction);
1336
1337         READ_NODE_FIELD(funcexpr);
1338         READ_INT_FIELD(funccolcount);
1339         READ_NODE_FIELD(funccolnames);
1340         READ_NODE_FIELD(funccoltypes);
1341         READ_NODE_FIELD(funccoltypmods);
1342         READ_NODE_FIELD(funccolcollations);
1343         READ_BITMAPSET_FIELD(funcparams);
1344
1345         READ_DONE();
1346 }
1347
1348 /*
1349  * _readTableSampleClause
1350  */
1351 static TableSampleClause *
1352 _readTableSampleClause(void)
1353 {
1354         READ_LOCALS(TableSampleClause);
1355
1356         READ_OID_FIELD(tsmhandler);
1357         READ_NODE_FIELD(args);
1358         READ_NODE_FIELD(repeatable);
1359
1360         READ_DONE();
1361 }
1362
1363 /*
1364  * _readDefElem
1365  */
1366 static DefElem *
1367 _readDefElem(void)
1368 {
1369         READ_LOCALS(DefElem);
1370
1371         READ_STRING_FIELD(defnamespace);
1372         READ_STRING_FIELD(defname);
1373         READ_NODE_FIELD(arg);
1374         READ_ENUM_FIELD(defaction, DefElemAction);
1375
1376         READ_DONE();
1377 }
1378
1379 /*
1380  * _readPlannedStmt
1381  */
1382 static PlannedStmt *
1383 _readPlannedStmt(void)
1384 {
1385         READ_LOCALS(PlannedStmt);
1386
1387         READ_ENUM_FIELD(commandType, CmdType);
1388         READ_UINT_FIELD(queryId);
1389         READ_BOOL_FIELD(hasReturning);
1390         READ_BOOL_FIELD(hasModifyingCTE);
1391         READ_BOOL_FIELD(canSetTag);
1392         READ_BOOL_FIELD(transientPlan);
1393         READ_BOOL_FIELD(dependsOnRole);
1394         READ_BOOL_FIELD(parallelModeNeeded);
1395         READ_NODE_FIELD(planTree);
1396         READ_NODE_FIELD(rtable);
1397         READ_NODE_FIELD(resultRelations);
1398         READ_NODE_FIELD(utilityStmt);
1399         READ_NODE_FIELD(subplans);
1400         READ_BITMAPSET_FIELD(rewindPlanIDs);
1401         READ_NODE_FIELD(rowMarks);
1402         READ_NODE_FIELD(relationOids);
1403         READ_NODE_FIELD(invalItems);
1404         READ_INT_FIELD(nParamExec);
1405
1406         READ_DONE();
1407 }
1408
1409 /*
1410  * ReadCommonPlan
1411  *      Assign the basic stuff of all nodes that inherit from Plan
1412  */
1413 static void
1414 ReadCommonPlan(Plan *local_node)
1415 {
1416         READ_TEMP_LOCALS();
1417
1418         READ_FLOAT_FIELD(startup_cost);
1419         READ_FLOAT_FIELD(total_cost);
1420         READ_FLOAT_FIELD(plan_rows);
1421         READ_INT_FIELD(plan_width);
1422         READ_BOOL_FIELD(parallel_aware);
1423         READ_INT_FIELD(plan_node_id);
1424         READ_NODE_FIELD(targetlist);
1425         READ_NODE_FIELD(qual);
1426         READ_NODE_FIELD(lefttree);
1427         READ_NODE_FIELD(righttree);
1428         READ_NODE_FIELD(initPlan);
1429         READ_BITMAPSET_FIELD(extParam);
1430         READ_BITMAPSET_FIELD(allParam);
1431 }
1432
1433 /*
1434  * _readPlan
1435  */
1436 static Plan *
1437 _readPlan(void)
1438 {
1439         READ_LOCALS_NO_FIELDS(Plan);
1440
1441         ReadCommonPlan(local_node);
1442
1443         READ_DONE();
1444 }
1445
1446 /*
1447  * _readResult
1448  */
1449 static Result *
1450 _readResult(void)
1451 {
1452         READ_LOCALS(Result);
1453
1454         ReadCommonPlan(&local_node->plan);
1455
1456         READ_NODE_FIELD(resconstantqual);
1457
1458         READ_DONE();
1459 }
1460
1461 /*
1462  * _readModifyTable
1463  */
1464 static ModifyTable *
1465 _readModifyTable(void)
1466 {
1467         READ_LOCALS(ModifyTable);
1468
1469         ReadCommonPlan(&local_node->plan);
1470
1471         READ_ENUM_FIELD(operation, CmdType);
1472         READ_BOOL_FIELD(canSetTag);
1473         READ_UINT_FIELD(nominalRelation);
1474         READ_NODE_FIELD(resultRelations);
1475         READ_INT_FIELD(resultRelIndex);
1476         READ_NODE_FIELD(plans);
1477         READ_NODE_FIELD(withCheckOptionLists);
1478         READ_NODE_FIELD(returningLists);
1479         READ_NODE_FIELD(fdwPrivLists);
1480         READ_BITMAPSET_FIELD(fdwDirectModifyPlans);
1481         READ_NODE_FIELD(rowMarks);
1482         READ_INT_FIELD(epqParam);
1483         READ_ENUM_FIELD(onConflictAction, OnConflictAction);
1484         READ_NODE_FIELD(arbiterIndexes);
1485         READ_NODE_FIELD(onConflictSet);
1486         READ_NODE_FIELD(onConflictWhere);
1487         READ_UINT_FIELD(exclRelRTI);
1488         READ_NODE_FIELD(exclRelTlist);
1489
1490         READ_DONE();
1491 }
1492
1493 /*
1494  * _readAppend
1495  */
1496 static Append *
1497 _readAppend(void)
1498 {
1499         READ_LOCALS(Append);
1500
1501         ReadCommonPlan(&local_node->plan);
1502
1503         READ_NODE_FIELD(appendplans);
1504
1505         READ_DONE();
1506 }
1507
1508 /*
1509  * _readMergeAppend
1510  */
1511 static MergeAppend *
1512 _readMergeAppend(void)
1513 {
1514         READ_LOCALS(MergeAppend);
1515
1516         ReadCommonPlan(&local_node->plan);
1517
1518         READ_NODE_FIELD(mergeplans);
1519         READ_INT_FIELD(numCols);
1520         READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
1521         READ_OID_ARRAY(sortOperators, local_node->numCols);
1522         READ_OID_ARRAY(collations, local_node->numCols);
1523         READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
1524
1525         READ_DONE();
1526 }
1527
1528 /*
1529  * _readRecursiveUnion
1530  */
1531 static RecursiveUnion *
1532 _readRecursiveUnion(void)
1533 {
1534         READ_LOCALS(RecursiveUnion);
1535
1536         ReadCommonPlan(&local_node->plan);
1537
1538         READ_INT_FIELD(wtParam);
1539         READ_INT_FIELD(numCols);
1540         READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
1541         READ_OID_ARRAY(dupOperators, local_node->numCols);
1542         READ_LONG_FIELD(numGroups);
1543
1544         READ_DONE();
1545 }
1546
1547 /*
1548  * _readBitmapAnd
1549  */
1550 static BitmapAnd *
1551 _readBitmapAnd(void)
1552 {
1553         READ_LOCALS(BitmapAnd);
1554
1555         ReadCommonPlan(&local_node->plan);
1556
1557         READ_NODE_FIELD(bitmapplans);
1558
1559         READ_DONE();
1560 }
1561
1562 /*
1563  * _readBitmapOr
1564  */
1565 static BitmapOr *
1566 _readBitmapOr(void)
1567 {
1568         READ_LOCALS(BitmapOr);
1569
1570         ReadCommonPlan(&local_node->plan);
1571
1572         READ_NODE_FIELD(bitmapplans);
1573
1574         READ_DONE();
1575 }
1576
1577 /*
1578  * ReadCommonScan
1579  *      Assign the basic stuff of all nodes that inherit from Scan
1580  */
1581 static void
1582 ReadCommonScan(Scan *local_node)
1583 {
1584         READ_TEMP_LOCALS();
1585
1586         ReadCommonPlan(&local_node->plan);
1587
1588         READ_UINT_FIELD(scanrelid);
1589 }
1590
1591 /*
1592  * _readScan
1593  */
1594 static Scan *
1595 _readScan(void)
1596 {
1597         READ_LOCALS_NO_FIELDS(Scan);
1598
1599         ReadCommonScan(local_node);
1600
1601         READ_DONE();
1602 }
1603
1604 /*
1605  * _readSeqScan
1606  */
1607 static SeqScan *
1608 _readSeqScan(void)
1609 {
1610         READ_LOCALS_NO_FIELDS(SeqScan);
1611
1612         ReadCommonScan(local_node);
1613
1614         READ_DONE();
1615 }
1616
1617 /*
1618  * _readSampleScan
1619  */
1620 static SampleScan *
1621 _readSampleScan(void)
1622 {
1623         READ_LOCALS(SampleScan);
1624
1625         ReadCommonScan(&local_node->scan);
1626
1627         READ_NODE_FIELD(tablesample);
1628
1629         READ_DONE();
1630 }
1631
1632 /*
1633  * _readIndexScan
1634  */
1635 static IndexScan *
1636 _readIndexScan(void)
1637 {
1638         READ_LOCALS(IndexScan);
1639
1640         ReadCommonScan(&local_node->scan);
1641
1642         READ_OID_FIELD(indexid);
1643         READ_NODE_FIELD(indexqual);
1644         READ_NODE_FIELD(indexqualorig);
1645         READ_NODE_FIELD(indexorderby);
1646         READ_NODE_FIELD(indexorderbyorig);
1647         READ_NODE_FIELD(indexorderbyops);
1648         READ_ENUM_FIELD(indexorderdir, ScanDirection);
1649
1650         READ_DONE();
1651 }
1652
1653 /*
1654  * _readIndexOnlyScan
1655  */
1656 static IndexOnlyScan *
1657 _readIndexOnlyScan(void)
1658 {
1659         READ_LOCALS(IndexOnlyScan);
1660
1661         ReadCommonScan(&local_node->scan);
1662
1663         READ_OID_FIELD(indexid);
1664         READ_NODE_FIELD(indexqual);
1665         READ_NODE_FIELD(indexorderby);
1666         READ_NODE_FIELD(indextlist);
1667         READ_ENUM_FIELD(indexorderdir, ScanDirection);
1668
1669         READ_DONE();
1670 }
1671
1672 /*
1673  * _readBitmapIndexScan
1674  */
1675 static BitmapIndexScan *
1676 _readBitmapIndexScan(void)
1677 {
1678         READ_LOCALS(BitmapIndexScan);
1679
1680         ReadCommonScan(&local_node->scan);
1681
1682         READ_OID_FIELD(indexid);
1683         READ_NODE_FIELD(indexqual);
1684         READ_NODE_FIELD(indexqualorig);
1685
1686         READ_DONE();
1687 }
1688
1689 /*
1690  * _readBitmapHeapScan
1691  */
1692 static BitmapHeapScan *
1693 _readBitmapHeapScan(void)
1694 {
1695         READ_LOCALS(BitmapHeapScan);
1696
1697         ReadCommonScan(&local_node->scan);
1698
1699         READ_NODE_FIELD(bitmapqualorig);
1700
1701         READ_DONE();
1702 }
1703
1704 /*
1705  * _readTidScan
1706  */
1707 static TidScan *
1708 _readTidScan(void)
1709 {
1710         READ_LOCALS(TidScan);
1711
1712         ReadCommonScan(&local_node->scan);
1713
1714         READ_NODE_FIELD(tidquals);
1715
1716         READ_DONE();
1717 }
1718
1719 /*
1720  * _readSubqueryScan
1721  */
1722 static SubqueryScan *
1723 _readSubqueryScan(void)
1724 {
1725         READ_LOCALS(SubqueryScan);
1726
1727         ReadCommonScan(&local_node->scan);
1728
1729         READ_NODE_FIELD(subplan);
1730
1731         READ_DONE();
1732 }
1733
1734 /*
1735  * _readFunctionScan
1736  */
1737 static FunctionScan *
1738 _readFunctionScan(void)
1739 {
1740         READ_LOCALS(FunctionScan);
1741
1742         ReadCommonScan(&local_node->scan);
1743
1744         READ_NODE_FIELD(functions);
1745         READ_BOOL_FIELD(funcordinality);
1746
1747         READ_DONE();
1748 }
1749
1750 /*
1751  * _readValuesScan
1752  */
1753 static ValuesScan *
1754 _readValuesScan(void)
1755 {
1756         READ_LOCALS(ValuesScan);
1757
1758         ReadCommonScan(&local_node->scan);
1759
1760         READ_NODE_FIELD(values_lists);
1761
1762         READ_DONE();
1763 }
1764
1765 /*
1766  * _readCteScan
1767  */
1768 static CteScan *
1769 _readCteScan(void)
1770 {
1771         READ_LOCALS(CteScan);
1772
1773         ReadCommonScan(&local_node->scan);
1774
1775         READ_INT_FIELD(ctePlanId);
1776         READ_INT_FIELD(cteParam);
1777
1778         READ_DONE();
1779 }
1780
1781 /*
1782  * _readWorkTableScan
1783  */
1784 static WorkTableScan *
1785 _readWorkTableScan(void)
1786 {
1787         READ_LOCALS(WorkTableScan);
1788
1789         ReadCommonScan(&local_node->scan);
1790
1791         READ_INT_FIELD(wtParam);
1792
1793         READ_DONE();
1794 }
1795
1796 /*
1797  * _readForeignScan
1798  */
1799 static ForeignScan *
1800 _readForeignScan(void)
1801 {
1802         READ_LOCALS(ForeignScan);
1803
1804         ReadCommonScan(&local_node->scan);
1805
1806         READ_ENUM_FIELD(operation, CmdType);
1807         READ_OID_FIELD(fs_server);
1808         READ_NODE_FIELD(fdw_exprs);
1809         READ_NODE_FIELD(fdw_private);
1810         READ_NODE_FIELD(fdw_scan_tlist);
1811         READ_NODE_FIELD(fdw_recheck_quals);
1812         READ_BITMAPSET_FIELD(fs_relids);
1813         READ_BOOL_FIELD(fsSystemCol);
1814
1815         READ_DONE();
1816 }
1817
1818 /*
1819  * _readCustomScan
1820  */
1821 static CustomScan *
1822 _readCustomScan(void)
1823 {
1824         READ_LOCALS(CustomScan);
1825         char       *custom_name;
1826         const CustomScanMethods *methods;
1827
1828         ReadCommonScan(&local_node->scan);
1829
1830         READ_UINT_FIELD(flags);
1831         READ_NODE_FIELD(custom_plans);
1832         READ_NODE_FIELD(custom_exprs);
1833         READ_NODE_FIELD(custom_private);
1834         READ_NODE_FIELD(custom_scan_tlist);
1835         READ_BITMAPSET_FIELD(custom_relids);
1836
1837         /* Lookup CustomScanMethods by CustomName */
1838         token = pg_strtok(&length); /* skip methods: */
1839         token = pg_strtok(&length); /* CustomName */
1840         custom_name = nullable_string(token, length);
1841         methods = GetCustomScanMethods(custom_name, false);
1842         local_node->methods = methods;
1843
1844         READ_DONE();
1845 }
1846
1847 /*
1848  * ReadCommonJoin
1849  *      Assign the basic stuff of all nodes that inherit from Join
1850  */
1851 static void
1852 ReadCommonJoin(Join *local_node)
1853 {
1854         READ_TEMP_LOCALS();
1855
1856         ReadCommonPlan(&local_node->plan);
1857
1858         READ_ENUM_FIELD(jointype, JoinType);
1859         READ_NODE_FIELD(joinqual);
1860 }
1861
1862 /*
1863  * _readJoin
1864  */
1865 static Join *
1866 _readJoin(void)
1867 {
1868         READ_LOCALS_NO_FIELDS(Join);
1869
1870         ReadCommonJoin(local_node);
1871
1872         READ_DONE();
1873 }
1874
1875 /*
1876  * _readNestLoop
1877  */
1878 static NestLoop *
1879 _readNestLoop(void)
1880 {
1881         READ_LOCALS(NestLoop);
1882
1883         ReadCommonJoin(&local_node->join);
1884
1885         READ_NODE_FIELD(nestParams);
1886
1887         READ_DONE();
1888 }
1889
1890 /*
1891  * _readMergeJoin
1892  */
1893 static MergeJoin *
1894 _readMergeJoin(void)
1895 {
1896         int                     numCols;
1897
1898         READ_LOCALS(MergeJoin);
1899
1900         ReadCommonJoin(&local_node->join);
1901
1902         READ_NODE_FIELD(mergeclauses);
1903
1904         numCols = list_length(local_node->mergeclauses);
1905
1906         READ_OID_ARRAY(mergeFamilies, numCols);
1907         READ_OID_ARRAY(mergeCollations, numCols);
1908         READ_INT_ARRAY(mergeStrategies, numCols);
1909         READ_BOOL_ARRAY(mergeNullsFirst, numCols);
1910
1911         READ_DONE();
1912 }
1913
1914 /*
1915  * _readHashJoin
1916  */
1917 static HashJoin *
1918 _readHashJoin(void)
1919 {
1920         READ_LOCALS(HashJoin);
1921
1922         ReadCommonJoin(&local_node->join);
1923
1924         READ_NODE_FIELD(hashclauses);
1925
1926         READ_DONE();
1927 }
1928
1929 /*
1930  * _readMaterial
1931  */
1932 static Material *
1933 _readMaterial(void)
1934 {
1935         READ_LOCALS_NO_FIELDS(Material);
1936
1937         ReadCommonPlan(&local_node->plan);
1938
1939         READ_DONE();
1940 }
1941
1942 /*
1943  * _readSort
1944  */
1945 static Sort *
1946 _readSort(void)
1947 {
1948         READ_LOCALS(Sort);
1949
1950         ReadCommonPlan(&local_node->plan);
1951
1952         READ_INT_FIELD(numCols);
1953         READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
1954         READ_OID_ARRAY(sortOperators, local_node->numCols);
1955         READ_OID_ARRAY(collations, local_node->numCols);
1956         READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
1957
1958         READ_DONE();
1959 }
1960
1961 /*
1962  * _readGroup
1963  */
1964 static Group *
1965 _readGroup(void)
1966 {
1967         READ_LOCALS(Group);
1968
1969         ReadCommonPlan(&local_node->plan);
1970
1971         READ_INT_FIELD(numCols);
1972         READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
1973         READ_OID_ARRAY(grpOperators, local_node->numCols);
1974
1975         READ_DONE();
1976 }
1977
1978 /*
1979  * _readAgg
1980  */
1981 static Agg *
1982 _readAgg(void)
1983 {
1984         READ_LOCALS(Agg);
1985
1986         ReadCommonPlan(&local_node->plan);
1987
1988         READ_ENUM_FIELD(aggstrategy, AggStrategy);
1989         READ_ENUM_FIELD(aggsplit, AggSplit);
1990         READ_INT_FIELD(numCols);
1991         READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
1992         READ_OID_ARRAY(grpOperators, local_node->numCols);
1993         READ_LONG_FIELD(numGroups);
1994         READ_NODE_FIELD(groupingSets);
1995         READ_NODE_FIELD(chain);
1996
1997         READ_DONE();
1998 }
1999
2000 /*
2001  * _readWindowAgg
2002  */
2003 static WindowAgg *
2004 _readWindowAgg(void)
2005 {
2006         READ_LOCALS(WindowAgg);
2007
2008         ReadCommonPlan(&local_node->plan);
2009
2010         READ_UINT_FIELD(winref);
2011         READ_INT_FIELD(partNumCols);
2012         READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
2013         READ_OID_ARRAY(partOperators, local_node->partNumCols);
2014         READ_INT_FIELD(ordNumCols);
2015         READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
2016         READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
2017         READ_INT_FIELD(frameOptions);
2018         READ_NODE_FIELD(startOffset);
2019         READ_NODE_FIELD(endOffset);
2020
2021         READ_DONE();
2022 }
2023
2024 /*
2025  * _readUnique
2026  */
2027 static Unique *
2028 _readUnique(void)
2029 {
2030         READ_LOCALS(Unique);
2031
2032         ReadCommonPlan(&local_node->plan);
2033
2034         READ_INT_FIELD(numCols);
2035         READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
2036         READ_OID_ARRAY(uniqOperators, local_node->numCols);
2037
2038         READ_DONE();
2039 }
2040
2041 /*
2042  * _readGather
2043  */
2044 static Gather *
2045 _readGather(void)
2046 {
2047         READ_LOCALS(Gather);
2048
2049         ReadCommonPlan(&local_node->plan);
2050
2051         READ_INT_FIELD(num_workers);
2052         READ_BOOL_FIELD(single_copy);
2053         READ_BOOL_FIELD(invisible);
2054
2055         READ_DONE();
2056 }
2057
2058 /*
2059  * _readHash
2060  */
2061 static Hash *
2062 _readHash(void)
2063 {
2064         READ_LOCALS(Hash);
2065
2066         ReadCommonPlan(&local_node->plan);
2067
2068         READ_OID_FIELD(skewTable);
2069         READ_INT_FIELD(skewColumn);
2070         READ_BOOL_FIELD(skewInherit);
2071         READ_OID_FIELD(skewColType);
2072         READ_INT_FIELD(skewColTypmod);
2073
2074         READ_DONE();
2075 }
2076
2077 /*
2078  * _readSetOp
2079  */
2080 static SetOp *
2081 _readSetOp(void)
2082 {
2083         READ_LOCALS(SetOp);
2084
2085         ReadCommonPlan(&local_node->plan);
2086
2087         READ_ENUM_FIELD(cmd, SetOpCmd);
2088         READ_ENUM_FIELD(strategy, SetOpStrategy);
2089         READ_INT_FIELD(numCols);
2090         READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
2091         READ_OID_ARRAY(dupOperators, local_node->numCols);
2092         READ_INT_FIELD(flagColIdx);
2093         READ_INT_FIELD(firstFlag);
2094         READ_LONG_FIELD(numGroups);
2095
2096         READ_DONE();
2097 }
2098
2099 /*
2100  * _readLockRows
2101  */
2102 static LockRows *
2103 _readLockRows(void)
2104 {
2105         READ_LOCALS(LockRows);
2106
2107         ReadCommonPlan(&local_node->plan);
2108
2109         READ_NODE_FIELD(rowMarks);
2110         READ_INT_FIELD(epqParam);
2111
2112         READ_DONE();
2113 }
2114
2115 /*
2116  * _readLimit
2117  */
2118 static Limit *
2119 _readLimit(void)
2120 {
2121         READ_LOCALS(Limit);
2122
2123         ReadCommonPlan(&local_node->plan);
2124
2125         READ_NODE_FIELD(limitOffset);
2126         READ_NODE_FIELD(limitCount);
2127
2128         READ_DONE();
2129 }
2130
2131 /*
2132  * _readNestLoopParam
2133  */
2134 static NestLoopParam *
2135 _readNestLoopParam(void)
2136 {
2137         READ_LOCALS(NestLoopParam);
2138
2139         READ_INT_FIELD(paramno);
2140         READ_NODE_FIELD(paramval);
2141
2142         READ_DONE();
2143 }
2144
2145 /*
2146  * _readPlanRowMark
2147  */
2148 static PlanRowMark *
2149 _readPlanRowMark(void)
2150 {
2151         READ_LOCALS(PlanRowMark);
2152
2153         READ_UINT_FIELD(rti);
2154         READ_UINT_FIELD(prti);
2155         READ_UINT_FIELD(rowmarkId);
2156         READ_ENUM_FIELD(markType, RowMarkType);
2157         READ_INT_FIELD(allMarkTypes);
2158         READ_ENUM_FIELD(strength, LockClauseStrength);
2159         READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
2160         READ_BOOL_FIELD(isParent);
2161
2162         READ_DONE();
2163 }
2164
2165 /*
2166  * _readPlanInvalItem
2167  */
2168 static PlanInvalItem *
2169 _readPlanInvalItem(void)
2170 {
2171         READ_LOCALS(PlanInvalItem);
2172
2173         READ_INT_FIELD(cacheId);
2174         READ_UINT_FIELD(hashValue);
2175
2176         READ_DONE();
2177 }
2178
2179 /*
2180  * _readSubPlan
2181  */
2182 static SubPlan *
2183 _readSubPlan(void)
2184 {
2185         READ_LOCALS(SubPlan);
2186
2187         READ_ENUM_FIELD(subLinkType, SubLinkType);
2188         READ_NODE_FIELD(testexpr);
2189         READ_NODE_FIELD(paramIds);
2190         READ_INT_FIELD(plan_id);
2191         READ_STRING_FIELD(plan_name);
2192         READ_OID_FIELD(firstColType);
2193         READ_INT_FIELD(firstColTypmod);
2194         READ_OID_FIELD(firstColCollation);
2195         READ_BOOL_FIELD(useHashTable);
2196         READ_BOOL_FIELD(unknownEqFalse);
2197         READ_NODE_FIELD(setParam);
2198         READ_NODE_FIELD(parParam);
2199         READ_NODE_FIELD(args);
2200         READ_FLOAT_FIELD(startup_cost);
2201         READ_FLOAT_FIELD(per_call_cost);
2202
2203         READ_DONE();
2204 }
2205
2206 /*
2207  * _readAlternativeSubPlan
2208  */
2209 static AlternativeSubPlan *
2210 _readAlternativeSubPlan(void)
2211 {
2212         READ_LOCALS(AlternativeSubPlan);
2213
2214         READ_NODE_FIELD(subplans);
2215
2216         READ_DONE();
2217 }
2218
2219 /*
2220  * _readExtensibleNode
2221  */
2222 static ExtensibleNode *
2223 _readExtensibleNode(void)
2224 {
2225         const ExtensibleNodeMethods *methods;
2226         ExtensibleNode *local_node;
2227         const char *extnodename;
2228
2229         READ_TEMP_LOCALS();
2230
2231         token = pg_strtok(&length); /* skip :extnodename */
2232         token = pg_strtok(&length); /* get extnodename */
2233
2234         extnodename = nullable_string(token, length);
2235         if (!extnodename)
2236                 elog(ERROR, "extnodename has to be supplied");
2237         methods = GetExtensibleNodeMethods(extnodename, false);
2238
2239         local_node = (ExtensibleNode *) newNode(methods->node_size,
2240                                                                                         T_ExtensibleNode);
2241         local_node->extnodename = extnodename;
2242
2243         /* deserialize the private fields */
2244         methods->nodeRead(local_node);
2245
2246         READ_DONE();
2247 }
2248
2249 /*
2250  * parseNodeString
2251  *
2252  * Given a character string representing a node tree, parseNodeString creates
2253  * the internal node structure.
2254  *
2255  * The string to be read must already have been loaded into pg_strtok().
2256  */
2257 Node *
2258 parseNodeString(void)
2259 {
2260         void       *return_value;
2261
2262         READ_TEMP_LOCALS();
2263
2264         token = pg_strtok(&length);
2265
2266 #define MATCH(tokname, namelen) \
2267         (length == namelen && memcmp(token, tokname, namelen) == 0)
2268
2269         if (MATCH("QUERY", 5))
2270                 return_value = _readQuery();
2271         else if (MATCH("WITHCHECKOPTION", 15))
2272                 return_value = _readWithCheckOption();
2273         else if (MATCH("SORTGROUPCLAUSE", 15))
2274                 return_value = _readSortGroupClause();
2275         else if (MATCH("GROUPINGSET", 11))
2276                 return_value = _readGroupingSet();
2277         else if (MATCH("WINDOWCLAUSE", 12))
2278                 return_value = _readWindowClause();
2279         else if (MATCH("ROWMARKCLAUSE", 13))
2280                 return_value = _readRowMarkClause();
2281         else if (MATCH("COMMONTABLEEXPR", 15))
2282                 return_value = _readCommonTableExpr();
2283         else if (MATCH("SETOPERATIONSTMT", 16))
2284                 return_value = _readSetOperationStmt();
2285         else if (MATCH("ALIAS", 5))
2286                 return_value = _readAlias();
2287         else if (MATCH("RANGEVAR", 8))
2288                 return_value = _readRangeVar();
2289         else if (MATCH("INTOCLAUSE", 10))
2290                 return_value = _readIntoClause();
2291         else if (MATCH("VAR", 3))
2292                 return_value = _readVar();
2293         else if (MATCH("CONST", 5))
2294                 return_value = _readConst();
2295         else if (MATCH("PARAM", 5))
2296                 return_value = _readParam();
2297         else if (MATCH("AGGREF", 6))
2298                 return_value = _readAggref();
2299         else if (MATCH("GROUPINGFUNC", 12))
2300                 return_value = _readGroupingFunc();
2301         else if (MATCH("WINDOWFUNC", 10))
2302                 return_value = _readWindowFunc();
2303         else if (MATCH("ARRAYREF", 8))
2304                 return_value = _readArrayRef();
2305         else if (MATCH("FUNCEXPR", 8))
2306                 return_value = _readFuncExpr();
2307         else if (MATCH("NAMEDARGEXPR", 12))
2308                 return_value = _readNamedArgExpr();
2309         else if (MATCH("OPEXPR", 6))
2310                 return_value = _readOpExpr();
2311         else if (MATCH("DISTINCTEXPR", 12))
2312                 return_value = _readDistinctExpr();
2313         else if (MATCH("NULLIFEXPR", 10))
2314                 return_value = _readNullIfExpr();
2315         else if (MATCH("SCALARARRAYOPEXPR", 17))
2316                 return_value = _readScalarArrayOpExpr();
2317         else if (MATCH("BOOLEXPR", 8))
2318                 return_value = _readBoolExpr();
2319         else if (MATCH("SUBLINK", 7))
2320                 return_value = _readSubLink();
2321         else if (MATCH("FIELDSELECT", 11))
2322                 return_value = _readFieldSelect();
2323         else if (MATCH("FIELDSTORE", 10))
2324                 return_value = _readFieldStore();
2325         else if (MATCH("RELABELTYPE", 11))
2326                 return_value = _readRelabelType();
2327         else if (MATCH("COERCEVIAIO", 11))
2328                 return_value = _readCoerceViaIO();
2329         else if (MATCH("ARRAYCOERCEEXPR", 15))
2330                 return_value = _readArrayCoerceExpr();
2331         else if (MATCH("CONVERTROWTYPEEXPR", 18))
2332                 return_value = _readConvertRowtypeExpr();
2333         else if (MATCH("COLLATE", 7))
2334                 return_value = _readCollateExpr();
2335         else if (MATCH("CASE", 4))
2336                 return_value = _readCaseExpr();
2337         else if (MATCH("WHEN", 4))
2338                 return_value = _readCaseWhen();
2339         else if (MATCH("CASETESTEXPR", 12))
2340                 return_value = _readCaseTestExpr();
2341         else if (MATCH("ARRAY", 5))
2342                 return_value = _readArrayExpr();
2343         else if (MATCH("ROW", 3))
2344                 return_value = _readRowExpr();
2345         else if (MATCH("ROWCOMPARE", 10))
2346                 return_value = _readRowCompareExpr();
2347         else if (MATCH("COALESCE", 8))
2348                 return_value = _readCoalesceExpr();
2349         else if (MATCH("MINMAX", 6))
2350                 return_value = _readMinMaxExpr();
2351         else if (MATCH("XMLEXPR", 7))
2352                 return_value = _readXmlExpr();
2353         else if (MATCH("NULLTEST", 8))
2354                 return_value = _readNullTest();
2355         else if (MATCH("BOOLEANTEST", 11))
2356                 return_value = _readBooleanTest();
2357         else if (MATCH("COERCETODOMAIN", 14))
2358                 return_value = _readCoerceToDomain();
2359         else if (MATCH("COERCETODOMAINVALUE", 19))
2360                 return_value = _readCoerceToDomainValue();
2361         else if (MATCH("SETTODEFAULT", 12))
2362                 return_value = _readSetToDefault();
2363         else if (MATCH("CURRENTOFEXPR", 13))
2364                 return_value = _readCurrentOfExpr();
2365         else if (MATCH("INFERENCEELEM", 13))
2366                 return_value = _readInferenceElem();
2367         else if (MATCH("TARGETENTRY", 11))
2368                 return_value = _readTargetEntry();
2369         else if (MATCH("RANGETBLREF", 11))
2370                 return_value = _readRangeTblRef();
2371         else if (MATCH("JOINEXPR", 8))
2372                 return_value = _readJoinExpr();
2373         else if (MATCH("FROMEXPR", 8))
2374                 return_value = _readFromExpr();
2375         else if (MATCH("ONCONFLICTEXPR", 14))
2376                 return_value = _readOnConflictExpr();
2377         else if (MATCH("RTE", 3))
2378                 return_value = _readRangeTblEntry();
2379         else if (MATCH("RANGETBLFUNCTION", 16))
2380                 return_value = _readRangeTblFunction();
2381         else if (MATCH("TABLESAMPLECLAUSE", 17))
2382                 return_value = _readTableSampleClause();
2383         else if (MATCH("NOTIFY", 6))
2384                 return_value = _readNotifyStmt();
2385         else if (MATCH("DEFELEM", 7))
2386                 return_value = _readDefElem();
2387         else if (MATCH("DECLARECURSOR", 13))
2388                 return_value = _readDeclareCursorStmt();
2389         else if (MATCH("PLANNEDSTMT", 11))
2390                 return_value = _readPlannedStmt();
2391         else if (MATCH("PLAN", 4))
2392                 return_value = _readPlan();
2393         else if (MATCH("RESULT", 6))
2394                 return_value = _readResult();
2395         else if (MATCH("MODIFYTABLE", 11))
2396                 return_value = _readModifyTable();
2397         else if (MATCH("APPEND", 6))
2398                 return_value = _readAppend();
2399         else if (MATCH("MERGEAPPEND", 11))
2400                 return_value = _readMergeAppend();
2401         else if (MATCH("RECURSIVEUNION", 14))
2402                 return_value = _readRecursiveUnion();
2403         else if (MATCH("BITMAPAND", 9))
2404                 return_value = _readBitmapAnd();
2405         else if (MATCH("BITMAPOR", 8))
2406                 return_value = _readBitmapOr();
2407         else if (MATCH("SCAN", 4))
2408                 return_value = _readScan();
2409         else if (MATCH("SEQSCAN", 7))
2410                 return_value = _readSeqScan();
2411         else if (MATCH("SAMPLESCAN", 10))
2412                 return_value = _readSampleScan();
2413         else if (MATCH("INDEXSCAN", 9))
2414                 return_value = _readIndexScan();
2415         else if (MATCH("INDEXONLYSCAN", 13))
2416                 return_value = _readIndexOnlyScan();
2417         else if (MATCH("BITMAPINDEXSCAN", 15))
2418                 return_value = _readBitmapIndexScan();
2419         else if (MATCH("BITMAPHEAPSCAN", 14))
2420                 return_value = _readBitmapHeapScan();
2421         else if (MATCH("TIDSCAN", 7))
2422                 return_value = _readTidScan();
2423         else if (MATCH("SUBQUERYSCAN", 12))
2424                 return_value = _readSubqueryScan();
2425         else if (MATCH("FUNCTIONSCAN", 12))
2426                 return_value = _readFunctionScan();
2427         else if (MATCH("VALUESSCAN", 10))
2428                 return_value = _readValuesScan();
2429         else if (MATCH("CTESCAN", 7))
2430                 return_value = _readCteScan();
2431         else if (MATCH("WORKTABLESCAN", 13))
2432                 return_value = _readWorkTableScan();
2433         else if (MATCH("FOREIGNSCAN", 11))
2434                 return_value = _readForeignScan();
2435         else if (MATCH("CUSTOMSCAN", 10))
2436                 return_value = _readCustomScan();
2437         else if (MATCH("JOIN", 4))
2438                 return_value = _readJoin();
2439         else if (MATCH("NESTLOOP", 8))
2440                 return_value = _readNestLoop();
2441         else if (MATCH("MERGEJOIN", 9))
2442                 return_value = _readMergeJoin();
2443         else if (MATCH("HASHJOIN", 8))
2444                 return_value = _readHashJoin();
2445         else if (MATCH("MATERIAL", 8))
2446                 return_value = _readMaterial();
2447         else if (MATCH("SORT", 4))
2448                 return_value = _readSort();
2449         else if (MATCH("GROUP", 5))
2450                 return_value = _readGroup();
2451         else if (MATCH("AGG", 3))
2452                 return_value = _readAgg();
2453         else if (MATCH("WINDOWAGG", 9))
2454                 return_value = _readWindowAgg();
2455         else if (MATCH("UNIQUE", 6))
2456                 return_value = _readUnique();
2457         else if (MATCH("GATHER", 6))
2458                 return_value = _readGather();
2459         else if (MATCH("HASH", 4))
2460                 return_value = _readHash();
2461         else if (MATCH("SETOP", 5))
2462                 return_value = _readSetOp();
2463         else if (MATCH("LOCKROWS", 8))
2464                 return_value = _readLockRows();
2465         else if (MATCH("LIMIT", 5))
2466                 return_value = _readLimit();
2467         else if (MATCH("NESTLOOPPARAM", 13))
2468                 return_value = _readNestLoopParam();
2469         else if (MATCH("PLANROWMARK", 11))
2470                 return_value = _readPlanRowMark();
2471         else if (MATCH("PLANINVALITEM", 13))
2472                 return_value = _readPlanInvalItem();
2473         else if (MATCH("SUBPLAN", 7))
2474                 return_value = _readSubPlan();
2475         else if (MATCH("ALTERNATIVESUBPLAN", 18))
2476                 return_value = _readAlternativeSubPlan();
2477         else if (MATCH("EXTENSIBLENODE", 14))
2478                 return_value = _readExtensibleNode();
2479         else
2480         {
2481                 elog(ERROR, "badly formatted node string \"%.32s\"...", token);
2482                 return_value = NULL;    /* keep compiler quiet */
2483         }
2484
2485         return (Node *) return_value;
2486 }
2487
2488
2489 /*
2490  * readDatum
2491  *
2492  * Given a string representation of a constant, recreate the appropriate
2493  * Datum.  The string representation embeds length info, but not byValue,
2494  * so we must be told that.
2495  */
2496 Datum
2497 readDatum(bool typbyval)
2498 {
2499         Size            length,
2500                                 i;
2501         int                     tokenLength;
2502         char       *token;
2503         Datum           res;
2504         char       *s;
2505
2506         /*
2507          * read the actual length of the value
2508          */
2509         token = pg_strtok(&tokenLength);
2510         length = atoui(token);
2511
2512         token = pg_strtok(&tokenLength);        /* read the '[' */
2513         if (token == NULL || token[0] != '[')
2514                 elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
2515                          token ? (const char *) token : "[NULL]", length);
2516
2517         if (typbyval)
2518         {
2519                 if (length > (Size) sizeof(Datum))
2520                         elog(ERROR, "byval datum but length = %zu", length);
2521                 res = (Datum) 0;
2522                 s = (char *) (&res);
2523                 for (i = 0; i < (Size) sizeof(Datum); i++)
2524                 {
2525                         token = pg_strtok(&tokenLength);
2526                         s[i] = (char) atoi(token);
2527                 }
2528         }
2529         else if (length <= 0)
2530                 res = (Datum) NULL;
2531         else
2532         {
2533                 s = (char *) palloc(length);
2534                 for (i = 0; i < length; i++)
2535                 {
2536                         token = pg_strtok(&tokenLength);
2537                         s[i] = (char) atoi(token);
2538                 }
2539                 res = PointerGetDatum(s);
2540         }
2541
2542         token = pg_strtok(&tokenLength);        /* read the ']' */
2543         if (token == NULL || token[0] != ']')
2544                 elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
2545                          token ? (const char *) token : "[NULL]", length);
2546
2547         return res;
2548 }
2549
2550 /*
2551  * readAttrNumberCols
2552  */
2553 AttrNumber *
2554 readAttrNumberCols(int numCols)
2555 {
2556         int                     tokenLength,
2557                                 i;
2558         char       *token;
2559         AttrNumber *attr_vals;
2560
2561         if (numCols <= 0)
2562                 return NULL;
2563
2564         attr_vals = (AttrNumber *) palloc(numCols * sizeof(AttrNumber));
2565         for (i = 0; i < numCols; i++)
2566         {
2567                 token = pg_strtok(&tokenLength);
2568                 attr_vals[i] = atoi(token);
2569         }
2570
2571         return attr_vals;
2572 }
2573
2574 /*
2575  * readOidCols
2576  */
2577 Oid *
2578 readOidCols(int numCols)
2579 {
2580         int                     tokenLength,
2581                                 i;
2582         char       *token;
2583         Oid                *oid_vals;
2584
2585         if (numCols <= 0)
2586                 return NULL;
2587
2588         oid_vals = (Oid *) palloc(numCols * sizeof(Oid));
2589         for (i = 0; i < numCols; i++)
2590         {
2591                 token = pg_strtok(&tokenLength);
2592                 oid_vals[i] = atooid(token);
2593         }
2594
2595         return oid_vals;
2596 }
2597
2598 /*
2599  * readIntCols
2600  */
2601 int *
2602 readIntCols(int numCols)
2603 {
2604         int                     tokenLength,
2605                                 i;
2606         char       *token;
2607         int                *int_vals;
2608
2609         if (numCols <= 0)
2610                 return NULL;
2611
2612         int_vals = (int *) palloc(numCols * sizeof(int));
2613         for (i = 0; i < numCols; i++)
2614         {
2615                 token = pg_strtok(&tokenLength);
2616                 int_vals[i] = atoi(token);
2617         }
2618
2619         return int_vals;
2620 }
2621
2622 /*
2623  * readBoolCols
2624  */
2625 bool *
2626 readBoolCols(int numCols)
2627 {
2628         int                     tokenLength,
2629                                 i;
2630         char       *token;
2631         bool       *bool_vals;
2632
2633         if (numCols <= 0)
2634                 return NULL;
2635
2636         bool_vals = (bool *) palloc(numCols * sizeof(bool));
2637         for (i = 0; i < numCols; i++)
2638         {
2639                 token = pg_strtok(&tokenLength);
2640                 bool_vals[i] = strtobool(token);
2641         }
2642
2643         return bool_vals;
2644 }