From 46630c58183571be9e0662aaa389ad84f6ddc17a Mon Sep 17 00:00:00 2001 From: Amit Langote Date: Tue, 23 Jul 2024 21:05:55 +0900 Subject: [PATCH 1/2] SQL/JSON: Some fixes to JsonBehavior expression casting 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 the coercion works correctly for EXISTS columns that use fixed- length character string types. For example, so that the default "false" doesn't emit an "value too long for type character(2)" error even when no ON ERROR clause is 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. 5. Instead of returning a NULL when the JsonBehavior value cannot be coerced to the RETURNING type, throw the error message telling the user to possibly reconsider the RETURNING type. Tests related to casting to bit(N) are taken from Jian He's patch. Reported-by: Jian He Author: Jian He Author: Amit Langote Discussion: https://postgr.es/m/CACJufxEo4sUjKCYtda0_qt9tazqqKPmF1cqhW9KBOUeJFqQd2g@mail.gmail.com --- src/backend/executor/execExpr.c | 12 +++ src/backend/executor/execExprInterp.c | 81 +++++++++++++-- src/backend/parser/parse_expr.c | 99 +++++++++++++------ .../regress/expected/sqljson_jsontable.out | 29 ++++-- .../regress/expected/sqljson_queryfuncs.out | 78 ++++++++++----- src/test/regress/sql/sqljson_jsontable.sql | 5 +- src/test/regress/sql/sqljson_queryfuncs.sql | 15 ++- 7 files changed, 249 insertions(+), 70 deletions(-) diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c index ccd4863778..54cd9b1c42 100644 --- a/src/backend/executor/execExpr.c +++ b/src/backend/executor/execExpr.c @@ -4416,9 +4416,15 @@ ExecInitJsonExpr(JsonExpr *jsexpr, ExprState *state, /* Step to coerce the ON ERROR expression if needed */ if (jsexpr->on_error->coerce) + { ExecInitJsonCoercion(state, jsexpr->returning, escontext, jsexpr->omit_quotes, resv, resnull); + scratch->opcode = EEOP_JSONEXPR_COERCION_FINISH; + scratch->d.jsonexpr.jsestate = jsestate; + ExprEvalPushStep(state, scratch); + } + /* JUMP to end to skip the ON EMPTY steps added below. */ jumps_to_end = lappend_int(jumps_to_end, state->steps_len); scratch->opcode = EEOP_JUMP; @@ -4449,8 +4455,14 @@ ExecInitJsonExpr(JsonExpr *jsexpr, ExprState *state, /* Step to coerce the ON EMPTY expression if needed */ if (jsexpr->on_empty->coerce) + { ExecInitJsonCoercion(state, jsexpr->returning, escontext, jsexpr->omit_quotes, resv, resnull); + + scratch->opcode = EEOP_JSONEXPR_COERCION_FINISH; + scratch->d.jsonexpr.jsestate = jsestate; + ExprEvalPushStep(state, scratch); + } } foreach(lc, jumps_to_end) diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c index d8735286c4..9d4cca0db2 100644 --- a/src/backend/executor/execExprInterp.c +++ b/src/backend/executor/execExprInterp.c @@ -4284,13 +4284,12 @@ ExecEvalJsonExprPath(ExprState *state, ExprEvalStep *op, memset(&jsestate->error, 0, sizeof(NullableDatum)); memset(&jsestate->empty, 0, sizeof(NullableDatum)); - /* - * Also reset ErrorSaveContext contents for the next row. Since we don't - * set details_wanted, we don't need to also reset error_data, which would - * be NULL anyway. - */ - Assert(!jsestate->escontext.details_wanted && - jsestate->escontext.error_data == NULL); + /* Also reset ErrorSaveContext contents for the next row. */ + if (jsestate->escontext.details_wanted) + { + jsestate->escontext.error_data = NULL; + jsestate->escontext.details_wanted = false; + } jsestate->escontext.error_occurred = false; switch (jsexpr->op) @@ -4400,6 +4399,15 @@ ExecEvalJsonExprPath(ExprState *state, ExprEvalStep *op, error = true; } + /* + * When setting up the ErrorSaveContext (if needed) for capturing the + * errors that occur when coercing the JsonBehavior expression, set + * details_wanted to be able to show the actual error message as the + * DETAIL of the error message that tells that it is the + * JsonBehavior expression that caused the error; see + * ExecEvalJsonCoercionFinish(). + */ + /* Handle ON EMPTY. */ if (empty) { @@ -4410,6 +4418,9 @@ ExecEvalJsonExprPath(ExprState *state, ExprEvalStep *op, if (jsexpr->on_empty->btype != JSON_BEHAVIOR_ERROR) { jsestate->empty.value = BoolGetDatum(true); + /* Set up to catch coercion errors of the ON EMPTY value. */ + jsestate->escontext.error_occurred = false; + jsestate->escontext.details_wanted = true; Assert(jsestate->jump_empty >= 0); return jsestate->jump_empty; } @@ -4417,6 +4428,9 @@ ExecEvalJsonExprPath(ExprState *state, ExprEvalStep *op, else if (jsexpr->on_error->btype != JSON_BEHAVIOR_ERROR) { jsestate->error.value = BoolGetDatum(true); + /* Set up to catch coercion errors of the ON ERROR value. */ + jsestate->escontext.error_occurred = false; + jsestate->escontext.details_wanted = true; Assert(!throw_error && jsestate->jump_error >= 0); return jsestate->jump_error; } @@ -4442,6 +4456,9 @@ ExecEvalJsonExprPath(ExprState *state, ExprEvalStep *op, *op->resvalue = (Datum) 0; *op->resnull = true; jsestate->error.value = BoolGetDatum(true); + /* Set up to catch coercion errors of the ON ERROR value. */ + jsestate->escontext.error_occurred = false; + jsestate->escontext.details_wanted = true; return jsestate->jump_error; } @@ -4544,9 +4561,33 @@ ExecEvalJsonCoercion(ExprState *state, ExprEvalStep *op, (Node *) escontext); } +static char * +GetJsonBehaviorValueString(JsonBehavior *behavior) +{ + /* + * The order of array elements must correspond to the order of + * JsonBehaviorType members. + */ + const char *behavior_names[] = + { + "NULL", + "ERROR", + "EMPTY", + "TRUE", + "FALSE", + "UNKNOWN", + "EMPTY ARRAY", + "EMPTY OBJECT", + "DEFAULT" + }; + + return pstrdup(behavior_names[behavior->btype]); +} + /* * Checks if an error occurred in ExecEvalJsonCoercion(). If so, this sets - * JsonExprState.error to trigger the ON ERROR handling steps. + * JsonExprState.error to trigger the ON ERROR handling steps, unless the + * error is thrown when coercing a JsonBehavior value. */ void ExecEvalJsonCoercionFinish(ExprState *state, ExprEvalStep *op) @@ -4555,9 +4596,33 @@ ExecEvalJsonCoercionFinish(ExprState *state, ExprEvalStep *op) if (SOFT_ERROR_OCCURRED(&jsestate->escontext)) { + /* + * jsestate->error or jsetate->empty being set means that the error + * occurred when coercing the JsonBehavior value. Throw the error in + * that case with the actual coercion error message shown in the + * DETAIL part. + */ + if (DatumGetBool(jsestate->error.value)) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("could not coerce ON ERROR expression (%s) to the RETURNING type", + GetJsonBehaviorValueString(jsestate->jsexpr->on_error)), + errdetail("%s", jsestate->escontext.error_data->message))); + else if (DatumGetBool(jsestate->empty.value)) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("could not coerce ON EMPTY expression (%s) to the RETURNING type", + GetJsonBehaviorValueString(jsestate->jsexpr->on_empty)), + errdetail("%s", jsestate->escontext.error_data->message))); + *op->resvalue = (Datum) 0; *op->resnull = true; + jsestate->error.value = BoolGetDatum(true); + + /* Set up to catch coercion errors of the ON ERROR value. */ + jsestate->escontext.error_occurred = false; + jsestate->escontext.details_wanted = true; } } diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c index 8577f27806..5485104b6b 100644 --- a/src/backend/parser/parse_expr.c +++ b/src/backend/parser/parse_expr.c @@ -4685,51 +4685,90 @@ 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); + char typcategory = TypeCategory(returning->typid); - /* - * 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; - 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 cast the expression."), + 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) diff --git a/src/test/regress/expected/sqljson_jsontable.out b/src/test/regress/expected/sqljson_jsontable.out index 5fd43be367..eeeb411e47 100644 --- a/src/test/regress/expected/sqljson_jsontable.out +++ b/src/test/regress/expected/sqljson_jsontable.out @@ -555,21 +555,38 @@ SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a int4 EXISTS PATH '$.a')); (1 row) SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a int2 EXISTS PATH '$.a')); -ERROR: cannot cast behavior expression of type boolean to smallint +ERROR: could not coerce ON ERROR expression (FALSE) to the RETURNING type +DETAIL: invalid input syntax for type smallint: "false" SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a int8 EXISTS PATH '$.a')); -ERROR: cannot cast behavior expression of type boolean to bigint +ERROR: could not coerce ON ERROR expression (FALSE) to the RETURNING type +DETAIL: invalid input syntax for type bigint: "false" SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a float4 EXISTS PATH '$.a')); -ERROR: cannot cast behavior expression of type boolean to real -SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a char(5) EXISTS PATH '$.a')); +ERROR: could not coerce ON ERROR expression (FALSE) to the RETURNING type +DETAIL: invalid input syntax for type real: "false" +-- Default FALSE (ON ERROR) doesn't fit char(3) +SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a char(3) EXISTS PATH '$.a')); +ERROR: could not coerce ON ERROR expression (FALSE) to the RETURNING type +DETAIL: value too long for type character(3) +SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a char(3) EXISTS PATH '$.a' ERROR ON ERROR)); +ERROR: value too long for type character(3) +SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a char(5) EXISTS PATH '$.a' ERROR ON ERROR)); a ------- false (1 row) SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a json EXISTS PATH '$.a')); -ERROR: cannot cast behavior expression of type boolean to json + a +------- + false +(1 row) + SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a jsonb EXISTS PATH '$.a')); -ERROR: cannot cast behavior expression of type boolean to jsonb + a +------- + false +(1 row) + -- JSON_TABLE: WRAPPER/QUOTES clauses on scalar columns SELECT * FROM JSON_TABLE(jsonb '"world"', '$' COLUMNS (item text PATH '$' KEEP QUOTES ON SCALAR STRING)); item diff --git a/src/test/regress/expected/sqljson_queryfuncs.out b/src/test/regress/expected/sqljson_queryfuncs.out index 074aedb2dd..95bfe369f8 100644 --- a/src/test/regress/expected/sqljson_queryfuncs.out +++ b/src/test/regress/expected/sqljson_queryfuncs.out @@ -313,11 +313,8 @@ SELECT JSON_VALUE(jsonb '"2017-02-20"', '$' RETURNING date) + 9; -- Test NULL checks execution in domain types CREATE DOMAIN sqljsonb_int_not_null AS int NOT NULL; SELECT JSON_VALUE(jsonb 'null', '$' RETURNING sqljsonb_int_not_null); - json_value ------------- - -(1 row) - +ERROR: could not coerce ON ERROR expression (NULL) to the RETURNING type +DETAIL: domain sqljsonb_int_not_null does not allow null values SELECT JSON_VALUE(jsonb 'null', '$' RETURNING sqljsonb_int_not_null ERROR ON ERROR); ERROR: domain sqljsonb_int_not_null does not allow null values SELECT JSON_VALUE(jsonb 'null', '$' RETURNING sqljsonb_int_not_null DEFAULT 2 ON EMPTY ERROR ON ERROR); @@ -665,7 +662,11 @@ SELECT JSON_QUERY(jsonb '"aaa"', '$.a' RETURNING char(2) OMIT QUOTES DEFAULT 'bb (1 row) SELECT JSON_QUERY(jsonb '"aaa"', '$.a' RETURNING char(2) OMIT QUOTES DEFAULT '"bb"'::jsonb ON EMPTY); -ERROR: value too long for type character(2) + json_query +------------ + bb +(1 row) + -- OMIT QUOTES behavior should not be specified when WITH WRAPPER used: -- Should fail SELECT JSON_QUERY(jsonb '[1]', '$' WITH WRAPPER OMIT QUOTES); @@ -853,13 +854,17 @@ SELECT JSON_QUERY(jsonb '[1,2]', '$' RETURNING bytea FORMAT JSON); (1 row) SELECT JSON_QUERY(jsonb '[1,2]', '$[*]' RETURNING bytea EMPTY OBJECT ON ERROR); -ERROR: cannot cast behavior expression of type jsonb to bytea -LINE 1: ... JSON_QUERY(jsonb '[1,2]', '$[*]' RETURNING bytea EMPTY OBJE... - ^ + json_query +------------ + \x7b7d +(1 row) + SELECT JSON_QUERY(jsonb '[1,2]', '$[*]' RETURNING bytea FORMAT JSON EMPTY OBJECT ON ERROR); -ERROR: cannot cast behavior expression of type jsonb to bytea -LINE 1: ...jsonb '[1,2]', '$[*]' RETURNING bytea FORMAT JSON EMPTY OBJE... - ^ + json_query +------------ + \x7b7d +(1 row) + SELECT JSON_QUERY(jsonb '[1,2]', '$[*]' RETURNING json EMPTY OBJECT ON ERROR); json_query ------------ @@ -873,13 +878,11 @@ SELECT JSON_QUERY(jsonb '[1,2]', '$[*]' RETURNING jsonb EMPTY OBJECT ON ERROR); (1 row) SELECT JSON_QUERY(jsonb '[3,4]', '$[*]' RETURNING bigint[] EMPTY OBJECT ON ERROR); -ERROR: cannot cast behavior expression of type jsonb to bigint[] -LINE 1: ...ON_QUERY(jsonb '[3,4]', '$[*]' RETURNING bigint[] EMPTY OBJE... - ^ +ERROR: could not coerce ON ERROR expression (EMPTY OBJECT) to the RETURNING type +DETAIL: expected JSON array SELECT JSON_QUERY(jsonb '"[3,4]"', '$[*]' RETURNING bigint[] EMPTY OBJECT ON ERROR); -ERROR: cannot cast behavior expression of type jsonb to bigint[] -LINE 1: ..._QUERY(jsonb '"[3,4]"', '$[*]' RETURNING bigint[] EMPTY OBJE... - ^ +ERROR: could not coerce ON ERROR expression (EMPTY OBJECT) to the RETURNING type +DETAIL: expected JSON array -- Coercion fails with quotes on SELECT JSON_QUERY(jsonb '"123.1"', '$' RETURNING int2 error on error); ERROR: invalid input syntax for type smallint: ""123.1"" @@ -1035,11 +1038,8 @@ SELECT JSON_QUERY(jsonb '{"a": 1}', '$.a' RETURNING sqljsonb_int_not_null); (1 row) SELECT JSON_QUERY(jsonb '{"a": 1}', '$.b' RETURNING sqljsonb_int_not_null); - json_query ------------- - -(1 row) - +ERROR: could not coerce ON EMPTY expression (NULL) to the RETURNING type +DETAIL: domain sqljsonb_int_not_null does not allow null values SELECT JSON_QUERY(jsonb '{"a": 1}', '$.b' RETURNING sqljsonb_int_not_null ERROR ON EMPTY ERROR ON ERROR); ERROR: no SQL/JSON item found for specified path -- Test timestamptz passing and output @@ -1369,7 +1369,7 @@ ERROR: invalid ON ERROR behavior LINE 1: SELECT JSON_QUERY(jsonb '1', '$' TRUE ON ERROR); ^ DETAIL: Only ERROR, NULL, EMPTY [ ARRAY ], EMPTY OBJECT, or DEFAULT expression is allowed in ON ERROR for JSON_QUERY(). --- Test implicit coercion domain over fixed-legth type specified in RETURNING +-- Test implicit coercion domain over fixed-length type specified in RETURNING CREATE DOMAIN queryfuncs_char2 AS char(2); CREATE DOMAIN queryfuncs_char2_chk AS char(2) CHECK (VALUE NOT IN ('12')); SELECT JSON_QUERY(jsonb '123', '$' RETURNING queryfuncs_char2 ERROR ON ERROR); @@ -1405,3 +1405,33 @@ SELECT JSON_VALUE(jsonb '123', '$' RETURNING queryfuncs_char2_chk DEFAULT 1 ON E (1 row) DROP DOMAIN queryfuncs_char2, queryfuncs_char2_chk; +-- Test coercion to domain over another fixed-length type of the ON ERROR / +-- EMPTY expressions. Ask user to cast the DEFAULT expression explicitly if +-- automatic casting cannot be done, for example, from int to bit(2). +CREATE DOMAIN queryfuncs_d_varbit3 AS varbit(3) CHECK (VALUE <> '01'); +SELECT JSON_VALUE(jsonb '1234', '$' RETURNING queryfuncs_d_varbit3 DEFAULT '111111' ON ERROR); +ERROR: bit string too long for type bit varying(3) +SELECT JSON_VALUE(jsonb '1234', '$' RETURNING queryfuncs_d_varbit3 DEFAULT '010' ON ERROR); + json_value +------------ + 010 +(1 row) + +SELECT JSON_VALUE(jsonb '1234', '$' RETURNING queryfuncs_d_varbit3 DEFAULT '01' ON ERROR); +ERROR: value for domain queryfuncs_d_varbit3 violates check constraint "queryfuncs_d_varbit3_check" +SELECT JSON_VALUE(jsonb '"111"', '$' RETURNING bit(2) ERROR ON ERROR); +ERROR: bit string length 3 does not match type bit(2) +SELECT JSON_VALUE(jsonb '1234', '$' RETURNING bit(3) DEFAULT 1 ON ERROR); +ERROR: cannot cast behavior expression of type integer to bit +LINE 1: ...VALUE(jsonb '1234', '$' RETURNING bit(3) DEFAULT 1 ON ERROR... + ^ +HINT: You will need to cast the expression. +SELECT JSON_VALUE(jsonb '1234', '$' RETURNING bit(3) DEFAULT 1::bit(3) ON ERROR); + json_value +------------ + 001 +(1 row) + +SELECT JSON_VALUE(jsonb '"111"', '$.a' RETURNING bit(3) DEFAULT '1111' ON EMPTY); +ERROR: bit string length 4 does not match type bit(3) +DROP DOMAIN queryfuncs_d_varbit3; diff --git a/src/test/regress/sql/sqljson_jsontable.sql b/src/test/regress/sql/sqljson_jsontable.sql index 4594e5b013..dc509bed8a 100644 --- a/src/test/regress/sql/sqljson_jsontable.sql +++ b/src/test/regress/sql/sqljson_jsontable.sql @@ -266,7 +266,10 @@ SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a int4 EXISTS PATH '$.a')); SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a int2 EXISTS PATH '$.a')); SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a int8 EXISTS PATH '$.a')); SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a float4 EXISTS PATH '$.a')); -SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a char(5) EXISTS PATH '$.a')); +-- Default FALSE (ON ERROR) doesn't fit char(3) +SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a char(3) EXISTS PATH '$.a')); +SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a char(3) EXISTS PATH '$.a' ERROR ON ERROR)); +SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a char(5) EXISTS PATH '$.a' ERROR ON ERROR)); SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a json EXISTS PATH '$.a')); SELECT * FROM JSON_TABLE(jsonb '"a"', '$' COLUMNS (a jsonb EXISTS PATH '$.a')); diff --git a/src/test/regress/sql/sqljson_queryfuncs.sql b/src/test/regress/sql/sqljson_queryfuncs.sql index be5593b332..0dd55f9453 100644 --- a/src/test/regress/sql/sqljson_queryfuncs.sql +++ b/src/test/regress/sql/sqljson_queryfuncs.sql @@ -467,7 +467,7 @@ SELECT JSON_EXISTS(jsonb '1', '$' DEFAULT 1 ON ERROR); SELECT JSON_VALUE(jsonb '1', '$' EMPTY ON ERROR); SELECT JSON_QUERY(jsonb '1', '$' TRUE ON ERROR); --- Test implicit coercion domain over fixed-legth type specified in RETURNING +-- Test implicit coercion domain over fixed-length type specified in RETURNING CREATE DOMAIN queryfuncs_char2 AS char(2); CREATE DOMAIN queryfuncs_char2_chk AS char(2) CHECK (VALUE NOT IN ('12')); SELECT JSON_QUERY(jsonb '123', '$' RETURNING queryfuncs_char2 ERROR ON ERROR); @@ -479,3 +479,16 @@ SELECT JSON_VALUE(jsonb '123', '$' RETURNING queryfuncs_char2 DEFAULT 1 ON ERROR SELECT JSON_VALUE(jsonb '123', '$' RETURNING queryfuncs_char2_chk ERROR ON ERROR); SELECT JSON_VALUE(jsonb '123', '$' RETURNING queryfuncs_char2_chk DEFAULT 1 ON ERROR); DROP DOMAIN queryfuncs_char2, queryfuncs_char2_chk; + +-- Test coercion to domain over another fixed-length type of the ON ERROR / +-- EMPTY expressions. Ask user to cast the DEFAULT expression explicitly if +-- automatic casting cannot be done, for example, from int to bit(2). +CREATE DOMAIN queryfuncs_d_varbit3 AS varbit(3) CHECK (VALUE <> '01'); +SELECT JSON_VALUE(jsonb '1234', '$' RETURNING queryfuncs_d_varbit3 DEFAULT '111111' ON ERROR); +SELECT JSON_VALUE(jsonb '1234', '$' RETURNING queryfuncs_d_varbit3 DEFAULT '010' ON ERROR); +SELECT JSON_VALUE(jsonb '1234', '$' RETURNING queryfuncs_d_varbit3 DEFAULT '01' ON ERROR); +SELECT JSON_VALUE(jsonb '"111"', '$' RETURNING bit(2) ERROR ON ERROR); +SELECT JSON_VALUE(jsonb '1234', '$' RETURNING bit(3) DEFAULT 1 ON ERROR); +SELECT JSON_VALUE(jsonb '1234', '$' RETURNING bit(3) DEFAULT 1::bit(3) ON ERROR); +SELECT JSON_VALUE(jsonb '"111"', '$.a' RETURNING bit(3) DEFAULT '1111' ON EMPTY); +DROP DOMAIN queryfuncs_d_varbit3; -- 2.43.0