From a524f50d0fc6fe6f2146ce708c2c9576d3734da4 Mon Sep 17 00:00:00 2001 From: Tomas Vondra Date: Wed, 16 Oct 2019 13:23:18 +0200 Subject: [PATCH] Improve the check for pg_catalog.unknown data type in pg_upgrade The pg_upgrade check for pg_catalog.unknown type when upgrading from 9.6 had a couple of issues with domains and composite types - it detected even composite types unused in objects with storage. So for example this was enough to trigger an unnecessary pg_upgrade failure: CREATE TYPE unknown_composite AS (u pg_catalog.unknown) On the other hand, this only happened with composite types directly on the pg_catalog.unknown data type, but not with a domain. So this was not detected CREATE DOMAIN unknown_domain AS pg_catalog.unknown; CREATE TYPE unknown_composite_2 AS (u unknown_domain); unlike the first example. These false positives and inconsistencies are unfortunate, but what's worse we've failed to detected objects using the pg_catalog.unknown type through a domain. So we missed cases like this CREATE TABLE t (u unknown_composite_2); The consequence is clusters broken after a pg_upgrade. This fixes these false positives and false negatives by using the same recursive CTE introduced by eaf900e842 for sql_identifier. Backpatch all the way to 10, where the of pg_catalog.unknown data type was restricted. Author: Tomas Vondra Backpatch-to: 10- Discussion: https://postgr.es/m/16045-673e8fa6b5ace196%40postgresql.org --- src/bin/pg_upgrade/version.c | 30 +++++++++++++++++++++++++++--- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/src/bin/pg_upgrade/version.c b/src/bin/pg_upgrade/version.c index be5f108f0a..b64171d275 100644 --- a/src/bin/pg_upgrade/version.c +++ b/src/bin/pg_upgrade/version.c @@ -229,7 +229,8 @@ old_9_3_check_for_line_data_type_usage(ClusterInfo *cluster) * mid-upgrade. Worse, if there's a matview with such a column, the * DDL reload will silently change it to "text" which won't match the * on-disk storage (which is like "cstring"). So we *must* reject that. - * Also check composite types, in case they are used for table columns. + * Also check composite types and domains on the "unknwown" type (even + * combinations of both), in case they are used for table columns. * We needn't check indexes, because "unknown" has no opclasses. */ void @@ -256,17 +257,40 @@ old_9_6_check_for_unknown_data_type_usage(ClusterInfo *cluster) DbInfo *active_db = &cluster->dbarr.dbs[dbnum]; PGconn *conn = connectToServer(cluster, active_db->db_name); + /* + * The pg_catalog.unknown type may be wrapped in a domain or composite + * type, or both (9.3 did not allow domains on composite types, but + * there may be multi-level composite type). To detect these cases + * we need a recursive CTE. + */ res = executeQueryOrDie(conn, + "WITH RECURSIVE oids AS ( " + /* the pg_catalog.unknown type itself */ + " SELECT 'pg_catalog.unknown'::pg_catalog.regtype AS oid " + " UNION ALL " + " SELECT * FROM ( " + /* domains on the type */ + " WITH x AS (SELECT oid FROM oids) " + " SELECT t.oid FROM pg_catalog.pg_type t, x WHERE typbasetype = x.oid AND typtype = 'd' " + " UNION " + /* composite types containing the type */ + " SELECT t.oid FROM pg_catalog.pg_type t, pg_catalog.pg_class c, pg_catalog.pg_attribute a, x " + " WHERE t.typtype = 'c' AND " + " t.oid = c.reltype AND " + " c.oid = a.attrelid AND " + " NOT a.attisdropped AND " + " a.atttypid = x.oid " + " ) foo " + ") " "SELECT n.nspname, c.relname, a.attname " "FROM pg_catalog.pg_class c, " " pg_catalog.pg_namespace n, " " pg_catalog.pg_attribute a " "WHERE c.oid = a.attrelid AND " " NOT a.attisdropped AND " - " a.atttypid = 'pg_catalog.unknown'::pg_catalog.regtype AND " + " a.atttypid IN (SELECT oid FROM oids) AND " " c.relkind IN (" CppAsString2(RELKIND_RELATION) ", " - CppAsString2(RELKIND_COMPOSITE_TYPE) ", " CppAsString2(RELKIND_MATVIEW) ") AND " " c.relnamespace = n.oid AND " /* exclude possible orphaned temp tables */