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_INT_FIELD(numCols);
1997         READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
1998         READ_OID_ARRAY(grpOperators, local_node->numCols);
1999         READ_LONG_FIELD(numGroups);
2000         READ_NODE_FIELD(groupingSets);
2001         READ_NODE_FIELD(chain);
2002
2003         READ_DONE();
2004 }
2005
2006 /*
2007  * _readWindowAgg
2008  */
2009 static WindowAgg *
2010 _readWindowAgg(void)
2011 {
2012         READ_LOCALS(WindowAgg);
2013
2014         ReadCommonPlan(&local_node->plan);
2015
2016         READ_UINT_FIELD(winref);
2017         READ_INT_FIELD(partNumCols);
2018         READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
2019         READ_OID_ARRAY(partOperators, local_node->partNumCols);
2020         READ_INT_FIELD(ordNumCols);
2021         READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
2022         READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
2023         READ_INT_FIELD(frameOptions);
2024         READ_NODE_FIELD(startOffset);
2025         READ_NODE_FIELD(endOffset);
2026
2027         READ_DONE();
2028 }
2029
2030 /*
2031  * _readUnique
2032  */
2033 static Unique *
2034 _readUnique(void)
2035 {
2036         READ_LOCALS(Unique);
2037
2038         ReadCommonPlan(&local_node->plan);
2039
2040         READ_INT_FIELD(numCols);
2041         READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
2042         READ_OID_ARRAY(uniqOperators, local_node->numCols);
2043
2044         READ_DONE();
2045 }
2046
2047 /*
2048  * _readGather
2049  */
2050 static Gather *
2051 _readGather(void)
2052 {
2053         READ_LOCALS(Gather);
2054
2055         ReadCommonPlan(&local_node->plan);
2056
2057         READ_INT_FIELD(num_workers);
2058         READ_BOOL_FIELD(single_copy);
2059         READ_BOOL_FIELD(invisible);
2060
2061         READ_DONE();
2062 }
2063
2064 /*
2065  * _readHash
2066  */
2067 static Hash *
2068 _readHash(void)
2069 {
2070         READ_LOCALS(Hash);
2071
2072         ReadCommonPlan(&local_node->plan);
2073
2074         READ_OID_FIELD(skewTable);
2075         READ_INT_FIELD(skewColumn);
2076         READ_BOOL_FIELD(skewInherit);
2077         READ_OID_FIELD(skewColType);
2078         READ_INT_FIELD(skewColTypmod);
2079
2080         READ_DONE();
2081 }
2082
2083 /*
2084  * _readSetOp
2085  */
2086 static SetOp *
2087 _readSetOp(void)
2088 {
2089         READ_LOCALS(SetOp);
2090
2091         ReadCommonPlan(&local_node->plan);
2092
2093         READ_ENUM_FIELD(cmd, SetOpCmd);
2094         READ_ENUM_FIELD(strategy, SetOpStrategy);
2095         READ_INT_FIELD(numCols);
2096         READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
2097         READ_OID_ARRAY(dupOperators, local_node->numCols);
2098         READ_INT_FIELD(flagColIdx);
2099         READ_INT_FIELD(firstFlag);
2100         READ_LONG_FIELD(numGroups);
2101
2102         READ_DONE();
2103 }
2104
2105 /*
2106  * _readLockRows
2107  */
2108 static LockRows *
2109 _readLockRows(void)
2110 {
2111         READ_LOCALS(LockRows);
2112
2113         ReadCommonPlan(&local_node->plan);
2114
2115         READ_NODE_FIELD(rowMarks);
2116         READ_INT_FIELD(epqParam);
2117
2118         READ_DONE();
2119 }
2120
2121 /*
2122  * _readLimit
2123  */
2124 static Limit *
2125 _readLimit(void)
2126 {
2127         READ_LOCALS(Limit);
2128
2129         ReadCommonPlan(&local_node->plan);
2130
2131         READ_NODE_FIELD(limitOffset);
2132         READ_NODE_FIELD(limitCount);
2133
2134         READ_DONE();
2135 }
2136
2137 /*
2138  * _readNestLoopParam
2139  */
2140 static NestLoopParam *
2141 _readNestLoopParam(void)
2142 {
2143         READ_LOCALS(NestLoopParam);
2144
2145         READ_INT_FIELD(paramno);
2146         READ_NODE_FIELD(paramval);
2147
2148         READ_DONE();
2149 }
2150
2151 /*
2152  * _readPlanRowMark
2153  */
2154 static PlanRowMark *
2155 _readPlanRowMark(void)
2156 {
2157         READ_LOCALS(PlanRowMark);
2158
2159         READ_UINT_FIELD(rti);
2160         READ_UINT_FIELD(prti);
2161         READ_UINT_FIELD(rowmarkId);
2162         READ_ENUM_FIELD(markType, RowMarkType);
2163         READ_INT_FIELD(allMarkTypes);
2164         READ_ENUM_FIELD(strength, LockClauseStrength);
2165         READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
2166         READ_BOOL_FIELD(isParent);
2167
2168         READ_DONE();
2169 }
2170
2171 /*
2172  * _readPlanInvalItem
2173  */
2174 static PlanInvalItem *
2175 _readPlanInvalItem(void)
2176 {
2177         READ_LOCALS(PlanInvalItem);
2178
2179         READ_INT_FIELD(cacheId);
2180         READ_UINT_FIELD(hashValue);
2181
2182         READ_DONE();
2183 }
2184
2185 /*
2186  * _readSubPlan
2187  */
2188 static SubPlan *
2189 _readSubPlan(void)
2190 {
2191         READ_LOCALS(SubPlan);
2192
2193         READ_ENUM_FIELD(subLinkType, SubLinkType);
2194         READ_NODE_FIELD(testexpr);
2195         READ_NODE_FIELD(paramIds);
2196         READ_INT_FIELD(plan_id);
2197         READ_STRING_FIELD(plan_name);
2198         READ_OID_FIELD(firstColType);
2199         READ_INT_FIELD(firstColTypmod);
2200         READ_OID_FIELD(firstColCollation);
2201         READ_BOOL_FIELD(useHashTable);
2202         READ_BOOL_FIELD(unknownEqFalse);
2203         READ_NODE_FIELD(setParam);
2204         READ_NODE_FIELD(parParam);
2205         READ_NODE_FIELD(args);
2206         READ_FLOAT_FIELD(startup_cost);
2207         READ_FLOAT_FIELD(per_call_cost);
2208
2209         READ_DONE();
2210 }
2211
2212 /*
2213  * _readAlternativeSubPlan
2214  */
2215 static AlternativeSubPlan *
2216 _readAlternativeSubPlan(void)
2217 {
2218         READ_LOCALS(AlternativeSubPlan);
2219
2220         READ_NODE_FIELD(subplans);
2221
2222         READ_DONE();
2223 }
2224
2225 /*
2226  * _readExtensibleNode
2227  */
2228 static ExtensibleNode *
2229 _readExtensibleNode(void)
2230 {
2231         const ExtensibleNodeMethods *methods;
2232         ExtensibleNode *local_node;
2233         const char         *extnodename;
2234         READ_TEMP_LOCALS();
2235
2236         token = pg_strtok(&length);             /* skip: extnodename */
2237         token = pg_strtok(&length);             /* get extnodename */
2238
2239         extnodename = nullable_string(token, length);
2240         if (!extnodename)
2241                 elog(ERROR, "extnodename has to be supplied");
2242         methods = GetExtensibleNodeMethods(extnodename, false);
2243
2244         local_node = (ExtensibleNode *) newNode(methods->node_size,
2245                                                                                         T_ExtensibleNode);
2246         local_node->extnodename = extnodename;
2247
2248         /* deserialize the private fields */
2249         methods->nodeRead(local_node);
2250
2251         READ_DONE();
2252 }
2253
2254 /*
2255  * parseNodeString
2256  *
2257  * Given a character string representing a node tree, parseNodeString creates
2258  * the internal node structure.
2259  *
2260  * The string to be read must already have been loaded into pg_strtok().
2261  */
2262 Node *
2263 parseNodeString(void)
2264 {
2265         void       *return_value;
2266
2267         READ_TEMP_LOCALS();
2268
2269         token = pg_strtok(&length);
2270
2271 #define MATCH(tokname, namelen) \
2272         (length == namelen && memcmp(token, tokname, namelen) == 0)
2273
2274         if (MATCH("QUERY", 5))
2275                 return_value = _readQuery();
2276         else if (MATCH("WITHCHECKOPTION", 15))
2277                 return_value = _readWithCheckOption();
2278         else if (MATCH("SORTGROUPCLAUSE", 15))
2279                 return_value = _readSortGroupClause();
2280         else if (MATCH("GROUPINGSET", 11))
2281                 return_value = _readGroupingSet();
2282         else if (MATCH("WINDOWCLAUSE", 12))
2283                 return_value = _readWindowClause();
2284         else if (MATCH("ROWMARKCLAUSE", 13))
2285                 return_value = _readRowMarkClause();
2286         else if (MATCH("COMMONTABLEEXPR", 15))
2287                 return_value = _readCommonTableExpr();
2288         else if (MATCH("SETOPERATIONSTMT", 16))
2289                 return_value = _readSetOperationStmt();
2290         else if (MATCH("ALIAS", 5))
2291                 return_value = _readAlias();
2292         else if (MATCH("RANGEVAR", 8))
2293                 return_value = _readRangeVar();
2294         else if (MATCH("INTOCLAUSE", 10))
2295                 return_value = _readIntoClause();
2296         else if (MATCH("VAR", 3))
2297                 return_value = _readVar();
2298         else if (MATCH("CONST", 5))
2299                 return_value = _readConst();
2300         else if (MATCH("PARAM", 5))
2301                 return_value = _readParam();
2302         else if (MATCH("AGGREF", 6))
2303                 return_value = _readAggref();
2304         else if (MATCH("GROUPINGFUNC", 12))
2305                 return_value = _readGroupingFunc();
2306         else if (MATCH("WINDOWFUNC", 10))
2307                 return_value = _readWindowFunc();
2308         else if (MATCH("ARRAYREF", 8))
2309                 return_value = _readArrayRef();
2310         else if (MATCH("FUNCEXPR", 8))
2311                 return_value = _readFuncExpr();
2312         else if (MATCH("NAMEDARGEXPR", 12))
2313                 return_value = _readNamedArgExpr();
2314         else if (MATCH("OPEXPR", 6))
2315                 return_value = _readOpExpr();
2316         else if (MATCH("DISTINCTEXPR", 12))
2317                 return_value = _readDistinctExpr();
2318         else if (MATCH("NULLIFEXPR", 10))
2319                 return_value = _readNullIfExpr();
2320         else if (MATCH("SCALARARRAYOPEXPR", 17))
2321                 return_value = _readScalarArrayOpExpr();
2322         else if (MATCH("BOOLEXPR", 8))
2323                 return_value = _readBoolExpr();
2324         else if (MATCH("SUBLINK", 7))
2325                 return_value = _readSubLink();
2326         else if (MATCH("FIELDSELECT", 11))
2327                 return_value = _readFieldSelect();
2328         else if (MATCH("FIELDSTORE", 10))
2329                 return_value = _readFieldStore();
2330         else if (MATCH("RELABELTYPE", 11))
2331                 return_value = _readRelabelType();
2332         else if (MATCH("COERCEVIAIO", 11))
2333                 return_value = _readCoerceViaIO();
2334         else if (MATCH("ARRAYCOERCEEXPR", 15))
2335                 return_value = _readArrayCoerceExpr();
2336         else if (MATCH("CONVERTROWTYPEEXPR", 18))
2337                 return_value = _readConvertRowtypeExpr();
2338         else if (MATCH("COLLATE", 7))
2339                 return_value = _readCollateExpr();
2340         else if (MATCH("CASE", 4))
2341                 return_value = _readCaseExpr();
2342         else if (MATCH("WHEN", 4))
2343                 return_value = _readCaseWhen();
2344         else if (MATCH("CASETESTEXPR", 12))
2345                 return_value = _readCaseTestExpr();
2346         else if (MATCH("ARRAY", 5))
2347                 return_value = _readArrayExpr();
2348         else if (MATCH("ROW", 3))
2349                 return_value = _readRowExpr();
2350         else if (MATCH("ROWCOMPARE", 10))
2351                 return_value = _readRowCompareExpr();
2352         else if (MATCH("COALESCE", 8))
2353                 return_value = _readCoalesceExpr();
2354         else if (MATCH("MINMAX", 6))
2355                 return_value = _readMinMaxExpr();
2356         else if (MATCH("XMLEXPR", 7))
2357                 return_value = _readXmlExpr();
2358         else if (MATCH("NULLTEST", 8))
2359                 return_value = _readNullTest();
2360         else if (MATCH("BOOLEANTEST", 11))
2361                 return_value = _readBooleanTest();
2362         else if (MATCH("COERCETODOMAIN", 14))
2363                 return_value = _readCoerceToDomain();
2364         else if (MATCH("COERCETODOMAINVALUE", 19))
2365                 return_value = _readCoerceToDomainValue();
2366         else if (MATCH("SETTODEFAULT", 12))
2367                 return_value = _readSetToDefault();
2368         else if (MATCH("CURRENTOFEXPR", 13))
2369                 return_value = _readCurrentOfExpr();
2370         else if (MATCH("INFERENCEELEM", 13))
2371                 return_value = _readInferenceElem();
2372         else if (MATCH("TARGETENTRY", 11))
2373                 return_value = _readTargetEntry();
2374         else if (MATCH("RANGETBLREF", 11))
2375                 return_value = _readRangeTblRef();
2376         else if (MATCH("JOINEXPR", 8))
2377                 return_value = _readJoinExpr();
2378         else if (MATCH("FROMEXPR", 8))
2379                 return_value = _readFromExpr();
2380         else if (MATCH("ONCONFLICTEXPR", 14))
2381                 return_value = _readOnConflictExpr();
2382         else if (MATCH("RTE", 3))
2383                 return_value = _readRangeTblEntry();
2384         else if (MATCH("RANGETBLFUNCTION", 16))
2385                 return_value = _readRangeTblFunction();
2386         else if (MATCH("TABLESAMPLECLAUSE", 17))
2387                 return_value = _readTableSampleClause();
2388         else if (MATCH("NOTIFY", 6))
2389                 return_value = _readNotifyStmt();
2390         else if (MATCH("DEFELEM", 7))
2391                 return_value = _readDefElem();
2392         else if (MATCH("DECLARECURSOR", 13))
2393                 return_value = _readDeclareCursorStmt();
2394         else if (MATCH("PLANNEDSTMT", 11))
2395                 return_value = _readPlannedStmt();
2396         else if (MATCH("PLAN", 4))
2397                 return_value = _readPlan();
2398         else if (MATCH("RESULT", 6))
2399                 return_value = _readResult();
2400         else if (MATCH("MODIFYTABLE", 11))
2401                 return_value = _readModifyTable();
2402         else if (MATCH("APPEND", 6))
2403                 return_value = _readAppend();
2404         else if (MATCH("MERGEAPPEND", 11))
2405                 return_value = _readMergeAppend();
2406         else if (MATCH("RECURSIVEUNION", 14))
2407                 return_value = _readRecursiveUnion();
2408         else if (MATCH("BITMAPAND", 9))
2409                 return_value = _readBitmapAnd();
2410         else if (MATCH("BITMAPOR", 8))
2411                 return_value = _readBitmapOr();
2412         else if (MATCH("SCAN", 4))
2413                 return_value = _readScan();
2414         else if (MATCH("SEQSCAN", 7))
2415                 return_value = _readSeqScan();
2416         else if (MATCH("SAMPLESCAN", 10))
2417                 return_value = _readSampleScan();
2418         else if (MATCH("INDEXSCAN", 9))
2419                 return_value = _readIndexScan();
2420         else if (MATCH("INDEXONLYSCAN", 13))
2421                 return_value = _readIndexOnlyScan();
2422         else if (MATCH("BITMAPINDEXSCAN", 15))
2423                 return_value = _readBitmapIndexScan();
2424         else if (MATCH("BITMAPHEAPSCAN", 14))
2425                 return_value = _readBitmapHeapScan();
2426         else if (MATCH("TIDSCAN", 7))
2427                 return_value = _readTidScan();
2428         else if (MATCH("SUBQUERYSCAN", 12))
2429                 return_value = _readSubqueryScan();
2430         else if (MATCH("FUNCTIONSCAN", 12))
2431                 return_value = _readFunctionScan();
2432         else if (MATCH("VALUESSCAN", 10))
2433                 return_value = _readValuesScan();
2434         else if (MATCH("CTESCAN", 7))
2435                 return_value = _readCteScan();
2436         else if (MATCH("WORKTABLESCAN", 13))
2437                 return_value = _readWorkTableScan();
2438         else if (MATCH("FOREIGNSCAN", 11))
2439                 return_value = _readForeignScan();
2440         else if (MATCH("CUSTOMSCAN", 10))
2441                 return_value = _readCustomScan();
2442         else if (MATCH("JOIN", 4))
2443                 return_value = _readJoin();
2444         else if (MATCH("NESTLOOP", 8))
2445                 return_value = _readNestLoop();
2446         else if (MATCH("MERGEJOIN", 9))
2447                 return_value = _readMergeJoin();
2448         else if (MATCH("HASHJOIN", 8))
2449                 return_value = _readHashJoin();
2450         else if (MATCH("MATERIAL", 8))
2451                 return_value = _readMaterial();
2452         else if (MATCH("SORT", 4))
2453                 return_value = _readSort();
2454         else if (MATCH("GROUP", 5))
2455                 return_value = _readGroup();
2456         else if (MATCH("AGG", 3))
2457                 return_value = _readAgg();
2458         else if (MATCH("WINDOWAGG", 9))
2459                 return_value = _readWindowAgg();
2460         else if (MATCH("UNIQUE", 6))
2461                 return_value = _readUnique();
2462         else if (MATCH("GATHER", 6))
2463                 return_value = _readGather();
2464         else if (MATCH("HASH", 4))
2465                 return_value = _readHash();
2466         else if (MATCH("SETOP", 5))
2467                 return_value = _readSetOp();
2468         else if (MATCH("LOCKROWS", 8))
2469                 return_value = _readLockRows();
2470         else if (MATCH("LIMIT", 5))
2471                 return_value = _readLimit();
2472         else if (MATCH("NESTLOOPPARAM", 13))
2473                 return_value = _readNestLoopParam();
2474         else if (MATCH("PLANROWMARK", 11))
2475                 return_value = _readPlanRowMark();
2476         else if (MATCH("PLANINVALITEM", 13))
2477                 return_value = _readPlanInvalItem();
2478         else if (MATCH("SUBPLAN", 7))
2479                 return_value = _readSubPlan();
2480         else if (MATCH("ALTERNATIVESUBPLAN", 18))
2481                 return_value = _readAlternativeSubPlan();
2482         else if (MATCH("EXTENSIBLENODE", 14))
2483                 return_value = _readExtensibleNode();
2484         else
2485         {
2486                 elog(ERROR, "badly formatted node string \"%.32s\"...", token);
2487                 return_value = NULL;    /* keep compiler quiet */
2488         }
2489
2490         return (Node *) return_value;
2491 }
2492
2493
2494 /*
2495  * readDatum
2496  *
2497  * Given a string representation of a constant, recreate the appropriate
2498  * Datum.  The string representation embeds length info, but not byValue,
2499  * so we must be told that.
2500  */
2501 static Datum
2502 readDatum(bool typbyval)
2503 {
2504         Size            length,
2505                                 i;
2506         int                     tokenLength;
2507         char       *token;
2508         Datum           res;
2509         char       *s;
2510
2511         /*
2512          * read the actual length of the value
2513          */
2514         token = pg_strtok(&tokenLength);
2515         length = atoui(token);
2516
2517         token = pg_strtok(&tokenLength);        /* read the '[' */
2518         if (token == NULL || token[0] != '[')
2519                 elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
2520                          token ? (const char *) token : "[NULL]", length);
2521
2522         if (typbyval)
2523         {
2524                 if (length > (Size) sizeof(Datum))
2525                         elog(ERROR, "byval datum but length = %zu", length);
2526                 res = (Datum) 0;
2527                 s = (char *) (&res);
2528                 for (i = 0; i < (Size) sizeof(Datum); i++)
2529                 {
2530                         token = pg_strtok(&tokenLength);
2531                         s[i] = (char) atoi(token);
2532                 }
2533         }
2534         else if (length <= 0)
2535                 res = (Datum) NULL;
2536         else
2537         {
2538                 s = (char *) palloc(length);
2539                 for (i = 0; i < length; i++)
2540                 {
2541                         token = pg_strtok(&tokenLength);
2542                         s[i] = (char) atoi(token);
2543                 }
2544                 res = PointerGetDatum(s);
2545         }
2546
2547         token = pg_strtok(&tokenLength);        /* read the ']' */
2548         if (token == NULL || token[0] != ']')
2549                 elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
2550                          token ? (const char *) token : "[NULL]", length);
2551
2552         return res;
2553 }
2554
2555 /*
2556  * readAttrNumberCols
2557  */
2558 static AttrNumber *
2559 readAttrNumberCols(int numCols)
2560 {
2561         int                     tokenLength,
2562                                 i;
2563         char       *token;
2564         AttrNumber *attr_vals;
2565
2566         if (numCols <= 0)
2567                 return NULL;
2568
2569         attr_vals = (AttrNumber *) palloc(numCols * sizeof(AttrNumber));
2570         for (i = 0; i < numCols; i++)
2571         {
2572                 token = pg_strtok(&tokenLength);
2573                 attr_vals[i] = atoi(token);
2574         }
2575
2576         return attr_vals;
2577 }
2578
2579 /*
2580  * readOidCols
2581  */
2582 static Oid *
2583 readOidCols(int numCols)
2584 {
2585         int                     tokenLength,
2586                                 i;
2587         char       *token;
2588         Oid                *oid_vals;
2589
2590         if (numCols <= 0)
2591                 return NULL;
2592
2593         oid_vals = (Oid *) palloc(numCols * sizeof(Oid));
2594         for (i = 0; i < numCols; i++)
2595         {
2596                 token = pg_strtok(&tokenLength);
2597                 oid_vals[i] = atooid(token);
2598         }
2599
2600         return oid_vals;
2601 }
2602
2603 /*
2604  * readIntCols
2605  */
2606 static int *
2607 readIntCols(int numCols)
2608 {
2609         int                     tokenLength,
2610                                 i;
2611         char       *token;
2612         int                *int_vals;
2613
2614         if (numCols <= 0)
2615                 return NULL;
2616
2617         int_vals = (int *) palloc(numCols * sizeof(int));
2618         for (i = 0; i < numCols; i++)
2619         {
2620                 token = pg_strtok(&tokenLength);
2621                 int_vals[i] = atoi(token);
2622         }
2623
2624         return int_vals;
2625 }
2626
2627 /*
2628  * readBoolCols
2629  */
2630 static bool *
2631 readBoolCols(int numCols)
2632 {
2633         int                     tokenLength,
2634                                 i;
2635         char       *token;
2636         bool       *bool_vals;
2637
2638         if (numCols <= 0)
2639                 return NULL;
2640
2641         bool_vals = (bool *) palloc(numCols * sizeof(bool));
2642         for (i = 0; i < numCols; i++)
2643         {
2644                 token = pg_strtok(&tokenLength);
2645                 bool_vals[i] = strtobool(token);
2646         }
2647
2648         return bool_vals;
2649 }