Subclasses inherit constraints of super classes properly

diff --git a/src/backend/commands/creatinh.c b/src/backend/commands/creatinh.c
index 1c49045330d9e1e99aa141aa6528a025ac43eb58..e39c24f8dfa6f936c3e75c6a3ee80e3a1744ba06 100644 (file)
--- a/src/backend/commands/creatinh.c
+++ b/src/backend/commands/creatinh.c
@@ -8,11 +8,7 @@
  *
  *
  * IDENTIFICATION
-<<<<<<< creatinh.c
- *   $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.62 2000/07/04 06:11:27 tgl Exp $
-=======
- *   $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.62 2000/07/04 06:11:27 tgl Exp $
->>>>>>> 1.58
+ *   $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.63 2000/08/04 06:12:11 inoue Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -29,13 +25,14 @@
 #include "commands/creatinh.h"
 #include "miscadmin.h"
 #include "utils/syscache.h"
+#include "optimizer/clauses.h"
 
 /* ----------------
  *     local stuff
  * ----------------
  */
 
-static bool checkAttrExists(const char *attributeName,
+static int checkAttrExists(const char *attributeName,
                const char *attributeType, List *schema);
 static List *MergeAttributes(List *schema, List *supers, List **supconstr);
 static void StoreCatalogInheritance(Oid relationId, List *supers);
@@ -246,6 +243,45 @@ TruncateRelation(char *name)
    heap_truncate(name);
 }
 
+/*
+ * complementary static functions for MergeAttributes().
+ * Varattnos of pg_relcheck.rcbin should be rewritten when
+ * subclasses inherit the constraints from the super class.
+ * Note that these functions rewrite varattnos while walking
+ * through a node tree. 
+ */
+static bool
+change_varattnos_walker(Node *node, const AttrNumber *newattno)
+{
+   if (node == NULL)
+       return false;
+   if (IsA(node, Var))
+   {
+       Var *var = (Var *) node;
+
+       Assert(newattno != NULL);
+       if (var->varlevelsup == 0 && var->varno == 1)
+       {
+           /*
+            * ??? the following may be a problem when the
+            * node is multiply referenced though
+            * stringToNode() doesn't create such a node
+            * currently. 
+            */
+           Assert(newattno[var->varattno - 1] > 0);
+           var->varattno = newattno[var->varattno - 1];
+           return true;
+       }
+       else
+           return false;
+   }
+   return expression_tree_walker(node, change_varattnos_walker, (void *)newattno);
+}
+static bool
+change_varattnos_of_a_node(Node *node, const AttrNumber *newattno)
+{
+   return expression_tree_walker(node, change_varattnos_walker, (void *)newattno);
+}
 /*
  * MergeAttributes
  *     Returns new schema given initial schema and supers.
@@ -283,6 +319,7 @@ MergeAttributes(List *schema, List *supers, List **supconstr)
    List       *entry;
    List       *inhSchema = NIL;
    List       *constraints = NIL;
+   int     attnums;
 
    /*
     * Validates that there are no duplications. Validity checking of
@@ -325,6 +362,7 @@ MergeAttributes(List *schema, List *supers, List **supconstr)
    /*
     * merge the inherited attributes into the schema
     */
