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