Re: ALTER OBJECT SET SCHEMA - Mailing list pgsql-patches

Here is an updated version of your patch.  Would you supply SGML
documentation updates to match the code changes?  Thanks.

---------------------------------------------------------------------------

Bernd Helmle wrote:
> Here's my current patch for ALTER OBJECT SET SCHEMA: the attached patch
> file implements
> schema "move" for FUNCTION, SEQUENCE, TYPE, DOMAIN and TABLE with all
> improvements discussed on -hackers recently. Altering OPERATOR, OPERATOR
> CLASS, AGGREGATE and CONVERSION are currently not implemented (since i ran
> out of time) :(
>
> Supported syntax is
>
> ALTER TABLE name SET SCHEMA name;
> ALTER SEQUENCE name SET SCHEMA name;
> ALTER FUNCTION name SET SCHEMA name;
> ALTER TYPE name SET SCHEMA name;
> ALTER DOMAIN name SET SCHEMA name;
>
> TIA
>
> --
>   Bernd

[ Attachment, skipping... ]

>
> ---------------------------(end of broadcast)---------------------------
> TIP 5: Have you checked our extensive FAQ?
>
>                http://www.postgresql.org/docs/faq

--
  Bruce Momjian                        |  http://candle.pha.pa.us
  pgman@candle.pha.pa.us               |  (610) 359-1001
  +  If your life is a hard drive,     |  13 Roberts Road
  +  Christ can be your backup.        |  Newtown Square, Pennsylvania 19073
Index: src/backend/catalog/pg_depend.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/catalog/pg_depend.c,v
retrieving revision 1.13
diff -c -c -r1.13 pg_depend.c
*** src/backend/catalog/pg_depend.c    14 Apr 2005 20:03:23 -0000    1.13
--- src/backend/catalog/pg_depend.c    29 Jul 2005 03:11:17 -0000
***************
*** 211,213 ****
--- 211,273 ----

      return ret;
  }
+
+ bool
+ changeDependencyFor(Oid classId, Oid objectId, Oid oldrefobjectId,
+                     Oid newrefobjectId)
+ {
+     ScanKeyData key[2];
+     SysScanDesc scan;
+     HeapTuple    tup;
+     Relation    depRel;
+     bool        result = false; /* nothing changed */
+
+     Assert(OidIsValid(classId) && OidIsValid(objectId) &&
+            OidIsValid(oldrefobjectId) && OidIsValid(newrefobjectId));
+
+     depRel = heap_open(DependRelationId, RowExclusiveLock);
+
+     ScanKeyInit(&key[0], Anum_pg_depend_classid, BTEqualStrategyNumber, F_OIDEQ,
+                 ObjectIdGetDatum(classId));
+     ScanKeyInit(&key[1], Anum_pg_depend_objid, BTEqualStrategyNumber, F_OIDEQ,
+                 ObjectIdGetDatum(objectId));
+
+     scan = systable_beginscan(depRel, DependDependerIndexId, true,
+                   SnapshotNow, 2, key);
+
+     while (HeapTupleIsValid((tup = systable_getnext(scan))))
+     {
+         Form_pg_depend depend_class = (Form_pg_depend) GETSTRUCT(tup);
+
+         if (depend_class->refobjid == oldrefobjectId)
+         {
+             ObjectAddress objAddr;
+
+             objAddr.classId = classId;
+             objAddr.objectId = oldrefobjectId;
+             objAddr.objectSubId = 0;
+
+             if (isObjectPinned(&objAddr, depRel))
+                 elog(ERROR, "attempt to change dependency on a system object!");
+
+             tup = heap_copytuple(tup);
+             depend_class = (Form_pg_depend) GETSTRUCT(tup);
+
+             depend_class->refobjid = newrefobjectId;
+             simple_heap_update(depRel, &tup->t_self, tup);
+             CatalogUpdateIndexes(depRel, tup);
+
+             /*
+              * Assume that the specified object/classId couldn't reference the
+              * changed object twice, so exit the loop immediately.
+              */
+             result = true;
+             break;
+         }
+     }
+
+     systable_endscan(scan);
+     heap_close(depRel, RowExclusiveLock);
+
+     return result;
+ }
Index: src/backend/commands/alter.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/commands/alter.c,v
retrieving revision 1.13
diff -c -c -r1.13 alter.c
*** src/backend/commands/alter.c    28 Jun 2005 05:08:53 -0000    1.13
--- src/backend/commands/alter.c    29 Jul 2005 03:11:17 -0000
***************
*** 38,43 ****
--- 38,75 ----


  /*
+  * Executes an ALTER OBJECT / SET SCHEMA statement
+  */
+ void
+ ExecRenameObjSchemaStmt(RenameObjSchemaStmt *stmt)
+ {
+     Oid relid;
+
+     switch (stmt->renameType)
+     {
+         case OBJECT_TYPE:
+         case OBJECT_DOMAIN:
+             AlterDomainNamespace(stmt->object, stmt->newname);
+             break;
+
+         case OBJECT_FUNCTION:
+             AlterFunctionNamespace(stmt->object, stmt->objarg, stmt->newname);
+             break;
+
+         case OBJECT_SEQUENCE:
+         case OBJECT_TABLE:
+             CheckRelationOwnership(stmt->relation, true);
+             relid = RangeVarGetRelid(stmt->relation, false);
+             AlterTableNamespace(relid, stmt->newname);
+             break;
+
+         default:
+             elog(ERROR, "unrecognized rename schema stmt type: %d",
+                  (int) stmt->renameType);
+     }
+ }
+
+ /*
   * Executes an ALTER OBJECT / RENAME TO statement.    Based on the object
   * type, the function appropriate to that type is executed.
   */
