mirror of
https://github.com/postgres/postgres.git
synced 2026-01-27 21:43:08 +03:00
0da39aa766
If a column is omitted in an INSERT, and there's no column default, the code in preptlist.c generates a NULL Const to be inserted. Furthermore, if the column is of a domain type, we wrap the Const in CoerceToDomain, so as to throw a run-time error if the domain has a NOT NULL constraint. That's fine as far as it goes, but there are two problems: 1. We're being sloppy about the type/typmod that the Const is labeled with. It really should have the domain's base type/typmod, since it's the input to CoerceToDomain not the output. This can result in coerce_to_domain inserting a useless length-coercion function (useless because it's being applied to a null). The coercion would typically get const-folded away later, but it'd be better not to create it in the first place. 2. We're not applying expression preprocessing (specifically, eval_const_expressions) to the resulting expression tree. The planner's primary expression-preprocessing pass already happened, so that means the length coercion step and CoerceToDomain node miss preprocessing altogether. This is at the least inefficient, since it means the length coercion and CoerceToDomain will actually be executed for each inserted row, though they could be const-folded away in most cases. Worse, it seems possible that missing preprocessing for the length coercion could result in an invalid plan (for example, due to failing to perform default-function-argument insertion). I'm not aware of any live bug of that sort with core datatypes, and it might be unreachable for extension types as well because of restrictions of CREATE CAST, but I'm not entirely convinced that it's unreachable. Hence, it seems worth back-patching the fix (although I only went back to v14, as the patch doesn't apply cleanly at all in v13). There are several places in the rewriter that are building null domain constants the same way as preptlist.c. While those are before the planner and hence don't have any reachable bug, they're still applying a length coercion that will be const-folded away later, uselessly wasting cycles. Hence, make a utility routine that all of these places can call to do it right. Making this code more careful about the typmod assigned to the generated NULL constant has visible but cosmetic effects on some of the plans shown in contrib/postgres_fdw's regression tests. Discussion: https://postgr.es/m/1865579.1738113656@sss.pgh.pa.us Backpatch-through: 14
106 lines
3.8 KiB
C
106 lines
3.8 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* parse_coerce.h
|
|
* Routines for type coercion.
|
|
*
|
|
*
|
|
* Portions Copyright (c) 1996-2025, 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 IsBinaryCoercibleWithCast(Oid srctype, Oid targettype,
|
|
Oid *castoid);
|
|
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 Node *coerce_null_to_domain(Oid typid, int32 typmod, Oid collation,
|
|
int typlen, bool typbyval);
|
|
|
|
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 */
|