diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c index 8ea5c9ce1b..fed97907b2 100644 --- a/src/backend/nodes/outfuncs.c +++ b/src/backend/nodes/outfuncs.c @@ -5,7 +5,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.136 2001/01/07 01:08:47 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.137 2001/01/08 00:31:43 tgl Exp $ * * NOTES * Every (plan) node in POSTGRES has an associated "out" routine which @@ -27,6 +27,8 @@ #include "utils/datum.h" +#define booltostr(x) ((x) ? "true" : "false") + static void _outDatum(StringInfo str, Datum value, int typlen, bool typbyval); static void _outNode(StringInfo str, void *obj); @@ -56,7 +58,8 @@ _outToken(StringInfo str, char *s) *s == '\"' || *s == '@' || isdigit((unsigned char) *s) || - (*s == '-' && isdigit((unsigned char) s[1]))) + ((*s == '+' || *s == '-') && + (isdigit((unsigned char) s[1]) || s[1] == '.'))) appendStringInfoChar(str, '\\'); while (*s) { @@ -84,6 +87,21 @@ _outIntList(StringInfo str, List *list) appendStringInfoChar(str, ')'); } +/* + * _outOidList - + * converts a List of OIDs + */ +static void +_outOidList(StringInfo str, List *list) +{ + List *l; + + appendStringInfoChar(str, '('); + foreach(l, list) + appendStringInfo(str, " %u", (Oid) lfirsti(l)); + appendStringInfoChar(str, ')'); +} + static void _outCreateStmt(StringInfo str, CreateStmt *node) { @@ -91,7 +109,7 @@ _outCreateStmt(StringInfo str, CreateStmt *node) _outToken(str, node->relname); appendStringInfo(str, " :istemp %s ", - node->istemp ? "true" : "false"); + booltostr(node->istemp)); appendStringInfo(str, " :columns "); _outNode(str, node->tableElts); @@ -125,8 +143,8 @@ _outIndexStmt(StringInfo str, IndexStmt *node) _outNode(str, node->rangetable); appendStringInfo(str, " :unique %s :primary %s ", - node->unique ? "true" : "false", - node->primary ? "true" : "false"); + booltostr(node->unique), + booltostr(node->primary)); } static void @@ -145,8 +163,8 @@ _outFuncCall(StringInfo str, FuncCall *node) appendStringInfo(str, " :args "); _outNode(str, node->args); appendStringInfo(str, " :agg_star %s :agg_distinct %s ", - node->agg_star ? "true" : "false", - node->agg_distinct ? "true" : "false"); + booltostr(node->agg_star), + booltostr(node->agg_distinct)); } static void @@ -157,8 +175,8 @@ _outColumnDef(StringInfo str, ColumnDef *node) appendStringInfo(str, " :typename "); _outNode(str, node->typename); appendStringInfo(str, " :is_not_null %s :is_sequence %s :raw_default ", - node->is_not_null ? "true" : "false", - node->is_sequence ? "true" : "false"); + booltostr(node->is_not_null), + booltostr(node->is_sequence)); _outNode(str, node->raw_default); appendStringInfo(str, " :cooked_default "); _outToken(str, node->cooked_default); @@ -172,8 +190,8 @@ _outTypeName(StringInfo str, TypeName *node) appendStringInfo(str, " TYPENAME :name "); _outToken(str, node->name); appendStringInfo(str, " :timezone %s :setof %s typmod %d :arrayBounds ", - node->timezone ? "true" : "false", - node->setof ? "true" : "false", + booltostr(node->timezone), + booltostr(node->setof), node->typmod); _outNode(str, node->arrayBounds); } @@ -245,11 +263,11 @@ _outQuery(StringInfo str, Query *node) appendStringInfo(str, " :isPortal %s :isBinary %s :isTemp %s" " :hasAggs %s :hasSubLinks %s :rtable ", - node->isPortal ? "true" : "false", - node->isBinary ? "true" : "false", - node->isTemp ? "true" : "false", - node->hasAggs ? "true" : "false", - node->hasSubLinks ? "true" : "false"); + booltostr(node->isPortal), + booltostr(node->isBinary), + booltostr(node->isTemp), + booltostr(node->hasAggs), + booltostr(node->hasSubLinks)); _outNode(str, node->rtable); appendStringInfo(str, " :jointree "); @@ -289,14 +307,14 @@ _outQuery(StringInfo str, Query *node) static void _outSortClause(StringInfo str, SortClause *node) { - appendStringInfo(str, " SORTCLAUSE :tleSortGroupRef %d :sortop %u ", + appendStringInfo(str, " SORTCLAUSE :tleSortGroupRef %u :sortop %u ", node->tleSortGroupRef, node->sortop); } static void _outGroupClause(StringInfo str, GroupClause *node) { - appendStringInfo(str, " GROUPCLAUSE :tleSortGroupRef %d :sortop %u ", + appendStringInfo(str, " GROUPCLAUSE :tleSortGroupRef %u :sortop %u ", node->tleSortGroupRef, node->sortop); } @@ -305,12 +323,12 @@ _outSetOperationStmt(StringInfo str, SetOperationStmt *node) { appendStringInfo(str, " SETOPERATIONSTMT :op %d :all %s :larg ", (int) node->op, - node->all ? "true" : "false"); + booltostr(node->all)); _outNode(str, node->larg); appendStringInfo(str, " :rarg "); _outNode(str, node->rarg); appendStringInfo(str, " :colTypes "); - _outIntList(str, node->colTypes); + _outOidList(str, node->colTypes); } /* @@ -384,7 +402,7 @@ _outAppend(StringInfo str, Append *node) _outNode(str, node->appendplans); appendStringInfo(str, " :isTarget %s ", - node->isTarget ? "true" : "false"); + booltostr(node->isTarget)); } /* @@ -453,7 +471,7 @@ _outSubPlan(StringInfo str, SubPlan *node) appendStringInfo(str, " SUBPLAN :plan "); _outNode(str, node->plan); - appendStringInfo(str, " :planid %u :rtable ", node->plan_id); + appendStringInfo(str, " :planid %d :rtable ", node->plan_id); _outNode(str, node->rtable); appendStringInfo(str, " :setprm "); @@ -500,7 +518,7 @@ _outIndexScan(StringInfo str, IndexScan *node) _outPlanInfo(str, (Plan *) node); appendStringInfo(str, " :scanrelid %u :indxid ", node->scan.scanrelid); - _outIntList(str, node->indxid); + _outOidList(str, node->indxid); appendStringInfo(str, " :indxqual "); _outNode(str, node->indxqual); @@ -578,7 +596,7 @@ _outGroup(StringInfo str, Group *node) /* the actual Group fields */ appendStringInfo(str, " :numCols %d :tuplePerGroup %s ", node->numCols, - node->tuplePerGroup ? "true" : "false"); + booltostr(node->tuplePerGroup)); } static void @@ -654,11 +672,11 @@ _outResdom(StringInfo str, Resdom *node) node->restype, node->restypmod); _outToken(str, node->resname); - appendStringInfo(str, " :reskey %d :reskeyop %u :ressortgroupref %d :resjunk %s ", + appendStringInfo(str, " :reskey %u :reskeyop %u :ressortgroupref %u :resjunk %s ", node->reskey, node->reskeyop, node->ressortgroupref, - node->resjunk ? "true" : "false"); + booltostr(node->resjunk)); } static void @@ -667,7 +685,7 @@ _outFjoin(StringInfo str, Fjoin *node) int i; appendStringInfo(str, " FJOIN :initialized %s :nNodes %d ", - node->fj_initialized ? "true" : "false", + booltostr(node->fj_initialized), node->fj_nNodes); appendStringInfo(str, " :innerNode "); @@ -677,7 +695,8 @@ _outFjoin(StringInfo str, Fjoin *node) node->fj_results); for (i = 0; i < node->fj_nNodes; i++) - appendStringInfo(str, (node->fj_alwaysDone[i]) ? "true" : "false"); + appendStringInfo(str, + booltostr(node->fj_alwaysDone[i])); } /* @@ -728,13 +747,13 @@ static void _outVar(StringInfo str, Var *node) { appendStringInfo(str, - " VAR :varno %d :varattno %d :vartype %u :vartypmod %d ", + " VAR :varno %u :varattno %d :vartype %u :vartypmod %d ", node->varno, node->varattno, node->vartype, node->vartypmod); - appendStringInfo(str, " :varlevelsup %u :varnoold %d :varoattno %d", + appendStringInfo(str, " :varlevelsup %u :varnoold %u :varoattno %d", node->varlevelsup, node->varnoold, node->varoattno); @@ -751,8 +770,8 @@ _outConst(StringInfo str, Const *node) " :constisnull %s :constvalue ", node->consttype, node->constlen, - node->constbyval ? "true" : "false", - node->constisnull ? "true" : "false"); + booltostr(node->constbyval), + booltostr(node->constisnull)); if (node->constisnull) appendStringInfo(str, "<>"); @@ -773,8 +792,8 @@ _outAggref(StringInfo str, Aggref *node) _outNode(str, node->target); appendStringInfo(str, " :aggstar %s :aggdistinct %s ", - node->aggstar ? "true" : "false", - node->aggdistinct ? "true" : "false"); + booltostr(node->aggstar), + booltostr(node->aggdistinct)); /* aggno is not dumped */ } @@ -787,7 +806,7 @@ _outSubLink(StringInfo str, SubLink *node) appendStringInfo(str, " SUBLINK :subLinkType %d :useor %s :lefthand ", node->subLinkType, - node->useor ? "true" : "false"); + booltostr(node->useor)); _outNode(str, node->lefthand); appendStringInfo(str, " :oper "); @@ -916,7 +935,7 @@ _outJoinExpr(StringInfo str, JoinExpr *node) { appendStringInfo(str, " JOINEXPR :jointype %d :isNatural %s :larg ", (int) node->jointype, - node->isNatural ? "true" : "false"); + booltostr(node->isNatural)); _outNode(str, node->larg); appendStringInfo(str, " :rarg "); _outNode(str, node->rarg); @@ -955,9 +974,9 @@ _outRelOptInfo(StringInfo str, RelOptInfo *node) _outNode(str, node->cheapest_total_path); appendStringInfo(str, " :pruneable %s :issubquery %s :indexed %s :pages %ld :tuples %.0f :subplan ", - node->pruneable ? "true" : "false", - node->issubquery ? "true" : "false", - node->indexed ? "true" : "false", + booltostr(node->pruneable), + booltostr(node->issubquery), + booltostr(node->indexed), node->pages, node->tuples); _outNode(str, node->subplan); @@ -1010,10 +1029,10 @@ _outRangeTblEntry(StringInfo str, RangeTblEntry *node) _outNode(str, node->eref); appendStringInfo(str, " :inh %s :inFromCl %s :checkForRead %s" " :checkForWrite %s :checkAsUser %u", - node->inh ? "true" : "false", - node->inFromCl ? "true" : "false", - node->checkForRead ? "true" : "false", - node->checkForWrite ? "true" : "false", + booltostr(node->inh), + booltostr(node->inFromCl), + booltostr(node->checkForRead), + booltostr(node->checkForWrite), node->checkAsUser); } @@ -1045,7 +1064,7 @@ _outIndexPath(StringInfo str, IndexPath *node) _outNode(str, node->path.pathkeys); appendStringInfo(str, " :indexid "); - _outIntList(str, node->indexid); + _outOidList(str, node->indexid); appendStringInfo(str, " :indexqual "); _outNode(str, node->indexqual); @@ -1055,7 +1074,7 @@ _outIndexPath(StringInfo str, IndexPath *node) _outIntList(str, node->joinrelids); appendStringInfo(str, " :alljoinquals %s :rows %.2f ", - node->alljoinquals ? "true" : "false", + booltostr(node->alljoinquals), node->rows); } @@ -1192,7 +1211,7 @@ _outRestrictInfo(StringInfo str, RestrictInfo *node) _outNode(str, node->clause); appendStringInfo(str, " :ispusheddown %s :subclauseindices ", - node->ispusheddown ? "true" : "false"); + booltostr(node->ispusheddown)); _outNode(str, node->subclauseindices); appendStringInfo(str, " :mergejoinoperator %u ", node->mergejoinoperator); @@ -1313,7 +1332,7 @@ _outValue(StringInfo str, Value *value) { switch (value->type) { - case T_Integer: + case T_Integer: appendStringInfo(str, " %ld ", value->val.ival); break; case T_Float: diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c index 1aa0bc3377..685fbd7eb2 100644 --- a/src/backend/nodes/readfuncs.c +++ b/src/backend/nodes/readfuncs.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.103 2001/01/07 01:08:47 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.104 2001/01/08 00:31:43 tgl Exp $ * * NOTES * Most of the read functions for plan nodes are tested. (In fact, they @@ -32,6 +32,22 @@ #include "nodes/relation.h" +/* + * 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 atooid(x) ((Oid) strtoul((x), NULL, 10)) + +#define strtobool(x) ((*(x) == 't') ? true : false) + +#define nullable_string(token,length) \ + ((length) == 0 ? (char *) NULL : debackslash(token, length)) + + static Datum readDatum(bool typbyval); @@ -40,6 +56,7 @@ static Datum readDatum(bool typbyval); * ---------------- */ +/* Convert Value list returned by nodeRead into list of integers */ static List * toIntList(List *list) { @@ -47,8 +64,44 @@ toIntList(List *list) foreach(l, list) { - /* ugly manipulation, should probably free the Value node too */ - lfirst(l) = (void *) intVal(lfirst(l)); + Value *v = (Value *) lfirst(l); + + if (!IsA(v, Integer)) + elog(ERROR, "toIntList: unexpected datatype"); + lfirsti(l) = intVal(v); + pfree(v); + } + return list; +} + +/* Convert Value list returned by nodeRead into list of OIDs */ +static List * +toOidList(List *list) +{ + List *l; + + foreach(l, list) + { + Value *v = (Value *) lfirst(l); + + /* + * This is a bit tricky because OID is unsigned, and so nodeRead + * might have concluded the value doesn't fit in an integer. + * Must cope with T_Float as well. + */ + if (IsA(v, Integer)) + { + lfirsti(l) = (Oid) intVal(v); + pfree(v); + } + else if (IsA(v, Float)) + { + lfirsti(l) = atooid(strVal(v)); + pfree(strVal(v)); + pfree(v); + } + else + elog(ERROR, "toOidList: unexpected datatype"); } return list; } @@ -93,30 +146,27 @@ _readQuery(void) token = pg_strtok(&length); /* skip :into */ token = pg_strtok(&length); /* get into */ - if (length == 0) - local_node->into = NULL; - else - local_node->into = debackslash(token, length); + local_node->into = nullable_string(token, length); token = pg_strtok(&length); /* skip :isPortal */ token = pg_strtok(&length); /* get isPortal */ - local_node->isPortal = (token[0] == 't') ? true : false; + local_node->isPortal = strtobool(token); token = pg_strtok(&length); /* skip :isBinary */ token = pg_strtok(&length); /* get isBinary */ - local_node->isBinary = (token[0] == 't') ? true : false; + local_node->isBinary = strtobool(token); token = pg_strtok(&length); /* skip :isTemp */ token = pg_strtok(&length); /* get isTemp */ - local_node->isTemp = (token[0] == 't') ? true : false; + local_node->isTemp = strtobool(token); token = pg_strtok(&length); /* skip the :hasAggs */ token = pg_strtok(&length); /* get hasAggs */ - local_node->hasAggs = (token[0] == 't') ? true : false; + local_node->hasAggs = strtobool(token); token = pg_strtok(&length); /* skip the :hasSubLinks */ token = pg_strtok(&length); /* get hasSubLinks */ - local_node->hasSubLinks = (token[0] == 't') ? true : false; + local_node->hasSubLinks = strtobool(token); token = pg_strtok(&length); /* skip :rtable */ local_node->rtable = nodeRead(true); @@ -172,11 +222,11 @@ _readSortClause(void) token = pg_strtok(&length); /* skip :tleSortGroupRef */ token = pg_strtok(&length); /* get tleSortGroupRef */ - local_node->tleSortGroupRef = strtoul(token, NULL, 10); + local_node->tleSortGroupRef = atoui(token); token = pg_strtok(&length); /* skip :sortop */ token = pg_strtok(&length); /* get sortop */ - local_node->sortop = strtoul(token, NULL, 10); + local_node->sortop = atooid(token); return local_node; } @@ -196,11 +246,11 @@ _readGroupClause(void) token = pg_strtok(&length); /* skip :tleSortGroupRef */ token = pg_strtok(&length); /* get tleSortGroupRef */ - local_node->tleSortGroupRef = strtoul(token, NULL, 10); + local_node->tleSortGroupRef = atoui(token); token = pg_strtok(&length); /* skip :sortop */ token = pg_strtok(&length); /* get sortop */ - local_node->sortop = strtoul(token, NULL, 10); + local_node->sortop = atooid(token); return local_node; } @@ -224,7 +274,7 @@ _readSetOperationStmt(void) token = pg_strtok(&length); /* eat :all */ token = pg_strtok(&length); /* get all */ - local_node->all = (token[0] == 't') ? true : false; + local_node->all = strtobool(token); token = pg_strtok(&length); /* eat :larg */ local_node->larg = nodeRead(true); /* get larg */ @@ -233,7 +283,7 @@ _readSetOperationStmt(void) local_node->rarg = nodeRead(true); /* get rarg */ token = pg_strtok(&length); /* eat :colTypes */ - local_node->colTypes = toIntList(nodeRead(true)); + local_node->colTypes = toOidList(nodeRead(true)); return local_node; } @@ -345,7 +395,7 @@ _readAppend(void) token = pg_strtok(&length); /* eat :isTarget */ token = pg_strtok(&length); /* get isTarget */ - local_node->isTarget = (token[0] == 't') ? true : false; + local_node->isTarget = strtobool(token); return local_node; } @@ -453,7 +503,7 @@ _readHashJoin(void) token = pg_strtok(&length); /* eat :hashjoinop */ token = pg_strtok(&length); /* get hashjoinop */ - local_node->hashjoinop = strtoul(token, NULL, 10); + local_node->hashjoinop = atooid(token); return local_node; } @@ -476,7 +526,7 @@ _getScan(Scan *node) token = pg_strtok(&length); /* eat :scanrelid */ token = pg_strtok(&length); /* get scanrelid */ - node->scanrelid = strtoul(token, NULL, 10); + node->scanrelid = atoui(token); } /* ---------------- @@ -533,7 +583,7 @@ _readIndexScan(void) _getScan((Scan *) local_node); token = pg_strtok(&length); /* eat :indxid */ - local_node->indxid = toIntList(nodeRead(true)); /* now read it */ + local_node->indxid = toOidList(nodeRead(true)); /* now read it */ token = pg_strtok(&length); /* eat :indxqual */ local_node->indxqual = nodeRead(true); /* now read it */ @@ -681,7 +731,7 @@ _readResdom(void) token = pg_strtok(&length); /* eat :restype */ token = pg_strtok(&length); /* get restype */ - local_node->restype = (Oid) atol(token); + local_node->restype = atooid(token); token = pg_strtok(&length); /* eat :restypmod */ token = pg_strtok(&length); /* get restypmod */ @@ -689,26 +739,23 @@ _readResdom(void) token = pg_strtok(&length); /* eat :resname */ token = pg_strtok(&length); /* get the name */ - if (length == 0) - local_node->resname = NULL; - else - local_node->resname = debackslash(token, length); + local_node->resname = nullable_string(token, length); token = pg_strtok(&length); /* eat :reskey */ token = pg_strtok(&length); /* get reskey */ - local_node->reskey = strtoul(token, NULL, 10); + local_node->reskey = atoui(token); token = pg_strtok(&length); /* eat :reskeyop */ token = pg_strtok(&length); /* get reskeyop */ - local_node->reskeyop = (Oid) atol(token); + local_node->reskeyop = atooid(token); token = pg_strtok(&length); /* eat :ressortgroupref */ token = pg_strtok(&length); /* get ressortgroupref */ - local_node->ressortgroupref = strtoul(token, NULL, 10); + local_node->ressortgroupref = atoui(token); token = pg_strtok(&length); /* eat :resjunk */ token = pg_strtok(&length); /* get resjunk */ - local_node->resjunk = (token[0] == 't') ? true : false; + local_node->resjunk = strtobool(token); return local_node; } @@ -730,24 +777,24 @@ _readExpr(void) token = pg_strtok(&length); /* eat :typeOid */ token = pg_strtok(&length); /* get typeOid */ - local_node->typeOid = (Oid) atol(token); + local_node->typeOid = atooid(token); token = pg_strtok(&length); /* eat :opType */ token = pg_strtok(&length); /* get opType */ - if (!strncmp(token, "op", 2)) + if (strncmp(token, "op", 2) == 0) local_node->opType = OP_EXPR; - else if (!strncmp(token, "func", 4)) + else if (strncmp(token, "func", 4) == 0) local_node->opType = FUNC_EXPR; - else if (!strncmp(token, "or", 2)) + else if (strncmp(token, "or", 2) == 0) local_node->opType = OR_EXPR; - else if (!strncmp(token, "and", 3)) + else if (strncmp(token, "and", 3) == 0) local_node->opType = AND_EXPR; - else if (!strncmp(token, "not", 3)) + else if (strncmp(token, "not", 3) == 0) local_node->opType = NOT_EXPR; - else if (!strncmp(token, "subp", 4)) + else if (strncmp(token, "subp", 4) == 0) local_node->opType = SUBPLAN_EXPR; else - elog(ERROR, "_readExpr: unknown opType \"%.10s\"", token); + elog(ERROR, "_readExpr: unknown opType \"%.*s\"", length, token); token = pg_strtok(&length); /* eat :oper */ local_node->oper = nodeRead(true); @@ -775,7 +822,7 @@ _readCaseExpr(void) token = pg_strtok(&length); /* eat :casetype */ token = pg_strtok(&length); /* get casetype */ - local_node->casetype = (Oid) atol(token); + local_node->casetype = atooid(token); token = pg_strtok(&length); /* eat :arg */ local_node->arg = nodeRead(true); @@ -828,7 +875,7 @@ _readVar(void) token = pg_strtok(&length); /* eat :varno */ token = pg_strtok(&length); /* get varno */ - local_node->varno = strtoul(token, NULL, 10); + local_node->varno = atoui(token); token = pg_strtok(&length); /* eat :varattno */ token = pg_strtok(&length); /* get varattno */ @@ -836,7 +883,7 @@ _readVar(void) token = pg_strtok(&length); /* eat :vartype */ token = pg_strtok(&length); /* get vartype */ - local_node->vartype = (Oid) atol(token); + local_node->vartype = atooid(token); token = pg_strtok(&length); /* eat :vartypmod */ token = pg_strtok(&length); /* get vartypmod */ @@ -844,11 +891,11 @@ _readVar(void) token = pg_strtok(&length); /* eat :varlevelsup */ token = pg_strtok(&length); /* get varlevelsup */ - local_node->varlevelsup = (Index) atoi(token); + local_node->varlevelsup = atoui(token); token = pg_strtok(&length); /* eat :varnoold */ token = pg_strtok(&length); /* get varnoold */ - local_node->varnoold = (Index) atoi(token); + local_node->varnoold = atoui(token); token = pg_strtok(&length); /* eat :varoattno */ token = pg_strtok(&length); /* eat :varoattno */ @@ -874,7 +921,7 @@ _readArrayRef(void) token = pg_strtok(&length); /* eat :refelemtype */ token = pg_strtok(&length); /* get refelemtype */ - local_node->refelemtype = strtoul(token, NULL, 10); + local_node->refelemtype = atooid(token); token = pg_strtok(&length); /* eat :refattrlength */ token = pg_strtok(&length); /* get refattrlength */ @@ -886,7 +933,7 @@ _readArrayRef(void) token = pg_strtok(&length); /* eat :refelembyval */ token = pg_strtok(&length); /* get refelembyval */ - local_node->refelembyval = (token[0] == 't') ? true : false; + local_node->refelembyval = strtobool(token); token = pg_strtok(&length); /* eat :refupperindex */ local_node->refupperindexpr = nodeRead(true); @@ -920,27 +967,19 @@ _readConst(void) token = pg_strtok(&length); /* get :consttype */ token = pg_strtok(&length); /* now read it */ - local_node->consttype = (Oid) atol(token); + local_node->consttype = atooid(token); token = pg_strtok(&length); /* get :constlen */ token = pg_strtok(&length); /* now read it */ - local_node->constlen = strtol(token, NULL, 10); + local_node->constlen = atoi(token); token = pg_strtok(&length); /* get :constbyval */ token = pg_strtok(&length); /* now read it */ - - if (!strncmp(token, "true", 4)) - local_node->constbyval = true; - else - local_node->constbyval = false; + local_node->constbyval = strtobool(token); token = pg_strtok(&length); /* get :constisnull */ token = pg_strtok(&length); /* now read it */ - - if (!strncmp(token, "true", 4)) - local_node->constisnull = true; - else - local_node->constisnull = false; + local_node->constisnull = strtobool(token); token = pg_strtok(&length); /* get :constvalue */ @@ -973,11 +1012,11 @@ _readFunc(void) token = pg_strtok(&length); /* get :funcid */ token = pg_strtok(&length); /* now read it */ - local_node->funcid = (Oid) atol(token); + local_node->funcid = atooid(token); token = pg_strtok(&length); /* get :functype */ token = pg_strtok(&length); /* now read it */ - local_node->functype = (Oid) atol(token); + local_node->functype = atooid(token); local_node->func_fcache = NULL; @@ -1001,15 +1040,15 @@ _readOper(void) token = pg_strtok(&length); /* get :opno */ token = pg_strtok(&length); /* now read it */ - local_node->opno = (Oid) atol(token); + local_node->opno = atooid(token); token = pg_strtok(&length); /* get :opid */ token = pg_strtok(&length); /* now read it */ - local_node->opid = (Oid) atol(token); + local_node->opid = atooid(token); token = pg_strtok(&length); /* get :opresulttype */ token = pg_strtok(&length); /* now read it */ - local_node->opresulttype = (Oid) atol(token); + local_node->opresulttype = atooid(token); local_node->op_fcache = NULL; @@ -1037,18 +1076,15 @@ _readParam(void) token = pg_strtok(&length); /* get :paramid */ token = pg_strtok(&length); /* now read it */ - local_node->paramid = atol(token); + local_node->paramid = atoi(token); token = pg_strtok(&length); /* get :paramname */ token = pg_strtok(&length); /* now read it */ - if (length == 0) - local_node->paramname = NULL; - else - local_node->paramname = debackslash(token, length); + local_node->paramname = nullable_string(token, length); token = pg_strtok(&length); /* get :paramtype */ token = pg_strtok(&length); /* now read it */ - local_node->paramtype = (Oid) atol(token); + local_node->paramtype = atooid(token); return local_node; } @@ -1074,22 +1110,22 @@ _readAggref(void) token = pg_strtok(&length); /* eat :basetype */ token = pg_strtok(&length); /* get basetype */ - local_node->basetype = (Oid) atol(token); + local_node->basetype = atooid(token); token = pg_strtok(&length); /* eat :aggtype */ token = pg_strtok(&length); /* get aggtype */ - local_node->aggtype = (Oid) atol(token); + local_node->aggtype = atooid(token); token = pg_strtok(&length); /* eat :target */ local_node->target = nodeRead(true); /* now read it */ token = pg_strtok(&length); /* eat :aggstar */ token = pg_strtok(&length); /* get aggstar */ - local_node->aggstar = (token[0] == 't') ? true : false; + local_node->aggstar = strtobool(token); token = pg_strtok(&length); /* eat :aggdistinct */ token = pg_strtok(&length); /* get aggdistinct */ - local_node->aggdistinct = (token[0] == 't') ? true : false; + local_node->aggdistinct = strtobool(token); return local_node; } @@ -1115,7 +1151,7 @@ _readSubLink(void) token = pg_strtok(&length); /* eat :useor */ token = pg_strtok(&length); /* get useor */ - local_node->useor = (token[0] == 't') ? true : false; + local_node->useor = strtobool(token); token = pg_strtok(&length); /* eat :lefthand */ local_node->lefthand = nodeRead(true); /* now read it */ @@ -1153,7 +1189,7 @@ _readFieldSelect(void) token = pg_strtok(&length); /* eat :resulttype */ token = pg_strtok(&length); /* get resulttype */ - local_node->resulttype = (Oid) atol(token); + local_node->resulttype = atooid(token); token = pg_strtok(&length); /* eat :resulttypmod */ token = pg_strtok(&length); /* get resulttypmod */ @@ -1182,7 +1218,7 @@ _readRelabelType(void) token = pg_strtok(&length); /* eat :resulttype */ token = pg_strtok(&length); /* get resulttype */ - local_node->resulttype = (Oid) atol(token); + local_node->resulttype = atooid(token); token = pg_strtok(&length); /* eat :resulttypmod */ token = pg_strtok(&length); /* get resulttypmod */ @@ -1257,7 +1293,7 @@ _readJoinExpr(void) token = pg_strtok(&length); /* eat :isNatural */ token = pg_strtok(&length); /* get :isNatural */ - local_node->isNatural = (token[0] == 't') ? true : false; + local_node->isNatural = strtobool(token); token = pg_strtok(&length); /* eat :larg */ local_node->larg = nodeRead(true); /* now read it */ @@ -1325,15 +1361,15 @@ _readRelOptInfo(void) token = pg_strtok(&length); /* eat :pruneable */ token = pg_strtok(&length); /* get :pruneable */ - local_node->pruneable = (token[0] == 't') ? true : false; + local_node->pruneable = strtobool(token); token = pg_strtok(&length); /* get :issubquery */ token = pg_strtok(&length); /* now read it */ - local_node->issubquery = (token[0] == 't') ? true : false; + local_node->issubquery = strtobool(token); token = pg_strtok(&length); /* get :indexed */ token = pg_strtok(&length); /* now read it */ - local_node->indexed = (token[0] == 't') ? true : false; + local_node->indexed = strtobool(token); token = pg_strtok(&length); /* get :pages */ token = pg_strtok(&length); /* now read it */ @@ -1421,14 +1457,11 @@ _readRangeTblEntry(void) token = pg_strtok(&length); /* eat :relname */ token = pg_strtok(&length); /* get :relname */ - if (length == 0) - local_node->relname = NULL; - else - local_node->relname = debackslash(token, length); + local_node->relname = nullable_string(token, length); token = pg_strtok(&length); /* eat :relid */ token = pg_strtok(&length); /* get :relid */ - local_node->relid = strtoul(token, NULL, 10); + local_node->relid = atooid(token); token = pg_strtok(&length); /* eat :subquery */ local_node->subquery = nodeRead(true); /* now read it */ @@ -1441,23 +1474,23 @@ _readRangeTblEntry(void) token = pg_strtok(&length); /* eat :inh */ token = pg_strtok(&length); /* get :inh */ - local_node->inh = (token[0] == 't') ? true : false; + local_node->inh = strtobool(token); token = pg_strtok(&length); /* eat :inFromCl */ token = pg_strtok(&length); /* get :inFromCl */ - local_node->inFromCl = (token[0] == 't') ? true : false; + local_node->inFromCl = strtobool(token); token = pg_strtok(&length); /* eat :checkForRead */ token = pg_strtok(&length); /* get :checkForRead */ - local_node->checkForRead = (token[0] == 't') ? true : false; + local_node->checkForRead = strtobool(token); token = pg_strtok(&length); /* eat :checkForWrite */ token = pg_strtok(&length); /* get :checkForWrite */ - local_node->checkForWrite = (token[0] == 't') ? true : false; + local_node->checkForWrite = strtobool(token); token = pg_strtok(&length); /* eat :checkAsUser */ token = pg_strtok(&length); /* get :checkAsUser */ - local_node->checkAsUser = strtoul(token, NULL, 10); + local_node->checkAsUser = atooid(token); return local_node; } @@ -1479,7 +1512,7 @@ _readPath(void) token = pg_strtok(&length); /* get :pathtype */ token = pg_strtok(&length); /* now read it */ - local_node->pathtype = atol(token); + local_node->pathtype = atoi(token); token = pg_strtok(&length); /* get :startup_cost */ token = pg_strtok(&length); /* now read it */ @@ -1512,7 +1545,7 @@ _readIndexPath(void) token = pg_strtok(&length); /* get :pathtype */ token = pg_strtok(&length); /* now read it */ - local_node->path.pathtype = atol(token); + local_node->path.pathtype = atoi(token); token = pg_strtok(&length); /* get :startup_cost */ token = pg_strtok(&length); /* now read it */ @@ -1526,7 +1559,7 @@ _readIndexPath(void) local_node->path.pathkeys = nodeRead(true); /* now read it */ token = pg_strtok(&length); /* get :indexid */ - local_node->indexid = toIntList(nodeRead(true)); + local_node->indexid = toOidList(nodeRead(true)); token = pg_strtok(&length); /* get :indexqual */ local_node->indexqual = nodeRead(true); /* now read it */ @@ -1540,7 +1573,7 @@ _readIndexPath(void) token = pg_strtok(&length); /* get :alljoinquals */ token = pg_strtok(&length); /* now read it */ - local_node->alljoinquals = (token[0] == 't') ? true : false; + local_node->alljoinquals = strtobool(token); token = pg_strtok(&length); /* get :rows */ token = pg_strtok(&length); /* now read it */ @@ -1566,7 +1599,7 @@ _readTidPath(void) token = pg_strtok(&length); /* get :pathtype */ token = pg_strtok(&length); /* now read it */ - local_node->path.pathtype = atol(token); + local_node->path.pathtype = atoi(token); token = pg_strtok(&length); /* get :startup_cost */ token = pg_strtok(&length); /* now read it */ @@ -1605,7 +1638,7 @@ _readAppendPath(void) token = pg_strtok(&length); /* get :pathtype */ token = pg_strtok(&length); /* now read it */ - local_node->path.pathtype = atol(token); + local_node->path.pathtype = atoi(token); token = pg_strtok(&length); /* get :startup_cost */ token = pg_strtok(&length); /* now read it */ @@ -1641,7 +1674,7 @@ _readNestPath(void) token = pg_strtok(&length); /* get :pathtype */ token = pg_strtok(&length); /* now read it */ - local_node->path.pathtype = atol(token); + local_node->path.pathtype = atoi(token); token = pg_strtok(&length); /* get :startup_cost */ token = pg_strtok(&length); /* now read it */ @@ -1687,7 +1720,7 @@ _readMergePath(void) token = pg_strtok(&length); /* get :pathtype */ token = pg_strtok(&length); /* now read it */ - local_node->jpath.path.pathtype = atol(token); + local_node->jpath.path.pathtype = atoi(token); token = pg_strtok(&length); /* get :startup_cost */ token = pg_strtok(&length); /* now read it */ @@ -1742,7 +1775,7 @@ _readHashPath(void) token = pg_strtok(&length); /* get :pathtype */ token = pg_strtok(&length); /* now read it */ - local_node->jpath.path.pathtype = atol(token); + local_node->jpath.path.pathtype = atoi(token); token = pg_strtok(&length); /* get :startup_cost */ token = pg_strtok(&length); /* now read it */ @@ -1791,8 +1824,7 @@ _readPathKeyItem(void) token = pg_strtok(&length); /* get :sortop */ token = pg_strtok(&length); /* now read it */ - - local_node->sortop = (Oid) atol(token); + local_node->sortop = atooid(token); token = pg_strtok(&length); /* get :key */ local_node->key = nodeRead(true); /* now read it */ @@ -1820,26 +1852,26 @@ _readRestrictInfo(void) token = pg_strtok(&length); /* get :ispusheddown */ token = pg_strtok(&length); /* now read it */ - local_node->ispusheddown = (token[0] == 't') ? true : false; + local_node->ispusheddown = strtobool(token); token = pg_strtok(&length); /* get :subclauseindices */ local_node->subclauseindices = nodeRead(true); /* now read it */ token = pg_strtok(&length); /* get :mergejoinoperator */ token = pg_strtok(&length); /* now read it */ - local_node->mergejoinoperator = (Oid) atol(token); + local_node->mergejoinoperator = atooid(token); token = pg_strtok(&length); /* get :left_sortop */ token = pg_strtok(&length); /* now read it */ - local_node->left_sortop = (Oid) atol(token); + local_node->left_sortop = atooid(token); token = pg_strtok(&length); /* get :right_sortop */ token = pg_strtok(&length); /* now read it */ - local_node->right_sortop = (Oid) atol(token); + local_node->right_sortop = atooid(token); token = pg_strtok(&length); /* get :hashjoinoperator */ token = pg_strtok(&length); /* now read it */ - local_node->hashjoinoperator = (Oid) atol(token); + local_node->hashjoinoperator = atooid(token); /* eval_cost is not part of saved representation; compute on first use */ local_node->eval_cost = -1; @@ -2036,28 +2068,28 @@ parsePlanString(void) static Datum readDatum(bool typbyval) { - int length; + Size length, + i; int tokenLength; char *token; Datum res; char *s; - int i; /* * read the actual length of the value */ token = pg_strtok(&tokenLength); - length = atoi(token); + length = atoui(token); token = pg_strtok(&tokenLength); /* skip the '[' */ if (typbyval) { - if ((Size) length > sizeof(Datum)) - elog(ERROR, "readDatum: byval & length = %d", length); + if (length > (Size) sizeof(Datum)) + elog(ERROR, "readDatum: byval & length = %u", length); res = (Datum) 0; s = (char *) (&res); - for (i = 0; i < (int) sizeof(Datum); i++) + for (i = 0; i < (Size) sizeof(Datum); i++) { token = pg_strtok(&tokenLength); s[i] = (char) atoi(token);