Fix test about ignoring extension dependencies during extension scripts.

Commit 08dd23cec introduced an exception to the rule that extension member
objects can only be dropped as part of dropping the whole extension,
intending to allow such drops while running the extension's own creation or
update scripts.  However, the exception was only applied at the outermost
recursion level, because it was modeled on a pre-existing check to ignore
dependencies on objects listed in pendingObjects.  Bug #14434 from Philippe
Beaudoin shows that this is inadequate: in some cases we can reach an
extension member object by recursion from another one.  (The bug concerns
the serial-sequence case; I'm not sure if there are other cases, but there
might well be.)

To fix, revert 08dd23cec's changes to findDependentObjects() and instead
apply the creating_extension exception regardless of stack level.

Having seen this example, I'm a bit suspicious that the pendingObjects
logic is also wrong and such cases should likewise be allowed at any
recursion level.  However, changing that would interact in subtle ways
with the recursion logic (at least it would need to be moved to after the
recursing-from check).  Given that the code's been like that a long time,
I'll refrain from touching it without a clear example showing it's wrong.

Back-patch to all active branches.  In HEAD and 9.6, where suitable
test infrastructure exists, add a regression test case based on the
bug report.

Report: <20161125151448.6529.33039@wrigleys.postgresql.org>
Discussion: <13224.1480177514@sss.pgh.pa.us>

diff --git a/src/backend/catalog/dependency.c b/src/backend/catalog/dependency.c
index 997936108d7db44d5eea843bda06b03c9eed8aa8..042d54bc41b03bdd555d2963a39ef05c2e741378 100644 (file)
--- a/src/backend/catalog/dependency.c
+++ b/src/backend/catalog/dependency.c
@@ -553,29 +553,43 @@ findDependentObjects(const ObjectAddress *object,
                        case DEPENDENCY_AUTO:
                                /* no problem */
                                break;
-                       case DEPENDENCY_INTERNAL:
+
                        case DEPENDENCY_EXTENSION:
 
+                               /*
+                                * If the other object is the extension currently being
+                                * created/altered, ignore this dependency and continue with
+                                * the deletion.  This allows dropping of an extension's
+                                * objects within the extension's scripts, as well as corner
+                                * cases such as dropping a transient object created within
+                                * such a script.
+                                */
+                               if (creating_extension &&
+                                       otherObject.classId == ExtensionRelationId &&
+                                       otherObject.objectId == CurrentExtensionObject)
+                                       break;
+
+                               /* Otherwise, treat this like an internal dependency */
+                               /* FALL THRU */
+
+                       case DEPENDENCY_INTERNAL:
+
                                /*
                                 * This object is part of the internal implementation of
                                 * another object, or is part of the extension that is the
                                 * other object.  We have three cases:
                                 *
-                                * 1. At the outermost recursion level, we normally disallow
-                                * the DROP.  (We just ereport here, rather than proceeding,
-                                * since no other dependencies are likely to be interesting.)
-                                * However, there are exceptions.
+                                * 1. At the outermost recursion level, disallow the DROP. (We
+                                * just ereport here, rather than proceeding, since no other
+                                * dependencies are likely to be interesting.)  However, if
+                                * the owning object is listed in pendingObjects, just release
+                                * the caller's lock and return; we'll eventually complete the
+                                * DROP when we reach that entry in the pending list.
                                 */
                                if (stack == NULL)
                                {
                                        char       *otherObjDesc;
 
-                                       /*
-                                        * Exception 1a: if the owning object is listed in
-                                        * pendingObjects, just release the caller's lock and
-                                        * return.  We'll eventually complete the DROP when we
-                                        * reach that entry in the pending list.
-                                        */
                                        if (pendingObjects &&
                                                object_address_present(&otherObject, pendingObjects))
                                        {
@@ -584,21 +598,6 @@ findDependentObjects(const ObjectAddress *object,
                                                ReleaseDeletionLock(object);
                                                return;
                                        }
-
-                                       /*
-                                        * Exception 1b: if the owning object is the extension
-                                        * currently being created/altered, it's okay to continue
-                                        * with the deletion.  This allows dropping of an
-                                        * extension's objects within the extension's scripts, as
-                                        * well as corner cases such as dropping a transient
-                                        * object created within such a script.
-                                        */
-                                       if (creating_extension &&
-                                               otherObject.classId == ExtensionRelationId &&
-                                               otherObject.objectId == CurrentExtensionObject)
-                                               break;
-
-                                       /* No exception applies, so throw the error */
                                        otherObjDesc = getObjectDescription(&otherObject);
                                        ereport(ERROR,
                                                        (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),