Allow ALTER TABLE name {OF type | NOT OF}.

This syntax allows a standalone table to be made into a typed table,
or a typed table to be made standalone.  This is possibly a mildly
useful feature in its own right, but the real motivation for this
change is that we need it to make pg_upgrade work with typed tables.
This doesn't actually fix that problem, but it's necessary
infrastructure.

Noah Misch

diff --git a/doc/src/sgml/ref/alter_table.sgml b/doc/src/sgml/ref/alter_table.sgml
index c1948624d7033c7b038bbe304ebd2890a2bda614..4e02438483b6344c4f0e3046f7952f0fadb20deb 100644 (file)
--- a/doc/src/sgml/ref/alter_table.sgml
+++ b/doc/src/sgml/ref/alter_table.sgml
@@ -63,6 +63,8 @@ ALTER TABLE <replaceable class="PARAMETER">name</replaceable>
     RESET ( <replaceable class="PARAMETER">storage_parameter</replaceable> [, ... ] )
     INHERIT <replaceable class="PARAMETER">parent_table</replaceable>
     NO INHERIT <replaceable class="PARAMETER">parent_table</replaceable>
+    OF <replaceable class="PARAMETER">type_name</replaceable>
+    NOT OF
     OWNER TO <replaceable class="PARAMETER">new_owner</replaceable>
     SET TABLESPACE <replaceable class="PARAMETER">new_tablespace</replaceable>
 
@@ -490,6 +492,30 @@ ALTER TABLE <replaceable class="PARAMETER">name</replaceable>
     </listitem>
    </varlistentry>
 
+   <varlistentry>
+    <term><literal>OF <replaceable class="PARAMETER">type_name</replaceable></literal></term>
+    <listitem>
+     <para>
+      This form links the table to a composite type as though <command>CREATE
+      TABLE OF</> had formed it.  The table's list of column names and types
+      must precisely match that of the composite type; the presence of
+      an <literal>oid</> system column is permitted to differ.  The table must
+      not inherit from any other table.  These restrictions ensure
+      that <command>CREATE TABLE OF</> would permit an equivalent table
+      definition.
+     </para>
+    </listitem>
+   </varlistentry>
+
+   <varlistentry>
+    <term><literal>NOT OF</literal></term>
+    <listitem>
+     <para>
+      This form dissociates a typed table from its type.
+     </para>
+    </listitem>
+   </varlistentry>
+
    <varlistentry>
     <term><literal>OWNER</literal></term>
     <listitem>

diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 1f709a4977360027e2783511fe50aa3182c55183..bb77c5311a965a9de8a7554ad0679767ed24fc37 100644 (file)
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -81,6 +81,7 @@
 #include "utils/snapmgr.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
+#include "utils/typcache.h"
 
 
 /*
@@ -357,6 +358,9 @@ static void ATExecEnableDisableRule(Relation rel, char *rulename,
 static void ATPrepAddInherit(Relation child_rel);
 static void ATExecAddInherit(Relation child_rel, RangeVar *parent, LOCKMODE lockmode);
 static void ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode);
+static void drop_parent_dependency(Oid relid, Oid refclassid, Oid refobjid);
+static void ATExecAddOf(Relation rel, const TypeName *ofTypename, LOCKMODE lockmode);
+static void ATExecDropOf(Relation rel, LOCKMODE lockmode);
 static void ATExecGenericOptions(Relation rel, List *options);
 
 static void copy_relation_data(SMgrRelation rel, SMgrRelation dst,
@@ -2683,6 +2687,16 @@ AlterTableGetLockLevel(List *cmds)
                                cmd_lockmode = ShareUpdateExclusiveLock;
                                break;
 
+                               /*
+                                * These subcommands affect implicit row type conversion. They
+                                * have affects similar to CREATE/DROP CAST on queries.  We
+                                * don't provide for invalidating parse trees as a result of
+                                * such changes.  Do avoid concurrent pg_class updates, though.
+                                */
+                       case AT_AddOf:
+                       case AT_DropOf:
+                               cmd_lockmode = ShareUpdateExclusiveLock;
+
                                /*
                                 * These subcommands affect general strategies for performance
                                 * and maintenance, though don't change the semantic results
@@ -2942,13 +2956,11 @@ ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
                case AT_EnableAlwaysRule:
                case AT_EnableReplicaRule:
                case AT_DisableRule:
-                       ATSimplePermissions(rel, ATT_TABLE);
-                       /* These commands never recurse */
-                       /* No command-specific prep needed */
-                       pass = AT_PASS_MISC;
-                       break;
                case AT_DropInherit:    /* NO INHERIT */
