Skip to content

G
Gpdb

Greenplum / Gpdb

通知 7
Star 1
Fork 0
G
Gpdb

体验新版 GitCode，发现更多精彩内容 >>

提交 681ed4e2 编写于 作者: T Tom Lane
浏览文件
操作

Code cleanups: make non-implicit WITHOUT FUNCTION casts work, avoid 

redundant pg_cast searches, fix obsolete comments.
上级 a03f9adb
隐藏空白更改
内联 并排
Showing with 266 addition and 299 deletion
src/backend/parser/parse_coerce.c
浏览文件 @ 681ed4e2
......@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.81 2002/08/31 22:10:46 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.82 2002/09/01 02:27:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
......@@ -27,24 +27,27 @@
#include "utils/syscache.h"
Oid DemoteType(Oid inType);
Oid PromoteTypeToNext(Oid inType);
static Oid PreferredType(CATEGORY category, Oid type);
static Node *build_func_call(Oid funcid, Oid rettype, List *args);
static Oid find_coercion_function(Oid targetTypeId, Oid sourceTypeId,
bool isExplicit);
static bool find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId,
bool isExplicit,
Oid *funcid);
static Oid find_typmod_coercion_function(Oid typeId);
static Node *build_func_call(Oid funcid, Oid rettype, List *args);
/* coerce_type()
* Convert a function argument to a different type.
/*
* coerce_type()
* Convert a function argument to a different type.
*
* The caller should already have determined that the coercion is possible;
* see can_coerce_type.
*/
Node *
coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
Oid targetTypeId, int32 atttypmod, bool isExplicit)
{
Node *result;
Oid funcId;
if (targetTypeId == inputTypeId ||
node == NULL)
......@@ -118,25 +121,71 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
/* assume can_coerce_type verified that implicit coercion is okay */
result = node;
}
else if (IsBinaryCompatible(inputTypeId, targetTypeId))
else if (find_coercion_pathway(targetTypeId, inputTypeId, isExplicit,
&funcId))
{
/*
* We don't really need to do a conversion, but we do need to
* attach a RelabelType node so that the expression will be seen
* to have the intended type when inspected by higher-level code.
*
* Also, domains may have value restrictions beyond the base type
* that must be accounted for.
*/
result = coerce_type_constraints(pstate, node, targetTypeId, true);
/*
* XXX could we label result with exprTypmod(node) instead of
* default -1 typmod, to save a possible length-coercion later?
* Would work if both types have same interpretation of typmod,
* which is likely but not certain (wrong if target is a domain,
* in any case).
*/
result = (Node *) makeRelabelType(result, targetTypeId, -1);
if (OidIsValid(funcId))
{
/*
* Generate an expression tree representing run-time application
* of the conversion function. If we are dealing with a domain
* target type, the conversion function will yield the base type.
*/
Oid baseTypeId = getBaseType(targetTypeId);
result = build_func_call(funcId, baseTypeId, makeList1(node));
/*
* If domain, test against domain constraints and relabel with
* domain type ID
*/
if (targetTypeId != baseTypeId)
{
result = coerce_type_constraints(pstate, result,
targetTypeId, true);
result = (Node *) makeRelabelType(result, targetTypeId, -1);
}
/*
* If the input is a constant, apply the type conversion function
* now instead of delaying to runtime. (We could, of course, just
* leave this to be done during planning/optimization; but it's a
* very frequent special case, and we save cycles in the rewriter
* if we fold the expression now.)
*
* Note that no folding will occur if the conversion function is
* not marked 'immutable'.
*
* HACK: if constant is NULL, don't fold it here. This is needed
* by make_subplan(), which calls this routine on placeholder
* Const nodes that mustn't be collapsed. (It'd be a lot cleaner
* to make a separate node type for that purpose...)
*/
if (IsA(node, Const) &&
!((Const *) node)->constisnull)
result = eval_const_expressions(result);
}
else
{
/*
* We don't need to do a physical conversion, but we do need to
* attach a RelabelType node so that the expression will be seen
* to have the intended type when inspected by higher-level code.
*
* Also, domains may have value restrictions beyond the base type
* that must be accounted for.
*/
result = coerce_type_constraints(pstate, node,
targetTypeId, true);
/*
* XXX could we label result with exprTypmod(node) instead of
* default -1 typmod, to save a possible length-coercion later?
* Would work if both types have same interpretation of typmod,
* which is likely but not certain (wrong if target is a domain,
* in any case).
*/
result = (Node *) makeRelabelType(result, targetTypeId, -1);
}
}
else if (typeInheritsFrom(inputTypeId, targetTypeId))
{
......@@ -149,74 +198,23 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
}
else
{
/*
* Otherwise, find the appropriate type conversion function
* (caller should have determined that there is one), and generate
* an expression tree representing run-time application of the
* conversion function.
*
* For domains, we use the coercion function for the base type.
*/
Oid baseTypeId = getBaseType(targetTypeId);
Oid funcId;
funcId = find_coercion_function(baseTypeId,
getBaseType(inputTypeId),
isExplicit);
if (!OidIsValid(funcId))
elog(ERROR, "coerce_type: no conversion function from '%s' to '%s'",
format_type_be(inputTypeId), format_type_be(targetTypeId));
result = build_func_call(funcId, baseTypeId, makeList1(node));
/*
* If domain, test against domain constraints and relabel with
* domain type ID
*/
if (targetTypeId != baseTypeId)
{
result = coerce_type_constraints(pstate, result, targetTypeId,
true);
result = (Node *) makeRelabelType(result, targetTypeId, -1);
}
/*
* If the input is a constant, apply the type conversion function
* now instead of delaying to runtime. (We could, of course, just
* leave this to be done during planning/optimization; but it's a
* very frequent special case, and we save cycles in the rewriter
* if we fold the expression now.)
*
* Note that no folding will occur if the conversion function is not
* marked 'iscachable'.
*
* HACK: if constant is NULL, don't fold it here. This is needed by
* make_subplan(), which calls this routine on placeholder Const
* nodes that mustn't be collapsed. (It'd be a lot cleaner to
* make a separate node type for that purpose...)
*/
if (IsA(node, Const) &&
!((Const *) node)->constisnull)
result = eval_const_expressions(result);
/* If we get here, caller blew it */
elog(ERROR, "coerce_type: no conversion function from %s to %s",
format_type_be(inputTypeId), format_type_be(targetTypeId));
result = NULL; /* keep compiler quiet */
}
return result;
}
/* can_coerce_type()
* Can input_typeids be coerced to func_typeids?
*
* There are a few types which are known apriori to be convertible.
* We will check for those cases first, and then look for possible
* conversion functions.
/*
* can_coerce_type()
* Can input_typeids be coerced to func_typeids?
*
* We must be told whether this is an implicit or explicit coercion
* (explicit being a CAST construct, explicit function call, etc).
* We will accept a wider set of coercion cases for an explicit coercion.
*
* Notes:
* This uses the same mechanism as the CAST() SQL construct in gram.y.
*/
bool
can_coerce_type(int nargs, Oid *input_typeids, Oid *func_typeids,
......@@ -278,35 +276,101 @@ can_coerce_type(int nargs, Oid *input_typeids, Oid *func_typeids,
}
/*
* one of the known-good transparent conversions? then drop
* through...
* If pg_cast shows that we can coerce, accept. This test now
* covers both binary-compatible and coercion-function cases.
*/
if (IsBinaryCompatible(inputTypeId, targetTypeId))
if (find_coercion_pathway(targetTypeId, inputTypeId, isExplicit,
&funcId))
continue;
/*
* If input is a class type that inherits from target, no problem
* If input is a class type that inherits from target, accept
*/
if (typeInheritsFrom(inputTypeId, targetTypeId))
continue;
/*
* Else, try for run-time conversion using functions: look for a
* single-argument function named with the target type name and
* accepting the source type.
*
* If either type is a domain, use its base type instead.
* Else, cannot coerce at this argument position
*/
funcId = find_coercion_function(getBaseType(targetTypeId),
getBaseType(inputTypeId),
isExplicit);
if (!OidIsValid(funcId))
return false;
return false;
}
return true;
}
/*
* Create an expression tree to enforce the constraints (if any)
* that should be applied by the type. Currently this is only
* interesting for domain types.
*/
Node *
coerce_type_constraints(ParseState *pstate, Node *arg,
Oid typeId, bool applyTypmod)
{
char *notNull = NULL;
int32 typmod = -1;
for (;;)
{
HeapTuple tup;
Form_pg_type typTup;
tup = SearchSysCache(TYPEOID,
ObjectIdGetDatum(typeId),
0, 0, 0);
if (!HeapTupleIsValid(tup))
elog(ERROR, "coerce_type_constraints: failed to lookup type %u",
typeId);
typTup = (Form_pg_type) GETSTRUCT(tup);
/* Test for NOT NULL Constraint */
if (typTup->typnotnull && notNull == NULL)
notNull = pstrdup(NameStr(typTup->typname));
/* TODO: Add CHECK Constraints to domains */
if (typTup->typtype != 'd')
{
/* Not a domain, so done */
ReleaseSysCache(tup);
break;
}
Assert(typmod < 0);
typeId = typTup->typbasetype;
typmod = typTup->typtypmod;
ReleaseSysCache(tup);
}
/*
* If domain applies a typmod to its base type, do length coercion.
*/
if (applyTypmod && typmod >= 0)
arg = coerce_type_typmod(pstate, arg, typeId, typmod);
/*
* Only need to add one NOT NULL check regardless of how many
* domains in the stack request it. The topmost domain that
* requested it is used as the constraint name.
*/
if (notNull)
{
ConstraintTest *r = makeNode(ConstraintTest);
r->arg = arg;
r->testtype = CONSTR_TEST_NOTNULL;
r->name = notNull;
r->check_expr = NULL;
arg = (Node *) r;
}
return arg;
}
/* coerce_type_typmod()
* Force a value to a particular typmod, if meaningful and possible.
*
......@@ -317,21 +381,9 @@ can_coerce_type(int nargs, Oid *input_typeids, Oid *func_typeids,
* The caller must have already ensured that the value is of the correct
* type, typically by applying coerce_type.
*
* If the target column type possesses a function named for the type
* and having parameter signature (columntype, int4), we assume that
* the type requires coercion to its own length and that the said
* function should be invoked to do that.
*
* "bpchar" (ie, char(N)) and "numeric" are examples of such types.
*
* This mechanism may seem pretty grotty and in need of replacement by
* something in pg_cast, but since typmod is only interesting for datatypes
* that have special handling in the grammar, there's not really much
* percentage in making it any easier to apply such coercions ...
*
* NOTE: this does not need to work on domain types, because any typmod
* coercion for a domain is considered to be part of the type coercion
* needed to produce the domain value in the first place.
* needed to produce the domain value in the first place. So, no getBaseType.
*/
Node *
coerce_type_typmod(ParseState *pstate, Node *node,
......@@ -600,100 +652,6 @@ TypeCategory(Oid inType)
} /* TypeCategory() */
/* IsBinaryCompatible()
* Check if two types are binary-compatible.
*
* This notion allows us to cheat and directly exchange values without
* going through the trouble of calling a conversion function.
*
* XXX This should be moved to system catalog lookups
* to allow for better type extensibility.
*/
#define TypeIsTextGroup(t) \
((t) == TEXTOID || \
(t) == BPCHAROID || \
(t) == VARCHAROID)
/* Notice OidGroup is a subset of Int4GroupA */
#define TypeIsOidGroup(t) \
((t) == OIDOID || \
(t) == REGPROCOID || \
(t) == REGPROCEDUREOID || \
(t) == REGOPEROID || \
(t) == REGOPERATOROID || \
(t) == REGCLASSOID || \
(t) == REGTYPEOID)
/*
* INT4 is binary-compatible with many types, but we don't want to allow
* implicit coercion directly between, say, OID and AbsTime. So we subdivide
* the categories.
*/
#define TypeIsInt4GroupA(t) \
((t) == INT4OID || \
TypeIsOidGroup(t))
#define TypeIsInt4GroupB(t) \
((t) == INT4OID || \
(t) == ABSTIMEOID)
#define TypeIsInt4GroupC(t) \
((t) == INT4OID || \
(t) == RELTIMEOID)
#define TypeIsInetGroup(t) \
((t) == INETOID || \
(t) == CIDROID)
#define TypeIsBitGroup(t) \
((t) == BITOID || \
(t) == VARBITOID)
static bool
DirectlyBinaryCompatible(Oid type1, Oid type2)
{
HeapTuple tuple;
bool result;
if (type1 == type2)
return true;
tuple = SearchSysCache(CASTSOURCETARGET, type1, type2, 0, 0);
if (HeapTupleIsValid(tuple))
{
Form_pg_cast caststruct;
caststruct = (Form_pg_cast) GETSTRUCT(tuple);
result = caststruct->castfunc == InvalidOid && caststruct->castimplicit;
ReleaseSysCache(tuple);
}
else
result = false;
return result;
}
bool
IsBinaryCompatible(Oid type1, Oid type2)
{
if (DirectlyBinaryCompatible(type1, type2))
return true;
/*
* Perhaps the types are domains; if so, look at their base types
*/
if (OidIsValid(type1))
type1 = getBaseType(type1);
if (OidIsValid(type2))
type2 = getBaseType(type2);
if (DirectlyBinaryCompatible(type1, type2))
return true;
return false;
}
/* IsPreferredType()
* Check if this type is a preferred type.
* XXX This should be moved to system catalog lookups
......@@ -733,7 +691,13 @@ PreferredType(CATEGORY category, Oid type)
break;
case (NUMERIC_TYPE):
if (TypeIsOidGroup(type))
if (type == OIDOID ||
type == REGPROCOID ||
type == REGPROCEDUREOID ||
type == REGOPEROID ||
type == REGOPERATOROID ||
type == REGCLASSOID ||
type == REGTYPEOID)
result = OIDOID;
else if (type == NUMERICOID)
result = NUMERICOID;
......@@ -768,30 +732,85 @@ PreferredType(CATEGORY category, Oid type)
return result;
} /* PreferredType() */
/*
* find_coercion_function
* Look for a coercion function between two types.
/* IsBinaryCompatible()
* Check if two types are binary-compatible.
*
* A coercion function must be named after (the internal name of) its
* result type, and must accept exactly the specified input type. We
* also require it to be defined in the same namespace as its result type.
* Furthermore, unless we are doing explicit coercion the function must
* be marked as usable for implicit coercion --- this allows coercion
* functions to be provided that aren't implicitly invokable.
* This notion allows us to cheat and directly exchange values without
* going through the trouble of calling a conversion function.
*
* This routine is also used to look for length-coercion functions, which
* are similar but accept a second argument. secondArgType is the type
* of the second argument (normally INT4OID), or InvalidOid if we are
* looking for a regular coercion function.
* As of 7.3, binary compatibility isn't hardwired into the code anymore.
* We consider two types binary-compatible if there is an implicit,
* no-function-needed pg_cast entry. NOTE that we assume that such
* entries are symmetric, ie, it doesn't matter which type we consider
* source and which target. (cf. checks in opr_sanity regression test)
*/
bool
IsBinaryCompatible(Oid type1, Oid type2)
{
HeapTuple tuple;
Form_pg_cast castForm;
bool result;
/* Fast path if same type */
if (type1 == type2)
return true;
/* Perhaps the types are domains; if so, look at their base types */
if (OidIsValid(type1))
type1 = getBaseType(type1);
if (OidIsValid(type2))
type2 = getBaseType(type2);
/* Somewhat-fast path if same base type */
if (type1 == type2)
return true;
/* Else look in pg_cast */
tuple = SearchSysCache(CASTSOURCETARGET,
ObjectIdGetDatum(type1),
ObjectIdGetDatum(type2),
0, 0);
if (!HeapTupleIsValid(tuple))
return false; /* no cast */
castForm = (Form_pg_cast) GETSTRUCT(tuple);
result = (castForm->castfunc == InvalidOid) && castForm->castimplicit;
ReleaseSysCache(tuple);
return result;
}
/*
* find_coercion_pathway
* Look for a coercion pathway between two types.
*
* If a function is found, return its pg_proc OID; else return InvalidOid.
* If we find a matching entry in pg_cast, return TRUE, and set *funcid
* to the castfunc value (which may be InvalidOid for a binary-compatible
* coercion).
*/
static Oid
find_coercion_function(Oid targetTypeId, Oid sourceTypeId, bool isExplicit)
static bool
find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId, bool isExplicit,
Oid *funcid)
{
Oid funcid = InvalidOid;
bool result = false;
HeapTuple tuple;
*funcid = InvalidOid;
/* Perhaps the types are domains; if so, look at their base types */
if (OidIsValid(sourceTypeId))
sourceTypeId = getBaseType(sourceTypeId);
if (OidIsValid(targetTypeId))
targetTypeId = getBaseType(targetTypeId);
/* Domains are automatically binary-compatible with their base type */
if (sourceTypeId == targetTypeId)
return true;
/* Else look in pg_cast */
tuple = SearchSysCache(CASTSOURCETARGET,
ObjectIdGetDatum(sourceTypeId),
ObjectIdGetDatum(targetTypeId),
......@@ -799,18 +818,36 @@ find_coercion_function(Oid targetTypeId, Oid sourceTypeId, bool isExplicit)
if (HeapTupleIsValid(tuple))
{
Form_pg_cast cform = (Form_pg_cast) GETSTRUCT(tuple);
Form_pg_cast castForm = (Form_pg_cast) GETSTRUCT(tuple);
if (isExplicit || cform->castimplicit)
funcid = cform->castfunc;
if (isExplicit || castForm->castimplicit)
{
*funcid = castForm->castfunc;
result = true;
}
ReleaseSysCache(tuple);
}
return funcid;
return result;
}
/*
* find_typmod_coercion_function -- does the given type need length coercion?
*
* If the target type possesses a function named for the type
* and having parameter signature (targettype, int4), we assume that
* the type requires coercion to its own length and that the said
* function should be invoked to do that.
*
* "bpchar" (ie, char(N)) and "numeric" are examples of such types.
*
* This mechanism may seem pretty grotty and in need of replacement by
* something in pg_cast, but since typmod is only interesting for datatypes
* that have special handling in the grammar, there's not really much
* percentage in making it any easier to apply such coercions ...
*/
static Oid
find_typmod_coercion_function(Oid typeId)
{
......@@ -849,6 +886,7 @@ find_typmod_coercion_function(Oid typeId)
}
ReleaseSysCache(targetType);
return funcid;
}
......@@ -877,74 +915,3 @@ build_func_call(Oid funcid, Oid rettype, List *args)
return (Node *) expr;
}
/*
* Create an expression tree to enforce the constraints (if any)
* that should be applied by the type. Currently this is only
* interesting for domain types.
*/
Node *
coerce_type_constraints(ParseState *pstate, Node *arg,
Oid typeId, bool applyTypmod)
{
char *notNull = NULL;
int32 typmod = -1;
for (;;)
{
HeapTuple tup;
Form_pg_type typTup;
tup = SearchSysCache(TYPEOID,
ObjectIdGetDatum(typeId),
0, 0, 0);
if (!HeapTupleIsValid(tup))
elog(ERROR, "coerce_type_constraints: failed to lookup type %u",
typeId);
typTup = (Form_pg_type) GETSTRUCT(tup);
/* Test for NOT NULL Constraint */
if (typTup->typnotnull && notNull == NULL)
notNull = pstrdup(NameStr(typTup->typname));
/* TODO: Add CHECK Constraints to domains */
if (typTup->typtype != 'd')
{
/* Not a domain, so done */
ReleaseSysCache(tup);
break;
}
Assert(typmod < 0);
typeId = typTup->typbasetype;
typmod = typTup->typtypmod;
ReleaseSysCache(tup);
}
/*
* If domain applies a typmod to its base type, do length coercion.
*/
if (applyTypmod && typmod >= 0)
arg = coerce_type_typmod(pstate, arg, typeId, typmod);
/*
* Only need to add one NOT NULL check regardless of how many
* domains in the stack request it. The topmost domain that
* requested it is used as the constraint name.
*/
if (notNull)
{
ConstraintTest *r = makeNode(ConstraintTest);
r->arg = arg;
r->testtype = CONSTR_TEST_NOTNULL;
r->name = notNull;
r->check_expr = NULL;
arg = (Node *) r;
}
return arg;
}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或