database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-06-27 23:21:58 +03:00
Code Activity

SQL/JSON: Some fixes to JsonBehavior expression casting

Browse Source 
1. Remove the special case handling when casting the JsonBehavior
   expressions to types with typmod, like 86d33987 did for the casting
   of SQL/JSON constructor functions.

2. Fix casting for fixed-length character and bit string types by
   using assignment-level casts.  This is again similar to what
   86d33987 did, but for ON ERROR / EMPTY expressions.

3. Use runtime coercion for the boolean ON ERROR constants so that
   using fixed-length character string types, for example, for an
   EXISTS column doesn't cause a "value too long for type
   character(n)" when the parser tries to coerce the default ON ERROR
   value "false" to that type, that is, even when clause is not
   specified.

4. Simplify the conditions of when to use runtime coercion vs
   creating the cast expression in the parser itself.  jsonb-valued
   expressions are now always coerced at runtime and boolean
   expressions too if the target type is a string type for the
   reasons mentioned above.

Tests are taken from a patch that Jian He posted.

Reported-by: Jian He <jian.universality@gmail.com>
Author: Jian He <jian.universality@gmail.com>
Author: Amit Langote <amitlangote09@gmail.com>
Discussion: https://postgr.es/m/CACJufxEo4sUjKCYtda0_qt9tazqqKPmF1cqhW9KBOUeJFqQd2g@mail.gmail.com
Backpatch-through: 17
This commit is contained in:
Amit Langote
2024-07-30 10:11:23 +09:00
parent 8240401437
commit 74c96699be
5 changed files with 164 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
src/backend/parser/parse_expr.c
View File

@ -4685,51 +4685,91 @@ transformJsonBehavior(ParseState *pstate, JsonBehavior *behavior,
if (expr == NULL && btype != JSON_BEHAVIOR_ERROR)
expr = GetJsonBehaviorConst(btype, location);
if (expr)
/*
* Try to coerce the expression if needed.
*
* Use runtime coercion using json_populate_type() if the expression is
* NULL, jsonb-valued, or boolean-valued (unless the target type is
* integer or domain over integer, in which case use the
* boolean-to-integer cast function).
*
* For other non-NULL expressions, try to find a cast and error out if one
* is not found.
*/
if (expr && exprType(expr) != returning->typid)
{
Node *coerced_expr = expr;
bool isnull = (IsA(expr, Const) && ((Const *) expr)->constisnull);
/*
* Coerce NULLs and "internal" (that is, not specified by the user)
* jsonb-valued expressions at runtime using json_populate_type().
*
* For other (user-specified) non-NULL values, try to find a cast and
* error out if one is not found.
*/
if (isnull ||
(exprType(expr) == JSONBOID &&
btype == default_behavior))
exprType(expr) == JSONBOID ||
(exprType(expr) == BOOLOID &&
getBaseType(returning->typid) != INT4OID))
{
coerce_at_runtime = true;
/*
* json_populate_type() expects to be passed a jsonb value, so gin
* up a Const containing the appropriate boolean value represented
* as jsonb, discarding the original Const containing a plain
* boolean.
*/
if (exprType(expr) == BOOLOID)
{
char *val = btype == JSON_BEHAVIOR_TRUE ? "true" : "false";
expr = (Node *) makeConst(JSONBOID, -1, InvalidOid, -1,
DirectFunctionCall1(jsonb_in,
CStringGetDatum(val)),
false, false);
}
}
else
{
int32 baseTypmod = returning->typmod;
Node *coerced_expr;
char typcategory = TypeCategory(returning->typid);
if (get_typtype(returning->typid) == TYPTYPE_DOMAIN)
(void) getBaseTypeAndTypmod(returning->typid, &baseTypmod);
if (baseTypmod > 0)
expr = coerce_to_specific_type(pstate, expr, TEXTOID,
"JSON_FUNCTION()");
/*
* Use an assignment cast if coercing to a string type so that
* build_coercion_expression() assumes implicit coercion when
* coercing the typmod, so that inputs exceeding length cause an
* error instead of silent truncation.
*/
coerced_expr =
coerce_to_target_type(pstate, expr, exprType(expr),
returning->typid, baseTypmod,
baseTypmod > 0 ? COERCION_IMPLICIT :
returning->typid, returning->typmod,
(typcategory == TYPCATEGORY_STRING ||
typcategory == TYPCATEGORY_BITSTRING) ?
COERCION_ASSIGNMENT :
COERCION_EXPLICIT,
baseTypmod > 0 ? COERCE_IMPLICIT_CAST :
COERCE_EXPLICIT_CAST,
exprLocation((Node *) behavior));
}
if (coerced_expr == NULL)
ereport(ERROR,
errcode(ERRCODE_CANNOT_COERCE),
errmsg("cannot cast behavior expression of type %s to %s",
format_type_be(exprType(expr)),
format_type_be(returning->typid)),
parser_errposition(pstate, exprLocation(expr)));
else
if (coerced_expr == NULL)
{
/*
* Provide a HINT if the expression comes from a DEFAULT
* clause.
*/
if (btype == JSON_BEHAVIOR_DEFAULT)
ereport(ERROR,
errcode(ERRCODE_CANNOT_COERCE),
errmsg("cannot cast behavior expression of type %s to %s",
format_type_be(exprType(expr)),
format_type_be(returning->typid)),
errhint("You will need to explicitly cast the expression to type %s.",
format_type_be(returning->typid)),
parser_errposition(pstate, exprLocation(expr)));
else
ereport(ERROR,
errcode(ERRCODE_CANNOT_COERCE),
errmsg("cannot cast behavior expression of type %s to %s",
format_type_be(exprType(expr)),
format_type_be(returning->typid)),
parser_errposition(pstate, exprLocation(expr)));
}
expr = coerced_expr;
}
}
if (behavior)