Index: src/backend/commands/functioncmds.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/commands/functioncmds.c,v
retrieving revision 1.64
diff -c -c -r1.64 functioncmds.c
*** src/backend/commands/functioncmds.c    14 Jul 2005 21:46:29 -0000    1.64
--- src/backend/commands/functioncmds.c    29 Jul 2005 03:11:18 -0000
***************
*** 1427,1429 ****
--- 1427,1493 ----
      systable_endscan(scan);
      heap_close(relation, RowExclusiveLock);
  }
+
+ void
+ AlterFunctionNamespace(List *name, List *argtypes, const char *newnpname)
+ {
+     Oid             procOid;
+     Oid             oldnpOid;
+     Oid             newnpOid;
+     HeapTuple        tup;
+     HeapTuple        nptup;
+     Relation        rel;
+     Form_pg_proc        proc;
+     AclResult        aclrc;
+
+     Assert(newnpname != NULL && name != NIL);
+
+     rel = heap_open(ProcedureRelationId, RowExclusiveLock);
+     procOid = LookupFuncNameTypeNames(name, argtypes, false);
+
+     tup = SearchSysCacheCopy(PROCOID, ObjectIdGetDatum(procOid), 0, 0, 0);
+
+     if (!HeapTupleIsValid(tup))
+         elog(ERROR, "cache lookup failed for function %u", procOid);
+
+     nptup = SearchSysCacheCopy(NAMESPACENAME, CStringGetDatum(newnpname),
+                 0, 0, 0);
+     if (!HeapTupleIsValid(nptup))
+         ereport(ERROR,
+              (errcode(ERRCODE_UNDEFINED_SCHEMA),
+               errmsg("schema \"%s\" doesn't exists", newnpname)));
+
+     newnpOid = HeapTupleGetOid(nptup);
+     if ((aclrc = pg_namespace_aclcheck(newnpOid, GetUserId(), ACL_CREATE))
+             != ACLCHECK_OK)
+         aclcheck_error(aclrc, ACL_KIND_NAMESPACE, newnpname);
+
+     proc = (Form_pg_proc) GETSTRUCT(tup);
+     oldnpOid = proc->pronamespace;
+
+     if ((aclrc = pg_namespace_aclcheck(oldnpOid, GetUserId(), ACL_CREATE))
+             != ACLCHECK_OK)
+         aclcheck_error(aclrc, ACL_KIND_NAMESPACE, get_namespace_name(oldnpOid));
+
+     if (!pg_proc_ownercheck(HeapTupleGetOid(tup), GetUserId()))
+         aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_PROC, NameListToString(name));
+
+     if (SearchSysCacheExists(PROCNAMEARGSNSP,
+         CStringGetDatum(NameStr(proc->proname)),
+         PointerGetDatum(&proc->proargtypes), ObjectIdGetDatum(newnpOid), 0))
+         ereport(ERROR,
+              (errcode(ERRCODE_DUPLICATE_FUNCTION),
+               errmsg("function \"%s\" already exists in schema \"%s\"",
+                  NameStr(proc->proname), get_namespace_name(newnpOid))));
+
+     proc->pronamespace = newnpOid;
+     simple_heap_update(rel, &tup->t_self, tup);
+
+     CatalogUpdateIndexes(rel, tup);
+
+     if (changeDependencyFor(ProcedureRelationId, procOid, oldnpOid, newnpOid))
+         elog(NOTICE, "changed dependency to new schema \"%s\"", newnpname);
+
+     heap_freetuple(tup);
+     heap_close(rel, RowExclusiveLock);
+ }
Index: src/backend/commands/tablecmds.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/commands/tablecmds.c,v
retrieving revision 1.164
diff -c -c -r1.164 tablecmds.c
*** src/backend/commands/tablecmds.c    14 Jul 2005 21:46:29 -0000    1.164
--- src/backend/commands/tablecmds.c    29 Jul 2005 03:11:22 -0000
***************
*** 15,20 ****
--- 15,21 ----
  #include "postgres.h"

  #include "access/genam.h"
+ #include "access/heapam.h"
  #include "access/tuptoaster.h"
  #include "catalog/catalog.h"
  #include "catalog/dependency.h"
***************
*** 22,27 ****
--- 23,29 ----
  #include "catalog/index.h"
  #include "catalog/indexing.h"
  #include "catalog/namespace.h"
+ #include "catalog/pg_attrdef.h"
  #include "catalog/pg_constraint.h"
  #include "catalog/pg_depend.h"
  #include "catalog/pg_inherits.h"
***************
*** 6198,6200 ****
--- 6200,6639 ----
          }
      }
  }