+               case AT_AddOf:                  /* OF */
+               case AT_DropOf:                 /* NOT OF */
                        ATSimplePermissions(rel, ATT_TABLE);
+                       /* These commands never recurse */
                        /* No command-specific prep needed */
                        pass = AT_PASS_MISC;
                        break;
@@ -3211,6 +3223,12 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel,
                case AT_DropInherit:
                        ATExecDropInherit(rel, (RangeVar *) cmd->def, lockmode);
                        break;
+               case AT_AddOf:
+                       ATExecAddOf(rel, (TypeName *) cmd->def, lockmode);
+                       break;
+               case AT_DropOf:
+                       ATExecDropOf(rel, lockmode);
+                       break;
                case AT_GenericOptions:
                        ATExecGenericOptions(rel, (List *) cmd->def);
                        break;
@@ -4045,6 +4063,42 @@ find_typed_table_dependencies(Oid typeOid, const char *typeName, DropBehavior be
 }
 
 
+/*
+ * check_of_type
+ *
+ * Check whether a type is suitable for CREATE TABLE OF/ALTER TABLE OF.  If it
+ * isn't suitable, throw an error.  Currently, we require that the type
+ * originated with CREATE TABLE AS.  We could support any row type, but doing so
+ * would require handling a number of extra corner cases in the DDL commands.
+ */
+void
+check_of_type(HeapTuple typetuple)
+{
+       Form_pg_type typ = (Form_pg_type) GETSTRUCT(typetuple);
+       bool            typeOk = false;
+
+       if (typ->typtype == TYPTYPE_COMPOSITE)
+       {
+               Relation        typeRelation;
+
+               Assert(OidIsValid(typ->typrelid));
+               typeRelation = relation_open(typ->typrelid, AccessShareLock);
+               typeOk = (typeRelation->rd_rel->relkind == RELKIND_COMPOSITE_TYPE);
+               /*
+                * Close the parent rel, but keep our AccessShareLock on it until xact
+                * commit.      That will prevent someone else from deleting or ALTERing
+                * the type before the typed table creation/conversion commits.
+                */
+               relation_close(typeRelation, NoLock);
+       }
+       if (!typeOk)
+               ereport(ERROR,
+                               (errcode(ERRCODE_WRONG_OBJECT_TYPE),
+                                errmsg("type %s is not a composite type",
+                                               format_type_be(HeapTupleGetOid(typetuple)))));
+}
+
+
 /*
  * ALTER TABLE ADD COLUMN
  *
@@ -8355,8 +8409,7 @@ ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode)
        ScanKeyData key[3];
        HeapTuple       inheritsTuple,
                                attributeTuple,
-                               constraintTuple,
-                               depTuple;
+                               constraintTuple;
        List       *connames;
        bool            found = false;
 
@@ -8522,11 +8575,29 @@ ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode)
        systable_endscan(scan);
        heap_close(catalogRelation, RowExclusiveLock);
 
-       /*
-        * Drop the dependency
-        *
-        * There's no convenient way to do this, so go trawling through pg_depend
-        */
+       drop_parent_dependency(RelationGetRelid(rel),
+                                                  RelationRelationId,
+                                                  RelationGetRelid(parent_rel));
+
+       /* keep our lock on the parent relation until commit */
+       heap_close(parent_rel, NoLock);
+}
+
+/*
+ * Drop the dependency created by StoreCatalogInheritance1 (CREATE TABLE
+ * INHERITS/ALTER TABLE INHERIT -- refclassid will be RelationRelationId) or
+ * heap_create_with_catalog (CREATE TABLE OF/ALTER TABLE OF -- refclassid will
+ * be TypeRelationId).  There's no convenient way to do this, so go trawling
+ * through pg_depend.
+ */
+static void
+drop_parent_dependency(Oid relid, Oid refclassid, Oid refobjid)
+{
+       Relation        catalogRelation;
+       SysScanDesc scan;
+       ScanKeyData key[3];
+       HeapTuple       depTuple;
+
        catalogRelation = heap_open(DependRelationId, RowExclusiveLock);
 
        ScanKeyInit(&key[0],
@@ -8536,7 +8607,7 @@ ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode)
        ScanKeyInit(&key[1],
                                Anum_pg_depend_objid,
                                BTEqualStrategyNumber, F_OIDEQ,
-                               ObjectIdGetDatum(RelationGetRelid(rel)));
+                               ObjectIdGetDatum(relid));
        ScanKeyInit(&key[2],
                                Anum_pg_depend_objsubid,
                                BTEqualStrategyNumber, F_INT4EQ,
@@ -8549,8 +8620,8 @@ ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode)
        {
                Form_pg_depend dep = (Form_pg_depend) GETSTRUCT(depTuple);
 
-               if (dep->refclassid == RelationRelationId &&
-                       dep->refobjid == RelationGetRelid(parent_rel) &&
+               if (dep->refclassid == refclassid &&
+                       dep->refobjid == refobjid &&
                        dep->refobjsubid == 0 &&
                        dep->deptype == DEPENDENCY_NORMAL)
                        simple_heap_delete(catalogRelation, &depTuple->t_self);
@@ -8558,9 +8629,181 @@ ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode)
 
        systable_endscan(scan);
        heap_close(catalogRelation, RowExclusiveLock);
+}
 
