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