+
+ /*
+  * Rebuilds the default expression on a SERIAL column, identified
+  * by relid and attnum. The caller has to make sure, that attnum is really
+  * a SERIAL column, no further checks are done by
+  * RebuildSequenceDefaultExpr().
+  */
+ static void
+ RebuildSequenceDefaultExpr(Oid relid, AttrNumber attnum, char *seqname,
+                             char *nspname)
+ {
+     ScanKeyData keys[2];
+     SysScanDesc scan;
+     HeapTuple    tup;
+     bool        isnull;
+     Datum        value;
+     text        *adbin;
+     Expr        *expr;
+     char *quoted_name = palloc(strlen(nspname) + strlen(seqname) + 2 /* dot */);
+     /*
+      * Open the table we need to check for default expressions. Please
+      * note that we don't need to acquire a lock here, since we assume any
+      * interface function (such as AlterTableNamespace()) have locked the
+      * relation already.
+      */
+     Relation table_relation = heap_open(relid, NoLock);
+     Relation attr_default_rel = heap_open(AttrDefaultRelationId, RowExclusiveLock);
+
+     TupleDesc attrDesc = table_relation->rd_att;
+
+     MemSet(quoted_name, 0, strlen(nspname) + strlen(seqname) + 2);
+     strncpy(quoted_name, nspname, strlen(nspname));
+     strncat(quoted_name, ".", 1);
+     strncat(quoted_name, seqname, strlen(seqname));
+
+     /*
+      * Check that there is really a default expressions. Since we assume we are
+      * called from AlterSeqNamespacesForRel() there *must* be a default
+      * expression that calls nextval()...
+      */
+     if (!attrDesc->constr && attrDesc->constr->num_defval > 0)
+         elog(ERROR, "expected column defaults, but table %u has none defined",
+               relid);
+
+     ScanKeyInit(&keys[0], Anum_pg_attrdef_adrelid, BTEqualStrategyNumber, F_OIDEQ,
+                 ObjectIdGetDatum(relid));
+     ScanKeyInit(&keys[1], Anum_pg_attrdef_adnum, BTEqualStrategyNumber, F_INT2EQ,
+                 Int16GetDatum(attnum));
+
+     scan = systable_beginscan(attr_default_rel, AttrDefaultIndexId, true,
+                                SnapshotNow, 2, keys);
+     if (!HeapTupleIsValid(tup = systable_getnext(scan)))
+         elog(ERROR, "could not found pg_attrdef attribute for column %d",
+               attnum + 1);
+
+     isnull = false;
+     value = heap_getattr(tup, Anum_pg_attrdef_adbin,
+                          RelationGetDescr(attr_default_rel), &isnull);
+     if (isnull)
+         elog(ERROR, "null value in adbin default expression for column %d",
+               attnum + 1);
+
+     adbin = DatumGetTextP(value);
+
+     /* Get executable expression node */
+
+     expr = stringToNode(VARDATA(adbin));
+
+     if IsA(expr, FuncExpr)
+     {
+         FuncExpr        *func;
+         Const            *cval;
+         Expr             *arg_expr;
+
+         func = (FuncExpr *) expr;
+         arg_expr = linitial(func->args);
+         if IsA(arg_expr, FuncExpr)
+         {
+             Expr         *const_expr;
+             Datum         values[ Natts_pg_attrdef ];
+             char         replaces[ Natts_pg_attrdef ];
+             char         nulls[4] = { ' ', ' ', ' ', ' ' };
+             char         *func_expr_str;
+             char         *adsrc;
+             HeapTuple     newtup;
+
+             func = (FuncExpr *)arg_expr;
+             const_expr = linitial(func->args);
+
+             if IsA(const_expr, Const)
+             {
+                 /* modify argument to nextval() */
+                 func->args = list_delete_first(func->args);
+                 cval = makeNode(Const);
+                 cval->consttype = ((Const *)const_expr)->consttype;
+                 cval->constlen    = ((Const *)const_expr)->constlen;
+                 cval->constisnull = ((Const *)const_expr)->constisnull;
+                 cval->constbyval  = ((Const *)const_expr)->constbyval;
+                 cval->constvalue = PointerGetDatum(DirectFunctionCall1(textin,
+                                                    CStringGetDatum(quoted_name)));
+                 func->args = lappend(func->args, cval);
+
+                 /* update expressions in pg_attrdef */
+                 func_expr_str = nodeToString(expr);
+                 values[ Anum_pg_attrdef_adbin - 1 ] = DirectFunctionCall1(textin,
+                                                    CStringGetDatum(func_expr_str));
+                 adsrc = deparse_expression((Node *)expr, deparse_context_for(
+                                     RelationGetRelationName(table_relation), relid),
+                                     false, false);
+                 values[ Anum_pg_attrdef_adsrc - 1 ] = DirectFunctionCall1(textin,
+                                                            CStringGetDatum(adsrc));
+                 MemSet(replaces, ' ', sizeof(replaces));
+                 replaces[ Anum_pg_attrdef_adbin - 1 ] = 'r';
+                 replaces[ Anum_pg_attrdef_adsrc - 1 ] = 'r';
+                 newtup = heap_modifytuple(tup, attr_default_rel->rd_att,
+                                            values, nulls, replaces);
+                 simple_heap_update(attr_default_rel, &newtup->t_self, newtup);
+                 CatalogUpdateIndexes(attr_default_rel, newtup);
+             }
+         }
+     }
+
+     systable_endscan(scan);
+     heap_close(table_relation, NoLock);
+     heap_close(attr_default_rel, RowExclusiveLock);
+ }
+
+ /*
+  * Moves all sequences, based on a SERIAL column type of the
+  * specified relation to a new schema. Please note that we only move
+  * sequences to the new schema, that have tracked dependencies in
+  * pg_depend, because only those could be created via a SERIAL
+  * column type.
+  */
+ static void
+ AlterSeqNamespacesForTable (Oid relOid,
+                  Oid newnspOid)
+ {
+     Relation         dependRel;
+     Relation         classRel;
+     HeapTuple         depTup;
+     ScanKeyData        key[2];
+     SysScanDesc        scan;
+
+     Assert(OidIsValid(relOid) && OidIsValid(newnspOid));
+
+     /* Open pg_depend and grab a row share lock. */
+     dependRel = heap_open(DependRelationId, RowShareLock);
+
+     ScanKeyInit(&key[0], Anum_pg_depend_refclassid, BTEqualStrategyNumber, F_OIDEQ,
+                 ObjectIdGetDatum(RelationRelationId));
+
+     ScanKeyInit(&key[1], Anum_pg_depend_refobjid, BTEqualStrategyNumber, F_OIDEQ,
+                 ObjectIdGetDatum(relOid));
+
+     scan = systable_beginscan(dependRel, DependReferenceIndexId, true,
+                                 SnapshotNow, 2, key);
+
+     classRel = heap_open(RelationRelationId, RowExclusiveLock);
+
+     while (HeapTupleIsValid((depTup = systable_getnext(scan))))
+     {
+         /*
+          * The dependent object is examined wether it is a attached sequence
+          * or not. If true, we need to pull out the pg_class tuple of
+          * the dependent sequence and modify the relnamespace to reflect
+          * the new table schema.
+          */
+         Form_pg_depend        dependent = (Form_pg_depend) GETSTRUCT(depTup);
+         Form_pg_class        myclass;
+         HeapTuple               seqTup;
+
+         seqTup = SearchSysCacheCopy(RELOID, ObjectIdGetDatum(dependent->objid),
+                                     0, 0, 0);
+         if (!HeapTupleIsValid(seqTup))
+             /*
+              *    Don't stop on a cache lookup failure, since this
+              *    only means that the dependent object is _not_ in pg_class
+              */
+             continue;
+
+         myclass = (Form_pg_class) GETSTRUCT(seqTup);
+
+         if (myclass->relkind == RELKIND_SEQUENCE)
+         {
+             TypeName        *seqName;
+             Relation         seqRel;
+             char             *nspname = get_namespace_name(newnspOid);
+
+             myclass->relnamespace = newnspOid;
+
+             elog(DEBUG1, "moving sequence OID %u to new schema OID %u",
+                  HeapTupleGetOid(seqTup), newnspOid);
+
+             simple_heap_update(classRel, &seqTup->t_self, seqTup);
+             CatalogUpdateIndexes(classRel, seqTup);
+
+             /*
+              * Sequences have entries in pg_type. We need to be careful
+              * to move them to the new namespace, too.
+              */
+             seqName = makeNode(TypeName);
+             seqName->names = NIL;
+             seqName->typeid = myclass->reltype;
+             seqName->typmod = -1;
+             seqName->arrayBounds = NIL;
+
+             seqRel = heap_open(TypeRelationId, RowExclusiveLock);
+             AlterTypeNamespace(myclass->reltype, seqRel, nspname, seqName, false);
+             heap_close(seqRel, RowExclusiveLock);
+
+             /*
+              * At least we need to rebuild all column default expressions that
+              * rely on this sequence.
+              */
+             if (dependent->refobjsubid > 0)
+             {
+                 AttrNumber attnum = dependent->refobjsubid;
+                 RebuildSequenceDefaultExpr(relOid, attnum,
+                                           NameStr(myclass->relname), nspname);
+             }
+         }
+     }
+
+     systable_endscan(scan);
+     heap_close(classRel, RowExclusiveLock);
+     heap_close(dependRel, RowShareLock);
+
+ }
+
+ /*
+  * Moves all constraints for the specified relation to another
+  * namespace, specified by newnspOid. The function supports 'moving'
+  * constraints that are defined on tables and domains. Other relkinds
+  * causes the function to trap an error.
+  *
+  * NOTE: AlterConstraintNamespacesForRel() doesn't check itself for
+  * access permissions, this should be done by the caller.
+  */
+ void
+ AlterConstraintNamespacesForRel(Oid relOid, Oid newnspOid, const char relkind)
+ {
+
+     Relation        conRel;
+     HeapTuple         tup;
+     SysScanDesc     scan = NULL;
+     ScanKeyData     key[1];
+
+     Assert(OidIsValid(relOid) && OidIsValid(newnspOid));
+
+     conRel = heap_open(ConstraintRelationId, RowExclusiveLock);
+
+     /* Initialize index scan */
+     switch (relkind)
+     {
+         case RELKIND_RELATION:
+             ScanKeyInit(&key[0], Anum_pg_constraint_conrelid,
+                         BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(relOid));
+             scan = systable_beginscan(conRel, ConstraintRelidIndexId, true,
+                            SnapshotNow, 1, key);
+             break;
+
+         case RELKIND_COMPOSITE_TYPE:
+             ScanKeyInit(&key[0], Anum_pg_constraint_contypid,
+                         BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(relOid));
+             scan = systable_beginscan(conRel, ConstraintTypidIndexId, true,
+                            SnapshotNow, 1, key);
+             break;
+
+         default:
+             elog(ERROR, "altering constraint namespace only supported for tables and types");
+             break;
+     }
+
+     while(HeapTupleIsValid((tup = systable_getnext(scan))))
+     {
+         Form_pg_constraint     constraint;
+         HeapTuple             newtuple = NULL;
+
+         newtuple = heap_copytuple(tup);
+         constraint = (Form_pg_constraint) GETSTRUCT(newtuple);
+         constraint->connamespace = newnspOid;
+
+         simple_heap_update(conRel, &newtuple->t_self, newtuple);
+         CatalogUpdateIndexes(conRel, newtuple);
+     }
+
+     systable_endscan(scan);
+     heap_close(conRel, RowExclusiveLock);
+ }
+
+ /*
+  * Moves all indexes for the specified relation to another namespace.
+  *
+  * NOTE: AlterIndexNamespacesForTable() assumes that the caller checks wether
+  * there are enough permissions on the source and target namespace and
+  * locks to "move" the index to the new namespace. This is should be
+  * no problem, since this function is intended to be a small helper function to
+  * AlterTableNamespace() only. That's also the reason why it lives here.
+  */
+ static void
+ AlterIndexNamespacesForTable(Oid relOid, Oid newnspOid)
+ {
+     Relation            indexRel;
+     Relation            classRel;
+     HeapTuple            tup;
+     ScanKeyData            key[1];
+     SysScanDesc            scan;
+
+     Assert(OidIsValid(relOid) && OidIsValid(newnspOid));
+
+     indexRel = heap_open(IndexRelationId, RowShareLock);
+
+     classRel = heap_open(RelationRelationId, RowExclusiveLock);
+
+     ScanKeyInit(&key[0], Anum_pg_index_indrelid, BTEqualStrategyNumber, F_OIDEQ,
+                 ObjectIdGetDatum(relOid));
+
+     scan = systable_beginscan(indexRel, IndexIndrelidIndexId, true, SnapshotNow, 1, key);
+
+     while (HeapTupleIsValid((tup = systable_getnext(scan))))
+     {
+         Form_pg_index        index = (Form_pg_index) GETSTRUCT(tup);
+         Form_pg_class        indexClass;
+         HeapTuple            classTup = NULL;
+
+         classTup = SearchSysCacheCopy(RELOID, ObjectIdGetDatum(index->indexrelid),
+                                          0, 0, 0);
+
+         if (!HeapTupleIsValid(classTup))
+             elog(ERROR, "cache lookup failed for index relation OID %u",
+                   index->indexrelid);
+
+         indexClass = (Form_pg_class) GETSTRUCT(classTup);
+         indexClass->relnamespace = newnspOid;
+
+         simple_heap_update(classRel, &classTup->t_self, classTup);
+         CatalogUpdateIndexes(classRel, classTup);
+     }
+
+     systable_endscan(scan);
+     heap_close(classRel, RowExclusiveLock);
+     heap_close(indexRel, RowShareLock);
+
+ }
+
+ /*
+  * Changes the namespace of the specified table
+  * Ownership of the specified relation (relid) should be checked
+  * by the caller.
+  */
+ void
+ AlterTableNamespace(Oid relid, const char *newnpname)
+ {
+     HeapTuple            tup;
+     Relation            rel;
+     Relation            relRel;
+     char                *relname;
+     Oid                oldnpOid;
+     Oid                newnpOid;
+     Relation            relType;
+     TypeName            *typename;
+     Form_pg_class        class;
+     AclResult            aclrc;
+
+     rel = relation_open(relid, AccessExclusiveLock);
+
+     tup = SearchSysCacheCopy(NAMESPACENAME, CStringGetDatum(newnpname),
+                              0, 0, 0);
+     if (!HeapTupleIsValid(tup))
+         ereport(ERROR,
+              (errcode(ERRCODE_UNDEFINED_SCHEMA),
+               errmsg("schema \"%s\" doesn't exists", newnpname)));
+
+     newnpOid = HeapTupleGetOid(tup);
+
+     if ((aclrc = pg_namespace_aclcheck(HeapTupleGetOid(tup), GetUserId(),
+         ACL_CREATE)) != ACLCHECK_OK)
+         aclcheck_error(aclrc, ACL_KIND_NAMESPACE, newnpname);
+
+     oldnpOid = get_rel_namespace(relid);
+
+     if ((aclrc = pg_namespace_aclcheck(oldnpOid, GetUserId(), ACL_CREATE))
+         != ACLCHECK_OK)
+         aclcheck_error(aclrc, ACL_KIND_NAMESPACE, get_namespace_name(oldnpOid));
+
+     if (oldnpOid == newnpOid)
+         elog(ERROR, "relation %u already in schema %s", relid, newnpname);
+
+     relname = get_rel_name(relid);
+     if (get_relname_relid(relname, newnpOid) != InvalidOid)
+         ereport(ERROR,
+             (errcode(ERRCODE_DUPLICATE_TABLE),
+               errmsg("relation \"%s\" already exists in schema \"%s\"",
+                      relname, newnpname)));
+
+     relRel = heap_open(RelationRelationId, RowExclusiveLock);
+
+     tup = SearchSysCacheCopy(RELOID, PointerGetDatum(relid), 0, 0, 0);
+
+     if (!HeapTupleIsValid(tup))
+         elog(ERROR, "cache lookup failed for relation %u", relid);
+
+     class = (Form_pg_class) GETSTRUCT(tup);
+     class->relnamespace = newnpOid;
+     simple_heap_update(relRel, &tup->t_self, tup);
+
+     relType = heap_open(TypeRelationId, RowExclusiveLock);
+
+     typename = makeNode(TypeName);
+     typename->names  = NIL;
+     typename->typeid = class->reltype;
+     typename->typmod = -1;
+     typename->arrayBounds = NIL;
+
+     AlterTypeNamespace(class->reltype, relType, newnpname, typename, false);
+
+     heap_close(relType, NoLock);
+
+     if (class->relkind == RELKIND_RELATION)
+     {
+         AlterIndexNamespacesForTable(relid, newnpOid);
+         AlterConstraintNamespacesForRel(relid, newnpOid, RELKIND_RELATION);
+         AlterSeqNamespacesForTable(relid, newnpOid);
+     }
+
+
+     if (changeDependencyFor(RelationRelationId, relid, oldnpOid, newnpOid))
+         elog(DEBUG1, "changed dependency to new schema \"%s\"", newnpname);
+
+     CatalogUpdateIndexes(relRel, tup);
+
+     heap_freetuple(tup);
+     heap_close(relRel, RowExclusiveLock);
+
+     relation_close(rel, NoLock);
+ }
Index: src/backend/commands/typecmds.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/commands/typecmds.c,v
retrieving revision 1.76
diff -c -c -r1.76 typecmds.c
*** src/backend/commands/typecmds.c    14 Jul 2005 21:46:29 -0000    1.76
--- src/backend/commands/typecmds.c    29 Jul 2005 03:11:24 -0000
***************
*** 2097,2102 ****
          changeDependencyOnOwner(TypeRelationId, typeOid, newOwnerId);
      }

