/*------------------------------------------------------------------------- * * readfuncs.c * Reader functions for Postgres tree nodes. * * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION * src/backend/nodes/readfuncs.c * * NOTES * Parse location fields are written out by outfuncs.c, but only for * debugging use. When reading a location field, we normally discard * the stored value and set the location field to -1 (ie, "unknown"). * This is because nodes coming from a stored rule should not be thought * to have a known location in the current query's text. * * However, if restore_location_fields is true, we do restore location * fields from the string. This is currently intended only for use by the * debug_write_read_parse_plan_trees test code, which doesn't want to cause * any change in the node contents. * *------------------------------------------------------------------------- */ #include "postgres.h" #include #include "miscadmin.h" #include "nodes/bitmapset.h" #include "nodes/readfuncs.h" /* * Macros to simplify reading of different kinds of fields. Use these * wherever possible to reduce the chance for silly typos. Note that these * hard-wire conventions about the names of the local variables in a Read * routine. */ /* Macros for declaring appropriate local variables */ /* A few guys need only local_node */ #define READ_LOCALS_NO_FIELDS(nodeTypeName) \ nodeTypeName *local_node = makeNode(nodeTypeName) /* And a few guys need only the pg_strtok support fields */ #define READ_TEMP_LOCALS() \ const char *token; \ int length /* ... but most need both */ #define READ_LOCALS(nodeTypeName) \ READ_LOCALS_NO_FIELDS(nodeTypeName); \ READ_TEMP_LOCALS() /* Read an integer field (anything written as ":fldname %d") */ #define READ_INT_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ local_node->fldname = atoi(token) /* Read an unsigned integer field (anything written as ":fldname %u") */ #define READ_UINT_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ local_node->fldname = atoui(token) /* Read a signed integer field (anything written using INT64_FORMAT) */ #define READ_INT64_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ local_node->fldname = strtoi64(token, NULL, 10) /* Read an unsigned integer field (anything written using UINT64_FORMAT) */ #define READ_UINT64_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ local_node->fldname = strtou64(token, NULL, 10) /* Read a long integer field (anything written as ":fldname %ld") */ #define READ_LONG_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ local_node->fldname = atol(token) /* Read an OID field (don't hard-wire assumption that OID is same as uint) */ #define READ_OID_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ local_node->fldname = atooid(token) /* Read a char field (ie, one ascii character) */ #define READ_CHAR_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ /* avoid overhead of calling debackslash() for one char */ \ local_node->fldname = (length == 0) ? '\0' : (token[0] == '\\' ? token[1] : token[0]) /* Read an enumerated-type field that was written as an integer code */ #define READ_ENUM_FIELD(fldname, enumtype) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ local_node->fldname = (enumtype) atoi(token) /* Read a float field */ #define READ_FLOAT_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ local_node->fldname = atof(token) /* Read a boolean field */ #define READ_BOOL_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ local_node->fldname = strtobool(token) /* Read a character-string field */ #define READ_STRING_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ local_node->fldname = nullable_string(token, length) /* Read a parse location field (and possibly throw away the value) */ #ifdef DEBUG_NODE_TESTS_ENABLED #define READ_LOCATION_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ local_node->fldname = restore_location_fields ? atoi(token) : -1 #else #define READ_LOCATION_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ token = pg_strtok(&length); /* get field value */ \ (void) token; /* in case not used elsewhere */ \ local_node->fldname = -1 /* set field to "unknown" */ #endif /* Read a Node field */ #define READ_NODE_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ (void) token; /* in case not used elsewhere */ \ local_node->fldname = nodeRead(NULL, 0) /* Read a bitmapset field */ #define READ_BITMAPSET_FIELD(fldname) \ token = pg_strtok(&length); /* skip :fldname */ \ (void) token; /* in case not used elsewhere */ \ local_node->fldname = _readBitmapset() /* Read an attribute number array */ #define READ_ATTRNUMBER_ARRAY(fldname, len) \ token = pg_strtok(&length); /* skip :fldname */ \ local_node->fldname = readAttrNumberCols(len) /* Read an oid array */ #define READ_OID_ARRAY(fldname, len) \ token = pg_strtok(&length); /* skip :fldname */ \ local_node->fldname = readOidCols(len) /* Read an int array */ #define READ_INT_ARRAY(fldname, len) \ token = pg_strtok(&length); /* skip :fldname */ \ local_node->fldname = readIntCols(len) /* Read a bool array */ #define READ_BOOL_ARRAY(fldname, len) \ token = pg_strtok(&length); /* skip :fldname */ \ local_node->fldname = readBoolCols(len) /* Routine exit */ #define READ_DONE() \ return local_node /* * NOTE: use atoi() to read values written with %d, or atoui() to read * values written with %u in outfuncs.c. An exception is OID values, * for which use atooid(). (As of 7.1, outfuncs.c writes OIDs as %u, * but this will probably change in the future.) */ #define atoui(x) ((unsigned int) strtoul((x), NULL, 10)) #define strtobool(x) ((*(x) == 't') ? true : false) static char * nullable_string(const char *token, int length) { /* outToken emits <> for NULL, and pg_strtok makes that an empty string */ if (length == 0) return NULL; /* outToken emits "" for empty string */ if (length == 2 && token[0] == '"' && token[1] == '"') return pstrdup(""); /* otherwise, we must remove protective backslashes added by outToken */ return debackslash(token, length); } /* * _readBitmapset * * Note: this code is used in contexts where we know that a Bitmapset * is expected. There is equivalent code in nodeRead() that can read a * Bitmapset when we come across one in other contexts. */ static Bitmapset * _readBitmapset(void) { Bitmapset *result = NULL; READ_TEMP_LOCALS(); token = pg_strtok(&length); if (token == NULL) elog(ERROR, "incomplete Bitmapset structure"); if (length != 1 || token[0] != '(') elog(ERROR, "unrecognized token: \"%.*s\"", length, token); token = pg_strtok(&length); if (token == NULL) elog(ERROR, "incomplete Bitmapset structure"); if (length != 1 || token[0] != 'b') elog(ERROR, "unrecognized token: \"%.*s\"", length, token); for (;;) { int val; char *endptr; token = pg_strtok(&length); if (token == NULL) elog(ERROR, "unterminated Bitmapset structure"); if (length == 1 && token[0] == ')') break; val = (int) strtol(token, &endptr, 10); if (endptr != token + length) elog(ERROR, "unrecognized integer: \"%.*s\"", length, token); result = bms_add_member(result, val); } return result; } /* * We export this function for use by extensions that define extensible nodes. * That's somewhat historical, though, because calling nodeRead() will work. */ Bitmapset * readBitmapset(void) { return _readBitmapset(); } #include "readfuncs.funcs.c" /* * Support functions for nodes with custom_read_write attribute or * special_read_write attribute */ static Const * _readConst(void) { READ_LOCALS(Const); READ_OID_FIELD(consttype); READ_INT_FIELD(consttypmod); READ_OID_FIELD(constcollid); READ_INT_FIELD(constlen); READ_BOOL_FIELD(constbyval); READ_BOOL_FIELD(constisnull); READ_LOCATION_FIELD(location); token = pg_strtok(&length); /* skip :constvalue */ if (local_node->constisnull) token = pg_strtok(&length); /* skip "<>" */ else local_node->constvalue = readDatum(local_node->constbyval); READ_DONE(); } static BoolExpr * _readBoolExpr(void) { READ_LOCALS(BoolExpr); /* do-it-yourself enum representation */ token = pg_strtok(&length); /* skip :boolop */ token = pg_strtok(&length); /* get field value */ if (length == 3 && strncmp(token, "and", 3) == 0) local_node->boolop = AND_EXPR; else if (length == 2 && strncmp(token, "or", 2) == 0) local_node->boolop = OR_EXPR; else if (length == 3 && strncmp(token, "not", 3) == 0) local_node->boolop = NOT_EXPR; else elog(ERROR, "unrecognized boolop \"%.*s\"", length, token); READ_NODE_FIELD(args); READ_LOCATION_FIELD(location); READ_DONE(); } static A_Const * _readA_Const(void) { READ_LOCALS(A_Const); /* We expect either NULL or :val here */ token = pg_strtok(&length); if (length == 4 && strncmp(token, "NULL", 4) == 0) local_node->isnull = true; else { union ValUnion *tmp = nodeRead(NULL, 0); /* To forestall valgrind complaints, copy only the valid data */ switch (nodeTag(tmp)) { case T_Integer: memcpy(&local_node->val, tmp, sizeof(Integer)); break; case T_Float: memcpy(&local_node->val, tmp, sizeof(Float)); break; case T_Boolean: memcpy(&local_node->val, tmp, sizeof(Boolean)); break; case T_String: memcpy(&local_node->val, tmp, sizeof(String)); break; case T_BitString: memcpy(&local_node->val, tmp, sizeof(BitString)); break; default: elog(ERROR, "unrecognized node type: %d", (int) nodeTag(tmp)); break; } } READ_LOCATION_FIELD(location); READ_DONE(); } static RangeTblEntry * _readRangeTblEntry(void) { READ_LOCALS(RangeTblEntry); READ_NODE_FIELD(alias); READ_NODE_FIELD(eref); READ_ENUM_FIELD(rtekind, RTEKind); switch (local_node->rtekind) { case RTE_RELATION: READ_OID_FIELD(relid); READ_BOOL_FIELD(inh); READ_CHAR_FIELD(relkind); READ_INT_FIELD(rellockmode); READ_UINT_FIELD(perminfoindex); READ_NODE_FIELD(tablesample); break; case RTE_SUBQUERY: READ_NODE_FIELD(subquery); READ_BOOL_FIELD(security_barrier); /* we re-use these RELATION fields, too: */ READ_OID_FIELD(relid); READ_BOOL_FIELD(inh); READ_CHAR_FIELD(relkind); READ_INT_FIELD(rellockmode); READ_UINT_FIELD(perminfoindex); break; case RTE_JOIN: READ_ENUM_FIELD(jointype, JoinType); READ_INT_FIELD(joinmergedcols); READ_NODE_FIELD(joinaliasvars); READ_NODE_FIELD(joinleftcols); READ_NODE_FIELD(joinrightcols); READ_NODE_FIELD(join_using_alias); break; case RTE_FUNCTION: READ_NODE_FIELD(functions); READ_BOOL_FIELD(funcordinality); break; case RTE_TABLEFUNC: READ_NODE_FIELD(tablefunc); /* The RTE must have a copy of the column type info, if any */ if (local_node->tablefunc) { TableFunc *tf = local_node->tablefunc; local_node->coltypes = tf->coltypes; local_node->coltypmods = tf->coltypmods; local_node->colcollations = tf->colcollations; } break; case RTE_VALUES: READ_NODE_FIELD(values_lists); READ_NODE_FIELD(coltypes); READ_NODE_FIELD(coltypmods); READ_NODE_FIELD(colcollations); break; case RTE_CTE: READ_STRING_FIELD(ctename); READ_UINT_FIELD(ctelevelsup); READ_BOOL_FIELD(self_reference); READ_NODE_FIELD(coltypes); READ_NODE_FIELD(coltypmods); READ_NODE_FIELD(colcollations); break; case RTE_NAMEDTUPLESTORE: READ_STRING_FIELD(enrname); READ_FLOAT_FIELD(enrtuples); READ_NODE_FIELD(coltypes); READ_NODE_FIELD(coltypmods); READ_NODE_FIELD(colcollations); /* we re-use these RELATION fields, too: */ READ_OID_FIELD(relid); break; case RTE_RESULT: /* no extra fields */ break; case RTE_GROUP: READ_NODE_FIELD(groupexprs); break; default: elog(ERROR, "unrecognized RTE kind: %d", (int) local_node->rtekind); break; } READ_BOOL_FIELD(lateral); READ_BOOL_FIELD(inFromCl); READ_NODE_FIELD(securityQuals); READ_DONE(); } static A_Expr * _readA_Expr(void) { READ_LOCALS(A_Expr); token = pg_strtok(&length); if (length == 3 && strncmp(token, "ANY", 3) == 0) { local_node->kind = AEXPR_OP_ANY; READ_NODE_FIELD(name); } else if (length == 3 && strncmp(token, "ALL", 3) == 0) { local_node->kind = AEXPR_OP_ALL; READ_NODE_FIELD(name); } else if (length == 8 && strncmp(token, "DISTINCT", 8) == 0) { local_node->kind = AEXPR_DISTINCT; READ_NODE_FIELD(name); } else if (length == 12 && strncmp(token, "NOT_DISTINCT", 12) == 0) { local_node->kind = AEXPR_NOT_DISTINCT; READ_NODE_FIELD(name); } else if (length == 6 && strncmp(token, "NULLIF", 6) == 0) { local_node->kind = AEXPR_NULLIF; READ_NODE_FIELD(name); } else if (length == 2 && strncmp(token, "IN", 2) == 0) { local_node->kind = AEXPR_IN; READ_NODE_FIELD(name); } else if (length == 4 && strncmp(token, "LIKE", 4) == 0) { local_node->kind = AEXPR_LIKE; READ_NODE_FIELD(name); } else if (length == 5 && strncmp(token, "ILIKE", 5) == 0) { local_node->kind = AEXPR_ILIKE; READ_NODE_FIELD(name); } else if (length == 7 && strncmp(token, "SIMILAR", 7) == 0) { local_node->kind = AEXPR_SIMILAR; READ_NODE_FIELD(name); } else if (length == 7 && strncmp(token, "BETWEEN", 7) == 0) { local_node->kind = AEXPR_BETWEEN; READ_NODE_FIELD(name); } else if (length == 11 && strncmp(token, "NOT_BETWEEN", 11) == 0) { local_node->kind = AEXPR_NOT_BETWEEN; READ_NODE_FIELD(name); } else if (length == 11 && strncmp(token, "BETWEEN_SYM", 11) == 0) { local_node->kind = AEXPR_BETWEEN_SYM; READ_NODE_FIELD(name); } else if (length == 15 && strncmp(token, "NOT_BETWEEN_SYM", 15) == 0) { local_node->kind = AEXPR_NOT_BETWEEN_SYM; READ_NODE_FIELD(name); } else if (length == 5 && strncmp(token, ":name", 5) == 0) { local_node->kind = AEXPR_OP; local_node->name = nodeRead(NULL, 0); } else elog(ERROR, "unrecognized A_Expr kind: \"%.*s\"", length, token); READ_NODE_FIELD(lexpr); READ_NODE_FIELD(rexpr); READ_LOCATION_FIELD(rexpr_list_start); READ_LOCATION_FIELD(rexpr_list_end); READ_LOCATION_FIELD(location); READ_DONE(); } static ExtensibleNode * _readExtensibleNode(void) { const ExtensibleNodeMethods *methods; ExtensibleNode *local_node; const char *extnodename; READ_TEMP_LOCALS(); token = pg_strtok(&length); /* skip :extnodename */ token = pg_strtok(&length); /* get extnodename */ extnodename = nullable_string(token, length); if (!extnodename) elog(ERROR, "extnodename has to be supplied"); methods = GetExtensibleNodeMethods(extnodename, false); local_node = (ExtensibleNode *) newNode(methods->node_size, T_ExtensibleNode); local_node->extnodename = extnodename; /* deserialize the private fields */ methods->nodeRead(local_node); READ_DONE(); } /* * parseNodeString * * Given a character string representing a node tree, parseNodeString creates * the internal node structure. * * The string to be read must already have been loaded into pg_strtok(). */ Node * parseNodeString(void) { READ_TEMP_LOCALS(); /* Guard against stack overflow due to overly complex expressions */ check_stack_depth(); token = pg_strtok(&length); #define MATCH(tokname, namelen) \ (length == namelen && memcmp(token, tokname, namelen) == 0) #include "readfuncs.switch.c" elog(ERROR, "badly formatted node string \"%.32s\"...", token); return NULL; /* keep compiler quiet */ } /* * readDatum * * Given a string representation of a constant, recreate the appropriate * Datum. The string representation embeds length info, but not byValue, * so we must be told that. */ Datum readDatum(bool typbyval) { Size length, i; int tokenLength; const char *token; Datum res; char *s; /* * read the actual length of the value */ token = pg_strtok(&tokenLength); length = atoui(token); token = pg_strtok(&tokenLength); /* read the '[' */ if (token == NULL || token[0] != '[') elog(ERROR, "expected \"[\" to start datum, but got \"%s\"; length = %zu", token ? token : "[NULL]", length); if (typbyval) { if (length > (Size) sizeof(Datum)) elog(ERROR, "byval datum but length = %zu", length); res = (Datum) 0; s = (char *) (&res); for (i = 0; i < (Size) sizeof(Datum); i++) { token = pg_strtok(&tokenLength); s[i] = (char) atoi(token); } } else if (length <= 0) res = (Datum) NULL; else { s = (char *) palloc(length); for (i = 0; i < length; i++) { token = pg_strtok(&tokenLength); s[i] = (char) atoi(token); } res = PointerGetDatum(s); } token = pg_strtok(&tokenLength); /* read the ']' */ if (token == NULL || token[0] != ']') elog(ERROR, "expected \"]\" to end datum, but got \"%s\"; length = %zu", token ? token : "[NULL]", length); return res; } /* * common implementation for scalar-array-reading functions * * The data format is either "<>" for a NULL pointer (in which case numCols * is ignored) or "(item item item)" where the number of items must equal * numCols. The convfunc must be okay with stopping at whitespace or a * right parenthesis, since pg_strtok won't null-terminate the token. */ #define READ_SCALAR_ARRAY(fnname, datatype, convfunc) \ datatype * \ fnname(int numCols) \ { \ datatype *vals; \ READ_TEMP_LOCALS(); \ token = pg_strtok(&length); \ if (token == NULL) \ elog(ERROR, "incomplete scalar array"); \ if (length == 0) \ return NULL; /* it was "<>", so return NULL pointer */ \ if (length != 1 || token[0] != '(') \ elog(ERROR, "unrecognized token: \"%.*s\"", length, token); \ vals = (datatype *) palloc(numCols * sizeof(datatype)); \ for (int i = 0; i < numCols; i++) \ { \ token = pg_strtok(&length); \ if (token == NULL || token[0] == ')') \ elog(ERROR, "incomplete scalar array"); \ vals[i] = convfunc(token); \ } \ token = pg_strtok(&length); \ if (token == NULL || length != 1 || token[0] != ')') \ elog(ERROR, "incomplete scalar array"); \ return vals; \ } /* * Note: these functions are exported in nodes.h for possible use by * extensions, so don't mess too much with their names or API. */ READ_SCALAR_ARRAY(readAttrNumberCols, int16, atoi) READ_SCALAR_ARRAY(readOidCols, Oid, atooid) /* outfuncs.c has writeIndexCols, but we don't yet need that here */ /* READ_SCALAR_ARRAY(readIndexCols, Index, atoui) */ READ_SCALAR_ARRAY(readIntCols, int, atoi) READ_SCALAR_ARRAY(readBoolCols, bool, strtobool)