Fix ALTER TABLE OWNER to adjust the ownership of dependent sequences,

not only indexes.  Alvaro Herrera, with some kibitzing by Tom Lane.

diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 63ee33dd3045a3103680872d4a550a6c54a88e03..c8efaa23b1ad28f9f91f16df102f04eaf9567c84 100644 (file)
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/commands/tablecmds.c,v 1.132 2004/09/16 16:58:28 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/commands/tablecmds.c,v 1.133 2004/09/23 23:20:24 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -237,6 +237,8 @@ static void ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
 static void ATPostAlterTypeCleanup(List **wqueue, AlteredTableInfo *tab);
 static void ATPostAlterTypeParse(char *cmd, List **wqueue);
 static void ATExecChangeOwner(Oid relationOid, int32 newOwnerSysId);
+static void change_owner_recurse_to_sequences(Oid relationOid,
+                                             int32 newOwnerSysId);
 static void ATExecClusterOn(Relation rel, const char *indexName);
 static void ATExecDropCluster(Relation rel);
 static void ATPrepSetTableSpace(AlteredTableInfo *tab, Relation rel,
@@ -5121,8 +5123,10 @@ ATExecChangeOwner(Oid relationOid, int32 newOwnerSysId)
    HeapTuple   tuple;
    Form_pg_class tuple_class;
 
-   /* Get exclusive lock till end of transaction on the target table */
-   /* Use relation_open here so that we work on indexes... */
+   /*
+    * Get exclusive lock till end of transaction on the target table.
+    * Use relation_open so that we can work on indexes and sequences.
+    */
    target_rel = relation_open(relationOid, AccessExclusiveLock);
 
    /* Get its pg_class tuple, too */
@@ -5202,8 +5206,8 @@ ATExecChangeOwner(Oid relationOid, int32 newOwnerSysId)
 
        /*
         * If we are operating on a table, also change the ownership of
-        * any indexes that belong to the table, as well as the table's
-        * toast table (if it has one)
+        * any indexes and sequences that belong to the table, as well as
+        * the table's toast table (if it has one)
         */
        if (tuple_class->relkind == RELKIND_RELATION ||
            tuple_class->relkind == RELKIND_TOASTVALUE)
@@ -5226,6 +5230,9 @@ ATExecChangeOwner(Oid relationOid, int32 newOwnerSysId)
            /* If it has a toast table, recurse to change its ownership */
            if (tuple_class->reltoastrelid != InvalidOid)
                ATExecChangeOwner(tuple_class->reltoastrelid, newOwnerSysId);
+
+           /* If it has dependent sequences, recurse to change them too */
+           change_owner_recurse_to_sequences(relationOid, newOwnerSysId);
        }
    }
 
@@ -5234,6 +5241,73 @@ ATExecChangeOwner(Oid relationOid, int32 newOwnerSysId)
    relation_close(target_rel, NoLock);
 }
 
+/*
+ * change_owner_recurse_to_sequences
+ *
+ * Helper function for ATExecChangeOwner.  Examines pg_depend searching
+ * for sequences that are dependent on serial columns, and changes their
+ * ownership.
+ */
+static void
+change_owner_recurse_to_sequences(Oid relationOid, int32 newOwnerSysId)
+{
+   Relation    depRel;
+   SysScanDesc scan;
+   ScanKeyData key[2];
+   HeapTuple   tup;
+
+   /*
+    * SERIAL sequences are those having an internal dependency on one
+    * of the table's columns (we don't care *which* column, exactly).
+    */
+   depRel = heap_openr(DependRelationName, RowExclusiveLock);
+
+   ScanKeyInit(&key[0],
+           Anum_pg_depend_refclassid,
+           BTEqualStrategyNumber, F_OIDEQ,
+           ObjectIdGetDatum(RelOid_pg_class));
+   ScanKeyInit(&key[1],
+           Anum_pg_depend_refobjid,
+           BTEqualStrategyNumber, F_OIDEQ,
+           ObjectIdGetDatum(relationOid));
+   /* we leave refobjsubid unspecified */
+
+   scan = systable_beginscan(depRel, DependReferenceIndex, true,
+                             SnapshotNow, 2, key);
+
+   while (HeapTupleIsValid(tup = systable_getnext(scan)))
+   {
+       Form_pg_depend depForm = (Form_pg_depend) GETSTRUCT(tup);
+       Relation    seqRel;
+
+       /* skip dependencies other than internal dependencies on columns */
+       if (depForm->refobjsubid == 0 ||
+           depForm->classid != RelOid_pg_class ||
+           depForm->objsubid != 0 ||
+           depForm->deptype != DEPENDENCY_INTERNAL)
+           continue;
+
+       /* Use relation_open just in case it's an index */
+       seqRel = relation_open(depForm->objid, AccessExclusiveLock);
+
+       /* skip non-sequence relations */
+       if (RelationGetForm(seqRel)->relkind != RELKIND_SEQUENCE)
+       {
+           /* No need to keep the lock */
+           relation_close(seqRel, AccessExclusiveLock);
+           continue;
+       }
+
+       /* We don't need to close the sequence while we alter it. */
+       ATExecChangeOwner(depForm->objid, newOwnerSysId);
+
+       /* Now we can close it.  Keep the lock till end of transaction. */
+       relation_close(seqRel, NoLock);
+   }
+
+   systable_endscan(scan);
+}
+
 /*
  * ALTER TABLE CLUSTER ON
  *