-     /* Clean up */
      heap_close(rel, RowExclusiveLock);
  }
--- 2097,2262 ----
          changeDependencyOnOwner(TypeRelationId, typeOid, newOwnerId);
      }

      heap_close(rel, RowExclusiveLock);
  }
+
+ /*
+  * Apply new namespace to specified type. Assume TypeRelationId
+  * is already opened by the caller.
+  *
+  * Specifying errorOnTableType to TRUE causes the function
+  * to error out if an attempt to rename a table type namespace occurs.
+  * This is necessary, since we want users to use ALTER TABLE to rename
+  * the table type's namespace.
+  */
+ void
+ AlterTypeNamespace(Oid typeOid, Relation rel, const char *newnpname,
+             const TypeName *typename, const bool errorOnTableType)
+ {
+     HeapTuple            tup;
+     HeapTuple            nsptup;
+     Form_pg_type        mytype;
+     AclResult            aclrc;
+     Oid                    oldnpOid;
+     Oid                    relTypeOid;
+     Oid                    classId;
+
+     Assert(OidIsValid(typeOid) && typename != NULL && rel != NULL && newnpname != NULL);
+
+     tup = SearchSysCacheCopy(TYPEOID, ObjectIdGetDatum(typeOid), 0, 0, 0);
+
+     if (!HeapTupleIsValid(tup))
+         elog(ERROR, "cache lookup failed for type %u", typeOid);
+
+     mytype = (Form_pg_type) GETSTRUCT(tup);
+
+     if (!pg_type_ownercheck(typeOid, GetUserId()))
+         aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TYPE, TypeNameToString(typename));
+
+     if ((aclrc = pg_namespace_aclcheck(mytype->typnamespace, GetUserId(),
+             ACL_CREATE)) != ACLCHECK_OK)
+         aclcheck_error(aclrc, ACL_KIND_NAMESPACE, get_namespace_name(mytype->typnamespace));
+
+     nsptup = SearchSysCacheCopy(NAMESPACENAME, CStringGetDatum(newnpname), 0, 0, 0);
+
+     if (!HeapTupleIsValid(nsptup))
+         ereport(ERROR,
+              (errcode(ERRCODE_UNDEFINED_SCHEMA),
+               errmsg("schema \"%s\" doesn't exists", newnpname)));
+
+     if ((aclrc = pg_namespace_aclcheck(HeapTupleGetOid(nsptup), GetUserId(),
+                     ACL_CREATE)) != ACLCHECK_OK)
+         aclcheck_error(aclrc, ACL_KIND_NAMESPACE, newnpname);
+
+     /*
+      * if errorOnTableType is requested, we don't want to allow renaming
+      * the namespace of a table type. If such an attempt occurs, we error
+      * out....
+      */
+     if (mytype->typtype == RELKIND_COMPOSITE_TYPE && errorOnTableType &&
+         get_rel_relkind(mytype->typrelid) != RELKIND_COMPOSITE_TYPE)
+         ereport(ERROR,
+             (errcode(ERRCODE_WRONG_OBJECT_TYPE),
+              errmsg("\"%s\" is a table's row type",
+                 TypeNameToString(typename))));
+
+     if (mytype->typnamespace == HeapTupleGetOid(nsptup))
+         ereport(ERROR,
+             (errcode(ERRCODE_DUPLICATE_OBJECT),
+              errmsg("type \"%s\" already in schema \"%s\"",
+                 TypeNameToString(typename), newnpname)));
+
+     oldnpOid = mytype->typnamespace; /* save for dependency refactoring */
+     mytype->typnamespace = HeapTupleGetOid(nsptup);
+     simple_heap_update(rel, &tup->t_self, tup);
+
+     CatalogUpdateIndexes(rel, tup);
+
+     /*
+      * Composite types has pg_class entries.
+      * We need to modify the pg_class tuple as well to
+      * reflect the changes of its schema.
+      */
+     if (mytype->typtype == 'c' && get_rel_relkind(mytype->typrelid) == 'c')
+     {
+         Form_pg_class pg_class;
+         Relation  relClass = heap_open(RelationRelationId, RowExclusiveLock);
+         HeapTuple relTup   = SearchSysCacheCopy(RELOID,
+                                     ObjectIdGetDatum(mytype->typrelid), 0, 0, 0);
+
+         if (!HeapTupleIsValid(relTup))
+             elog(ERROR, "cache lookup for relation \"%s\" failed",
+               TypeNameToString(typename));
+
+         pg_class = (Form_pg_class) GETSTRUCT(relTup);
+         pg_class->relnamespace = HeapTupleGetOid(nsptup);
+
+         simple_heap_update(relClass, &relTup->t_self, relTup);
+         CatalogUpdateIndexes(relClass, relTup);
+
+         heap_close(relClass, RowExclusiveLock);
+         heap_freetuple(relTup);
+
+         relTypeOid = mytype->typrelid;
+         classId = RelationRelationId;
+     }
+     else
+     {
+         relTypeOid = typeOid;
+         classId = TypeRelationId;
+     }
+
+     if (changeDependencyFor(classId, relTypeOid, oldnpOid, HeapTupleGetOid(nsptup)))
+         elog(DEBUG1, "changed dependency to new schema \"%s\"", newnpname);
+
+     heap_freetuple(tup);
+     heap_freetuple(nsptup);
+ }
+
+ void
+ AlterDomainNamespace(List *names, const char *newnpname)
+ {
+     Oid                    typeOid;
+     Oid                    nspOid;
+     TypeName            *typename;
+     Relation            rel;
+     HeapTuple            nspTup;
+
+     Assert(names != NIL && newnpname != NULL);
+
+     /*
+      * As usual, create the type stuff so we can use
+      * standard type functions.
+      */
+
+     typename = makeNode(TypeName);
+     typename->names = names;
+     typename->typmod = -1;
+     typename->arrayBounds = NIL;
+
+     rel = heap_open(TypeRelationId, RowExclusiveLock);
+
+     /* get type OID */
+     typeOid = LookupTypeName(typename);
+
+     if (!OidIsValid(typeOid))
+         ereport(ERROR,
+             (errcode(ERRCODE_UNDEFINED_OBJECT),
+              errmsg("type \"%s\" does not exist",
+                 TypeNameToString(typename))));
+
+     AlterTypeNamespace(typeOid, rel, newnpname, typename, true);
+
+     nspTup = SearchSysCacheCopy(NAMESPACENAME, CStringGetDatum(newnpname), 0, 0, 0);
+
+     if (!HeapTupleIsValid(nspTup))
+         elog(ERROR, "cache lookup failure for schema %s", newnpname);
+
+     nspOid = HeapTupleGetOid(nspTup);
+
+     AlterConstraintNamespacesForRel(typeOid, nspOid, RELKIND_COMPOSITE_TYPE);
+
+     heap_close(rel, RowExclusiveLock);
+ }
+
+
Index: src/backend/parser/gram.y
===================================================================
RCS file: /cvsroot/pgsql/src/backend/parser/gram.y,v
retrieving revision 2.504
diff -c -c -r2.504 gram.y
*** src/backend/parser/gram.y    26 Jul 2005 22:37:50 -0000    2.504
--- src/backend/parser/gram.y    29 Jul 2005 03:11:27 -0000
***************
*** 132,138 ****

  %type <node>    stmt schema_stmt
          AlterDatabaseSetStmt AlterDomainStmt AlterGroupStmt AlterOwnerStmt
