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