1 /*-------------------------------------------------------------------------
4 * Reader functions for Postgres tree nodes.
6 * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
11 * src/backend/nodes/readfuncs.c
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.
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.
25 *-------------------------------------------------------------------------
32 #include "nodes/extensible.h"
33 #include "nodes/parsenodes.h"
34 #include "nodes/plannodes.h"
35 #include "nodes/readfuncs.h"
36 #include "utils/builtins.h"
40 * Macros to simplify reading of different kinds of fields. Use these
41 * wherever possible to reduce the chance for silly typos. Note that these
42 * hard-wire conventions about the names of the local variables in a Read
46 /* Macros for declaring appropriate local variables */
48 /* A few guys need only local_node */
49 #define READ_LOCALS_NO_FIELDS(nodeTypeName) \
50 nodeTypeName *local_node = makeNode(nodeTypeName)
52 /* And a few guys need only the pg_strtok support fields */
53 #define READ_TEMP_LOCALS() \
57 /* ... but most need both */
58 #define READ_LOCALS(nodeTypeName) \
59 READ_LOCALS_NO_FIELDS(nodeTypeName); \
62 /* Read an integer field (anything written as ":fldname %d") */
63 #define READ_INT_FIELD(fldname) \
64 token = pg_strtok(&length); /* skip :fldname */ \
65 token = pg_strtok(&length); /* get field value */ \
66 local_node->fldname = atoi(token)
68 /* Read an unsigned integer field (anything written as ":fldname %u") */
69 #define READ_UINT_FIELD(fldname) \
70 token = pg_strtok(&length); /* skip :fldname */ \
71 token = pg_strtok(&length); /* get field value */ \
72 local_node->fldname = atoui(token)
74 /* Read an unsigned integer field (anything written using UINT64_FORMAT) */
75 #define READ_UINT64_FIELD(fldname) \
76 token = pg_strtok(&length); /* skip :fldname */ \
77 token = pg_strtok(&length); /* get field value */ \
78 local_node->fldname = pg_strtouint64(token, NULL, 10)
80 /* Read a long integer field (anything written as ":fldname %ld") */
81 #define READ_LONG_FIELD(fldname) \
82 token = pg_strtok(&length); /* skip :fldname */ \
83 token = pg_strtok(&length); /* get field value */ \
84 local_node->fldname = atol(token)
86 /* Read an OID field (don't hard-wire assumption that OID is same as uint) */
87 #define READ_OID_FIELD(fldname) \
88 token = pg_strtok(&length); /* skip :fldname */ \
89 token = pg_strtok(&length); /* get field value */ \
90 local_node->fldname = atooid(token)
92 /* Read a char field (ie, one ascii character) */
93 #define READ_CHAR_FIELD(fldname) \
94 token = pg_strtok(&length); /* skip :fldname */ \
95 token = pg_strtok(&length); /* get field value */ \
96 /* avoid overhead of calling debackslash() for one char */ \
97 local_node->fldname = (length == 0) ? '\0' : (token[0] == '\\' ? token[1] : token[0])
99 /* Read an enumerated-type field that was written as an integer code */
100 #define READ_ENUM_FIELD(fldname, enumtype) \
101 token = pg_strtok(&length); /* skip :fldname */ \
102 token = pg_strtok(&length); /* get field value */ \
103 local_node->fldname = (enumtype) atoi(token)
105 /* Read a float field */
106 #define READ_FLOAT_FIELD(fldname) \
107 token = pg_strtok(&length); /* skip :fldname */ \
108 token = pg_strtok(&length); /* get field value */ \
109 local_node->fldname = atof(token)
111 /* Read a boolean field */
112 #define READ_BOOL_FIELD(fldname) \
113 token = pg_strtok(&length); /* skip :fldname */ \
114 token = pg_strtok(&length); /* get field value */ \
115 local_node->fldname = strtobool(token)
117 /* Read a character-string field */
118 #define READ_STRING_FIELD(fldname) \
119 token = pg_strtok(&length); /* skip :fldname */ \
120 token = pg_strtok(&length); /* get field value */ \
121 local_node->fldname = nullable_string(token, length)
123 /* Read a parse location field (and throw away the value, per notes above) */
124 #define READ_LOCATION_FIELD(fldname) \
125 token = pg_strtok(&length); /* skip :fldname */ \
126 token = pg_strtok(&length); /* get field value */ \
127 (void) token; /* in case not used elsewhere */ \
128 local_node->fldname = -1 /* set field to "unknown" */
130 /* Read a Node field */
131 #define READ_NODE_FIELD(fldname) \
132 token = pg_strtok(&length); /* skip :fldname */ \
133 (void) token; /* in case not used elsewhere */ \
134 local_node->fldname = nodeRead(NULL, 0)
136 /* Read a bitmapset field */
137 #define READ_BITMAPSET_FIELD(fldname) \
138 token = pg_strtok(&length); /* skip :fldname */ \
139 (void) token; /* in case not used elsewhere */ \
140 local_node->fldname = _readBitmapset()
142 /* Read an attribute number array */
143 #define READ_ATTRNUMBER_ARRAY(fldname, len) \
144 token = pg_strtok(&length); /* skip :fldname */ \
145 local_node->fldname = readAttrNumberCols(len);
147 /* Read an oid array */
148 #define READ_OID_ARRAY(fldname, len) \
149 token = pg_strtok(&length); /* skip :fldname */ \
150 local_node->fldname = readOidCols(len);
152 /* Read an int array */
153 #define READ_INT_ARRAY(fldname, len) \
154 token = pg_strtok(&length); /* skip :fldname */ \
155 local_node->fldname = readIntCols(len);
157 /* Read a bool array */
158 #define READ_BOOL_ARRAY(fldname, len) \
159 token = pg_strtok(&length); /* skip :fldname */ \
160 local_node->fldname = readBoolCols(len);
163 #define READ_DONE() \
168 * NOTE: use atoi() to read values written with %d, or atoui() to read
169 * values written with %u in outfuncs.c. An exception is OID values,
170 * for which use atooid(). (As of 7.1, outfuncs.c writes OIDs as %u,
171 * but this will probably change in the future.)
173 #define atoui(x) ((unsigned int) strtoul((x), NULL, 10))
175 #define strtobool(x) ((*(x) == 't') ? true : false)
177 #define nullable_string(token,length) \
178 ((length) == 0 ? NULL : debackslash(token, length))
187 Bitmapset *result = NULL;
191 token = pg_strtok(&length);
193 elog(ERROR, "incomplete Bitmapset structure");
194 if (length != 1 || token[0] != '(')
195 elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
197 token = pg_strtok(&length);
199 elog(ERROR, "incomplete Bitmapset structure");
200 if (length != 1 || token[0] != 'b')
201 elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
208 token = pg_strtok(&length);
210 elog(ERROR, "unterminated Bitmapset structure");
211 if (length == 1 && token[0] == ')')
213 val = (int) strtol(token, &endptr, 10);
214 if (endptr != token + length)
215 elog(ERROR, "unrecognized integer: \"%.*s\"", length, token);
216 result = bms_add_member(result, val);
223 * for use by extensions which define extensible nodes
228 return _readBitmapset();
239 READ_ENUM_FIELD(commandType, CmdType);
240 READ_ENUM_FIELD(querySource, QuerySource);
241 local_node->queryId = UINT64CONST(0); /* not saved in output format */
242 READ_BOOL_FIELD(canSetTag);
243 READ_NODE_FIELD(utilityStmt);
244 READ_INT_FIELD(resultRelation);
245 READ_BOOL_FIELD(hasAggs);
246 READ_BOOL_FIELD(hasWindowFuncs);
247 READ_BOOL_FIELD(hasTargetSRFs);
248 READ_BOOL_FIELD(hasSubLinks);
249 READ_BOOL_FIELD(hasDistinctOn);
250 READ_BOOL_FIELD(hasRecursive);
251 READ_BOOL_FIELD(hasModifyingCTE);
252 READ_BOOL_FIELD(hasForUpdate);
253 READ_BOOL_FIELD(hasRowSecurity);
254 READ_NODE_FIELD(cteList);
255 READ_NODE_FIELD(rtable);
256 READ_NODE_FIELD(jointree);
257 READ_NODE_FIELD(targetList);
258 READ_ENUM_FIELD(override, OverridingKind);
259 READ_NODE_FIELD(onConflict);
260 READ_NODE_FIELD(returningList);
261 READ_NODE_FIELD(groupClause);
262 READ_NODE_FIELD(groupingSets);
263 READ_NODE_FIELD(havingQual);
264 READ_NODE_FIELD(windowClause);
265 READ_NODE_FIELD(distinctClause);
266 READ_NODE_FIELD(sortClause);
267 READ_NODE_FIELD(limitOffset);
268 READ_NODE_FIELD(limitCount);
269 READ_NODE_FIELD(rowMarks);
270 READ_NODE_FIELD(setOperations);
271 READ_NODE_FIELD(constraintDeps);
272 /* withCheckOptions intentionally omitted, see comment in parsenodes.h */
273 READ_INT_FIELD(mergeTarget_relation);
274 READ_NODE_FIELD(mergeSourceTargetList);
275 READ_NODE_FIELD(mergeActionList);
276 READ_LOCATION_FIELD(stmt_location);
277 READ_LOCATION_FIELD(stmt_len);
286 _readNotifyStmt(void)
288 READ_LOCALS(NotifyStmt);
290 READ_STRING_FIELD(conditionname);
291 READ_STRING_FIELD(payload);
297 * _readDeclareCursorStmt
299 static DeclareCursorStmt *
300 _readDeclareCursorStmt(void)
302 READ_LOCALS(DeclareCursorStmt);
304 READ_STRING_FIELD(portalname);
305 READ_INT_FIELD(options);
306 READ_NODE_FIELD(query);
312 * _readWithCheckOption
314 static WithCheckOption *
315 _readWithCheckOption(void)
317 READ_LOCALS(WithCheckOption);
319 READ_ENUM_FIELD(kind, WCOKind);
320 READ_STRING_FIELD(relname);
321 READ_STRING_FIELD(polname);
322 READ_NODE_FIELD(qual);
323 READ_BOOL_FIELD(cascaded);
329 * _readSortGroupClause
331 static SortGroupClause *
332 _readSortGroupClause(void)
334 READ_LOCALS(SortGroupClause);
336 READ_UINT_FIELD(tleSortGroupRef);
337 READ_OID_FIELD(eqop);
338 READ_OID_FIELD(sortop);
339 READ_BOOL_FIELD(nulls_first);
340 READ_BOOL_FIELD(hashable);
349 _readGroupingSet(void)
351 READ_LOCALS(GroupingSet);
353 READ_ENUM_FIELD(kind, GroupingSetKind);
354 READ_NODE_FIELD(content);
355 READ_LOCATION_FIELD(location);
363 static WindowClause *
364 _readWindowClause(void)
366 READ_LOCALS(WindowClause);
368 READ_STRING_FIELD(name);
369 READ_STRING_FIELD(refname);
370 READ_NODE_FIELD(partitionClause);
371 READ_NODE_FIELD(orderClause);
372 READ_INT_FIELD(frameOptions);
373 READ_NODE_FIELD(startOffset);
374 READ_NODE_FIELD(endOffset);
375 READ_OID_FIELD(startInRangeFunc);
376 READ_OID_FIELD(endInRangeFunc);
377 READ_OID_FIELD(inRangeColl);
378 READ_BOOL_FIELD(inRangeAsc);
379 READ_BOOL_FIELD(inRangeNullsFirst);
380 READ_UINT_FIELD(winref);
381 READ_BOOL_FIELD(copiedOrder);
389 static RowMarkClause *
390 _readRowMarkClause(void)
392 READ_LOCALS(RowMarkClause);
394 READ_UINT_FIELD(rti);
395 READ_ENUM_FIELD(strength, LockClauseStrength);
396 READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
397 READ_BOOL_FIELD(pushedDown);
403 * _readCommonTableExpr
405 static CommonTableExpr *
406 _readCommonTableExpr(void)
408 READ_LOCALS(CommonTableExpr);
410 READ_STRING_FIELD(ctename);
411 READ_NODE_FIELD(aliascolnames);
412 READ_NODE_FIELD(ctequery);
413 READ_LOCATION_FIELD(location);
414 READ_BOOL_FIELD(cterecursive);
415 READ_INT_FIELD(cterefcount);
416 READ_NODE_FIELD(ctecolnames);
417 READ_NODE_FIELD(ctecoltypes);
418 READ_NODE_FIELD(ctecoltypmods);
419 READ_NODE_FIELD(ctecolcollations);
425 * _readSetOperationStmt
427 static SetOperationStmt *
428 _readSetOperationStmt(void)
430 READ_LOCALS(SetOperationStmt);
432 READ_ENUM_FIELD(op, SetOperation);
433 READ_BOOL_FIELD(all);
434 READ_NODE_FIELD(larg);
435 READ_NODE_FIELD(rarg);
436 READ_NODE_FIELD(colTypes);
437 READ_NODE_FIELD(colTypmods);
438 READ_NODE_FIELD(colCollations);
439 READ_NODE_FIELD(groupClauses);
446 * Stuff from primnodes.h.
454 READ_STRING_FIELD(aliasname);
455 READ_NODE_FIELD(colnames);
463 READ_LOCALS(RangeVar);
465 local_node->catalogname = NULL; /* not currently saved in output format */
467 READ_STRING_FIELD(schemaname);
468 READ_STRING_FIELD(relname);
469 READ_BOOL_FIELD(inh);
470 READ_CHAR_FIELD(relpersistence);
471 READ_NODE_FIELD(alias);
472 READ_LOCATION_FIELD(location);
483 READ_LOCALS(TableFunc);
485 READ_NODE_FIELD(ns_uris);
486 READ_NODE_FIELD(ns_names);
487 READ_NODE_FIELD(docexpr);
488 READ_NODE_FIELD(rowexpr);
489 READ_NODE_FIELD(colnames);
490 READ_NODE_FIELD(coltypes);
491 READ_NODE_FIELD(coltypmods);
492 READ_NODE_FIELD(colcollations);
493 READ_NODE_FIELD(colexprs);
494 READ_NODE_FIELD(coldefexprs);
495 READ_BITMAPSET_FIELD(notnulls);
496 READ_INT_FIELD(ordinalitycol);
497 READ_LOCATION_FIELD(location);
503 _readIntoClause(void)
505 READ_LOCALS(IntoClause);
507 READ_NODE_FIELD(rel);
508 READ_NODE_FIELD(colNames);
509 READ_NODE_FIELD(options);
510 READ_ENUM_FIELD(onCommit, OnCommitAction);
511 READ_STRING_FIELD(tableSpaceName);
512 READ_NODE_FIELD(viewQuery);
513 READ_BOOL_FIELD(skipData);
526 READ_UINT_FIELD(varno);
527 READ_INT_FIELD(varattno);
528 READ_OID_FIELD(vartype);
529 READ_INT_FIELD(vartypmod);
530 READ_OID_FIELD(varcollid);
531 READ_UINT_FIELD(varlevelsup);
532 READ_UINT_FIELD(varnoold);
533 READ_INT_FIELD(varoattno);
534 READ_LOCATION_FIELD(location);
547 READ_OID_FIELD(consttype);
548 READ_INT_FIELD(consttypmod);
549 READ_OID_FIELD(constcollid);
550 READ_INT_FIELD(constlen);
551 READ_BOOL_FIELD(constbyval);
552 READ_BOOL_FIELD(constisnull);
553 READ_LOCATION_FIELD(location);
555 token = pg_strtok(&length); /* skip :constvalue */
556 if (local_node->constisnull)
557 token = pg_strtok(&length); /* skip "<>" */
559 local_node->constvalue = readDatum(local_node->constbyval);
572 READ_ENUM_FIELD(paramkind, ParamKind);
573 READ_INT_FIELD(paramid);
574 READ_OID_FIELD(paramtype);
575 READ_INT_FIELD(paramtypmod);
576 READ_OID_FIELD(paramcollid);
577 READ_LOCATION_FIELD(location);
590 READ_OID_FIELD(aggfnoid);
591 READ_OID_FIELD(aggtype);
592 READ_OID_FIELD(aggcollid);
593 READ_OID_FIELD(inputcollid);
594 READ_OID_FIELD(aggtranstype);
595 READ_NODE_FIELD(aggargtypes);
596 READ_NODE_FIELD(aggdirectargs);
597 READ_NODE_FIELD(args);
598 READ_NODE_FIELD(aggorder);
599 READ_NODE_FIELD(aggdistinct);
600 READ_NODE_FIELD(aggfilter);
601 READ_BOOL_FIELD(aggstar);
602 READ_BOOL_FIELD(aggvariadic);
603 READ_CHAR_FIELD(aggkind);
604 READ_UINT_FIELD(agglevelsup);
605 READ_ENUM_FIELD(aggsplit, AggSplit);
606 READ_LOCATION_FIELD(location);
614 static GroupingFunc *
615 _readGroupingFunc(void)
617 READ_LOCALS(GroupingFunc);
619 READ_NODE_FIELD(args);
620 READ_NODE_FIELD(refs);
621 READ_NODE_FIELD(cols);
622 READ_UINT_FIELD(agglevelsup);
623 READ_LOCATION_FIELD(location);
632 _readWindowFunc(void)
634 READ_LOCALS(WindowFunc);
636 READ_OID_FIELD(winfnoid);
637 READ_OID_FIELD(wintype);
638 READ_OID_FIELD(wincollid);
639 READ_OID_FIELD(inputcollid);
640 READ_NODE_FIELD(args);
641 READ_NODE_FIELD(aggfilter);
642 READ_UINT_FIELD(winref);
643 READ_BOOL_FIELD(winstar);
644 READ_BOOL_FIELD(winagg);
645 READ_LOCATION_FIELD(location);
656 READ_LOCALS(ArrayRef);
658 READ_OID_FIELD(refarraytype);
659 READ_OID_FIELD(refelemtype);
660 READ_INT_FIELD(reftypmod);
661 READ_OID_FIELD(refcollid);
662 READ_NODE_FIELD(refupperindexpr);
663 READ_NODE_FIELD(reflowerindexpr);
664 READ_NODE_FIELD(refexpr);
665 READ_NODE_FIELD(refassgnexpr);
676 READ_LOCALS(FuncExpr);
678 READ_OID_FIELD(funcid);
679 READ_OID_FIELD(funcresulttype);
680 READ_BOOL_FIELD(funcretset);
681 READ_BOOL_FIELD(funcvariadic);
682 READ_ENUM_FIELD(funcformat, CoercionForm);
683 READ_OID_FIELD(funccollid);
684 READ_OID_FIELD(inputcollid);
685 READ_NODE_FIELD(args);
686 READ_LOCATION_FIELD(location);
694 static NamedArgExpr *
695 _readNamedArgExpr(void)
697 READ_LOCALS(NamedArgExpr);
699 READ_NODE_FIELD(arg);
700 READ_STRING_FIELD(name);
701 READ_INT_FIELD(argnumber);
702 READ_LOCATION_FIELD(location);
715 READ_OID_FIELD(opno);
716 READ_OID_FIELD(opfuncid);
717 READ_OID_FIELD(opresulttype);
718 READ_BOOL_FIELD(opretset);
719 READ_OID_FIELD(opcollid);
720 READ_OID_FIELD(inputcollid);
721 READ_NODE_FIELD(args);
722 READ_LOCATION_FIELD(location);
730 static DistinctExpr *
731 _readDistinctExpr(void)
733 READ_LOCALS(DistinctExpr);
735 READ_OID_FIELD(opno);
736 READ_OID_FIELD(opfuncid);
737 READ_OID_FIELD(opresulttype);
738 READ_BOOL_FIELD(opretset);
739 READ_OID_FIELD(opcollid);
740 READ_OID_FIELD(inputcollid);
741 READ_NODE_FIELD(args);
742 READ_LOCATION_FIELD(location);
751 _readNullIfExpr(void)
753 READ_LOCALS(NullIfExpr);
755 READ_OID_FIELD(opno);
756 READ_OID_FIELD(opfuncid);
757 READ_OID_FIELD(opresulttype);
758 READ_BOOL_FIELD(opretset);
759 READ_OID_FIELD(opcollid);
760 READ_OID_FIELD(inputcollid);
761 READ_NODE_FIELD(args);
762 READ_LOCATION_FIELD(location);
768 * _readScalarArrayOpExpr
770 static ScalarArrayOpExpr *
771 _readScalarArrayOpExpr(void)
773 READ_LOCALS(ScalarArrayOpExpr);
775 READ_OID_FIELD(opno);
776 READ_OID_FIELD(opfuncid);
777 READ_BOOL_FIELD(useOr);
778 READ_OID_FIELD(inputcollid);
779 READ_NODE_FIELD(args);
780 READ_LOCATION_FIELD(location);
791 READ_LOCALS(BoolExpr);
793 /* do-it-yourself enum representation */
794 token = pg_strtok(&length); /* skip :boolop */
795 token = pg_strtok(&length); /* get field value */
796 if (strncmp(token, "and", 3) == 0)
797 local_node->boolop = AND_EXPR;
798 else if (strncmp(token, "or", 2) == 0)
799 local_node->boolop = OR_EXPR;
800 else if (strncmp(token, "not", 3) == 0)
801 local_node->boolop = NOT_EXPR;
803 elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
805 READ_NODE_FIELD(args);
806 READ_LOCATION_FIELD(location);
817 READ_LOCALS(SubLink);
819 READ_ENUM_FIELD(subLinkType, SubLinkType);
820 READ_INT_FIELD(subLinkId);
821 READ_NODE_FIELD(testexpr);
822 READ_NODE_FIELD(operName);
823 READ_NODE_FIELD(subselect);
824 READ_LOCATION_FIELD(location);
830 * _readSubPlan is not needed since it doesn't appear in stored rules.
837 _readFieldSelect(void)
839 READ_LOCALS(FieldSelect);
841 READ_NODE_FIELD(arg);
842 READ_INT_FIELD(fieldnum);
843 READ_OID_FIELD(resulttype);
844 READ_INT_FIELD(resulttypmod);
845 READ_OID_FIELD(resultcollid);
854 _readFieldStore(void)
856 READ_LOCALS(FieldStore);
858 READ_NODE_FIELD(arg);
859 READ_NODE_FIELD(newvals);
860 READ_NODE_FIELD(fieldnums);
861 READ_OID_FIELD(resulttype);
870 _readRelabelType(void)
872 READ_LOCALS(RelabelType);
874 READ_NODE_FIELD(arg);
875 READ_OID_FIELD(resulttype);
876 READ_INT_FIELD(resulttypmod);
877 READ_OID_FIELD(resultcollid);
878 READ_ENUM_FIELD(relabelformat, CoercionForm);
879 READ_LOCATION_FIELD(location);
888 _readCoerceViaIO(void)
890 READ_LOCALS(CoerceViaIO);
892 READ_NODE_FIELD(arg);
893 READ_OID_FIELD(resulttype);
894 READ_OID_FIELD(resultcollid);
895 READ_ENUM_FIELD(coerceformat, CoercionForm);
896 READ_LOCATION_FIELD(location);
902 * _readArrayCoerceExpr
904 static ArrayCoerceExpr *
905 _readArrayCoerceExpr(void)
907 READ_LOCALS(ArrayCoerceExpr);
909 READ_NODE_FIELD(arg);
910 READ_NODE_FIELD(elemexpr);
911 READ_OID_FIELD(resulttype);
912 READ_INT_FIELD(resulttypmod);
913 READ_OID_FIELD(resultcollid);
914 READ_ENUM_FIELD(coerceformat, CoercionForm);
915 READ_LOCATION_FIELD(location);
921 * _readConvertRowtypeExpr
923 static ConvertRowtypeExpr *
924 _readConvertRowtypeExpr(void)
926 READ_LOCALS(ConvertRowtypeExpr);
928 READ_NODE_FIELD(arg);
929 READ_OID_FIELD(resulttype);
930 READ_ENUM_FIELD(convertformat, CoercionForm);
931 READ_LOCATION_FIELD(location);
940 _readCollateExpr(void)
942 READ_LOCALS(CollateExpr);
944 READ_NODE_FIELD(arg);
945 READ_OID_FIELD(collOid);
946 READ_LOCATION_FIELD(location);
957 READ_LOCALS(CaseExpr);
959 READ_OID_FIELD(casetype);
960 READ_OID_FIELD(casecollid);
961 READ_NODE_FIELD(arg);
962 READ_NODE_FIELD(args);
963 READ_NODE_FIELD(defresult);
964 READ_LOCATION_FIELD(location);
975 READ_LOCALS(CaseWhen);
977 READ_NODE_FIELD(expr);
978 READ_NODE_FIELD(result);
979 READ_LOCATION_FIELD(location);
987 static CaseTestExpr *
988 _readCaseTestExpr(void)
990 READ_LOCALS(CaseTestExpr);
992 READ_OID_FIELD(typeId);
993 READ_INT_FIELD(typeMod);
994 READ_OID_FIELD(collation);
1003 _readArrayExpr(void)
1005 READ_LOCALS(ArrayExpr);
1007 READ_OID_FIELD(array_typeid);
1008 READ_OID_FIELD(array_collid);
1009 READ_OID_FIELD(element_typeid);
1010 READ_NODE_FIELD(elements);
1011 READ_BOOL_FIELD(multidims);
1012 READ_LOCATION_FIELD(location);
1023 READ_LOCALS(RowExpr);
1025 READ_NODE_FIELD(args);
1026 READ_OID_FIELD(row_typeid);
1027 READ_ENUM_FIELD(row_format, CoercionForm);
1028 READ_NODE_FIELD(colnames);
1029 READ_LOCATION_FIELD(location);
1035 * _readRowCompareExpr
1037 static RowCompareExpr *
1038 _readRowCompareExpr(void)
1040 READ_LOCALS(RowCompareExpr);
1042 READ_ENUM_FIELD(rctype, RowCompareType);
1043 READ_NODE_FIELD(opnos);
1044 READ_NODE_FIELD(opfamilies);
1045 READ_NODE_FIELD(inputcollids);
1046 READ_NODE_FIELD(largs);
1047 READ_NODE_FIELD(rargs);
1055 static CoalesceExpr *
1056 _readCoalesceExpr(void)
1058 READ_LOCALS(CoalesceExpr);
1060 READ_OID_FIELD(coalescetype);
1061 READ_OID_FIELD(coalescecollid);
1062 READ_NODE_FIELD(args);
1063 READ_LOCATION_FIELD(location);
1072 _readMinMaxExpr(void)
1074 READ_LOCALS(MinMaxExpr);
1076 READ_OID_FIELD(minmaxtype);
1077 READ_OID_FIELD(minmaxcollid);
1078 READ_OID_FIELD(inputcollid);
1079 READ_ENUM_FIELD(op, MinMaxOp);
1080 READ_NODE_FIELD(args);
1081 READ_LOCATION_FIELD(location);
1087 * _readSQLValueFunction
1089 static SQLValueFunction *
1090 _readSQLValueFunction(void)
1092 READ_LOCALS(SQLValueFunction);
1094 READ_ENUM_FIELD(op, SQLValueFunctionOp);
1095 READ_OID_FIELD(type);
1096 READ_INT_FIELD(typmod);
1097 READ_LOCATION_FIELD(location);
1108 READ_LOCALS(XmlExpr);
1110 READ_ENUM_FIELD(op, XmlExprOp);
1111 READ_STRING_FIELD(name);
1112 READ_NODE_FIELD(named_args);
1113 READ_NODE_FIELD(arg_names);
1114 READ_NODE_FIELD(args);
1115 READ_ENUM_FIELD(xmloption, XmlOptionType);
1116 READ_OID_FIELD(type);
1117 READ_INT_FIELD(typmod);
1118 READ_LOCATION_FIELD(location);
1129 READ_LOCALS(NullTest);
1131 READ_NODE_FIELD(arg);
1132 READ_ENUM_FIELD(nulltesttype, NullTestType);
1133 READ_BOOL_FIELD(argisrow);
1134 READ_LOCATION_FIELD(location);
1142 static BooleanTest *
1143 _readBooleanTest(void)
1145 READ_LOCALS(BooleanTest);
1147 READ_NODE_FIELD(arg);
1148 READ_ENUM_FIELD(booltesttype, BoolTestType);
1149 READ_LOCATION_FIELD(location);
1155 * _readCoerceToDomain
1157 static CoerceToDomain *
1158 _readCoerceToDomain(void)
1160 READ_LOCALS(CoerceToDomain);
1162 READ_NODE_FIELD(arg);
1163 READ_OID_FIELD(resulttype);
1164 READ_INT_FIELD(resulttypmod);
1165 READ_OID_FIELD(resultcollid);
1166 READ_ENUM_FIELD(coercionformat, CoercionForm);
1167 READ_LOCATION_FIELD(location);
1173 * _readCoerceToDomainValue
1175 static CoerceToDomainValue *
1176 _readCoerceToDomainValue(void)
1178 READ_LOCALS(CoerceToDomainValue);
1180 READ_OID_FIELD(typeId);
1181 READ_INT_FIELD(typeMod);
1182 READ_OID_FIELD(collation);
1183 READ_LOCATION_FIELD(location);
1191 static SetToDefault *
1192 _readSetToDefault(void)
1194 READ_LOCALS(SetToDefault);
1196 READ_OID_FIELD(typeId);
1197 READ_INT_FIELD(typeMod);
1198 READ_OID_FIELD(collation);
1199 READ_LOCATION_FIELD(location);
1205 * _readCurrentOfExpr
1207 static CurrentOfExpr *
1208 _readCurrentOfExpr(void)
1210 READ_LOCALS(CurrentOfExpr);
1212 READ_UINT_FIELD(cvarno);
1213 READ_STRING_FIELD(cursor_name);
1214 READ_INT_FIELD(cursor_param);
1220 * _readNextValueExpr
1222 static NextValueExpr *
1223 _readNextValueExpr(void)
1225 READ_LOCALS(NextValueExpr);
1227 READ_OID_FIELD(seqid);
1228 READ_OID_FIELD(typeId);
1234 * _readInferenceElem
1236 static InferenceElem *
1237 _readInferenceElem(void)
1239 READ_LOCALS(InferenceElem);
1241 READ_NODE_FIELD(expr);
1242 READ_OID_FIELD(infercollid);
1243 READ_OID_FIELD(inferopclass);
1251 static TargetEntry *
1252 _readTargetEntry(void)
1254 READ_LOCALS(TargetEntry);
1256 READ_NODE_FIELD(expr);
1257 READ_INT_FIELD(resno);
1258 READ_STRING_FIELD(resname);
1259 READ_UINT_FIELD(ressortgroupref);
1260 READ_OID_FIELD(resorigtbl);
1261 READ_INT_FIELD(resorigcol);
1262 READ_BOOL_FIELD(resjunk);
1270 static RangeTblRef *
1271 _readRangeTblRef(void)
1273 READ_LOCALS(RangeTblRef);
1275 READ_INT_FIELD(rtindex);
1286 READ_LOCALS(JoinExpr);
1288 READ_ENUM_FIELD(jointype, JoinType);
1289 READ_BOOL_FIELD(isNatural);
1290 READ_NODE_FIELD(larg);
1291 READ_NODE_FIELD(rarg);
1292 READ_NODE_FIELD(usingClause);
1293 READ_NODE_FIELD(quals);
1294 READ_NODE_FIELD(alias);
1295 READ_INT_FIELD(rtindex);
1306 READ_LOCALS(FromExpr);
1308 READ_NODE_FIELD(fromlist);
1309 READ_NODE_FIELD(quals);
1315 * _readOnConflictExpr
1317 static OnConflictExpr *
1318 _readOnConflictExpr(void)
1320 READ_LOCALS(OnConflictExpr);
1322 READ_ENUM_FIELD(action, OnConflictAction);
1323 READ_NODE_FIELD(arbiterElems);
1324 READ_NODE_FIELD(arbiterWhere);
1325 READ_OID_FIELD(constraint);
1326 READ_NODE_FIELD(onConflictSet);
1327 READ_NODE_FIELD(onConflictWhere);
1328 READ_INT_FIELD(exclRelIndex);
1329 READ_NODE_FIELD(exclRelTlist);
1335 * Stuff from parsenodes.h.
1339 * _readRangeTblEntry
1341 static RangeTblEntry *
1342 _readRangeTblEntry(void)
1344 READ_LOCALS(RangeTblEntry);
1346 /* put alias + eref first to make dump more legible */
1347 READ_NODE_FIELD(alias);
1348 READ_NODE_FIELD(eref);
1349 READ_ENUM_FIELD(rtekind, RTEKind);
1351 switch (local_node->rtekind)
1354 READ_OID_FIELD(relid);
1355 READ_CHAR_FIELD(relkind);
1356 READ_NODE_FIELD(tablesample);
1359 READ_NODE_FIELD(subquery);
1360 READ_BOOL_FIELD(security_barrier);
1363 READ_ENUM_FIELD(jointype, JoinType);
1364 READ_NODE_FIELD(joinaliasvars);
1367 READ_NODE_FIELD(functions);
1368 READ_BOOL_FIELD(funcordinality);
1371 READ_NODE_FIELD(tablefunc);
1374 READ_NODE_FIELD(values_lists);
1375 READ_NODE_FIELD(coltypes);
1376 READ_NODE_FIELD(coltypmods);
1377 READ_NODE_FIELD(colcollations);
1380 READ_STRING_FIELD(ctename);
1381 READ_UINT_FIELD(ctelevelsup);
1382 READ_BOOL_FIELD(self_reference);
1383 READ_NODE_FIELD(coltypes);
1384 READ_NODE_FIELD(coltypmods);
1385 READ_NODE_FIELD(colcollations);
1387 case RTE_NAMEDTUPLESTORE:
1388 READ_STRING_FIELD(enrname);
1389 READ_FLOAT_FIELD(enrtuples);
1390 READ_OID_FIELD(relid);
1391 READ_NODE_FIELD(coltypes);
1392 READ_NODE_FIELD(coltypmods);
1393 READ_NODE_FIELD(colcollations);
1396 elog(ERROR, "unrecognized RTE kind: %d",
1397 (int) local_node->rtekind);
1401 READ_BOOL_FIELD(lateral);
1402 READ_BOOL_FIELD(inh);
1403 READ_BOOL_FIELD(inFromCl);
1404 READ_UINT_FIELD(requiredPerms);
1405 READ_OID_FIELD(checkAsUser);
1406 READ_BITMAPSET_FIELD(selectedCols);
1407 READ_BITMAPSET_FIELD(insertedCols);
1408 READ_BITMAPSET_FIELD(updatedCols);
1409 READ_NODE_FIELD(securityQuals);
1415 * _readRangeTblFunction
1417 static RangeTblFunction *
1418 _readRangeTblFunction(void)
1420 READ_LOCALS(RangeTblFunction);
1422 READ_NODE_FIELD(funcexpr);
1423 READ_INT_FIELD(funccolcount);
1424 READ_NODE_FIELD(funccolnames);
1425 READ_NODE_FIELD(funccoltypes);
1426 READ_NODE_FIELD(funccoltypmods);
1427 READ_NODE_FIELD(funccolcollations);
1428 READ_BITMAPSET_FIELD(funcparams);
1434 * _readTableSampleClause
1436 static TableSampleClause *
1437 _readTableSampleClause(void)
1439 READ_LOCALS(TableSampleClause);
1441 READ_OID_FIELD(tsmhandler);
1442 READ_NODE_FIELD(args);
1443 READ_NODE_FIELD(repeatable);
1454 READ_LOCALS(DefElem);
1456 READ_STRING_FIELD(defnamespace);
1457 READ_STRING_FIELD(defname);
1458 READ_NODE_FIELD(arg);
1459 READ_ENUM_FIELD(defaction, DefElemAction);
1460 READ_LOCATION_FIELD(location);
1468 static PlannedStmt *
1469 _readPlannedStmt(void)
1471 READ_LOCALS(PlannedStmt);
1473 READ_ENUM_FIELD(commandType, CmdType);
1474 READ_UINT64_FIELD(queryId);
1475 READ_BOOL_FIELD(hasReturning);
1476 READ_BOOL_FIELD(hasModifyingCTE);
1477 READ_BOOL_FIELD(canSetTag);
1478 READ_BOOL_FIELD(transientPlan);
1479 READ_BOOL_FIELD(dependsOnRole);
1480 READ_BOOL_FIELD(parallelModeNeeded);
1481 READ_BOOL_FIELD(jitFlags);
1482 READ_NODE_FIELD(planTree);
1483 READ_NODE_FIELD(rtable);
1484 READ_NODE_FIELD(resultRelations);
1485 READ_NODE_FIELD(nonleafResultRelations);
1486 READ_NODE_FIELD(rootResultRelations);
1487 READ_NODE_FIELD(subplans);
1488 READ_BITMAPSET_FIELD(rewindPlanIDs);
1489 READ_NODE_FIELD(rowMarks);
1490 READ_NODE_FIELD(relationOids);
1491 READ_NODE_FIELD(invalItems);
1492 READ_NODE_FIELD(paramExecTypes);
1493 READ_NODE_FIELD(utilityStmt);
1494 READ_LOCATION_FIELD(stmt_location);
1495 READ_LOCATION_FIELD(stmt_len);
1502 * Assign the basic stuff of all nodes that inherit from Plan
1505 ReadCommonPlan(Plan *local_node)
1509 READ_FLOAT_FIELD(startup_cost);
1510 READ_FLOAT_FIELD(total_cost);
1511 READ_FLOAT_FIELD(plan_rows);
1512 READ_INT_FIELD(plan_width);
1513 READ_BOOL_FIELD(parallel_aware);
1514 READ_BOOL_FIELD(parallel_safe);
1515 READ_INT_FIELD(plan_node_id);
1516 READ_NODE_FIELD(targetlist);
1517 READ_NODE_FIELD(qual);
1518 READ_NODE_FIELD(lefttree);
1519 READ_NODE_FIELD(righttree);
1520 READ_NODE_FIELD(initPlan);
1521 READ_BITMAPSET_FIELD(extParam);
1522 READ_BITMAPSET_FIELD(allParam);
1531 READ_LOCALS_NO_FIELDS(Plan);
1533 ReadCommonPlan(local_node);
1544 READ_LOCALS(Result);
1546 ReadCommonPlan(&local_node->plan);
1548 READ_NODE_FIELD(resconstantqual);
1557 _readProjectSet(void)
1559 READ_LOCALS_NO_FIELDS(ProjectSet);
1561 ReadCommonPlan(&local_node->plan);
1569 static ModifyTable *
1570 _readModifyTable(void)
1572 READ_LOCALS(ModifyTable);
1574 ReadCommonPlan(&local_node->plan);
1576 READ_ENUM_FIELD(operation, CmdType);
1577 READ_BOOL_FIELD(canSetTag);
1578 READ_UINT_FIELD(nominalRelation);
1579 READ_NODE_FIELD(partitioned_rels);
1580 READ_BOOL_FIELD(partColsUpdated);
1581 READ_NODE_FIELD(resultRelations);
1582 READ_INT_FIELD(mergeTargetRelation);
1583 READ_INT_FIELD(resultRelIndex);
1584 READ_INT_FIELD(rootResultRelIndex);
1585 READ_NODE_FIELD(plans);
1586 READ_NODE_FIELD(withCheckOptionLists);
1587 READ_NODE_FIELD(returningLists);
1588 READ_NODE_FIELD(fdwPrivLists);
1589 READ_BITMAPSET_FIELD(fdwDirectModifyPlans);
1590 READ_NODE_FIELD(rowMarks);
1591 READ_INT_FIELD(epqParam);
1592 READ_ENUM_FIELD(onConflictAction, OnConflictAction);
1593 READ_NODE_FIELD(arbiterIndexes);
1594 READ_NODE_FIELD(onConflictSet);
1595 READ_NODE_FIELD(onConflictWhere);
1596 READ_UINT_FIELD(exclRelRTI);
1597 READ_NODE_FIELD(exclRelTlist);
1598 READ_NODE_FIELD(mergeSourceTargetList);
1599 READ_NODE_FIELD(mergeActionList);
1607 static MergeAction *
1608 _readMergeAction(void)
1610 READ_LOCALS(MergeAction);
1612 READ_BOOL_FIELD(matched);
1613 READ_ENUM_FIELD(commandType, CmdType);
1614 READ_NODE_FIELD(condition);
1615 READ_NODE_FIELD(qual);
1616 READ_NODE_FIELD(stmt);
1617 READ_NODE_FIELD(targetList);
1628 READ_LOCALS(Append);
1630 ReadCommonPlan(&local_node->plan);
1632 READ_NODE_FIELD(partitioned_rels);
1633 READ_NODE_FIELD(appendplans);
1634 READ_INT_FIELD(first_partial_plan);
1642 static MergeAppend *
1643 _readMergeAppend(void)
1645 READ_LOCALS(MergeAppend);
1647 ReadCommonPlan(&local_node->plan);
1649 READ_NODE_FIELD(partitioned_rels);
1650 READ_NODE_FIELD(mergeplans);
1651 READ_INT_FIELD(numCols);
1652 READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
1653 READ_OID_ARRAY(sortOperators, local_node->numCols);
1654 READ_OID_ARRAY(collations, local_node->numCols);
1655 READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
1661 * _readRecursiveUnion
1663 static RecursiveUnion *
1664 _readRecursiveUnion(void)
1666 READ_LOCALS(RecursiveUnion);
1668 ReadCommonPlan(&local_node->plan);
1670 READ_INT_FIELD(wtParam);
1671 READ_INT_FIELD(numCols);
1672 READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
1673 READ_OID_ARRAY(dupOperators, local_node->numCols);
1674 READ_LONG_FIELD(numGroups);
1683 _readBitmapAnd(void)
1685 READ_LOCALS(BitmapAnd);
1687 ReadCommonPlan(&local_node->plan);
1689 READ_NODE_FIELD(bitmapplans);
1700 READ_LOCALS(BitmapOr);
1702 ReadCommonPlan(&local_node->plan);
1704 READ_BOOL_FIELD(isshared);
1705 READ_NODE_FIELD(bitmapplans);
1712 * Assign the basic stuff of all nodes that inherit from Scan
1715 ReadCommonScan(Scan *local_node)
1719 ReadCommonPlan(&local_node->plan);
1721 READ_UINT_FIELD(scanrelid);
1730 READ_LOCALS_NO_FIELDS(Scan);
1732 ReadCommonScan(local_node);
1743 READ_LOCALS_NO_FIELDS(SeqScan);
1745 ReadCommonScan(local_node);
1754 _readSampleScan(void)
1756 READ_LOCALS(SampleScan);
1758 ReadCommonScan(&local_node->scan);
1760 READ_NODE_FIELD(tablesample);
1769 _readIndexScan(void)
1771 READ_LOCALS(IndexScan);
1773 ReadCommonScan(&local_node->scan);
1775 READ_OID_FIELD(indexid);
1776 READ_NODE_FIELD(indexqual);
1777 READ_NODE_FIELD(indexqualorig);
1778 READ_NODE_FIELD(indexorderby);
1779 READ_NODE_FIELD(indexorderbyorig);
1780 READ_NODE_FIELD(indexorderbyops);
1781 READ_ENUM_FIELD(indexorderdir, ScanDirection);
1787 * _readIndexOnlyScan
1789 static IndexOnlyScan *
1790 _readIndexOnlyScan(void)
1792 READ_LOCALS(IndexOnlyScan);
1794 ReadCommonScan(&local_node->scan);
1796 READ_OID_FIELD(indexid);
1797 READ_NODE_FIELD(indexqual);
1798 READ_NODE_FIELD(indexorderby);
1799 READ_NODE_FIELD(indextlist);
1800 READ_ENUM_FIELD(indexorderdir, ScanDirection);
1806 * _readBitmapIndexScan
1808 static BitmapIndexScan *
1809 _readBitmapIndexScan(void)
1811 READ_LOCALS(BitmapIndexScan);
1813 ReadCommonScan(&local_node->scan);
1815 READ_OID_FIELD(indexid);
1816 READ_BOOL_FIELD(isshared);
1817 READ_NODE_FIELD(indexqual);
1818 READ_NODE_FIELD(indexqualorig);
1824 * _readBitmapHeapScan
1826 static BitmapHeapScan *
1827 _readBitmapHeapScan(void)
1829 READ_LOCALS(BitmapHeapScan);
1831 ReadCommonScan(&local_node->scan);
1833 READ_NODE_FIELD(bitmapqualorig);
1844 READ_LOCALS(TidScan);
1846 ReadCommonScan(&local_node->scan);
1848 READ_NODE_FIELD(tidquals);
1856 static SubqueryScan *
1857 _readSubqueryScan(void)
1859 READ_LOCALS(SubqueryScan);
1861 ReadCommonScan(&local_node->scan);
1863 READ_NODE_FIELD(subplan);
1871 static FunctionScan *
1872 _readFunctionScan(void)
1874 READ_LOCALS(FunctionScan);
1876 ReadCommonScan(&local_node->scan);
1878 READ_NODE_FIELD(functions);
1879 READ_BOOL_FIELD(funcordinality);
1888 _readValuesScan(void)
1890 READ_LOCALS(ValuesScan);
1892 ReadCommonScan(&local_node->scan);
1894 READ_NODE_FIELD(values_lists);
1900 * _readTableFuncScan
1902 static TableFuncScan *
1903 _readTableFuncScan(void)
1905 READ_LOCALS(TableFuncScan);
1907 ReadCommonScan(&local_node->scan);
1909 READ_NODE_FIELD(tablefunc);
1920 READ_LOCALS(CteScan);
1922 ReadCommonScan(&local_node->scan);
1924 READ_INT_FIELD(ctePlanId);
1925 READ_INT_FIELD(cteParam);
1931 * _readWorkTableScan
1933 static WorkTableScan *
1934 _readWorkTableScan(void)
1936 READ_LOCALS(WorkTableScan);
1938 ReadCommonScan(&local_node->scan);
1940 READ_INT_FIELD(wtParam);
1948 static ForeignScan *
1949 _readForeignScan(void)
1951 READ_LOCALS(ForeignScan);
1953 ReadCommonScan(&local_node->scan);
1955 READ_ENUM_FIELD(operation, CmdType);
1956 READ_OID_FIELD(fs_server);
1957 READ_NODE_FIELD(fdw_exprs);
1958 READ_NODE_FIELD(fdw_private);
1959 READ_NODE_FIELD(fdw_scan_tlist);
1960 READ_NODE_FIELD(fdw_recheck_quals);
1961 READ_BITMAPSET_FIELD(fs_relids);
1962 READ_BOOL_FIELD(fsSystemCol);
1971 _readCustomScan(void)
1973 READ_LOCALS(CustomScan);
1975 const CustomScanMethods *methods;
1977 ReadCommonScan(&local_node->scan);
1979 READ_UINT_FIELD(flags);
1980 READ_NODE_FIELD(custom_plans);
1981 READ_NODE_FIELD(custom_exprs);
1982 READ_NODE_FIELD(custom_private);
1983 READ_NODE_FIELD(custom_scan_tlist);
1984 READ_BITMAPSET_FIELD(custom_relids);
1986 /* Lookup CustomScanMethods by CustomName */
1987 token = pg_strtok(&length); /* skip methods: */
1988 token = pg_strtok(&length); /* CustomName */
1989 custom_name = nullable_string(token, length);
1990 methods = GetCustomScanMethods(custom_name, false);
1991 local_node->methods = methods;
1998 * Assign the basic stuff of all nodes that inherit from Join
2001 ReadCommonJoin(Join *local_node)
2005 ReadCommonPlan(&local_node->plan);
2007 READ_ENUM_FIELD(jointype, JoinType);
2008 READ_BOOL_FIELD(inner_unique);
2009 READ_NODE_FIELD(joinqual);
2018 READ_LOCALS_NO_FIELDS(Join);
2020 ReadCommonJoin(local_node);
2031 READ_LOCALS(NestLoop);
2033 ReadCommonJoin(&local_node->join);
2035 READ_NODE_FIELD(nestParams);
2044 _readMergeJoin(void)
2048 READ_LOCALS(MergeJoin);
2050 ReadCommonJoin(&local_node->join);
2052 READ_BOOL_FIELD(skip_mark_restore);
2053 READ_NODE_FIELD(mergeclauses);
2055 numCols = list_length(local_node->mergeclauses);
2057 READ_OID_ARRAY(mergeFamilies, numCols);
2058 READ_OID_ARRAY(mergeCollations, numCols);
2059 READ_INT_ARRAY(mergeStrategies, numCols);
2060 READ_BOOL_ARRAY(mergeNullsFirst, numCols);
2071 READ_LOCALS(HashJoin);
2073 ReadCommonJoin(&local_node->join);
2075 READ_NODE_FIELD(hashclauses);
2086 READ_LOCALS_NO_FIELDS(Material);
2088 ReadCommonPlan(&local_node->plan);
2101 ReadCommonPlan(&local_node->plan);
2103 READ_INT_FIELD(numCols);
2104 READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
2105 READ_OID_ARRAY(sortOperators, local_node->numCols);
2106 READ_OID_ARRAY(collations, local_node->numCols);
2107 READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
2120 ReadCommonPlan(&local_node->plan);
2122 READ_INT_FIELD(numCols);
2123 READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
2124 READ_OID_ARRAY(grpOperators, local_node->numCols);
2137 ReadCommonPlan(&local_node->plan);
2139 READ_ENUM_FIELD(aggstrategy, AggStrategy);
2140 READ_ENUM_FIELD(aggsplit, AggSplit);
2141 READ_INT_FIELD(numCols);
2142 READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols);
2143 READ_OID_ARRAY(grpOperators, local_node->numCols);
2144 READ_LONG_FIELD(numGroups);
2145 READ_BITMAPSET_FIELD(aggParams);
2146 READ_NODE_FIELD(groupingSets);
2147 READ_NODE_FIELD(chain);
2156 _readWindowAgg(void)
2158 READ_LOCALS(WindowAgg);
2160 ReadCommonPlan(&local_node->plan);
2162 READ_UINT_FIELD(winref);
2163 READ_INT_FIELD(partNumCols);
2164 READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols);
2165 READ_OID_ARRAY(partOperators, local_node->partNumCols);
2166 READ_INT_FIELD(ordNumCols);
2167 READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols);
2168 READ_OID_ARRAY(ordOperators, local_node->ordNumCols);
2169 READ_INT_FIELD(frameOptions);
2170 READ_NODE_FIELD(startOffset);
2171 READ_NODE_FIELD(endOffset);
2172 READ_OID_FIELD(startInRangeFunc);
2173 READ_OID_FIELD(endInRangeFunc);
2174 READ_OID_FIELD(inRangeColl);
2175 READ_BOOL_FIELD(inRangeAsc);
2176 READ_BOOL_FIELD(inRangeNullsFirst);
2187 READ_LOCALS(Unique);
2189 ReadCommonPlan(&local_node->plan);
2191 READ_INT_FIELD(numCols);
2192 READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols);
2193 READ_OID_ARRAY(uniqOperators, local_node->numCols);
2204 READ_LOCALS(Gather);
2206 ReadCommonPlan(&local_node->plan);
2208 READ_INT_FIELD(num_workers);
2209 READ_INT_FIELD(rescan_param);
2210 READ_BOOL_FIELD(single_copy);
2211 READ_BOOL_FIELD(invisible);
2212 READ_BITMAPSET_FIELD(initParam);
2220 static GatherMerge *
2221 _readGatherMerge(void)
2223 READ_LOCALS(GatherMerge);
2225 ReadCommonPlan(&local_node->plan);
2227 READ_INT_FIELD(num_workers);
2228 READ_INT_FIELD(rescan_param);
2229 READ_INT_FIELD(numCols);
2230 READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols);
2231 READ_OID_ARRAY(sortOperators, local_node->numCols);
2232 READ_OID_ARRAY(collations, local_node->numCols);
2233 READ_BOOL_ARRAY(nullsFirst, local_node->numCols);
2234 READ_BITMAPSET_FIELD(initParam);
2247 ReadCommonPlan(&local_node->plan);
2249 READ_OID_FIELD(skewTable);
2250 READ_INT_FIELD(skewColumn);
2251 READ_BOOL_FIELD(skewInherit);
2252 READ_FLOAT_FIELD(rows_total);
2265 ReadCommonPlan(&local_node->plan);
2267 READ_ENUM_FIELD(cmd, SetOpCmd);
2268 READ_ENUM_FIELD(strategy, SetOpStrategy);
2269 READ_INT_FIELD(numCols);
2270 READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols);
2271 READ_OID_ARRAY(dupOperators, local_node->numCols);
2272 READ_INT_FIELD(flagColIdx);
2273 READ_INT_FIELD(firstFlag);
2274 READ_LONG_FIELD(numGroups);
2285 READ_LOCALS(LockRows);
2287 ReadCommonPlan(&local_node->plan);
2289 READ_NODE_FIELD(rowMarks);
2290 READ_INT_FIELD(epqParam);
2303 ReadCommonPlan(&local_node->plan);
2305 READ_NODE_FIELD(limitOffset);
2306 READ_NODE_FIELD(limitCount);
2312 * _readNestLoopParam
2314 static NestLoopParam *
2315 _readNestLoopParam(void)
2317 READ_LOCALS(NestLoopParam);
2319 READ_INT_FIELD(paramno);
2320 READ_NODE_FIELD(paramval);
2328 static PlanRowMark *
2329 _readPlanRowMark(void)
2331 READ_LOCALS(PlanRowMark);
2333 READ_UINT_FIELD(rti);
2334 READ_UINT_FIELD(prti);
2335 READ_UINT_FIELD(rowmarkId);
2336 READ_ENUM_FIELD(markType, RowMarkType);
2337 READ_INT_FIELD(allMarkTypes);
2338 READ_ENUM_FIELD(strength, LockClauseStrength);
2339 READ_ENUM_FIELD(waitPolicy, LockWaitPolicy);
2340 READ_BOOL_FIELD(isParent);
2346 * _readPlanInvalItem
2348 static PlanInvalItem *
2349 _readPlanInvalItem(void)
2351 READ_LOCALS(PlanInvalItem);
2353 READ_INT_FIELD(cacheId);
2354 READ_UINT_FIELD(hashValue);
2365 READ_LOCALS(SubPlan);
2367 READ_ENUM_FIELD(subLinkType, SubLinkType);
2368 READ_NODE_FIELD(testexpr);
2369 READ_NODE_FIELD(paramIds);
2370 READ_INT_FIELD(plan_id);
2371 READ_STRING_FIELD(plan_name);
2372 READ_OID_FIELD(firstColType);
2373 READ_INT_FIELD(firstColTypmod);
2374 READ_OID_FIELD(firstColCollation);
2375 READ_BOOL_FIELD(useHashTable);
2376 READ_BOOL_FIELD(unknownEqFalse);
2377 READ_BOOL_FIELD(parallel_safe);
2378 READ_NODE_FIELD(setParam);
2379 READ_NODE_FIELD(parParam);
2380 READ_NODE_FIELD(args);
2381 READ_FLOAT_FIELD(startup_cost);
2382 READ_FLOAT_FIELD(per_call_cost);
2388 * _readAlternativeSubPlan
2390 static AlternativeSubPlan *
2391 _readAlternativeSubPlan(void)
2393 READ_LOCALS(AlternativeSubPlan);
2395 READ_NODE_FIELD(subplans);
2401 * _readExtensibleNode
2403 static ExtensibleNode *
2404 _readExtensibleNode(void)
2406 const ExtensibleNodeMethods *methods;
2407 ExtensibleNode *local_node;
2408 const char *extnodename;
2412 token = pg_strtok(&length); /* skip :extnodename */
2413 token = pg_strtok(&length); /* get extnodename */
2415 extnodename = nullable_string(token, length);
2417 elog(ERROR, "extnodename has to be supplied");
2418 methods = GetExtensibleNodeMethods(extnodename, false);
2420 local_node = (ExtensibleNode *) newNode(methods->node_size,
2422 local_node->extnodename = extnodename;
2424 /* deserialize the private fields */
2425 methods->nodeRead(local_node);
2431 * _readPartitionBoundSpec
2433 static PartitionBoundSpec *
2434 _readPartitionBoundSpec(void)
2436 READ_LOCALS(PartitionBoundSpec);
2438 READ_CHAR_FIELD(strategy);
2439 READ_BOOL_FIELD(is_default);
2440 READ_INT_FIELD(modulus);
2441 READ_INT_FIELD(remainder);
2442 READ_NODE_FIELD(listdatums);
2443 READ_NODE_FIELD(lowerdatums);
2444 READ_NODE_FIELD(upperdatums);
2445 READ_LOCATION_FIELD(location);
2451 * _readPartitionRangeDatum
2453 static PartitionRangeDatum *
2454 _readPartitionRangeDatum(void)
2456 READ_LOCALS(PartitionRangeDatum);
2458 READ_ENUM_FIELD(kind, PartitionRangeDatumKind);
2459 READ_NODE_FIELD(value);
2460 READ_LOCATION_FIELD(location);
2468 * Given a character string representing a node tree, parseNodeString creates
2469 * the internal node structure.
2471 * The string to be read must already have been loaded into pg_strtok().
2474 parseNodeString(void)
2480 token = pg_strtok(&length);
2482 #define MATCH(tokname, namelen) \
2483 (length == namelen && memcmp(token, tokname, namelen) == 0)
2485 if (MATCH("QUERY", 5))
2486 return_value = _readQuery();
2487 else if (MATCH("WITHCHECKOPTION", 15))
2488 return_value = _readWithCheckOption();
2489 else if (MATCH("SORTGROUPCLAUSE", 15))
2490 return_value = _readSortGroupClause();
2491 else if (MATCH("GROUPINGSET", 11))
2492 return_value = _readGroupingSet();
2493 else if (MATCH("WINDOWCLAUSE", 12))
2494 return_value = _readWindowClause();
2495 else if (MATCH("ROWMARKCLAUSE", 13))
2496 return_value = _readRowMarkClause();
2497 else if (MATCH("COMMONTABLEEXPR", 15))
2498 return_value = _readCommonTableExpr();
2499 else if (MATCH("SETOPERATIONSTMT", 16))
2500 return_value = _readSetOperationStmt();
2501 else if (MATCH("ALIAS", 5))
2502 return_value = _readAlias();
2503 else if (MATCH("RANGEVAR", 8))
2504 return_value = _readRangeVar();
2505 else if (MATCH("INTOCLAUSE", 10))
2506 return_value = _readIntoClause();
2507 else if (MATCH("TABLEFUNC", 9))
2508 return_value = _readTableFunc();
2509 else if (MATCH("VAR", 3))
2510 return_value = _readVar();
2511 else if (MATCH("CONST", 5))
2512 return_value = _readConst();
2513 else if (MATCH("PARAM", 5))
2514 return_value = _readParam();
2515 else if (MATCH("AGGREF", 6))
2516 return_value = _readAggref();
2517 else if (MATCH("GROUPINGFUNC", 12))
2518 return_value = _readGroupingFunc();
2519 else if (MATCH("WINDOWFUNC", 10))
2520 return_value = _readWindowFunc();
2521 else if (MATCH("ARRAYREF", 8))
2522 return_value = _readArrayRef();
2523 else if (MATCH("FUNCEXPR", 8))
2524 return_value = _readFuncExpr();
2525 else if (MATCH("NAMEDARGEXPR", 12))
2526 return_value = _readNamedArgExpr();
2527 else if (MATCH("OPEXPR", 6))
2528 return_value = _readOpExpr();
2529 else if (MATCH("DISTINCTEXPR", 12))
2530 return_value = _readDistinctExpr();
2531 else if (MATCH("NULLIFEXPR", 10))
2532 return_value = _readNullIfExpr();
2533 else if (MATCH("SCALARARRAYOPEXPR", 17))
2534 return_value = _readScalarArrayOpExpr();
2535 else if (MATCH("BOOLEXPR", 8))
2536 return_value = _readBoolExpr();
2537 else if (MATCH("SUBLINK", 7))
2538 return_value = _readSubLink();
2539 else if (MATCH("FIELDSELECT", 11))
2540 return_value = _readFieldSelect();
2541 else if (MATCH("FIELDSTORE", 10))
2542 return_value = _readFieldStore();
2543 else if (MATCH("RELABELTYPE", 11))
2544 return_value = _readRelabelType();
2545 else if (MATCH("COERCEVIAIO", 11))
2546 return_value = _readCoerceViaIO();
2547 else if (MATCH("ARRAYCOERCEEXPR", 15))
2548 return_value = _readArrayCoerceExpr();
2549 else if (MATCH("CONVERTROWTYPEEXPR", 18))
2550 return_value = _readConvertRowtypeExpr();
2551 else if (MATCH("COLLATE", 7))
2552 return_value = _readCollateExpr();
2553 else if (MATCH("CASE", 4))
2554 return_value = _readCaseExpr();
2555 else if (MATCH("WHEN", 4))
2556 return_value = _readCaseWhen();
2557 else if (MATCH("CASETESTEXPR", 12))
2558 return_value = _readCaseTestExpr();
2559 else if (MATCH("ARRAY", 5))
2560 return_value = _readArrayExpr();
2561 else if (MATCH("ROW", 3))
2562 return_value = _readRowExpr();
2563 else if (MATCH("ROWCOMPARE", 10))
2564 return_value = _readRowCompareExpr();
2565 else if (MATCH("COALESCE", 8))
2566 return_value = _readCoalesceExpr();
2567 else if (MATCH("MINMAX", 6))
2568 return_value = _readMinMaxExpr();
2569 else if (MATCH("SQLVALUEFUNCTION", 16))
2570 return_value = _readSQLValueFunction();
2571 else if (MATCH("XMLEXPR", 7))
2572 return_value = _readXmlExpr();
2573 else if (MATCH("NULLTEST", 8))
2574 return_value = _readNullTest();
2575 else if (MATCH("BOOLEANTEST", 11))
2576 return_value = _readBooleanTest();
2577 else if (MATCH("COERCETODOMAIN", 14))
2578 return_value = _readCoerceToDomain();
2579 else if (MATCH("COERCETODOMAINVALUE", 19))
2580 return_value = _readCoerceToDomainValue();
2581 else if (MATCH("SETTODEFAULT", 12))
2582 return_value = _readSetToDefault();
2583 else if (MATCH("CURRENTOFEXPR", 13))
2584 return_value = _readCurrentOfExpr();
2585 else if (MATCH("NEXTVALUEEXPR", 13))
2586 return_value = _readNextValueExpr();
2587 else if (MATCH("INFERENCEELEM", 13))
2588 return_value = _readInferenceElem();
2589 else if (MATCH("TARGETENTRY", 11))
2590 return_value = _readTargetEntry();
2591 else if (MATCH("RANGETBLREF", 11))
2592 return_value = _readRangeTblRef();
2593 else if (MATCH("JOINEXPR", 8))
2594 return_value = _readJoinExpr();
2595 else if (MATCH("FROMEXPR", 8))
2596 return_value = _readFromExpr();
2597 else if (MATCH("ONCONFLICTEXPR", 14))
2598 return_value = _readOnConflictExpr();
2599 else if (MATCH("RTE", 3))
2600 return_value = _readRangeTblEntry();
2601 else if (MATCH("RANGETBLFUNCTION", 16))
2602 return_value = _readRangeTblFunction();
2603 else if (MATCH("TABLESAMPLECLAUSE", 17))
2604 return_value = _readTableSampleClause();
2605 else if (MATCH("NOTIFY", 6))
2606 return_value = _readNotifyStmt();
2607 else if (MATCH("DEFELEM", 7))
2608 return_value = _readDefElem();
2609 else if (MATCH("DECLARECURSOR", 13))
2610 return_value = _readDeclareCursorStmt();
2611 else if (MATCH("PLANNEDSTMT", 11))
2612 return_value = _readPlannedStmt();
2613 else if (MATCH("PLAN", 4))
2614 return_value = _readPlan();
2615 else if (MATCH("RESULT", 6))
2616 return_value = _readResult();
2617 else if (MATCH("PROJECTSET", 10))
2618 return_value = _readProjectSet();
2619 else if (MATCH("MODIFYTABLE", 11))
2620 return_value = _readModifyTable();
2621 else if (MATCH("MERGEACTION", 11))
2622 return_value = _readMergeAction();
2623 else if (MATCH("APPEND", 6))
2624 return_value = _readAppend();
2625 else if (MATCH("MERGEAPPEND", 11))
2626 return_value = _readMergeAppend();
2627 else if (MATCH("RECURSIVEUNION", 14))
2628 return_value = _readRecursiveUnion();
2629 else if (MATCH("BITMAPAND", 9))
2630 return_value = _readBitmapAnd();
2631 else if (MATCH("BITMAPOR", 8))
2632 return_value = _readBitmapOr();
2633 else if (MATCH("SCAN", 4))
2634 return_value = _readScan();
2635 else if (MATCH("SEQSCAN", 7))
2636 return_value = _readSeqScan();
2637 else if (MATCH("SAMPLESCAN", 10))
2638 return_value = _readSampleScan();
2639 else if (MATCH("INDEXSCAN", 9))
2640 return_value = _readIndexScan();
2641 else if (MATCH("INDEXONLYSCAN", 13))
2642 return_value = _readIndexOnlyScan();
2643 else if (MATCH("BITMAPINDEXSCAN", 15))
2644 return_value = _readBitmapIndexScan();
2645 else if (MATCH("BITMAPHEAPSCAN", 14))
2646 return_value = _readBitmapHeapScan();
2647 else if (MATCH("TIDSCAN", 7))
2648 return_value = _readTidScan();
2649 else if (MATCH("SUBQUERYSCAN", 12))
2650 return_value = _readSubqueryScan();
2651 else if (MATCH("FUNCTIONSCAN", 12))
2652 return_value = _readFunctionScan();
2653 else if (MATCH("VALUESSCAN", 10))
2654 return_value = _readValuesScan();
2655 else if (MATCH("TABLEFUNCSCAN", 13))
2656 return_value = _readTableFuncScan();
2657 else if (MATCH("CTESCAN", 7))
2658 return_value = _readCteScan();
2659 else if (MATCH("WORKTABLESCAN", 13))
2660 return_value = _readWorkTableScan();
2661 else if (MATCH("FOREIGNSCAN", 11))
2662 return_value = _readForeignScan();
2663 else if (MATCH("CUSTOMSCAN", 10))
2664 return_value = _readCustomScan();
2665 else if (MATCH("JOIN", 4))
2666 return_value = _readJoin();
2667 else if (MATCH("NESTLOOP", 8))
2668 return_value = _readNestLoop();
2669 else if (MATCH("MERGEJOIN", 9))
2670 return_value = _readMergeJoin();
2671 else if (MATCH("HASHJOIN", 8))
2672 return_value = _readHashJoin();
2673 else if (MATCH("MATERIAL", 8))
2674 return_value = _readMaterial();
2675 else if (MATCH("SORT", 4))
2676 return_value = _readSort();
2677 else if (MATCH("GROUP", 5))
2678 return_value = _readGroup();
2679 else if (MATCH("AGG", 3))
2680 return_value = _readAgg();
2681 else if (MATCH("WINDOWAGG", 9))
2682 return_value = _readWindowAgg();
2683 else if (MATCH("UNIQUE", 6))
2684 return_value = _readUnique();
2685 else if (MATCH("GATHER", 6))
2686 return_value = _readGather();
2687 else if (MATCH("GATHERMERGE", 11))
2688 return_value = _readGatherMerge();
2689 else if (MATCH("HASH", 4))
2690 return_value = _readHash();
2691 else if (MATCH("SETOP", 5))
2692 return_value = _readSetOp();
2693 else if (MATCH("LOCKROWS", 8))
2694 return_value = _readLockRows();
2695 else if (MATCH("LIMIT", 5))
2696 return_value = _readLimit();
2697 else if (MATCH("NESTLOOPPARAM", 13))
2698 return_value = _readNestLoopParam();
2699 else if (MATCH("PLANROWMARK", 11))
2700 return_value = _readPlanRowMark();
2701 else if (MATCH("PLANINVALITEM", 13))
2702 return_value = _readPlanInvalItem();
2703 else if (MATCH("SUBPLAN", 7))
2704 return_value = _readSubPlan();
2705 else if (MATCH("ALTERNATIVESUBPLAN", 18))
2706 return_value = _readAlternativeSubPlan();
2707 else if (MATCH("EXTENSIBLENODE", 14))
2708 return_value = _readExtensibleNode();
2709 else if (MATCH("PARTITIONBOUNDSPEC", 18))
2710 return_value = _readPartitionBoundSpec();
2711 else if (MATCH("PARTITIONRANGEDATUM", 19))
2712 return_value = _readPartitionRangeDatum();
2715 elog(ERROR, "badly formatted node string \"%.32s\"...", token);
2716 return_value = NULL; /* keep compiler quiet */
2719 return (Node *) return_value;
2726 * Given a string representation of a constant, recreate the appropriate
2727 * Datum. The string representation embeds length info, but not byValue,
2728 * so we must be told that.
2731 readDatum(bool typbyval)
2741 * read the actual length of the value
2743 token = pg_strtok(&tokenLength);
2744 length = atoui(token);
2746 token = pg_strtok(&tokenLength); /* read the '[' */
2747 if (token == NULL || token[0] != '[')
2748 elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu",
2749 token ? (const char *) token : "[NULL]", length);
2753 if (length > (Size) sizeof(Datum))
2754 elog(ERROR, "byval datum but length = %zu", length);
2756 s = (char *) (&res);
2757 for (i = 0; i < (Size) sizeof(Datum); i++)
2759 token = pg_strtok(&tokenLength);
2760 s[i] = (char) atoi(token);
2763 else if (length <= 0)
2767 s = (char *) palloc(length);
2768 for (i = 0; i < length; i++)
2770 token = pg_strtok(&tokenLength);
2771 s[i] = (char) atoi(token);
2773 res = PointerGetDatum(s);
2776 token = pg_strtok(&tokenLength); /* read the ']' */
2777 if (token == NULL || token[0] != ']')
2778 elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu",
2779 token ? (const char *) token : "[NULL]", length);
2785 * readAttrNumberCols
2788 readAttrNumberCols(int numCols)
2793 AttrNumber *attr_vals;
2798 attr_vals = (AttrNumber *) palloc(numCols * sizeof(AttrNumber));
2799 for (i = 0; i < numCols; i++)
2801 token = pg_strtok(&tokenLength);
2802 attr_vals[i] = atoi(token);
2812 readOidCols(int numCols)
2822 oid_vals = (Oid *) palloc(numCols * sizeof(Oid));
2823 for (i = 0; i < numCols; i++)
2825 token = pg_strtok(&tokenLength);
2826 oid_vals[i] = atooid(token);
2836 readIntCols(int numCols)
2846 int_vals = (int *) palloc(numCols * sizeof(int));
2847 for (i = 0; i < numCols; i++)
2849 token = pg_strtok(&tokenLength);
2850 int_vals[i] = atoi(token);
2860 readBoolCols(int numCols)
2870 bool_vals = (bool *) palloc(numCols * sizeof(bool));
2871 for (i = 0; i < numCols; i++)
2873 token = pg_strtok(&tokenLength);
2874 bool_vals[i] = strtobool(token);