!         AlterSeqStmt AlterTableStmt AlterUserStmt AlterUserSetStmt
          AlterRoleStmt AlterRoleSetStmt
          AnalyzeStmt ClosePortalStmt ClusterStmt CommentStmt
          ConstraintsSetStmt CopyStmt CreateAsStmt CreateCastStmt
--- 132,138 ----

  %type <node>    stmt schema_stmt
          AlterDatabaseSetStmt AlterDomainStmt AlterGroupStmt AlterOwnerStmt
!         AlterSeqStmt AlterTableStmt AlterUserStmt AlterUserSetStmt AlterObjectSchemaStmt
          AlterRoleStmt AlterRoleSetStmt
          AnalyzeStmt ClosePortalStmt ClusterStmt CommentStmt
          ConstraintsSetStmt CopyStmt CreateAsStmt CreateCastStmt
***************
*** 487,492 ****
--- 487,493 ----

  stmt :
              AlterDatabaseSetStmt
+             | AlterObjectSchemaStmt
              | AlterDomainStmt
              | AlterFunctionStmt
              | AlterGroupStmt
***************
*** 3997,4002 ****
--- 3998,4060 ----
              | /*EMPTY*/                                { $$ = 0; }
          ;

+ /*****************************************************************************
+  *
+  * ALTER THING name SET SCHEMA name
+  *
+  *****************************************************************************/
+
+ AlterObjectSchemaStmt: ALTER TABLE relation_expr SET SCHEMA name
+                 {
+                     RenameObjSchemaStmt *n = makeNode(RenameObjSchemaStmt);
+                     n->renameType = OBJECT_TABLE;
+                     n->relation = $3;
+                     n->object = NIL;
+                     n->objarg = NIL;
+                     n->newname = $6;
+                     $$ = (Node *)n;
+                 }
+            | ALTER SEQUENCE relation_expr SET SCHEMA name
+                 {
+                     RenameObjSchemaStmt *n = makeNode(RenameObjSchemaStmt);
+                     n->renameType = OBJECT_SEQUENCE;
+                     n->relation = $3;
+                     n->object = NIL;
+                     n->objarg = NIL;
+                     n->newname = $6;
+                     $$ = (Node *)n;
+                 }
+            | ALTER FUNCTION func_name func_args SET SCHEMA name
+                {
+                     RenameObjSchemaStmt *n = makeNode(RenameObjSchemaStmt);
+                     n->renameType = OBJECT_FUNCTION;
+                     n->relation = NULL;
+                     n->object = $3;
+                     n->objarg = extractArgTypes($4);
+                     n->newname = $7;
+                     $$ = (Node *)n;
+                }
+            | ALTER DOMAIN_P any_name SET SCHEMA name
+                {
+                     RenameObjSchemaStmt *n = makeNode(RenameObjSchemaStmt);
+                     n->renameType = OBJECT_DOMAIN;
+                     n->relation = NULL;
+                     n->object = $3;
+                     n->objarg = NIL;
+                     n->newname = $6;
+                     $$ = (Node *)n;
+                 }
+            | ALTER TYPE_P any_name SET SCHEMA name
+                {
+                     RenameObjSchemaStmt *n = makeNode(RenameObjSchemaStmt);
+                     n->renameType = OBJECT_TYPE;
+                     n->relation = NULL;
+                     n->object = $3;
+                     n->objarg = NIL;
+                     n->newname = $6;
+                     $$ = (Node *)n;
+                }
+         ;

  /*****************************************************************************
   *
Index: src/backend/tcop/utility.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/tcop/utility.c,v
retrieving revision 1.241
diff -c -c -r1.241 utility.c
*** src/backend/tcop/utility.c    14 Jul 2005 05:13:41 -0000    1.241
--- src/backend/tcop/utility.c    29 Jul 2005 03:11:29 -0000
***************
*** 284,289 ****
--- 284,290 ----
          case T_AlterSeqStmt:
          case T_AlterTableStmt:
          case T_RenameStmt:
+         case T_RenameObjSchemaStmt:
          case T_CommentStmt:
          case T_DefineStmt:
          case T_CreateCastStmt:
***************
*** 624,629 ****
--- 625,634 ----
              ExecRenameStmt((RenameStmt *) parsetree);
              break;

+         case T_RenameObjSchemaStmt:
+                 ExecRenameObjSchemaStmt((RenameObjSchemaStmt *)parsetree);
+                 break;
+
          case T_AlterOwnerStmt:
              ExecAlterOwnerStmt((AlterOwnerStmt *) parsetree);
              break;
***************
*** 1323,1328 ****
--- 1328,1360 ----
              tag = "COPY";
              break;

+         case T_RenameObjSchemaStmt:
+             switch(((RenameObjSchemaStmt *) parsetree)->renameType)
+             {
+                 case OBJECT_AGGREGATE:
+                     tag = "ALTER AGGREGATE";
+                     break;
+
+                 case OBJECT_CONVERSION:
+                     tag = "ALTER CONVERSION";
+
+                 case OBJECT_DOMAIN:
+                     tag = "ALTER DOMAIN";
+                     break;
+
+                 case OBJECT_FUNCTION:
+                     tag = "ALTER FUNCTION";
+                     break;
+
+                 case OBJECT_SEQUENCE:
+                     tag = "ALTER SEQUENCE";
+                     break;
+
+                 default:
+                     tag = "ALTER TABLE";
+                     break;
+             }
+
          case T_RenameStmt:
              switch (((RenameStmt *) parsetree)->renameType)
              {
Index: src/include/catalog/dependency.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/catalog/dependency.h,v
retrieving revision 1.15
diff -c -c -r1.15 dependency.h
*** src/include/catalog/dependency.h    7 Jul 2005 20:39:59 -0000    1.15
--- src/include/catalog/dependency.h    29 Jul 2005 03:11:30 -0000
***************
*** 198,201 ****
--- 198,206 ----

  extern void dropDatabaseDependencies(Oid databaseId);

+ extern bool changeDependencyFor(Oid classId,
+                                  Oid objectId,
+                                  Oid oldrefobjectId,
+                                  Oid newrefobjectId);
+
  #endif   /* DEPENDENCY_H */
