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  * _readAppend
1606  */
1607 static Append *
1608 _readAppend(void)
1609 {
1610         READ_LOCALS(Append);
1611
1612         ReadCommonPlan(&local_node->plan);
1613
1614         READ_NODE_FIELD(partitioned_rels);
1615         READ_NODE_FIELD(appendplans);
1616         READ_INT_FIELD(first_partial_plan);
1617
1618         READ_DONE();
1619 }
1620
1621 /*
1622  * _readMergeAppend
1623  */
1624 static MergeAppend *
1625 _readMergeAppend(void)
1626 {
1627         READ_LOCALS(MergeAppend);
1628
1629         ReadCommonPlan(&local_node->plan);
1630
1631         READ_NODE_FIELD(partitioned_rels);
1632         READ_NODE_FIELD(mergeplans);
1633         READ_INT_FIELD(numCols);
1634         READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
1635         READ_OID_ARRAY(sortOperators, local_node->numCols);
1636         READ_OID_ARRAY(collations, local_node->numCols);
1637         READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
1638
1639         READ_DONE();
1640 }
1641
1642 /*
1643  * _readRecursiveUnion
1644  */
1645 static RecursiveUnion *
1646 _readRecursiveUnion(void)
1647 {
1648         READ_LOCALS(RecursiveUnion);
1649
1650         ReadCommonPlan(&local_node->plan);
1651
1652         READ_INT_FIELD(wtParam);
1653         READ_INT_FIELD(numCols);
1654         READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
1655         READ_OID_ARRAY(dupOperators, local_node->numCols);
1656         READ_LONG_FIELD(numGroups);
1657
1658         READ_DONE();
1659 }
1660
1661 /*
1662  * _readBitmapAnd
1663  */
1664 static BitmapAnd *
1665 _readBitmapAnd(void)
1666 {
1667         READ_LOCALS(BitmapAnd);
1668
1669         ReadCommonPlan(&local_node->plan);
1670
1671         READ_NODE_FIELD(bitmapplans);
1672
1673         READ_DONE();
1674 }
1675
1676 /*
1677  * _readBitmapOr
1678  */
1679 static BitmapOr *
1680 _readBitmapOr(void)
1681 {
1682         READ_LOCALS(BitmapOr);
1683
1684         ReadCommonPlan(&local_node->plan);
1685
1686         READ_BOOL_FIELD(isshared);
1687         READ_NODE_FIELD(bitmapplans);
1688
1689         READ_DONE();
1690 }
1691
1692 /*
1693  * ReadCommonScan
1694  *      Assign the basic stuff of all nodes that inherit from Scan
1695  */
1696 static void
1697 ReadCommonScan(Scan *local_node)
1698 {
1699         READ_TEMP_LOCALS();
1700
1701         ReadCommonPlan(&local_node->plan);
1702
1703         READ_UINT_FIELD(scanrelid);
1704 }
1705
1706 /*
1707  * _readScan
1708  */
1709 static Scan *
1710 _readScan(void)
1711 {
1712         READ_LOCALS_NO_FIELDS(Scan);
1713
1714         ReadCommonScan(local_node);
1715
1716         READ_DONE();
1717 }
1718
1719 /*
1720  * _readSeqScan
1721  */
1722 static SeqScan *
1723 _readSeqScan(void)
1724 {
1725         READ_LOCALS_NO_FIELDS(SeqScan);
1726
1727         ReadCommonScan(local_node);
1728
1729         READ_DONE();
1730 }
1731
1732 /*
1733  * _readSampleScan
1734  */
1735 static SampleScan *
1736 _readSampleScan(void)
1737 {
1738         READ_LOCALS(SampleScan);
1739
1740         ReadCommonScan(&local_node->scan);
1741
1742         READ_NODE_FIELD(tablesample);
1743
1744         READ_DONE();
1745 }
1746
1747 /*
1748  * _readIndexScan
1749  */
1750 static IndexScan *
1751 _readIndexScan(void)
1752 {
1753         READ_LOCALS(IndexScan);
1754
1755         ReadCommonScan(&local_node->scan);
1756
1757         READ_OID_FIELD(indexid);
1758         READ_NODE_FIELD(indexqual);
1759         READ_NODE_FIELD(indexqualorig);
1760         READ_NODE_FIELD(indexorderby);
1761         READ_NODE_FIELD(indexorderbyorig);
1762         READ_NODE_FIELD(indexorderbyops);
1763         READ_ENUM_FIELD(indexorderdir, ScanDirection);
1764
1765         READ_DONE();
1766 }
1767
1768 /*
1769  * _readIndexOnlyScan
1770  */
1771 static IndexOnlyScan *
1772 _readIndexOnlyScan(void)
1773 {
1774         READ_LOCALS(IndexOnlyScan);
1775
1776         ReadCommonScan(&local_node->scan);
1777
1778         READ_OID_FIELD(indexid);
1779         READ_NODE_FIELD(indexqual);
1780         READ_NODE_FIELD(indexorderby);
1781         READ_NODE_FIELD(indextlist);
1782         READ_ENUM_FIELD(indexorderdir, ScanDirection);
1783
1784         READ_DONE();
1785 }
1786
1787 /*
1788  * _readBitmapIndexScan
1789  */
1790 static BitmapIndexScan *
1791 _readBitmapIndexScan(void)
1792 {
1793         READ_LOCALS(BitmapIndexScan);
1794
1795         ReadCommonScan(&local_node->scan);
1796
1797         READ_OID_FIELD(indexid);
1798         READ_BOOL_FIELD(isshared);
1799         READ_NODE_FIELD(indexqual);
1800         READ_NODE_FIELD(indexqualorig);
1801
1802         READ_DONE();
1803 }
1804
1805 /*
1806  * _readBitmapHeapScan
1807  */
1808 static BitmapHeapScan *
1809 _readBitmapHeapScan(void)
1810 {
1811         READ_LOCALS(BitmapHeapScan);
1812
1813         ReadCommonScan(&local_node->scan);
1814
1815         READ_NODE_FIELD(bitmapqualorig);
1816
1817         READ_DONE();
1818 }
1819
1820 /*
1821  * _readTidScan
1822  */
1823 static TidScan *
1824 _readTidScan(void)
1825 {
1826         READ_LOCALS(TidScan);
1827
1828         ReadCommonScan(&local_node->scan);
1829
1830         READ_NODE_FIELD(tidquals);
1831
1832         READ_DONE();
1833 }
1834
1835 /*
1836  * _readSubqueryScan
1837  */
1838 static SubqueryScan *
1839 _readSubqueryScan(void)
1840 {
1841         READ_LOCALS(SubqueryScan);
1842
1843         ReadCommonScan(&local_node->scan);
1844
1845         READ_NODE_FIELD(subplan);
1846
1847         READ_DONE();
1848 }
1849
1850 /*
1851  * _readFunctionScan
1852  */
1853 static FunctionScan *
1854 _readFunctionScan(void)
1855 {
1856         READ_LOCALS(FunctionScan);
1857
1858         ReadCommonScan(&local_node->scan);
1859
1860         READ_NODE_FIELD(functions);
1861         READ_BOOL_FIELD(funcordinality);
1862
1863         READ_DONE();
1864 }
1865
1866 /*
1867  * _readValuesScan
1868  */
1869 static ValuesScan *
1870 _readValuesScan(void)
1871 {
1872         READ_LOCALS(ValuesScan);
1873
1874         ReadCommonScan(&local_node->scan);
1875
1876         READ_NODE_FIELD(values_lists);
1877
1878         READ_DONE();
1879 }
1880
1881 /*
1882  * _readTableFuncScan
1883  */
1884 static TableFuncScan *
1885 _readTableFuncScan(void)
1886 {
1887         READ_LOCALS(TableFuncScan);
1888
1889         ReadCommonScan(&local_node->scan);
1890
1891         READ_NODE_FIELD(tablefunc);
1892
1893         READ_DONE();
1894 }
1895
1896 /*
1897  * _readCteScan
1898  */
1899 static CteScan *
1900 _readCteScan(void)
1901 {
1902         READ_LOCALS(CteScan);
1903
1904         ReadCommonScan(&local_node->scan);
1905
1906         READ_INT_FIELD(ctePlanId);
1907         READ_INT_FIELD(cteParam);
1908
1909         READ_DONE();
1910 }
1911
1912 /*
1913  * _readWorkTableScan
1914  */
1915 static WorkTableScan *
1916 _readWorkTableScan(void)
1917 {
1918         READ_LOCALS(WorkTableScan);
1919
1920         ReadCommonScan(&local_node->scan);
1921
1922         READ_INT_FIELD(wtParam);
1923
1924         READ_DONE();
1925 }
1926
1927 /*
1928  * _readForeignScan
1929  */
1930 static ForeignScan *
1931 _readForeignScan(void)
1932 {
1933         READ_LOCALS(ForeignScan);
1934
1935         ReadCommonScan(&local_node->scan);
1936
1937         READ_ENUM_FIELD(operation, CmdType);
1938         READ_OID_FIELD(fs_server);
1939         READ_NODE_FIELD(fdw_exprs);
1940         READ_NODE_FIELD(fdw_private);
1941         READ_NODE_FIELD(fdw_scan_tlist);
1942         READ_NODE_FIELD(fdw_recheck_quals);
1943         READ_BITMAPSET_FIELD(fs_relids);
1944         READ_BOOL_FIELD(fsSystemCol);
1945
1946         READ_DONE();
1947 }
1948
1949 /*
1950  * _readCustomScan
1951  */
1952 static CustomScan *
1953 _readCustomScan(void)
1954 {
1955         READ_LOCALS(CustomScan);
1956         char       *custom_name;
1957         const CustomScanMethods *methods;
1958
1959         ReadCommonScan(&local_node->scan);
1960
1961         READ_UINT_FIELD(flags);
1962         READ_NODE_FIELD(custom_plans);
1963         READ_NODE_FIELD(custom_exprs);
1964         READ_NODE_FIELD(custom_private);
1965         READ_NODE_FIELD(custom_scan_tlist);
1966         READ_BITMAPSET_FIELD(custom_relids);
1967
1968         /* Lookup CustomScanMethods by CustomName */
1969         token = pg_strtok(&length); /* skip methods: */
1970         token = pg_strtok(&length); /* CustomName */
1971         custom_name = nullable_string(token, length);
1972         methods = GetCustomScanMethods(custom_name, false);
1973         local_node->methods = methods;
1974
1975         READ_DONE();
1976 }
1977
1978 /*
1979  * ReadCommonJoin
1980  *      Assign the basic stuff of all nodes that inherit from Join
1981  */
1982 static void
1983 ReadCommonJoin(Join *local_node)
1984 {
1985         READ_TEMP_LOCALS();
1986
1987         ReadCommonPlan(&local_node->plan);
1988
1989         READ_ENUM_FIELD(jointype, JoinType);
1990         READ_BOOL_FIELD(inner_unique);
1991         READ_NODE_FIELD(joinqual);
1992 }
1993
1994 /*
1995  * _readJoin
1996  */
1997 static Join *
1998 _readJoin(void)
1999 {
2000         READ_LOCALS_NO_FIELDS(Join);
2001
2002         ReadCommonJoin(local_node);
2003
2004         READ_DONE();
2005 }
2006
2007 /*
2008  * _readNestLoop
2009  */
2010 static NestLoop *
2011 _readNestLoop(void)
2012 {
2013         READ_LOCALS(NestLoop);
2014
2015         ReadCommonJoin(&local_node->join);
2016
2017         READ_NODE_FIELD(nestParams);
2018
2019         READ_DONE();
2020 }
2021
2022 /*
2023  * _readMergeJoin
2024  */
2025 static MergeJoin *
2026 _readMergeJoin(void)
2027 {
2028         int                     numCols;
2029
2030         READ_LOCALS(MergeJoin);
2031
2032         ReadCommonJoin(&local_node->join);
2033
2034         READ_BOOL_FIELD(skip_mark_restore);
2035         READ_NODE_FIELD(mergeclauses);
2036
2037         numCols = list_length(local_node->mergeclauses);
2038
2039         READ_OID_ARRAY(mergeFamilies, numCols);
2040         READ_OID_ARRAY(mergeCollations, numCols);
2041         READ_INT_ARRAY(mergeStrategies, numCols);
2042         READ_BOOL_ARRAY(mergeNullsFirst, numCols);
2043
2044         READ_DONE();
2045 }
2046
2047 /*
2048  * _readHashJoin
2049  */
2050 static HashJoin *
2051 _readHashJoin(void)
2052 {
2053         READ_LOCALS(HashJoin);
2054
2055         ReadCommonJoin(&local_node->join);
2056
2057         READ_NODE_FIELD(hashclauses);
2058
2059         READ_DONE();
2060 }
2061
2062 /*
2063  * _readMaterial
2064  */
2065 static Material *
2066 _readMaterial(void)
2067 {
2068         READ_LOCALS_NO_FIELDS(Material);
2069
2070         ReadCommonPlan(&local_node->plan);
2071
2072         READ_DONE();
2073 }
2074
2075 /*
2076  * _readSort
2077  */
2078 static Sort *
2079 _readSort(void)
2080 {
2081         READ_LOCALS(Sort);
2082
2083         ReadCommonPlan(&local_node->plan);
2084
2085         READ_INT_FIELD(numCols);
2086         READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
2087         READ_OID_ARRAY(sortOperators, local_node->numCols);
2088         READ_OID_ARRAY(collations, local_node->numCols);
2089         READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
2090
2091         READ_DONE();
2092 }
2093
2094 /*
2095  * _readGroup
2096  */
2097 static Group *
2098 _readGroup(void)
2099 {
2100         READ_LOCALS(Group);
2101
2102         ReadCommonPlan(&local_node->plan);
2103
2104         READ_INT_FIELD(numCols);
2105         READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
2106         READ_OID_ARRAY(grpOperators, local_node->numCols);
2107
2108         READ_DONE();
2109 }
2110
2111 /*
2112  * _readAgg
2113  */
2114 static Agg *
2115 _readAgg(void)
2116 {
2117         READ_LOCALS(Agg);
2118
2119         ReadCommonPlan(&local_node->plan);
2120
2121         READ_ENUM_FIELD(aggstrategy, AggStrategy);
2122         READ_ENUM_FIELD(aggsplit, AggSplit);
2123         READ_INT_FIELD(numCols);
2124         READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
2125         READ_OID_ARRAY(grpOperators, local_node->numCols);
2126         READ_LONG_FIELD(numGroups);
2127         READ_BITMAPSET_FIELD(aggParams);
2128         READ_NODE_FIELD(groupingSets);
2129         READ_NODE_FIELD(chain);
2130
2131         READ_DONE();
2132 }
2133
2134 /*
2135  * _readWindowAgg
2136  */
2137 static WindowAgg *
2138 _readWindowAgg(void)
2139 {
2140         READ_LOCALS(WindowAgg);
2141
2142         ReadCommonPlan(&local_node->plan);
2143
2144         READ_UINT_FIELD(winref);
2145         READ_INT_FIELD(partNumCols);
2146         READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
2147         READ_OID_ARRAY(partOperators, local_node->partNumCols);
2148         READ_INT_FIELD(ordNumCols);
2149         READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
2150         READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
2151         READ_INT_FIELD(frameOptions);
2152         READ_NODE_FIELD(startOffset);
2153         READ_NODE_FIELD(endOffset);
2154         READ_OID_FIELD(startInRangeFunc);
2155         READ_OID_FIELD(endInRangeFunc);
2156         READ_OID_FIELD(inRangeColl);
2157         READ_BOOL_FIELD(inRangeAsc);
2158         READ_BOOL_FIELD(inRangeNullsFirst);
2159
2160         READ_DONE();
2161 }
2162
2163 /*
2164  * _readUnique
2165  */
2166 static Unique *
2167 _readUnique(void)
2168 {
2169         READ_LOCALS(Unique);
2170
2171         ReadCommonPlan(&local_node->plan);
2172
2173         READ_INT_FIELD(numCols);
2174         READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
2175         READ_OID_ARRAY(uniqOperators, local_node->numCols);
2176
2177         READ_DONE();
2178 }
2179
2180 /*
2181  * _readGather
2182  */
2183 static Gather *
2184 _readGather(void)
2185 {
2186         READ_LOCALS(Gather);
2187
2188         ReadCommonPlan(&local_node->plan);
2189
2190         READ_INT_FIELD(num_workers);
2191         READ_INT_FIELD(rescan_param);
2192         READ_BOOL_FIELD(single_copy);
2193         READ_BOOL_FIELD(invisible);
2194         READ_BITMAPSET_FIELD(initParam);
2195
2196         READ_DONE();
2197 }
2198
2199 /*
2200  * _readGatherMerge
2201  */
2202 static GatherMerge *
2203 _readGatherMerge(void)
2204 {
2205         READ_LOCALS(GatherMerge);
2206
2207         ReadCommonPlan(&local_node->plan);
2208
2209         READ_INT_FIELD(num_workers);
2210         READ_INT_FIELD(rescan_param);
2211         READ_INT_FIELD(numCols);
2212         READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
2213         READ_OID_ARRAY(sortOperators, local_node->numCols);
2214         READ_OID_ARRAY(collations, local_node->numCols);
2215         READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
2216         READ_BITMAPSET_FIELD(initParam);
2217
2218         READ_DONE();
2219 }
2220
2221 /*
2222  * _readHash
2223  */
2224 static Hash *
2225 _readHash(void)
2226 {
2227         READ_LOCALS(Hash);
2228
2229         ReadCommonPlan(&local_node->plan);
2230
2231         READ_OID_FIELD(skewTable);
2232         READ_INT_FIELD(skewColumn);
2233         READ_BOOL_FIELD(skewInherit);
2234         READ_FLOAT_FIELD(rows_total);
2235
2236         READ_DONE();
2237 }
2238
2239 /*
2240  * _readSetOp
2241  */
2242 static SetOp *
2243 _readSetOp(void)
2244 {
2245         READ_LOCALS(SetOp);
2246
2247         ReadCommonPlan(&local_node->plan);
2248
2249         READ_ENUM_FIELD(cmd, SetOpCmd);
2250         READ_ENUM_FIELD(strategy, SetOpStrategy);
2251         READ_INT_FIELD(numCols);
2252         READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
2253         READ_OID_ARRAY(dupOperators, local_node->numCols);
2254         READ_INT_FIELD(flagColIdx);
2255         READ_INT_FIELD(firstFlag);
2256         READ_LONG_FIELD(numGroups);
2257
2258         READ_DONE();
2259 }
2260
2261 /*
2262  * _readLockRows
2263  */
2264 static LockRows *
2265 _readLockRows(void)
2266 {
2267         READ_LOCALS(LockRows);
2268
2269         ReadCommonPlan(&local_node->plan);
2270
2271         READ_NODE_FIELD(rowMarks);
2272         READ_INT_FIELD(epqParam);
2273
2274         READ_DONE();
2275 }
2276
2277 /*
2278  * _readLimit
2279  */
2280 static Limit *
2281 _readLimit(void)
2282 {
2283         READ_LOCALS(Limit);
2284
2285         ReadCommonPlan(&local_node->plan);
2286
2287         READ_NODE_FIELD(limitOffset);
2288         READ_NODE_FIELD(limitCount);
2289
2290         READ_DONE();
2291 }
2292
2293 /*
2294  * _readNestLoopParam
2295  */
2296 static NestLoopParam *
2297 _readNestLoopParam(void)
2298 {
2299         READ_LOCALS(NestLoopParam);
2300
2301         READ_INT_FIELD(paramno);
2302         READ_NODE_FIELD(paramval);
2303
2304         READ_DONE();
2305 }
2306
2307 /*
2308  * _readPlanRowMark
2309  */
2310 static PlanRowMark *
2311 _readPlanRowMark(void)
2312 {
2313         READ_LOCALS(PlanRowMark);
2314
2315         READ_UINT_FIELD(rti);
2316         READ_UINT_FIELD(prti);
2317         READ_UINT_FIELD(rowmarkId);
2318         READ_ENUM_FIELD(markType, RowMarkType);
2319         READ_INT_FIELD(allMarkTypes);
2320         READ_ENUM_FIELD(strength, LockClauseStrength);
2321         READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
2322         READ_BOOL_FIELD(isParent);
2323
2324         READ_DONE();
2325 }
2326
2327 /*
2328  * _readPlanInvalItem
2329  */
2330 static PlanInvalItem *
2331 _readPlanInvalItem(void)
2332 {
2333         READ_LOCALS(PlanInvalItem);
2334
2335         READ_INT_FIELD(cacheId);
2336         READ_UINT_FIELD(hashValue);
2337
2338         READ_DONE();
2339 }
2340
2341 /*
2342  * _readSubPlan
2343  */
2344 static SubPlan *
2345 _readSubPlan(void)
2346 {
2347         READ_LOCALS(SubPlan);
2348
2349         READ_ENUM_FIELD(subLinkType, SubLinkType);
2350         READ_NODE_FIELD(testexpr);
2351         READ_NODE_FIELD(paramIds);
2352         READ_INT_FIELD(plan_id);
2353         READ_STRING_FIELD(plan_name);
2354         READ_OID_FIELD(firstColType);
2355         READ_INT_FIELD(firstColTypmod);
2356         READ_OID_FIELD(firstColCollation);
2357         READ_BOOL_FIELD(useHashTable);
2358         READ_BOOL_FIELD(unknownEqFalse);
2359         READ_BOOL_FIELD(parallel_safe);
2360         READ_NODE_FIELD(setParam);
2361         READ_NODE_FIELD(parParam);
2362         READ_NODE_FIELD(args);
2363         READ_FLOAT_FIELD(startup_cost);
2364         READ_FLOAT_FIELD(per_call_cost);
2365
2366         READ_DONE();
2367 }
2368
2369 /*
2370  * _readAlternativeSubPlan
2371  */
2372 static AlternativeSubPlan *
2373 _readAlternativeSubPlan(void)
2374 {
2375         READ_LOCALS(AlternativeSubPlan);
2376
2377         READ_NODE_FIELD(subplans);
2378
2379         READ_DONE();
2380 }
2381
2382 /*
2383  * _readExtensibleNode
2384  */
2385 static ExtensibleNode *
2386 _readExtensibleNode(void)
2387 {
2388         const ExtensibleNodeMethods *methods;
2389         ExtensibleNode *local_node;
2390         const char *extnodename;
2391
2392         READ_TEMP_LOCALS();
2393
2394         token = pg_strtok(&length); /* skip :extnodename */
2395         token = pg_strtok(&length); /* get extnodename */
2396
2397         extnodename = nullable_string(token, length);
2398         if (!extnodename)
2399                 elog(ERROR, "extnodename has to be supplied");
2400         methods = GetExtensibleNodeMethods(extnodename, false);
2401
2402         local_node = (ExtensibleNode *) newNode(methods->node_size,
2403                                                                                         T_ExtensibleNode);
2404         local_node->extnodename = extnodename;
2405
2406         /* deserialize the private fields */
2407         methods->nodeRead(local_node);
2408
2409         READ_DONE();
2410 }
2411
2412 /*
2413  * _readPartitionBoundSpec
2414  */
2415 static PartitionBoundSpec *
2416 _readPartitionBoundSpec(void)
2417 {
2418         READ_LOCALS(PartitionBoundSpec);
2419
2420         READ_CHAR_FIELD(strategy);
2421         READ_BOOL_FIELD(is_default);
2422         READ_INT_FIELD(modulus);
2423         READ_INT_FIELD(remainder);
2424         READ_NODE_FIELD(listdatums);
2425         READ_NODE_FIELD(lowerdatums);
2426         READ_NODE_FIELD(upperdatums);
2427         READ_LOCATION_FIELD(location);
2428
2429         READ_DONE();
2430 }
2431
2432 /*
2433  * _readPartitionRangeDatum
2434  */
2435 static PartitionRangeDatum *
2436 _readPartitionRangeDatum(void)
2437 {
2438         READ_LOCALS(PartitionRangeDatum);
2439
2440         READ_ENUM_FIELD(kind, PartitionRangeDatumKind);
2441         READ_NODE_FIELD(value);
2442         READ_LOCATION_FIELD(location);
2443
2444         READ_DONE();
2445 }
2446
2447 /*
2448  * parseNodeString
2449  *
2450  * Given a character string representing a node tree, parseNodeString creates
2451  * the internal node structure.
2452  *
2453  * The string to be read must already have been loaded into pg_strtok().
2454  */
2455 Node *
2456 parseNodeString(void)
2457 {
2458         void       *return_value;
2459
2460         READ_TEMP_LOCALS();
2461
2462         token = pg_strtok(&length);
2463
2464 #define MATCH(tokname, namelen) \
2465         (length == namelen && memcmp(token, tokname, namelen) == 0)
2466
2467         if (MATCH("QUERY", 5))
2468                 return_value = _readQuery();
2469         else if (MATCH("WITHCHECKOPTION", 15))
2470                 return_value = _readWithCheckOption();
2471         else if (MATCH("SORTGROUPCLAUSE", 15))
2472                 return_value = _readSortGroupClause();
2473         else if (MATCH("GROUPINGSET", 11))
2474                 return_value = _readGroupingSet();
2475         else if (MATCH("WINDOWCLAUSE", 12))
2476                 return_value = _readWindowClause();
2477         else if (MATCH("ROWMARKCLAUSE", 13))
2478                 return_value = _readRowMarkClause();
2479         else if (MATCH("COMMONTABLEEXPR", 15))
2480                 return_value = _readCommonTableExpr();
2481         else if (MATCH("SETOPERATIONSTMT", 16))
2482                 return_value = _readSetOperationStmt();
2483         else if (MATCH("ALIAS", 5))
2484                 return_value = _readAlias();
2485         else if (MATCH("RANGEVAR", 8))
2486                 return_value = _readRangeVar();
2487         else if (MATCH("INTOCLAUSE", 10))
2488                 return_value = _readIntoClause();
2489         else if (MATCH("TABLEFUNC", 9))
2490                 return_value = _readTableFunc();
2491         else if (MATCH("VAR", 3))
2492                 return_value = _readVar();
2493         else if (MATCH("CONST", 5))
2494                 return_value = _readConst();
2495         else if (MATCH("PARAM", 5))
2496                 return_value = _readParam();
2497         else if (MATCH("AGGREF", 6))
2498                 return_value = _readAggref();
2499         else if (MATCH("GROUPINGFUNC", 12))
2500                 return_value = _readGroupingFunc();
2501         else if (MATCH("WINDOWFUNC", 10))
2502                 return_value = _readWindowFunc();
2503         else if (MATCH("ARRAYREF", 8))
2504                 return_value = _readArrayRef();
2505         else if (MATCH("FUNCEXPR", 8))
2506                 return_value = _readFuncExpr();
2507         else if (MATCH("NAMEDARGEXPR", 12))
2508                 return_value = _readNamedArgExpr();
2509         else if (MATCH("OPEXPR", 6))
2510                 return_value = _readOpExpr();
2511         else if (MATCH("DISTINCTEXPR", 12))
2512                 return_value = _readDistinctExpr();
2513         else if (MATCH("NULLIFEXPR", 10))
2514                 return_value = _readNullIfExpr();
2515         else if (MATCH("SCALARARRAYOPEXPR", 17))
2516                 return_value = _readScalarArrayOpExpr();
2517         else if (MATCH("BOOLEXPR", 8))
2518                 return_value = _readBoolExpr();
2519         else if (MATCH("SUBLINK", 7))
2520                 return_value = _readSubLink();
2521         else if (MATCH("FIELDSELECT", 11))
2522                 return_value = _readFieldSelect();
2523         else if (MATCH("FIELDSTORE", 10))
2524                 return_value = _readFieldStore();
2525         else if (MATCH("RELABELTYPE", 11))
2526                 return_value = _readRelabelType();
2527         else if (MATCH("COERCEVIAIO", 11))
2528                 return_value = _readCoerceViaIO();
2529         else if (MATCH("ARRAYCOERCEEXPR", 15))
2530                 return_value = _readArrayCoerceExpr();
2531         else if (MATCH("CONVERTROWTYPEEXPR", 18))
2532                 return_value = _readConvertRowtypeExpr();
2533         else if (MATCH("COLLATE", 7))
2534                 return_value = _readCollateExpr();
2535         else if (MATCH("CASE", 4))
2536                 return_value = _readCaseExpr();
2537         else if (MATCH("WHEN", 4))
2538                 return_value = _readCaseWhen();
2539         else if (MATCH("CASETESTEXPR", 12))
2540                 return_value = _readCaseTestExpr();
2541         else if (MATCH("ARRAY", 5))
2542                 return_value = _readArrayExpr();
2543         else if (MATCH("ROW", 3))
2544                 return_value = _readRowExpr();
2545         else if (MATCH("ROWCOMPARE", 10))
2546                 return_value = _readRowCompareExpr();
2547         else if (MATCH("COALESCE", 8))
2548                 return_value = _readCoalesceExpr();
2549         else if (MATCH("MINMAX", 6))
2550                 return_value = _readMinMaxExpr();
2551         else if (MATCH("SQLVALUEFUNCTION", 16))
2552                 return_value = _readSQLValueFunction();
2553         else if (MATCH("XMLEXPR", 7))
2554                 return_value = _readXmlExpr();
2555         else if (MATCH("NULLTEST", 8))
2556                 return_value = _readNullTest();
2557         else if (MATCH("BOOLEANTEST", 11))
2558                 return_value = _readBooleanTest();
2559         else if (MATCH("COERCETODOMAIN", 14))
2560                 return_value = _readCoerceToDomain();
2561         else if (MATCH("COERCETODOMAINVALUE", 19))
2562                 return_value = _readCoerceToDomainValue();
2563         else if (MATCH("SETTODEFAULT", 12))
2564                 return_value = _readSetToDefault();
2565         else if (MATCH("CURRENTOFEXPR", 13))
2566                 return_value = _readCurrentOfExpr();
2567         else if (MATCH("NEXTVALUEEXPR", 13))
2568                 return_value = _readNextValueExpr();
2569         else if (MATCH("INFERENCEELEM", 13))
2570                 return_value = _readInferenceElem();
2571         else if (MATCH("TARGETENTRY", 11))
2572                 return_value = _readTargetEntry();
2573         else if (MATCH("RANGETBLREF", 11))
2574                 return_value = _readRangeTblRef();
2575         else if (MATCH("JOINEXPR", 8))
2576                 return_value = _readJoinExpr();
2577         else if (MATCH("FROMEXPR", 8))
2578                 return_value = _readFromExpr();
2579         else if (MATCH("ONCONFLICTEXPR", 14))
2580                 return_value = _readOnConflictExpr();
2581         else if (MATCH("RTE", 3))
2582                 return_value = _readRangeTblEntry();
2583         else if (MATCH("RANGETBLFUNCTION", 16))
2584                 return_value = _readRangeTblFunction();
2585         else if (MATCH("TABLESAMPLECLAUSE", 17))
2586                 return_value = _readTableSampleClause();
2587         else if (MATCH("NOTIFY", 6))
2588                 return_value = _readNotifyStmt();
2589         else if (MATCH("DEFELEM", 7))
2590                 return_value = _readDefElem();
2591         else if (MATCH("DECLARECURSOR", 13))
2592                 return_value = _readDeclareCursorStmt();
2593         else if (MATCH("PLANNEDSTMT", 11))
2594                 return_value = _readPlannedStmt();
2595         else if (MATCH("PLAN", 4))
2596                 return_value = _readPlan();
2597         else if (MATCH("RESULT", 6))
2598                 return_value = _readResult();
2599         else if (MATCH("PROJECTSET", 10))
2600                 return_value = _readProjectSet();
2601         else if (MATCH("MODIFYTABLE", 11))
2602                 return_value = _readModifyTable();
2603         else if (MATCH("APPEND", 6))
2604                 return_value = _readAppend();
2605         else if (MATCH("MERGEAPPEND", 11))
2606                 return_value = _readMergeAppend();
2607         else if (MATCH("RECURSIVEUNION", 14))
2608                 return_value = _readRecursiveUnion();
2609         else if (MATCH("BITMAPAND", 9))
2610                 return_value = _readBitmapAnd();
2611         else if (MATCH("BITMAPOR", 8))
2612                 return_value = _readBitmapOr();
2613         else if (MATCH("SCAN", 4))
2614                 return_value = _readScan();
2615         else if (MATCH("SEQSCAN", 7))
2616                 return_value = _readSeqScan();
2617         else if (MATCH("SAMPLESCAN", 10))
2618                 return_value = _readSampleScan();
2619         else if (MATCH("INDEXSCAN", 9))
2620                 return_value = _readIndexScan();
2621         else if (MATCH("INDEXONLYSCAN", 13))
2622                 return_value = _readIndexOnlyScan();
2623         else if (MATCH("BITMAPINDEXSCAN", 15))
2624                 return_value = _readBitmapIndexScan();
2625         else if (MATCH("BITMAPHEAPSCAN", 14))
2626                 return_value = _readBitmapHeapScan();
2627         else if (MATCH("TIDSCAN", 7))
2628                 return_value = _readTidScan();
2629         else if (MATCH("SUBQUERYSCAN", 12))
2630                 return_value = _readSubqueryScan();
2631         else if (MATCH("FUNCTIONSCAN", 12))
2632                 return_value = _readFunctionScan();
2633         else if (MATCH("VALUESSCAN", 10))
2634                 return_value = _readValuesScan();
2635         else if (MATCH("TABLEFUNCSCAN", 13))
2636                 return_value = _readTableFuncScan();
2637         else if (MATCH("CTESCAN", 7))
2638                 return_value = _readCteScan();
2639         else if (MATCH("WORKTABLESCAN", 13))
2640                 return_value = _readWorkTableScan();
2641         else if (MATCH("FOREIGNSCAN", 11))
2642                 return_value = _readForeignScan();
2643         else if (MATCH("CUSTOMSCAN", 10))
2644                 return_value = _readCustomScan();
2645         else if (MATCH("JOIN", 4))
2646                 return_value = _readJoin();
2647         else if (MATCH("NESTLOOP", 8))
2648                 return_value = _readNestLoop();
2649         else if (MATCH("MERGEJOIN", 9))
2650                 return_value = _readMergeJoin();
2651         else if (MATCH("HASHJOIN", 8))
2652                 return_value = _readHashJoin();
2653         else if (MATCH("MATERIAL", 8))
2654                 return_value = _readMaterial();
2655         else if (MATCH("SORT", 4))
2656                 return_value = _readSort();
2657         else if (MATCH("GROUP", 5))
2658                 return_value = _readGroup();
2659         else if (MATCH("AGG", 3))
2660                 return_value = _readAgg();
2661         else if (MATCH("WINDOWAGG", 9))
2662                 return_value = _readWindowAgg();
2663         else if (MATCH("UNIQUE", 6))
2664                 return_value = _readUnique();
2665         else if (MATCH("GATHER", 6))
2666                 return_value = _readGather();
2667         else if (MATCH("GATHERMERGE", 11))
2668                 return_value = _readGatherMerge();
2669         else if (MATCH("HASH", 4))
2670                 return_value = _readHash();
2671         else if (MATCH("SETOP", 5))
2672                 return_value = _readSetOp();
2673         else if (MATCH("LOCKROWS", 8))
2674                 return_value = _readLockRows();
2675         else if (MATCH("LIMIT", 5))
2676                 return_value = _readLimit();
2677         else if (MATCH("NESTLOOPPARAM", 13))
2678                 return_value = _readNestLoopParam();
2679         else if (MATCH("PLANROWMARK", 11))
2680                 return_value = _readPlanRowMark();
2681         else if (MATCH("PLANINVALITEM", 13))
2682                 return_value = _readPlanInvalItem();
2683         else if (MATCH("SUBPLAN", 7))
2684                 return_value = _readSubPlan();
2685         else if (MATCH("ALTERNATIVESUBPLAN", 18))
2686                 return_value = _readAlternativeSubPlan();
2687         else if (MATCH("EXTENSIBLENODE", 14))
2688                 return_value = _readExtensibleNode();
2689         else if (MATCH("PARTITIONBOUNDSPEC", 18))
2690                 return_value = _readPartitionBoundSpec();
2691         else if (MATCH("PARTITIONRANGEDATUM", 19))
2692                 return_value = _readPartitionRangeDatum();
2693         else
2694         {
2695                 elog(ERROR, "badly formatted node string \"%.32s\"...", token);
2696                 return_value = NULL;    /* keep compiler quiet */
2697         }
2698
2699         return (Node *) return_value;
2700 }
2701
2702
2703 /*
2704  * readDatum
2705  *
2706  * Given a string representation of a constant, recreate the appropriate
2707  * Datum.  The string representation embeds length info, but not byValue,
2708  * so we must be told that.
2709  */
2710 Datum
2711 readDatum(bool typbyval)
2712 {
2713         Size            length,
2714                                 i;
2715         int                     tokenLength;
2716         char       *token;
2717         Datum           res;
2718         char       *s;
2719
2720         /*
2721          * read the actual length of the value
2722          */
2723         token = pg_strtok(&tokenLength);
2724         length = atoui(token);
2725
2726         token = pg_strtok(&tokenLength);        /* read the '[' */
2727         if (token == NULL || token[0] != '[')
2728                 elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
2729                          token ? (const char *) token : "[NULL]", length);
2730
2731         if (typbyval)
2732         {
2733                 if (length > (Size) sizeof(Datum))
2734                         elog(ERROR, "byval datum but length = %zu", length);
2735                 res = (Datum) 0;
2736                 s = (char *) (&res);
2737                 for (i = 0; i < (Size) sizeof(Datum); i++)
2738                 {
2739                         token = pg_strtok(&tokenLength);
2740                         s[i] = (char) atoi(token);
2741                 }
2742         }
2743         else if (length <= 0)
2744                 res = (Datum) NULL;
2745         else
2746         {
2747                 s = (char *) palloc(length);
2748                 for (i = 0; i < length; i++)
2749                 {
2750                         token = pg_strtok(&tokenLength);
2751                         s[i] = (char) atoi(token);
2752                 }
2753                 res = PointerGetDatum(s);
2754         }
2755
2756         token = pg_strtok(&tokenLength);        /* read the ']' */
2757         if (token == NULL || token[0] != ']')
2758                 elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
2759                          token ? (const char *) token : "[NULL]", length);
2760
2761         return res;
2762 }
2763
2764 /*
2765  * readAttrNumberCols
2766  */
2767 AttrNumber *
2768 readAttrNumberCols(int numCols)
2769 {
2770         int                     tokenLength,
2771                                 i;
2772         char       *token;
2773         AttrNumber *attr_vals;
2774
2775         if (numCols <= 0)
2776                 return NULL;
2777
2778         attr_vals = (AttrNumber *) palloc(numCols * sizeof(AttrNumber));
2779         for (i = 0; i < numCols; i++)
2780         {
2781                 token = pg_strtok(&tokenLength);
2782                 attr_vals[i] = atoi(token);
2783         }
2784
2785         return attr_vals;
2786 }
2787
2788 /*
2789  * readOidCols
2790  */
2791 Oid *
2792 readOidCols(int numCols)
2793 {
2794         int                     tokenLength,
2795                                 i;
2796         char       *token;
2797         Oid                *oid_vals;
2798
2799         if (numCols <= 0)
2800                 return NULL;
2801
2802         oid_vals = (Oid *) palloc(numCols * sizeof(Oid));
2803         for (i = 0; i < numCols; i++)
2804         {
2805                 token = pg_strtok(&tokenLength);
2806                 oid_vals[i] = atooid(token);
2807         }
2808
2809         return oid_vals;
2810 }
2811
2812 /*
2813  * readIntCols
2814  */
2815 int *
2816 readIntCols(int numCols)
2817 {
2818         int                     tokenLength,
2819                                 i;
2820         char       *token;
2821         int                *int_vals;
2822
2823         if (numCols <= 0)
2824                 return NULL;
2825
2826         int_vals = (int *) palloc(numCols * sizeof(int));
2827         for (i = 0; i < numCols; i++)
2828         {
2829                 token = pg_strtok(&tokenLength);
2830                 int_vals[i] = atoi(token);
2831         }
2832
2833         return int_vals;
2834 }
2835
2836 /*
2837  * readBoolCols
2838  */
2839 bool *
2840 readBoolCols(int numCols)
2841 {
2842         int                     tokenLength,
2843                                 i;
2844         char       *token;
2845         bool       *bool_vals;
2846
2847         if (numCols <= 0)
2848                 return NULL;
2849
2850         bool_vals = (bool *) palloc(numCols * sizeof(bool));
2851         for (i = 0; i < numCols; i++)
2852         {
2853                 token = pg_strtok(&tokenLength);
2854                 bool_vals[i] = strtobool(token);
2855         }
2856
2857         return bool_vals;
2858 }