+   attnums = 0;
    foreach(entry, supers)
    {
        char       *name = strVal(lfirst(entry));
@@ -333,15 +371,30 @@ MergeAttributes(List *schema, List *supers, List **supconstr)
        AttrNumber  attrno;
        TupleDesc   tupleDesc;
        TupleConstr *constr;
+       AttrNumber  *newattno, *partialAttidx;
+       Node        *expr;
+       int     i, attidx, attno_exist;
 
        relation = heap_openr(name, AccessShareLock);
        setRelhassubclassInRelation(relation->rd_id, true);
        tupleDesc = RelationGetDescr(relation);
+       /* allocate a new attribute number table and initialize */
+       newattno = (AttrNumber *) palloc(tupleDesc->natts * sizeof(AttrNumber));
+       for (i = 0; i < tupleDesc->natts; i++)
+           newattno [i] = 0;
+       /*
+        * searching and storing order are different.
+        * another table is needed.
+        */ 
+       partialAttidx = (AttrNumber *) palloc(tupleDesc->natts * sizeof(AttrNumber));
+       for (i = 0; i < tupleDesc->natts; i++)
+           partialAttidx [i] = 0;
        constr = tupleDesc->constr;
 
        if (relation->rd_rel->relkind != RELKIND_RELATION)
            elog(ERROR, "CREATE TABLE: inherited relation \"%s\" is not a table", name);
 
+       attidx = 0;
        for (attrno = relation->rd_rel->relnatts - 1; attrno >= 0; attrno--)
        {
            Form_pg_attribute attribute = tupleDesc->attrs[attrno];
@@ -365,16 +418,21 @@ MergeAttributes(List *schema, List *supers, List **supconstr)
             * check validity
             *
             */
-           if (checkAttrExists(attributeName, attributeType, schema))
+           if (checkAttrExists(attributeName, attributeType, schema) != 0)
                elog(ERROR, "CREATE TABLE: attribute \"%s\" already exists in inherited schema",
                     attributeName);
 
-           if (checkAttrExists(attributeName, attributeType, inhSchema))
+           if (0 < (attno_exist = checkAttrExists(attributeName, attributeType, inhSchema)))
+           {
 
                /*
                 * this entry already exists
                 */
+               newattno[attribute->attnum - 1] = attno_exist;
                continue;
+           }
+           attidx++;
+           partialAttidx[attribute->attnum - 1] = attidx;
 
            /*
             * add an entry to the schema
@@ -408,6 +466,13 @@ MergeAttributes(List *schema, List *supers, List **supconstr)
            }
            partialResult = lcons(def, partialResult);
        }
+       for (i = 0; i < tupleDesc->natts; i++)
+       {
+           if (partialAttidx[i] > 0)
+               newattno[i] = attnums + attidx + 1 - partialAttidx[i];
+       }
+       attnums += attidx;
+       pfree(partialAttidx);
 
        if (constr && constr->num_check > 0)
        {
@@ -424,10 +489,14 @@ MergeAttributes(List *schema, List *supers, List **supconstr)
                else
                    cdef->name = pstrdup(check[i].ccname);
                cdef->raw_expr = NULL;
-               cdef->cooked_expr = pstrdup(check[i].ccbin);
+               /* adjust varattnos of ccbin here */
+               expr = stringToNode(check[i].ccbin);
+               change_varattnos_of_a_node(expr, newattno);
+               cdef->cooked_expr = nodeToString(expr);
                constraints = lappend(constraints, cdef);
            }
        }
+       pfree(newattno);
 
        /*
         * Close the parent rel, but keep our AccessShareLock on it until
@@ -645,17 +714,19 @@ again:
 
 
 /*
- * returns true if attribute already exists in schema, false otherwise.
+ * returns the index(star with 1) if attribute already exists in schema, 0 otherwise.
  */
-static bool
+static int
 checkAttrExists(const char *attributeName, const char *attributeType, List *schema)
 {
    List       *s;
+   int i = 0;
 
    foreach(s, schema)
    {
        ColumnDef  *def = lfirst(s);
 
+       ++i;
        if (strcmp(attributeName, def->colname) == 0)
        {
 
@@ -665,10 +736,10 @@ checkAttrExists(const char *attributeName, const char *attributeType, List *sche
            if (strcmp(attributeType, def->typename->name) != 0)
                elog(ERROR, "CREATE TABLE: attribute \"%s\" type conflict (%s and %s)",
                     attributeName, attributeType, def->typename->name);
-           return true;
+           return i;
        }
    }
-   return false;
+   return 0;
 }