-       /* keep our lock on the parent relation until commit */
-       heap_close(parent_rel, NoLock);
+/*
+ * ALTER TABLE OF
+ *
+ * Attach a table to a composite type, as though it had been created with CREATE
+ * TABLE OF.  All attname, atttypid, atttypmod and attcollation must match.  The
+ * subject table must not have inheritance parents.  These restrictions ensure
+ * that you cannot create a configuration impossible with CREATE TABLE OF alone.
+ */
+static void
+ATExecAddOf(Relation rel, const TypeName *ofTypename, LOCKMODE lockmode)
+{
+       Oid                     relid = RelationGetRelid(rel);
+       Type            typetuple;
+       Form_pg_type typ;
+       Oid                     typeid;
+       Relation        inheritsRelation,
+                               relationRelation;
+       SysScanDesc scan;
+       ScanKeyData key;
+       AttrNumber      table_attno,
+                               type_attno;
+       TupleDesc       typeTupleDesc,
+                               tableTupleDesc;
+       ObjectAddress tableobj,
+                               typeobj;
+       HeapTuple       classtuple;
+
+       /* Validate the type. */
+       typetuple = typenameType(NULL, ofTypename, NULL);
+       check_of_type(typetuple);
+       typ = (Form_pg_type) GETSTRUCT(typetuple);
+       typeid = HeapTupleGetOid(typetuple);
+
+       /* Fail if the table has any inheritance parents. */
+       inheritsRelation = heap_open(InheritsRelationId, AccessShareLock);
+       ScanKeyInit(&key,
+                               Anum_pg_inherits_inhrelid,
+                               BTEqualStrategyNumber, F_OIDEQ,
+                               ObjectIdGetDatum(relid));
+       scan = systable_beginscan(inheritsRelation, InheritsRelidSeqnoIndexId,
+                                                         true, SnapshotNow, 1, &key);
+       if (HeapTupleIsValid(systable_getnext(scan)))
+               ereport(ERROR,
+                               (errcode(ERRCODE_WRONG_OBJECT_TYPE),
+                                errmsg("typed tables cannot inherit")));
+       systable_endscan(scan);
+       heap_close(inheritsRelation, AccessShareLock);
+
+       /*
+        * Check the tuple descriptors for compatibility.  Unlike inheritance, we
+        * require that the order also match.  However, attnotnull need not match.
+        * Also unlike inheritance, we do not require matching relhasoids.
+        */
+       typeTupleDesc = lookup_rowtype_tupdesc(typeid, -1);
+       tableTupleDesc = RelationGetDescr(rel);
+       table_attno = 1;
+       for (type_attno = 1; type_attno <= typeTupleDesc->natts; type_attno++)
+       {
+               Form_pg_attribute type_attr,
+                                       table_attr;
+               const char *type_attname,
+                                  *table_attname;
+
+               /* Get the next non-dropped type attribute. */
+               type_attr = typeTupleDesc->attrs[type_attno - 1];
+               if (type_attr->attisdropped)
+                       continue;
+               type_attname = NameStr(type_attr->attname);
+
+               /* Get the next non-dropped table attribute. */
+               do
+               {
+                       if (table_attno > tableTupleDesc->natts)
+                               ereport(ERROR,
+                                               (errcode(ERRCODE_DATATYPE_MISMATCH),
+                                                errmsg("table is missing column \"%s\"",
+                                                               type_attname)));
+                       table_attr = tableTupleDesc->attrs[table_attno++ - 1];
+               } while (table_attr->attisdropped);
+               table_attname = NameStr(table_attr->attname);
+
+               /* Compare name. */
+               if (strncmp(table_attname, type_attname, NAMEDATALEN) != 0)
+                       ereport(ERROR,
+                                       (errcode(ERRCODE_DATATYPE_MISMATCH),
+                                        errmsg("table has column \"%s\" where type requires \"%s\"",
+                                                       table_attname, type_attname)));
+
+               /* Compare type. */
+               if (table_attr->atttypid != type_attr->atttypid ||
+                       table_attr->atttypmod != type_attr->atttypmod ||
+                       table_attr->attcollation != type_attr->attcollation)
+                       ereport(ERROR,
+                                       (errcode(ERRCODE_DATATYPE_MISMATCH),
+                                        errmsg("table \"%s\" has different type for column \"%s\"",
+                                                       RelationGetRelationName(rel), type_attname)));
+       }
+       DecrTupleDescRefCount(typeTupleDesc);
+
+       /* Any remaining columns at the end of the table had better be dropped. */
+       for (; table_attno <= tableTupleDesc->natts; table_attno++)
+       {
+               Form_pg_attribute table_attr = tableTupleDesc->attrs[table_attno - 1];
+               if (!table_attr->attisdropped)
+                       ereport(ERROR,
+                                       (errcode(ERRCODE_DATATYPE_MISMATCH),
+                                        errmsg("table has extra column \"%s\"",
+                                                       NameStr(table_attr->attname))));
+       }
+
+       /* If the table was already typed, drop the existing dependency. */
+       if (rel->rd_rel->reloftype)
+               drop_parent_dependency(relid, TypeRelationId, rel->rd_rel->reloftype);
+
+       /* Record a dependency on the new type. */
+       tableobj.classId = RelationRelationId;
+       tableobj.objectId = relid;
+       tableobj.objectSubId = 0;
+       typeobj.classId = TypeRelationId;
+       typeobj.objectId = typeid;
+       typeobj.objectSubId = 0;
+       recordDependencyOn(&tableobj, &typeobj, DEPENDENCY_NORMAL);
+
+       /* Update pg_class.reloftype */
+       relationRelation = heap_open(RelationRelationId, RowExclusiveLock);
+       classtuple = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+       if (!HeapTupleIsValid(classtuple))
+               elog(ERROR, "cache lookup failed for relation %u", relid);
+       ((Form_pg_class) GETSTRUCT(classtuple))->reloftype = typeid;
+       simple_heap_update(relationRelation, &classtuple->t_self, classtuple);
+       CatalogUpdateIndexes(relationRelation, classtuple);
+       heap_freetuple(classtuple);
+       heap_close(relationRelation, RowExclusiveLock);
+
+       ReleaseSysCache(typetuple);
+}
+
+/*
+ * ALTER TABLE NOT OF
+ *
+ * Detach a typed table from its originating type.  Just clear reloftype and
+ * remove the dependency.
+ */
+static void
+ATExecDropOf(Relation rel, LOCKMODE lockmode)
+{
+       Oid                     relid = RelationGetRelid(rel);
+       Relation        relationRelation;
+       HeapTuple       tuple;
+
+       if (!OidIsValid(rel->rd_rel->reloftype))
+               ereport(ERROR,
+                               (errcode(ERRCODE_WRONG_OBJECT_TYPE),
+                                errmsg("\"%s\" is not a typed table",
+                                               RelationGetRelationName(rel))));
+
+       /*
+        * We don't bother to check ownership of the type --- ownership of the table
+        * is presumed enough rights.  No lock required on the type, either.
+        */
+
+       drop_parent_dependency(relid, TypeRelationId, rel->rd_rel->reloftype);
+
+       /* Clear pg_class.reloftype */
+       relationRelation = heap_open(RelationRelationId, RowExclusiveLock);
+       tuple = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+       if (!HeapTupleIsValid(tuple))
+               elog(ERROR, "cache lookup failed for relation %u", relid);
+       ((Form_pg_class) GETSTRUCT(tuple))->reloftype = InvalidOid;
+       simple_heap_update(relationRelation, &tuple->t_self, tuple);
+       CatalogUpdateIndexes(relationRelation, tuple);
+       heap_freetuple(tuple);
+       heap_close(relationRelation, RowExclusiveLock);
 }
 
 /*

diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index a22ab66ae5936c352686713ebb6c564872589576..1e4f8f698b368d09df07afc32d6e996a3e1fc876 100644 (file)
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -1933,6 +1933,23 @@ alter_table_cmd:
                                        n->def = (Node *) $3;
                                        $$ = (Node *)n;
                                }
+                       /* ALTER TABLE <name> OF <type_name> */
+                       | OF any_name
+                               {
+                                       AlterTableCmd *n = makeNode(AlterTableCmd);
+                                       TypeName *def = makeTypeNameFromNameList($2);
+                                       def->location = @2;
+                                       n->subtype = AT_AddOf;
+                                       n->def = (Node *) def;
+                                       $$ = (Node *)n;
+                               }
+                       /* ALTER TABLE <name> NOT OF */
+                       | NOT OF
+                               {
+                                       AlterTableCmd *n = makeNode(AlterTableCmd);
+                                       n->subtype = AT_DropOf;
+                                       $$ = (Node *)n;
+                               }
                        /* ALTER TABLE <name> OWNER TO RoleId */
                        | OWNER TO RoleId
                                {

diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index 4f1bb34dae0a995aaf9524a55c67bb4ccebb6d21..0078814905d12ed8638af2d39d18274dba3edbba 100644 (file)
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -825,35 +825,15 @@ transformOfType(CreateStmtContext *cxt, TypeName *ofTypename)
        TupleDesc       tupdesc;
        int                     i;
        Oid                     ofTypeId;
-       bool            typeOk = false;
 
        AssertArg(ofTypename);
 
        tuple = typenameType(NULL, ofTypename, NULL);
+       check_of_type(tuple);
        typ = (Form_pg_type) GETSTRUCT(tuple);
        ofTypeId = HeapTupleGetOid(tuple);
        ofTypename->typeOid = ofTypeId;         /* cached for later */
 
-       if (typ->typtype == TYPTYPE_COMPOSITE)
-       {
-               Relation        typeRelation;
-
-               Assert(OidIsValid(typ->typrelid));
-               typeRelation = relation_open(typ->typrelid, AccessShareLock);
-               typeOk = (typeRelation->rd_rel->relkind == RELKIND_COMPOSITE_TYPE);
-               /*
-                * Close the parent rel, but keep our AccessShareLock on it until xact
-                * commit.      That will prevent someone else from deleting or ALTERing
-                * the type before the typed table creation commits.
-                */
-               relation_close(typeRelation, NoLock);
-       }
-       if (!typeOk)
-               ereport(ERROR,
-                               (errcode(ERRCODE_WRONG_OBJECT_TYPE),
-                                errmsg("type %s is not a composite type",
-                                               format_type_be(ofTypeId))));
-
        tupdesc = lookup_rowtype_tupdesc(ofTypeId, -1);
        for (i = 0; i < tupdesc->natts; i++)
        {

diff --git a/src/include/commands/tablecmds.h b/src/include/commands/tablecmds.h
index d4383525db485f33d24f550020ddcdff981ebdd4..3f971eb218f770b4da689bbb4d1d5b6e25fd4bd8 100644 (file)
--- a/src/include/commands/tablecmds.h
+++ b/src/include/commands/tablecmds.h
@@ -56,6 +56,8 @@ extern void find_composite_type_dependencies(Oid typeOid,
                                                                 Relation origRelation,
                                                                 const char *origTypeName);
 
+extern void check_of_type(HeapTuple typetuple);
+
 extern AttrNumber *varattnos_map(TupleDesc olddesc, TupleDesc newdesc);
 extern AttrNumber *varattnos_map_schema(TupleDesc old, List *schema);
 extern void change_varattnos_of_a_node(Node *node, const AttrNumber *newattno);

diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index c6337cfb8794e08fedab43489f1232398c840d0d..24b4f7233395055443ce52e68e37d770d234b360 100644 (file)
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -1219,6 +1219,8 @@ typedef enum AlterTableType
        AT_DisableRule,                         /* DISABLE RULE name */
        AT_AddInherit,                          /* INHERIT parent */
        AT_DropInherit,                         /* NO INHERIT parent */
+       AT_AddOf,                                       /* OF <type_name> */
+       AT_DropOf,                                      /* NOT OF */
        AT_GenericOptions,                      /* OPTIONS (...) */
 } AlterTableType;
 

diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out
index 5b1223be6a9c5a447e99f4c13c7da8dca57e6679..8344d8542fa768b632d01fb1525831c85c7c34e7 100644 (file)
--- a/src/test/regress/expected/alter_table.out
+++ b/src/test/regress/expected/alter_table.out
@@ -1942,3 +1942,41 @@ Typed table of type: test_type2
 
 CREATE TYPE test_type_empty AS ();
 DROP TYPE test_type_empty;
+--
+-- typed tables: OF / NOT OF
+--
+CREATE TYPE tt_t0 AS (z inet, x int, y numeric(8,2));
+ALTER TYPE tt_t0 DROP ATTRIBUTE z;
+CREATE TABLE tt0 (x int NOT NULL, y numeric(8,2));     -- OK
+CREATE TABLE tt1 (x int, y bigint);                                    -- wrong base type
+CREATE TABLE tt2 (x int, y numeric(9,2));                      -- wrong typmod
+CREATE TABLE tt3 (y numeric(8,2), x int);                      -- wrong column order
+CREATE TABLE tt4 (x int);                                                      -- too few columns
+CREATE TABLE tt5 (x int, y numeric(8,2), z int);       -- too few columns
+CREATE TABLE tt6 () INHERITS (tt0);                                    -- can't have a parent
+CREATE TABLE tt7 (x int, q text, y numeric(8,2)) WITH OIDS;
+ALTER TABLE tt7 DROP q;                                                                -- OK
+ALTER TABLE tt0 OF tt_t0;
+ALTER TABLE tt1 OF tt_t0;
+ERROR:  table "tt1" has different type for column "y"
+ALTER TABLE tt2 OF tt_t0;
+ERROR:  table "tt2" has different type for column "y"
+ALTER TABLE tt3 OF tt_t0;
+ERROR:  table has column "y" where type requires "x"
+ALTER TABLE tt4 OF tt_t0;
+ERROR:  table is missing column "y"
+ALTER TABLE tt5 OF tt_t0;
+ERROR:  table has extra column "z"
+ALTER TABLE tt6 OF tt_t0;
+ERROR:  typed tables cannot inherit
+ALTER TABLE tt7 OF tt_t0;
+CREATE TYPE tt_t1 AS (x int, y numeric(8,2));
+ALTER TABLE tt7 OF tt_t1;                      -- reassign an already-typed table
+ALTER TABLE tt7 NOT OF;
+\d tt7
+        Table "public.tt7"
+ Column |     Type     | Modifiers 
+--------+--------------+-----------
+ x      | integer      | 
+ y      | numeric(8,2) | 
+

diff --git a/src/test/regress/sql/alter_table.sql b/src/test/regress/sql/alter_table.sql
index 43a9ce971f6e31f76a1f389c2f1173ebd418a53d..25fa7d562c597699e0243164a057512e59cf02a7 100644 (file)
--- a/src/test/regress/sql/alter_table.sql
+++ b/src/test/regress/sql/alter_table.sql
@@ -1369,3 +1369,33 @@ ALTER TYPE test_type2 RENAME ATTRIBUTE a TO aa CASCADE;
 
 CREATE TYPE test_type_empty AS ();
 DROP TYPE test_type_empty;
+
+--
+-- typed tables: OF / NOT OF
+--
+
+CREATE TYPE tt_t0 AS (z inet, x int, y numeric(8,2));
+ALTER TYPE tt_t0 DROP ATTRIBUTE z;
+CREATE TABLE tt0 (x int NOT NULL, y numeric(8,2));     -- OK
+CREATE TABLE tt1 (x int, y bigint);                                    -- wrong base type
+CREATE TABLE tt2 (x int, y numeric(9,2));                      -- wrong typmod
+CREATE TABLE tt3 (y numeric(8,2), x int);                      -- wrong column order
+CREATE TABLE tt4 (x int);                                                      -- too few columns
+CREATE TABLE tt5 (x int, y numeric(8,2), z int);       -- too few columns
+CREATE TABLE tt6 () INHERITS (tt0);                                    -- can't have a parent
+CREATE TABLE tt7 (x int, q text, y numeric(8,2)) WITH OIDS;
+ALTER TABLE tt7 DROP q;                                                                -- OK
+
+ALTER TABLE tt0 OF tt_t0;
+ALTER TABLE tt1 OF tt_t0;
+ALTER TABLE tt2 OF tt_t0;
+ALTER TABLE tt3 OF tt_t0;
+ALTER TABLE tt4 OF tt_t0;
+ALTER TABLE tt5 OF tt_t0;
+ALTER TABLE tt6 OF tt_t0;
+ALTER TABLE tt7 OF tt_t0;
+
+CREATE TYPE tt_t1 AS (x int, y numeric(8,2));
+ALTER TABLE tt7 OF tt_t1;                      -- reassign an already-typed table
+ALTER TABLE tt7 NOT OF;
+\d tt7