Index: src/include/commands/alter.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/commands/alter.h,v
retrieving revision 1.6
diff -c -c -r1.6 alter.h
*** src/include/commands/alter.h    31 Dec 2004 22:03:28 -0000    1.6
--- src/include/commands/alter.h    29 Jul 2005 03:11:30 -0000
***************
*** 16,21 ****
--- 16,23 ----

  #include "nodes/parsenodes.h"

+ extern void ExecRenameObjSchemaStmt(RenameObjSchemaStmt *stmt);
+
  extern void ExecRenameStmt(RenameStmt *stmt);

  extern void ExecAlterOwnerStmt(AlterOwnerStmt *stmt);
Index: src/include/commands/defrem.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/commands/defrem.h,v
retrieving revision 1.66
diff -c -c -r1.66 defrem.h
*** src/include/commands/defrem.h    28 Jun 2005 05:09:12 -0000    1.66
--- src/include/commands/defrem.h    29 Jul 2005 03:11:30 -0000
***************
*** 55,60 ****
--- 55,62 ----
  extern void CreateCast(CreateCastStmt *stmt);
  extern void DropCast(DropCastStmt *stmt);
  extern void DropCastById(Oid castOid);
+ extern void AlterFunctionNamespace(List *name, List *argtypes,
+                     const char *newnpname);

  /* commands/operatorcmds.c */
  extern void DefineOperator(List *names, List *parameters);
