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