Ensure that pg_amop/amproc entries depend on their lefttype/righttype.

Usually an entry in pg_amop or pg_amproc does not need a dependency on
its amoplefttype/amoprighttype/amproclefttype/amprocrighttype types,
because there is an indirect dependency via the argument types of its
referenced operator or procedure, or via the opclass it belongs to.
However, for some support procedures in some index AMs, the argument
types of the support procedure might not mention the column data type
at all.  Also, the amop/amproc entry might be treated as "loose" in
the opfamily, in which case it lacks a dependency on any particular
opclass; or it might be a cross-type entry having a reference to a
datatype that is not its opclass' opcintype.

The upshot of all this is that there are cases where a datatype can
be dropped while leaving behind amop/amproc entries that mention it,
because there is no path in pg_depend showing that those entries
depend on that type.  Such entries are harmless in normal activity,
because they won't get used, but they cause problems for maintenance
actions such as dropping the operator family.  They also cause pg_dump
to produce bogus output.  The previous commit put a band-aid on the
DROP OPERATOR FAMILY failure, but a real fix is needed.

To fix, add pg_depend entries showing that a pg_amop/pg_amproc entry
depends on its lefttype/righttype.  To avoid bloating pg_depend too
much, skip this if the referenced operator or function has that type
as an input type.  (I did not bother with considering the possible
indirect dependency via the opclass' opcintype; at least in the
reported case, that wouldn't help anyway.)

Probably, the reason this has escaped notice for so long is that
add-on datatypes and relevant opclasses/opfamilies are usually
packaged as extensions nowadays, so that there's no way to drop
a type without dropping the referencing opclasses/opfamilies too.
Still, in the absence of pg_depend entries there's nothing that
constrains DROP EXTENSION to drop the opfamily entries before the
datatype, so it seems possible for a DROP failure to occur anyway.

The specific case that was reported doesn't fail in v13, because
v13 prefers to attach the support procedure to the opclass not the
opfamily.  But it's surely possible to construct other edge cases
that do fail in v13, so patch that too.

Per report from Yoran Heling.  Back-patch to all supported branches.

Discussion: https://postgr.es/m/Z1MVCOh1hprjK5Sf@gmai021

diff --git a/src/backend/commands/opclasscmds.c b/src/backend/commands/opclasscmds.c
index 783c497372d6c3780c0b036b0b6675ae25b78060..0ebbe8c855697d59fa964ef21ec87d5eaaf2076d 100644 (file)
--- a/src/backend/commands/opclasscmds.c
+++ b/src/backend/commands/opclasscmds.c
@@ -69,6 +69,7 @@ static void storeOperators(List *opfamilyname, Oid amoid,
 static void storeProcedures(List *opfamilyname, Oid amoid,
                            Oid opfamilyoid, Oid opclassoid,
                            List *procedures, bool isAdd);
+static bool typeDepNeeded(Oid typid, OpFamilyMember *member, bool isProc);
 static void dropOperators(List *opfamilyname, Oid amoid, Oid opfamilyoid,
                          List *operators);
 static void dropProcedures(List *opfamilyname, Oid amoid, Oid opfamilyoid,
@@ -1390,6 +1391,7 @@ storeOperators(List *opfamilyname, Oid amoid,
    foreach(l, operators)
    {
        OpFamilyMember *op = (OpFamilyMember *) lfirst(l);
+       DependencyType opdeptype;
        char        oppurpose;
 
        /*
@@ -1446,6 +1448,7 @@ storeOperators(List *opfamilyname, Oid amoid,
        if (OidIsValid(opclassoid))
        {
            /* if contained in an opclass, use a NORMAL dep on operator */
+           opdeptype = DEPENDENCY_NORMAL;
            recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
            /* ... and an INTERNAL dep on the opclass */
@@ -1457,6 +1460,7 @@ storeOperators(List *opfamilyname, Oid amoid,
        else
        {
            /* if "loose" in the opfamily, use a AUTO dep on operator */
+           opdeptype = DEPENDENCY_AUTO;
            recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
 
            /* ... and an AUTO dep on the opfamily */
@@ -1466,6 +1470,27 @@ storeOperators(List *opfamilyname, Oid amoid,
            recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
        }
 
+       if (typeDepNeeded(op->lefttype, op, false))
+       {
+           referenced.classId = TypeRelationId;
+           referenced.objectId = op->lefttype;
+           referenced.objectSubId = 0;
+
+           /* use same dependency type as for operator */
+           recordDependencyOn(&myself, &referenced, opdeptype);
+       }
+
+       if (op->lefttype != op->righttype &&
+           typeDepNeeded(op->righttype, op, false))
+       {
+           referenced.classId = TypeRelationId;
+           referenced.objectId = op->righttype;
+           referenced.objectSubId = 0;
+
+           /* use same dependency type as for operator */
+           recordDependencyOn(&myself, &referenced, opdeptype);
+       }
+
        /* A search operator also needs a dep on the referenced opfamily */
        if (OidIsValid(op->sortfamily))
        {
@@ -1508,6 +1533,7 @@ storeProcedures(List *opfamilyname, Oid amoid,
    foreach(l, procedures)
    {
        OpFamilyMember *proc = (OpFamilyMember *) lfirst(l);
+       DependencyType procdeptype;
 
        /*
         * If adding to an existing family, check for conflict with an
@@ -1558,6 +1584,7 @@ storeProcedures(List *opfamilyname, Oid amoid,
        if (OidIsValid(opclassoid))
        {
            /* if contained in an opclass, use a NORMAL dep on procedure */
+           procdeptype = DEPENDENCY_NORMAL;
            recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
            /* ... and an INTERNAL dep on the opclass */
@@ -1569,6 +1596,7 @@ storeProcedures(List *opfamilyname, Oid amoid,
        else
        {
            /* if "loose" in the opfamily, use a AUTO dep on procedure */
+           procdeptype = DEPENDENCY_AUTO;
            recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
 
            /* ... and an AUTO dep on the opfamily */
@@ -1577,6 +1605,28 @@ storeProcedures(List *opfamilyname, Oid amoid,
            referenced.objectSubId = 0;
            recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
        }
+
+       if (typeDepNeeded(proc->lefttype, proc, true))
+       {
+           referenced.classId = TypeRelationId;
+           referenced.objectId = proc->lefttype;
+           referenced.objectSubId = 0;
+
+           /* use same dependency type as for procedure */
+           recordDependencyOn(&myself, &referenced, procdeptype);
+       }
+
+       if (proc->lefttype != proc->righttype &&
+           typeDepNeeded(proc->righttype, proc, true))
+       {
+           referenced.classId = TypeRelationId;
+           referenced.objectId = proc->righttype;
+           referenced.objectSubId = 0;
+
+           /* use same dependency type as for procedure */
+           recordDependencyOn(&myself, &referenced, procdeptype);
+       }
+
        /* Post create hook of access method procedure */
        InvokeObjectPostCreateHook(AccessMethodProcedureRelationId,
                                   entryoid, 0);
@@ -1585,6 +1635,47 @@ storeProcedures(List *opfamilyname, Oid amoid,
    table_close(rel, RowExclusiveLock);
 }
 
+/*
+ * Detect whether a pg_amop or pg_amproc entry needs an explicit dependency
+ * on its lefttype or righttype.
+ *
+ * We make such a dependency unless the entry has an indirect dependency
+ * via its referenced operator or function.  That's nearly always true
+ * for operators, but might well not be true for support functions.
+ */
+static bool
+typeDepNeeded(Oid typid, OpFamilyMember *member, bool isProc)
+{
+   bool        result = true;
+
+   if (isProc)
+   {
+       Oid        *argtypes;
+       int         nargs;
+
+       (void) get_func_signature(member->object, &argtypes, &nargs);
+       for (int i = 0; i < nargs; i++)
+       {
+           if (typid == argtypes[i])
+           {
+               result = false; /* match, no dependency needed */
+               break;
+           }
+       }
+       pfree(argtypes);
+   }
+   else
+   {
+       Oid         lefttype,
+                   righttype;
+
+       op_input_types(member->object, &lefttype, &righttype);
+       if (typid == lefttype || typid == righttype)
+           result = false;     /* match, no dependency needed */
+   }
+   return result;
+}
+
 
 /*
  * Remove operator entries from an opfamily.