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