Properly schema-qualify additional object types in getObjectDescription().

Collations, conversions, extended statistics objects (in >= v10),
and all four types of text search objects have schema-qualified names.
getObjectDescription() ignored that and would emit just the base name of
the object, potentially producing wrong or at least highly misleading
output.  Fix it to add the schema name whenever the object is not "visible"
in the current search path, as is the rule for other schema-qualifiable
object types.

Although in common situations the output won't change, this seems to me
(tgl) to be a bug worthy of back-patching, hence do so.

Kyotaro Horiguchi, per a complaint from me

Discussion: https://postgr.es/m/20180522.182020.114074746.horiguchi.kyotaro@lab.ntt.co.jp

diff --git a/src/backend/catalog/objectaddress.c b/src/backend/catalog/objectaddress.c
index 279d6e3e435c7926afb1f84e5fe60d0086ae4a14..472eef210fc7a42eb3b27b564a5b6c02805f5e74 100644 (file)
--- a/src/backend/catalog/objectaddress.c
+++ b/src/backend/catalog/objectaddress.c
@@ -1567,6 +1567,7 @@ getObjectDescription(const ObjectAddress *object)
                        {
                                HeapTuple       collTup;
                                Form_pg_collation coll;
+                               char       *nspname;
 
                                collTup = SearchSysCache1(COLLOID,
                                                                                  ObjectIdGetDatum(object->objectId));
@@ -1574,8 +1575,16 @@ getObjectDescription(const ObjectAddress *object)
                                        elog(ERROR, "cache lookup failed for collation %u",
                                                 object->objectId);
                                coll = (Form_pg_collation) GETSTRUCT(collTup);
+
+                               /* Qualify the name if not visible in search path */
+                               if (CollationIsVisible(object->objectId))
+                                       nspname = NULL;
+                               else
+                                       nspname = get_namespace_name(coll->collnamespace);
+
                                appendStringInfo(&buffer, _("collation %s"),
-                                                                NameStr(coll->collname));
+                                                                quote_qualified_identifier(nspname,
+                                                                                                                       NameStr(coll->collname)));
                                ReleaseSysCache(collTup);
                                break;
                        }
@@ -1615,14 +1624,25 @@ getObjectDescription(const ObjectAddress *object)
                case OCLASS_CONVERSION:
                        {
                                HeapTuple       conTup;
+                               Form_pg_conversion conv;
+                               char       *nspname;
 
                                conTup = SearchSysCache1(CONVOID,
                                                                                 ObjectIdGetDatum(object->objectId));
                                if (!HeapTupleIsValid(conTup))
                                        elog(ERROR, "cache lookup failed for conversion %u",
                                                 object->objectId);
+                               conv = (Form_pg_conversion) GETSTRUCT(conTup);
+
+                               /* Qualify the name if not visible in search path */
+                               if (ConversionIsVisible(object->objectId))
+                                       nspname = NULL;
+                               else
+                                       nspname = get_namespace_name(conv->connamespace);
+
                                appendStringInfo(&buffer, _("conversion %s"),
-                                NameStr(((Form_pg_conversion) GETSTRUCT(conTup))->conname));
+                                                                quote_qualified_identifier(nspname,
+                                                                                                                       NameStr(conv->conname)));
                                ReleaseSysCache(conTup);
                                break;
                        }
@@ -1917,14 +1937,25 @@ getObjectDescription(const ObjectAddress *object)
                case OCLASS_TSPARSER:
                        {
                                HeapTuple       tup;
+                               Form_pg_ts_parser prsForm;
+                               char       *nspname;
 
                                tup = SearchSysCache1(TSPARSEROID,
                                                                          ObjectIdGetDatum(object->objectId));
                                if (!HeapTupleIsValid(tup))
                                        elog(ERROR, "cache lookup failed for text search parser %u",
                                                 object->objectId);
+                               prsForm = (Form_pg_ts_parser) GETSTRUCT(tup);
+
+                               /* Qualify the name if not visible in search path */
+                               if (TSParserIsVisible(object->objectId))
+                                       nspname = NULL;
+                               else
+                                       nspname = get_namespace_name(prsForm->prsnamespace);
+
                                appendStringInfo(&buffer, _("text search parser %s"),
-                                        NameStr(((Form_pg_ts_parser) GETSTRUCT(tup))->prsname));
+                                                                quote_qualified_identifier(nspname,
+                                                                                                                       NameStr(prsForm->prsname)));
                                ReleaseSysCache(tup);
                                break;
                        }
@@ -1932,14 +1963,25 @@ getObjectDescription(const ObjectAddress *object)
                case OCLASS_TSDICT:
                        {
                                HeapTuple       tup;
+                               Form_pg_ts_dict dictForm;
+                               char       *nspname;
 
                                tup = SearchSysCache1(TSDICTOID,
                                                                          ObjectIdGetDatum(object->objectId));
                                if (!HeapTupleIsValid(tup))
                                        elog(ERROR, "cache lookup failed for text search dictionary %u",
                                                 object->objectId);
+                               dictForm = (Form_pg_ts_dict) GETSTRUCT(tup);
+
+                               /* Qualify the name if not visible in search path */
+                               if (TSDictionaryIsVisible(object->objectId))
+                                       nspname = NULL;
+                               else
+                                       nspname = get_namespace_name(dictForm->dictnamespace);
+
                                appendStringInfo(&buffer, _("text search dictionary %s"),
-                                         NameStr(((Form_pg_ts_dict) GETSTRUCT(tup))->dictname));
+                                                                quote_qualified_identifier(nspname,
+                                                                                                                       NameStr(dictForm->dictname)));
                                ReleaseSysCache(tup);
                                break;
                        }
