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