Index: src/include/commands/tablecmds.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/commands/tablecmds.h,v
retrieving revision 1.22
diff -c -c -r1.22 tablecmds.h
*** src/include/commands/tablecmds.h    27 Jan 2005 03:18:24 -0000    1.22
--- src/include/commands/tablecmds.h    29 Jul 2005 03:11:30 -0000
***************
*** 16,21 ****
--- 16,26 ----

  #include "nodes/parsenodes.h"

+ extern void AlterConstraintNamespacesForRel(Oid relOid,
+                          Oid newnspOid,
+                          const char relkind);
+ extern void AlterTableNamespace(Oid relid,
+                   const char *newnpname);

  extern Oid    DefineRelation(CreateStmt *stmt, char relkind);

Index: src/include/commands/typecmds.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/commands/typecmds.h,v
retrieving revision 1.11
diff -c -c -r1.11 typecmds.h
*** src/include/commands/typecmds.h    28 Jun 2005 05:09:12 -0000    1.11
--- src/include/commands/typecmds.h    29 Jul 2005 03:11:30 -0000
***************
*** 19,24 ****
--- 19,27 ----

  #define DEFAULT_TYPDELIM        ','

+ extern void AlterTypeNamespace(Oid typeOid, Relation rel, const char *newnpname,
+                 const TypeName *typename, const bool errorOnTableType);
+ extern void AlterDomainNamespace(List *names, const char *newnpname);
  extern void DefineType(List *names, List *parameters);
  extern void RemoveType(List *names, DropBehavior behavior);
  extern void RemoveTypeById(Oid typeOid);
