PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
readfuncs.c
Go to the documentation of this file.
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 *
178 {
179  Bitmapset *result = NULL;
180 
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 *
219 {
220  return _readBitmapset();
221 }
222 
223 /*
224  * _readQuery
225  */
226 static Query *
228 {
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 *
276 {
278 
279  READ_STRING_FIELD(conditionname);
280  READ_STRING_FIELD(payload);
281 
282  READ_DONE();
283 }
284 
285 /*
286  * _readDeclareCursorStmt
287  */
288 static DeclareCursorStmt *
290 {
292 
293  READ_STRING_FIELD(portalname);
295  READ_NODE_FIELD(query);
296 
297  READ_DONE();
298 }
299 
300 /*
301  * _readWithCheckOption
302  */
303 static WithCheckOption *
305 {
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 *
322 {
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 *
339 {
341 
343  READ_NODE_FIELD(content);
344  READ_LOCATION_FIELD(location);
345 
346  READ_DONE();
347 }
348 
349 /*
350  * _readWindowClause
351  */
352 static WindowClause *
354 {
356 
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 *
375 {
377 
378  READ_UINT_FIELD(rti);
380  READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
381  READ_BOOL_FIELD(pushedDown);
382 
383  READ_DONE();
384 }
385 
386 /*
387  * _readCommonTableExpr
388  */
389 static CommonTableExpr *
391 {
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 *
413 {
415 
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 *
435 {
437 
438  READ_STRING_FIELD(aliasname);
439  READ_NODE_FIELD(colnames);
440 
441  READ_DONE();
442 }
443 
444 static RangeVar *
446 {
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 *
467 {
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 *
489 {
491 
492  READ_NODE_FIELD(rel);
493  READ_NODE_FIELD(colNames);
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 *
529 {
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 *
554 {
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 *
572 {
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);
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 *
601 {
603 
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 *
618 {
620 
621  READ_OID_FIELD(winfnoid);
622  READ_OID_FIELD(wintype);
623  READ_OID_FIELD(wincollid);
624  READ_OID_FIELD(inputcollid);
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 *
640 {
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 *
660 {
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);
671  READ_LOCATION_FIELD(location);
672 
673  READ_DONE();
674 }
675 
676 /*
677  * _readNamedArgExpr
678  */
679 static NamedArgExpr *
681 {
683 
686  READ_INT_FIELD(argnumber);
687  READ_LOCATION_FIELD(location);
688 
689  READ_DONE();
690 }
691 
692 /*
693  * _readOpExpr
694  */
695 static OpExpr *
697 {
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);
707  READ_LOCATION_FIELD(location);
708 
709  READ_DONE();
710 }
711 
712 /*
713  * _readDistinctExpr
714  */
715 static DistinctExpr *
717 {
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);
727  READ_LOCATION_FIELD(location);
728 
729  READ_DONE();
730 }
731 
732 /*
733  * _readNullIfExpr
734  */
735 static NullIfExpr *
737 {
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);
747  READ_LOCATION_FIELD(location);
748 
749  READ_DONE();
750 }
751 
752 /*
753  * _readScalarArrayOpExpr
754  */
755 static ScalarArrayOpExpr *
757 {
759 
760  READ_OID_FIELD(opno);
761  READ_OID_FIELD(opfuncid);
762  READ_BOOL_FIELD(useOr);
763  READ_OID_FIELD(inputcollid);
765  READ_LOCATION_FIELD(location);
766 
767  READ_DONE();
768 }
769 
770 /*
771  * _readBoolExpr
772  */
773 static BoolExpr *
775 {
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 
791  READ_LOCATION_FIELD(location);
792 
793  READ_DONE();
794 }
795 
796 /*
797  * _readSubLink
798  */
799 static SubLink *
801 {
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 *
823 {
825 
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 *
840 {
842 
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 *
856 {
858 
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 *
874 {
876 
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 *
891 {
893 
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 *
911 {
913 
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 *
927 {
929 
931  READ_OID_FIELD(collOid);
932  READ_LOCATION_FIELD(location);
933 
934  READ_DONE();
935 }
936 
937 /*
938  * _readCaseExpr
939  */
940 static CaseExpr *
942 {
944 
945  READ_OID_FIELD(casetype);
946  READ_OID_FIELD(casecollid);
949  READ_NODE_FIELD(defresult);
950  READ_LOCATION_FIELD(location);
951 
952  READ_DONE();
953 }
954 
955 /*
956  * _readCaseWhen
957  */
958 static CaseWhen *
960 {
962 
963  READ_NODE_FIELD(expr);
965  READ_LOCATION_FIELD(location);
966 
967  READ_DONE();
968 }
969 
970 /*
971  * _readCaseTestExpr
972  */
973 static CaseTestExpr *
975 {
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 *
990 {
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 *
1008 {
1010 
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 *
1025 {
1027 
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 *
1043 {
1045 
1046  READ_OID_FIELD(coalescetype);
1047  READ_OID_FIELD(coalescecollid);
1049  READ_LOCATION_FIELD(location);
1050 
1051  READ_DONE();
1052 }
1053 
1054 /*
1055  * _readMinMaxExpr
1056  */
1057 static MinMaxExpr *
1059 {
1061 
1062  READ_OID_FIELD(minmaxtype);
1063  READ_OID_FIELD(minmaxcollid);
1064  READ_OID_FIELD(inputcollid);
1067  READ_LOCATION_FIELD(location);
1068 
1069  READ_DONE();
1070 }
1071 
1072 /*
1073  * _readSQLValueFunction
1074  */
1075 static SQLValueFunction *
1077 {
1079 
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 *
1093 {
1095 
1098  READ_NODE_FIELD(named_args);
1099  READ_NODE_FIELD(arg_names);
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 *
1114 {
1116 
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 *
1130 {
1132 
1134  READ_ENUM_FIELD(booltesttype, BoolTestType);
1135  READ_LOCATION_FIELD(location);
1136 
1137  READ_DONE();
1138 }
1139 
1140 /*
1141  * _readCoerceToDomain
1142  */
1143 static CoerceToDomain *
1145 {
1147 
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 *
1163 {
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 *
1179 {
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 *
1195 {
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 *
1210 {
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 *
1225 {
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 *
1244 {
1246 
1247  READ_INT_FIELD(rtindex);
1248 
1249  READ_DONE();
1250 }
1251 
1252 /*
1253  * _readJoinExpr
1254  */
1255 static JoinExpr *
1257 {
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 *
1277 {
1279 
1280  READ_NODE_FIELD(fromlist);
1281  READ_NODE_FIELD(quals);
1282 
1283  READ_DONE();
1284 }
1285 
1286 /*
1287  * _readOnConflictExpr
1288  */
1289 static OnConflictExpr *
1291 {
1293 
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 *
1315 {
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:
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 *
1390 {
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 *
1409 {
1411 
1412  READ_OID_FIELD(tsmhandler);
1414  READ_NODE_FIELD(repeatable);
1415 
1416  READ_DONE();
1417 }
1418 
1419 /*
1420  * _readDefElem
1421  */
1422 static DefElem *
1424 {
1426 
1427  READ_STRING_FIELD(defnamespace);
1428  READ_STRING_FIELD(defname);
1430  READ_ENUM_FIELD(defaction, DefElemAction);
1431  READ_LOCATION_FIELD(location);
1432 
1433  READ_DONE();
1434 }
1435 
1436 /*
1437  * _readPlannedStmt
1438  */
1439 static PlannedStmt *
1441 {
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 *
1500 {
1502 
1503  ReadCommonPlan(local_node);
1504 
1505  READ_DONE();
1506 }
1507 
1508 /*
1509  * _readResult
1510  */
1511 static Result *
1513 {
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 *
1528 {
1530 
1531  ReadCommonPlan(&local_node->plan);
1532 
1533  READ_DONE();
1534 }
1535 
1536 /*
1537  * _readModifyTable
1538  */
1539 static ModifyTable *
1541 {
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 *
1575 {
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 *
1591 {
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 *
1612 {
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 *
1631 {
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 *
1646 {
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 *
1676 {
1678 
1679  ReadCommonScan(local_node);
1680 
1681  READ_DONE();
1682 }
1683 
1684 /*
1685  * _readSeqScan
1686  */
1687 static SeqScan *
1689 {
1691 
1692  ReadCommonScan(local_node);
1693 
1694  READ_DONE();
1695 }
1696 
1697 /*
1698  * _readSampleScan
1699  */
1700 static SampleScan *
1702 {
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 *
1717 {
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 *
1738 {
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 *
1757 {
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 *
1775 {
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 *
1790 {
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 *
1805 {
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 *
1820 {
1822 
1823  ReadCommonScan(&local_node->scan);
1824 
1826  READ_BOOL_FIELD(funcordinality);
1827 
1828  READ_DONE();
1829 }
1830 
1831 /*
1832  * _readValuesScan
1833  */
1834 static ValuesScan *
1836 {
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 *
1851 {
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 *
1866 {
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 *
1882 {
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 *
1897 {
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 *
1919 {
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 *
1964 {
1966 
1967  ReadCommonJoin(local_node);
1968 
1969  READ_DONE();
1970 }
1971 
1972 /*
1973  * _readNestLoop
1974  */
1975 static NestLoop *
1977 {
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 *
1992 {
1993  int numCols;
1994 
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 *
2017 {
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 *
2032 {
2034 
2035  ReadCommonPlan(&local_node->plan);
2036 
2037  READ_DONE();
2038 }
2039 
2040 /*
2041  * _readSort
2042  */
2043 static Sort *
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 *
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 *
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 *
2104 {
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 *
2128 {
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 *
2145 {
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 *
2162 {
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 *
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 *
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 *
2221 {
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 *
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 *
2253 {
2255 
2256  READ_INT_FIELD(paramno);
2257  READ_NODE_FIELD(paramval);
2258 
2259  READ_DONE();
2260 }
2261 
2262 /*
2263  * _readPlanRowMark
2264  */
2265 static PlanRowMark *
2267 {
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);
2276  READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
2277  READ_BOOL_FIELD(isParent);
2278 
2279  READ_DONE();
2280 }
2281 
2282 /*
2283  * _readPlanInvalItem
2284  */
2285 static PlanInvalItem *
2287 {
2289 
2290  READ_INT_FIELD(cacheId);
2291  READ_UINT_FIELD(hashValue);
2292 
2293  READ_DONE();
2294 }
2295 
2296 /*
2297  * _readSubPlan
2298  */
2299 static SubPlan *
2301 {
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);
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 *
2329 {
2331 
2332  READ_NODE_FIELD(subplans);
2333 
2334  READ_DONE();
2335 }
2336 
2337 /*
2338  * _readExtensibleNode
2339  */
2340 static ExtensibleNode *
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,
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 *
2372 {
2374 
2375  READ_CHAR_FIELD(strategy);
2376  READ_NODE_FIELD(listdatums);
2377  READ_NODE_FIELD(lowerdatums);
2378  READ_NODE_FIELD(upperdatums);
2379 
2380  READ_DONE();
2381 }
2382 
2383 /*
2384  * _readPartitionRangeDatum
2385  */
2386 static PartitionRangeDatum *
2388 {
2390 
2391  READ_BOOL_FIELD(infinite);
2393 
2394  READ_DONE();
2395 }
2396 
2397 /*
2398  * parseNodeString
2399  *
2400  * Given a character string representing a node tree, parseNodeString creates
2401  * the internal node structure.
2402  *
2403  * The string to be read must already have been loaded into pg_strtok().
2404  */
2405 Node *
2407 {
2408  void *return_value;
2409 
2410  READ_TEMP_LOCALS();
2411 
2412  token = pg_strtok(&length);
2413 
2414 #define MATCH(tokname, namelen) \
2415  (length == namelen && memcmp(token, tokname, namelen) == 0)
2416 
2417  if (MATCH("QUERY", 5))
2418  return_value = _readQuery();
2419  else if (MATCH("WITHCHECKOPTION", 15))
2420  return_value = _readWithCheckOption();
2421  else if (MATCH("SORTGROUPCLAUSE", 15))
2422  return_value = _readSortGroupClause();
2423  else if (MATCH("GROUPINGSET", 11))
2424  return_value = _readGroupingSet();
2425  else if (MATCH("WINDOWCLAUSE", 12))
2426  return_value = _readWindowClause();
2427  else if (MATCH("ROWMARKCLAUSE", 13))
2428  return_value = _readRowMarkClause();
2429  else if (MATCH("COMMONTABLEEXPR", 15))
2430  return_value = _readCommonTableExpr();
2431  else if (MATCH("SETOPERATIONSTMT", 16))
2432  return_value = _readSetOperationStmt();
2433  else if (MATCH("ALIAS", 5))
2434  return_value = _readAlias();
2435  else if (MATCH("RANGEVAR", 8))
2436  return_value = _readRangeVar();
2437  else if (MATCH("INTOCLAUSE", 10))
2438  return_value = _readIntoClause();
2439  else if (MATCH("TABLEFUNC", 9))
2440  return_value = _readTableFunc();
2441  else if (MATCH("VAR", 3))
2442  return_value = _readVar();
2443  else if (MATCH("CONST", 5))
2444  return_value = _readConst();
2445  else if (MATCH("PARAM", 5))
2446  return_value = _readParam();
2447  else if (MATCH("AGGREF", 6))
2448  return_value = _readAggref();
2449  else if (MATCH("GROUPINGFUNC", 12))
2450  return_value = _readGroupingFunc();
2451  else if (MATCH("WINDOWFUNC", 10))
2452  return_value = _readWindowFunc();
2453  else if (MATCH("ARRAYREF", 8))
2454  return_value = _readArrayRef();
2455  else if (MATCH("FUNCEXPR", 8))
2456  return_value = _readFuncExpr();
2457  else if (MATCH("NAMEDARGEXPR", 12))
2458  return_value = _readNamedArgExpr();
2459  else if (MATCH("OPEXPR", 6))
2460  return_value = _readOpExpr();
2461  else if (MATCH("DISTINCTEXPR", 12))
2462  return_value = _readDistinctExpr();
2463  else if (MATCH("NULLIFEXPR", 10))
2464  return_value = _readNullIfExpr();
2465  else if (MATCH("SCALARARRAYOPEXPR", 17))
2466  return_value = _readScalarArrayOpExpr();
2467  else if (MATCH("BOOLEXPR", 8))
2468  return_value = _readBoolExpr();
2469  else if (MATCH("SUBLINK", 7))
2470  return_value = _readSubLink();
2471  else if (MATCH("FIELDSELECT", 11))
2472  return_value = _readFieldSelect();
2473  else if (MATCH("FIELDSTORE", 10))
2474  return_value = _readFieldStore();
2475  else if (MATCH("RELABELTYPE", 11))
2476  return_value = _readRelabelType();
2477  else if (MATCH("COERCEVIAIO", 11))
2478  return_value = _readCoerceViaIO();
2479  else if (MATCH("ARRAYCOERCEEXPR", 15))
2480  return_value = _readArrayCoerceExpr();
2481  else if (MATCH("CONVERTROWTYPEEXPR", 18))
2482  return_value = _readConvertRowtypeExpr();
2483  else if (MATCH("COLLATE", 7))
2484  return_value = _readCollateExpr();
2485  else if (MATCH("CASE", 4))
2486  return_value = _readCaseExpr();
2487  else if (MATCH("WHEN", 4))
2488  return_value = _readCaseWhen();
2489  else if (MATCH("CASETESTEXPR", 12))
2490  return_value = _readCaseTestExpr();
2491  else if (MATCH("ARRAY", 5))
2492  return_value = _readArrayExpr();
2493  else if (MATCH("ROW", 3))
2494  return_value = _readRowExpr();
2495  else if (MATCH("ROWCOMPARE", 10))
2496  return_value = _readRowCompareExpr();
2497  else if (MATCH("COALESCE", 8))
2498  return_value = _readCoalesceExpr();
2499  else if (MATCH("MINMAX", 6))
2500  return_value = _readMinMaxExpr();
2501  else if (MATCH("SQLVALUEFUNCTION", 16))
2502  return_value = _readSQLValueFunction();
2503  else if (MATCH("XMLEXPR", 7))
2504  return_value = _readXmlExpr();
2505  else if (MATCH("NULLTEST", 8))
2506  return_value = _readNullTest();
2507  else if (MATCH("BOOLEANTEST", 11))
2508  return_value = _readBooleanTest();
2509  else if (MATCH("COERCETODOMAIN", 14))
2510  return_value = _readCoerceToDomain();
2511  else if (MATCH("COERCETODOMAINVALUE", 19))
2512  return_value = _readCoerceToDomainValue();
2513  else if (MATCH("SETTODEFAULT", 12))
2514  return_value = _readSetToDefault();
2515  else if (MATCH("CURRENTOFEXPR", 13))
2516  return_value = _readCurrentOfExpr();
2517  else if (MATCH("INFERENCEELEM", 13))
2518  return_value = _readInferenceElem();
2519  else if (MATCH("TARGETENTRY", 11))
2520  return_value = _readTargetEntry();
2521  else if (MATCH("RANGETBLREF", 11))
2522  return_value = _readRangeTblRef();
2523  else if (MATCH("JOINEXPR", 8))
2524  return_value = _readJoinExpr();
2525  else if (MATCH("FROMEXPR", 8))
2526  return_value = _readFromExpr();
2527  else if (MATCH("ONCONFLICTEXPR", 14))
2528  return_value = _readOnConflictExpr();
2529  else if (MATCH("RTE", 3))
2530  return_value = _readRangeTblEntry();
2531  else if (MATCH("RANGETBLFUNCTION", 16))
2532  return_value = _readRangeTblFunction();
2533  else if (MATCH("TABLESAMPLECLAUSE", 17))
2534  return_value = _readTableSampleClause();
2535  else if (MATCH("NOTIFY", 6))
2536  return_value = _readNotifyStmt();
2537  else if (MATCH("DEFELEM", 7))
2538  return_value = _readDefElem();
2539  else if (MATCH("DECLARECURSOR", 13))
2540  return_value = _readDeclareCursorStmt();
2541  else if (MATCH("PLANNEDSTMT", 11))
2542  return_value = _readPlannedStmt();
2543  else if (MATCH("PLAN", 4))
2544  return_value = _readPlan();
2545  else if (MATCH("RESULT", 6))
2546  return_value = _readResult();
2547  else if (MATCH("PROJECTSET", 10))
2548  return_value = _readProjectSet();
2549  else if (MATCH("MODIFYTABLE", 11))
2550  return_value = _readModifyTable();
2551  else if (MATCH("APPEND", 6))
2552  return_value = _readAppend();
2553  else if (MATCH("MERGEAPPEND", 11))
2554  return_value = _readMergeAppend();
2555  else if (MATCH("RECURSIVEUNION", 14))
2556  return_value = _readRecursiveUnion();
2557  else if (MATCH("BITMAPAND", 9))
2558  return_value = _readBitmapAnd();
2559  else if (MATCH("BITMAPOR", 8))
2560  return_value = _readBitmapOr();
2561  else if (MATCH("SCAN", 4))
2562  return_value = _readScan();
2563  else if (MATCH("SEQSCAN", 7))
2564  return_value = _readSeqScan();
2565  else if (MATCH("SAMPLESCAN", 10))
2566  return_value = _readSampleScan();
2567  else if (MATCH("INDEXSCAN", 9))
2568  return_value = _readIndexScan();
2569  else if (MATCH("INDEXONLYSCAN", 13))
2570  return_value = _readIndexOnlyScan();
2571  else if (MATCH("BITMAPINDEXSCAN", 15))
2572  return_value = _readBitmapIndexScan();
2573  else if (MATCH("BITMAPHEAPSCAN", 14))
2574  return_value = _readBitmapHeapScan();
2575  else if (MATCH("TIDSCAN", 7))
2576  return_value = _readTidScan();
2577  else if (MATCH("SUBQUERYSCAN", 12))
2578  return_value = _readSubqueryScan();
2579  else if (MATCH("FUNCTIONSCAN", 12))
2580  return_value = _readFunctionScan();
2581  else if (MATCH("VALUESSCAN", 10))
2582  return_value = _readValuesScan();
2583  else if (MATCH("TABLEFUNCSCAN", 13))
2584  return_value = _readTableFuncScan();
2585  else if (MATCH("CTESCAN", 7))
2586  return_value = _readCteScan();
2587  else if (MATCH("WORKTABLESCAN", 13))
2588  return_value = _readWorkTableScan();
2589  else if (MATCH("FOREIGNSCAN", 11))
2590  return_value = _readForeignScan();
2591  else if (MATCH("CUSTOMSCAN", 10))
2592  return_value = _readCustomScan();
2593  else if (MATCH("JOIN", 4))
2594  return_value = _readJoin();
2595  else if (MATCH("NESTLOOP", 8))
2596  return_value = _readNestLoop();
2597  else if (MATCH("MERGEJOIN", 9))
2598  return_value = _readMergeJoin();
2599  else if (MATCH("HASHJOIN", 8))
2600  return_value = _readHashJoin();
2601  else if (MATCH("MATERIAL", 8))
2602  return_value = _readMaterial();
2603  else if (MATCH("SORT", 4))
2604  return_value = _readSort();
2605  else if (MATCH("GROUP", 5))
2606  return_value = _readGroup();
2607  else if (MATCH("AGG", 3))
2608  return_value = _readAgg();
2609  else if (MATCH("WINDOWAGG", 9))
2610  return_value = _readWindowAgg();
2611  else if (MATCH("UNIQUE", 6))
2612  return_value = _readUnique();
2613  else if (MATCH("GATHER", 6))
2614  return_value = _readGather();
2615  else if (MATCH("GATHERMERGE", 11))
2616  return_value = _readGatherMerge();
2617  else if (MATCH("HASH", 4))
2618  return_value = _readHash();
2619  else if (MATCH("SETOP", 5))
2620  return_value = _readSetOp();
2621  else if (MATCH("LOCKROWS", 8))
2622  return_value = _readLockRows();
2623  else if (MATCH("LIMIT", 5))
2624  return_value = _readLimit();
2625  else if (MATCH("NESTLOOPPARAM", 13))
2626  return_value = _readNestLoopParam();
2627  else if (MATCH("PLANROWMARK", 11))
2628  return_value = _readPlanRowMark();
2629  else if (MATCH("PLANINVALITEM", 13))
2630  return_value = _readPlanInvalItem();
2631  else if (MATCH("SUBPLAN", 7))
2632  return_value = _readSubPlan();
2633  else if (MATCH("ALTERNATIVESUBPLAN", 18))
2634  return_value = _readAlternativeSubPlan();
2635  else if (MATCH("EXTENSIBLENODE", 14))
2636  return_value = _readExtensibleNode();
2637  else if (MATCH("PARTITIONBOUND", 14))
2638  return_value = _readPartitionBoundSpec();
2639  else if (MATCH("PARTRANGEDATUM", 14))
2640  return_value = _readPartitionRangeDatum();
2641  else
2642  {
2643  elog(ERROR, "badly formatted node string \"%.32s\"...", token);
2644  return_value = NULL; /* keep compiler quiet */
2645  }
2646 
2647  return (Node *) return_value;
2648 }
2649 
2650 
2651 /*
2652  * readDatum
2653  *
2654  * Given a string representation of a constant, recreate the appropriate
2655  * Datum. The string representation embeds length info, but not byValue,
2656  * so we must be told that.
2657  */
2658 Datum
2659 readDatum(bool typbyval)
2660 {
2661  Size length,
2662  i;
2663  int tokenLength;
2664  char *token;
2665  Datum res;
2666  char *s;
2667 
2668  /*
2669  * read the actual length of the value
2670  */
2671  token = pg_strtok(&tokenLength);
2672  length = atoui(token);
2673 
2674  token = pg_strtok(&tokenLength); /* read the '[' */
2675  if (token == NULL || token[0] != '[')
2676  elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
2677  token ? (const char *) token : "[NULL]", length);
2678 
2679  if (typbyval)
2680  {
2681  if (length > (Size) sizeof(Datum))
2682  elog(ERROR, "byval datum but length = %zu", length);
2683  res = (Datum) 0;
2684  s = (char *) (&res);
2685  for (i = 0; i < (Size) sizeof(Datum); i++)
2686  {
2687  token = pg_strtok(&tokenLength);
2688  s[i] = (char) atoi(token);
2689  }
2690  }
2691  else if (length <= 0)
2692  res = (Datum) NULL;
2693  else
2694  {
2695  s = (char *) palloc(length);
2696  for (i = 0; i < length; i++)
2697  {
2698  token = pg_strtok(&tokenLength);
2699  s[i] = (char) atoi(token);
2700  }
2701  res = PointerGetDatum(s);
2702  }
2703 
2704  token = pg_strtok(&tokenLength); /* read the ']' */
2705  if (token == NULL || token[0] != ']')
2706  elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
2707  token ? (const char *) token : "[NULL]", length);
2708 
2709  return res;
2710 }
2711 
2712 /*
2713  * readAttrNumberCols
2714  */
2715 AttrNumber *
2717 {
2718  int tokenLength,
2719  i;
2720  char *token;
2721  AttrNumber *attr_vals;
2722 
2723  if (numCols <= 0)
2724  return NULL;
2725 
2726  attr_vals = (AttrNumber *) palloc(numCols * sizeof(AttrNumber));
2727  for (i = 0; i < numCols; i++)
2728  {
2729  token = pg_strtok(&tokenLength);
2730  attr_vals[i] = atoi(token);
2731  }
2732 
2733  return attr_vals;
2734 }
2735 
2736 /*
2737  * readOidCols
2738  */
2739 Oid *
2740 readOidCols(int numCols)
2741 {
2742  int tokenLength,
2743  i;
2744  char *token;
2745  Oid *oid_vals;
2746 
2747  if (numCols <= 0)
2748  return NULL;
2749 
2750  oid_vals = (Oid *) palloc(numCols * sizeof(Oid));
2751  for (i = 0; i < numCols; i++)
2752  {
2753  token = pg_strtok(&tokenLength);
2754  oid_vals[i] = atooid(token);
2755  }
2756 
2757  return oid_vals;
2758 }
2759 
2760 /*
2761  * readIntCols
2762  */
2763 int *
2764 readIntCols(int numCols)
2765 {
2766  int tokenLength,
2767  i;
2768  char *token;
2769  int *int_vals;
2770 
2771  if (numCols <= 0)
2772  return NULL;
2773 
2774  int_vals = (int *) palloc(numCols * sizeof(int));
2775  for (i = 0; i < numCols; i++)
2776  {
2777  token = pg_strtok(&tokenLength);
2778  int_vals[i] = atoi(token);
2779  }
2780 
2781  return int_vals;
2782 }
2783 
2784 /*
2785  * readBoolCols
2786  */
2787 bool *
2788 readBoolCols(int numCols)
2789 {
2790  int tokenLength,
2791  i;
2792  char *token;
2793  bool *bool_vals;
2794 
2795  if (numCols <= 0)
2796  return NULL;
2797 
2798  bool_vals = (bool *) palloc(numCols * sizeof(bool));
2799  for (i = 0; i < numCols; i++)
2800  {
2801  token = pg_strtok(&tokenLength);
2802  bool_vals[i] = strtobool(token);
2803  }
2804 
2805  return bool_vals;
2806 }
static NullTest * _readNullTest(void)
Definition: readfuncs.c:1113
static JoinExpr * _readJoinExpr(void)
Definition: readfuncs.c:1256
static RangeVar * _readRangeVar(void)
Definition: readfuncs.c:445
#define atoui(x)
Definition: readfuncs.c:165
static RangeTblEntry * _readRangeTblEntry(void)
Definition: readfuncs.c:1314
static DefElem * _readDefElem(void)
Definition: readfuncs.c:1423
static RowExpr * _readRowExpr(void)
Definition: readfuncs.c:1007
int length(const List *list)
Definition: list.c:1271
static MergeJoin * _readMergeJoin(void)
Definition: readfuncs.c:1991
static MinMaxExpr * _readMinMaxExpr(void)
Definition: readfuncs.c:1058
static RowMarkClause * _readRowMarkClause(void)
Definition: readfuncs.c:374
static FuncExpr * _readFuncExpr(void)
Definition: readfuncs.c:659
Plan plan
Definition: plannodes.h:328
#define READ_BOOL_ARRAY(fldname, len)
Definition: readfuncs.c:150
static Hash * _readHash(void)
Definition: readfuncs.c:2181
char * pg_strtok(int *length)
Definition: read.c:107
static Result * _readResult(void)
Definition: readfuncs.c:1512
static Query * _readQuery(void)
Definition: readfuncs.c:227
static RowCompareExpr * _readRowCompareExpr(void)
Definition: readfuncs.c:1024
static Param * _readParam(void)
Definition: readfuncs.c:553
static PlanInvalItem * _readPlanInvalItem(void)
Definition: readfuncs.c:2286
ParamKind
Definition: primnodes.h:233
static WindowAgg * _readWindowAgg(void)
Definition: readfuncs.c:2103
static IndexScan * _readIndexScan(void)
Definition: readfuncs.c:1716
static NotifyStmt * _readNotifyStmt(void)
Definition: readfuncs.c:275
static Scan * _readScan(void)
Definition: readfuncs.c:1675
static NamedArgExpr * _readNamedArgExpr(void)
Definition: readfuncs.c:680
static LockRows * _readLockRows(void)
Definition: readfuncs.c:2220
static CurrentOfExpr * _readCurrentOfExpr(void)
Definition: readfuncs.c:1194
#define READ_LONG_FIELD(fldname)
Definition: readfuncs.c:74
#define PointerGetDatum(X)
Definition: postgres.h:562
static CollateExpr * _readCollateExpr(void)
Definition: readfuncs.c:926
static SubqueryScan * _readSubqueryScan(void)
Definition: readfuncs.c:1804
BoolTestType
Definition: primnodes.h:1194
#define strtobool(x)
Definition: readfuncs.c:167
static BitmapIndexScan * _readBitmapIndexScan(void)
Definition: readfuncs.c:1756
static CaseExpr * _readCaseExpr(void)
Definition: readfuncs.c:941
static FunctionScan * _readFunctionScan(void)
Definition: readfuncs.c:1819
static PartitionBoundSpec * _readPartitionBoundSpec(void)
Definition: readfuncs.c:2371
#define READ_BOOL_FIELD(fldname)
Definition: readfuncs.c:104
XmlExprOp
Definition: primnodes.h:1120
QuerySource
Definition: parsenodes.h:38
static Unique * _readUnique(void)
Definition: readfuncs.c:2127
static MergeAppend * _readMergeAppend(void)
Definition: readfuncs.c:1590
Definition: nodes.h:509
#define READ_LOCALS_NO_FIELDS(nodeTypeName)
Definition: readfuncs.c:48
static WindowFunc * _readWindowFunc(void)
Definition: readfuncs.c:617
static WindowClause * _readWindowClause(void)
Definition: readfuncs.c:353
return result
Definition: formatting.c:1632
static OpExpr * _readOpExpr(void)
Definition: readfuncs.c:696
static IndexOnlyScan * _readIndexOnlyScan(void)
Definition: readfuncs.c:1737
static BitmapAnd * _readBitmapAnd(void)
Definition: readfuncs.c:1630
NullTestType
Definition: primnodes.h:1171
unsigned int Oid
Definition: postgres_ext.h:31
Definition: primnodes.h:163
static FromExpr * _readFromExpr(void)
Definition: readfuncs.c:1276
static Aggref * _readAggref(void)
Definition: readfuncs.c:571
SetOpStrategy
Definition: nodes.h:786
static NestLoop * _readNestLoop(void)
Definition: readfuncs.c:1976
OnCommitAction
Definition: primnodes.h:47
static ModifyTable * _readModifyTable(void)
Definition: readfuncs.c:1540
JoinType
Definition: nodes.h:672
static DistinctExpr * _readDistinctExpr(void)
Definition: readfuncs.c:716
Oid * readOidCols(int numCols)
Definition: readfuncs.c:2740
static ArrayCoerceExpr * _readArrayCoerceExpr(void)
Definition: readfuncs.c:890
static TargetEntry * _readTargetEntry(void)
Definition: readfuncs.c:1224
#define newNode(size, tag)
Definition: nodes.h:547
static void ReadCommonPlan(Plan *local_node)
Definition: readfuncs.c:1475
static Agg * _readAgg(void)
Definition: readfuncs.c:2080
static SeqScan * _readSeqScan(void)
Definition: readfuncs.c:1688
MinMaxOp
Definition: primnodes.h:1053
SetOperation
Definition: parsenodes.h:1463
bool * readBoolCols(int numCols)
Definition: readfuncs.c:2788
static AlternativeSubPlan * _readAlternativeSubPlan(void)
Definition: readfuncs.c:2328
static CteScan * _readCteScan(void)
Definition: readfuncs.c:1865
static GroupingFunc * _readGroupingFunc(void)
Definition: readfuncs.c:600
#define ERROR
Definition: elog.h:43
static CoerceToDomain * _readCoerceToDomain(void)
Definition: readfuncs.c:1144
static SubLink * _readSubLink(void)
Definition: readfuncs.c:800
static HashJoin * _readHashJoin(void)
Definition: readfuncs.c:2016
#define READ_FLOAT_FIELD(fldname)
Definition: readfuncs.c:98
static ValuesScan * _readValuesScan(void)
Definition: readfuncs.c:1835
static ConvertRowtypeExpr * _readConvertRowtypeExpr(void)
Definition: readfuncs.c:910
#define READ_OID_ARRAY(fldname, len)
Definition: readfuncs.c:140
static OnConflictExpr * _readOnConflictExpr(void)
Definition: readfuncs.c:1290
RTEKind
Definition: parsenodes.h:913
static NullIfExpr * _readNullIfExpr(void)
Definition: readfuncs.c:736
static Append * _readAppend(void)
Definition: readfuncs.c:1574
static ExtensibleNode * _readExtensibleNode(void)
Definition: readfuncs.c:2341
static PlanRowMark * _readPlanRowMark(void)
Definition: readfuncs.c:2266
static FieldSelect * _readFieldSelect(void)
Definition: readfuncs.c:822
int * readIntCols(int numCols)
Definition: readfuncs.c:2764
static ArrayRef * _readArrayRef(void)
Definition: readfuncs.c:639
ScanDirection
Definition: sdir.h:22
static CaseWhen * _readCaseWhen(void)
Definition: readfuncs.c:959
static SQLValueFunction * _readSQLValueFunction(void)
Definition: readfuncs.c:1076
#define READ_CHAR_FIELD(fldname)
Definition: readfuncs.c:86
AttrNumber * readAttrNumberCols(int numCols)
Definition: readfuncs.c:2716
#define MATCH(tokname, namelen)
#define atooid(x)
Definition: postgres_ext.h:42
static ForeignScan * _readForeignScan(void)
Definition: readfuncs.c:1896
static RelabelType * _readRelabelType(void)
Definition: readfuncs.c:855
WCOKind
Definition: parsenodes.h:1078
static SetOp * _readSetOp(void)
Definition: readfuncs.c:2198
#define READ_UINT_FIELD(fldname)
Definition: readfuncs.c:68
#define READ_ENUM_FIELD(fldname, enumtype)
Definition: readfuncs.c:92
Datum readDatum(bool typbyval)
Definition: readfuncs.c:2659
SQLValueFunctionOp
Definition: primnodes.h:1081
static SortGroupClause * _readSortGroupClause(void)
Definition: readfuncs.c:321
void(* nodeRead)(struct ExtensibleNode *node)
Definition: extensible.h:70
#define READ_NODE_FIELD(fldname)
Definition: readfuncs.c:123
SubLinkType
Definition: primnodes.h:617
Bitmapset * readBitmapset(void)
Definition: readfuncs.c:218
static Limit * _readLimit(void)
Definition: readfuncs.c:2236
static PartitionRangeDatum * _readPartitionRangeDatum(void)
Definition: readfuncs.c:2387
LockClauseStrength
Definition: lockoptions.h:21
static void ReadCommonScan(Scan *local_node)
Definition: readfuncs.c:1662
uintptr_t Datum
Definition: postgres.h:372
static void ReadCommonJoin(Join *local_node)
Definition: readfuncs.c:1948
static GatherMerge * _readGatherMerge(void)
Definition: readfuncs.c:2161
static DeclareCursorStmt * _readDeclareCursorStmt(void)
Definition: readfuncs.c:289
static Gather * _readGather(void)
Definition: readfuncs.c:2144
#define READ_TEMP_LOCALS()
Definition: readfuncs.c:52
const char * extnodename
Definition: extensible.h:35
static Var * _readVar(void)
Definition: readfuncs.c:507
#define READ_LOCATION_FIELD(fldname)
Definition: readfuncs.c:116
RowCompareType
Definition: primnodes.h:1016
static SampleScan * _readSampleScan(void)
Definition: readfuncs.c:1701
static SubPlan * _readSubPlan(void)
Definition: readfuncs.c:2300
#define READ_LOCALS(nodeTypeName)
Definition: readfuncs.c:57
#define NULL
Definition: c.h:229
static TidScan * _readTidScan(void)
Definition: readfuncs.c:1789
static CoerceToDomainValue * _readCoerceToDomainValue(void)
Definition: readfuncs.c:1162
static TableFuncScan * _readTableFuncScan(void)
Definition: readfuncs.c:1850
static IntoClause * _readIntoClause(void)
Definition: readfuncs.c:488
static Const * _readConst(void)
Definition: readfuncs.c:528
static SetOperationStmt * _readSetOperationStmt(void)
Definition: readfuncs.c:412
static PlannedStmt * _readPlannedStmt(void)
Definition: readfuncs.c:1440
XmlOptionType
Definition: primnodes.h:1132
size_t Size
Definition: c.h:356
static Material * _readMaterial(void)
Definition: readfuncs.c:2031
AggSplit
Definition: nodes.h:756
#define READ_OID_FIELD(fldname)
Definition: readfuncs.c:80
static int list_length(const List *l)
Definition: pg_list.h:89
static CaseTestExpr * _readCaseTestExpr(void)
Definition: readfuncs.c:974
RowMarkType
Definition: plannodes.h:952
static Alias * _readAlias(void)
Definition: readfuncs.c:434
static BitmapOr * _readBitmapOr(void)
Definition: readfuncs.c:1645
static const struct fns functions
Definition: regcomp.c:299
static RangeTblRef * _readRangeTblRef(void)
Definition: readfuncs.c:1243
static RecursiveUnion * _readRecursiveUnion(void)
Definition: readfuncs.c:1611
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:698
static FieldStore * _readFieldStore(void)
Definition: readfuncs.c:839
static CoalesceExpr * _readCoalesceExpr(void)
Definition: readfuncs.c:1042
const char * name
Definition: encode.c:521
#define READ_BITMAPSET_FIELD(fldname)
Definition: readfuncs.c:129
Node * parseNodeString(void)
Definition: readfuncs.c:2406
static SetToDefault * _readSetToDefault(void)
Definition: readfuncs.c:1178
static WithCheckOption * _readWithCheckOption(void)
Definition: readfuncs.c:304
static InferenceElem * _readInferenceElem(void)
Definition: readfuncs.c:1209
AggStrategy
Definition: nodes.h:734
static ScalarArrayOpExpr * _readScalarArrayOpExpr(void)
Definition: readfuncs.c:756
void * palloc(Size size)
Definition: mcxt.c:849
int xmloption
Definition: xml.c:97
SetOpCmd
Definition: nodes.h:778
int i
static BoolExpr * _readBoolExpr(void)
Definition: readfuncs.c:774
static CustomScan * _readCustomScan(void)
Definition: readfuncs.c:1918
DefElemAction
Definition: parsenodes.h:708
void * arg
static CommonTableExpr * _readCommonTableExpr(void)
Definition: readfuncs.c:390
static ArrayExpr * _readArrayExpr(void)
Definition: readfuncs.c:989
GroupingSetKind
Definition: parsenodes.h:1214
#define READ_STRING_FIELD(fldname)
Definition: readfuncs.c:110
#define READ_DONE()
Definition: readfuncs.c:155
#define READ_INT_FIELD(fldname)
Definition: readfuncs.c:62
Definition: plannodes.h:782
#define elog
Definition: elog.h:219
static struct @121 value
static RangeTblFunction * _readRangeTblFunction(void)
Definition: readfuncs.c:1389
static BooleanTest * _readBooleanTest(void)
Definition: readfuncs.c:1129
static Plan * _readPlan(void)
Definition: readfuncs.c:1499
static XmlExpr * _readXmlExpr(void)
Definition: readfuncs.c:1092
#define READ_ATTRNUMBER_ARRAY(fldname, len)
Definition: readfuncs.c:135
CoercionForm
Definition: primnodes.h:435
static TableFunc * _readTableFunc(void)
Definition: readfuncs.c:466
#define READ_INT_ARRAY(fldname, len)
Definition: readfuncs.c:145
const CustomScanMethods * GetCustomScanMethods(const char *CustomName, bool missing_ok)
Definition: extensible.c:137
static TableSampleClause * _readTableSampleClause(void)
Definition: readfuncs.c:1408
static NestLoopParam * _readNestLoopParam(void)
Definition: readfuncs.c:2252
static ProjectSet * _readProjectSet(void)
Definition: readfuncs.c:1527
OnConflictAction
Definition: nodes.h:798
static BitmapHeapScan * _readBitmapHeapScan(void)
Definition: readfuncs.c:1774
int16 AttrNumber
Definition: attnum.h:21
LockWaitPolicy
Definition: lockoptions.h:36
long val
Definition: informix.c:689
static Bitmapset * _readBitmapset(void)
Definition: readfuncs.c:177
CmdType
Definition: nodes.h:648
static Join * _readJoin(void)
Definition: readfuncs.c:1963
static Sort * _readSort(void)
Definition: readfuncs.c:2044
static CoerceViaIO * _readCoerceViaIO(void)
Definition: readfuncs.c:873
static Group * _readGroup(void)
Definition: readfuncs.c:2063
static GroupingSet * _readGroupingSet(void)
Definition: readfuncs.c:338
static WorkTableScan * _readWorkTableScan(void)
Definition: readfuncs.c:1881
const ExtensibleNodeMethods * GetExtensibleNodeMethods(const char *extnodename, bool missing_ok)
Definition: extensible.c:125
#define nullable_string(token, length)
Definition: readfuncs.c:169
Plan plan
Definition: plannodes.h:668
OverridingKind
Definition: parsenodes.h:30