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(aggoutputtype);
 550         READ_OID_FIELD(aggcollid);
 551         READ_OID_FIELD(inputcollid);
 552         READ_NODE_FIELD(aggdirectargs);
 553         READ_NODE_FIELD(args);
 554         READ_NODE_FIELD(aggorder);
 555         READ_NODE_FIELD(aggdistinct);
 556         READ_NODE_FIELD(aggfilter);
 557         READ_BOOL_FIELD(aggstar);
 558         READ_BOOL_FIELD(aggvariadic);
 559         READ_CHAR_FIELD(aggkind);
 560         READ_UINT_FIELD(agglevelsup);
 561         READ_LOCATION_FIELD(location);
 562
 563         READ_DONE();
 564 }
 565
 566 /*
 567  * _readGroupingFunc
 568  */
 569 static GroupingFunc *
 570 _readGroupingFunc(void)
 571 {
 572         READ_LOCALS(GroupingFunc);
 573
 574         READ_NODE_FIELD(args);
 575         READ_NODE_FIELD(refs);
 576         READ_NODE_FIELD(cols);
 577         READ_UINT_FIELD(agglevelsup);
 578         READ_LOCATION_FIELD(location);
 579
 580         READ_DONE();
 581 }
 582
 583 /*
 584  * _readWindowFunc
 585  */
 586 static WindowFunc *
 587 _readWindowFunc(void)
 588 {
 589         READ_LOCALS(WindowFunc);
 590
 591         READ_OID_FIELD(winfnoid);
 592         READ_OID_FIELD(wintype);
 593         READ_OID_FIELD(wincollid);
 594         READ_OID_FIELD(inputcollid);
 595         READ_NODE_FIELD(args);
 596         READ_NODE_FIELD(aggfilter);
 597         READ_UINT_FIELD(winref);
 598         READ_BOOL_FIELD(winstar);
 599         READ_BOOL_FIELD(winagg);
 600         READ_LOCATION_FIELD(location);
 601
 602         READ_DONE();
 603 }
 604
 605 /*
 606  * _readArrayRef
 607  */
 608 static ArrayRef *
 609 _readArrayRef(void)
 610 {
 611         READ_LOCALS(ArrayRef);
 612
 613         READ_OID_FIELD(refarraytype);
 614         READ_OID_FIELD(refelemtype);
 615         READ_INT_FIELD(reftypmod);
 616         READ_OID_FIELD(refcollid);
 617         READ_NODE_FIELD(refupperindexpr);
 618         READ_NODE_FIELD(reflowerindexpr);
 619         READ_NODE_FIELD(refexpr);
 620         READ_NODE_FIELD(refassgnexpr);
 621
 622         READ_DONE();
 623 }
 624
 625 /*
 626  * _readFuncExpr
 627  */
 628 static FuncExpr *
 629 _readFuncExpr(void)
 630 {
 631         READ_LOCALS(FuncExpr);
 632
 633         READ_OID_FIELD(funcid);
 634         READ_OID_FIELD(funcresulttype);
 635         READ_BOOL_FIELD(funcretset);
 636         READ_BOOL_FIELD(funcvariadic);
 637         READ_ENUM_FIELD(funcformat, CoercionForm);
 638         READ_OID_FIELD(funccollid);
 639         READ_OID_FIELD(inputcollid);
 640         READ_NODE_FIELD(args);
 641         READ_LOCATION_FIELD(location);
 642
 643         READ_DONE();
 644 }
 645
 646 /*
 647  * _readNamedArgExpr
 648  */
 649 static NamedArgExpr *
 650 _readNamedArgExpr(void)
 651 {
 652         READ_LOCALS(NamedArgExpr);
 653
 654         READ_NODE_FIELD(arg);
 655         READ_STRING_FIELD(name);
 656         READ_INT_FIELD(argnumber);
 657         READ_LOCATION_FIELD(location);
 658
 659         READ_DONE();
 660 }
 661
 662 /*
 663  * _readOpExpr
 664  */
 665 static OpExpr *
 666 _readOpExpr(void)
 667 {
 668         READ_LOCALS(OpExpr);
 669
 670         READ_OID_FIELD(opno);
 671         READ_OID_FIELD(opfuncid);
 672         READ_OID_FIELD(opresulttype);
 673         READ_BOOL_FIELD(opretset);
 674         READ_OID_FIELD(opcollid);
 675         READ_OID_FIELD(inputcollid);
 676         READ_NODE_FIELD(args);
 677         READ_LOCATION_FIELD(location);
 678
 679         READ_DONE();
 680 }
 681
 682 /*
 683  * _readDistinctExpr
 684  */
 685 static DistinctExpr *
 686 _readDistinctExpr(void)
 687 {
 688         READ_LOCALS(DistinctExpr);
 689
 690         READ_OID_FIELD(opno);
 691         READ_OID_FIELD(opfuncid);
 692         READ_OID_FIELD(opresulttype);
 693         READ_BOOL_FIELD(opretset);
 694         READ_OID_FIELD(opcollid);
 695         READ_OID_FIELD(inputcollid);
 696         READ_NODE_FIELD(args);
 697         READ_LOCATION_FIELD(location);
 698
 699         READ_DONE();
 700 }
 701
 702 /*
 703  * _readNullIfExpr
 704  */
 705 static NullIfExpr *
 706 _readNullIfExpr(void)
 707 {
 708         READ_LOCALS(NullIfExpr);
 709
 710         READ_OID_FIELD(opno);
 711         READ_OID_FIELD(opfuncid);
 712         READ_OID_FIELD(opresulttype);
 713         READ_BOOL_FIELD(opretset);
 714         READ_OID_FIELD(opcollid);
 715         READ_OID_FIELD(inputcollid);
 716         READ_NODE_FIELD(args);
 717         READ_LOCATION_FIELD(location);
 718
 719         READ_DONE();
 720 }
 721
 722 /*
 723  * _readScalarArrayOpExpr
 724  */
 725 static ScalarArrayOpExpr *
 726 _readScalarArrayOpExpr(void)
 727 {
 728         READ_LOCALS(ScalarArrayOpExpr);
 729
 730         READ_OID_FIELD(opno);
 731         READ_OID_FIELD(opfuncid);
 732         READ_BOOL_FIELD(useOr);
 733         READ_OID_FIELD(inputcollid);
 734         READ_NODE_FIELD(args);
 735         READ_LOCATION_FIELD(location);
 736
 737         READ_DONE();
 738 }
 739
 740 /*
 741  * _readBoolExpr
 742  */
 743 static BoolExpr *
 744 _readBoolExpr(void)
 745 {
 746         READ_LOCALS(BoolExpr);
 747
 748         /* do-it-yourself enum representation */
 749         token = pg_strtok(&length); /* skip :boolop */
 750         token = pg_strtok(&length); /* get field value */
 751         if (strncmp(token, "and", 3) == 0)
 752                 local_node->boolop = AND_EXPR;
 753         else if (strncmp(token, "or", 2) == 0)
 754                 local_node->boolop = OR_EXPR;
 755         else if (strncmp(token, "not", 3) == 0)
 756                 local_node->boolop = NOT_EXPR;
 757         else
 758                 elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
 759
 760         READ_NODE_FIELD(args);
 761         READ_LOCATION_FIELD(location);
 762
 763         READ_DONE();
 764 }
 765
 766 /*
 767  * _readSubLink
 768  */
 769 static SubLink *
 770 _readSubLink(void)
 771 {
 772         READ_LOCALS(SubLink);
 773
 774         READ_ENUM_FIELD(subLinkType, SubLinkType);
 775         READ_INT_FIELD(subLinkId);
 776         READ_NODE_FIELD(testexpr);
 777         READ_NODE_FIELD(operName);
 778         READ_NODE_FIELD(subselect);
 779         READ_LOCATION_FIELD(location);
 780
 781         READ_DONE();
 782 }
 783
 784 /*
 785  * _readSubPlan is not needed since it doesn't appear in stored rules.
 786  */
 787
 788 /*
 789  * _readFieldSelect
 790  */
 791 static FieldSelect *
 792 _readFieldSelect(void)
 793 {
 794         READ_LOCALS(FieldSelect);
 795
 796         READ_NODE_FIELD(arg);
 797         READ_INT_FIELD(fieldnum);
 798         READ_OID_FIELD(resulttype);
 799         READ_INT_FIELD(resulttypmod);
 800         READ_OID_FIELD(resultcollid);
 801
 802         READ_DONE();
 803 }
 804
 805 /*
 806  * _readFieldStore
 807  */
 808 static FieldStore *
 809 _readFieldStore(void)
 810 {
 811         READ_LOCALS(FieldStore);
 812
 813         READ_NODE_FIELD(arg);
 814         READ_NODE_FIELD(newvals);
 815         READ_NODE_FIELD(fieldnums);
 816         READ_OID_FIELD(resulttype);
 817
 818         READ_DONE();
 819 }
 820
 821 /*
 822  * _readRelabelType
 823  */
 824 static RelabelType *
 825 _readRelabelType(void)
 826 {
 827         READ_LOCALS(RelabelType);
 828
 829         READ_NODE_FIELD(arg);
 830         READ_OID_FIELD(resulttype);
 831         READ_INT_FIELD(resulttypmod);
 832         READ_OID_FIELD(resultcollid);
 833         READ_ENUM_FIELD(relabelformat, CoercionForm);
 834         READ_LOCATION_FIELD(location);
 835
 836         READ_DONE();
 837 }
 838
 839 /*
 840  * _readCoerceViaIO
 841  */
 842 static CoerceViaIO *
 843 _readCoerceViaIO(void)
 844 {
 845         READ_LOCALS(CoerceViaIO);
 846
 847         READ_NODE_FIELD(arg);
 848         READ_OID_FIELD(resulttype);
 849         READ_OID_FIELD(resultcollid);
 850         READ_ENUM_FIELD(coerceformat, CoercionForm);
 851         READ_LOCATION_FIELD(location);
 852
 853         READ_DONE();
 854 }
 855
 856 /*
 857  * _readArrayCoerceExpr
 858  */
 859 static ArrayCoerceExpr *
 860 _readArrayCoerceExpr(void)
 861 {
 862         READ_LOCALS(ArrayCoerceExpr);
 863
 864         READ_NODE_FIELD(arg);
 865         READ_OID_FIELD(elemfuncid);
 866         READ_OID_FIELD(resulttype);
 867         READ_INT_FIELD(resulttypmod);
 868         READ_OID_FIELD(resultcollid);
 869         READ_BOOL_FIELD(isExplicit);
 870         READ_ENUM_FIELD(coerceformat, CoercionForm);
 871         READ_LOCATION_FIELD(location);
 872
 873         READ_DONE();
 874 }
 875
 876 /*
 877  * _readConvertRowtypeExpr
 878  */
 879 static ConvertRowtypeExpr *
 880 _readConvertRowtypeExpr(void)
 881 {
 882         READ_LOCALS(ConvertRowtypeExpr);
 883
 884         READ_NODE_FIELD(arg);
 885         READ_OID_FIELD(resulttype);
 886         READ_ENUM_FIELD(convertformat, CoercionForm);
 887         READ_LOCATION_FIELD(location);
 888
 889         READ_DONE();
 890 }
 891
 892 /*
 893  * _readCollateExpr
 894  */
 895 static CollateExpr *
 896 _readCollateExpr(void)
 897 {
 898         READ_LOCALS(CollateExpr);
 899
 900         READ_NODE_FIELD(arg);
 901         READ_OID_FIELD(collOid);
 902         READ_LOCATION_FIELD(location);
 903
 904         READ_DONE();
 905 }
 906
 907 /*
 908  * _readCaseExpr
 909  */
 910 static CaseExpr *
 911 _readCaseExpr(void)
 912 {
 913         READ_LOCALS(CaseExpr);
 914
 915         READ_OID_FIELD(casetype);
 916         READ_OID_FIELD(casecollid);
 917         READ_NODE_FIELD(arg);
 918         READ_NODE_FIELD(args);
 919         READ_NODE_FIELD(defresult);
 920         READ_LOCATION_FIELD(location);
 921
 922         READ_DONE();
 923 }
 924
 925 /*
 926  * _readCaseWhen
 927  */
 928 static CaseWhen *
 929 _readCaseWhen(void)
 930 {
 931         READ_LOCALS(CaseWhen);
 932
 933         READ_NODE_FIELD(expr);
 934         READ_NODE_FIELD(result);
 935         READ_LOCATION_FIELD(location);
 936
 937         READ_DONE();
 938 }
 939
 940 /*
 941  * _readCaseTestExpr
 942  */
 943 static CaseTestExpr *
 944 _readCaseTestExpr(void)
 945 {
 946         READ_LOCALS(CaseTestExpr);
 947
 948         READ_OID_FIELD(typeId);
 949         READ_INT_FIELD(typeMod);
 950         READ_OID_FIELD(collation);
 951
 952         READ_DONE();
 953 }
 954
 955 /*
 956  * _readArrayExpr
 957  */
 958 static ArrayExpr *
 959 _readArrayExpr(void)
 960 {
 961         READ_LOCALS(ArrayExpr);
 962
 963         READ_OID_FIELD(array_typeid);
 964         READ_OID_FIELD(array_collid);
 965         READ_OID_FIELD(element_typeid);
 966         READ_NODE_FIELD(elements);
 967         READ_BOOL_FIELD(multidims);
 968         READ_LOCATION_FIELD(location);
 969
 970         READ_DONE();
 971 }
 972
 973 /*
 974  * _readRowExpr
 975  */
 976 static RowExpr *
 977 _readRowExpr(void)
 978 {
 979         READ_LOCALS(RowExpr);
 980
 981         READ_NODE_FIELD(args);
 982         READ_OID_FIELD(row_typeid);
 983         READ_ENUM_FIELD(row_format, CoercionForm);
 984         READ_NODE_FIELD(colnames);
 985         READ_LOCATION_FIELD(location);
 986
 987         READ_DONE();
 988 }
 989
 990 /*
 991  * _readRowCompareExpr
 992  */
 993 static RowCompareExpr *
 994 _readRowCompareExpr(void)
 995 {
 996         READ_LOCALS(RowCompareExpr);
 997
 998         READ_ENUM_FIELD(rctype, RowCompareType);
 999         READ_NODE_FIELD(opnos);
1000         READ_NODE_FIELD(opfamilies);
1001         READ_NODE_FIELD(inputcollids);
1002         READ_NODE_FIELD(largs);
1003         READ_NODE_FIELD(rargs);
1004
1005         READ_DONE();
1006 }
1007
1008 /*
1009  * _readCoalesceExpr
1010  */
1011 static CoalesceExpr *
1012 _readCoalesceExpr(void)
1013 {
1014         READ_LOCALS(CoalesceExpr);
1015
1016         READ_OID_FIELD(coalescetype);
1017         READ_OID_FIELD(coalescecollid);
1018         READ_NODE_FIELD(args);
1019         READ_LOCATION_FIELD(location);
1020
1021         READ_DONE();
1022 }
1023
1024 /*
1025  * _readMinMaxExpr
1026  */
1027 static MinMaxExpr *
1028 _readMinMaxExpr(void)
1029 {
1030         READ_LOCALS(MinMaxExpr);
1031
1032         READ_OID_FIELD(minmaxtype);
1033         READ_OID_FIELD(minmaxcollid);
1034         READ_OID_FIELD(inputcollid);
1035         READ_ENUM_FIELD(op, MinMaxOp);
1036         READ_NODE_FIELD(args);
1037         READ_LOCATION_FIELD(location);
1038
1039         READ_DONE();
1040 }
1041
1042 /*
1043  * _readXmlExpr
1044  */
1045 static XmlExpr *
1046 _readXmlExpr(void)
1047 {
1048         READ_LOCALS(XmlExpr);
1049
1050         READ_ENUM_FIELD(op, XmlExprOp);
1051         READ_STRING_FIELD(name);
1052         READ_NODE_FIELD(named_args);
1053         READ_NODE_FIELD(arg_names);
1054         READ_NODE_FIELD(args);
1055         READ_ENUM_FIELD(xmloption, XmlOptionType);
1056         READ_OID_FIELD(type);
1057         READ_INT_FIELD(typmod);
1058         READ_LOCATION_FIELD(location);
1059
1060         READ_DONE();
1061 }
1062
1063 /*
1064  * _readNullTest
1065  */
1066 static NullTest *
1067 _readNullTest(void)
1068 {
1069         READ_LOCALS(NullTest);
1070
1071         READ_NODE_FIELD(arg);
1072         READ_ENUM_FIELD(nulltesttype, NullTestType);
1073         READ_BOOL_FIELD(argisrow);
1074         READ_LOCATION_FIELD(location);
1075
1076         READ_DONE();
1077 }
1078
1079 /*
1080  * _readBooleanTest
1081  */
1082 static BooleanTest *
1083 _readBooleanTest(void)
1084 {
1085         READ_LOCALS(BooleanTest);
1086
1087         READ_NODE_FIELD(arg);
1088         READ_ENUM_FIELD(booltesttype, BoolTestType);
1089         READ_LOCATION_FIELD(location);
1090
1091         READ_DONE();
1092 }
1093
1094 /*
1095  * _readCoerceToDomain
1096  */
1097 static CoerceToDomain *
1098 _readCoerceToDomain(void)
1099 {
1100         READ_LOCALS(CoerceToDomain);
1101
1102         READ_NODE_FIELD(arg);
1103         READ_OID_FIELD(resulttype);
1104         READ_INT_FIELD(resulttypmod);
1105         READ_OID_FIELD(resultcollid);
1106         READ_ENUM_FIELD(coercionformat, CoercionForm);
1107         READ_LOCATION_FIELD(location);
1108
1109         READ_DONE();
1110 }
1111
1112 /*
1113  * _readCoerceToDomainValue
1114  */
1115 static CoerceToDomainValue *
1116 _readCoerceToDomainValue(void)
1117 {
1118         READ_LOCALS(CoerceToDomainValue);
1119
1120         READ_OID_FIELD(typeId);
1121         READ_INT_FIELD(typeMod);
1122         READ_OID_FIELD(collation);
1123         READ_LOCATION_FIELD(location);
1124
1125         READ_DONE();
1126 }
1127
1128 /*
1129  * _readSetToDefault
1130  */
1131 static SetToDefault *
1132 _readSetToDefault(void)
1133 {
1134         READ_LOCALS(SetToDefault);
1135
1136         READ_OID_FIELD(typeId);
1137         READ_INT_FIELD(typeMod);
1138         READ_OID_FIELD(collation);
1139         READ_LOCATION_FIELD(location);
1140
1141         READ_DONE();
1142 }
1143
1144 /*
1145  * _readCurrentOfExpr
1146  */
1147 static CurrentOfExpr *
1148 _readCurrentOfExpr(void)
1149 {
1150         READ_LOCALS(CurrentOfExpr);
1151
1152         READ_UINT_FIELD(cvarno);
1153         READ_STRING_FIELD(cursor_name);
1154         READ_INT_FIELD(cursor_param);
1155
1156         READ_DONE();
1157 }
1158
1159 /*
1160  * _readInferenceElem
1161  */
1162 static InferenceElem *
1163 _readInferenceElem(void)
1164 {
1165         READ_LOCALS(InferenceElem);
1166
1167         READ_NODE_FIELD(expr);
1168         READ_OID_FIELD(infercollid);
1169         READ_OID_FIELD(inferopclass);
1170
1171         READ_DONE();
1172 }
1173
1174 /*
1175  * _readTargetEntry
1176  */
1177 static TargetEntry *
1178 _readTargetEntry(void)
1179 {
1180         READ_LOCALS(TargetEntry);
1181
1182         READ_NODE_FIELD(expr);
1183         READ_INT_FIELD(resno);
1184         READ_STRING_FIELD(resname);
1185         READ_UINT_FIELD(ressortgroupref);
1186         READ_OID_FIELD(resorigtbl);
1187         READ_INT_FIELD(resorigcol);
1188         READ_BOOL_FIELD(resjunk);
1189
1190         READ_DONE();
1191 }
1192
1193 /*
1194  * _readRangeTblRef
1195  */
1196 static RangeTblRef *
1197 _readRangeTblRef(void)
1198 {
1199         READ_LOCALS(RangeTblRef);
1200
1201         READ_INT_FIELD(rtindex);
1202
1203         READ_DONE();
1204 }
1205
1206 /*
1207  * _readJoinExpr
1208  */
1209 static JoinExpr *
1210 _readJoinExpr(void)
1211 {
1212         READ_LOCALS(JoinExpr);
1213
1214         READ_ENUM_FIELD(jointype, JoinType);
1215         READ_BOOL_FIELD(isNatural);
1216         READ_NODE_FIELD(larg);
1217         READ_NODE_FIELD(rarg);
1218         READ_NODE_FIELD(usingClause);
1219         READ_NODE_FIELD(quals);
1220         READ_NODE_FIELD(alias);
1221         READ_INT_FIELD(rtindex);
1222
1223         READ_DONE();
1224 }
1225
1226 /*
1227  * _readFromExpr
1228  */
1229 static FromExpr *
1230 _readFromExpr(void)
1231 {
1232         READ_LOCALS(FromExpr);
1233
1234         READ_NODE_FIELD(fromlist);
1235         READ_NODE_FIELD(quals);
1236
1237         READ_DONE();
1238 }
1239
1240 /*
1241  * _readOnConflictExpr
1242  */
1243 static OnConflictExpr *
1244 _readOnConflictExpr(void)
1245 {
1246         READ_LOCALS(OnConflictExpr);
1247
1248         READ_ENUM_FIELD(action, OnConflictAction);
1249         READ_NODE_FIELD(arbiterElems);
1250         READ_NODE_FIELD(arbiterWhere);
1251         READ_OID_FIELD(constraint);
1252         READ_NODE_FIELD(onConflictSet);
1253         READ_NODE_FIELD(onConflictWhere);
1254         READ_INT_FIELD(exclRelIndex);
1255         READ_NODE_FIELD(exclRelTlist);
1256
1257         READ_DONE();
1258 }
1259
1260 /*
1261  *      Stuff from parsenodes.h.
1262  */
1263
1264 /*
1265  * _readRangeTblEntry
1266  */
1267 static RangeTblEntry *
1268 _readRangeTblEntry(void)
1269 {
1270         READ_LOCALS(RangeTblEntry);
1271
1272         /* put alias + eref first to make dump more legible */
1273         READ_NODE_FIELD(alias);
1274         READ_NODE_FIELD(eref);
1275         READ_ENUM_FIELD(rtekind, RTEKind);
1276
1277         switch (local_node->rtekind)
1278         {
1279                 case RTE_RELATION:
1280                         READ_OID_FIELD(relid);
1281                         READ_CHAR_FIELD(relkind);
1282                         READ_NODE_FIELD(tablesample);
1283                         break;
1284                 case RTE_SUBQUERY:
1285                         READ_NODE_FIELD(subquery);
1286                         READ_BOOL_FIELD(security_barrier);
1287                         break;
1288                 case RTE_JOIN:
1289                         READ_ENUM_FIELD(jointype, JoinType);
1290                         READ_NODE_FIELD(joinaliasvars);
1291                         break;
1292                 case RTE_FUNCTION:
1293                         READ_NODE_FIELD(functions);
1294                         READ_BOOL_FIELD(funcordinality);
1295                         break;
1296                 case RTE_VALUES:
1297                         READ_NODE_FIELD(values_lists);
1298                         READ_NODE_FIELD(values_collations);
1299                         break;
1300                 case RTE_CTE:
1301                         READ_STRING_FIELD(ctename);
1302                         READ_UINT_FIELD(ctelevelsup);
1303                         READ_BOOL_FIELD(self_reference);
1304                         READ_NODE_FIELD(ctecoltypes);
1305                         READ_NODE_FIELD(ctecoltypmods);
1306                         READ_NODE_FIELD(ctecolcollations);
1307                         break;
1308                 default:
1309                         elog(ERROR, "unrecognized RTE kind: %d",
1310                                  (int) local_node->rtekind);
1311                         break;
1312         }
1313
1314         READ_BOOL_FIELD(lateral);
1315         READ_BOOL_FIELD(inh);
1316         READ_BOOL_FIELD(inFromCl);
1317         READ_UINT_FIELD(requiredPerms);
1318         READ_OID_FIELD(checkAsUser);
1319         READ_BITMAPSET_FIELD(selectedCols);
1320         READ_BITMAPSET_FIELD(insertedCols);
1321         READ_BITMAPSET_FIELD(updatedCols);
1322         READ_NODE_FIELD(securityQuals);
1323
1324         READ_DONE();
1325 }
1326
1327 /*
1328  * _readRangeTblFunction
1329  */
1330 static RangeTblFunction *
1331 _readRangeTblFunction(void)
1332 {
1333         READ_LOCALS(RangeTblFunction);
1334
1335         READ_NODE_FIELD(funcexpr);
1336         READ_INT_FIELD(funccolcount);
1337         READ_NODE_FIELD(funccolnames);
1338         READ_NODE_FIELD(funccoltypes);
1339         READ_NODE_FIELD(funccoltypmods);
1340         READ_NODE_FIELD(funccolcollations);
1341         READ_BITMAPSET_FIELD(funcparams);
1342
1343         READ_DONE();
1344 }
1345
1346 /*
1347  * _readTableSampleClause
1348  */
1349 static TableSampleClause *
1350 _readTableSampleClause(void)
1351 {
1352         READ_LOCALS(TableSampleClause);
1353
1354         READ_OID_FIELD(tsmhandler);
1355         READ_NODE_FIELD(args);
1356         READ_NODE_FIELD(repeatable);
1357
1358         READ_DONE();
1359 }
1360
1361 /*
1362  * _readDefElem
1363  */
1364 static DefElem *
1365 _readDefElem(void)
1366 {
1367         READ_LOCALS(DefElem);
1368
1369         READ_STRING_FIELD(defnamespace);
1370         READ_STRING_FIELD(defname);
1371         READ_NODE_FIELD(arg);
1372         READ_ENUM_FIELD(defaction, DefElemAction);
1373
1374         READ_DONE();
1375 }
1376
1377 /*
1378  * _readPlannedStmt
1379  */
1380 static PlannedStmt *
1381 _readPlannedStmt(void)
1382 {
1383         READ_LOCALS(PlannedStmt);
1384
1385         READ_ENUM_FIELD(commandType, CmdType);
1386         READ_UINT_FIELD(queryId);
1387         READ_BOOL_FIELD(hasReturning);
1388         READ_BOOL_FIELD(hasModifyingCTE);
1389         READ_BOOL_FIELD(canSetTag);
1390         READ_BOOL_FIELD(transientPlan);
1391         READ_NODE_FIELD(planTree);
1392         READ_NODE_FIELD(rtable);
1393         READ_NODE_FIELD(resultRelations);
1394         READ_NODE_FIELD(utilityStmt);
1395         READ_NODE_FIELD(subplans);
1396         READ_BITMAPSET_FIELD(rewindPlanIDs);
1397         READ_NODE_FIELD(rowMarks);
1398         READ_NODE_FIELD(relationOids);
1399         READ_NODE_FIELD(invalItems);
1400         READ_INT_FIELD(nParamExec);
1401         READ_BOOL_FIELD(hasRowSecurity);
1402         READ_BOOL_FIELD(parallelModeNeeded);
1403         READ_BOOL_FIELD(hasForeignJoin);
1404
1405         READ_DONE();
1406 }
1407
1408 /*
1409  * ReadCommonPlan
1410  *      Assign the basic stuff of all nodes that inherit from Plan
1411  */
1412 static void
1413 ReadCommonPlan(Plan *local_node)
1414 {
1415         READ_TEMP_LOCALS();
1416
1417         READ_FLOAT_FIELD(startup_cost);
1418         READ_FLOAT_FIELD(total_cost);
1419         READ_FLOAT_FIELD(plan_rows);
1420         READ_INT_FIELD(plan_width);
1421         READ_BOOL_FIELD(parallel_aware);
1422         READ_INT_FIELD(plan_node_id);
1423         READ_NODE_FIELD(targetlist);
1424         READ_NODE_FIELD(qual);
1425         READ_NODE_FIELD(lefttree);
1426         READ_NODE_FIELD(righttree);
1427         READ_NODE_FIELD(initPlan);
1428         READ_BITMAPSET_FIELD(extParam);
1429         READ_BITMAPSET_FIELD(allParam);
1430 }
1431
1432 /*
1433  * _readPlan
1434  */
1435 static Plan *
1436 _readPlan(void)
1437 {
1438         READ_LOCALS_NO_FIELDS(Plan);
1439
1440         ReadCommonPlan(local_node);
1441
1442         READ_DONE();
1443 }
1444
1445 /*
1446  * _readResult
1447  */
1448 static Result *
1449 _readResult(void)
1450 {
1451         READ_LOCALS(Result);
1452
1453         ReadCommonPlan(&local_node->plan);
1454
1455         READ_NODE_FIELD(resconstantqual);
1456
1457         READ_DONE();
1458 }
1459
1460 /*
1461  * _readModifyTable
1462  */
1463 static ModifyTable *
1464 _readModifyTable(void)
1465 {
1466         READ_LOCALS(ModifyTable);
1467
1468         ReadCommonPlan(&local_node->plan);
1469
1470         READ_ENUM_FIELD(operation, CmdType);
1471         READ_BOOL_FIELD(canSetTag);
1472         READ_UINT_FIELD(nominalRelation);
1473         READ_NODE_FIELD(resultRelations);
1474         READ_INT_FIELD(resultRelIndex);
1475         READ_NODE_FIELD(plans);
1476         READ_NODE_FIELD(withCheckOptionLists);
1477         READ_NODE_FIELD(returningLists);
1478         READ_NODE_FIELD(fdwPrivLists);
1479         READ_BITMAPSET_FIELD(fdwDirectModifyPlans);
1480         READ_NODE_FIELD(rowMarks);
1481         READ_INT_FIELD(epqParam);
1482         READ_ENUM_FIELD(onConflictAction, OnConflictAction);
1483         READ_NODE_FIELD(arbiterIndexes);
1484         READ_NODE_FIELD(onConflictSet);
1485         READ_NODE_FIELD(onConflictWhere);
1486         READ_UINT_FIELD(exclRelRTI);
1487         READ_NODE_FIELD(exclRelTlist);
1488
1489         READ_DONE();
1490 }
1491
1492 /*
1493  * _readAppend
1494  */
1495 static Append *
1496 _readAppend(void)
1497 {
1498         READ_LOCALS(Append);
1499
1500         ReadCommonPlan(&local_node->plan);
1501
1502         READ_NODE_FIELD(appendplans);
1503
1504         READ_DONE();
1505 }
1506
1507 /*
1508  * _readMergeAppend
1509  */
1510 static MergeAppend *
1511 _readMergeAppend(void)
1512 {
1513         READ_LOCALS(MergeAppend);
1514
1515         ReadCommonPlan(&local_node->plan);
1516
1517         READ_NODE_FIELD(mergeplans);
1518         READ_INT_FIELD(numCols);
1519         READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
1520         READ_OID_ARRAY(sortOperators, local_node->numCols);
1521         READ_OID_ARRAY(collations, local_node->numCols);
1522         READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
1523
1524         READ_DONE();
1525 }
1526
1527 /*
1528  * _readRecursiveUnion
1529  */
1530 static RecursiveUnion *
1531 _readRecursiveUnion(void)
1532 {
1533         READ_LOCALS(RecursiveUnion);
1534
1535         ReadCommonPlan(&local_node->plan);
1536
1537         READ_INT_FIELD(wtParam);
1538         READ_INT_FIELD(numCols);
1539         READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
1540         READ_OID_ARRAY(dupOperators, local_node->numCols);
1541         READ_LONG_FIELD(numGroups);
1542
1543         READ_DONE();
1544 }
1545
1546 /*
1547  * _readBitmapAnd
1548  */
1549 static BitmapAnd *
1550 _readBitmapAnd(void)
1551 {
1552         READ_LOCALS(BitmapAnd);
1553
1554         ReadCommonPlan(&local_node->plan);
1555
1556         READ_NODE_FIELD(bitmapplans);
1557
1558         READ_DONE();
1559 }
1560
1561 /*
1562  * _readBitmapOr
1563  */
1564 static BitmapOr *
1565 _readBitmapOr(void)
1566 {
1567         READ_LOCALS(BitmapOr);
1568
1569         ReadCommonPlan(&local_node->plan);
1570
1571         READ_NODE_FIELD(bitmapplans);
1572
1573         READ_DONE();
1574 }
1575
1576 /*
1577  * ReadCommonScan
1578  *      Assign the basic stuff of all nodes that inherit from Scan
1579  */
1580 static void
1581 ReadCommonScan(Scan *local_node)
1582 {
1583         READ_TEMP_LOCALS();
1584
1585         ReadCommonPlan(&local_node->plan);
1586
1587         READ_UINT_FIELD(scanrelid);
1588 }
1589
1590 /*
1591  * _readScan
1592  */
1593 static Scan *
1594 _readScan(void)
1595 {
1596         READ_LOCALS_NO_FIELDS(Scan);
1597
1598         ReadCommonScan(local_node);
1599
1600         READ_DONE();
1601 }
1602
1603 /*
1604  * _readSeqScan
1605  */
1606 static SeqScan *
1607 _readSeqScan(void)
1608 {
1609         READ_LOCALS_NO_FIELDS(SeqScan);
1610
1611         ReadCommonScan(local_node);
1612
1613         READ_DONE();
1614 }
1615
1616 /*
1617  * _readSampleScan
1618  */
1619 static SampleScan *
1620 _readSampleScan(void)
1621 {
1622         READ_LOCALS(SampleScan);
1623
1624         ReadCommonScan(&local_node->scan);
1625
1626         READ_NODE_FIELD(tablesample);
1627
1628         READ_DONE();
1629 }
1630
1631 /*
1632  * _readIndexScan
1633  */
1634 static IndexScan *
1635 _readIndexScan(void)
1636 {
1637         READ_LOCALS(IndexScan);
1638
1639         ReadCommonScan(&local_node->scan);
1640
1641         READ_OID_FIELD(indexid);
1642         READ_NODE_FIELD(indexqual);
1643         READ_NODE_FIELD(indexqualorig);
1644         READ_NODE_FIELD(indexorderby);
1645         READ_NODE_FIELD(indexorderbyorig);
1646         READ_NODE_FIELD(indexorderbyops);
1647         READ_ENUM_FIELD(indexorderdir, ScanDirection);
1648
1649         READ_DONE();
1650 }
1651
1652 /*
1653  * _readIndexOnlyScan
1654  */
1655 static IndexOnlyScan *
1656 _readIndexOnlyScan(void)
1657 {
1658         READ_LOCALS(IndexOnlyScan);
1659
1660         ReadCommonScan(&local_node->scan);
1661
1662         READ_OID_FIELD(indexid);
1663         READ_NODE_FIELD(indexqual);
1664         READ_NODE_FIELD(indexorderby);
1665         READ_NODE_FIELD(indextlist);
1666         READ_ENUM_FIELD(indexorderdir, ScanDirection);
1667
1668         READ_DONE();
1669 }
1670
1671 /*
1672  * _readBitmapIndexScan
1673  */
1674 static BitmapIndexScan *
1675 _readBitmapIndexScan(void)
1676 {
1677         READ_LOCALS(BitmapIndexScan);
1678
1679         ReadCommonScan(&local_node->scan);
1680
1681         READ_OID_FIELD(indexid);
1682         READ_NODE_FIELD(indexqual);
1683         READ_NODE_FIELD(indexqualorig);
1684
1685         READ_DONE();
1686 }
1687
1688 /*
1689  * _readBitmapHeapScan
1690  */
1691 static BitmapHeapScan *
1692 _readBitmapHeapScan(void)
1693 {
1694         READ_LOCALS(BitmapHeapScan);
1695
1696         ReadCommonScan(&local_node->scan);
1697
1698         READ_NODE_FIELD(bitmapqualorig);
1699
1700         READ_DONE();
1701 }
1702
1703 /*
1704  * _readTidScan
1705  */
1706 static TidScan *
1707 _readTidScan(void)
1708 {
1709         READ_LOCALS(TidScan);
1710
1711         ReadCommonScan(&local_node->scan);
1712
1713         READ_NODE_FIELD(tidquals);
1714
1715         READ_DONE();
1716 }
1717
1718 /*
1719  * _readSubqueryScan
1720  */
1721 static SubqueryScan *
1722 _readSubqueryScan(void)
1723 {
1724         READ_LOCALS(SubqueryScan);
1725
1726         ReadCommonScan(&local_node->scan);
1727
1728         READ_NODE_FIELD(subplan);
1729
1730         READ_DONE();
1731 }
1732
1733 /*
1734  * _readFunctionScan
1735  */
1736 static FunctionScan *
1737 _readFunctionScan(void)
1738 {
1739         READ_LOCALS(FunctionScan);
1740
1741         ReadCommonScan(&local_node->scan);
1742
1743         READ_NODE_FIELD(functions);
1744         READ_BOOL_FIELD(funcordinality);
1745
1746         READ_DONE();
1747 }
1748
1749 /*
1750  * _readValuesScan
1751  */
1752 static ValuesScan *
1753 _readValuesScan(void)
1754 {
1755         READ_LOCALS(ValuesScan);
1756
1757         ReadCommonScan(&local_node->scan);
1758
1759         READ_NODE_FIELD(values_lists);
1760
1761         READ_DONE();
1762 }
1763
1764 /*
1765  * _readCteScan
1766  */
1767 static CteScan *
1768 _readCteScan(void)
1769 {
1770         READ_LOCALS(CteScan);
1771
1772         ReadCommonScan(&local_node->scan);
1773
1774         READ_INT_FIELD(ctePlanId);
1775         READ_INT_FIELD(cteParam);
1776
1777         READ_DONE();
1778 }
1779
1780 /*
1781  * _readWorkTableScan
1782  */
1783 static WorkTableScan *
1784 _readWorkTableScan(void)
1785 {
1786         READ_LOCALS(WorkTableScan);
1787
1788         ReadCommonScan(&local_node->scan);
1789
1790         READ_INT_FIELD(wtParam);
1791
1792         READ_DONE();
1793 }
1794
1795 /*
1796  * _readForeignScan
1797  */
1798 static ForeignScan *
1799 _readForeignScan(void)
1800 {
1801         READ_LOCALS(ForeignScan);
1802
1803         ReadCommonScan(&local_node->scan);
1804
1805         READ_ENUM_FIELD(operation, CmdType);
1806         READ_OID_FIELD(fs_server);
1807         READ_NODE_FIELD(fdw_exprs);
1808         READ_NODE_FIELD(fdw_private);
1809         READ_NODE_FIELD(fdw_scan_tlist);
1810         READ_NODE_FIELD(fdw_recheck_quals);
1811         READ_BITMAPSET_FIELD(fs_relids);
1812         READ_BOOL_FIELD(fsSystemCol);
1813
1814         READ_DONE();
1815 }
1816
1817 /*
1818  * _readCustomScan
1819  */
1820 static CustomScan *
1821 _readCustomScan(void)
1822 {
1823         READ_LOCALS(CustomScan);
1824         char       *custom_name;
1825         const CustomScanMethods *methods;
1826
1827         ReadCommonScan(&local_node->scan);
1828
1829         READ_UINT_FIELD(flags);
1830         READ_NODE_FIELD(custom_plans);
1831         READ_NODE_FIELD(custom_exprs);
1832         READ_NODE_FIELD(custom_private);
1833         READ_NODE_FIELD(custom_scan_tlist);
1834         READ_BITMAPSET_FIELD(custom_relids);
1835
1836         /* Lookup CustomScanMethods by CustomName */
1837         token = pg_strtok(&length);             /* skip methods: */
1838         token = pg_strtok(&length);             /* CustomName */
1839         custom_name = nullable_string(token, length);
1840         methods = GetCustomScanMethods(custom_name, false);
1841         local_node->methods = methods;
1842
1843         READ_DONE();
1844 }
1845
1846 /*
1847  * ReadCommonJoin
1848  *      Assign the basic stuff of all nodes that inherit from Join
1849  */
1850 static void
1851 ReadCommonJoin(Join *local_node)
1852 {
1853         READ_TEMP_LOCALS();
1854
1855         ReadCommonPlan(&local_node->plan);
1856
1857         READ_ENUM_FIELD(jointype, JoinType);
1858         READ_NODE_FIELD(joinqual);
1859 }
1860
1861 /*
1862  * _readJoin
1863  */
1864 static Join *
1865 _readJoin(void)
1866 {
1867         READ_LOCALS_NO_FIELDS(Join);
1868
1869         ReadCommonJoin(local_node);
1870
1871         READ_DONE();
1872 }
1873
1874 /*
1875  * _readNestLoop
1876  */
1877 static NestLoop *
1878 _readNestLoop(void)
1879 {
1880         READ_LOCALS(NestLoop);
1881
1882         ReadCommonJoin(&local_node->join);
1883
1884         READ_NODE_FIELD(nestParams);
1885
1886         READ_DONE();
1887 }
1888
1889 /*
1890  * _readMergeJoin
1891  */
1892 static MergeJoin *
1893 _readMergeJoin(void)
1894 {
1895         int                     numCols;
1896
1897         READ_LOCALS(MergeJoin);
1898
1899         ReadCommonJoin(&local_node->join);
1900
1901         READ_NODE_FIELD(mergeclauses);
1902
1903         numCols = list_length(local_node->mergeclauses);
1904
1905         READ_OID_ARRAY(mergeFamilies, numCols);
1906         READ_OID_ARRAY(mergeCollations, numCols);
1907         READ_INT_ARRAY(mergeStrategies, numCols);
1908         READ_BOOL_ARRAY(mergeNullsFirst, numCols);
1909
1910         READ_DONE();
1911 }
1912
1913 /*
1914  * _readHashJoin
1915  */
1916 static HashJoin *
1917 _readHashJoin(void)
1918 {
1919         READ_LOCALS(HashJoin);
1920
1921         ReadCommonJoin(&local_node->join);
1922
1923         READ_NODE_FIELD(hashclauses);
1924
1925         READ_DONE();
1926 }
1927
1928 /*
1929  * _readMaterial
1930  */
1931 static Material *
1932 _readMaterial(void)
1933 {
1934         READ_LOCALS_NO_FIELDS(Material);
1935
1936         ReadCommonPlan(&local_node->plan);
1937
1938         READ_DONE();
1939 }
1940
1941 /*
1942  * _readSort
1943  */
1944 static Sort *
1945 _readSort(void)
1946 {
1947         READ_LOCALS(Sort);
1948
1949         ReadCommonPlan(&local_node->plan);
1950
1951         READ_INT_FIELD(numCols);
1952         READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
1953         READ_OID_ARRAY(sortOperators, local_node->numCols);
1954         READ_OID_ARRAY(collations, local_node->numCols);
1955         READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
1956
1957         READ_DONE();
1958 }
1959
1960 /*
1961  * _readGroup
1962  */
1963 static Group *
1964 _readGroup(void)
1965 {
1966         READ_LOCALS(Group);
1967
1968         ReadCommonPlan(&local_node->plan);
1969
1970         READ_INT_FIELD(numCols);
1971         READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
1972         READ_OID_ARRAY(grpOperators, local_node->numCols);
1973
1974         READ_DONE();
1975 }
1976
1977 /*
1978  * _readAgg
1979  */
1980 static Agg *
1981 _readAgg(void)
1982 {
1983         READ_LOCALS(Agg);
1984
1985         ReadCommonPlan(&local_node->plan);
1986
1987         READ_ENUM_FIELD(aggstrategy, AggStrategy);
1988         READ_BOOL_FIELD(combineStates);
1989         READ_BOOL_FIELD(finalizeAggs);
1990         READ_BOOL_FIELD(serialStates);
1991         READ_INT_FIELD(numCols);
1992         READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
1993         READ_OID_ARRAY(grpOperators, local_node->numCols);
1994         READ_LONG_FIELD(numGroups);
1995         READ_NODE_FIELD(groupingSets);
1996         READ_NODE_FIELD(chain);
1997
1998         READ_DONE();
1999 }
2000
2001 /*
2002  * _readWindowAgg
2003  */
2004 static WindowAgg *
2005 _readWindowAgg(void)
2006 {
2007         READ_LOCALS(WindowAgg);
2008
2009         ReadCommonPlan(&local_node->plan);
2010
2011         READ_UINT_FIELD(winref);
2012         READ_INT_FIELD(partNumCols);
2013         READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
2014         READ_OID_ARRAY(partOperators, local_node->partNumCols);
2015         READ_INT_FIELD(ordNumCols);
2016         READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
2017         READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
2018         READ_INT_FIELD(frameOptions);
2019         READ_NODE_FIELD(startOffset);
2020         READ_NODE_FIELD(endOffset);
2021
2022         READ_DONE();
2023 }
2024
2025 /*
2026  * _readUnique
2027  */
2028 static Unique *
2029 _readUnique(void)
2030 {
2031         READ_LOCALS(Unique);
2032
2033         ReadCommonPlan(&local_node->plan);
2034
2035         READ_INT_FIELD(numCols);
2036         READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
2037         READ_OID_ARRAY(uniqOperators, local_node->numCols);
2038
2039         READ_DONE();
2040 }
2041
2042 /*
2043  * _readGather
2044  */
2045 static Gather *
2046 _readGather(void)
2047 {
2048         READ_LOCALS(Gather);
2049
2050         ReadCommonPlan(&local_node->plan);
2051
2052         READ_INT_FIELD(num_workers);
2053         READ_BOOL_FIELD(single_copy);
2054         READ_BOOL_FIELD(invisible);
2055
2056         READ_DONE();
2057 }
2058
2059 /*
2060  * _readHash
2061  */
2062 static Hash *
2063 _readHash(void)
2064 {
2065         READ_LOCALS(Hash);
2066
2067         ReadCommonPlan(&local_node->plan);
2068
2069         READ_OID_FIELD(skewTable);
2070         READ_INT_FIELD(skewColumn);
2071         READ_BOOL_FIELD(skewInherit);
2072         READ_OID_FIELD(skewColType);
2073         READ_INT_FIELD(skewColTypmod);
2074
2075         READ_DONE();
2076 }
2077
2078 /*
2079  * _readSetOp
2080  */
2081 static SetOp *
2082 _readSetOp(void)
2083 {
2084         READ_LOCALS(SetOp);
2085
2086         ReadCommonPlan(&local_node->plan);
2087
2088         READ_ENUM_FIELD(cmd, SetOpCmd);
2089         READ_ENUM_FIELD(strategy, SetOpStrategy);
2090         READ_INT_FIELD(numCols);
2091         READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
2092         READ_OID_ARRAY(dupOperators, local_node->numCols);
2093         READ_INT_FIELD(flagColIdx);
2094         READ_INT_FIELD(firstFlag);
2095         READ_LONG_FIELD(numGroups);
2096
2097         READ_DONE();
2098 }
2099
2100 /*
2101  * _readLockRows
2102  */
2103 static LockRows *
2104 _readLockRows(void)
2105 {
2106         READ_LOCALS(LockRows);
2107
2108         ReadCommonPlan(&local_node->plan);
2109
2110         READ_NODE_FIELD(rowMarks);
2111         READ_INT_FIELD(epqParam);
2112
2113         READ_DONE();
2114 }
2115
2116 /*
2117  * _readLimit
2118  */
2119 static Limit *
2120 _readLimit(void)
2121 {
2122         READ_LOCALS(Limit);
2123
2124         ReadCommonPlan(&local_node->plan);
2125
2126         READ_NODE_FIELD(limitOffset);
2127         READ_NODE_FIELD(limitCount);
2128
2129         READ_DONE();
2130 }
2131
2132 /*
2133  * _readNestLoopParam
2134  */
2135 static NestLoopParam *
2136 _readNestLoopParam(void)
2137 {
2138         READ_LOCALS(NestLoopParam);
2139
2140         READ_INT_FIELD(paramno);
2141         READ_NODE_FIELD(paramval);
2142
2143         READ_DONE();
2144 }
2145
2146 /*
2147  * _readPlanRowMark
2148  */
2149 static PlanRowMark *
2150 _readPlanRowMark(void)
2151 {
2152         READ_LOCALS(PlanRowMark);
2153
2154         READ_UINT_FIELD(rti);
2155         READ_UINT_FIELD(prti);
2156         READ_UINT_FIELD(rowmarkId);
2157         READ_ENUM_FIELD(markType, RowMarkType);
2158         READ_INT_FIELD(allMarkTypes);
2159         READ_ENUM_FIELD(strength, LockClauseStrength);
2160         READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
2161         READ_BOOL_FIELD(isParent);
2162
2163         READ_DONE();
2164 }
2165
2166 /*
2167  * _readPlanInvalItem
2168  */
2169 static PlanInvalItem *
2170 _readPlanInvalItem(void)
2171 {
2172         READ_LOCALS(PlanInvalItem);
2173
2174         READ_INT_FIELD(cacheId);
2175         READ_UINT_FIELD(hashValue);
2176
2177         READ_DONE();
2178 }
2179
2180 /*
2181  * _readSubPlan
2182  */
2183 static SubPlan *
2184 _readSubPlan(void)
2185 {
2186         READ_LOCALS(SubPlan);
2187
2188         READ_ENUM_FIELD(subLinkType, SubLinkType);
2189         READ_NODE_FIELD(testexpr);
2190         READ_NODE_FIELD(paramIds);
2191         READ_INT_FIELD(plan_id);
2192         READ_STRING_FIELD(plan_name);
2193         READ_OID_FIELD(firstColType);
2194         READ_INT_FIELD(firstColTypmod);
2195         READ_OID_FIELD(firstColCollation);
2196         READ_BOOL_FIELD(useHashTable);
2197         READ_BOOL_FIELD(unknownEqFalse);
2198         READ_NODE_FIELD(setParam);
2199         READ_NODE_FIELD(parParam);
2200         READ_NODE_FIELD(args);
2201         READ_FLOAT_FIELD(startup_cost);
2202         READ_FLOAT_FIELD(per_call_cost);
2203
2204         READ_DONE();
2205 }
2206
2207 /*
2208  * _readAlternativeSubPlan
2209  */
2210 static AlternativeSubPlan *
2211 _readAlternativeSubPlan(void)
2212 {
2213         READ_LOCALS(AlternativeSubPlan);
2214
2215         READ_NODE_FIELD(subplans);
2216
2217         READ_DONE();
2218 }
2219
2220 /*
2221  * _readExtensibleNode
2222  */
2223 static ExtensibleNode *
2224 _readExtensibleNode(void)
2225 {
2226         const ExtensibleNodeMethods *methods;
2227         ExtensibleNode *local_node;
2228         const char         *extnodename;
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 }