Index: src/include/nodes/nodes.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/nodes/nodes.h,v
retrieving revision 1.172
diff -c -c -r1.172 nodes.h
*** src/include/nodes/nodes.h    28 Jun 2005 05:09:13 -0000    1.172
--- src/include/nodes/nodes.h    29 Jul 2005 03:11:30 -0000
***************
*** 284,289 ****
--- 284,290 ----
      T_CreateTableSpaceStmt,
      T_DropTableSpaceStmt,
      T_AlterOwnerStmt,
+     T_RenameObjSchemaStmt,

      T_A_Expr = 800,
      T_ColumnRef,
Index: src/include/nodes/parsenodes.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/nodes/parsenodes.h,v
retrieving revision 1.286
diff -c -c -r1.286 parsenodes.h
*** src/include/nodes/parsenodes.h    26 Jul 2005 16:38:28 -0000    1.286
--- src/include/nodes/parsenodes.h    29 Jul 2005 03:11:34 -0000
***************
*** 1471,1476 ****
--- 1471,1491 ----
  } RemoveOpClassStmt;

  /* ----------------------
+  *        Alter Object Rename Schema
+  * ----------------------
+  */
+ typedef struct RenameObjSchemaStmt
+ {
+     NodeTag    type;
+     RangeVar   *relation;
+     List       *object;
+     List       *objarg;
+
+     char       *newname;
+     ObjectType renameType;
+ } RenameObjSchemaStmt;
+
+ /* ----------------------
   *        Alter Object Rename Statement
   * ----------------------
   */