Fix for DEFAULT ''.

diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 219d1df480ba764ee6435ce02be2b4b5e36953a8..ba7d7e2939afcb45515d35cb490e5a841a14d20f 100644 (file)
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -1538,26 +1538,11 @@ start:
 
        if (type != atp->atttypid)
        {
-               /*
-                *      Though these types are binary compatible, bpchar has a fixed
-                *      length on the disk, requiring non-bpchar types to be padded
-                *      before storage in the default table.  bjm 1999/05/18
-                */
-               if (1==0 && atp->atttypid == BPCHAROID &&
-                       (type == TEXTOID || type == BPCHAROID || type == UNKNOWNOID))
-               {
-
-                       FuncCall   *n = makeNode(FuncCall);
-
-                       n->funcname = typeidTypeName(atp->atttypid);
-                       n->args = lcons((Node *)expr, NIL);
-                       expr = transformExpr(NULL, (Node *) n, EXPR_COLUMN_FIRST);
-
-               }
-               else if (IS_BINARY_COMPATIBLE(type, atp->atttypid))
+               if (IS_BINARY_COMPATIBLE(type, atp->atttypid))
                        ; /* use without change */
                else if (can_coerce_type(1, &(type), &(atp->atttypid)))
-                       expr = coerce_type(NULL, (Node *)expr, type, atp->atttypid);
+                       expr = coerce_type(NULL, (Node *)expr, type, atp->atttypid,
+                                                                                                                atp->atttypmod);
                else if (IsA(expr, Const))
                {
                        if (*cast != 0)

diff --git a/src/backend/parser/parse_coerce.c b/src/backend/parser/parse_coerce.c
index ad1b0bbc1626d64a5ff6bfcc0282463e8671f2c9..56d43bbe17e53cde265346227d4b67c0c75dfa8a 100644 (file)
--- a/src/backend/parser/parse_coerce.c
+++ b/src/backend/parser/parse_coerce.c
@@ -35,7 +35,8 @@ static Oid PreferredType(CATEGORY category, Oid type);
  * Convert a function argument to a different type.
  */
 Node *
-coerce_type(ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId)
+coerce_type(ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId,
+               int32 atttypmod)
 {
        Node       *result = NULL;
        Oid                     infunc;
@@ -82,11 +83,16 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId)
                                con->consttype = targetTypeId;
                                con->constlen = typeLen(typeidType(targetTypeId));
 
-                               /* use "-1" for varchar() type */
+                               /*
+                                *      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,
                                                                                           typeidTypElem(targetTypeId),
-                                                                                          -1);
+                                                               (targetTypeId != BPCHAROID) ? -1 : atttypmod);
                                con->constisnull = false;
                                con->constbyval = typeByVal(typeidType(targetTypeId));
                                con->constisset = false;
@@ -100,7 +106,7 @@ coerce_type(ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId)
                result = node;
 
        return result;
-}      /* coerce_type() */
+}
 
 
 /* can_coerce_type()
@@ -178,7 +184,7 @@ can_coerce_type(int nargs, Oid *input_typeids, Oid *func_typeids)
        }
 
        return true;
-}      /* can_coerce_type() */
+}
 
 
 /* TypeCategory()

diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index 82978eb71b4372899a23c17507a1565e9ad4c0c0..789c418464bb3fa8ef63ebdec168b09ee97d49ee 100644 (file)
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -417,7 +417,8 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
                                        }
                                        else if (can_coerce_type(1, &c->casetype, &ptype))
                                        {
-                                               c->defresult = coerce_type(pstate, c->defresult, c->casetype, ptype);
+                                               c->defresult = coerce_type(pstate, c->defresult,
+                                                                                                       c->casetype, ptype, -1);
                                                c->casetype = ptype;
                                        }
                                        else
@@ -439,7 +440,8 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
                                        {
                                                if (can_coerce_type(1, &wtype, &ptype))
                                                {
-                                                       w->result = coerce_type(pstate, w->result, wtype, ptype);
+                                                       w->result = coerce_type(pstate, w->result, wtype,
+                                                                                                       ptype, -1);
                                                }
                                                else
                                                {

diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c
index ed2c5eb95ccc6cd39162ab51acba2737c044c163..033605037bd865bc790a29ad885993bbbbb65c25 100644 (file)
--- a/src/backend/parser/parse_func.c
+++ b/src/backend/parser/parse_func.c
@@ -352,7 +352,6 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
                }
                else
                {
-
                        /*
                         * Parsing aggregates.
                         */
@@ -361,7 +360,6 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
                        int                             ncandidates;
                        CandidateList   candidates;
 
