Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1xTM8Y-00000000HT9-1JKP for pgsql-bugs@arkaria.postgresql.org; Tue, 17 Nov 2026 16:34:26 +0000 Received: from localhost ([127.0.0.1]:48332 helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.98.2) (envelope-from ) id 1xTM8W-000000061kG-2uS7 for pgsql-bugs@arkaria.postgresql.org; Tue, 17 Nov 2026 16:34:24 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]:57838) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1xTM8W-000000061k6-1fSL for pgsql-bugs@lists.postgresql.org; Tue, 17 Nov 2026 16:34:24 +0000 Received: from sss.pgh.pa.us ([68.162.161.243]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.98.2) (envelope-from ) id 1xTM8T-00000000CNj-2x8v for pgsql-bugs@lists.postgresql.org; Tue, 17 Nov 2026 16:34:24 +0000 Received: from sss1.sss.pgh.pa.us (localhost [127.0.0.1]) by sss.pgh.pa.us (8.18.1/8.18.1) with ESMTP id 6AHGYIB1457448; Tue, 17 Nov 2026 11:34:18 -0500 DKIM-Filter: OpenDKIM Filter v2.11.0 sss.pgh.pa.us 6AHGYIB1457448 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sss.pgh.pa.us; s=default; t=1794933259; bh=N0WKP3k1QBNEOG96UI7X3S8+ig7UwAsGFVf442KgCec=; h=From:To:cc:Subject:In-reply-to:References:Date:From; b=q2brP7v2MRfhlyJSPeVPn9Nuegr5vnFaRS4v7gpfm4Wl6hwuY2iV9kHKYnzO0egnR 99GxyiMyEm4Phu2MHWCdKUdTRqvgiv9FvCOr4JrcpOZOCHT5RvgqOC2RxqNBeCOw4c vf/syIZa8WvyPVnRvKdYk6wx+GxQqvyH11Z0GnkA= From: Tom Lane To: Ayush Tiwari cc: =?UTF-8?B?0JHQvtGA0LjRgSDQnNGD0YDQsNGI0L7Qsg==?= , pgsql-bugs@lists.postgresql.org Subject: Re: BUG #19906: Backend crash (signal 11) creating a LANGUAGE sql function that returns a composite type from a sub- In-reply-to: References: <19906-229033275b593ef0@postgresql.org> <126458.1794857339@sss.pgh.pa.us> <266210.1794869177@sss.pgh.pa.us> Comments: In-reply-to Ayush Tiwari message dated "Tue, 17 Nov 2026 07:15:04 +0530" MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----- =_aaaaaaaaaa0" Content-ID: <457439.1794933246.0@sss.pgh.pa.us> Date: Tue, 17 Nov 2026 11:34:18 -0500 Message-ID: <457447.1794933258@sss.pgh.pa.us> List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk ------- =_aaaaaaaaaa0 Content-Type: text/plain; charset="us-ascii" Content-ID: <457439.1794933246.1@sss.pgh.pa.us> Ayush Tiwari writes: > Post your last mail, I was auditing the places that need these comment > updates, and the difference between that list and your patch is: > 1) make_fn_arguments() in parse_func.c still has the old comment, and > clauses.c calls it with NULL. > 2) make_row_comparison_op() in parse_expr.c has it too, but it > dereferences pstate anyway, so that line can just go? Good catches. Incorporated in less-drafty v2. regards, tom lane ------- =_aaaaaaaaaa0 Content-Type: text/x-diff; name*0="v2-0001-Don-t-crash-on-null-pstate-in-coerce_record_to_co.p"; name*1="atch"; charset="us-ascii" Content-ID: <457439.1794933246.2@sss.pgh.pa.us> Content-Description: v2-0001-Don-t-crash-on-null-pstate-in-coerce_record_to_co.patch Content-Transfer-Encoding: quoted-printable =46rom 308386876e33e0a7569c53372af1050cb4a5d8bc Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 17 Nov 2026 11:32:47 -0500 Subject: [PATCH v2] Don't crash on null pstate in coerce_record_to_complex= (). Since commit 913bbd88d, this case is reachable if a SQL-language function returns a whole-row Var of type RECORD when its declared output type is a named composite type. We'd need the original ParseState to find out what the Var's columns are, but we don't have that structure at hand anymore. This didn't work before 913bbd88d either, but you got a slightly off-point error message instead of a crash. Given that this has never worked and there's been no field complaints about that before now, it doesn't seem worth doing major work to fix this; let's just ensure that we throw a helpful error explaining what to do to work around the limitation. (The workaround actually reaches this same code, but does so while we still have the ParseState.) While at it, update various badly-obsolete comments about what coerce_type() uses its pstate argument for. Bug: #19906 Reported-by: Boris Murasov Author: Tom Lane Reviewed-by: Ayush Tiwari Discussion: https://postgr.es/m/19906-229033275b593ef0@postgresql.org Backpatch-through: 15 --- src/backend/parser/parse_coerce.c | 46 +++++++++++++++--------- src/backend/parser/parse_expr.c | 4 +-- src/backend/parser/parse_func.c | 3 +- src/test/regress/expected/rangefuncs.out | 9 ++++- src/test/regress/sql/rangefuncs.sql | 7 +++- 5 files changed, 45 insertions(+), 24 deletions(-) diff --git a/src/backend/parser/parse_coerce.c b/src/backend/parser/parse_= coerce.c index d3240f4b265..bd4e12c9989 100644 --- a/src/backend/parser/parse_coerce.c +++ b/src/backend/parser/parse_coerce.c @@ -147,9 +147,14 @@ coerce_to_target_type(ParseState *pstate, Node *expr,= Oid exprtype, * applies length conversion, and in those cases only, the result will * already be properly coerced to the specified typmod. * - * pstate is only used in the case that we are able to resolve the type o= f - * a previously UNKNOWN Param. It is okay to pass pstate =3D NULL if the - * caller does not want type information updated for Params. + * pstate can be NULL in calls from outside the parser. This mostly work= s, + * but note the following restrictions: + * 1. No p_coerce_param_hook processing is possible, so Params receive + * no special treatment. + * 2. Whole-row Vars of type RECORD (those referring to non-table FROM it= ems + * such as joins or sub-selects) cannot be cast to named composite types, + * since we can't resolve their columns. + * 3. No error position information will be provided. * * Note: this function must not modify the given expression tree, only ad= d * decoration on top of it. See transformSetOperationTree, for example. @@ -1009,7 +1014,7 @@ build_coercion_expression(Node *node, * Coerce a RECORD to a specific composite type. * * Currently we only support this for inputs that are RowExprs or whole-r= ow - * Vars. + * Vars. pstate =3D=3D NULL prevents handling the latter case. */ static Node * coerce_record_to_complex(ParseState *pstate, Node *node, @@ -1039,12 +1044,22 @@ coerce_record_to_complex(ParseState *pstate, Node = *node, else if (node && IsA(node, Var) && ((Var *) node)->varattno =3D=3D InvalidAttrNumber) { - Var *var =3D (Var *) node; - ParseNamespaceItem *nsitem; + if (pstate) + { + Var *var =3D (Var *) node; + ParseNamespaceItem *nsitem; = - nsitem =3D GetNSItemByVar(pstate, var); - args =3D expandNSItemVars(pstate, nsitem, var->varlevelsup, - var->location, NULL); + nsitem =3D GetNSItemByVar(pstate, var); + args =3D expandNSItemVars(pstate, nsitem, var->varlevelsup, + var->location, NULL); + } + else + ereport(ERROR, + (errcode(ERRCODE_CANNOT_COERCE), + errmsg("cannot cast type %s to %s", + format_type_be(RECORDOID), + format_type_be(targetTypeId)), + errhint("Cast the whole-row variable to the desired type explicitly= ."))); } else ereport(ERROR, @@ -1156,8 +1171,7 @@ coerce_record_to_complex(ParseState *pstate, Node *n= ode, * * Returns the possibly-transformed node tree. * - * As with coerce_type, pstate may be NULL if no special unknown-Param - * processing is wanted. + * As with coerce_type, pstate may be NULL for calls from outside the par= ser. */ Node * coerce_to_boolean(ParseState *pstate, Node *node, @@ -1203,8 +1217,7 @@ coerce_to_boolean(ParseState *pstate, Node *node, * * Returns the possibly-transformed node tree. * - * As with coerce_type, pstate may be NULL if no special unknown-Param - * processing is wanted. + * As with coerce_type, pstate may be NULL for calls from outside the par= ser. */ Node * coerce_to_specific_type_typmod(ParseState *pstate, Node *node, @@ -1252,8 +1265,7 @@ coerce_to_specific_type_typmod(ParseState *pstate, N= ode *node, * * Returns the possibly-transformed node tree. * - * As with coerce_type, pstate may be NULL if no special unknown-Param - * processing is wanted. + * As with coerce_type, pstate may be NULL for calls from outside the par= ser. */ Node * coerce_to_specific_type(ParseState *pstate, Node *node, @@ -1330,6 +1342,7 @@ parser_coercion_errposition(ParseState *pstate, * This is used for determining the output type of CASE, UNION, * and similar constructs. * + * 'pstate' is used only for error reporting, and can be NULL. * 'exprs' is a *nonempty* list of expressions. Note that earlier items * in the list will be preferred if there is doubt. * 'context' is a phrase to use in the error message if we fail to select @@ -1569,8 +1582,7 @@ select_common_type_from_oids(int nargs, const Oid *t= ypeids, bool noerror) * expressions to the desired type. 'context' is a phrase to use in the * error message if we fail to coerce. * - * As with coerce_type, pstate may be NULL if no special unknown-Param - * processing is wanted. + * As with coerce_type, pstate may be NULL for calls from outside the par= ser. */ Node * coerce_to_common_type(ParseState *pstate, Node *node, diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_ex= pr.c index 728392f436f..e207b7a1978 100644 --- a/src/backend/parser/parse_expr.c +++ b/src/backend/parser/parse_expr.c @@ -2826,9 +2826,7 @@ transformCollateClause(ParseState *pstate, CollateCl= ause *c) /* * Transform a "row compare-op row" construct * - * The inputs are lists of already-transformed expressions. - * As with coerce_type, pstate may be NULL if no special unknown-Param - * processing is wanted. + * The argument lists are lists of already-transformed expressions. * * The output may be a single OpExpr, an AND or OR combination of OpExprs= , * or a RowCompareExpr. In all cases it is guaranteed to return boolean. diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_fu= nc.c index 410e54accd8..c4ba284fa18 100644 --- a/src/backend/parser/parse_func.c +++ b/src/backend/parser/parse_func.c @@ -2005,8 +2005,7 @@ unify_hypothetical_args(ParseState *pstate, * * Caution: given argument list is modified in-place. * - * As with coerce_type, pstate may be NULL if no special unknown-Param - * processing is wanted. + * As with coerce_type, pstate may be NULL for calls from outside the par= ser. */ void make_fn_arguments(ParseState *pstate, diff --git a/src/test/regress/expected/rangefuncs.out b/src/test/regress/e= xpected/rangefuncs.out index a7cb1b5611d..a9ad3687887 100644 --- a/src/test/regress/expected/rangefuncs.out +++ b/src/test/regress/expected/rangefuncs.out @@ -2,7 +2,14 @@ CREATE TABLE rngfunc2(rngfuncid int, f2 int); INSERT INTO rngfunc2 VALUES(1, 11); INSERT INTO rngfunc2 VALUES(2, 22); INSERT INTO rngfunc2 VALUES(1, 111); -CREATE FUNCTION rngfunct(int) returns setof rngfunc2 as 'SELECT * FROM rn= gfunc2 WHERE rngfuncid =3D $1 ORDER BY f2;' LANGUAGE SQL; +CREATE FUNCTION rngfunct(int) returns setof rngfunc2 as + 'SELECT * FROM rngfunc2 WHERE rngfuncid =3D $1 ORDER BY f2;' LANGUAGE S= QL; +-- this variant doesn't work +CREATE FUNCTION rngfunct2(int) returns setof rngfunc2 as + 'SELECT s FROM (SELECT * FROM rngfunc2) s;' LANGUAGE SQL; +ERROR: cannot cast type record to rngfunc2 +HINT: Cast the whole-row variable to the desired type explicitly. +CONTEXT: SQL function "rngfunct2" -- function with ORDINALITY select * from rngfunct(1) with ordinality as z(a,b,ord); a | b | ord = diff --git a/src/test/regress/sql/rangefuncs.sql b/src/test/regress/sql/ra= ngefuncs.sql index 3c47c98e113..1d35f938fd4 100644 --- a/src/test/regress/sql/rangefuncs.sql +++ b/src/test/regress/sql/rangefuncs.sql @@ -3,7 +3,12 @@ INSERT INTO rngfunc2 VALUES(1, 11); INSERT INTO rngfunc2 VALUES(2, 22); INSERT INTO rngfunc2 VALUES(1, 111); = -CREATE FUNCTION rngfunct(int) returns setof rngfunc2 as 'SELECT * FROM rn= gfunc2 WHERE rngfuncid =3D $1 ORDER BY f2;' LANGUAGE SQL; +CREATE FUNCTION rngfunct(int) returns setof rngfunc2 as + 'SELECT * FROM rngfunc2 WHERE rngfuncid =3D $1 ORDER BY f2;' LANGUAGE S= QL; + +-- this variant doesn't work +CREATE FUNCTION rngfunct2(int) returns setof rngfunc2 as + 'SELECT s FROM (SELECT * FROM rngfunc2) s;' LANGUAGE SQL; = -- function with ORDINALITY select * from rngfunct(1) with ordinality as z(a,b,ord); -- = 2.52.0 ------- =_aaaaaaaaaa0--