Cope with circularities involving a view's ON SELECT rule. I originally

thought there couldn't be any, but the folly of this was exposed by an
example from andrew@supernews.com 5-Dec-2004.  The patch applies the
identical logic already used for table constraints and defaults to ON
SELECT rules, so I have reasonable confidence in it even though it might
look like complicated logic.

diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index c161b3d0afe14ed96edc121e61b9502c1f7e9132..4b96613a1cc586ea20749424b211c46f589aa201 100644 (file)
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -12,7 +12,7 @@
  * by PostgreSQL
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.c,v 1.395 2004/12/14 21:35:20 tgl Exp $
+ *   $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.c,v 1.396 2004/12/14 22:16:32 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -3160,12 +3160,21 @@ getRules(int *numRules)
             */
            if (ruleinfo[i].ruletable->relkind == RELKIND_VIEW &&
                ruleinfo[i].ev_type == '1' && ruleinfo[i].is_instead)
+           {
                addObjectDependency(&ruleinfo[i].ruletable->dobj,
                                    ruleinfo[i].dobj.dumpId);
+               /* We'll merge the rule into CREATE VIEW, if possible */
+               ruleinfo[i].separate = false;
+           }
            else
+           {
                addObjectDependency(&ruleinfo[i].dobj,
                                    ruleinfo[i].ruletable->dobj.dumpId);
+               ruleinfo[i].separate = true;
+           }
        }
+       else
+           ruleinfo[i].separate = true;
    }
 
    PQclear(res);
@@ -7617,10 +7626,10 @@ dumpRule(Archive *fout, RuleInfo *rinfo)
        return;
 
    /*
-    * If it is an ON SELECT rule, we do not need to dump it because it
-    * will be handled via CREATE VIEW for the table.
+    * If it is an ON SELECT rule that is created implicitly by CREATE VIEW,
+    * we do not want to dump it as a separate object.
     */
-   if (rinfo->ev_type == '1' && rinfo->is_instead)
+   if (!rinfo->separate)
        return;
 
    /*

diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 07798c90f4720e3fd155f04c2ec3e798362da990..a6a010d187abf21f39223f8046277092a41b2e3b 100644 (file)
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.h,v 1.113 2004/11/05 19:16:19 tgl Exp $
+ * $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.h,v 1.114 2004/12/14 22:16:32 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -252,6 +252,8 @@ typedef struct _ruleInfo
    TableInfo  *ruletable;      /* link to table the rule is for */
    char        ev_type;
    bool        is_instead;
+   bool        separate;       /* TRUE if must dump as separate item */
+   /* separate is always true for non-ON SELECT rules */
 } RuleInfo;
 
 typedef struct _triggerInfo

diff --git a/src/bin/pg_dump/pg_dump_sort.c b/src/bin/pg_dump/pg_dump_sort.c
index 79696f452f767d6336c96c48e0cf2a41df1f271e..34b4b468b1f178c485d7e993cc2c176875b6921f 100644 (file)
--- a/src/bin/pg_dump/pg_dump_sort.c
+++ b/src/bin/pg_dump/pg_dump_sort.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump_sort.c,v 1.6 2004/08/29 05:06:53 momjian Exp $
+ *   $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump_sort.c,v 1.7 2004/12/14 22:16:32 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -639,7 +639,8 @@ repairTypeFuncLoop(DumpableObject *typeobj, DumpableObject *funcobj)
 /*
  * Because we force a view to depend on its ON SELECT rule, while there
  * will be an implicit dependency in the other direction, we need to break
- * the loop.  We can always do this by removing the implicit dependency.
+ * the loop.  If there are no other objects in the loop then we can remove
+ * the implicit dependency and leave the ON SELECT rule non-separate.
  */
 static void
 repairViewRuleLoop(DumpableObject *viewobj,
@@ -649,6 +650,29 @@ repairViewRuleLoop(DumpableObject *viewobj,
    removeObjectDependency(ruleobj, viewobj->dumpId);
 }
 
+/*
+ * However, if there are other objects in the loop, we must break the loop
+ * by making the ON SELECT rule a separately-dumped object.
+ *
+ * Because findLoop() finds shorter cycles before longer ones, it's likely
+ * that we will have previously fired repairViewRuleLoop() and removed the
+ * rule's dependency on the view.  Put it back to ensure the rule won't be
+ * emitted before the view...
+ */
+static void
+repairViewRuleMultiLoop(DumpableObject *viewobj,
+                       DumpableObject *ruleobj)
+{
+   /* remove view's dependency on rule */
+   removeObjectDependency(viewobj, ruleobj->dumpId);
+   /* pretend view is a plain table and dump it that way */
+   ((TableInfo *) viewobj)->relkind = 'r';     /* RELKIND_RELATION */
+   /* mark rule as needing its own dump */
+   ((RuleInfo *) ruleobj)->separate = true;
+   /* put back rule's dependency on view */
+   addObjectDependency(ruleobj, viewobj->dumpId);
+}
+
 /*
  * Because we make tables depend on their CHECK constraints, while there
  * will be an automatic dependency in the other direction, we need to break
@@ -765,7 +789,8 @@ repairDependencyLoop(DumpableObject **loop,
        loop[0]->objType == DO_TABLE &&
        loop[1]->objType == DO_RULE &&
        ((RuleInfo *) loop[1])->ev_type == '1' &&
-       ((RuleInfo *) loop[1])->is_instead)
+       ((RuleInfo *) loop[1])->is_instead &&
+       ((RuleInfo *) loop[1])->ruletable == (TableInfo *) loop[0])
    {
        repairViewRuleLoop(loop[0], loop[1]);
        return;
@@ -774,12 +799,35 @@ repairDependencyLoop(DumpableObject **loop,
        loop[1]->objType == DO_TABLE &&
        loop[0]->objType == DO_RULE &&
        ((RuleInfo *) loop[0])->ev_type == '1' &&
-       ((RuleInfo *) loop[0])->is_instead)
+       ((RuleInfo *) loop[0])->is_instead &&
+       ((RuleInfo *) loop[0])->ruletable == (TableInfo *) loop[1])
    {
        repairViewRuleLoop(loop[1], loop[0]);
        return;
    }
 
+   /* Indirect loop involving view and ON SELECT rule */
+   if (nLoop > 2)
+   {
+       for (i = 0; i < nLoop; i++)
+       {
+           if (loop[i]->objType == DO_TABLE)
+           {
+               for (j = 0; j < nLoop; j++)
+               {
+                   if (loop[j]->objType == DO_RULE &&
+                       ((RuleInfo *) loop[j])->ev_type == '1' &&
+                       ((RuleInfo *) loop[j])->is_instead &&
+                       ((RuleInfo *) loop[j])->ruletable == (TableInfo *) loop[i])
+                   {
+                       repairViewRuleMultiLoop(loop[i], loop[j]);
+                       return;
+                   }
+               }
+           }
+       }
+   }
+
    /* Table and CHECK constraint */
    if (nLoop == 2 &&
        loop[0]->objType == DO_TABLE &&