The dependent object was created as part of creation of the
       referenced object, and is really just a part of its internal
       implementation.  A direct <command>DROP</command> of the dependent
       object will be disallowed outright (we'll tell the user to issue
       a <command>DROP</command> against the referenced object, instead).
       A <command>DROP</command> of the referenced object will result in
       automatically dropping the dependent object
       whether <literal>CASCADE</literal> is specified or not.  If the
       dependent object has to be dropped due to a dependency on some other
       object being removed, its drop is converted to a drop of the referenced
       object, so that <literal>NORMAL</literal> and <literal>AUTO</literal>
       dependencies of the dependent object behave much like they were
       dependencies of the referenced object.
       Example: a view's <literal>ON SELECT</literal> rule is made
       internally dependent on the view, preventing it from being dropped
       while the view remains.  Dependencies of the rule (such as tables it
       refers to) act as if they were dependencies of the view.
      </para>
     </listitem>
    </varlistentry>

    <varlistentry>
     <term><symbol>DEPENDENCY_PARTITION_PRI</symbol> (<literal>P</literal>)</term>
     <term><symbol>DEPENDENCY_PARTITION_SEC</symbol> (<literal>S</literal>)</term>
     <listitem>
      <para>
       The dependent object was created as part of creation of the
       referenced object, and is really just a part of its internal
       implementation; however, unlike <literal>INTERNAL</literal>,
       there is more than one such referenced object.  The dependent object
       must not be dropped unless at least one of these referenced objects
       is dropped; if any one is, the dependent object should be dropped
       whether or not <literal>CASCADE</literal> is specified.  Also
       unlike <literal>INTERNAL</literal>, a drop of some other object
       that the dependent object depends on does not result in automatic
       deletion of any partition-referenced object.  Hence, if the drop
       does not cascade to at least one of these objects via some other
       path, it will be refused.  (In most cases, the dependent object
       shares all its non-partition dependencies with at least one
       partition-referenced object, so that this restriction does not
       result in blocking any cascaded delete.)
       Primary and secondary partition dependencies behave identically
       except that the primary dependency is preferred for use in error
       messages; hence, a partition-dependent object should have one
       primary partition dependency and one or more secondary partition
       dependencies.
       Note that partition dependencies are made in addition to, not
       instead of, any dependencies the object would normally have.  This
       simplifies <command>ATTACH/DETACH PARTITION</command> operations:
       the partition dependencies need only be added or removed.
       Example: a child partitioned index is made partition-dependent
       on both the partition table it is on and the parent partitioned
       index, so that it goes away if either of those is dropped, but
       not otherwise.  The dependency on the parent index is primary,
       so that if the user tries to drop the child partitioned index,
       the error message will suggest dropping the parent index instead
       (not the table).
      </para>
     </listitem>
    </varlistentry>

    <varlistentry>
     <term><symbol>DEPENDENCY_EXTENSION</symbol> (<literal>e</literal>)</term>
     <listitem>
      <para>
       The dependent object is a member of the <firstterm>extension</firstterm> that is
       the referenced object (see
       <link linkend="catalog-pg-extension"><structname>pg_extension</structname></link>).
       The dependent object can be dropped only via
       <link linkend="sql-dropextension"><command>DROP