@@ -1947,14 +1989,25 @@ getObjectDescription(const ObjectAddress *object)
                case OCLASS_TSTEMPLATE:
                        {
                                HeapTuple       tup;
+                               Form_pg_ts_template tmplForm;
+                               char       *nspname;
 
                                tup = SearchSysCache1(TSTEMPLATEOID,
                                                                          ObjectIdGetDatum(object->objectId));
                                if (!HeapTupleIsValid(tup))
                                        elog(ERROR, "cache lookup failed for text search template %u",
                                                 object->objectId);
+                               tmplForm = (Form_pg_ts_template) GETSTRUCT(tup);
+
+                               /* Qualify the name if not visible in search path */
+                               if (TSTemplateIsVisible(object->objectId))
+                                       nspname = NULL;
+                               else
+                                       nspname = get_namespace_name(tmplForm->tmplnamespace);
+
                                appendStringInfo(&buffer, _("text search template %s"),
-                                 NameStr(((Form_pg_ts_template) GETSTRUCT(tup))->tmplname));
+                                                                quote_qualified_identifier(nspname,
+                                                                                                                       NameStr(tmplForm->tmplname)));
                                ReleaseSysCache(tup);
                                break;
                        }
@@ -1962,14 +2015,25 @@ getObjectDescription(const ObjectAddress *object)
                case OCLASS_TSCONFIG:
                        {
                                HeapTuple       tup;
+                               Form_pg_ts_config cfgForm;
+                               char       *nspname;
 
                                tup = SearchSysCache1(TSCONFIGOID,
                                                                          ObjectIdGetDatum(object->objectId));
                                if (!HeapTupleIsValid(tup))
                                        elog(ERROR, "cache lookup failed for text search configuration %u",
                                                 object->objectId);
+                               cfgForm = (Form_pg_ts_config) GETSTRUCT(tup);
+
+                               /* Qualify the name if not visible in search path */
+                               if (TSConfigIsVisible(object->objectId))
+                                       nspname = NULL;
+                               else
+                                       nspname = get_namespace_name(cfgForm->cfgnamespace);
+
                                appendStringInfo(&buffer, _("text search configuration %s"),
-                                        NameStr(((Form_pg_ts_config) GETSTRUCT(tup))->cfgname));
+                                                                quote_qualified_identifier(nspname,
+                                                                                                                       NameStr(cfgForm->cfgname)));
                                ReleaseSysCache(tup);
                                break;
                        }

diff --git a/src/test/regress/expected/alter_generic.out b/src/test/regress/expected/alter_generic.out
index 1d7e52412fe3ad979d762de289362fc40e5f11cf..5dea339e0ca5689f84243d99dd5c07bb7be57f82 100644 (file)
--- a/src/test/regress/expected/alter_generic.out
+++ b/src/test/regress/expected/alter_generic.out
@@ -494,13 +494,13 @@ DROP SCHEMA alt_nsp2 CASCADE;
 NOTICE:  drop cascades to 9 other objects
 DETAIL:  drop cascades to function alt_nsp2.alt_func2(integer)
 drop cascades to function alt_nsp2.alt_agg2(integer)
-drop cascades to conversion alt_conv2
+drop cascades to conversion alt_nsp2.alt_conv2
 drop cascades to operator alt_nsp2.@-@(integer,integer)
 drop cascades to operator family alt_nsp2.alt_opf2 for access method hash
-drop cascades to text search dictionary alt_ts_dict2
-drop cascades to text search configuration alt_ts_conf2
-drop cascades to text search template alt_ts_temp2
-drop cascades to text search parser alt_ts_prs2
+drop cascades to text search dictionary alt_nsp2.alt_ts_dict2
+drop cascades to text search configuration alt_nsp2.alt_ts_conf2
+drop cascades to text search template alt_nsp2.alt_ts_temp2
+drop cascades to text search parser alt_nsp2.alt_ts_prs2
 DROP USER regtest_alter_user1;
 DROP USER regtest_alter_user2;
 DROP USER regtest_alter_user3;

diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out
index 56096f11af2fa6586ef6cfed12e3894715a4c1a5..9204bef671774ebde04eb43bd54442bf43c95493 100644 (file)
--- a/src/test/regress/expected/alter_table.out
+++ b/src/test/regress/expected/alter_table.out
@@ -2352,11 +2352,11 @@ drop cascades to operator family alter2.ctype_hash_ops for access method hash
 drop cascades to type alter2.ctype
 drop cascades to function alter2.same(alter2.ctype,alter2.ctype)
 drop cascades to operator alter2.=(alter2.ctype,alter2.ctype)
-drop cascades to conversion ascii_to_utf8
-drop cascades to text search parser prs
-drop cascades to text search configuration cfg
-drop cascades to text search template tmpl
-drop cascades to text search dictionary dict
+drop cascades to conversion alter2.ascii_to_utf8
+drop cascades to text search parser alter2.prs
+drop cascades to text search configuration alter2.cfg
+drop cascades to text search template alter2.tmpl
+drop cascades to text search dictionary alter2.dict
 --
 -- composite types
 --