From dd3bab5fd74db009c946278bb314c8458a2fef11 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Sun, 27 Nov 2011 22:27:24 -0500 Subject: [PATCH] Ensure that whole-row junk Vars are always of composite type. The EvalPlanQual machinery assumes that whole-row Vars generated for the outputs of non-table RTEs will be of composite types. However, for the case where the RTE is a function call returning a scalar type, we were doing the wrong thing, as a result of sharing code with a parser case where the function's scalar output is wanted. (Or at least, that's what that case has done historically; it does seem a bit inconsistent.) To fix, extend makeWholeRowVar's API so that it can support both use-cases. This fixes Belinda Cussen's report of crashes during concurrent execution of UPDATEs involving joins to the result of UNNEST() --- in READ COMMITTED mode, we'd run the EvalPlanQual machinery after a conflicting row update commits, and it was expecting to get a HeapTuple not a scalar datum from the "wholerowN" variable referencing the function RTE. Back-patch to 9.0 where the current EvalPlanQual implementation appeared. In 9.1 and up, this patch also fixes failure to attach the correct collation to the Var generated for a scalar-result case. An example: regression=# select upper(x.*) from textcat('ab', 'cd') x; ERROR: could not determine which collation to use for upper() function --- src/backend/nodes/makefuncs.c | 45 +++++++++++++------------- src/backend/optimizer/prep/preptlist.c | 3 +- src/backend/parser/parse_expr.c | 11 +++++-- src/backend/rewrite/rewriteHandler.c | 3 +- src/include/nodes/makefuncs.h | 3 +- 5 files changed, 38 insertions(+), 27 deletions(-) diff --git a/src/backend/nodes/makefuncs.c b/src/backend/nodes/makefuncs.c index 9070cd2d73..683e751148 100644 --- a/src/backend/nodes/makefuncs.c +++ b/src/backend/nodes/makefuncs.c @@ -121,11 +121,17 @@ makeVarFromTargetEntry(Index varno, * with error cases, but it's not worth changing now.) The vartype indicates * a rowtype; either a named composite type, or RECORD. This function * encapsulates the logic for determining the correct rowtype OID to use. + * + * If allowScalar is true, then for the case where the RTE is a function + * returning a non-composite result type, we produce a normal Var referencing + * the function's result directly, instead of the single-column composite + * value that the whole-row notation might otherwise suggest. */ Var * makeWholeRowVar(RangeTblEntry *rte, Index varno, - Index varlevelsup) + Index varlevelsup, + bool allowScalar) { Var *result; Oid toid; @@ -157,39 +163,34 @@ makeWholeRowVar(RangeTblEntry *rte, InvalidOid, varlevelsup); } - else + else if (allowScalar) { - /* - * func returns scalar; instead of making a whole-row Var, - * just reference the function's scalar output. (XXX this - * seems a tad inconsistent, especially if "f.*" was - * explicitly written ...) - */ + /* func returns scalar; just return its output as-is */ result = makeVar(varno, 1, toid, -1, + exprCollation(rte->funcexpr), + varlevelsup); + } + else + { + /* func returns scalar, but we want a composite result */ + result = makeVar(varno, + InvalidAttrNumber, + RECORDOID, + -1, InvalidOid, varlevelsup); } break; - case RTE_VALUES: - toid = RECORDOID; - /* returns composite; same as relation case */ - result = makeVar(varno, - InvalidAttrNumber, - toid, - -1, - InvalidOid, - varlevelsup); - break; default: /* - * RTE is a join or subselect. We represent this as a whole-row - * Var of RECORD type. (Note that in most cases the Var will be - * expanded to a RowExpr during planning, but that is not our - * concern here.) + * RTE is a join, subselect, or VALUES. We represent this as a + * whole-row Var of RECORD type. (Note that in most cases the Var + * will be expanded to a RowExpr during planning, but that is not + * our concern here.) */ result = makeVar(varno, InvalidAttrNumber, diff --git a/src/backend/optimizer/prep/preptlist.c b/src/backend/optimizer/prep/preptlist.c index 077ac49631..dccc557f03 100644 --- a/src/backend/optimizer/prep/preptlist.c +++ b/src/backend/optimizer/prep/preptlist.c @@ -129,7 +129,8 @@ preprocess_targetlist(PlannerInfo *root, List *tlist) /* Not a table, so we need the whole row as a junk var */ var = makeWholeRowVar(rt_fetch(rc->rti, range_table), rc->rti, - 0); + 0, + false); snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId); tle = makeTargetEntry((Expr *) var, list_length(tlist) + 1, diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c index 79328c9979..75236c76a1 100644 --- a/src/backend/parser/parse_expr.c +++ b/src/backend/parser/parse_expr.c @@ -2059,8 +2059,15 @@ transformWholeRowRef(ParseState *pstate, RangeTblEntry *rte, int location) /* Find the RTE's rangetable location */ vnum = RTERangeTablePosn(pstate, rte, &sublevels_up); - /* Build the appropriate referencing node */ - result = makeWholeRowVar(rte, vnum, sublevels_up); + /* + * Build the appropriate referencing node. Note that if the RTE is a + * function returning scalar, we create just a plain reference to the + * function value, not a composite containing a single column. This is + * pretty inconsistent at first sight, but it's what we've done + * historically. One argument for it is that "rel" and "rel.*" mean the + * same thing for composite relations, so why not for scalar functions... + */ + result = makeWholeRowVar(rte, vnum, sublevels_up, true); /* location is not filled in by makeWholeRowVar */ result->location = location; diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c index 3b31108775..a6f4141dd7 100644 --- a/src/backend/rewrite/rewriteHandler.c +++ b/src/backend/rewrite/rewriteHandler.c @@ -1188,7 +1188,8 @@ rewriteTargetListUD(Query *parsetree, RangeTblEntry *target_rte, */ var = makeWholeRowVar(target_rte, parsetree->resultRelation, - 0); + 0, + false); attrname = "wholerow"; } diff --git a/src/include/nodes/makefuncs.h b/src/include/nodes/makefuncs.h index 532681f8c0..c5ed6cb413 100644 --- a/src/include/nodes/makefuncs.h +++ b/src/include/nodes/makefuncs.h @@ -35,7 +35,8 @@ extern Var *makeVarFromTargetEntry(Index varno, extern Var *makeWholeRowVar(RangeTblEntry *rte, Index varno, - Index varlevelsup); + Index varlevelsup, + bool allowScalar); extern TargetEntry *makeTargetEntry(Expr *expr, AttrNumber resno,