-
                        /*
                         * the aggregate COUNT is a special case, ignore its base
                         * type.  Treat it as zero
@@ -392,7 +390,8 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
                                type = agg_select_candidate(basetype, candidates);
                                if (OidIsValid(type))
                                {
-                                       lfirst(fargs) = coerce_type(pstate, lfirst(fargs), basetype, type);
+                                       lfirst(fargs) = coerce_type(pstate, lfirst(fargs),
+                                                                                               basetype, type, -1);
                                        basetype = type;
 
                                        return (Node *) ParseAgg(pstate, funcname, basetype,
@@ -1316,7 +1315,7 @@ make_arguments(ParseState *pstate,
                        lfirst(current_fargs) = coerce_type(pstate,
                                                                                                lfirst(current_fargs),
                                                                                                input_typeids[i],
-                                                                                               function_typeids[i]);
+                                                                                               function_typeids[i], -1);
                }
        }
 }

diff --git a/src/backend/parser/parse_node.c b/src/backend/parser/parse_node.c
index f1765b4926af9e725e8a004e1800c676c1e0ee6c..9db51d3712c7ecfa16c3dd38984c7cd9fb47c32c 100644 (file)
--- a/src/backend/parser/parse_node.c
+++ b/src/backend/parser/parse_node.c
@@ -75,9 +75,7 @@ make_operand(char *opname,
 
                /* must coerce? */
                if (true_typeId != orig_typeId)
-               {
-                       result = coerce_type(NULL, tree, orig_typeId, true_typeId);
-               }
+                       result = coerce_type(NULL, tree, orig_typeId, true_typeId, -1);
        }
        /* otherwise, this is a NULL value */
        else

diff --git a/src/backend/parser/parse_relation.c b/src/backend/parser/parse_relation.c
index 079e0524f58b4ec713b5dcb53da70bea7e985984..907cbd04c34d68aaf8401a83b2f77ce487fc4b17 100644 (file)
--- a/src/backend/parser/parse_relation.c
+++ b/src/backend/parser/parse_relation.c
@@ -445,7 +445,9 @@ checkTargetTypes(ParseState *pstate, char *target_colname,
        {
                if (can_coerce_type(1, &attrtype_id, &attrtype_target))
                {
-                       Node       *expr = coerce_type(pstate, expr, attrtype_id, attrtype_target);
+                       Node       *expr = coerce_type(pstate, expr, attrtype_id,
+                                                                                       attrtype_target,
+                       get_atttypmod(pstate->p_target_relation->rd_id, resdomno_target));
 
                        elog(ERROR, "Type %s(%d) can be coerced to match target column %s(%d)",
                                 colname, get_atttypmod(rte->relid, resdomno_id),

diff --git a/src/backend/parser/parse_target.c b/src/backend/parser/parse_target.c
index 4e155a2bbada3977ef600cd1d643e048a00c68cd..0178604f4c2430916107d1dca0256590e5b3893c 100644 (file)
--- a/src/backend/parser/parse_target.c
+++ b/src/backend/parser/parse_target.c
@@ -121,7 +121,9 @@ MakeTargetEntryIdent(ParseState *pstate,
                {
                        if (can_coerce_type(1, &attrtype_id, &attrtype_target))
                        {
-                               expr = coerce_type(pstate, node, attrtype_id, attrtype_target);
+                               expr = coerce_type(pstate, node, attrtype_id,
+                                                                       attrtype_target,
+                       get_atttypmod(pstate->p_target_relation->rd_id, resdomno_target));
                                expr = transformExpr(pstate, expr, EXPR_COLUMN_FIRST);
                                tent = MakeTargetEntryExpr(pstate, *resname, expr, false, false);
                                expr = tent->expr;
@@ -666,7 +668,7 @@ CoerceTargetExpr(ParseState *pstate,
 {
        if (can_coerce_type(1, &type_id, &attrtype))
        {
-               expr = coerce_type(pstate, expr, type_id, attrtype);
+               expr = coerce_type(pstate, expr, type_id, attrtype, -1);
        }
 
 #ifndef DISABLE_STRING_HACKS
@@ -683,7 +685,7 @@ CoerceTargetExpr(ParseState *pstate,
                {
                }
                else if (can_coerce_type(1, &type_id, &text_id))
-                       expr = coerce_type(pstate, expr, type_id, text_id);
+                       expr = coerce_type(pstate, expr, type_id, text_id, -1);
                else
                        expr = NULL;
        }

diff --git a/src/include/parser/parse_coerce.h b/src/include/parser/parse_coerce.h
index 4e25ce6cb8f6c5af57a381758ab9fc4ccaa3cc86..d77102fce74dced692248f3fba6555dac82af01b 100644 (file)
--- a/src/include/parser/parse_coerce.h
+++ b/src/include/parser/parse_coerce.h
@@ -121,6 +121,7 @@ extern bool IsPreferredType(CATEGORY category, Oid type);
 extern CATEGORY TypeCategory(Oid type);
 
 extern bool can_coerce_type(int nargs, Oid *input_typeids, Oid *func_typeids);
-extern Node *coerce_type(ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId);
+extern Node *coerce_type(ParseState *pstate, Node *node, Oid inputTypeId,
+                                                Oid targetTypeId, int32 atttypmod);
 
 #endif  /* PARSE_COERCE_H */