1 /*-------------------------------------------------------------------------
4 * Reader functions for Postgres tree nodes.
6 * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
11 * src/backend/nodes/readfuncs.c
14 * Path and Plan nodes do not have any readfuncs support, because we
15 * never 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 *-------------------------------------------------------------------------
31 #include "nodes/parsenodes.h"
32 #include "nodes/readfuncs.h"
36 * Macros to simplify reading of different kinds of fields. Use these
37 * wherever possible to reduce the chance for silly typos. Note that these
38 * hard-wire conventions about the names of the local variables in a Read
42 /* Macros for declaring appropriate local variables */
44 /* A few guys need only local_node */
45 #define READ_LOCALS_NO_FIELDS(nodeTypeName) \
46 nodeTypeName *local_node = makeNode(nodeTypeName)
48 /* And a few guys need only the pg_strtok support fields */
49 #define READ_TEMP_LOCALS() \
52 (void) token /* possibly unused */
54 /* ... but most need both */
55 #define READ_LOCALS(nodeTypeName) \
56 READ_LOCALS_NO_FIELDS(nodeTypeName); \
59 /* Read an integer field (anything written as ":fldname %d") */
60 #define READ_INT_FIELD(fldname) \
61 token = pg_strtok(&length); /* skip :fldname */ \
62 token = pg_strtok(&length); /* get field value */ \
63 local_node->fldname = atoi(token)
65 /* Read an unsigned integer field (anything written as ":fldname %u") */
66 #define READ_UINT_FIELD(fldname) \
67 token = pg_strtok(&length); /* skip :fldname */ \
68 token = pg_strtok(&length); /* get field value */ \
69 local_node->fldname = atoui(token)
71 /* Read an OID field (don't hard-wire assumption that OID is same as uint) */
72 #define READ_OID_FIELD(fldname) \
73 token = pg_strtok(&length); /* skip :fldname */ \
74 token = pg_strtok(&length); /* get field value */ \
75 local_node->fldname = atooid(token)
77 /* Read a char field (ie, one ascii character) */
78 #define READ_CHAR_FIELD(fldname) \
79 token = pg_strtok(&length); /* skip :fldname */ \
80 token = pg_strtok(&length); /* get field value */ \
81 local_node->fldname = token[0]
83 /* Read an enumerated-type field that was written as an integer code */
84 #define READ_ENUM_FIELD(fldname, enumtype) \
85 token = pg_strtok(&length); /* skip :fldname */ \
86 token = pg_strtok(&length); /* get field value */ \
87 local_node->fldname = (enumtype) atoi(token)
89 /* Read a float field */
90 #define READ_FLOAT_FIELD(fldname) \
91 token = pg_strtok(&length); /* skip :fldname */ \
92 token = pg_strtok(&length); /* get field value */ \
93 local_node->fldname = atof(token)
95 /* Read a boolean field */
96 #define READ_BOOL_FIELD(fldname) \
97 token = pg_strtok(&length); /* skip :fldname */ \
98 token = pg_strtok(&length); /* get field value */ \
99 local_node->fldname = strtobool(token)
101 /* Read a character-string field */
102 #define READ_STRING_FIELD(fldname) \
103 token = pg_strtok(&length); /* skip :fldname */ \
104 token = pg_strtok(&length); /* get field value */ \
105 local_node->fldname = nullable_string(token, length)
107 /* Read a parse location field (and throw away the value, per notes above) */
108 #define READ_LOCATION_FIELD(fldname) \
109 token = pg_strtok(&length); /* skip :fldname */ \
110 token = pg_strtok(&length); /* get field value */ \
111 local_node->fldname = -1 /* set field to "unknown" */
113 /* Read a Node field */
114 #define READ_NODE_FIELD(fldname) \
115 token = pg_strtok(&length); /* skip :fldname */ \
116 local_node->fldname = nodeRead(NULL, 0)
118 /* Read a bitmapset field */
119 #define READ_BITMAPSET_FIELD(fldname) \
120 token = pg_strtok(&length); /* skip :fldname */ \
121 local_node->fldname = _readBitmapset()
124 #define READ_DONE() \
129 * NOTE: use atoi() to read values written with %d, or atoui() to read
130 * values written with %u in outfuncs.c. An exception is OID values,
131 * for which use atooid(). (As of 7.1, outfuncs.c writes OIDs as %u,
132 * but this will probably change in the future.)
134 #define atoui(x) ((unsigned int) strtoul((x), NULL, 10))
136 #define atooid(x) ((Oid) strtoul((x), NULL, 10))
138 #define strtobool(x) ((*(x) == 't') ? true : false)
140 #define nullable_string(token,length) \
141 ((length) == 0 ? NULL : debackslash(token, length))
144 static Datum readDatum(bool typbyval);
152 Bitmapset *result = NULL;
156 token = pg_strtok(&length);
158 elog(ERROR, "incomplete Bitmapset structure");
159 if (length != 1 || token[0] != '(')
160 elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
162 token = pg_strtok(&length);
164 elog(ERROR, "incomplete Bitmapset structure");
165 if (length != 1 || token[0] != 'b')
166 elog(ERROR, "unrecognized token: \"%.*s\"", length, token);
173 token = pg_strtok(&length);
175 elog(ERROR, "unterminated Bitmapset structure");
176 if (length == 1 && token[0] == ')')
178 val = (int) strtol(token, &endptr, 10);
179 if (endptr != token + length)
180 elog(ERROR, "unrecognized integer: \"%.*s\"", length, token);
181 result = bms_add_member(result, val);
196 READ_ENUM_FIELD(commandType, CmdType);
197 READ_ENUM_FIELD(querySource, QuerySource);
198 READ_BOOL_FIELD(canSetTag);
199 READ_NODE_FIELD(utilityStmt);
200 READ_INT_FIELD(resultRelation);
201 READ_NODE_FIELD(intoClause);
202 READ_BOOL_FIELD(hasAggs);
203 READ_BOOL_FIELD(hasWindowFuncs);
204 READ_BOOL_FIELD(hasSubLinks);
205 READ_BOOL_FIELD(hasDistinctOn);
206 READ_BOOL_FIELD(hasRecursive);
207 READ_BOOL_FIELD(hasModifyingCTE);
208 READ_BOOL_FIELD(hasForUpdate);
209 READ_NODE_FIELD(cteList);
210 READ_NODE_FIELD(rtable);
211 READ_NODE_FIELD(jointree);
212 READ_NODE_FIELD(targetList);
213 READ_NODE_FIELD(returningList);
214 READ_NODE_FIELD(groupClause);
215 READ_NODE_FIELD(havingQual);
216 READ_NODE_FIELD(windowClause);
217 READ_NODE_FIELD(distinctClause);
218 READ_NODE_FIELD(sortClause);
219 READ_NODE_FIELD(limitOffset);
220 READ_NODE_FIELD(limitCount);
221 READ_NODE_FIELD(rowMarks);
222 READ_NODE_FIELD(setOperations);
223 READ_NODE_FIELD(constraintDeps);
232 _readNotifyStmt(void)
234 READ_LOCALS(NotifyStmt);
236 READ_STRING_FIELD(conditionname);
237 READ_STRING_FIELD(payload);
243 * _readDeclareCursorStmt
245 static DeclareCursorStmt *
246 _readDeclareCursorStmt(void)
248 READ_LOCALS(DeclareCursorStmt);
250 READ_STRING_FIELD(portalname);
251 READ_INT_FIELD(options);
252 READ_NODE_FIELD(query);
258 * _readSortGroupClause
260 static SortGroupClause *
261 _readSortGroupClause(void)
263 READ_LOCALS(SortGroupClause);
265 READ_UINT_FIELD(tleSortGroupRef);
266 READ_OID_FIELD(eqop);
267 READ_OID_FIELD(sortop);
268 READ_BOOL_FIELD(nulls_first);
269 READ_BOOL_FIELD(hashable);
277 static WindowClause *
278 _readWindowClause(void)
280 READ_LOCALS(WindowClause);
282 READ_STRING_FIELD(name);
283 READ_STRING_FIELD(refname);
284 READ_NODE_FIELD(partitionClause);
285 READ_NODE_FIELD(orderClause);
286 READ_INT_FIELD(frameOptions);
287 READ_NODE_FIELD(startOffset);
288 READ_NODE_FIELD(endOffset);
289 READ_UINT_FIELD(winref);
290 READ_BOOL_FIELD(copiedOrder);
298 static RowMarkClause *
299 _readRowMarkClause(void)
301 READ_LOCALS(RowMarkClause);
303 READ_UINT_FIELD(rti);
304 READ_BOOL_FIELD(forUpdate);
305 READ_BOOL_FIELD(noWait);
306 READ_BOOL_FIELD(pushedDown);
312 * _readCommonTableExpr
314 static CommonTableExpr *
315 _readCommonTableExpr(void)
317 READ_LOCALS(CommonTableExpr);
319 READ_STRING_FIELD(ctename);
320 READ_NODE_FIELD(aliascolnames);
321 READ_NODE_FIELD(ctequery);
322 READ_LOCATION_FIELD(location);
323 READ_BOOL_FIELD(cterecursive);
324 READ_INT_FIELD(cterefcount);
325 READ_NODE_FIELD(ctecolnames);
326 READ_NODE_FIELD(ctecoltypes);
327 READ_NODE_FIELD(ctecoltypmods);
328 READ_NODE_FIELD(ctecolcollations);
334 * _readSetOperationStmt
336 static SetOperationStmt *
337 _readSetOperationStmt(void)
339 READ_LOCALS(SetOperationStmt);
341 READ_ENUM_FIELD(op, SetOperation);
342 READ_BOOL_FIELD(all);
343 READ_NODE_FIELD(larg);
344 READ_NODE_FIELD(rarg);
345 READ_NODE_FIELD(colTypes);
346 READ_NODE_FIELD(colTypmods);
347 READ_NODE_FIELD(colCollations);
348 READ_NODE_FIELD(groupClauses);
355 * Stuff from primnodes.h.
363 READ_STRING_FIELD(aliasname);
364 READ_NODE_FIELD(colnames);
372 READ_LOCALS(RangeVar);
374 local_node->catalogname = NULL; /* not currently saved in output
377 READ_STRING_FIELD(schemaname);
378 READ_STRING_FIELD(relname);
379 READ_ENUM_FIELD(inhOpt, InhOption);
380 READ_CHAR_FIELD(relpersistence);
381 READ_NODE_FIELD(alias);
382 READ_LOCATION_FIELD(location);
388 _readIntoClause(void)
390 READ_LOCALS(IntoClause);
392 READ_NODE_FIELD(rel);
393 READ_NODE_FIELD(colNames);
394 READ_NODE_FIELD(options);
395 READ_ENUM_FIELD(onCommit, OnCommitAction);
396 READ_STRING_FIELD(tableSpaceName);
397 READ_BOOL_FIELD(skipData);
410 READ_UINT_FIELD(varno);
411 READ_INT_FIELD(varattno);
412 READ_OID_FIELD(vartype);
413 READ_INT_FIELD(vartypmod);
414 READ_OID_FIELD(varcollid);
415 READ_UINT_FIELD(varlevelsup);
416 READ_UINT_FIELD(varnoold);
417 READ_INT_FIELD(varoattno);
418 READ_LOCATION_FIELD(location);
431 READ_OID_FIELD(consttype);
432 READ_INT_FIELD(consttypmod);
433 READ_OID_FIELD(constcollid);
434 READ_INT_FIELD(constlen);
435 READ_BOOL_FIELD(constbyval);
436 READ_BOOL_FIELD(constisnull);
437 READ_LOCATION_FIELD(location);
439 token = pg_strtok(&length); /* skip :constvalue */
440 if (local_node->constisnull)
441 token = pg_strtok(&length); /* skip "<>" */
443 local_node->constvalue = readDatum(local_node->constbyval);
456 READ_ENUM_FIELD(paramkind, ParamKind);
457 READ_INT_FIELD(paramid);
458 READ_OID_FIELD(paramtype);
459 READ_INT_FIELD(paramtypmod);
460 READ_OID_FIELD(paramcollid);
461 READ_LOCATION_FIELD(location);
474 READ_OID_FIELD(aggfnoid);
475 READ_OID_FIELD(aggtype);
476 READ_OID_FIELD(aggcollid);
477 READ_OID_FIELD(inputcollid);
478 READ_NODE_FIELD(args);
479 READ_NODE_FIELD(aggorder);
480 READ_NODE_FIELD(aggdistinct);
481 READ_BOOL_FIELD(aggstar);
482 READ_UINT_FIELD(agglevelsup);
483 READ_LOCATION_FIELD(location);
492 _readWindowFunc(void)
494 READ_LOCALS(WindowFunc);
496 READ_OID_FIELD(winfnoid);
497 READ_OID_FIELD(wintype);
498 READ_OID_FIELD(wincollid);
499 READ_OID_FIELD(inputcollid);
500 READ_NODE_FIELD(args);
501 READ_UINT_FIELD(winref);
502 READ_BOOL_FIELD(winstar);
503 READ_BOOL_FIELD(winagg);
504 READ_LOCATION_FIELD(location);
515 READ_LOCALS(ArrayRef);
517 READ_OID_FIELD(refarraytype);
518 READ_OID_FIELD(refelemtype);
519 READ_INT_FIELD(reftypmod);
520 READ_OID_FIELD(refcollid);
521 READ_NODE_FIELD(refupperindexpr);
522 READ_NODE_FIELD(reflowerindexpr);
523 READ_NODE_FIELD(refexpr);
524 READ_NODE_FIELD(refassgnexpr);
535 READ_LOCALS(FuncExpr);
537 READ_OID_FIELD(funcid);
538 READ_OID_FIELD(funcresulttype);
539 READ_BOOL_FIELD(funcretset);
540 READ_ENUM_FIELD(funcformat, CoercionForm);
541 READ_OID_FIELD(funccollid);
542 READ_OID_FIELD(inputcollid);
543 READ_NODE_FIELD(args);
544 READ_LOCATION_FIELD(location);
552 static NamedArgExpr *
553 _readNamedArgExpr(void)
555 READ_LOCALS(NamedArgExpr);
557 READ_NODE_FIELD(arg);
558 READ_STRING_FIELD(name);
559 READ_INT_FIELD(argnumber);
560 READ_LOCATION_FIELD(location);
573 READ_OID_FIELD(opno);
574 READ_OID_FIELD(opfuncid);
577 * The opfuncid is stored in the textual format primarily for debugging
578 * and documentation reasons. We want to always read it as zero to force
579 * it to be re-looked-up in the pg_operator entry. This ensures that
580 * stored rules don't have hidden dependencies on operators' functions.
581 * (We don't currently support an ALTER OPERATOR command, but might
584 local_node->opfuncid = InvalidOid;
586 READ_OID_FIELD(opresulttype);
587 READ_BOOL_FIELD(opretset);
588 READ_OID_FIELD(opcollid);
589 READ_OID_FIELD(inputcollid);
590 READ_NODE_FIELD(args);
591 READ_LOCATION_FIELD(location);
599 static DistinctExpr *
600 _readDistinctExpr(void)
602 READ_LOCALS(DistinctExpr);
604 READ_OID_FIELD(opno);
605 READ_OID_FIELD(opfuncid);
608 * The opfuncid is stored in the textual format primarily for debugging
609 * and documentation reasons. We want to always read it as zero to force
610 * it to be re-looked-up in the pg_operator entry. This ensures that
611 * stored rules don't have hidden dependencies on operators' functions.
612 * (We don't currently support an ALTER OPERATOR command, but might
615 local_node->opfuncid = InvalidOid;
617 READ_OID_FIELD(opresulttype);
618 READ_BOOL_FIELD(opretset);
619 READ_OID_FIELD(opcollid);
620 READ_OID_FIELD(inputcollid);
621 READ_NODE_FIELD(args);
622 READ_LOCATION_FIELD(location);
631 _readNullIfExpr(void)
633 READ_LOCALS(NullIfExpr);
635 READ_OID_FIELD(opno);
636 READ_OID_FIELD(opfuncid);
639 * The opfuncid is stored in the textual format primarily for debugging
640 * and documentation reasons. We want to always read it as zero to force
641 * it to be re-looked-up in the pg_operator entry. This ensures that
642 * stored rules don't have hidden dependencies on operators' functions.
643 * (We don't currently support an ALTER OPERATOR command, but might
646 local_node->opfuncid = InvalidOid;
648 READ_OID_FIELD(opresulttype);
649 READ_BOOL_FIELD(opretset);
650 READ_OID_FIELD(opcollid);
651 READ_OID_FIELD(inputcollid);
652 READ_NODE_FIELD(args);
653 READ_LOCATION_FIELD(location);
659 * _readScalarArrayOpExpr
661 static ScalarArrayOpExpr *
662 _readScalarArrayOpExpr(void)
664 READ_LOCALS(ScalarArrayOpExpr);
666 READ_OID_FIELD(opno);
667 READ_OID_FIELD(opfuncid);
670 * The opfuncid is stored in the textual format primarily for debugging
671 * and documentation reasons. We want to always read it as zero to force
672 * it to be re-looked-up in the pg_operator entry. This ensures that
673 * stored rules don't have hidden dependencies on operators' functions.
674 * (We don't currently support an ALTER OPERATOR command, but might
677 local_node->opfuncid = InvalidOid;
679 READ_BOOL_FIELD(useOr);
680 READ_OID_FIELD(inputcollid);
681 READ_NODE_FIELD(args);
682 READ_LOCATION_FIELD(location);
693 READ_LOCALS(BoolExpr);
695 /* do-it-yourself enum representation */
696 token = pg_strtok(&length); /* skip :boolop */
697 token = pg_strtok(&length); /* get field value */
698 if (strncmp(token, "and", 3) == 0)
699 local_node->boolop = AND_EXPR;
700 else if (strncmp(token, "or", 2) == 0)
701 local_node->boolop = OR_EXPR;
702 else if (strncmp(token, "not", 3) == 0)
703 local_node->boolop = NOT_EXPR;
705 elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
707 READ_NODE_FIELD(args);
708 READ_LOCATION_FIELD(location);
719 READ_LOCALS(SubLink);
721 READ_ENUM_FIELD(subLinkType, SubLinkType);
722 READ_NODE_FIELD(testexpr);
723 READ_NODE_FIELD(operName);
724 READ_NODE_FIELD(subselect);
725 READ_LOCATION_FIELD(location);
731 * _readSubPlan is not needed since it doesn't appear in stored rules.
738 _readFieldSelect(void)
740 READ_LOCALS(FieldSelect);
742 READ_NODE_FIELD(arg);
743 READ_INT_FIELD(fieldnum);
744 READ_OID_FIELD(resulttype);
745 READ_INT_FIELD(resulttypmod);
746 READ_OID_FIELD(resultcollid);
755 _readFieldStore(void)
757 READ_LOCALS(FieldStore);
759 READ_NODE_FIELD(arg);
760 READ_NODE_FIELD(newvals);
761 READ_NODE_FIELD(fieldnums);
762 READ_OID_FIELD(resulttype);
771 _readRelabelType(void)
773 READ_LOCALS(RelabelType);
775 READ_NODE_FIELD(arg);
776 READ_OID_FIELD(resulttype);
777 READ_INT_FIELD(resulttypmod);
778 READ_OID_FIELD(resultcollid);
779 READ_ENUM_FIELD(relabelformat, CoercionForm);
780 READ_LOCATION_FIELD(location);
789 _readCoerceViaIO(void)
791 READ_LOCALS(CoerceViaIO);
793 READ_NODE_FIELD(arg);
794 READ_OID_FIELD(resulttype);
795 READ_OID_FIELD(resultcollid);
796 READ_ENUM_FIELD(coerceformat, CoercionForm);
797 READ_LOCATION_FIELD(location);
803 * _readArrayCoerceExpr
805 static ArrayCoerceExpr *
806 _readArrayCoerceExpr(void)
808 READ_LOCALS(ArrayCoerceExpr);
810 READ_NODE_FIELD(arg);
811 READ_OID_FIELD(elemfuncid);
812 READ_OID_FIELD(resulttype);
813 READ_INT_FIELD(resulttypmod);
814 READ_OID_FIELD(resultcollid);
815 READ_BOOL_FIELD(isExplicit);
816 READ_ENUM_FIELD(coerceformat, CoercionForm);
817 READ_LOCATION_FIELD(location);
823 * _readConvertRowtypeExpr
825 static ConvertRowtypeExpr *
826 _readConvertRowtypeExpr(void)
828 READ_LOCALS(ConvertRowtypeExpr);
830 READ_NODE_FIELD(arg);
831 READ_OID_FIELD(resulttype);
832 READ_ENUM_FIELD(convertformat, CoercionForm);
833 READ_LOCATION_FIELD(location);
842 _readCollateExpr(void)
844 READ_LOCALS(CollateExpr);
846 READ_NODE_FIELD(arg);
847 READ_OID_FIELD(collOid);
848 READ_LOCATION_FIELD(location);
859 READ_LOCALS(CaseExpr);
861 READ_OID_FIELD(casetype);
862 READ_OID_FIELD(casecollid);
863 READ_NODE_FIELD(arg);
864 READ_NODE_FIELD(args);
865 READ_NODE_FIELD(defresult);
866 READ_LOCATION_FIELD(location);
877 READ_LOCALS(CaseWhen);
879 READ_NODE_FIELD(expr);
880 READ_NODE_FIELD(result);
881 READ_LOCATION_FIELD(location);
889 static CaseTestExpr *
890 _readCaseTestExpr(void)
892 READ_LOCALS(CaseTestExpr);
894 READ_OID_FIELD(typeId);
895 READ_INT_FIELD(typeMod);
896 READ_OID_FIELD(collation);
907 READ_LOCALS(ArrayExpr);
909 READ_OID_FIELD(array_typeid);
910 READ_OID_FIELD(array_collid);
911 READ_OID_FIELD(element_typeid);
912 READ_NODE_FIELD(elements);
913 READ_BOOL_FIELD(multidims);
914 READ_LOCATION_FIELD(location);
925 READ_LOCALS(RowExpr);
927 READ_NODE_FIELD(args);
928 READ_OID_FIELD(row_typeid);
929 READ_ENUM_FIELD(row_format, CoercionForm);
930 READ_NODE_FIELD(colnames);
931 READ_LOCATION_FIELD(location);
937 * _readRowCompareExpr
939 static RowCompareExpr *
940 _readRowCompareExpr(void)
942 READ_LOCALS(RowCompareExpr);
944 READ_ENUM_FIELD(rctype, RowCompareType);
945 READ_NODE_FIELD(opnos);
946 READ_NODE_FIELD(opfamilies);
947 READ_NODE_FIELD(inputcollids);
948 READ_NODE_FIELD(largs);
949 READ_NODE_FIELD(rargs);
957 static CoalesceExpr *
958 _readCoalesceExpr(void)
960 READ_LOCALS(CoalesceExpr);
962 READ_OID_FIELD(coalescetype);
963 READ_OID_FIELD(coalescecollid);
964 READ_NODE_FIELD(args);
965 READ_LOCATION_FIELD(location);
974 _readMinMaxExpr(void)
976 READ_LOCALS(MinMaxExpr);
978 READ_OID_FIELD(minmaxtype);
979 READ_OID_FIELD(minmaxcollid);
980 READ_OID_FIELD(inputcollid);
981 READ_ENUM_FIELD(op, MinMaxOp);
982 READ_NODE_FIELD(args);
983 READ_LOCATION_FIELD(location);
994 READ_LOCALS(XmlExpr);
996 READ_ENUM_FIELD(op, XmlExprOp);
997 READ_STRING_FIELD(name);
998 READ_NODE_FIELD(named_args);
999 READ_NODE_FIELD(arg_names);
1000 READ_NODE_FIELD(args);
1001 READ_ENUM_FIELD(xmloption, XmlOptionType);
1002 READ_OID_FIELD(type);
1003 READ_INT_FIELD(typmod);
1004 READ_LOCATION_FIELD(location);
1015 READ_LOCALS(NullTest);
1017 READ_NODE_FIELD(arg);
1018 READ_ENUM_FIELD(nulltesttype, NullTestType);
1019 READ_BOOL_FIELD(argisrow);
1027 static BooleanTest *
1028 _readBooleanTest(void)
1030 READ_LOCALS(BooleanTest);
1032 READ_NODE_FIELD(arg);
1033 READ_ENUM_FIELD(booltesttype, BoolTestType);
1039 * _readCoerceToDomain
1041 static CoerceToDomain *
1042 _readCoerceToDomain(void)
1044 READ_LOCALS(CoerceToDomain);
1046 READ_NODE_FIELD(arg);
1047 READ_OID_FIELD(resulttype);
1048 READ_INT_FIELD(resulttypmod);
1049 READ_OID_FIELD(resultcollid);
1050 READ_ENUM_FIELD(coercionformat, CoercionForm);
1051 READ_LOCATION_FIELD(location);
1057 * _readCoerceToDomainValue
1059 static CoerceToDomainValue *
1060 _readCoerceToDomainValue(void)
1062 READ_LOCALS(CoerceToDomainValue);
1064 READ_OID_FIELD(typeId);
1065 READ_INT_FIELD(typeMod);
1066 READ_OID_FIELD(collation);
1067 READ_LOCATION_FIELD(location);
1075 static SetToDefault *
1076 _readSetToDefault(void)
1078 READ_LOCALS(SetToDefault);
1080 READ_OID_FIELD(typeId);
1081 READ_INT_FIELD(typeMod);
1082 READ_OID_FIELD(collation);
1083 READ_LOCATION_FIELD(location);
1089 * _readCurrentOfExpr
1091 static CurrentOfExpr *
1092 _readCurrentOfExpr(void)
1094 READ_LOCALS(CurrentOfExpr);
1096 READ_UINT_FIELD(cvarno);
1097 READ_STRING_FIELD(cursor_name);
1098 READ_INT_FIELD(cursor_param);
1106 static TargetEntry *
1107 _readTargetEntry(void)
1109 READ_LOCALS(TargetEntry);
1111 READ_NODE_FIELD(expr);
1112 READ_INT_FIELD(resno);
1113 READ_STRING_FIELD(resname);
1114 READ_UINT_FIELD(ressortgroupref);
1115 READ_OID_FIELD(resorigtbl);
1116 READ_INT_FIELD(resorigcol);
1117 READ_BOOL_FIELD(resjunk);
1125 static RangeTblRef *
1126 _readRangeTblRef(void)
1128 READ_LOCALS(RangeTblRef);
1130 READ_INT_FIELD(rtindex);
1141 READ_LOCALS(JoinExpr);
1143 READ_ENUM_FIELD(jointype, JoinType);
1144 READ_BOOL_FIELD(isNatural);
1145 READ_NODE_FIELD(larg);
1146 READ_NODE_FIELD(rarg);
1147 READ_NODE_FIELD(usingClause);
1148 READ_NODE_FIELD(quals);
1149 READ_NODE_FIELD(alias);
1150 READ_INT_FIELD(rtindex);
1161 READ_LOCALS(FromExpr);
1163 READ_NODE_FIELD(fromlist);
1164 READ_NODE_FIELD(quals);
1171 * Stuff from parsenodes.h.
1175 * _readRangeTblEntry
1177 static RangeTblEntry *
1178 _readRangeTblEntry(void)
1180 READ_LOCALS(RangeTblEntry);
1182 /* put alias + eref first to make dump more legible */
1183 READ_NODE_FIELD(alias);
1184 READ_NODE_FIELD(eref);
1185 READ_ENUM_FIELD(rtekind, RTEKind);
1187 switch (local_node->rtekind)
1190 READ_OID_FIELD(relid);
1191 READ_CHAR_FIELD(relkind);
1194 READ_NODE_FIELD(subquery);
1197 READ_ENUM_FIELD(jointype, JoinType);
1198 READ_NODE_FIELD(joinaliasvars);
1201 READ_NODE_FIELD(funcexpr);
1202 READ_NODE_FIELD(funccoltypes);
1203 READ_NODE_FIELD(funccoltypmods);
1204 READ_NODE_FIELD(funccolcollations);
1207 READ_NODE_FIELD(values_lists);
1208 READ_NODE_FIELD(values_collations);
1211 READ_STRING_FIELD(ctename);
1212 READ_UINT_FIELD(ctelevelsup);
1213 READ_BOOL_FIELD(self_reference);
1214 READ_NODE_FIELD(ctecoltypes);
1215 READ_NODE_FIELD(ctecoltypmods);
1216 READ_NODE_FIELD(ctecolcollations);
1219 elog(ERROR, "unrecognized RTE kind: %d",
1220 (int) local_node->rtekind);
1224 READ_BOOL_FIELD(inh);
1225 READ_BOOL_FIELD(inFromCl);
1226 READ_UINT_FIELD(requiredPerms);
1227 READ_OID_FIELD(checkAsUser);
1228 READ_BITMAPSET_FIELD(selectedCols);
1229 READ_BITMAPSET_FIELD(modifiedCols);
1238 * Given a character string representing a node tree, parseNodeString creates
1239 * the internal node structure.
1241 * The string to be read must already have been loaded into pg_strtok().
1244 parseNodeString(void)
1250 token = pg_strtok(&length);
1252 #define MATCH(tokname, namelen) \
1253 (length == namelen && memcmp(token, tokname, namelen) == 0)
1255 if (MATCH("QUERY", 5))
1256 return_value = _readQuery();
1257 else if (MATCH("SORTGROUPCLAUSE", 15))
1258 return_value = _readSortGroupClause();
1259 else if (MATCH("WINDOWCLAUSE", 12))
1260 return_value = _readWindowClause();
1261 else if (MATCH("ROWMARKCLAUSE", 13))
1262 return_value = _readRowMarkClause();
1263 else if (MATCH("COMMONTABLEEXPR", 15))
1264 return_value = _readCommonTableExpr();
1265 else if (MATCH("SETOPERATIONSTMT", 16))
1266 return_value = _readSetOperationStmt();
1267 else if (MATCH("ALIAS", 5))
1268 return_value = _readAlias();
1269 else if (MATCH("RANGEVAR", 8))
1270 return_value = _readRangeVar();
1271 else if (MATCH("INTOCLAUSE", 10))
1272 return_value = _readIntoClause();
1273 else if (MATCH("VAR", 3))
1274 return_value = _readVar();
1275 else if (MATCH("CONST", 5))
1276 return_value = _readConst();
1277 else if (MATCH("PARAM", 5))
1278 return_value = _readParam();
1279 else if (MATCH("AGGREF", 6))
1280 return_value = _readAggref();
1281 else if (MATCH("WINDOWFUNC", 10))
1282 return_value = _readWindowFunc();
1283 else if (MATCH("ARRAYREF", 8))
1284 return_value = _readArrayRef();
1285 else if (MATCH("FUNCEXPR", 8))
1286 return_value = _readFuncExpr();
1287 else if (MATCH("NAMEDARGEXPR", 12))
1288 return_value = _readNamedArgExpr();
1289 else if (MATCH("OPEXPR", 6))
1290 return_value = _readOpExpr();
1291 else if (MATCH("DISTINCTEXPR", 12))
1292 return_value = _readDistinctExpr();
1293 else if (MATCH("NULLIFEXPR", 10))
1294 return_value = _readNullIfExpr();
1295 else if (MATCH("SCALARARRAYOPEXPR", 17))
1296 return_value = _readScalarArrayOpExpr();
1297 else if (MATCH("BOOLEXPR", 8))
1298 return_value = _readBoolExpr();
1299 else if (MATCH("SUBLINK", 7))
1300 return_value = _readSubLink();
1301 else if (MATCH("FIELDSELECT", 11))
1302 return_value = _readFieldSelect();
1303 else if (MATCH("FIELDSTORE", 10))
1304 return_value = _readFieldStore();
1305 else if (MATCH("RELABELTYPE", 11))
1306 return_value = _readRelabelType();
1307 else if (MATCH("COERCEVIAIO", 11))
1308 return_value = _readCoerceViaIO();
1309 else if (MATCH("ARRAYCOERCEEXPR", 15))
1310 return_value = _readArrayCoerceExpr();
1311 else if (MATCH("CONVERTROWTYPEEXPR", 18))
1312 return_value = _readConvertRowtypeExpr();
1313 else if (MATCH("COLLATE", 7))
1314 return_value = _readCollateExpr();
1315 else if (MATCH("CASE", 4))
1316 return_value = _readCaseExpr();
1317 else if (MATCH("WHEN", 4))
1318 return_value = _readCaseWhen();
1319 else if (MATCH("CASETESTEXPR", 12))
1320 return_value = _readCaseTestExpr();
1321 else if (MATCH("ARRAY", 5))
1322 return_value = _readArrayExpr();
1323 else if (MATCH("ROW", 3))
1324 return_value = _readRowExpr();
1325 else if (MATCH("ROWCOMPARE", 10))
1326 return_value = _readRowCompareExpr();
1327 else if (MATCH("COALESCE", 8))
1328 return_value = _readCoalesceExpr();
1329 else if (MATCH("MINMAX", 6))
1330 return_value = _readMinMaxExpr();
1331 else if (MATCH("XMLEXPR", 7))
1332 return_value = _readXmlExpr();
1333 else if (MATCH("NULLTEST", 8))
1334 return_value = _readNullTest();
1335 else if (MATCH("BOOLEANTEST", 11))
1336 return_value = _readBooleanTest();
1337 else if (MATCH("COERCETODOMAIN", 14))
1338 return_value = _readCoerceToDomain();
1339 else if (MATCH("COERCETODOMAINVALUE", 19))
1340 return_value = _readCoerceToDomainValue();
1341 else if (MATCH("SETTODEFAULT", 12))
1342 return_value = _readSetToDefault();
1343 else if (MATCH("CURRENTOFEXPR", 13))
1344 return_value = _readCurrentOfExpr();
1345 else if (MATCH("TARGETENTRY", 11))
1346 return_value = _readTargetEntry();
1347 else if (MATCH("RANGETBLREF", 11))
1348 return_value = _readRangeTblRef();
1349 else if (MATCH("JOINEXPR", 8))
1350 return_value = _readJoinExpr();
1351 else if (MATCH("FROMEXPR", 8))
1352 return_value = _readFromExpr();
1353 else if (MATCH("RTE", 3))
1354 return_value = _readRangeTblEntry();
1355 else if (MATCH("NOTIFY", 6))
1356 return_value = _readNotifyStmt();
1357 else if (MATCH("DECLARECURSOR", 13))
1358 return_value = _readDeclareCursorStmt();
1361 elog(ERROR, "badly formatted node string \"%.32s\"...", token);
1362 return_value = NULL; /* keep compiler quiet */
1365 return (Node *) return_value;
1372 * Given a string representation of a constant, recreate the appropriate
1373 * Datum. The string representation embeds length info, but not byValue,
1374 * so we must be told that.
1377 readDatum(bool typbyval)
1387 * read the actual length of the value
1389 token = pg_strtok(&tokenLength);
1390 length = atoui(token);
1392 token = pg_strtok(&tokenLength); /* read the '[' */
1393 if (token == NULL || token[0] != '[')
1394 elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %lu",
1395 token ? (const char *) token : "[NULL]",
1396 (unsigned long) length);
1400 if (length > (Size) sizeof(Datum))
1401 elog(ERROR, "byval datum but length = %lu",
1402 (unsigned long) length);
1404 s = (char *) (&res);
1405 for (i = 0; i < (Size) sizeof(Datum); i++)
1407 token = pg_strtok(&tokenLength);
1408 s[i] = (char) atoi(token);
1411 else if (length <= 0)
1415 s = (char *) palloc(length);
1416 for (i = 0; i < length; i++)
1418 token = pg_strtok(&tokenLength);
1419 s[i] = (char) atoi(token);
1421 res = PointerGetDatum(s);
1424 token = pg_strtok(&tokenLength); /* read the ']' */
1425 if (token == NULL || token[0] != ']')
1426 elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %lu",
1427 token ? (const char *) token : "[NULL]",
1428 (unsigned long) length);