From 51bef18b4cc1025848ef7600737449b86015509b Mon Sep 17 00:00:00 2001 From: jian he Date: Mon, 11 Aug 2025 14:11:42 +0800 Subject: [PATCH v6 18/18] CAST(expr AS newtype DEFAULT ON ERROR) Now that the type coercion node is error-safe, we also need to ensure that when a coercion fails, it falls back to evaluating the default node. draft doc also added. We cannot simply prohibit user-defined functions in pg_cast for safe cast evaluation because CREATE CAST can also utilize built-in functions. So, to completely disallow custom casts created via CREATE CAST used in safe cast evaluation, a new field in pg_cast would unfortunately be necessary. [0]: https://git.postgresql.org/cgit/postgresql.git/commit/?id=aaaf9449ec6be62cb0d30ed3588dc384f56274bf discussion: https://postgr.es/m/CADkLM=fv1JfY4Ufa-jcwwNbjQixNViskQ8jZu3Tz_p656i_4hQ@mail.gmail.com demo: SELECT CAST('1' AS date DEFAULT '2011-01-01' ON ERROR), CAST('{234,def,567}'::text[] AS integer[] DEFAULT '{-1011}' ON ERROR); date | int4 ------------+--------- 2011-01-01 | {-1011} --- doc/src/sgml/catalogs.sgml | 11 + doc/src/sgml/syntax.sgml | 15 + src/backend/catalog/pg_cast.c | 1 + src/backend/executor/execExpr.c | 83 +++- src/backend/executor/execExprInterp.c | 30 ++ src/backend/jit/llvm/llvmjit_expr.c | 49 ++ src/backend/nodes/nodeFuncs.c | 67 +++ src/backend/nodes/queryjumblefuncs.c | 14 + src/backend/optimizer/util/clauses.c | 19 + src/backend/parser/gram.y | 31 +- src/backend/parser/parse_expr.c | 345 +++++++++++++- src/backend/parser/parse_target.c | 14 + src/backend/parser/parse_type.c | 13 + src/backend/utils/adt/arrayfuncs.c | 6 + src/backend/utils/adt/ruleutils.c | 15 + src/backend/utils/fmgr/fmgr.c | 13 + src/include/catalog/pg_cast.dat | 302 ++++++------ src/include/catalog/pg_cast.h | 4 + src/include/executor/execExpr.h | 8 + src/include/fmgr.h | 3 + src/include/nodes/execnodes.h | 30 ++ src/include/nodes/parsenodes.h | 6 + src/include/nodes/primnodes.h | 35 ++ src/include/parser/parse_type.h | 2 + src/test/regress/expected/cast.out | 556 ++++++++++++++++++++++ src/test/regress/expected/create_cast.out | 5 + src/test/regress/expected/opr_sanity.out | 24 +- src/test/regress/parallel_schedule | 2 +- src/test/regress/sql/cast.sql | 259 ++++++++++ src/test/regress/sql/create_cast.sql | 1 + src/tools/pgindent/typedefs.list | 3 + 31 files changed, 1793 insertions(+), 173 deletions(-) create mode 100644 src/test/regress/expected/cast.out create mode 100644 src/test/regress/sql/cast.sql diff --git a/doc/src/sgml/catalogs.sgml b/doc/src/sgml/catalogs.sgml index da8a7882580..6398a6a0339 100644 --- a/doc/src/sgml/catalogs.sgml +++ b/doc/src/sgml/catalogs.sgml @@ -1846,6 +1846,17 @@ SCRAM-SHA-256$<iteration count>:&l b means that the types are binary-coercible, thus no conversion is required. + + + + casterrorsafe bool + + + This indicates whether the castfunc function is error-safe. + If true, the castfunc function is error-safe; if false, it is not. + + + diff --git a/doc/src/sgml/syntax.sgml b/doc/src/sgml/syntax.sgml index 916189a7d68..4854b78966e 100644 --- a/doc/src/sgml/syntax.sgml +++ b/doc/src/sgml/syntax.sgml @@ -2104,6 +2104,21 @@ CAST ( expression AS type The CAST syntax conforms to SQL; the syntax with :: is historical PostgreSQL usage. + The alternative syntax is + +CAST ( expression AS type ERROR ON CONVERSION ERROR ) + + + + + +CAST ( expression AS type DEFAULT expression ON CONVERSION ERROR ) + + For example, the following query will evaluate the default expression and return 42. + TODO: more explanation + +SELECT (CAST('error' AS integer DEFAULT 42 ON CONVERSION ERROR)); + diff --git a/src/backend/catalog/pg_cast.c b/src/backend/catalog/pg_cast.c index 1773c9c5491..6fe65d24d31 100644 --- a/src/backend/catalog/pg_cast.c +++ b/src/backend/catalog/pg_cast.c @@ -84,6 +84,7 @@ CastCreate(Oid sourcetypeid, Oid targettypeid, values[Anum_pg_cast_castfunc - 1] = ObjectIdGetDatum(funcid); values[Anum_pg_cast_castcontext - 1] = CharGetDatum(castcontext); values[Anum_pg_cast_castmethod - 1] = CharGetDatum(castmethod); + values[Anum_pg_cast_casterrorsafe - 1] = BoolGetDatum(false); tuple = heap_form_tuple(RelationGetDescr(relation), values, nulls); diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c index 921ec4e0bc1..eaed2d2be67 100644 --- a/src/backend/executor/execExpr.c +++ b/src/backend/executor/execExpr.c @@ -99,6 +99,9 @@ static void ExecBuildAggTransCall(ExprState *state, AggState *aggstate, static void ExecInitJsonExpr(JsonExpr *jsexpr, ExprState *state, Datum *resv, bool *resnull, ExprEvalStep *scratch); +static void ExecInitSafeTypeCastExpr(SafeTypeCastExpr *stcexpr, ExprState *state, + Datum *resv, bool *resnull, + ExprEvalStep *scratch); static void ExecInitJsonCoercion(ExprState *state, JsonReturning *returning, ErrorSaveContext *escontext, bool omit_quotes, bool exists_coerce, @@ -2178,6 +2181,14 @@ ExecInitExprRec(Expr *node, ExprState *state, break; } + case T_SafeTypeCastExpr: + { + SafeTypeCastExpr *stcexpr = castNode(SafeTypeCastExpr, node); + + ExecInitSafeTypeCastExpr(stcexpr, state, resv, resnull, &scratch); + break; + } + case T_CoalesceExpr: { CoalesceExpr *coalesce = (CoalesceExpr *) node; @@ -2744,7 +2755,7 @@ ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args, Oid funcid, /* Initialize function call parameter structure too */ InitFunctionCallInfoData(*fcinfo, flinfo, - nargs, inputcollid, NULL, NULL); + nargs, inputcollid, (Node *) state->escontext, NULL); /* Keep extra copies of this info to save an indirection at runtime */ scratch->d.func.fn_addr = flinfo->fn_addr; @@ -4742,6 +4753,76 @@ ExecBuildParamSetEqual(TupleDesc desc, return state; } +/* + * Push steps to evaluate a SafeTypeCastExpr and its various subsidiary + * expressions. We already handle errors softly for coercion nodes like + * CoerceViaIO, CoerceToDomain, ArrayCoerceExpr, and some FuncExprs. However, + * most of FuncExprs node (for example, int84) is not error-safe. For these + * cases, we instead wrap the source expression and target type information + * within a CoerceViaIO node. + */ +static void +ExecInitSafeTypeCastExpr(SafeTypeCastExpr *stcexpr , ExprState *state, + Datum *resv, bool *resnull, + ExprEvalStep *scratch) +{ + /* + * If coercion to the target type fails, fallback to the default expression + * specified in the ON CONVERSION ERROR clause. + */ + if (stcexpr->cast_expr == NULL) + { + ExecInitExprRec((Expr *) stcexpr->default_expr, + state, resv, resnull); + return; + } + else + { + SafeTypeCastState *stcstate; + ErrorSaveContext *escontext; + ErrorSaveContext *saved_escontext; + List *jumps_to_end = NIL; + + stcstate = palloc0(sizeof(SafeTypeCastState)); + stcstate->stcexpr = stcexpr; + stcstate->escontext.type = T_ErrorSaveContext; + escontext = &stcstate->escontext; + state->escontext = escontext; + + /* evaluate argument expression into step's result area */ + ExecInitExprRec((Expr *) stcexpr->cast_expr, + state, resv, resnull); + + scratch->opcode = EEOP_SAFETYPE_CAST; + scratch->d.stcexpr.stcstate = stcstate; + ExprEvalPushStep(state, scratch); + + stcstate->jump_error = state->steps_len; + /* JUMP to end if false, that is, skip the ON ERROR expression. */ + jumps_to_end = lappend_int(jumps_to_end, state->steps_len); + scratch->opcode = EEOP_JUMP_IF_NOT_TRUE; + scratch->resvalue = &stcstate->error.value; + scratch->resnull = &stcstate->error.isnull; + scratch->d.jump.jumpdone = -1; /* set below */ + ExprEvalPushStep(state, scratch); + + /* Steps to evaluate the ON ERROR expression */ + saved_escontext = state->escontext; + state->escontext = NULL; + ExecInitExprRec((Expr *) stcstate->stcexpr->default_expr, + state, resv, resnull); + state->escontext = saved_escontext; + + foreach_int(lc, jumps_to_end) + { + ExprEvalStep *as = &state->steps[lc]; + + as->d.jump.jumpdone = state->steps_len; + } + stcstate->jump_end = state->steps_len; + } +} + /* * Push steps to evaluate a JsonExpr and its various subsidiary expressions. */ diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c index 998674c180d..351923d7ec4 100644 --- a/src/backend/executor/execExprInterp.c +++ b/src/backend/executor/execExprInterp.c @@ -568,6 +568,7 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull) &&CASE_EEOP_XMLEXPR, &&CASE_EEOP_JSON_CONSTRUCTOR, &&CASE_EEOP_IS_JSON, + &&CASE_EEOP_SAFETYPE_CAST, &&CASE_EEOP_JSONEXPR_PATH, &&CASE_EEOP_JSONEXPR_COERCION, &&CASE_EEOP_JSONEXPR_COERCION_FINISH, @@ -1926,6 +1927,11 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull) EEO_NEXT(); } + EEO_CASE(EEOP_SAFETYPE_CAST) + { + EEO_JUMP(ExecEvalSafeTypeCast(state, op)); + } + EEO_CASE(EEOP_JSONEXPR_PATH) { /* too complex for an inline implementation */ @@ -5190,6 +5196,30 @@ GetJsonBehaviorValueString(JsonBehavior *behavior) return pstrdup(behavior_names[behavior->btype]); } +int +ExecEvalSafeTypeCast(ExprState *state, ExprEvalStep *op) +{ + SafeTypeCastState *stcstate = op->d.stcexpr.stcstate; + + if (SOFT_ERROR_OCCURRED(&stcstate->escontext)) + { + *op->resvalue = (Datum) 0; + *op->resnull = true; + + stcstate->error.value = BoolGetDatum(true); + + /* + * Reset for next use such as for catching errors when coercing a + * stcexpr expression. + */ + stcstate->escontext.error_occurred = false; + stcstate->escontext.details_wanted = false; + + return stcstate->jump_error; + } + return stcstate->jump_end; +} + /* * Checks if an error occurred in ExecEvalJsonCoercion(). If so, this sets * JsonExprState.error to trigger the ON ERROR handling steps, unless the diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c index 890bcb0b0a7..a2dfb823932 100644 --- a/src/backend/jit/llvm/llvmjit_expr.c +++ b/src/backend/jit/llvm/llvmjit_expr.c @@ -2256,6 +2256,55 @@ llvm_compile_expr(ExprState *state) LLVMBuildBr(b, opblocks[opno + 1]); break; + case EEOP_SAFETYPE_CAST: + { + SafeTypeCastState *stcstate = op->d.stcexpr.stcstate; + LLVMValueRef v_ret; + + /* + * Call ExecEvalSafeTypeCast(). It returns the address of + * the step to perform next. + */ + v_ret = build_EvalXFunc(b, mod, "ExecEvalSafeTypeCast", + v_state, op, v_econtext); + + /* + * Build a switch to map the return value (v_ret above), + * which is a runtime value of the step address to perform + * next to jump_error + */ + if (stcstate->jump_error >= 0) + { + LLVMValueRef v_jump_error; + LLVMValueRef v_switch; + LLVMBasicBlockRef b_done, + b_error; + + b_error = + l_bb_before_v(opblocks[opno + 1], + "op.%d.stcexpr_error", opno); + b_done = + l_bb_before_v(opblocks[opno + 1], + "op.%d.stcexpr_done", opno); + + v_switch = LLVMBuildSwitch(b, + v_ret, + b_done, + 1); + + /* Returned stcstate->jump_error? */ + v_jump_error = l_int32_const(lc, stcstate->jump_error); + LLVMAddCase(v_switch, v_jump_error, b_error); + + /* ON ERROR code */ + LLVMPositionBuilderAtEnd(b, b_error); + LLVMBuildBr(b, opblocks[stcstate->jump_error]); + + LLVMPositionBuilderAtEnd(b, b_done); + } + LLVMBuildBr(b, opblocks[stcstate->jump_end]); + break; + } case EEOP_JSONEXPR_PATH: { JsonExprState *jsestate = op->d.jsonexpr.jsestate; diff --git a/src/backend/nodes/nodeFuncs.c b/src/backend/nodes/nodeFuncs.c index 7bc823507f1..212f3e3c50c 100644 --- a/src/backend/nodes/nodeFuncs.c +++ b/src/backend/nodes/nodeFuncs.c @@ -206,6 +206,9 @@ exprType(const Node *expr) case T_RowCompareExpr: type = BOOLOID; break; + case T_SafeTypeCastExpr: + type = ((const SafeTypeCastExpr *) expr)->resulttype; + break; case T_CoalesceExpr: type = ((const CoalesceExpr *) expr)->coalescetype; break; @@ -450,6 +453,8 @@ exprTypmod(const Node *expr) return typmod; } break; + case T_SafeTypeCastExpr: + return ((const SafeTypeCastExpr *) expr)->resulttypmod; case T_CoalesceExpr: { /* @@ -965,6 +970,9 @@ exprCollation(const Node *expr) /* RowCompareExpr's result is boolean ... */ coll = InvalidOid; /* ... so it has no collation */ break; + case T_SafeTypeCastExpr: + coll = ((const SafeTypeCastExpr *) expr)->resultcollid; + break; case T_CoalesceExpr: coll = ((const CoalesceExpr *) expr)->coalescecollid; break; @@ -1232,6 +1240,9 @@ exprSetCollation(Node *expr, Oid collation) /* RowCompareExpr's result is boolean ... */ Assert(!OidIsValid(collation)); /* ... so never set a collation */ break; + case T_SafeTypeCastExpr: + ((SafeTypeCastExpr *) expr)->resultcollid = collation; + break; case T_CoalesceExpr: ((CoalesceExpr *) expr)->coalescecollid = collation; break; @@ -1554,6 +1565,15 @@ exprLocation(const Node *expr) /* just use leftmost argument's location */ loc = exprLocation((Node *) ((const RowCompareExpr *) expr)->largs); break; + case T_SafeTypeCastExpr: + { + const SafeTypeCastExpr *cast_expr = (const SafeTypeCastExpr *) expr; + if (cast_expr->cast_expr) + loc = exprLocation(cast_expr->cast_expr); + else + loc = exprLocation(cast_expr->default_expr); + break; + } case T_CoalesceExpr: /* COALESCE keyword should always be the first thing */ loc = ((const CoalesceExpr *) expr)->location; @@ -2325,6 +2345,18 @@ expression_tree_walker_impl(Node *node, return true; } break; + case T_SafeTypeCastExpr: + { + SafeTypeCastExpr *scexpr = (SafeTypeCastExpr *) node; + + if (WALK(scexpr->source_expr)) + return true; + if (WALK(scexpr->cast_expr)) + return true; + if (WALK(scexpr->default_expr)) + return true; + } + break; case T_CoalesceExpr: return WALK(((CoalesceExpr *) node)->args); case T_MinMaxExpr: @@ -3334,6 +3366,19 @@ expression_tree_mutator_impl(Node *node, return (Node *) newnode; } break; + case T_SafeTypeCastExpr: + { + SafeTypeCastExpr *scexpr = (SafeTypeCastExpr *) node; + SafeTypeCastExpr *newnode; + + FLATCOPY(newnode, scexpr, SafeTypeCastExpr); + MUTATE(newnode->source_expr, scexpr->source_expr, Node *); + MUTATE(newnode->cast_expr, scexpr->cast_expr, Node *); + MUTATE(newnode->default_expr, scexpr->default_expr, Node *); + + return (Node *) newnode; + } + break; case T_CoalesceExpr: { CoalesceExpr *coalesceexpr = (CoalesceExpr *) node; @@ -4468,6 +4513,28 @@ raw_expression_tree_walker_impl(Node *node, return true; } break; + case T_SafeTypeCast: + { + SafeTypeCast *sc = (SafeTypeCast *) node; + + if (WALK(sc->cast)) + return true; + if (WALK(sc->expr)) + return true; + } + break; + case T_SafeTypeCastExpr: + { + SafeTypeCastExpr *stc = (SafeTypeCastExpr *) node; + + if (WALK(stc->source_expr)) + return true; + if (WALK(stc->cast_expr)) + return true; + if (WALK(stc->default_expr)) + return true; + } + break; case T_CollateClause: return WALK(((CollateClause *) node)->arg); case T_SortBy: diff --git a/src/backend/nodes/queryjumblefuncs.c b/src/backend/nodes/queryjumblefuncs.c index 31f97151977..76426c88e9a 100644 --- a/src/backend/nodes/queryjumblefuncs.c +++ b/src/backend/nodes/queryjumblefuncs.c @@ -74,6 +74,7 @@ static void _jumbleElements(JumbleState *jstate, List *elements, Node *node); static void _jumbleParam(JumbleState *jstate, Node *node); static void _jumbleA_Const(JumbleState *jstate, Node *node); static void _jumbleVariableSetStmt(JumbleState *jstate, Node *node); +static void _jumbleSafeTypeCastExpr(JumbleState *jstate, Node *node); static void _jumbleRangeTblEntry_eref(JumbleState *jstate, RangeTblEntry *rte, Alias *expr); @@ -758,6 +759,19 @@ _jumbleVariableSetStmt(JumbleState *jstate, Node *node) JUMBLE_LOCATION(location); } +static void +_jumbleSafeTypeCastExpr(JumbleState *jstate, Node *node) +{ + SafeTypeCastExpr *expr = (SafeTypeCastExpr *) node; + + if (expr->cast_expr == NULL) + JUMBLE_NODE(source_expr); + else + JUMBLE_NODE(cast_expr); + + JUMBLE_NODE(default_expr); +} + /* * Custom query jumble function for RangeTblEntry.eref. */ diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c index 6f0b338d2cd..c04ca88b0fb 100644 --- a/src/backend/optimizer/util/clauses.c +++ b/src/backend/optimizer/util/clauses.c @@ -2942,6 +2942,25 @@ eval_const_expressions_mutator(Node *node, copyObject(jve->format)); } + case T_SafeTypeCastExpr: + { + SafeTypeCastExpr *stc = (SafeTypeCastExpr *) node; + SafeTypeCastExpr *newexpr; + Node *source_expr = stc->source_expr; + Node *default_expr = stc->default_expr; + + source_expr = eval_const_expressions_mutator(source_expr, context); + default_expr = eval_const_expressions_mutator(default_expr, context); + + newexpr = makeNode(SafeTypeCastExpr); + newexpr->source_expr = source_expr; + newexpr->cast_expr = stc->cast_expr; + newexpr->default_expr = default_expr; + newexpr->resulttype = stc->resulttype; + newexpr->resulttypmod = stc->resulttypmod; + newexpr->resultcollid = stc->resultcollid; + return (Node *) newexpr; + } case T_SubPlan: case T_AlternativeSubPlan: diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y index db43034b9db..20293d75524 100644 --- a/src/backend/parser/gram.y +++ b/src/backend/parser/gram.y @@ -642,6 +642,8 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query); %type PartitionBoundSpec %type hash_partbound %type hash_partbound_elem +%type cast_on_error_clause +%type cast_on_error_action %type json_format_clause json_format_clause_opt @@ -15931,8 +15933,25 @@ func_expr_common_subexpr: { $$ = makeSQLValueFunction(SVFOP_CURRENT_SCHEMA, -1, @1); } - | CAST '(' a_expr AS Typename ')' - { $$ = makeTypeCast($3, $5, @1); } + | CAST '(' a_expr AS Typename cast_on_error_clause ')' + { + TypeCast *cast = (TypeCast *) makeTypeCast($3, $5, @1); + if ($6 == NULL) + $$ = (Node *) cast; + else + { + SafeTypeCast *safecast = makeNode(SafeTypeCast); + + safecast->cast = (Node *) cast; + safecast->expr = $6; + + /* + * On-error actions must themselves be typecast to the + * same type as the original expression. + */ + $$ = (Node *) safecast; + } + } | EXTRACT '(' extract_list ')' { $$ = (Node *) makeFuncCall(SystemFuncName("extract"), @@ -16318,6 +16337,14 @@ func_expr_common_subexpr: } ; +cast_on_error_clause: cast_on_error_action ON CONVERSION_P ERROR_P { $$ = $1; } + | /* EMPTY */ { $$ = NULL; } + ; + +cast_on_error_action: ERROR_P { $$ = NULL; } + | NULL_P { $$ = makeNullAConst(-1); } + | DEFAULT a_expr { $$ = $2; } + ; /* * SQL/XML support diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c index d66276801c6..f837699d4b7 100644 --- a/src/backend/parser/parse_expr.c +++ b/src/backend/parser/parse_expr.c @@ -16,6 +16,8 @@ #include "postgres.h" #include "catalog/pg_aggregate.h" +#include "catalog/pg_cast.h" +#include "catalog/pg_proc.h" #include "catalog/pg_type.h" #include "commands/dbcommands.h" #include "miscadmin.h" @@ -37,6 +39,7 @@ #include "utils/date.h" #include "utils/fmgroids.h" #include "utils/lsyscache.h" +#include "utils/syscache.h" #include "utils/timestamp.h" #include "utils/xml.h" @@ -60,7 +63,10 @@ static Node *transformMultiAssignRef(ParseState *pstate, MultiAssignRef *maref); static Node *transformCaseExpr(ParseState *pstate, CaseExpr *c); static Node *transformSubLink(ParseState *pstate, SubLink *sublink); static Node *transformArrayExpr(ParseState *pstate, A_ArrayExpr *a, - Oid array_type, Oid element_type, int32 typmod); + Oid array_type, Oid element_type, int32 typmod, + bool *can_coerce); +static Node *transformArrayExprSafe(ParseState *pstate, A_ArrayExpr *a, + Oid array_type, Oid element_type, int32 typmod); static Node *transformRowExpr(ParseState *pstate, RowExpr *r, bool allowDefault); static Node *transformCoalesceExpr(ParseState *pstate, CoalesceExpr *c); static Node *transformMinMaxExpr(ParseState *pstate, MinMaxExpr *m); @@ -76,6 +82,7 @@ static Node *transformWholeRowRef(ParseState *pstate, int sublevels_up, int location); static Node *transformIndirection(ParseState *pstate, A_Indirection *ind); static Node *transformTypeCast(ParseState *pstate, TypeCast *tc); +static Node *transformTypeSafeCast(ParseState *pstate, SafeTypeCast *tc); static Node *transformCollateClause(ParseState *pstate, CollateClause *c); static Node *transformJsonObjectConstructor(ParseState *pstate, JsonObjectConstructor *ctor); @@ -106,6 +113,8 @@ static Expr *make_distinct_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree, int location); static Node *make_nulltest_from_distinct(ParseState *pstate, A_Expr *distincta, Node *arg); +static bool CovertUnknownConstSafe(ParseState *pstate, Node *node, + Oid targetType, int32 targetTypeMod); /* @@ -163,13 +172,17 @@ transformExprRecurse(ParseState *pstate, Node *expr) case T_A_ArrayExpr: result = transformArrayExpr(pstate, (A_ArrayExpr *) expr, - InvalidOid, InvalidOid, -1); + InvalidOid, InvalidOid, -1, NULL); break; case T_TypeCast: result = transformTypeCast(pstate, (TypeCast *) expr); break; + case T_SafeTypeCast: + result = transformTypeSafeCast(pstate, (SafeTypeCast *) expr); + break; + case T_CollateClause: result = transformCollateClause(pstate, (CollateClause *) expr); break; @@ -2004,16 +2017,127 @@ transformSubLink(ParseState *pstate, SubLink *sublink) return result; } +/* + * Return true iff successfuly coerced a Unknown Const to targetType +*/ +static bool CovertUnknownConstSafe(ParseState *pstate, Node *node, + Oid targetType, int32 targetTypeMod) +{ + Oid baseTypeId; + int32 baseTypeMod; + int32 inputTypeMod; + Type baseType; + char *string; + Datum datum; + bool converted; + Const *con; + + Assert(IsA(node, Const)); + Assert(exprType(node) == UNKNOWNOID); + + con = (Const *) node; + baseTypeMod = targetTypeMod; + baseTypeId = getBaseTypeAndTypmod(targetType, &baseTypeMod); + + if (baseTypeId == INTERVALOID) + inputTypeMod = baseTypeMod; + else + inputTypeMod = -1; + baseType = typeidType(baseTypeId); + + /* + * We assume here that UNKNOWN's internal representation is the same as + * CSTRING. + */ + if (!con->constisnull) + string = DatumGetCString(con->constvalue); + else + string = NULL; + + converted = stringTypeDatumSafe(baseType, + string, + inputTypeMod, + &datum); + + ReleaseSysCache(baseType); + + return converted; +} + +/* + * As with transformArrayExpr, we need to correctly parse back a query like + * CAST(ARRAY['three', 'a'] AS int[] DEFAULT '{21,22}' ON CONVERSION ERROR). We + * cannot allow eval_const_expressions to fold the A_ArrayExpr into a Const + * node, as this may cause an error too early. The A_ArrayExpr still need + * transformed into an ArrayExpr for the deparse purpose. + */ +static Node * +transformArrayExprSafe(ParseState *pstate, A_ArrayExpr *a, + Oid array_type, Oid element_type, int32 typmod) +{ + ArrayExpr *newa = makeNode(ArrayExpr); + List *newelems = NIL; + ListCell *element; + + newa->multidims = false; + foreach(element, a->elements) + { + Node *e = (Node *) lfirst(element); + Node *newe; + + /* + * If an element is itself an A_ArrayExpr, recurse directly so that we + * can pass down any target type we were given. + */ + if (IsA(e, A_ArrayExpr)) + { + newe = transformArrayExprSafe(pstate,(A_ArrayExpr *) e, array_type, element_type, typmod); + /* we certainly have an array here */ + Assert(array_type == InvalidOid || array_type == exprType(newe)); + newa->multidims = true; + } + else + { + newe = transformExprRecurse(pstate, e); + + if (!newa->multidims) + { + Oid newetype = exprType(newe); + + if (newetype != INT2VECTOROID && newetype != OIDVECTOROID && + type_is_array(newetype)) + newa->multidims = true; + } + } + + newelems = lappend(newelems, newe); + } + + newa->array_typeid = array_type; + /* array_collid will be set by parse_collate.c */ + newa->element_typeid = element_type; + newa->elements = newelems; + newa->list_start = a->list_start; + newa->list_end = -1; + newa->location = -1; + + return (Node *) newa; +} + /* * transformArrayExpr * * If the caller specifies the target type, the resulting array will * be of exactly that type. Otherwise we try to infer a common type * for the elements using select_common_type(). + * + * can_coerce is not null only when CAST(DEFAULT... ON CONVERSION ERROR) is + * specified. If we found out we can not cast to target type and can_coerce is + * not null, return NULL earlier and set can_coerce set false. */ static Node * transformArrayExpr(ParseState *pstate, A_ArrayExpr *a, - Oid array_type, Oid element_type, int32 typmod) + Oid array_type, Oid element_type, int32 typmod, bool *can_coerce) { ArrayExpr *newa = makeNode(ArrayExpr); List *newelems = NIL; @@ -2044,9 +2168,10 @@ transformArrayExpr(ParseState *pstate, A_ArrayExpr *a, (A_ArrayExpr *) e, array_type, element_type, - typmod); + typmod, + can_coerce); /* we certainly have an array here */ - Assert(array_type == InvalidOid || array_type == exprType(newe)); + Assert(can_coerce || array_type == InvalidOid || array_type == exprType(newe)); newa->multidims = true; } else @@ -2072,6 +2197,9 @@ transformArrayExpr(ParseState *pstate, A_ArrayExpr *a, newelems = lappend(newelems, newe); } + if (can_coerce && !*can_coerce) + return NULL; + /* * Select a target type for the elements. * @@ -2139,6 +2267,17 @@ transformArrayExpr(ParseState *pstate, A_ArrayExpr *a, Node *e = (Node *) lfirst(element); Node *newe; + if (can_coerce && (*can_coerce) && IsA(e, Const) && exprType(e) == UNKNOWNOID) + { + if (!CovertUnknownConstSafe(pstate, e, coerce_type, typmod)) + { + *can_coerce = false; + list_free(newcoercedelems); + newcoercedelems = NIL; + return NULL; + } + } + if (coerce_hard) { newe = coerce_to_target_type(pstate, e, @@ -2742,7 +2881,8 @@ transformTypeCast(ParseState *pstate, TypeCast *tc) (A_ArrayExpr *) arg, targetBaseType, elementType, - targetBaseTypmod); + targetBaseTypmod, + NULL); } else expr = transformExprRecurse(pstate, arg); @@ -2779,6 +2919,199 @@ transformTypeCast(ParseState *pstate, TypeCast *tc) return result; } + +/* + * Handle an explicit CAST(... DEFAULT ... ON CONVERSION ERROR) construct. + * + * Transform SafeTypeCast node, look up the type name, and apply any necessary + * coercion function(s). + */ +static Node * +transformTypeSafeCast(ParseState *pstate, SafeTypeCast *tc) +{ + SafeTypeCastExpr *result; + TypeCast *tcast = (TypeCast *) tc->cast; + Node *tc_arg = tcast->arg; + Node *def_expr; + Node *cast_expr = NULL; + Node *source_expr = NULL; + Node *array_expr = NULL; + Oid inputType = InvalidOid; + Oid targetType; + Oid targetBaseType; + int32 targetTypmod; + int32 targetBaseTypmod; + bool can_coerce = true; + int def_expr_loc = -1; + int location; + + result = makeNode(SafeTypeCastExpr); + + /* Look up the type name first */ + typenameTypeIdAndMod(pstate, tcast->typeName, &targetType, &targetTypmod); + targetBaseTypmod = targetTypmod; + targetBaseType = getBaseTypeAndTypmod(targetType, &targetBaseTypmod); + + result->resulttype = targetType; + result->resulttypmod = targetTypmod; + /* now looking at cast fail default expression */ + def_expr_loc = exprLocation(tc->expr); + def_expr = transformExprRecurse(pstate, tc->expr); + + if (expression_returns_set(def_expr)) + ereport(ERROR, + errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("DEFAULT expression must not return a set"), + parser_coercion_errposition(pstate, def_expr_loc, def_expr)); + + if (IsA(def_expr, Aggref) || IsA(def_expr, WindowFunc)) + ereport(ERROR, + errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("DEFAULT expression function must be a normal function"), + parser_coercion_errposition(pstate, def_expr_loc, def_expr)); + + if (IsA(def_expr, FuncExpr)) + { + if (get_func_prokind(((FuncExpr *) def_expr)->funcid) != PROKIND_FUNCTION) + ereport(ERROR, + errcode(ERRCODE_INVALID_OBJECT_DEFINITION), + errmsg("DEFAULT expression function must be a normal function"), + parser_coercion_errposition(pstate, def_expr_loc, def_expr)); + } + + def_expr = coerce_to_target_type(pstate, def_expr, exprType(def_expr), + targetType, targetTypmod, + COERCION_EXPLICIT, + COERCE_EXPLICIT_CAST, + exprLocation(def_expr)); + if (def_expr == NULL) + ereport(ERROR, + errcode(ERRCODE_CANNOT_COERCE), + errmsg("cannot cast DEFAULT clause for CAST ... ON CONVERSION ERROR to type %s", + format_type_be(targetType)), + parser_coercion_errposition(pstate, def_expr_loc, def_expr)); + + /* + * If the subject of the typecast is an ARRAY[] construct and the target + * type is an array type, we invoke transformArrayExpr() directly so that + * we can pass down the type information. This avoids some cases where + * transformArrayExpr() might not infer the correct type. Otherwise, just + * transform the argument normally. + */ + if (IsA(tc_arg, A_ArrayExpr)) + { + Oid elementType; + + /* + * If target is a domain over array, work with the base array type + * here. Below, we'll cast the array type to the domain. In the + * usual case that the target is not a domain, the remaining steps + * will be a no-op. + */ + elementType = get_element_type(targetBaseType); + + if (OidIsValid(elementType)) + { + array_expr = copyObject(tc_arg); + + source_expr = transformArrayExpr(pstate, + (A_ArrayExpr *) tc_arg, + targetBaseType, + elementType, + targetBaseTypmod, + &can_coerce); + if (!can_coerce) + { + Assert(source_expr == NULL); + source_expr = transformArrayExprSafe(pstate, + (A_ArrayExpr *) array_expr, + targetBaseType, + elementType, + targetBaseTypmod); + } + } + else + source_expr = transformExprRecurse(pstate, tc_arg); + } + else + source_expr = transformExprRecurse(pstate, tc_arg); + + inputType = exprType(source_expr); + if (inputType == InvalidOid && can_coerce) + return (Node *) result; /* do nothing if NULL input */ + + if (can_coerce && IsA(source_expr, Const) && exprType(source_expr) == UNKNOWNOID) + can_coerce = CovertUnknownConstSafe(pstate, + source_expr, + targetType, + targetTypmod); + + /* + * Location of the coercion is preferentially the location of the :: or + * CAST symbol, but if there is none then use the location of the type + * name (this can happen in TypeName 'string' syntax, for instance). + */ + location = tcast->location; + if (location < 0) + location = tcast->typeName->location; + + if (can_coerce) + { + Node *origexpr; + cast_expr = coerce_to_target_type(pstate, source_expr, inputType, + targetType, targetTypmod, + COERCION_EXPLICIT, + COERCE_EXPLICIT_CAST, + location); + origexpr = cast_expr; + while (cast_expr && IsA(cast_expr, CollateExpr)) + cast_expr = (Node *) ((CollateExpr *) cast_expr)->arg; + + if (cast_expr && IsA(cast_expr, FuncExpr)) + { + HeapTuple tuple; + ListCell *lc; + Node *sexpr; + FuncExpr *fexpr = (FuncExpr *) cast_expr; + + lc = list_head(fexpr->args); + sexpr = (Node *) lfirst(lc); + + /* Look in pg_cast */ + tuple = SearchSysCache2(CASTSOURCETARGET, + ObjectIdGetDatum(exprType(sexpr)), + ObjectIdGetDatum(targetType)); + + if (HeapTupleIsValid(tuple)) + { + Form_pg_cast castForm = (Form_pg_cast) GETSTRUCT(tuple); + if (!castForm->casterrorsafe) + ereport(ERROR, + errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("cannot cast type %s to %s when %s clause is specified for %s", + format_type_be(inputType), + format_type_be(targetType), + "DEFAULT", + "CAST ... ON CONVERSION ERROR"), + errhint("Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast"), + parser_errposition(pstate, exprLocation(source_expr))); + } + else + elog(ERROR, "cache lookup failed for pg_cast entry (%s cast to %s)", + format_type_be(inputType), + format_type_be(targetType)); + ReleaseSysCache(tuple); + } + cast_expr = origexpr; + } + + result->source_expr = source_expr; + result->cast_expr = cast_expr; + result->default_expr = def_expr; + + return (Node *) result; +} + /* * Handle an explicit COLLATE clause. * diff --git a/src/backend/parser/parse_target.c b/src/backend/parser/parse_target.c index 4aba0d9d4d5..812ed18c162 100644 --- a/src/backend/parser/parse_target.c +++ b/src/backend/parser/parse_target.c @@ -1823,6 +1823,20 @@ FigureColnameInternal(Node *node, char **name) } } break; + case T_SafeTypeCast: + strength = FigureColnameInternal(((SafeTypeCast *) node)->cast, + name); + if (strength <= 1) + { + TypeCast *node_cast; + node_cast = (TypeCast *)((SafeTypeCast *) node)->cast; + if (node_cast->typeName != NULL) + { + *name = strVal(llast(node_cast->typeName->names)); + return 1; + } + } + break; case T_CollateClause: return FigureColnameInternal(((CollateClause *) node)->arg, name); case T_GroupingFunc: diff --git a/src/backend/parser/parse_type.c b/src/backend/parser/parse_type.c index 7713bdc6af0..02e5f9c92d7 100644 --- a/src/backend/parser/parse_type.c +++ b/src/backend/parser/parse_type.c @@ -19,6 +19,7 @@ #include "catalog/pg_type.h" #include "lib/stringinfo.h" #include "nodes/makefuncs.h" +#include "nodes/miscnodes.h" #include "parser/parse_type.h" #include "parser/parser.h" #include "utils/array.h" @@ -660,6 +661,18 @@ stringTypeDatum(Type tp, char *string, int32 atttypmod) return OidInputFunctionCall(typinput, string, typioparam, atttypmod); } +bool +stringTypeDatumSafe(Type tp, char *string, int32 atttypmod, Datum *result) +{ + Form_pg_type typform = (Form_pg_type) GETSTRUCT(tp); + Oid typinput = typform->typinput; + Oid typioparam = getTypeIOParam(tp); + ErrorSaveContext escontext = {T_ErrorSaveContext}; + + return OidInputFunctionCallSafe(typinput, string, typioparam, atttypmod, + (fmNodePtr) &escontext, result); +} + /* * Given a typeid, return the type's typrelid (associated relation), if any. * Returns InvalidOid if type is not a composite type. diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c index b5f98bf22f9..6bd8a989dbd 100644 --- a/src/backend/utils/adt/arrayfuncs.c +++ b/src/backend/utils/adt/arrayfuncs.c @@ -3295,6 +3295,12 @@ array_map(Datum arrayd, return (Datum) 0; } + if (SOFT_ERROR_OCCURRED(exprstate->escontext)) + { + pfree(values); + pfree(nulls); + return (Datum) 0; + } if (nulls[i]) hasnulls = true; else diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index 3d6e6bdbfd2..ee868de2c64 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -10534,6 +10534,21 @@ get_rule_expr(Node *node, deparse_context *context, } break; + case T_SafeTypeCastExpr: + { + SafeTypeCastExpr *stcexpr = castNode(SafeTypeCastExpr, node); + + appendStringInfoString(buf, "CAST("); + get_rule_expr(stcexpr->source_expr, context, showimplicit); + + appendStringInfo(buf, " AS %s ", + format_type_with_typemod(stcexpr->resulttype, stcexpr->resulttypmod)); + + appendStringInfoString(buf, "DEFAULT "); + get_rule_expr(stcexpr->default_expr, context, showimplicit); + appendStringInfoString(buf, " ON CONVERSION ERROR)"); + } + break; case T_JsonExpr: { JsonExpr *jexpr = (JsonExpr *) node; diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c index 782291d9998..9de895e682f 100644 --- a/src/backend/utils/fmgr/fmgr.c +++ b/src/backend/utils/fmgr/fmgr.c @@ -1759,6 +1759,19 @@ OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod) return InputFunctionCall(&flinfo, str, typioparam, typmod); } +bool +OidInputFunctionCallSafe(Oid functionId, char *str, Oid typioparam, + int32 typmod, fmNodePtr escontext, + Datum *result) +{ + FmgrInfo flinfo; + + fmgr_info(functionId, &flinfo); + + return InputFunctionCallSafe(&flinfo, str, typioparam, typmod, + escontext, result); +} + char * OidOutputFunctionCall(Oid functionId, Datum val) { diff --git a/src/include/catalog/pg_cast.dat b/src/include/catalog/pg_cast.dat index fbfd669587f..3adef6b4faf 100644 --- a/src/include/catalog/pg_cast.dat +++ b/src/include/catalog/pg_cast.dat @@ -19,65 +19,65 @@ # int2->int4->int8->numeric->float4->float8, while casts in the # reverse direction are assignment-only. { castsource => 'int8', casttarget => 'int2', castfunc => 'int2(int8)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int8', casttarget => 'int4', castfunc => 'int4(int8)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int8', casttarget => 'float4', castfunc => 'float4(int8)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int8', casttarget => 'float8', castfunc => 'float8(int8)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int8', casttarget => 'numeric', castfunc => 'numeric(int8)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'int8', castfunc => 'int8(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'int4', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'float4', castfunc => 'float4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'float8', castfunc => 'float8(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'numeric', castfunc => 'numeric(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'int8', castfunc => 'int8(int4)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'int2', castfunc => 'int2(int4)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'float4', castfunc => 'float4(int4)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'float8', castfunc => 'float8(int4)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'numeric', castfunc => 'numeric(int4)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'float4', casttarget => 'int8', castfunc => 'int8(float4)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'float4', casttarget => 'int2', castfunc => 'int2(float4)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'float4', casttarget => 'int4', castfunc => 'int4(float4)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'float4', casttarget => 'float8', castfunc => 'float8(float4)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'float4', casttarget => 'numeric', - castfunc => 'numeric(float4)', castcontext => 'a', castmethod => 'f' }, + castfunc => 'numeric(float4)', castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'float8', casttarget => 'int8', castfunc => 'int8(float8)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'float8', casttarget => 'int2', castfunc => 'int2(float8)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'float8', casttarget => 'int4', castfunc => 'int4(float8)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'float8', casttarget => 'float4', castfunc => 'float4(float8)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'float8', casttarget => 'numeric', - castfunc => 'numeric(float8)', castcontext => 'a', castmethod => 'f' }, + castfunc => 'numeric(float8)', castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'numeric', casttarget => 'int8', castfunc => 'int8(numeric)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'numeric', casttarget => 'int2', castfunc => 'int2(numeric)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'numeric', casttarget => 'int4', castfunc => 'int4(numeric)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'numeric', casttarget => 'float4', - castfunc => 'float4(numeric)', castcontext => 'i', castmethod => 'f' }, + castfunc => 'float4(numeric)', castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'numeric', casttarget => 'float8', - castfunc => 'float8(numeric)', castcontext => 'i', castmethod => 'f' }, + castfunc => 'float8(numeric)', castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'money', casttarget => 'numeric', castfunc => 'numeric(money)', castcontext => 'a', castmethod => 'f' }, { castsource => 'numeric', casttarget => 'money', castfunc => 'money(numeric)', @@ -89,13 +89,13 @@ # Allow explicit coercions between int4 and bool { castsource => 'int4', casttarget => 'bool', castfunc => 'bool(int4)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bool', casttarget => 'int4', castfunc => 'int4(bool)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, # Allow explicit coercions between xid8 and xid { castsource => 'xid8', casttarget => 'xid', castfunc => 'xid(xid8)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, # OID category: allow implicit conversion from any integral type (including # int8, to support OID literals > 2G) to OID, as well as assignment coercion @@ -106,13 +106,13 @@ # casts from text and varchar to regclass, which exist mainly to support # legacy forms of nextval() and related functions. { castsource => 'int8', casttarget => 'oid', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'oid', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'oid', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'oid', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'oid', casttarget => 'regproc', castfunc => '0', @@ -120,13 +120,13 @@ { castsource => 'regproc', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regproc', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regproc', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regproc', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regproc', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regproc', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'regproc', casttarget => 'regprocedure', castfunc => '0', @@ -138,13 +138,13 @@ { castsource => 'regprocedure', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regprocedure', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regprocedure', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regprocedure', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regprocedure', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regprocedure', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'oid', casttarget => 'regoper', castfunc => '0', @@ -152,13 +152,13 @@ { castsource => 'regoper', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regoper', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regoper', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regoper', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regoper', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regoper', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'regoper', casttarget => 'regoperator', castfunc => '0', @@ -170,13 +170,13 @@ { castsource => 'regoperator', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regoperator', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regoperator', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regoperator', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regoperator', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regoperator', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'oid', casttarget => 'regclass', castfunc => '0', @@ -184,13 +184,13 @@ { castsource => 'regclass', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regclass', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regclass', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regclass', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regclass', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regclass', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'oid', casttarget => 'regcollation', castfunc => '0', @@ -198,13 +198,13 @@ { castsource => 'regcollation', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regcollation', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regcollation', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regcollation', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regcollation', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regcollation', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'oid', casttarget => 'regtype', castfunc => '0', @@ -212,13 +212,13 @@ { castsource => 'regtype', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regtype', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regtype', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regtype', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regtype', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regtype', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'oid', casttarget => 'regconfig', castfunc => '0', @@ -226,13 +226,13 @@ { castsource => 'regconfig', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regconfig', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regconfig', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regconfig', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regconfig', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regconfig', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'oid', casttarget => 'regdictionary', castfunc => '0', @@ -240,31 +240,31 @@ { castsource => 'regdictionary', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regdictionary', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regdictionary', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regdictionary', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regdictionary', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regdictionary', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'text', casttarget => 'regclass', castfunc => 'regclass', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'varchar', casttarget => 'regclass', castfunc => 'regclass', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'oid', casttarget => 'regrole', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regrole', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regrole', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regrole', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regrole', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regrole', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regrole', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'oid', casttarget => 'regnamespace', castfunc => '0', @@ -272,13 +272,13 @@ { castsource => 'regnamespace', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regnamespace', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regnamespace', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regnamespace', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regnamespace', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regnamespace', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'oid', casttarget => 'regdatabase', castfunc => '0', @@ -286,13 +286,13 @@ { castsource => 'regdatabase', casttarget => 'oid', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'int8', casttarget => 'regdatabase', castfunc => 'oid', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int2', casttarget => 'regdatabase', castfunc => 'int4(int2)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'regdatabase', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'regdatabase', casttarget => 'int8', castfunc => 'int8(oid)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'regdatabase', casttarget => 'int4', castfunc => '0', castcontext => 'a', castmethod => 'b' }, @@ -302,57 +302,57 @@ { castsource => 'text', casttarget => 'varchar', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'bpchar', casttarget => 'text', castfunc => 'text(bpchar)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bpchar', casttarget => 'varchar', castfunc => 'text(bpchar)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'varchar', casttarget => 'text', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'varchar', casttarget => 'bpchar', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'char', casttarget => 'text', castfunc => 'text(char)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'char', casttarget => 'bpchar', castfunc => 'bpchar(char)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'char', casttarget => 'varchar', castfunc => 'text(char)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'name', casttarget => 'text', castfunc => 'text(name)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'name', casttarget => 'bpchar', castfunc => 'bpchar(name)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'name', casttarget => 'varchar', castfunc => 'varchar(name)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'text', casttarget => 'char', castfunc => 'char(text)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bpchar', casttarget => 'char', castfunc => 'char(text)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'varchar', casttarget => 'char', castfunc => 'char(text)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'text', casttarget => 'name', castfunc => 'name(text)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bpchar', casttarget => 'name', castfunc => 'name(bpchar)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'varchar', casttarget => 'name', castfunc => 'name(varchar)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, # Allow explicit coercions between bytea and integer types { castsource => 'int2', casttarget => 'bytea', castfunc => 'bytea(int2)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'bytea', castfunc => 'bytea(int4)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int8', casttarget => 'bytea', castfunc => 'bytea(int8)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bytea', casttarget => 'int2', castfunc => 'int2(bytea)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bytea', casttarget => 'int4', castfunc => 'int4(bytea)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bytea', casttarget => 'int8', castfunc => 'int8(bytea)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, # Allow explicit coercions between int4 and "char" { castsource => 'char', casttarget => 'int4', castfunc => 'int4(char)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'char', castfunc => 'char(int4)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, # pg_node_tree can be coerced to, but not from, text { castsource => 'pg_node_tree', casttarget => 'text', castfunc => '0', @@ -378,31 +378,31 @@ # Datetime category { castsource => 'date', casttarget => 'timestamp', - castfunc => 'timestamp(date)', castcontext => 'i', castmethod => 'f' }, + castfunc => 'timestamp(date)', castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'date', casttarget => 'timestamptz', - castfunc => 'timestamptz(date)', castcontext => 'i', castmethod => 'f' }, + castfunc => 'timestamptz(date)', castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'time', casttarget => 'interval', castfunc => 'interval(time)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'time', casttarget => 'timetz', castfunc => 'timetz(time)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'timestamp', casttarget => 'date', - castfunc => 'date(timestamp)', castcontext => 'a', castmethod => 'f' }, + castfunc => 'date(timestamp)', castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'timestamp', casttarget => 'time', - castfunc => 'time(timestamp)', castcontext => 'a', castmethod => 'f' }, + castfunc => 'time(timestamp)', castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'timestamp', casttarget => 'timestamptz', - castfunc => 'timestamptz(timestamp)', castcontext => 'i', castmethod => 'f' }, + castfunc => 'timestamptz(timestamp)', castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'timestamptz', casttarget => 'date', - castfunc => 'date(timestamptz)', castcontext => 'a', castmethod => 'f' }, + castfunc => 'date(timestamptz)', castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'timestamptz', casttarget => 'time', - castfunc => 'time(timestamptz)', castcontext => 'a', castmethod => 'f' }, + castfunc => 'time(timestamptz)', castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'timestamptz', casttarget => 'timestamp', - castfunc => 'timestamp(timestamptz)', castcontext => 'a', castmethod => 'f' }, + castfunc => 'timestamp(timestamptz)', castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'timestamptz', casttarget => 'timetz', - castfunc => 'timetz(timestamptz)', castcontext => 'a', castmethod => 'f' }, + castfunc => 'timetz(timestamptz)', castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'interval', casttarget => 'time', castfunc => 'time(interval)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'timetz', casttarget => 'time', castfunc => 'time(timetz)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, # Geometric category { castsource => 'point', casttarget => 'box', castfunc => 'box(point)', @@ -436,15 +436,15 @@ # MAC address category { castsource => 'macaddr', casttarget => 'macaddr8', castfunc => 'macaddr8', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'macaddr8', casttarget => 'macaddr', castfunc => 'macaddr', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, # INET category { castsource => 'cidr', casttarget => 'inet', castfunc => '0', castcontext => 'i', castmethod => 'b' }, { castsource => 'inet', casttarget => 'cidr', castfunc => 'cidr', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, # BitString category { castsource => 'bit', casttarget => 'varbit', castfunc => '0', @@ -454,13 +454,13 @@ # Cross-category casts between bit and int4, int8 { castsource => 'int8', casttarget => 'bit', castfunc => 'bit(int8,int4)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int4', casttarget => 'bit', castfunc => 'bit(int4,int4)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bit', casttarget => 'int8', castfunc => 'int8(bit)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bit', casttarget => 'int4', castfunc => 'int4(bit)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, # Cross-category casts to and from TEXT # We need entries here only for a few specialized cases where the behavior @@ -471,68 +471,68 @@ # behavior will ensue when the automatic cast is applied instead of the # pg_cast entry! { castsource => 'cidr', casttarget => 'text', castfunc => 'text(inet)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'inet', casttarget => 'text', castfunc => 'text(inet)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bool', casttarget => 'text', castfunc => 'text(bool)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'xml', casttarget => 'text', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'text', casttarget => 'xml', castfunc => 'xml', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, # Cross-category casts to and from VARCHAR # We support all the same casts as for TEXT. { castsource => 'cidr', casttarget => 'varchar', castfunc => 'text(inet)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'inet', casttarget => 'varchar', castfunc => 'text(inet)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bool', casttarget => 'varchar', castfunc => 'text(bool)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'xml', casttarget => 'varchar', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'varchar', casttarget => 'xml', castfunc => 'xml', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, # Cross-category casts to and from BPCHAR # We support all the same casts as for TEXT. { castsource => 'cidr', casttarget => 'bpchar', castfunc => 'text(inet)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'inet', casttarget => 'bpchar', castfunc => 'text(inet)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bool', casttarget => 'bpchar', castfunc => 'text(bool)', - castcontext => 'a', castmethod => 'f' }, + castcontext => 'a', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'xml', casttarget => 'bpchar', castfunc => '0', castcontext => 'a', castmethod => 'b' }, { castsource => 'bpchar', casttarget => 'xml', castfunc => 'xml', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, # Length-coercion functions { castsource => 'bpchar', casttarget => 'bpchar', castfunc => 'bpchar(bpchar,int4,bool)', castcontext => 'i', - castmethod => 'f' }, + castmethod => 'f', casterrorsafe => 't' }, { castsource => 'varchar', casttarget => 'varchar', castfunc => 'varchar(varchar,int4,bool)', castcontext => 'i', - castmethod => 'f' }, + castmethod => 'f', casterrorsafe => 't' }, { castsource => 'time', casttarget => 'time', castfunc => 'time(time,int4)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'timestamp', casttarget => 'timestamp', castfunc => 'timestamp(timestamp,int4)', castcontext => 'i', - castmethod => 'f' }, + castmethod => 'f', casterrorsafe => 't' }, { castsource => 'timestamptz', casttarget => 'timestamptz', castfunc => 'timestamptz(timestamptz,int4)', castcontext => 'i', - castmethod => 'f' }, + castmethod => 'f', casterrorsafe => 't' }, { castsource => 'interval', casttarget => 'interval', castfunc => 'interval(interval,int4)', castcontext => 'i', - castmethod => 'f' }, + castmethod => 'f', casterrorsafe => 't' }, { castsource => 'timetz', casttarget => 'timetz', - castfunc => 'timetz(timetz,int4)', castcontext => 'i', castmethod => 'f' }, + castfunc => 'timetz(timetz,int4)', castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'bit', casttarget => 'bit', castfunc => 'bit(bit,int4,bool)', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'varbit', casttarget => 'varbit', castfunc => 'varbit', - castcontext => 'i', castmethod => 'f' }, + castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'numeric', casttarget => 'numeric', - castfunc => 'numeric(numeric,int4)', castcontext => 'i', castmethod => 'f' }, + castfunc => 'numeric(numeric,int4)', castcontext => 'i', castmethod => 'f', casterrorsafe => 't' }, # json to/from jsonb { castsource => 'json', casttarget => 'jsonb', castfunc => '0', @@ -542,36 +542,36 @@ # jsonb to numeric and bool types { castsource => 'jsonb', casttarget => 'bool', castfunc => 'bool(jsonb)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'jsonb', casttarget => 'numeric', castfunc => 'numeric(jsonb)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'jsonb', casttarget => 'int2', castfunc => 'int2(jsonb)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'jsonb', casttarget => 'int4', castfunc => 'int4(jsonb)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'jsonb', casttarget => 'int8', castfunc => 'int8(jsonb)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'jsonb', casttarget => 'float4', castfunc => 'float4(jsonb)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'jsonb', casttarget => 'float8', castfunc => 'float8(jsonb)', - castcontext => 'e', castmethod => 'f' }, + castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, # range to multirange { castsource => 'int4range', casttarget => 'int4multirange', castfunc => 'int4multirange(int4range)', castcontext => 'e', - castmethod => 'f' }, + castmethod => 'f', casterrorsafe => 't' }, { castsource => 'int8range', casttarget => 'int8multirange', castfunc => 'int8multirange(int8range)', castcontext => 'e', - castmethod => 'f' }, + castmethod => 'f', casterrorsafe => 't' }, { castsource => 'numrange', casttarget => 'nummultirange', castfunc => 'nummultirange(numrange)', castcontext => 'e', - castmethod => 'f' }, + castmethod => 'f', casterrorsafe => 't' }, { castsource => 'daterange', casttarget => 'datemultirange', castfunc => 'datemultirange(daterange)', castcontext => 'e', - castmethod => 'f' }, + castmethod => 'f', casterrorsafe => 't' }, { castsource => 'tsrange', casttarget => 'tsmultirange', - castfunc => 'tsmultirange(tsrange)', castcontext => 'e', castmethod => 'f' }, + castfunc => 'tsmultirange(tsrange)', castcontext => 'e', castmethod => 'f', casterrorsafe => 't' }, { castsource => 'tstzrange', casttarget => 'tstzmultirange', castfunc => 'tstzmultirange(tstzrange)', castcontext => 'e', - castmethod => 'f' }, + castmethod => 'f', casterrorsafe => 't' }, ] diff --git a/src/include/catalog/pg_cast.h b/src/include/catalog/pg_cast.h index 6a0ca337153..218d81d535a 100644 --- a/src/include/catalog/pg_cast.h +++ b/src/include/catalog/pg_cast.h @@ -47,6 +47,10 @@ CATALOG(pg_cast,2605,CastRelationId) /* cast method */ char castmethod; + + /* cast function error safe */ + bool casterrorsafe BKI_DEFAULT(f); + } FormData_pg_cast; /* ---------------- diff --git a/src/include/executor/execExpr.h b/src/include/executor/execExpr.h index 75366203706..0afcf09c086 100644 --- a/src/include/executor/execExpr.h +++ b/src/include/executor/execExpr.h @@ -265,6 +265,7 @@ typedef enum ExprEvalOp EEOP_XMLEXPR, EEOP_JSON_CONSTRUCTOR, EEOP_IS_JSON, + EEOP_SAFETYPE_CAST, EEOP_JSONEXPR_PATH, EEOP_JSONEXPR_COERCION, EEOP_JSONEXPR_COERCION_FINISH, @@ -750,6 +751,12 @@ typedef struct ExprEvalStep JsonIsPredicate *pred; /* original expression node */ } is_json; + /* for EEOP_SAFECAST */ + struct + { + struct SafeTypeCastState *stcstate; /* original expression node */ + } stcexpr; + /* for EEOP_JSONEXPR_PATH */ struct { @@ -892,6 +899,7 @@ extern int ExecEvalJsonExprPath(ExprState *state, ExprEvalStep *op, ExprContext *econtext); extern void ExecEvalJsonCoercion(ExprState *state, ExprEvalStep *op, ExprContext *econtext); +int ExecEvalSafeTypeCast(ExprState *state, ExprEvalStep *op); extern void ExecEvalJsonCoercionFinish(ExprState *state, ExprEvalStep *op); extern void ExecEvalGroupingFunc(ExprState *state, ExprEvalStep *op); extern void ExecEvalMergeSupportFunc(ExprState *state, ExprEvalStep *op, diff --git a/src/include/fmgr.h b/src/include/fmgr.h index 0fe7b4ebc77..299d4eef4ed 100644 --- a/src/include/fmgr.h +++ b/src/include/fmgr.h @@ -750,6 +750,9 @@ extern bool DirectInputFunctionCallSafe(PGFunction func, char *str, Datum *result); extern Datum OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod); +extern bool OidInputFunctionCallSafe(Oid functionId, char *str, Oid typioparam, + int32 typmod, fmNodePtr escontext, + Datum *result); extern char *OutputFunctionCall(FmgrInfo *flinfo, Datum val); extern char *OidOutputFunctionCall(Oid functionId, Datum val); extern Datum ReceiveFunctionCall(FmgrInfo *flinfo, fmStringInfo buf, diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index e107d6e5f81..282bfa770ef 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1058,6 +1058,36 @@ typedef struct DomainConstraintState ExprState *check_exprstate; /* check_expr's eval state, or NULL */ } DomainConstraintState; +typedef struct SafeTypeCastState +{ + SafeTypeCastExpr *stcexpr; + + /* Set to true if type cast cause an error. */ + NullableDatum error; + + /* + * Addresses of steps that implement DEFAULT expr ON CONVERSION ERROR for + * safe type cast. + */ + int jump_error; + + /* + * Address to jump to when skipping all the steps to evaulate the default + * expression after performing ExecEvalSafeTypeCast(). + */ + int jump_end; + + /* + * For error-safe evaluation of coercions. When DEFAULT expr ON CONVERSION + * ON ERROR is specified, a pointer to this is passed to ExecInitExprRec() + * when initializing the coercion expressions, see ExecInitSafeTypeCastExpr. + * + * Reset for each evaluation of EEOP_SAFETYPE_CAST. + */ + ErrorSaveContext escontext; + +} SafeTypeCastState; + /* * State for JsonExpr evaluation, too big to inline. * diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h index 86a236bd58b..95174e0feef 100644 --- a/src/include/nodes/parsenodes.h +++ b/src/include/nodes/parsenodes.h @@ -399,6 +399,12 @@ typedef struct TypeCast ParseLoc location; /* token location, or -1 if unknown */ } TypeCast; +typedef struct SafeTypeCast +{ + NodeTag type; + Node *cast; + Node *expr; /* default expr */ +} SafeTypeCast; /* * CollateClause - a COLLATE expression */ diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h index 6dfca3cb35b..d2df7c28932 100644 --- a/src/include/nodes/primnodes.h +++ b/src/include/nodes/primnodes.h @@ -756,6 +756,41 @@ typedef enum CoercionForm COERCE_SQL_SYNTAX, /* display with SQL-mandated special syntax */ } CoercionForm; +/* + * SafeTypeCastExpr - + * Transformed representation of + * CAST(expr AS typename DEFAULT expr2 ON ERROR) + * CAST(expr AS typename NULL ON ERROR) + */ +typedef struct SafeTypeCastExpr +{ + pg_node_attr(custom_query_jumble) + + Expr xpr; + + /* transformed expression being casted */ + Node *source_expr; + + /* + * The transformed cast expression; this may be NULL if the two types can't + * be cast. + */ + Node *cast_expr; + + /* Fall back to the default expression if the cast evaluation fails. */ + Node *default_expr; + + /* cast result data type */ + Oid resulttype pg_node_attr(query_jumble_ignore); + + /* cast result data type typmod (usually -1) */ + int32 resulttypmod pg_node_attr(query_jumble_ignore); + + /* cast result data type collation (usually -1) */ + Oid resultcollid pg_node_attr(query_jumble_ignore); + +} SafeTypeCastExpr; + /* * FuncExpr - expression node for a function call * diff --git a/src/include/parser/parse_type.h b/src/include/parser/parse_type.h index 0d919d8bfa2..12381aed64c 100644 --- a/src/include/parser/parse_type.h +++ b/src/include/parser/parse_type.h @@ -47,6 +47,8 @@ extern char *typeTypeName(Type t); extern Oid typeTypeRelid(Type typ); extern Oid typeTypeCollation(Type typ); extern Datum stringTypeDatum(Type tp, char *string, int32 atttypmod); +extern bool stringTypeDatumSafe(Type tp, char *string, int32 atttypmod, + Datum *result); extern Oid typeidTypeRelid(Oid type_id); extern Oid typeOrDomainTypeRelid(Oid type_id); diff --git a/src/test/regress/expected/cast.out b/src/test/regress/expected/cast.out new file mode 100644 index 00000000000..bf62e9348f1 --- /dev/null +++ b/src/test/regress/expected/cast.out @@ -0,0 +1,556 @@ +SET extra_float_digits = 0; +-- CAST DEFAULT ON CONVERSION ERROR +VALUES (CAST('error' AS integer ERROR ON CONVERSION ERROR)); --error +ERROR: invalid input syntax for type integer: "error" +LINE 1: VALUES (CAST('error' AS integer ERROR ON CONVERSION ERROR)); + ^ +VALUES (CAST('error' AS integer NULL ON CONVERSION ERROR)); + column1 +--------- + +(1 row) + +VALUES (CAST('error' AS integer DEFAULT 42 ON CONVERSION ERROR)); + column1 +--------- + 42 +(1 row) + +SELECT CAST(1 AS date DEFAULT NULL ON CONVERSION ERROR); + date +------ + +(1 row) + +SELECT CAST(1::numeric AS money DEFAULT NULL ON CONVERSION ERROR); +ERROR: cannot cast type numeric to money when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(1::numeric AS money DEFAULT NULL ON CONVERSION E... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(1111 AS "char" DEFAULT NULL ON CONVERSION ERROR); + char +------ + +(1 row) + +CREATE OR REPLACE FUNCTION ret_int8() RETURNS bigint AS +$$ +BEGIN RETURN 2147483648; END; +$$ +LANGUAGE plpgsql IMMUTABLE; +SELECT CAST('a' as int DEFAULT ret_int8() ON CONVERSION ERROR); --error +ERROR: integer out of range +SELECT CAST('a' as date DEFAULT ret_int8() ON CONVERSION ERROR); --error +ERROR: cannot cast DEFAULT clause for CAST ... ON CONVERSION ERROR to type date +LINE 1: SELECT CAST('a' as date DEFAULT ret_int8() ON CONVERSION ERR... + ^ +-- test array coerce +SELECT CAST('{123,abc,456}' AS integer[] DEFAULT '{-789}' ON CONVERSION ERROR); + int4 +-------- + {-789} +(1 row) + +SELECT CAST('{234,def,567}'::text[] AS integer[] DEFAULT '{-1011}' ON CONVERSION ERROR); + int4 +--------- + {-1011} +(1 row) + +SELECT CAST(ARRAY[['1'], ['three'],['a']] AS INTEGER[] DEFAULT '{1,2}' ON CONVERSION ERROR); + array +------- + {1,2} +(1 row) + +SELECT CAST(ARRAY[['1', '2'], ['three', 'a']] AS text[] DEFAULT '{21,22}' ON CONVERSION ERROR); + array +------------------- + {{1,2},{three,a}} +(1 row) + +-- test valid DEFAULT expression for CAST = ON CONVERSION ERROR +CREATE OR REPLACE FUNCTION ret_setint() RETURNS SETOF integer AS +$$ +BEGIN RETURN QUERY EXECUTE 'select 1 union all select 1'; END; +$$ +LANGUAGE plpgsql IMMUTABLE; +CREATE TABLE tcast(a text[], b int GENERATED BY DEFAULT AS IDENTITY, c text default '1'); +INSERT INTO tcast VALUES ('{12}'), ('{1,a, b}'), ('{{1,2}, {c,d}}'), ('{13}'); +SELECT CAST('a' as int DEFAULT ret_setint() ON CONVERSION ERROR) FROM tcast; --error +ERROR: DEFAULT expression must not return a set +LINE 1: SELECT CAST('a' as int DEFAULT ret_setint() ON CONVERSION ER... + ^ +SELECT CAST('a' as int DEFAULT sum(1) ON CONVERSION ERROR); --error +ERROR: DEFAULT expression function must be a normal function +LINE 1: SELECT CAST('a' as int DEFAULT sum(1) ON CONVERSION ERROR); + ^ +SELECT CAST('a' as int DEFAULT sum(1) over() ON CONVERSION ERROR); --error +ERROR: DEFAULT expression function must be a normal function +LINE 1: SELECT CAST('a' as int DEFAULT sum(1) over() ON CONVERSION E... + ^ +SELECT CAST('a' as int DEFAULT 'b' ON CONVERSION ERROR); --error +ERROR: invalid input syntax for type integer: "b" +LINE 1: SELECT CAST('a' as int DEFAULT 'b' ON CONVERSION ERROR); + ^ +SELECT CAST(t AS text[] DEFAULT '{21,22, ' || b || '}' ON CONVERSION ERROR) FROM tcast as t; + t +----------- + {21,22,1} + {21,22,2} + {21,22,3} + {21,22,4} +(4 rows) + +SELECT CAST(t.a AS int[] DEFAULT '{21,22}'::int[] || b ON CONVERSION ERROR) FROM tcast as t; + a +----------- + {12} + {21,22,2} + {21,22,3} + {13} +(4 rows) + +-- test with domain +CREATE DOMAIN d_int42 as int check (value = 42) NOT NULL; +CREATE DOMAIN d_char3_not_null as char(3) NOT NULL; +CREATE TYPE comp_domain_with_typmod AS (a d_char3_not_null, b int); +SELECT CAST(11 AS d_int42 DEFAULT 41 ON CONVERSION ERROR); --error +ERROR: value for domain d_int42 violates check constraint "d_int42_check" +SELECT CAST(11 AS d_int42 DEFAULT 42 ON CONVERSION ERROR); --ok + d_int42 +--------- + 42 +(1 row) + +SELECT CAST(NULL AS d_int42 DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: domain d_int42 does not allow null values +SELECT CAST(NULL AS d_int42 DEFAULT 42 ON CONVERSION ERROR); --ok + d_int42 +--------- + 42 +(1 row) + +SELECT CAST('(,42)' AS comp_domain_with_typmod DEFAULT NULL ON CONVERSION ERROR); + comp_domain_with_typmod +------------------------- + +(1 row) + +SELECT CAST('(NULL,42)' AS comp_domain_with_typmod DEFAULT '(1,2)' ON CONVERSION ERROR); + comp_domain_with_typmod +------------------------- + ("1 ",2) +(1 row) + +SELECT CAST('(NULL,42)' AS comp_domain_with_typmod DEFAULT '(1234,2)' ON CONVERSION ERROR); --error +ERROR: value too long for type character(3) +LINE 1: ...ST('(NULL,42)' AS comp_domain_with_typmod DEFAULT '(1234,2)'... + ^ +-----safe cast from bytea type to other type +SELECT CAST ('\x112233445566778899'::bytea AS int8 DEFAULT NULL ON CONVERSION ERROR); + int8 +------ + +(1 row) + +SELECT CAST('\x123456789A'::bytea AS int4 DEFAULT NULL ON CONVERSION ERROR); + int4 +------ + +(1 row) + +SELECT CAST('\x123456'::bytea AS int2 DEFAULT NULL ON CONVERSION ERROR); + int2 +------ + +(1 row) + +-----safe cast from range type to other type +SELECT CAST('[1,2]'::int4range AS int4multirange DEFAULT NULL ON CONVERSION ERROR); + int4multirange +---------------- + {[1,3)} +(1 row) + +SELECT CAST('[1,2]'::int8range AS int8multirange DEFAULT NULL ON CONVERSION ERROR); + int8multirange +---------------- + {[1,3)} +(1 row) + +SELECT CAST('[1,2]'::numrange AS nummultirange DEFAULT NULL ON CONVERSION ERROR); + nummultirange +--------------- + {[1,2]} +(1 row) + +SELECT CAST('[-infinity,infinity]'::daterange AS datemultirange DEFAULT NULL ON CONVERSION ERROR); + datemultirange +------------------------ + {[-infinity,infinity]} +(1 row) + +SELECT CAST('[-infinity,infinity]'::tsrange AS tsmultirange DEFAULT NULL ON CONVERSION ERROR); + tsmultirange +------------------------ + {[-infinity,infinity]} +(1 row) + +SELECT CAST('[-infinity,infinity]'::tstzrange AS tstzmultirange DEFAULT NULL ON CONVERSION ERROR); + tstzmultirange +------------------------ + {[-infinity,infinity]} +(1 row) + +-----safe cast from geometry to other geometry is not supported +SELECT CAST(NULL::point AS box DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type point to box when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::point AS box DEFAULT NULL ON CONVERSION ER... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::lseg AS point DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type lseg to point when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::lseg AS point DEFAULT NULL ON CONVERSION E... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::path AS polygon DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type path to polygon when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::path AS polygon DEFAULT NULL ON CONVERSION... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::box AS point DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type box to point when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::box AS point DEFAULT NULL ON CONVERSION ER... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::box AS lseg DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type box to lseg when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::box AS lseg DEFAULT NULL ON CONVERSION ERR... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::box AS polygon DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type box to polygon when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::box AS polygon DEFAULT NULL ON CONVERSION ... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::box AS circle DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type box to circle when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::box AS circle DEFAULT NULL ON CONVERSION E... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::polygon AS point DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type polygon to point when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::polygon AS point DEFAULT NULL ON CONVERSIO... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::polygon AS path DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type polygon to path when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::polygon AS path DEFAULT NULL ON CONVERSION... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::polygon AS box DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type polygon to box when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::polygon AS box DEFAULT NULL ON CONVERSION ... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::polygon AS circle DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type polygon to circle when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::polygon AS circle DEFAULT NULL ON CONVERSI... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::circle AS point DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type circle to point when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::circle AS point DEFAULT NULL ON CONVERSION... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::circle AS box DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type circle to box when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::circle AS box DEFAULT NULL ON CONVERSION E... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::circle AS polygon DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type circle to polygon when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::circle AS polygon DEFAULT NULL ON CONVERSI... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +-----safe cast from money or money cast to other type is not supported +SELECT CAST(NULL::int8 AS money DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type bigint to money when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::int8 AS money DEFAULT NULL ON CONVERSION E... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::int4 AS money DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type integer to money when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::int4 AS money DEFAULT NULL ON CONVERSION E... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::numeric AS money DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type numeric to money when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::numeric AS money DEFAULT NULL ON CONVERSIO... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +SELECT CAST(NULL::money AS numeric DEFAULT NULL ON CONVERSION ERROR); --error +ERROR: cannot cast type money to numeric when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(NULL::money AS numeric DEFAULT NULL ON CONVERSIO... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast +--test cast numeric value with fraction to another numeric value +CREATE TABLE safecast(col1 float4, col2 float8, col3 numeric, col4 numeric[], + col5 int2 default 32767, + col6 int4 default 32768, + col7 int8 default 4294967296); +INSERT INTO safecast VALUES('11.1234', '11.1234', '9223372036854775808', '{11.1234}'::numeric[]); +INSERT INTO safecast VALUES('inf', 'inf', 'inf', '{11.1234, 12, inf, NaN}'::numeric[]); +INSERT INTO safecast VALUES('-inf', '-inf', '-inf', '{11.1234, 12, -inf, NaN}'::numeric[]); +INSERT INTO safecast VALUES('NaN', 'NaN', 'NaN', '{11.1234, 12, -inf, NaN}'::numeric[]); +SELECT col1 as float4, + CAST(col1 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col1 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col1 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col1 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col1 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col1 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col1 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col1 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + float4 | to_int2 | to_int4 | to_oid | to_int8 | to_float4 | to_float8 | to_numeric | to_numeric_scale +-----------+---------+---------+--------+---------+-----------+------------------+------------+------------------ + 11.1234 | 11 | 11 | | 11 | 11.1234 | 11.1233997344971 | 11.1234 | 11.1 + Infinity | | | | | Infinity | Infinity | Infinity | + -Infinity | | | | | -Infinity | -Infinity | -Infinity | + NaN | | | | | NaN | NaN | NaN | NaN +(4 rows) + +SELECT col2 as float8, + CAST(col2 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col2 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col2 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col2 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col2 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col2 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col2 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col2 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + float8 | to_int2 | to_int4 | to_oid | to_int8 | to_float4 | to_float8 | to_numeric | to_numeric_scale +-----------+---------+---------+--------+---------+-----------+-----------+------------+------------------ + 11.1234 | 11 | 11 | | 11 | 11.1234 | 11.1234 | 11.1234 | 11.1 + Infinity | | | | | Infinity | Infinity | Infinity | + -Infinity | | | | | -Infinity | -Infinity | -Infinity | + NaN | | | | | NaN | NaN | NaN | NaN +(4 rows) + +SELECT col3 as numeric, + CAST(col3 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col3 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col3 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col3 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col3 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col3 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col3 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col3 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + numeric | to_int2 | to_int4 | to_oid | to_int8 | to_float4 | to_float8 | to_numeric | to_numeric_scale +---------------------+---------+---------+--------+---------+-------------+----------------------+---------------------+------------------ + 9223372036854775808 | | | | | 9.22337e+18 | 9.22337203685478e+18 | 9223372036854775808 | + Infinity | | | | | Infinity | Infinity | Infinity | + -Infinity | | | | | -Infinity | -Infinity | -Infinity | + NaN | | | | | NaN | NaN | NaN | NaN +(4 rows) + +SELECT col4 as num_arr, + CAST(col4 AS int2[] DEFAULT NULL ON CONVERSION ERROR) as int2arr, + CAST(col4 AS int4[] DEFAULT NULL ON CONVERSION ERROR) as int4arr, + CAST(col4 as int8[] DEFAULT NULL ON CONVERSION ERROR) as int8arr, + CAST(col4 as float4[] DEFAULT NULL ON CONVERSION ERROR) as f4arr, + CAST(col4 as float8[] DEFAULT NULL ON CONVERSION ERROR) as f8arr, + CAST(col4 as numeric(10,1)[] DEFAULT NULL ON CONVERSION ERROR) as numarr +FROM safecast; + num_arr | int2arr | int4arr | int8arr | f4arr | f8arr | numarr +----------------------------+---------+---------+---------+----------------------------+----------------------------+-------- + {11.1234} | {11} | {11} | {11} | {11.1234} | {11.1234} | {11.1} + {11.1234,12,Infinity,NaN} | | | | {11.1234,12,Infinity,NaN} | {11.1234,12,Infinity,NaN} | + {11.1234,12,-Infinity,NaN} | | | | {11.1234,12,-Infinity,NaN} | {11.1234,12,-Infinity,NaN} | + {11.1234,12,-Infinity,NaN} | | | | {11.1234,12,-Infinity,NaN} | {11.1234,12,-Infinity,NaN} | +(4 rows) + +SELECT col5 as int2, + CAST(col5 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col5 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col5 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col5 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col5 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col5 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col5 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col5 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + int2 | to_int2 | to_int4 | to_oid | to_int8 | to_float4 | to_float8 | to_numeric | to_numeric_scale +-------+---------+---------+--------+---------+-----------+-----------+------------+------------------ + 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767.0 + 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767.0 + 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767.0 + 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767 | 32767.0 +(4 rows) + +SELECT col6 as int4, + CAST(col6 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col6 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col6 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col6 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col6 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col6 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col6 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col6 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + int4 | to_int2 | to_int4 | to_oid | to_int8 | to_float4 | to_float8 | to_numeric | to_numeric_scale +-------+---------+---------+--------+---------+-----------+-----------+------------+------------------ + 32768 | | 32768 | 32768 | 32768 | 32768 | 32768 | 32768 | 32768.0 + 32768 | | 32768 | 32768 | 32768 | 32768 | 32768 | 32768 | 32768.0 + 32768 | | 32768 | 32768 | 32768 | 32768 | 32768 | 32768 | 32768.0 + 32768 | | 32768 | 32768 | 32768 | 32768 | 32768 | 32768 | 32768.0 +(4 rows) + +SELECT col7 as int8, + CAST(col7 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col7 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col7 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col7 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col7 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col7 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col7 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col7 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + int8 | to_int2 | to_int4 | to_oid | to_int8 | to_float4 | to_float8 | to_numeric | to_numeric_scale +------------+---------+---------+--------+------------+-------------+------------+------------+------------------ + 4294967296 | | | | 4294967296 | 4.29497e+09 | 4294967296 | 4294967296 | + 4294967296 | | | | 4294967296 | 4.29497e+09 | 4294967296 | 4294967296 | + 4294967296 | | | | 4294967296 | 4.29497e+09 | 4294967296 | 4294967296 | + 4294967296 | | | | 4294967296 | 4.29497e+09 | 4294967296 | 4294967296 | +(4 rows) + +--test date/timestamp/interval realted cast +CREATE TABLE safecast1(col0 date, col1 timestamp, col2 timestamptz, col3 interval, col4 time, col5 timetz); +insert into safecast1 VALUES +('-infinity', '-infinity', '-infinity', '-infinity', '2003-03-07 15:36:39 America/New_York', '2003-07-07 15:36:39 America/New_York'), +('-infinity', 'infinity', 'infinity', 'infinity','11:59:59.99 PM', '11:59:59.99 PM PDT'); +SELECT col0 as date, + CAST(col0 AS timestamptz DEFAULT NULL ON CONVERSION ERROR) as to_timestamptz, + CAST(col0 AS date DEFAULT NULL ON CONVERSION ERROR) as to_date, + CAST(col0 AS time DEFAULT NULL ON CONVERSION ERROR) as to_times, + CAST(col0 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col0 AS timestamp(2) DEFAULT NULL ON CONVERSION ERROR) as to_timestamp_scale +FROM safecast1; + date | to_timestamptz | to_date | to_times | to_timetz | to_timestamp_scale +-----------+----------------+-----------+----------+-----------+-------------------- + -infinity | -infinity | -infinity | | | -infinity + -infinity | -infinity | -infinity | | | -infinity +(2 rows) + +SELECT col1 as timestamp, + CAST(col1 AS timestamptz DEFAULT NULL ON CONVERSION ERROR) as to_timestamptz, + CAST(col1 AS date DEFAULT NULL ON CONVERSION ERROR) as to_date, + CAST(col1 AS time DEFAULT NULL ON CONVERSION ERROR) as to_times, + CAST(col1 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col1 AS timestamp(2) DEFAULT NULL ON CONVERSION ERROR) as to_timestamp_scale +FROM safecast1; + timestamp | to_timestamptz | to_date | to_times | to_timetz | to_timestamp_scale +-----------+----------------+-----------+----------+-----------+-------------------- + -infinity | -infinity | -infinity | | | -infinity + infinity | infinity | infinity | | | infinity +(2 rows) + +SELECT col2 as timestamptz, + CAST(col2 AS timestamptz DEFAULT NULL ON CONVERSION ERROR) as to_timestamptz, + CAST(col2 AS date DEFAULT NULL ON CONVERSION ERROR) as to_date, + CAST(col2 AS time DEFAULT NULL ON CONVERSION ERROR) as to_times, + CAST(col2 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col2 AS timestamp(2) DEFAULT NULL ON CONVERSION ERROR) as to_timestamp_scale +FROM safecast1; + timestamptz | to_timestamptz | to_date | to_times | to_timetz | to_timestamp_scale +-------------+----------------+-----------+----------+-----------+-------------------- + -infinity | -infinity | -infinity | | | -infinity + infinity | infinity | infinity | | | infinity +(2 rows) + +SELECT col3 as interval, + CAST(col3 AS timestamptz DEFAULT NULL ON CONVERSION ERROR) as to_timestamptz, + CAST(col3 AS date DEFAULT NULL ON CONVERSION ERROR) as to_date, + CAST(col3 AS time DEFAULT NULL ON CONVERSION ERROR) as to_times, + CAST(col3 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col3 AS timestamp(2) DEFAULT NULL ON CONVERSION ERROR) as to_timestamp_scale, + CAST(col3 AS interval(2) DEFAULT NULL ON CONVERSION ERROR) as to_interval_scale +FROM safecast1; + interval | to_timestamptz | to_date | to_times | to_timetz | to_timestamp_scale | to_interval_scale +-----------+----------------+---------+----------+-----------+--------------------+------------------- + -infinity | | | | | | -infinity + infinity | | | | | | infinity +(2 rows) + +SELECT col4 as time, + CAST(col4 AS time(2) DEFAULT NULL ON CONVERSION ERROR) as to_times, + CAST(col4 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col4 AS interval(2) DEFAULT NULL ON CONVERSION ERROR) as to_interval, + CAST(col4 AS interval(2) DEFAULT NULL ON CONVERSION ERROR) as to_interval_scale +FROM safecast1; + time | to_times | to_timetz | to_interval | to_interval_scale +-------------+-------------+----------------+-------------------------------+------------------------------- + 15:36:39 | 15:36:39 | 15:36:39-07 | @ 15 hours 36 mins 39 secs | @ 15 hours 36 mins 39 secs + 23:59:59.99 | 23:59:59.99 | 23:59:59.99-07 | @ 23 hours 59 mins 59.99 secs | @ 23 hours 59 mins 59.99 secs +(2 rows) + +SELECT col5 as timetz, + CAST(col5 AS time DEFAULT NULL ON CONVERSION ERROR) as to_time, + CAST(col5 AS time(2) DEFAULT NULL ON CONVERSION ERROR) as to_time_scale, + CAST(col5 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col5 AS timetz(6) DEFAULT NULL ON CONVERSION ERROR) as to_timetz_scale, + CAST(col5 AS interval DEFAULT NULL ON CONVERSION ERROR) as to_interval, + CAST(col5 AS interval(2) DEFAULT NULL ON CONVERSION ERROR) as to_interval_scale +FROM safecast1; + timetz | to_time | to_time_scale | to_timetz | to_timetz_scale | to_interval | to_interval_scale +----------------+-------------+---------------+----------------+-----------------+-------------+------------------- + 15:36:39-04 | 15:36:39 | 15:36:39 | 15:36:39-04 | 15:36:39-04 | | + 23:59:59.99-07 | 23:59:59.99 | 23:59:59.99 | 23:59:59.99-07 | 23:59:59.99-07 | | +(2 rows) + +CREATE TABLE safecast2(col0 jsonb, col1 text ); +INSERT INTO safecast2 VALUES ('"test"', 'oneone1, max=>1::int))) ON CONVERSION ERROR) as safecast, + CAST(ARRAY[['1'], ['three'],['a']] AS INTEGER[] DEFAULT '{1,2}' ON CONVERSION ERROR) as cast1, + CAST(ARRAY[['1', '2'], ['three', 'a']] AS text[] DEFAULT '{21,22}' ON CONVERSION ERROR) as cast2; +\sv safecastview +CREATE OR REPLACE VIEW public.safecastview AS + SELECT CAST('1234' AS character(3) DEFAULT '-1111'::integer::character(3) ON CONVERSION ERROR) AS bpchar, + CAST(1 AS date DEFAULT now()::date + random(min => 1, max => 1) ON CONVERSION ERROR) AS safecast, + CAST(ARRAY[ARRAY['1'], ARRAY['three'], ARRAY['a']] AS integer[] DEFAULT '{1,2}'::integer[] ON CONVERSION ERROR) AS cast1, + CAST(ARRAY[ARRAY['1'::text, '2'::text], ARRAY['three'::text, 'a'::text]] AS text[] DEFAULT '{21,22}'::text[] ON CONVERSION ERROR) AS cast2 +CREATE INDEX cast_error_idx ON tcast((cast(c as int DEFAULT random(min=>1, max=>1) ON CONVERSION ERROR))); --error +ERROR: functions in index expression must be marked IMMUTABLE +RESET extra_float_digits; diff --git a/src/test/regress/expected/create_cast.out b/src/test/regress/expected/create_cast.out index fd4871d94db..1ec99eef670 100644 --- a/src/test/regress/expected/create_cast.out +++ b/src/test/regress/expected/create_cast.out @@ -86,6 +86,11 @@ SELECT 1234::int4::casttesttype; -- Should work now bar1234 (1 row) +SELECT CAST(1234::int4 AS casttesttype DEFAULT NULL ON CONVERSION ERROR); -- error +ERROR: cannot cast type integer to casttesttype when DEFAULT clause is specified for CAST ... ON CONVERSION ERROR +LINE 1: SELECT CAST(1234::int4 AS casttesttype DEFAULT NULL ON CONVE... + ^ +HINT: Currently CAST ... DEFAULT ON CONVERSION ERROR does not support this cast -- check dependencies generated for that SELECT pg_describe_object(classid, objid, objsubid) as obj, pg_describe_object(refclassid, refobjid, refobjsubid) as objref, diff --git a/src/test/regress/expected/opr_sanity.out b/src/test/regress/expected/opr_sanity.out index 20bf9ea9cdf..25478364b7c 100644 --- a/src/test/regress/expected/opr_sanity.out +++ b/src/test/regress/expected/opr_sanity.out @@ -943,8 +943,8 @@ SELECT * FROM pg_cast c WHERE castsource = 0 OR casttarget = 0 OR castcontext NOT IN ('e', 'a', 'i') OR castmethod NOT IN ('f', 'b' ,'i'); - oid | castsource | casttarget | castfunc | castcontext | castmethod ------+------------+------------+----------+-------------+------------ + oid | castsource | casttarget | castfunc | castcontext | castmethod | casterrorsafe +-----+------------+------------+----------+-------------+------------+--------------- (0 rows) -- Check that castfunc is nonzero only for cast methods that need a function, @@ -953,8 +953,8 @@ SELECT * FROM pg_cast c WHERE (castmethod = 'f' AND castfunc = 0) OR (castmethod IN ('b', 'i') AND castfunc <> 0); - oid | castsource | casttarget | castfunc | castcontext | castmethod ------+------------+------------+----------+-------------+------------ + oid | castsource | casttarget | castfunc | castcontext | castmethod | casterrorsafe +-----+------------+------------+----------+-------------+------------+--------------- (0 rows) -- Look for casts to/from the same type that aren't length coercion functions. @@ -963,15 +963,15 @@ WHERE (castmethod = 'f' AND castfunc = 0) SELECT * FROM pg_cast c WHERE castsource = casttarget AND castfunc = 0; - oid | castsource | casttarget | castfunc | castcontext | castmethod ------+------------+------------+----------+-------------+------------ + oid | castsource | casttarget | castfunc | castcontext | castmethod | casterrorsafe +-----+------------+------------+----------+-------------+------------+--------------- (0 rows) SELECT c.* FROM pg_cast c, pg_proc p WHERE c.castfunc = p.oid AND p.pronargs < 2 AND castsource = casttarget; - oid | castsource | casttarget | castfunc | castcontext | castmethod ------+------------+------------+----------+-------------+------------ + oid | castsource | casttarget | castfunc | castcontext | castmethod | casterrorsafe +-----+------------+------------+----------+-------------+------------+--------------- (0 rows) -- Look for cast functions that don't have the right signature. The @@ -989,8 +989,8 @@ WHERE c.castfunc = p.oid AND OR (c.castsource = 'character'::regtype AND p.proargtypes[0] = 'text'::regtype)) OR NOT binary_coercible(p.prorettype, c.casttarget)); - oid | castsource | casttarget | castfunc | castcontext | castmethod ------+------------+------------+----------+-------------+------------ + oid | castsource | casttarget | castfunc | castcontext | castmethod | casterrorsafe +-----+------------+------------+----------+-------------+------------+--------------- (0 rows) SELECT c.* @@ -998,8 +998,8 @@ FROM pg_cast c, pg_proc p WHERE c.castfunc = p.oid AND ((p.pronargs > 1 AND p.proargtypes[1] != 'int4'::regtype) OR (p.pronargs > 2 AND p.proargtypes[2] != 'bool'::regtype)); - oid | castsource | casttarget | castfunc | castcontext | castmethod ------+------------+------------+----------+-------------+------------ + oid | castsource | casttarget | castfunc | castcontext | castmethod | casterrorsafe +-----+------------+------------+----------+-------------+------------+--------------- (0 rows) -- Look for binary compatible casts that do not have the reverse diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule index fbffc67ae60..ebbd454c450 100644 --- a/src/test/regress/parallel_schedule +++ b/src/test/regress/parallel_schedule @@ -81,7 +81,7 @@ test: brin_bloom brin_multi test: create_table_like alter_generic alter_operator misc async dbsize merge misc_functions sysviews tsrf tid tidscan tidrangescan collate.utf8 collate.icu.utf8 incremental_sort create_role without_overlaps generated_virtual # collate.linux.utf8 and collate.icu.utf8 tests cannot be run in parallel with each other -test: rules psql psql_crosstab psql_pipeline amutils stats_ext collate.linux.utf8 collate.windows.win1252 +test: rules psql psql_crosstab psql_pipeline amutils stats_ext collate.linux.utf8 collate.windows.win1252 cast # ---------- # Run these alone so they don't run out of parallel workers diff --git a/src/test/regress/sql/cast.sql b/src/test/regress/sql/cast.sql new file mode 100644 index 00000000000..27334212c8c --- /dev/null +++ b/src/test/regress/sql/cast.sql @@ -0,0 +1,259 @@ +SET extra_float_digits = 0; + +-- CAST DEFAULT ON CONVERSION ERROR +VALUES (CAST('error' AS integer ERROR ON CONVERSION ERROR)); --error +VALUES (CAST('error' AS integer NULL ON CONVERSION ERROR)); +VALUES (CAST('error' AS integer DEFAULT 42 ON CONVERSION ERROR)); +SELECT CAST(1 AS date DEFAULT NULL ON CONVERSION ERROR); +SELECT CAST(1::numeric AS money DEFAULT NULL ON CONVERSION ERROR); +SELECT CAST(1111 AS "char" DEFAULT NULL ON CONVERSION ERROR); + +CREATE OR REPLACE FUNCTION ret_int8() RETURNS bigint AS +$$ +BEGIN RETURN 2147483648; END; +$$ +LANGUAGE plpgsql IMMUTABLE; + +SELECT CAST('a' as int DEFAULT ret_int8() ON CONVERSION ERROR); --error +SELECT CAST('a' as date DEFAULT ret_int8() ON CONVERSION ERROR); --error + +-- test array coerce +SELECT CAST('{123,abc,456}' AS integer[] DEFAULT '{-789}' ON CONVERSION ERROR); +SELECT CAST('{234,def,567}'::text[] AS integer[] DEFAULT '{-1011}' ON CONVERSION ERROR); +SELECT CAST(ARRAY[['1'], ['three'],['a']] AS INTEGER[] DEFAULT '{1,2}' ON CONVERSION ERROR); +SELECT CAST(ARRAY[['1', '2'], ['three', 'a']] AS text[] DEFAULT '{21,22}' ON CONVERSION ERROR); + +-- test valid DEFAULT expression for CAST = ON CONVERSION ERROR +CREATE OR REPLACE FUNCTION ret_setint() RETURNS SETOF integer AS +$$ +BEGIN RETURN QUERY EXECUTE 'select 1 union all select 1'; END; +$$ +LANGUAGE plpgsql IMMUTABLE; + +CREATE TABLE tcast(a text[], b int GENERATED BY DEFAULT AS IDENTITY, c text default '1'); +INSERT INTO tcast VALUES ('{12}'), ('{1,a, b}'), ('{{1,2}, {c,d}}'), ('{13}'); +SELECT CAST('a' as int DEFAULT ret_setint() ON CONVERSION ERROR) FROM tcast; --error +SELECT CAST('a' as int DEFAULT sum(1) ON CONVERSION ERROR); --error +SELECT CAST('a' as int DEFAULT sum(1) over() ON CONVERSION ERROR); --error +SELECT CAST('a' as int DEFAULT 'b' ON CONVERSION ERROR); --error + +SELECT CAST(t AS text[] DEFAULT '{21,22, ' || b || '}' ON CONVERSION ERROR) FROM tcast as t; +SELECT CAST(t.a AS int[] DEFAULT '{21,22}'::int[] || b ON CONVERSION ERROR) FROM tcast as t; + +-- test with domain +CREATE DOMAIN d_int42 as int check (value = 42) NOT NULL; +CREATE DOMAIN d_char3_not_null as char(3) NOT NULL; +CREATE TYPE comp_domain_with_typmod AS (a d_char3_not_null, b int); +SELECT CAST(11 AS d_int42 DEFAULT 41 ON CONVERSION ERROR); --error +SELECT CAST(11 AS d_int42 DEFAULT 42 ON CONVERSION ERROR); --ok +SELECT CAST(NULL AS d_int42 DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL AS d_int42 DEFAULT 42 ON CONVERSION ERROR); --ok +SELECT CAST('(,42)' AS comp_domain_with_typmod DEFAULT NULL ON CONVERSION ERROR); +SELECT CAST('(NULL,42)' AS comp_domain_with_typmod DEFAULT '(1,2)' ON CONVERSION ERROR); +SELECT CAST('(NULL,42)' AS comp_domain_with_typmod DEFAULT '(1234,2)' ON CONVERSION ERROR); --error + +-----safe cast from bytea type to other type +SELECT CAST ('\x112233445566778899'::bytea AS int8 DEFAULT NULL ON CONVERSION ERROR); +SELECT CAST('\x123456789A'::bytea AS int4 DEFAULT NULL ON CONVERSION ERROR); +SELECT CAST('\x123456'::bytea AS int2 DEFAULT NULL ON CONVERSION ERROR); + +-----safe cast from range type to other type +SELECT CAST('[1,2]'::int4range AS int4multirange DEFAULT NULL ON CONVERSION ERROR); +SELECT CAST('[1,2]'::int8range AS int8multirange DEFAULT NULL ON CONVERSION ERROR); +SELECT CAST('[1,2]'::numrange AS nummultirange DEFAULT NULL ON CONVERSION ERROR); +SELECT CAST('[-infinity,infinity]'::daterange AS datemultirange DEFAULT NULL ON CONVERSION ERROR); +SELECT CAST('[-infinity,infinity]'::tsrange AS tsmultirange DEFAULT NULL ON CONVERSION ERROR); +SELECT CAST('[-infinity,infinity]'::tstzrange AS tstzmultirange DEFAULT NULL ON CONVERSION ERROR); + +-----safe cast from geometry to other geometry is not supported +SELECT CAST(NULL::point AS box DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::lseg AS point DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::path AS polygon DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::box AS point DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::box AS lseg DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::box AS polygon DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::box AS circle DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::polygon AS point DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::polygon AS path DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::polygon AS box DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::polygon AS circle DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::circle AS point DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::circle AS box DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::circle AS polygon DEFAULT NULL ON CONVERSION ERROR); --error + +-----safe cast from money or money cast to other type is not supported +SELECT CAST(NULL::int8 AS money DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::int4 AS money DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::numeric AS money DEFAULT NULL ON CONVERSION ERROR); --error +SELECT CAST(NULL::money AS numeric DEFAULT NULL ON CONVERSION ERROR); --error + +--test cast numeric value with fraction to another numeric value +CREATE TABLE safecast(col1 float4, col2 float8, col3 numeric, col4 numeric[], + col5 int2 default 32767, + col6 int4 default 32768, + col7 int8 default 4294967296); +INSERT INTO safecast VALUES('11.1234', '11.1234', '9223372036854775808', '{11.1234}'::numeric[]); +INSERT INTO safecast VALUES('inf', 'inf', 'inf', '{11.1234, 12, inf, NaN}'::numeric[]); +INSERT INTO safecast VALUES('-inf', '-inf', '-inf', '{11.1234, 12, -inf, NaN}'::numeric[]); +INSERT INTO safecast VALUES('NaN', 'NaN', 'NaN', '{11.1234, 12, -inf, NaN}'::numeric[]); + +SELECT col1 as float4, + CAST(col1 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col1 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col1 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col1 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col1 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col1 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col1 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col1 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + +SELECT col2 as float8, + CAST(col2 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col2 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col2 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col2 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col2 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col2 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col2 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col2 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + +SELECT col3 as numeric, + CAST(col3 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col3 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col3 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col3 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col3 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col3 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col3 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col3 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + +SELECT col4 as num_arr, + CAST(col4 AS int2[] DEFAULT NULL ON CONVERSION ERROR) as int2arr, + CAST(col4 AS int4[] DEFAULT NULL ON CONVERSION ERROR) as int4arr, + CAST(col4 as int8[] DEFAULT NULL ON CONVERSION ERROR) as int8arr, + CAST(col4 as float4[] DEFAULT NULL ON CONVERSION ERROR) as f4arr, + CAST(col4 as float8[] DEFAULT NULL ON CONVERSION ERROR) as f8arr, + CAST(col4 as numeric(10,1)[] DEFAULT NULL ON CONVERSION ERROR) as numarr +FROM safecast; + +SELECT col5 as int2, + CAST(col5 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col5 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col5 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col5 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col5 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col5 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col5 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col5 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + +SELECT col6 as int4, + CAST(col6 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col6 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col6 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col6 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col6 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col6 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col6 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col6 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + +SELECT col7 as int8, + CAST(col7 AS int2 DEFAULT NULL ON CONVERSION ERROR) as to_int2, + CAST(col7 AS int4 DEFAULT NULL ON CONVERSION ERROR) as to_int4, + CAST(col7 AS oid DEFAULT NULL ON CONVERSION ERROR) as to_oid, + CAST(col7 as int8 DEFAULT NULL ON CONVERSION ERROR) as to_int8, + CAST(col7 as float4 DEFAULT NULL ON CONVERSION ERROR) as to_float4, + CAST(col7 as float8 DEFAULT NULL ON CONVERSION ERROR) as to_float8, + CAST(col7 as numeric DEFAULT NULL ON CONVERSION ERROR) as to_numeric, + CAST(col7 as numeric(10,1) DEFAULT NULL ON CONVERSION ERROR) as to_numeric_scale +FROM safecast; + +--test date/timestamp/interval realted cast +CREATE TABLE safecast1(col0 date, col1 timestamp, col2 timestamptz, col3 interval, col4 time, col5 timetz); +insert into safecast1 VALUES +('-infinity', '-infinity', '-infinity', '-infinity', '2003-03-07 15:36:39 America/New_York', '2003-07-07 15:36:39 America/New_York'), +('-infinity', 'infinity', 'infinity', 'infinity','11:59:59.99 PM', '11:59:59.99 PM PDT'); + +SELECT col0 as date, + CAST(col0 AS timestamptz DEFAULT NULL ON CONVERSION ERROR) as to_timestamptz, + CAST(col0 AS date DEFAULT NULL ON CONVERSION ERROR) as to_date, + CAST(col0 AS time DEFAULT NULL ON CONVERSION ERROR) as to_times, + CAST(col0 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col0 AS timestamp(2) DEFAULT NULL ON CONVERSION ERROR) as to_timestamp_scale +FROM safecast1; + +SELECT col1 as timestamp, + CAST(col1 AS timestamptz DEFAULT NULL ON CONVERSION ERROR) as to_timestamptz, + CAST(col1 AS date DEFAULT NULL ON CONVERSION ERROR) as to_date, + CAST(col1 AS time DEFAULT NULL ON CONVERSION ERROR) as to_times, + CAST(col1 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col1 AS timestamp(2) DEFAULT NULL ON CONVERSION ERROR) as to_timestamp_scale +FROM safecast1; + +SELECT col2 as timestamptz, + CAST(col2 AS timestamptz DEFAULT NULL ON CONVERSION ERROR) as to_timestamptz, + CAST(col2 AS date DEFAULT NULL ON CONVERSION ERROR) as to_date, + CAST(col2 AS time DEFAULT NULL ON CONVERSION ERROR) as to_times, + CAST(col2 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col2 AS timestamp(2) DEFAULT NULL ON CONVERSION ERROR) as to_timestamp_scale +FROM safecast1; + +SELECT col3 as interval, + CAST(col3 AS timestamptz DEFAULT NULL ON CONVERSION ERROR) as to_timestamptz, + CAST(col3 AS date DEFAULT NULL ON CONVERSION ERROR) as to_date, + CAST(col3 AS time DEFAULT NULL ON CONVERSION ERROR) as to_times, + CAST(col3 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col3 AS timestamp(2) DEFAULT NULL ON CONVERSION ERROR) as to_timestamp_scale, + CAST(col3 AS interval(2) DEFAULT NULL ON CONVERSION ERROR) as to_interval_scale +FROM safecast1; + +SELECT col4 as time, + CAST(col4 AS time(2) DEFAULT NULL ON CONVERSION ERROR) as to_times, + CAST(col4 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col4 AS interval(2) DEFAULT NULL ON CONVERSION ERROR) as to_interval, + CAST(col4 AS interval(2) DEFAULT NULL ON CONVERSION ERROR) as to_interval_scale +FROM safecast1; + +SELECT col5 as timetz, + CAST(col5 AS time DEFAULT NULL ON CONVERSION ERROR) as to_time, + CAST(col5 AS time(2) DEFAULT NULL ON CONVERSION ERROR) as to_time_scale, + CAST(col5 AS timetz DEFAULT NULL ON CONVERSION ERROR) as to_timetz, + CAST(col5 AS timetz(6) DEFAULT NULL ON CONVERSION ERROR) as to_timetz_scale, + CAST(col5 AS interval DEFAULT NULL ON CONVERSION ERROR) as to_interval, + CAST(col5 AS interval(2) DEFAULT NULL ON CONVERSION ERROR) as to_interval_scale +FROM safecast1; + +CREATE TABLE safecast2(col0 jsonb, col1 text ); +INSERT INTO safecast2 VALUES ('"test"', 'one1, max=>1::int))) ON CONVERSION ERROR) as safecast, + CAST(ARRAY[['1'], ['three'],['a']] AS INTEGER[] DEFAULT '{1,2}' ON CONVERSION ERROR) as cast1, + CAST(ARRAY[['1', '2'], ['three', 'a']] AS text[] DEFAULT '{21,22}' ON CONVERSION ERROR) as cast2; +\sv safecastview + +CREATE INDEX cast_error_idx ON tcast((cast(c as int DEFAULT random(min=>1, max=>1) ON CONVERSION ERROR))); --error +RESET extra_float_digits; diff --git a/src/test/regress/sql/create_cast.sql b/src/test/regress/sql/create_cast.sql index 32187853cc7..0a15a795d87 100644 --- a/src/test/regress/sql/create_cast.sql +++ b/src/test/regress/sql/create_cast.sql @@ -62,6 +62,7 @@ $$ SELECT ('bar'::text || $1::text); $$; CREATE CAST (int4 AS casttesttype) WITH FUNCTION bar_int4_text(int4) AS IMPLICIT; SELECT 1234::int4::casttesttype; -- Should work now +SELECT CAST(1234::int4 AS casttesttype DEFAULT NULL ON CONVERSION ERROR); -- error -- check dependencies generated for that SELECT pg_describe_object(classid, objid, objsubid) as obj, diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index e6f2e93b2d6..5b32df3a2db 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2652,6 +2652,9 @@ STRLEN SV SYNCHRONIZATION_BARRIER SYSTEM_INFO +SafeTypeCast +SafeTypeCastExpr +SafeTypeCastState SampleScan SampleScanGetSampleSize_function SampleScanState -- 2.34.1