*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.21 1999/07/17 20:17:23 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.22 1999/08/05 02:33:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
int32 atttypmod)
{
Node *result = NULL;
- Type targetType;
- Oid infunc;
- Datum val;
- if (targetTypeId == InvalidOid)
+ if (targetTypeId == InvalidOid ||
+ targetTypeId == inputTypeId)
+ {
+ /* no conversion needed */
result = node;
- else if (inputTypeId != targetTypeId)
+ }
+ else if (IS_BINARY_COMPATIBLE(inputTypeId, targetTypeId))
{
-
- /*
- * one of the known-good transparent conversions? then drop
- * through...
+ /* no work if one of the known-good transparent conversions */
+ result = node;
+ }
+ else if (inputTypeId == UNKNOWNOID && IsA(node, Const))
+ {
+ /* Input is a string constant with previously undetermined type.
+ * Apply the target type's typinput function to it to produce
+ * a constant of the target type.
+ *
+ * NOTE: this case cannot be folded together with the other
+ * constant-input case, since the typinput function does not
+ * necessarily behave the same as a type conversion function.
+ * For example, int4's typinput function will reject "1.2",
+ * whereas float-to-int type conversion will round to integer.
*/
- if (IS_BINARY_COMPATIBLE(inputTypeId, targetTypeId))
- result = node;
+ Const *con = (Const *) node;
+ Type targetType = typeidType(targetTypeId);
+ char *val;
+ /* We know the source constant is really of type 'text' */
+ val = textout((text *) con->constvalue);
+
+ /* now make a new const node */
+ con = makeNode(Const);
+ con->consttype = targetTypeId;
+ con->constlen = typeLen(targetType);
+ con->constvalue = stringTypeDatum(targetType, val, atttypmod);
+ con->constisnull = false;
+ con->constbyval = typeByVal(targetType);
+ con->constisset = false;
+
+ pfree(val);
+
+ result = (Node *) con;
+ }
+ else
+ {
/*
- * if not unknown input type, try for explicit conversion using
- * functions...
+ * 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.
*/
- else if (inputTypeId != UNKNOWNOID)
- {
+ FuncCall *n = makeNode(FuncCall);
+ Type targetType = typeidType(targetTypeId);
- /*
- * We already know there is a function which will do this, so
- * let's use it
- */
- FuncCall *n = makeNode(FuncCall);
+ n->funcname = typeTypeName(targetType);
+ n->args = lcons(node, NIL);
- n->funcname = typeidTypeName(targetTypeId);
- n->args = lcons(node, NIL);
+ result = transformExpr(pstate, (Node *) n, EXPR_COLUMN_FIRST);
- result = transformExpr(pstate, (Node *) n, EXPR_COLUMN_FIRST);
- }
- else
+ /*
+ * If the input is a constant, apply the type conversion function
+ * now instead of delaying to runtime. (This could someday be
+ * done in a downstream constant-expression-simplifier, but we
+ * can save cycles in the rewriter if we do it here.)
+ *
+ * XXX there are cases where we probably shouldn't do this,
+ * such as coercing text 'now' to datetime? Need a way to
+ * know whether type conversion function is cacheable...
+ */
+ if (IsA(node, Const))
{
- if (nodeTag(node) == T_Const)
- {
- Const *con = (Const *) node;
-
- val = (Datum) textout((struct varlena *) con->constvalue);
- targetType = typeidType(targetTypeId);
- infunc = typeInfunc(targetType);
- con = makeNode(Const);
- con->consttype = targetTypeId;
- con->constlen = typeLen(targetType);
-
- /*
- * Use "-1" for varchar() type. For char(), we need to pad
- * out the type with the proper number of spaces. This
- * was a major problem for DEFAULT string constants to
- * char() types.
- */
- con->constvalue = (Datum) fmgr(infunc,
- val,
- typeTypElem(targetType),
- (targetTypeId != BPCHAROID) ? -1 : atttypmod);
- con->constisnull = false;
- con->constbyval = typeByVal(targetType);
- con->constisset = false;
- result = (Node *) con;
- }
- else
- result = node;
+ Const *con = (Const *) node;
+ Oid convertFuncid;
+ Datum val;
+
+ Assert(IsA(result, Expr) &&
+ ((Expr *) result)->opType == FUNC_EXPR);
+
+ /* Convert the given constant */
+ convertFuncid = ((Func *) (((Expr *) result)->oper))->funcid;
+ val = (Datum) fmgr(convertFuncid, con->constvalue);
+
+ /* now make a new const node */
+ con = makeNode(Const);
+ con->consttype = targetTypeId;
+ con->constlen = typeLen(targetType);
+ con->constvalue = val;
+ con->constisnull = false;
+ con->constbyval = typeByVal(targetType);
+ con->constisset = false;
+
+ result = (Node *) con;
}
}
- else
- result = node;
return result;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.55 1999/07/19 00:26:19 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.56 1999/08/05 02:33:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
return -1;
}
+/*
+ * Produce an appropriate Const node from a constant value produced
+ * by the parser and an explicit type name to cast to.
+ */
static Node *
parser_typecast(Value *expr, TypeName *typename, int32 atttypmod)
{
- /* check for passing non-ints */
Const *adt;
Datum lcp;
Type tp;
- char type_string[NAMEDATALEN];
- int32 len;
- char *cp = NULL;
char *const_string = NULL;
bool string_palloced = false;
break;
default:
elog(ERROR,
- "parser_typecast: cannot cast this expression to type '%s'",
+ "parser_typecast: cannot cast this expression to type '%s'",
typename->name);
}
if (typename->arrayBounds != NIL)
{
+ char type_string[NAMEDATALEN+2];
+
sprintf(type_string, "_%s", typename->name);
tp = (Type) typenameType(type_string);
}
else
tp = (Type) typenameType(typename->name);
- len = typeLen(tp);
-
- cp = stringTypeString(tp, const_string, atttypmod);
-
- if (!typeByVal(tp))
- lcp = PointerGetDatum(cp);
- else
- {
- switch (len)
- {
- case 1:
- lcp = Int8GetDatum(cp);
- break;
- case 2:
- lcp = Int16GetDatum(cp);
- break;
- case 4:
- lcp = Int32GetDatum(cp);
- break;
- default:
- lcp = PointerGetDatum(cp);
- break;
- }
- }
-
- adt = makeConst(typeTypeId(tp),
- len,
- (Datum) lcp,
- false,
- typeByVal(tp),
- false, /* not a set */
- true /* is cast */ );
-
- if (string_palloced)
- pfree(const_string);
-
- return (Node *) adt;
-}
-
-
-/* parser_typecast2()
- * Convert (only) constants to specified type.
- */
-Node *
-parser_typecast2(Node *expr, Oid exprType, Type tp, int32 atttypmod)
-{
- /* check for passing non-ints */
- Const *adt;
- Datum lcp;
- int32 len = typeLen(tp);
- char *cp = NULL;
-
- char *const_string = NULL;
- bool string_palloced = false;
-
- Assert(IsA(expr, Const));
-
- switch (exprType)
- {
- case 0: /* NULL */
- break;
- case INT4OID: /* int4 */
- const_string = (char *) palloc(256);
- string_palloced = true;
- sprintf(const_string, "%d",
- (int) ((Const *) expr)->constvalue);
- break;
- case NAMEOID: /* name */
- const_string = (char *) palloc(256);
- string_palloced = true;
- sprintf(const_string, "%s",
- (char *) ((Const *) expr)->constvalue);
- break;
- case CHAROID: /* char */
- const_string = (char *) palloc(256);
- string_palloced = true;
- sprintf(const_string, "%c",
- (char) ((Const *) expr)->constvalue);
- break;
- case FLOAT4OID: /* float4 */
- {
- float32 floatVal = DatumGetFloat32(((Const *) expr)->constvalue);
-
- const_string = (char *) palloc(256);
- string_palloced = true;
- sprintf(const_string, "%f", *floatVal);
- break;
- }
- case FLOAT8OID: /* float8 */
- {
- float64 floatVal = DatumGetFloat64(((Const *) expr)->constvalue);
-
- const_string = (char *) palloc(256);
- string_palloced = true;
- sprintf(const_string, "%f", *floatVal);
- break;
- }
- case CASHOID: /* money */
- const_string = (char *) palloc(256);
- string_palloced = true;
- sprintf(const_string, "%ld",
- (long) ((Const *) expr)->constvalue);
- break;
- case TEXTOID: /* text */
- const_string = DatumGetPointer(((Const *) expr)->constvalue);
- const_string = (char *) textout((struct varlena *) const_string);
- break;
- case UNKNOWNOID: /* unknown */
- const_string = DatumGetPointer(((Const *) expr)->constvalue);
- const_string = (char *) textout((struct varlena *) const_string);
- break;
- default:
- elog(ERROR, "unknown type %u", exprType);
- }
-
- if (!exprType)
- {
- adt = makeConst(typeTypeId(tp),
- (Size) 0,
- (Datum) NULL,
- true, /* isnull */
- false, /* was omitted */
- false, /* not a set */
- true /* is cast */ );
- return (Node *) adt;
- }
-
- cp = stringTypeString(tp, const_string, atttypmod);
-
- if (!typeByVal(tp))
- lcp = PointerGetDatum(cp);
- else
- {
- switch (len)
- {
- case 1:
- lcp = Int8GetDatum(cp);
- break;
- case 2:
- lcp = Int16GetDatum(cp);
- break;
- case 4:
- lcp = Int32GetDatum(cp);
- break;
- default:
- lcp = PointerGetDatum(cp);
- break;
- }
- }
+ lcp = stringTypeDatum(tp, const_string, atttypmod);
adt = makeConst(typeTypeId(tp),
- (Size) len,
+ typeLen(tp),
(Datum) lcp,
false,
typeByVal(tp),
false, /* not a set */
true /* is cast */ );
- /*
- * printf("adt %s : %u %d %d\n",CString(expr),typeTypeId(tp) ,
- * len,cp);
- */
if (string_palloced)
pfree(const_string);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.50 1999/07/17 20:17:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.51 1999/08/05 02:33:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
i < nargs;
i++, current_fargs = lnext(current_fargs))
{
-
- /*
- * unspecified type for string constant? then use heuristics for
- * conversion...
- */
- if (input_typeids[i] == UNKNOWNOID && function_typeids[i] != InvalidOid)
- {
- lfirst(current_fargs) = parser_typecast2(lfirst(current_fargs),
- input_typeids[i],
- typeidType(function_typeids[i]),
- -1);
- }
-
/* types don't match? then force coersion using a function call... */
- else if (input_typeids[i] != function_typeids[i])
+ if (input_typeids[i] != function_typeids[i])
{
lfirst(current_fargs) = coerce_type(pstate,
lfirst(current_fargs),
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.24 1999/07/17 20:17:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.25 1999/08/05 02:33:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/* Given a type structure and a string, returns the internal form of
that string */
-char *
-stringTypeString(Type tp, char *string, int32 atttypmod)
+Datum
+stringTypeDatum(Type tp, char *string, int32 atttypmod)
{
Oid op;
Oid typelem;
op = ((Form_pg_type) GETSTRUCT(tp))->typinput;
typelem = ((Form_pg_type) GETSTRUCT(tp))->typelem; /* XXX - used for
* array_in */
- return (char *) fmgr(op, string, typelem, atttypmod);
+ return (Datum) fmgr(op, string, typelem, atttypmod);
}
/* Given a type id, returns the out-conversion function of the type */
return typtup->typinput;
}
+
+/* Given a type structure, return the out-conversion function of the type */
+Oid
+typeOutfunc(Type typ)
+{
+ Form_pg_type typtup;
+
+ typtup = (Form_pg_type) GETSTRUCT(typ);
+
+ return typtup->typoutput;
+}
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_expr.h,v 1.14 1999/07/19 00:26:16 tgl Exp $
+ * $Id: parse_expr.h,v 1.15 1999/08/05 02:33:51 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern Node *transformExpr(ParseState *pstate, Node *expr, int precedence);
extern Oid exprType(Node *expr);
extern int32 exprTypmod(Node *expr);
-extern Node *parser_typecast2(Node *expr, Oid exprType, Type tp, int32 attypmod);
#endif /* PARSE_EXPR_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_type.h,v 1.10 1999/05/29 03:17:19 tgl Exp $
+ * $Id: parse_type.h,v 1.11 1999/08/05 02:33:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern bool typeByVal(Type t);
extern char *typeTypeName(Type t);
extern char typeTypeFlag(Type t);
-extern char *stringTypeString(Type tp, char *string, int32 atttypmod);
+extern Datum stringTypeDatum(Type tp, char *string, int32 atttypmod);
extern Oid typeidTypeRelid(Oid type_id);
extern Oid typeTypeRelid(Type typ);
extern Oid typeTypElem(Type typ);
extern Oid GetArrayElementType(Oid typearray);
extern Oid typeInfunc(Type typ);
+extern Oid typeOutfunc(Type typ);
#endif /* PARSE_TYPE_H */
projects / postgresql.git / commitdiff