mirror of
https://github.com/postgres/postgres.git
synced 2026-01-13 12:22:55 +03:00
8e2e0f7586
Although select_common_type() has a failure-return convention, an apparent successful return just provides a type OID that *might* work as a common supertype; we've not validated that the required casts actually exist. In the mainstream use-cases that doesn't matter, because we'll proceed to invoke coerce_to_common_type() on each input, which will fail appropriately if the proposed common type doesn't actually work. However, a few callers didn't read the (nonexistent) fine print, and thought that if they got back a nonzero OID then the coercions were sure to work. This affects in particular the recently-added "anycompatible" polymorphic types; we might think that a function/operator using such types matches cases it really doesn't. A likely end result of that is unexpected "ambiguous operator" errors, as for example in bug #17387 from James Inform. Another, much older, case is that the parser might try to transform an "x IN (list)" construct to a ScalarArrayOpExpr even when the list elements don't actually have a common supertype. It doesn't seem desirable to add more checking to select_common_type itself, as that'd just slow down the mainstream use-cases. Instead, write a separate function verify_common_type that performs the missing checks, and add a call to that where necessary. Likewise add verify_common_type_from_oids to go with select_common_type_from_oids. Back-patch to v13 where the "anycompatible" types came in. (The symptom complained of in bug #17387 doesn't appear till v14, but that's just because we didn't get around to converting || to use anycompatible till then.) In principle the "x IN (list)" fix could go back all the way, but I'm not currently convinced that it makes much difference in real-world cases, so I won't bother for now. Discussion: https://postgr.es/m/17387-5dfe54b988444963@postgresql.org
101 lines
3.6 KiB
C
101 lines
3.6 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* parse_coerce.h
|
|
* Routines for type coercion.
|
|
*
|
|
*
|
|
* Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
* src/include/parser/parse_coerce.h
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#ifndef PARSE_COERCE_H
|
|
#define PARSE_COERCE_H
|
|
|
|
#include "parser/parse_node.h"
|
|
|
|
|
|
/* Type categories (see TYPCATEGORY_xxx symbols in catalog/pg_type.h) */
|
|
typedef char TYPCATEGORY;
|
|
|
|
/* Result codes for find_coercion_pathway */
|
|
typedef enum CoercionPathType
|
|
{
|
|
COERCION_PATH_NONE, /* failed to find any coercion pathway */
|
|
COERCION_PATH_FUNC, /* apply the specified coercion function */
|
|
COERCION_PATH_RELABELTYPE, /* binary-compatible cast, no function */
|
|
COERCION_PATH_ARRAYCOERCE, /* need an ArrayCoerceExpr node */
|
|
COERCION_PATH_COERCEVIAIO /* need a CoerceViaIO node */
|
|
} CoercionPathType;
|
|
|
|
|
|
extern bool IsBinaryCoercible(Oid srctype, Oid targettype);
|
|
extern bool IsPreferredType(TYPCATEGORY category, Oid type);
|
|
extern TYPCATEGORY TypeCategory(Oid type);
|
|
|
|
extern Node *coerce_to_target_type(ParseState *pstate,
|
|
Node *expr, Oid exprtype,
|
|
Oid targettype, int32 targettypmod,
|
|
CoercionContext ccontext,
|
|
CoercionForm cformat,
|
|
int location);
|
|
extern bool can_coerce_type(int nargs, const Oid *input_typeids, const Oid *target_typeids,
|
|
CoercionContext ccontext);
|
|
extern Node *coerce_type(ParseState *pstate, Node *node,
|
|
Oid inputTypeId, Oid targetTypeId, int32 targetTypeMod,
|
|
CoercionContext ccontext, CoercionForm cformat, int location);
|
|
extern Node *coerce_to_domain(Node *arg, Oid baseTypeId, int32 baseTypeMod,
|
|
Oid typeId,
|
|
CoercionContext ccontext, CoercionForm cformat, int location,
|
|
bool hideInputCoercion);
|
|
|
|
extern Node *coerce_to_boolean(ParseState *pstate, Node *node,
|
|
const char *constructName);
|
|
extern Node *coerce_to_specific_type(ParseState *pstate, Node *node,
|
|
Oid targetTypeId,
|
|
const char *constructName);
|
|
|
|
extern Node *coerce_to_specific_type_typmod(ParseState *pstate, Node *node,
|
|
Oid targetTypeId, int32 targetTypmod,
|
|
const char *constructName);
|
|
|
|
extern int parser_coercion_errposition(ParseState *pstate,
|
|
int coerce_location,
|
|
Node *input_expr);
|
|
|
|
extern Oid select_common_type(ParseState *pstate, List *exprs,
|
|
const char *context, Node **which_expr);
|
|
extern Node *coerce_to_common_type(ParseState *pstate, Node *node,
|
|
Oid targetTypeId,
|
|
const char *context);
|
|
extern bool verify_common_type(Oid common_type, List *exprs);
|
|
|
|
extern int32 select_common_typmod(ParseState *pstate, List *exprs, Oid common_type);
|
|
|
|
extern bool check_generic_type_consistency(const Oid *actual_arg_types,
|
|
const Oid *declared_arg_types,
|
|
int nargs);
|
|
extern Oid enforce_generic_type_consistency(const Oid *actual_arg_types,
|
|
Oid *declared_arg_types,
|
|
int nargs,
|
|
Oid rettype,
|
|
bool allow_poly);
|
|
|
|
extern char *check_valid_polymorphic_signature(Oid ret_type,
|
|
const Oid *declared_arg_types,
|
|
int nargs);
|
|
extern char *check_valid_internal_signature(Oid ret_type,
|
|
const Oid *declared_arg_types,
|
|
int nargs);
|
|
|
|
extern CoercionPathType find_coercion_pathway(Oid targetTypeId,
|
|
Oid sourceTypeId,
|
|
CoercionContext ccontext,
|
|
Oid *funcid);
|
|
extern CoercionPathType find_typmod_coercion_function(Oid typeId,
|
|
Oid *funcid);
|
|
|
|
#endif /* PARSE_COERCE_H */
|